blob: 9dd37e2f5a84df84deb91554f85372966cf2e6d8 [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 */
Oliver Neukum61bf54b2007-02-08 09:04:48 +0100125 unsigned guess_capacity:1; /* READ_CAPACITY might be too high by 1 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 unsigned retry_hwerror:1; /* Retry HARDWARE_ERROR */
127
128 unsigned int device_blocked; /* Device returned QUEUE_FULL. */
129
130 unsigned int max_device_blocked; /* what device_blocked counts down from */
131#define SCSI_DEFAULT_DEVICE_BLOCKED 3
132
133 atomic_t iorequest_cnt;
134 atomic_t iodone_cnt;
135 atomic_t ioerr_cnt;
136
137 int timeout;
138
139 struct device sdev_gendev;
140 struct class_device sdev_classdev;
141
James Bottomleyffedb452006-02-23 14:27:18 -0600142 struct execute_work ew; /* used to get process context on put */
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 enum scsi_device_state sdev_state;
145 unsigned long sdev_data[0];
146} __attribute__((aligned(sizeof(unsigned long))));
147#define to_scsi_device(d) \
148 container_of(d, struct scsi_device, sdev_gendev)
149#define class_to_sdev(d) \
150 container_of(d, struct scsi_device, sdev_classdev)
151#define transport_class_to_sdev(class_dev) \
152 to_scsi_device(class_dev->dev)
153
James Bottomley9ccfc752005-10-02 11:45:08 -0500154#define sdev_printk(prefix, sdev, fmt, a...) \
155 dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a)
156
Jeff Garzik01d7b3b2005-10-24 18:03:34 -0400157#define scmd_printk(prefix, scmd, fmt, a...) \
158 dev_printk(prefix, &(scmd)->device->sdev_gendev, fmt, ##a)
159
James Bottomleyffedb452006-02-23 14:27:18 -0600160enum scsi_target_state {
161 STARGET_RUNNING = 1,
162 STARGET_DEL,
163};
164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165/*
166 * scsi_target: representation of a scsi target, for now, this is only
167 * used for single_lun devices. If no one has active IO to the target,
168 * starget_sdev_user is NULL, else it points to the active sdev.
169 */
170struct scsi_target {
171 struct scsi_device *starget_sdev_user;
172 struct list_head siblings;
173 struct list_head devices;
174 struct device dev;
175 unsigned int reap_ref; /* protected by the host lock */
176 unsigned int channel;
177 unsigned int id; /* target id ... replace
178 * scsi_device.id eventually */
Alan Stern1bfc5d92006-02-09 15:26:18 -0500179 unsigned int create:1; /* signal that it needs to be added */
180 unsigned int pdt_1f_for_no_lun; /* PDT = 0x1f */
181 /* means no lun present */
182
James Bottomley6f3a2022005-09-22 20:33:28 -0500183 char scsi_level;
James Bottomleyffedb452006-02-23 14:27:18 -0600184 struct execute_work ew;
185 enum scsi_target_state state;
James Bottomleya283bd32005-05-24 12:06:38 -0500186 void *hostdata; /* available to low-level driver */
187 unsigned long starget_data[0]; /* for the transport */
188 /* starget_data must be the last element!!!! */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189} __attribute__((aligned(sizeof(unsigned long))));
190
191#define to_scsi_target(d) container_of(d, struct scsi_target, dev)
192static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
193{
194 return to_scsi_target(sdev->sdev_gendev.parent);
195}
196#define transport_class_to_starget(class_dev) \
197 to_scsi_target(class_dev->dev)
198
James Bottomley9ccfc752005-10-02 11:45:08 -0500199#define starget_printk(prefix, starget, fmt, a...) \
200 dev_printk(prefix, &(starget)->dev, fmt, ##a)
201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202extern struct scsi_device *__scsi_add_device(struct Scsi_Host *,
203 uint, uint, uint, void *hostdata);
James Bottomley146f7262005-09-10 12:44:09 -0500204extern int scsi_add_device(struct Scsi_Host *host, uint channel,
205 uint target, uint lun);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206extern void scsi_remove_device(struct scsi_device *);
207extern int scsi_device_cancel(struct scsi_device *, int);
208
209extern int scsi_device_get(struct scsi_device *);
210extern void scsi_device_put(struct scsi_device *);
211extern struct scsi_device *scsi_device_lookup(struct Scsi_Host *,
212 uint, uint, uint);
213extern struct scsi_device *__scsi_device_lookup(struct Scsi_Host *,
214 uint, uint, uint);
215extern struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *,
216 uint);
217extern struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *,
218 uint);
219extern void starget_for_each_device(struct scsi_target *, void *,
220 void (*fn)(struct scsi_device *, void *));
221
222/* only exposed to implement shost_for_each_device */
223extern struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *,
224 struct scsi_device *);
225
226/**
Matthew Wilcox3e082a92006-09-28 15:19:20 -0600227 * shost_for_each_device - iterate over all devices of a host
228 * @sdev: the &struct scsi_device to use as a cursor
229 * @shost: the &struct scsi_host to iterate over
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 *
Matthew Wilcox3e082a92006-09-28 15:19:20 -0600231 * Iterator that returns each device attached to @shost. This loop
232 * takes a reference on each device and releases it at the end. If
233 * you break out of the loop, you must call scsi_device_put(sdev).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 */
235#define shost_for_each_device(sdev, shost) \
236 for ((sdev) = __scsi_iterate_devices((shost), NULL); \
237 (sdev); \
238 (sdev) = __scsi_iterate_devices((shost), (sdev)))
239
240/**
Matthew Wilcox3e082a92006-09-28 15:19:20 -0600241 * __shost_for_each_device - iterate over all devices of a host (UNLOCKED)
242 * @sdev: the &struct scsi_device to use as a cursor
243 * @shost: the &struct scsi_host to iterate over
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 *
Matthew Wilcox3e082a92006-09-28 15:19:20 -0600245 * Iterator that returns each device attached to @shost. It does _not_
246 * take a reference on the scsi_device, so the whole loop must be
247 * protected by shost->host_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 *
Matthew Wilcox3e082a92006-09-28 15:19:20 -0600249 * Note: The only reason to use this is because you need to access the
250 * device list in interrupt context. Otherwise you really want to use
251 * shost_for_each_device instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 */
253#define __shost_for_each_device(sdev, shost) \
254 list_for_each_entry((sdev), &((shost)->__devices), siblings)
255
256extern void scsi_adjust_queue_depth(struct scsi_device *, int, int);
257extern int scsi_track_queue_full(struct scsi_device *, int);
258
259extern int scsi_set_medium_removal(struct scsi_device *, char);
260
261extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
262 unsigned char *buffer, int len, int timeout,
James Bottomley1cf72692005-08-28 11:27:01 -0500263 int retries, struct scsi_mode_data *data,
James Bottomleyea73a9f2005-08-28 11:33:52 -0500264 struct scsi_sense_hdr *);
James Bottomley5baba832006-03-18 14:10:35 -0600265extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
266 int modepage, unsigned char *buffer, int len,
267 int timeout, int retries,
268 struct scsi_mode_data *data,
269 struct scsi_sense_hdr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
271 int retries);
272extern int scsi_device_set_state(struct scsi_device *sdev,
273 enum scsi_device_state state);
274extern int scsi_device_quiesce(struct scsi_device *sdev);
275extern void scsi_device_resume(struct scsi_device *sdev);
276extern void scsi_target_quiesce(struct scsi_target *);
277extern void scsi_target_resume(struct scsi_target *);
278extern void scsi_scan_target(struct device *parent, unsigned int channel,
279 unsigned int id, unsigned int lun, int rescan);
280extern void scsi_target_reap(struct scsi_target *);
281extern void scsi_target_block(struct device *);
282extern void scsi_target_unblock(struct device *);
283extern void scsi_remove_target(struct device *);
James.Smart@Emulex.Com2f4701d2005-07-13 22:05:03 -0400284extern void int_to_scsilun(unsigned int, struct scsi_lun *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285extern const char *scsi_device_state_name(enum scsi_device_state);
286extern int scsi_is_sdev_device(const struct device *);
287extern int scsi_is_target_device(const struct device *);
James Bottomley33aa6872005-08-28 11:31:14 -0500288extern int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
289 int data_direction, void *buffer, unsigned bufflen,
290 unsigned char *sense, int timeout, int retries,
291 int flag);
James Bottomleyea73a9f2005-08-28 11:33:52 -0500292extern int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd,
293 int data_direction, void *buffer, unsigned bufflen,
294 struct scsi_sense_hdr *, int timeout, int retries);
Mike Christie6e68af62005-11-11 05:30:27 -0600295extern int scsi_execute_async(struct scsi_device *sdev,
brking@us.ibm.combb1d1072006-01-23 15:03:22 -0600296 const unsigned char *cmd, int cmd_len, int data_direction,
Mike Christie6e68af62005-11-11 05:30:27 -0600297 void *buffer, unsigned bufflen, int use_sg,
298 int timeout, int retries, void *privdata,
299 void (*done)(void *, char *, int, int),
300 gfp_t gfp);
James Bottomley33aa6872005-08-28 11:31:14 -0500301
Andrew Mortoncb5d9e02006-09-30 21:23:44 -0400302static inline int __must_check scsi_device_reprobe(struct scsi_device *sdev)
James Bottomleye28482c2006-03-14 14:24:55 -0600303{
Andrew Mortoncb5d9e02006-09-30 21:23:44 -0400304 return device_reprobe(&sdev->sdev_gendev);
James Bottomleye28482c2006-03-14 14:24:55 -0600305}
306
Jeff Garzik01d7b3b2005-10-24 18:03:34 -0400307static inline unsigned int sdev_channel(struct scsi_device *sdev)
308{
309 return sdev->channel;
310}
311
312static inline unsigned int sdev_id(struct scsi_device *sdev)
313{
314 return sdev->id;
315}
316
317#define scmd_id(scmd) sdev_id((scmd)->device)
318#define scmd_channel(scmd) sdev_channel((scmd)->device)
319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320static inline int scsi_device_online(struct scsi_device *sdev)
321{
322 return sdev->sdev_state != SDEV_OFFLINE;
323}
324
325/* accessor functions for the SCSI parameters */
326static inline int scsi_device_sync(struct scsi_device *sdev)
327{
328 return sdev->sdtr;
329}
330static inline int scsi_device_wide(struct scsi_device *sdev)
331{
332 return sdev->wdtr;
333}
334static inline int scsi_device_dt(struct scsi_device *sdev)
335{
336 return sdev->ppr;
337}
338static inline int scsi_device_dt_only(struct scsi_device *sdev)
339{
340 if (sdev->inquiry_len < 57)
341 return 0;
342 return (sdev->inquiry[56] & 0x0c) == 0x04;
343}
344static inline int scsi_device_ius(struct scsi_device *sdev)
345{
346 if (sdev->inquiry_len < 57)
347 return 0;
348 return sdev->inquiry[56] & 0x01;
349}
350static inline int scsi_device_qas(struct scsi_device *sdev)
351{
352 if (sdev->inquiry_len < 57)
353 return 0;
354 return sdev->inquiry[56] & 0x02;
355}
356#endif /* _SCSI_SCSI_DEVICE_H */