blob: b401c82036be216edf1dadf0f1ce01c0b1301891 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _SCSI_SCSI_DEVICE_H
2#define _SCSI_SCSI_DEVICE_H
3
4#include <linux/device.h>
5#include <linux/list.h>
6#include <linux/spinlock.h>
James Bottomleyffedb452006-02-23 14:27:18 -06007#include <linux/workqueue.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <asm/atomic.h>
9
10struct request_queue;
11struct scsi_cmnd;
James Bottomleye10fb912005-07-14 11:54:17 -050012struct scsi_lun;
James Bottomleyea73a9f2005-08-28 11:33:52 -050013struct scsi_sense_hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070014
James Bottomley1cf72692005-08-28 11:27:01 -050015struct scsi_mode_data {
16 __u32 length;
17 __u16 block_descriptor_length;
18 __u8 medium_type;
19 __u8 device_specific;
20 __u8 header_length;
21 __u8 longlba:1;
22};
23
Linus Torvalds1da177e2005-04-16 15:20:36 -070024/*
25 * sdev state: If you alter this, you also need to alter scsi_sysfs.c
26 * (for the ascii descriptions) and the state model enforcer:
27 * scsi_lib:scsi_device_set_state().
28 */
29enum scsi_device_state {
30 SDEV_CREATED = 1, /* device created but not added to sysfs
31 * Only internal commands allowed (for inq) */
32 SDEV_RUNNING, /* device properly configured
33 * All commands allowed */
34 SDEV_CANCEL, /* beginning to delete device
35 * Only error handler commands allowed */
36 SDEV_DEL, /* device deleted
37 * no commands allowed */
38 SDEV_QUIESCE, /* Device quiescent. No block commands
39 * will be accepted, only specials (which
40 * originate in the mid-layer) */
41 SDEV_OFFLINE, /* Device offlined (by error handling or
42 * user request */
43 SDEV_BLOCK, /* Device blocked by scsi lld. No scsi
44 * commands from user or midlayer should be issued
45 * to the scsi lld. */
46};
47
48struct scsi_device {
49 struct Scsi_Host *host;
50 struct request_queue *request_queue;
51
52 /* the next two are protected by the host->host_lock */
53 struct list_head siblings; /* list of all devices on this host */
54 struct list_head same_target_siblings; /* just the devices sharing same target id */
55
c2a93312005-04-12 16:38:09 -050056 /* this is now protected by the request_queue->queue_lock */
06f81ea2005-04-17 14:57:29 -050057 unsigned int device_busy; /* commands actually active on
58 * low-level. protected by queue_lock. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 spinlock_t list_lock;
60 struct list_head cmd_list; /* queue of in use SCSI Command structures */
61 struct list_head starved_entry;
62 struct scsi_cmnd *current_cmnd; /* currently active command */
63 unsigned short queue_depth; /* How deep of a queue we want */
64 unsigned short last_queue_full_depth; /* These two are used by */
65 unsigned short last_queue_full_count; /* scsi_track_queue_full() */
66 unsigned long last_queue_full_time;/* don't let QUEUE_FULLs on the same
67 jiffie count on our counter, they
68 could all be from the same event. */
69
70 unsigned int id, lun, channel;
71
72 unsigned int manufacturer; /* Manufacturer of device, for using
73 * vendor-specific cmd's */
74 unsigned sector_size; /* size in bytes */
75
76 void *hostdata; /* available to low-level driver */
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 char type;
78 char scsi_level;
79 char inq_periph_qual; /* PQ from INQUIRY data */
80 unsigned char inquiry_len; /* valid bytes in 'inquiry' */
81 unsigned char * inquiry; /* INQUIRY response data */
James Bottomley7f23e142005-12-01 12:50:13 -060082 const char * vendor; /* [back_compat] point into 'inquiry' ... */
83 const char * model; /* ... after scan; point to static string */
84 const char * rev; /* ... "nullnullnullnull" before scan */
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 unsigned char current_tag; /* current tag */
86 struct scsi_target *sdev_target; /* used only for single_lun */
87
88 unsigned int sdev_bflags; /* black/white flags as also found in
89 * scsi_devinfo.[hc]. For now used only to
90 * pass settings from slave_alloc to scsi
91 * core. */
92 unsigned writeable:1;
93 unsigned removable:1;
94 unsigned changed:1; /* Data invalid due to media change */
95 unsigned busy:1; /* Used to prevent races */
96 unsigned lockable:1; /* Able to prevent media removal */
97 unsigned locked:1; /* Media removal disabled */
98 unsigned borken:1; /* Tell the Seagate driver to be
99 * painfully slow on this device */
100 unsigned disconnect:1; /* can disconnect */
101 unsigned soft_reset:1; /* Uses soft reset option */
102 unsigned sdtr:1; /* Device supports SDTR messages */
103 unsigned wdtr:1; /* Device supports WDTR messages */
104 unsigned ppr:1; /* Device supports PPR messages */
105 unsigned tagged_supported:1; /* Supports SCSI-II tagged queuing */
106 unsigned simple_tags:1; /* simple queue tag messages are enabled */
107 unsigned ordered_tags:1;/* ordered queue tag messages are enabled */
108 unsigned single_lun:1; /* Indicates we should only allow I/O to
109 * one of the luns for the device at a
110 * time. */
111 unsigned was_reset:1; /* There was a bus reset on the bus for
112 * this device */
113 unsigned expecting_cc_ua:1; /* Expecting a CHECK_CONDITION/UNIT_ATTN
114 * because we did a bus reset. */
115 unsigned use_10_for_rw:1; /* first try 10-byte read / write */
116 unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
117 unsigned skip_ms_page_8:1; /* do not use MODE SENSE page 0x08 */
118 unsigned skip_ms_page_3f:1; /* do not use MODE SENSE page 0x3f */
119 unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
120 unsigned no_start_on_add:1; /* do not issue start on add */
121 unsigned allow_restart:1; /* issue START_UNIT in error handler */
122 unsigned no_uld_attach:1; /* disable connecting to upper level drivers */
123 unsigned select_no_atn:1;
124 unsigned fix_capacity:1; /* READ_CAPACITY is too high by 1 */
125 unsigned retry_hwerror:1; /* Retry HARDWARE_ERROR */
126
127 unsigned int device_blocked; /* Device returned QUEUE_FULL. */
128
129 unsigned int max_device_blocked; /* what device_blocked counts down from */
130#define SCSI_DEFAULT_DEVICE_BLOCKED 3
131
132 atomic_t iorequest_cnt;
133 atomic_t iodone_cnt;
134 atomic_t ioerr_cnt;
135
136 int timeout;
137
138 struct device sdev_gendev;
139 struct class_device sdev_classdev;
140
James Bottomleyffedb452006-02-23 14:27:18 -0600141 struct execute_work ew; /* used to get process context on put */
142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 enum scsi_device_state sdev_state;
144 unsigned long sdev_data[0];
145} __attribute__((aligned(sizeof(unsigned long))));
146#define to_scsi_device(d) \
147 container_of(d, struct scsi_device, sdev_gendev)
148#define class_to_sdev(d) \
149 container_of(d, struct scsi_device, sdev_classdev)
150#define transport_class_to_sdev(class_dev) \
151 to_scsi_device(class_dev->dev)
152
James Bottomley9ccfc752005-10-02 11:45:08 -0500153#define sdev_printk(prefix, sdev, fmt, a...) \
154 dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a)
155
Jeff Garzik01d7b3b2005-10-24 18:03:34 -0400156#define scmd_printk(prefix, scmd, fmt, a...) \
157 dev_printk(prefix, &(scmd)->device->sdev_gendev, fmt, ##a)
158
James Bottomleyffedb452006-02-23 14:27:18 -0600159enum scsi_target_state {
160 STARGET_RUNNING = 1,
161 STARGET_DEL,
162};
163
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164/*
165 * scsi_target: representation of a scsi target, for now, this is only
166 * used for single_lun devices. If no one has active IO to the target,
167 * starget_sdev_user is NULL, else it points to the active sdev.
168 */
169struct scsi_target {
170 struct scsi_device *starget_sdev_user;
171 struct list_head siblings;
172 struct list_head devices;
173 struct device dev;
174 unsigned int reap_ref; /* protected by the host lock */
175 unsigned int channel;
176 unsigned int id; /* target id ... replace
177 * scsi_device.id eventually */
Alan Stern1bfc5d92006-02-09 15:26:18 -0500178 unsigned int create:1; /* signal that it needs to be added */
179 unsigned int pdt_1f_for_no_lun; /* PDT = 0x1f */
180 /* means no lun present */
181
James Bottomley6f3a2022005-09-22 20:33:28 -0500182 char scsi_level;
James Bottomleyffedb452006-02-23 14:27:18 -0600183 struct execute_work ew;
184 enum scsi_target_state state;
James Bottomleya283bd32005-05-24 12:06:38 -0500185 void *hostdata; /* available to low-level driver */
186 unsigned long starget_data[0]; /* for the transport */
187 /* starget_data must be the last element!!!! */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188} __attribute__((aligned(sizeof(unsigned long))));
189
190#define to_scsi_target(d) container_of(d, struct scsi_target, dev)
191static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
192{
193 return to_scsi_target(sdev->sdev_gendev.parent);
194}
195#define transport_class_to_starget(class_dev) \
196 to_scsi_target(class_dev->dev)
197
James Bottomley9ccfc752005-10-02 11:45:08 -0500198#define starget_printk(prefix, starget, fmt, a...) \
199 dev_printk(prefix, &(starget)->dev, fmt, ##a)
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201extern struct scsi_device *__scsi_add_device(struct Scsi_Host *,
202 uint, uint, uint, void *hostdata);
James Bottomley146f7262005-09-10 12:44:09 -0500203extern int scsi_add_device(struct Scsi_Host *host, uint channel,
204 uint target, uint lun);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205extern void scsi_remove_device(struct scsi_device *);
206extern int scsi_device_cancel(struct scsi_device *, int);
207
208extern int scsi_device_get(struct scsi_device *);
209extern void scsi_device_put(struct scsi_device *);
210extern struct scsi_device *scsi_device_lookup(struct Scsi_Host *,
211 uint, uint, uint);
212extern struct scsi_device *__scsi_device_lookup(struct Scsi_Host *,
213 uint, uint, uint);
214extern struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *,
215 uint);
216extern struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *,
217 uint);
218extern void starget_for_each_device(struct scsi_target *, void *,
219 void (*fn)(struct scsi_device *, void *));
220
221/* only exposed to implement shost_for_each_device */
222extern struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *,
223 struct scsi_device *);
224
225/**
226 * shost_for_each_device - iterate over all devices of a host
227 * @sdev: iterator
228 * @host: host whiches devices we want to iterate over
229 *
230 * This traverses over each devices of @shost. The devices have
231 * a reference that must be released by scsi_host_put when breaking
232 * out of the loop.
233 */
234#define shost_for_each_device(sdev, shost) \
235 for ((sdev) = __scsi_iterate_devices((shost), NULL); \
236 (sdev); \
237 (sdev) = __scsi_iterate_devices((shost), (sdev)))
238
239/**
240 * __shost_for_each_device - iterate over all devices of a host (UNLOCKED)
241 * @sdev: iterator
242 * @host: host whiches devices we want to iterate over
243 *
244 * This traverses over each devices of @shost. It does _not_ take a
245 * reference on the scsi_device, thus it the whole loop must be protected
246 * by shost->host_lock.
247 *
248 * Note: The only reason why drivers would want to use this is because
249 * they're need to access the device list in irq context. Otherwise you
250 * really want to use shost_for_each_device instead.
251 */
252#define __shost_for_each_device(sdev, shost) \
253 list_for_each_entry((sdev), &((shost)->__devices), siblings)
254
255extern void scsi_adjust_queue_depth(struct scsi_device *, int, int);
256extern int scsi_track_queue_full(struct scsi_device *, int);
257
258extern int scsi_set_medium_removal(struct scsi_device *, char);
259
260extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
261 unsigned char *buffer, int len, int timeout,
James Bottomley1cf72692005-08-28 11:27:01 -0500262 int retries, struct scsi_mode_data *data,
James Bottomleyea73a9f2005-08-28 11:33:52 -0500263 struct scsi_sense_hdr *);
James Bottomley5baba832006-03-18 14:10:35 -0600264extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
265 int modepage, unsigned char *buffer, int len,
266 int timeout, int retries,
267 struct scsi_mode_data *data,
268 struct scsi_sense_hdr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
270 int retries);
271extern int scsi_device_set_state(struct scsi_device *sdev,
272 enum scsi_device_state state);
273extern int scsi_device_quiesce(struct scsi_device *sdev);
274extern void scsi_device_resume(struct scsi_device *sdev);
275extern void scsi_target_quiesce(struct scsi_target *);
276extern void scsi_target_resume(struct scsi_target *);
277extern void scsi_scan_target(struct device *parent, unsigned int channel,
278 unsigned int id, unsigned int lun, int rescan);
279extern void scsi_target_reap(struct scsi_target *);
280extern void scsi_target_block(struct device *);
281extern void scsi_target_unblock(struct device *);
282extern void scsi_remove_target(struct device *);
James.Smart@Emulex.Com2f4701d2005-07-13 22:05:03 -0400283extern void int_to_scsilun(unsigned int, struct scsi_lun *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284extern const char *scsi_device_state_name(enum scsi_device_state);
285extern int scsi_is_sdev_device(const struct device *);
286extern int scsi_is_target_device(const struct device *);
James Bottomley33aa6872005-08-28 11:31:14 -0500287extern int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
288 int data_direction, void *buffer, unsigned bufflen,
289 unsigned char *sense, int timeout, int retries,
290 int flag);
James Bottomleyea73a9f2005-08-28 11:33:52 -0500291extern int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd,
292 int data_direction, void *buffer, unsigned bufflen,
293 struct scsi_sense_hdr *, int timeout, int retries);
Mike Christie6e68af62005-11-11 05:30:27 -0600294extern int scsi_execute_async(struct scsi_device *sdev,
brking@us.ibm.combb1d1072006-01-23 15:03:22 -0600295 const unsigned char *cmd, int cmd_len, int data_direction,
Mike Christie6e68af62005-11-11 05:30:27 -0600296 void *buffer, unsigned bufflen, int use_sg,
297 int timeout, int retries, void *privdata,
298 void (*done)(void *, char *, int, int),
299 gfp_t gfp);
James Bottomley33aa6872005-08-28 11:31:14 -0500300
Andrew Mortoncb5d9e02006-09-30 21:23:44 -0400301static inline int __must_check scsi_device_reprobe(struct scsi_device *sdev)
James Bottomleye28482c2006-03-14 14:24:55 -0600302{
Andrew Mortoncb5d9e02006-09-30 21:23:44 -0400303 return device_reprobe(&sdev->sdev_gendev);
James Bottomleye28482c2006-03-14 14:24:55 -0600304}
305
Jeff Garzik01d7b3b2005-10-24 18:03:34 -0400306static inline unsigned int sdev_channel(struct scsi_device *sdev)
307{
308 return sdev->channel;
309}
310
311static inline unsigned int sdev_id(struct scsi_device *sdev)
312{
313 return sdev->id;
314}
315
316#define scmd_id(scmd) sdev_id((scmd)->device)
317#define scmd_channel(scmd) sdev_channel((scmd)->device)
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319static inline int scsi_device_online(struct scsi_device *sdev)
320{
321 return sdev->sdev_state != SDEV_OFFLINE;
322}
323
324/* accessor functions for the SCSI parameters */
325static inline int scsi_device_sync(struct scsi_device *sdev)
326{
327 return sdev->sdtr;
328}
329static inline int scsi_device_wide(struct scsi_device *sdev)
330{
331 return sdev->wdtr;
332}
333static inline int scsi_device_dt(struct scsi_device *sdev)
334{
335 return sdev->ppr;
336}
337static inline int scsi_device_dt_only(struct scsi_device *sdev)
338{
339 if (sdev->inquiry_len < 57)
340 return 0;
341 return (sdev->inquiry[56] & 0x0c) == 0x04;
342}
343static inline int scsi_device_ius(struct scsi_device *sdev)
344{
345 if (sdev->inquiry_len < 57)
346 return 0;
347 return sdev->inquiry[56] & 0x01;
348}
349static inline int scsi_device_qas(struct scsi_device *sdev)
350{
351 if (sdev->inquiry_len < 57)
352 return 0;
353 return sdev->inquiry[56] & 0x02;
354}
355#endif /* _SCSI_SCSI_DEVICE_H */