Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef _SCSI_SCSI_DEVICE_H |
| 2 | #define _SCSI_SCSI_DEVICE_H |
| 3 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | #include <linux/list.h> |
| 5 | #include <linux/spinlock.h> |
James Bottomley | ffedb45 | 2006-02-23 14:27:18 -0600 | [diff] [blame] | 6 | #include <linux/workqueue.h> |
Martin K. Petersen | a4d04a4 | 2007-02-27 22:40:27 -0500 | [diff] [blame] | 7 | #include <linux/blkdev.h> |
Hugh Dickins | d211f05 | 2008-08-06 18:21:18 +0100 | [diff] [blame] | 8 | #include <scsi/scsi.h> |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 9 | #include <linux/atomic.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | |
Paul Gortmaker | 313162d | 2012-01-30 11:46:54 -0500 | [diff] [blame] | 11 | struct device; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | struct request_queue; |
| 13 | struct scsi_cmnd; |
James Bottomley | e10fb91 | 2005-07-14 11:54:17 -0500 | [diff] [blame] | 14 | struct scsi_lun; |
James Bottomley | ea73a9f | 2005-08-28 11:33:52 -0500 | [diff] [blame] | 15 | struct scsi_sense_hdr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | |
James Bottomley | 1cf7269 | 2005-08-28 11:27:01 -0500 | [diff] [blame] | 17 | struct scsi_mode_data { |
| 18 | __u32 length; |
| 19 | __u16 block_descriptor_length; |
| 20 | __u8 medium_type; |
| 21 | __u8 device_specific; |
| 22 | __u8 header_length; |
| 23 | __u8 longlba:1; |
| 24 | }; |
| 25 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | /* |
| 27 | * sdev state: If you alter this, you also need to alter scsi_sysfs.c |
| 28 | * (for the ascii descriptions) and the state model enforcer: |
| 29 | * scsi_lib:scsi_device_set_state(). |
| 30 | */ |
| 31 | enum scsi_device_state { |
| 32 | SDEV_CREATED = 1, /* device created but not added to sysfs |
| 33 | * Only internal commands allowed (for inq) */ |
| 34 | SDEV_RUNNING, /* device properly configured |
| 35 | * All commands allowed */ |
| 36 | SDEV_CANCEL, /* beginning to delete device |
| 37 | * Only error handler commands allowed */ |
| 38 | SDEV_DEL, /* device deleted |
| 39 | * no commands allowed */ |
| 40 | SDEV_QUIESCE, /* Device quiescent. No block commands |
| 41 | * will be accepted, only specials (which |
| 42 | * originate in the mid-layer) */ |
| 43 | SDEV_OFFLINE, /* Device offlined (by error handling or |
| 44 | * user request */ |
Mike Christie | 1b8d262 | 2012-05-17 23:56:56 -0500 | [diff] [blame] | 45 | SDEV_TRANSPORT_OFFLINE, /* Offlined by transport class error handler */ |
James Bottomley | 6f4267e | 2008-08-22 16:53:31 -0500 | [diff] [blame] | 46 | SDEV_BLOCK, /* Device blocked by scsi lld. No |
| 47 | * scsi commands from user or midlayer |
| 48 | * should be issued to the scsi |
| 49 | * lld. */ |
| 50 | SDEV_CREATED_BLOCK, /* same as above but for created devices */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | }; |
| 52 | |
Jeff Garzik | a341cd0 | 2007-10-29 17:15:22 -0400 | [diff] [blame] | 53 | enum scsi_device_event { |
| 54 | SDEV_EVT_MEDIA_CHANGE = 1, /* media has changed */ |
Ewan D. Milne | 279afdf | 2013-08-08 15:07:48 -0400 | [diff] [blame] | 55 | SDEV_EVT_INQUIRY_CHANGE_REPORTED, /* 3F 03 UA reported */ |
| 56 | SDEV_EVT_CAPACITY_CHANGE_REPORTED, /* 2A 09 UA reported */ |
| 57 | SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED, /* 38 07 UA reported */ |
| 58 | SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED, /* 2A 01 UA reported */ |
| 59 | SDEV_EVT_LUN_CHANGE_REPORTED, /* 3F 0E UA reported */ |
Hannes Reinecke | 14c3e67 | 2015-07-06 13:41:53 +0200 | [diff] [blame] | 60 | SDEV_EVT_ALUA_STATE_CHANGE_REPORTED, /* 2A 06 UA reported */ |
Jeff Garzik | a341cd0 | 2007-10-29 17:15:22 -0400 | [diff] [blame] | 61 | |
Ewan D. Milne | 279afdf | 2013-08-08 15:07:48 -0400 | [diff] [blame] | 62 | SDEV_EVT_FIRST = SDEV_EVT_MEDIA_CHANGE, |
Hannes Reinecke | 14c3e67 | 2015-07-06 13:41:53 +0200 | [diff] [blame] | 63 | SDEV_EVT_LAST = SDEV_EVT_ALUA_STATE_CHANGE_REPORTED, |
Ewan D. Milne | 279afdf | 2013-08-08 15:07:48 -0400 | [diff] [blame] | 64 | |
Jeff Garzik | a341cd0 | 2007-10-29 17:15:22 -0400 | [diff] [blame] | 65 | SDEV_EVT_MAXBITS = SDEV_EVT_LAST + 1 |
| 66 | }; |
| 67 | |
| 68 | struct scsi_event { |
| 69 | enum scsi_device_event evt_type; |
| 70 | struct list_head node; |
| 71 | |
| 72 | /* put union of data structures, for non-simple event types, |
| 73 | * here |
| 74 | */ |
| 75 | }; |
| 76 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | struct scsi_device { |
| 78 | struct Scsi_Host *host; |
| 79 | struct request_queue *request_queue; |
| 80 | |
| 81 | /* the next two are protected by the host->host_lock */ |
| 82 | struct list_head siblings; /* list of all devices on this host */ |
| 83 | struct list_head same_target_siblings; /* just the devices sharing same target id */ |
| 84 | |
Christoph Hellwig | 71e75c9 | 2014-04-11 19:07:01 +0200 | [diff] [blame] | 85 | atomic_t device_busy; /* commands actually active on LLDD */ |
Christoph Hellwig | cd9070c | 2014-01-23 12:07:41 +0100 | [diff] [blame] | 86 | atomic_t device_blocked; /* Device returned QUEUE_FULL. */ |
| 87 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | spinlock_t list_lock; |
| 89 | struct list_head cmd_list; /* queue of in use SCSI Command structures */ |
| 90 | struct list_head starved_entry; |
| 91 | struct scsi_cmnd *current_cmnd; /* currently active command */ |
| 92 | unsigned short queue_depth; /* How deep of a queue we want */ |
Vasu Dev | 4a84067 | 2009-10-22 15:46:33 -0700 | [diff] [blame] | 93 | unsigned short max_queue_depth; /* max queue depth */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | unsigned short last_queue_full_depth; /* These two are used by */ |
| 95 | unsigned short last_queue_full_count; /* scsi_track_queue_full() */ |
Vasu Dev | 4a84067 | 2009-10-22 15:46:33 -0700 | [diff] [blame] | 96 | unsigned long last_queue_full_time; /* last queue full time */ |
| 97 | unsigned long queue_ramp_up_period; /* ramp up period in jiffies */ |
| 98 | #define SCSI_DEFAULT_RAMP_UP_PERIOD (120 * HZ) |
| 99 | |
| 100 | unsigned long last_queue_ramp_up; /* last queue ramp up time */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | |
Hannes Reinecke | 9cb78c1 | 2014-06-25 15:27:36 +0200 | [diff] [blame] | 102 | unsigned int id, channel; |
| 103 | u64 lun; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | unsigned int manufacturer; /* Manufacturer of device, for using |
| 105 | * vendor-specific cmd's */ |
| 106 | unsigned sector_size; /* size in bytes */ |
| 107 | |
| 108 | void *hostdata; /* available to low-level driver */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | char type; |
| 110 | char scsi_level; |
| 111 | char inq_periph_qual; /* PQ from INQUIRY data */ |
| 112 | unsigned char inquiry_len; /* valid bytes in 'inquiry' */ |
| 113 | unsigned char * inquiry; /* INQUIRY response data */ |
James Bottomley | 7f23e14 | 2005-12-01 12:50:13 -0600 | [diff] [blame] | 114 | const char * vendor; /* [back_compat] point into 'inquiry' ... */ |
| 115 | const char * model; /* ... after scan; point to static string */ |
| 116 | const char * rev; /* ... "nullnullnullnull" before scan */ |
Hannes Reinecke | b3ae878 | 2014-03-15 09:51:49 +0100 | [diff] [blame] | 117 | |
| 118 | #define SCSI_VPD_PG_LEN 255 |
| 119 | int vpd_pg83_len; |
| 120 | unsigned char *vpd_pg83; |
| 121 | int vpd_pg80_len; |
| 122 | unsigned char *vpd_pg80; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | unsigned char current_tag; /* current tag */ |
| 124 | struct scsi_target *sdev_target; /* used only for single_lun */ |
| 125 | |
| 126 | unsigned int sdev_bflags; /* black/white flags as also found in |
| 127 | * scsi_devinfo.[hc]. For now used only to |
| 128 | * pass settings from slave_alloc to scsi |
| 129 | * core. */ |
Martin K. Petersen | 0816c92 | 2013-05-10 10:36:04 -0400 | [diff] [blame] | 130 | unsigned int eh_timeout; /* Error handling timeout */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | unsigned removable:1; |
| 132 | unsigned changed:1; /* Data invalid due to media change */ |
| 133 | unsigned busy:1; /* Used to prevent races */ |
| 134 | unsigned lockable:1; /* Able to prevent media removal */ |
| 135 | unsigned locked:1; /* Media removal disabled */ |
| 136 | unsigned borken:1; /* Tell the Seagate driver to be |
| 137 | * painfully slow on this device */ |
| 138 | unsigned disconnect:1; /* can disconnect */ |
| 139 | unsigned soft_reset:1; /* Uses soft reset option */ |
| 140 | unsigned sdtr:1; /* Device supports SDTR messages */ |
| 141 | unsigned wdtr:1; /* Device supports WDTR messages */ |
| 142 | unsigned ppr:1; /* Device supports PPR messages */ |
| 143 | unsigned tagged_supported:1; /* Supports SCSI-II tagged queuing */ |
| 144 | unsigned simple_tags:1; /* simple queue tag messages are enabled */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | unsigned was_reset:1; /* There was a bus reset on the bus for |
| 146 | * this device */ |
| 147 | unsigned expecting_cc_ua:1; /* Expecting a CHECK_CONDITION/UNIT_ATTN |
| 148 | * because we did a bus reset. */ |
| 149 | unsigned use_10_for_rw:1; /* first try 10-byte read / write */ |
| 150 | unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */ |
Martin K. Petersen | 3c6bdae | 2012-09-18 12:19:30 -0400 | [diff] [blame] | 151 | unsigned no_report_opcodes:1; /* no REPORT SUPPORTED OPERATION CODES */ |
Martin K. Petersen | 5db4486 | 2012-09-18 12:19:32 -0400 | [diff] [blame] | 152 | unsigned no_write_same:1; /* no WRITE SAME command */ |
Jason J. Herne | 53ad570 | 2012-11-14 17:03:22 -0500 | [diff] [blame] | 153 | unsigned use_16_for_rw:1; /* Use read/write(16) over read/write(10) */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | unsigned skip_ms_page_8:1; /* do not use MODE SENSE page 0x08 */ |
| 155 | unsigned skip_ms_page_3f:1; /* do not use MODE SENSE page 0x3f */ |
Alan Stern | 09b6b51 | 2012-01-10 13:43:30 -0500 | [diff] [blame] | 156 | unsigned skip_vpd_pages:1; /* do not read VPD pages */ |
Martin K. Petersen | c1d40a5 | 2014-07-15 12:49:17 -0400 | [diff] [blame] | 157 | unsigned try_vpd_pages:1; /* attempt to read VPD pages */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */ |
| 159 | unsigned no_start_on_add:1; /* do not issue start on add */ |
| 160 | unsigned allow_restart:1; /* issue START_UNIT in error handler */ |
Tejun Heo | c3c94c5 | 2007-03-21 00:13:59 +0900 | [diff] [blame] | 161 | unsigned manage_start_stop:1; /* Let HLD (sd) manage start/stop */ |
Stefan Richter | d2886ea | 2008-05-11 00:34:07 +0200 | [diff] [blame] | 162 | unsigned start_stop_pwr_cond:1; /* Set power cond. in START_STOP_UNIT */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | unsigned no_uld_attach:1; /* disable connecting to upper level drivers */ |
| 164 | unsigned select_no_atn:1; |
| 165 | unsigned fix_capacity:1; /* READ_CAPACITY is too high by 1 */ |
Oliver Neukum | 61bf54b | 2007-02-08 09:04:48 +0100 | [diff] [blame] | 166 | unsigned guess_capacity:1; /* READ_CAPACITY might be too high by 1 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | unsigned retry_hwerror:1; /* Retry HARDWARE_ERROR */ |
Linus Torvalds | 1835107 | 2008-08-05 21:42:21 -0700 | [diff] [blame] | 168 | unsigned last_sector_bug:1; /* do not use multisector accesses on |
| 169 | SD_LAST_BUGGY_SECTORS */ |
Hans de Goede | 8e04d80 | 2010-10-01 14:20:08 -0700 | [diff] [blame] | 170 | unsigned no_read_disc_info:1; /* Avoid READ_DISC_INFO cmds */ |
Hans de Goede | 5ce524b | 2010-10-01 14:20:10 -0700 | [diff] [blame] | 171 | unsigned no_read_capacity_16:1; /* Avoid READ_CAPACITY_16 cmds */ |
Alan Stern | 6a0bdff | 2012-06-20 16:04:19 -0400 | [diff] [blame] | 172 | unsigned try_rc_10_first:1; /* Try READ_CAPACACITY_10 first */ |
James Bottomley | 860dc73 | 2009-11-19 17:48:29 -0500 | [diff] [blame] | 173 | unsigned is_visible:1; /* is the device visible in sysfs */ |
Namjae Jeon | b81478d | 2012-07-07 23:05:08 -0400 | [diff] [blame] | 174 | unsigned wce_default_on:1; /* Cache is ON by default */ |
Martin K. Petersen | d974e42 | 2012-08-28 14:29:35 -0400 | [diff] [blame] | 175 | unsigned no_dif:1; /* T10 PI (DIF) should be disabled */ |
Alan Stern | b14bf2d | 2014-06-30 11:04:21 -0400 | [diff] [blame] | 176 | unsigned broken_fua:1; /* Don't set FUA bit */ |
Alan Stern | 50c4e96 | 2014-09-02 11:35:50 -0400 | [diff] [blame] | 177 | unsigned lun_in_cdb:1; /* Store LUN bits in CDB[1] */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | |
Aaron Lu | 6f4c827 | 2013-01-23 15:09:32 +0800 | [diff] [blame] | 179 | atomic_t disk_events_disable_depth; /* disable depth for disk events */ |
| 180 | |
Jeff Garzik | a341cd0 | 2007-10-29 17:15:22 -0400 | [diff] [blame] | 181 | DECLARE_BITMAP(supported_events, SDEV_EVT_MAXBITS); /* supported events */ |
Ewan D. Milne | 279afdf | 2013-08-08 15:07:48 -0400 | [diff] [blame] | 182 | DECLARE_BITMAP(pending_events, SDEV_EVT_MAXBITS); /* pending events */ |
Jeff Garzik | a341cd0 | 2007-10-29 17:15:22 -0400 | [diff] [blame] | 183 | struct list_head event_list; /* asserted events */ |
| 184 | struct work_struct event_work; |
| 185 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | unsigned int max_device_blocked; /* what device_blocked counts down from */ |
| 187 | #define SCSI_DEFAULT_DEVICE_BLOCKED 3 |
| 188 | |
| 189 | atomic_t iorequest_cnt; |
| 190 | atomic_t iodone_cnt; |
| 191 | atomic_t ioerr_cnt; |
| 192 | |
Tony Jones | ee959b0 | 2008-02-22 00:13:36 +0100 | [diff] [blame] | 193 | struct device sdev_gendev, |
| 194 | sdev_dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | |
James Bottomley | ffedb45 | 2006-02-23 14:27:18 -0600 | [diff] [blame] | 196 | struct execute_work ew; /* used to get process context on put */ |
Jens Axboe | 9937a5e | 2011-05-17 11:04:44 +0200 | [diff] [blame] | 197 | struct work_struct requeue_work; |
James Bottomley | ffedb45 | 2006-02-23 14:27:18 -0600 | [diff] [blame] | 198 | |
Christoph Hellwig | ee14c67 | 2015-08-27 14:16:59 +0200 | [diff] [blame] | 199 | struct scsi_device_handler *handler; |
| 200 | void *handler_data; |
| 201 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | enum scsi_device_state sdev_state; |
| 203 | unsigned long sdev_data[0]; |
| 204 | } __attribute__((aligned(sizeof(unsigned long)))); |
Chandra Seetharaman | a6a8d9f | 2008-05-01 14:49:46 -0700 | [diff] [blame] | 205 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | #define to_scsi_device(d) \ |
| 207 | container_of(d, struct scsi_device, sdev_gendev) |
| 208 | #define class_to_sdev(d) \ |
Tony Jones | ee959b0 | 2008-02-22 00:13:36 +0100 | [diff] [blame] | 209 | container_of(d, struct scsi_device, sdev_dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | #define transport_class_to_sdev(class_dev) \ |
Tony Jones | ee959b0 | 2008-02-22 00:13:36 +0100 | [diff] [blame] | 211 | to_scsi_device(class_dev->parent) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | |
Dan Williams | 3af74a3 | 2014-02-06 12:23:07 -0800 | [diff] [blame] | 213 | #define sdev_dbg(sdev, fmt, a...) \ |
| 214 | dev_dbg(&(sdev)->sdev_gendev, fmt, ##a) |
| 215 | |
Hannes Reinecke | 22e0d99 | 2014-10-24 14:26:44 +0200 | [diff] [blame] | 216 | /* |
| 217 | * like scmd_printk, but the device name is passed in |
| 218 | * as a string pointer |
| 219 | */ |
Hannes Reinecke | 9c4a6b1 | 2015-02-04 08:11:34 +0100 | [diff] [blame] | 220 | __printf(4, 5) void |
Christoph Hellwig | 6a806cb | 2015-01-18 16:11:29 +0100 | [diff] [blame] | 221 | sdev_prefix_printk(const char *, const struct scsi_device *, const char *, |
| 222 | const char *, ...); |
Hannes Reinecke | 22e0d99 | 2014-10-24 14:26:44 +0200 | [diff] [blame] | 223 | |
Hannes Reinecke | ded85c1 | 2015-01-08 07:43:42 +0100 | [diff] [blame] | 224 | #define sdev_printk(l, sdev, fmt, a...) \ |
| 225 | sdev_prefix_printk(l, sdev, NULL, fmt, ##a) |
| 226 | |
Hannes Reinecke | 9c4a6b1 | 2015-02-04 08:11:34 +0100 | [diff] [blame] | 227 | __printf(3, 4) void |
Christoph Hellwig | 6a806cb | 2015-01-18 16:11:29 +0100 | [diff] [blame] | 228 | scmd_printk(const char *, const struct scsi_cmnd *, const char *, ...); |
Jeff Garzik | 01d7b3b | 2005-10-24 18:03:34 -0400 | [diff] [blame] | 229 | |
Dan Williams | 3af74a3 | 2014-02-06 12:23:07 -0800 | [diff] [blame] | 230 | #define scmd_dbg(scmd, fmt, a...) \ |
| 231 | do { \ |
| 232 | if ((scmd)->request->rq_disk) \ |
| 233 | sdev_dbg((scmd)->device, "[%s] " fmt, \ |
| 234 | (scmd)->request->rq_disk->disk_name, ##a);\ |
| 235 | else \ |
| 236 | sdev_dbg((scmd)->device, fmt, ##a); \ |
| 237 | } while (0) |
| 238 | |
James Bottomley | ffedb45 | 2006-02-23 14:27:18 -0600 | [diff] [blame] | 239 | enum scsi_target_state { |
James Bottomley | 643eb2d | 2008-03-22 22:42:27 -0500 | [diff] [blame] | 240 | STARGET_CREATED = 1, |
| 241 | STARGET_RUNNING, |
James Bottomley | ffedb45 | 2006-02-23 14:27:18 -0600 | [diff] [blame] | 242 | STARGET_DEL, |
| 243 | }; |
| 244 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | /* |
| 246 | * scsi_target: representation of a scsi target, for now, this is only |
| 247 | * used for single_lun devices. If no one has active IO to the target, |
| 248 | * starget_sdev_user is NULL, else it points to the active sdev. |
| 249 | */ |
| 250 | struct scsi_target { |
| 251 | struct scsi_device *starget_sdev_user; |
| 252 | struct list_head siblings; |
| 253 | struct list_head devices; |
| 254 | struct device dev; |
James Bottomley | e63ed0d | 2014-01-21 07:00:50 -0800 | [diff] [blame] | 255 | struct kref reap_ref; /* last put renders target invisible */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | unsigned int channel; |
| 257 | unsigned int id; /* target id ... replace |
| 258 | * scsi_device.id eventually */ |
Alan Stern | 1bfc5d9 | 2006-02-09 15:26:18 -0500 | [diff] [blame] | 259 | unsigned int create:1; /* signal that it needs to be added */ |
Tony Battersby | 25d7c36 | 2007-11-12 10:00:44 -0500 | [diff] [blame] | 260 | unsigned int single_lun:1; /* Indicates we should only |
| 261 | * allow I/O to one of the luns |
| 262 | * for the device at a time. */ |
Alan Stern | de8c46b | 2012-01-10 13:43:04 -0500 | [diff] [blame] | 263 | unsigned int pdt_1f_for_no_lun:1; /* PDT = 0x1f |
| 264 | * means no lun present. */ |
Alan Stern | 09b6b51 | 2012-01-10 13:43:30 -0500 | [diff] [blame] | 265 | unsigned int no_report_luns:1; /* Don't use |
| 266 | * REPORT LUNS for scanning. */ |
Ewan D. Milne | 279afdf | 2013-08-08 15:07:48 -0400 | [diff] [blame] | 267 | unsigned int expecting_lun_change:1; /* A device has reported |
| 268 | * a 3F/0E UA, other devices on |
| 269 | * the same target will also. */ |
Christoph Hellwig | 7ae65c0 | 2014-01-22 14:49:41 +0100 | [diff] [blame] | 270 | /* commands actually active on LLD. */ |
| 271 | atomic_t target_busy; |
Christoph Hellwig | cd9070c | 2014-01-23 12:07:41 +0100 | [diff] [blame] | 272 | atomic_t target_blocked; |
| 273 | |
Mike Christie | f0c0a37 | 2008-08-17 15:24:38 -0500 | [diff] [blame] | 274 | /* |
| 275 | * LLDs should set this in the slave_alloc host template callout. |
| 276 | * If set to zero then there is not limit. |
| 277 | */ |
| 278 | unsigned int can_queue; |
Mike Christie | f0c0a37 | 2008-08-17 15:24:38 -0500 | [diff] [blame] | 279 | unsigned int max_target_blocked; |
| 280 | #define SCSI_DEFAULT_TARGET_BLOCKED 3 |
Alan Stern | 1bfc5d9 | 2006-02-09 15:26:18 -0500 | [diff] [blame] | 281 | |
James Bottomley | 6f3a202 | 2005-09-22 20:33:28 -0500 | [diff] [blame] | 282 | char scsi_level; |
James Bottomley | ffedb45 | 2006-02-23 14:27:18 -0600 | [diff] [blame] | 283 | enum scsi_target_state state; |
James Bottomley | a283bd3 | 2005-05-24 12:06:38 -0500 | [diff] [blame] | 284 | void *hostdata; /* available to low-level driver */ |
| 285 | unsigned long starget_data[0]; /* for the transport */ |
| 286 | /* starget_data must be the last element!!!! */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 287 | } __attribute__((aligned(sizeof(unsigned long)))); |
| 288 | |
| 289 | #define to_scsi_target(d) container_of(d, struct scsi_target, dev) |
| 290 | static inline struct scsi_target *scsi_target(struct scsi_device *sdev) |
| 291 | { |
| 292 | return to_scsi_target(sdev->sdev_gendev.parent); |
| 293 | } |
| 294 | #define transport_class_to_starget(class_dev) \ |
Tony Jones | ee959b0 | 2008-02-22 00:13:36 +0100 | [diff] [blame] | 295 | to_scsi_target(class_dev->parent) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | |
James Bottomley | 9ccfc75 | 2005-10-02 11:45:08 -0500 | [diff] [blame] | 297 | #define starget_printk(prefix, starget, fmt, a...) \ |
| 298 | dev_printk(prefix, &(starget)->dev, fmt, ##a) |
| 299 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | extern struct scsi_device *__scsi_add_device(struct Scsi_Host *, |
Hannes Reinecke | 9cb78c1 | 2014-06-25 15:27:36 +0200 | [diff] [blame] | 301 | uint, uint, u64, void *hostdata); |
James Bottomley | 146f726 | 2005-09-10 12:44:09 -0500 | [diff] [blame] | 302 | extern int scsi_add_device(struct Scsi_Host *host, uint channel, |
Hannes Reinecke | 9cb78c1 | 2014-06-25 15:27:36 +0200 | [diff] [blame] | 303 | uint target, u64 lun); |
Chandra Seetharaman | a6a8d9f | 2008-05-01 14:49:46 -0700 | [diff] [blame] | 304 | extern int scsi_register_device_handler(struct scsi_device_handler *scsi_dh); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 305 | extern void scsi_remove_device(struct scsi_device *); |
Chandra Seetharaman | a6a8d9f | 2008-05-01 14:49:46 -0700 | [diff] [blame] | 306 | extern int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh); |
Hannes Reinecke | b3ae878 | 2014-03-15 09:51:49 +0100 | [diff] [blame] | 307 | void scsi_attach_vpd(struct scsi_device *sdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | |
| 309 | extern int scsi_device_get(struct scsi_device *); |
| 310 | extern void scsi_device_put(struct scsi_device *); |
| 311 | extern struct scsi_device *scsi_device_lookup(struct Scsi_Host *, |
Hannes Reinecke | 9cb78c1 | 2014-06-25 15:27:36 +0200 | [diff] [blame] | 312 | uint, uint, u64); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 313 | extern struct scsi_device *__scsi_device_lookup(struct Scsi_Host *, |
Hannes Reinecke | 9cb78c1 | 2014-06-25 15:27:36 +0200 | [diff] [blame] | 314 | uint, uint, u64); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 315 | extern struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *, |
Hannes Reinecke | 9cb78c1 | 2014-06-25 15:27:36 +0200 | [diff] [blame] | 316 | u64); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | extern struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *, |
Hannes Reinecke | 9cb78c1 | 2014-06-25 15:27:36 +0200 | [diff] [blame] | 318 | u64); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | extern void starget_for_each_device(struct scsi_target *, void *, |
| 320 | void (*fn)(struct scsi_device *, void *)); |
Maciej W. Rozycki | 522939d | 2007-12-10 15:49:31 -0800 | [diff] [blame] | 321 | extern void __starget_for_each_device(struct scsi_target *, void *, |
| 322 | void (*fn)(struct scsi_device *, |
| 323 | void *)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | |
| 325 | /* only exposed to implement shost_for_each_device */ |
| 326 | extern struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *, |
| 327 | struct scsi_device *); |
| 328 | |
| 329 | /** |
Matthew Wilcox | 3e082a9 | 2006-09-28 15:19:20 -0600 | [diff] [blame] | 330 | * shost_for_each_device - iterate over all devices of a host |
| 331 | * @sdev: the &struct scsi_device to use as a cursor |
| 332 | * @shost: the &struct scsi_host to iterate over |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 333 | * |
Matthew Wilcox | 3e082a9 | 2006-09-28 15:19:20 -0600 | [diff] [blame] | 334 | * Iterator that returns each device attached to @shost. This loop |
| 335 | * takes a reference on each device and releases it at the end. If |
| 336 | * you break out of the loop, you must call scsi_device_put(sdev). |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 337 | */ |
| 338 | #define shost_for_each_device(sdev, shost) \ |
| 339 | for ((sdev) = __scsi_iterate_devices((shost), NULL); \ |
| 340 | (sdev); \ |
| 341 | (sdev) = __scsi_iterate_devices((shost), (sdev))) |
| 342 | |
| 343 | /** |
Matthew Wilcox | 3e082a9 | 2006-09-28 15:19:20 -0600 | [diff] [blame] | 344 | * __shost_for_each_device - iterate over all devices of a host (UNLOCKED) |
| 345 | * @sdev: the &struct scsi_device to use as a cursor |
| 346 | * @shost: the &struct scsi_host to iterate over |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 347 | * |
Matthew Wilcox | 3e082a9 | 2006-09-28 15:19:20 -0600 | [diff] [blame] | 348 | * Iterator that returns each device attached to @shost. It does _not_ |
| 349 | * take a reference on the scsi_device, so the whole loop must be |
| 350 | * protected by shost->host_lock. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | * |
Matthew Wilcox | 3e082a9 | 2006-09-28 15:19:20 -0600 | [diff] [blame] | 352 | * Note: The only reason to use this is because you need to access the |
| 353 | * device list in interrupt context. Otherwise you really want to use |
| 354 | * shost_for_each_device instead. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | */ |
| 356 | #define __shost_for_each_device(sdev, shost) \ |
| 357 | list_for_each_entry((sdev), &((shost)->__devices), siblings) |
| 358 | |
Christoph Hellwig | db5ed4d | 2014-11-13 15:08:42 +0100 | [diff] [blame] | 359 | extern int scsi_change_queue_depth(struct scsi_device *, int); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 360 | extern int scsi_track_queue_full(struct scsi_device *, int); |
| 361 | |
| 362 | extern int scsi_set_medium_removal(struct scsi_device *, char); |
| 363 | |
| 364 | extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, |
| 365 | unsigned char *buffer, int len, int timeout, |
James Bottomley | 1cf7269 | 2005-08-28 11:27:01 -0500 | [diff] [blame] | 366 | int retries, struct scsi_mode_data *data, |
James Bottomley | ea73a9f | 2005-08-28 11:33:52 -0500 | [diff] [blame] | 367 | struct scsi_sense_hdr *); |
James Bottomley | 5baba83 | 2006-03-18 14:10:35 -0600 | [diff] [blame] | 368 | extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp, |
| 369 | int modepage, unsigned char *buffer, int len, |
| 370 | int timeout, int retries, |
| 371 | struct scsi_mode_data *data, |
| 372 | struct scsi_sense_hdr *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 373 | extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout, |
James Bottomley | 001aac2 | 2007-12-02 19:10:40 +0200 | [diff] [blame] | 374 | int retries, struct scsi_sense_hdr *sshdr); |
James Bottomley | e3deec0 | 2009-11-03 12:33:07 -0600 | [diff] [blame] | 375 | extern int scsi_get_vpd_page(struct scsi_device *, u8 page, unsigned char *buf, |
| 376 | int buf_len); |
Martin K. Petersen | 3c6bdae | 2012-09-18 12:19:30 -0400 | [diff] [blame] | 377 | extern int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer, |
| 378 | unsigned int len, unsigned char opcode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 379 | extern int scsi_device_set_state(struct scsi_device *sdev, |
| 380 | enum scsi_device_state state); |
Jeff Garzik | a341cd0 | 2007-10-29 17:15:22 -0400 | [diff] [blame] | 381 | extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type, |
| 382 | gfp_t gfpflags); |
| 383 | extern void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt); |
| 384 | extern void sdev_evt_send_simple(struct scsi_device *sdev, |
| 385 | enum scsi_device_event evt_type, gfp_t gfpflags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 386 | extern int scsi_device_quiesce(struct scsi_device *sdev); |
| 387 | extern void scsi_device_resume(struct scsi_device *sdev); |
| 388 | extern void scsi_target_quiesce(struct scsi_target *); |
| 389 | extern void scsi_target_resume(struct scsi_target *); |
| 390 | extern void scsi_scan_target(struct device *parent, unsigned int channel, |
Hannes Reinecke | 9cb78c1 | 2014-06-25 15:27:36 +0200 | [diff] [blame] | 391 | unsigned int id, u64 lun, int rescan); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | extern void scsi_target_reap(struct scsi_target *); |
| 393 | extern void scsi_target_block(struct device *); |
Mike Christie | 5d9fb5c | 2012-05-17 23:56:57 -0500 | [diff] [blame] | 394 | extern void scsi_target_unblock(struct device *, enum scsi_device_state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 395 | extern void scsi_remove_target(struct device *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | extern const char *scsi_device_state_name(enum scsi_device_state); |
| 397 | extern int scsi_is_sdev_device(const struct device *); |
| 398 | extern int scsi_is_target_device(const struct device *); |
James Bottomley | 33aa687 | 2005-08-28 11:31:14 -0500 | [diff] [blame] | 399 | extern int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd, |
| 400 | int data_direction, void *buffer, unsigned bufflen, |
| 401 | unsigned char *sense, int timeout, int retries, |
Martin K. Petersen | 2bfad21 | 2014-04-09 22:20:48 -0400 | [diff] [blame] | 402 | u64 flags, int *resid); |
Lin Ming | 9b21493 | 2013-03-23 11:42:25 +0800 | [diff] [blame] | 403 | extern int scsi_execute_req_flags(struct scsi_device *sdev, |
| 404 | const unsigned char *cmd, int data_direction, void *buffer, |
| 405 | unsigned bufflen, struct scsi_sense_hdr *sshdr, int timeout, |
Martin K. Petersen | 2bfad21 | 2014-04-09 22:20:48 -0400 | [diff] [blame] | 406 | int retries, int *resid, u64 flags); |
Lin Ming | 9b21493 | 2013-03-23 11:42:25 +0800 | [diff] [blame] | 407 | static inline int scsi_execute_req(struct scsi_device *sdev, |
| 408 | const unsigned char *cmd, int data_direction, void *buffer, |
| 409 | unsigned bufflen, struct scsi_sense_hdr *sshdr, int timeout, |
| 410 | int retries, int *resid) |
| 411 | { |
| 412 | return scsi_execute_req_flags(sdev, cmd, data_direction, buffer, |
| 413 | bufflen, sshdr, timeout, retries, resid, 0); |
| 414 | } |
Aaron Lu | 6f4c827 | 2013-01-23 15:09:32 +0800 | [diff] [blame] | 415 | extern void sdev_disable_disk_events(struct scsi_device *sdev); |
| 416 | extern void sdev_enable_disk_events(struct scsi_device *sdev); |
James Bottomley | 33aa687 | 2005-08-28 11:31:14 -0500 | [diff] [blame] | 417 | |
Rafael J. Wysocki | 4f7ad52 | 2014-12-14 23:13:55 +0100 | [diff] [blame] | 418 | #ifdef CONFIG_PM |
Alan Stern | bc4f240 | 2010-06-17 10:41:42 -0400 | [diff] [blame] | 419 | extern int scsi_autopm_get_device(struct scsi_device *); |
| 420 | extern void scsi_autopm_put_device(struct scsi_device *); |
| 421 | #else |
| 422 | static inline int scsi_autopm_get_device(struct scsi_device *d) { return 0; } |
| 423 | static inline void scsi_autopm_put_device(struct scsi_device *d) {} |
Rafael J. Wysocki | 4f7ad52 | 2014-12-14 23:13:55 +0100 | [diff] [blame] | 424 | #endif /* CONFIG_PM */ |
Alan Stern | bc4f240 | 2010-06-17 10:41:42 -0400 | [diff] [blame] | 425 | |
Andrew Morton | cb5d9e0 | 2006-09-30 21:23:44 -0400 | [diff] [blame] | 426 | static inline int __must_check scsi_device_reprobe(struct scsi_device *sdev) |
James Bottomley | e28482c | 2006-03-14 14:24:55 -0600 | [diff] [blame] | 427 | { |
Andrew Morton | cb5d9e0 | 2006-09-30 21:23:44 -0400 | [diff] [blame] | 428 | return device_reprobe(&sdev->sdev_gendev); |
James Bottomley | e28482c | 2006-03-14 14:24:55 -0600 | [diff] [blame] | 429 | } |
| 430 | |
Jeff Garzik | 01d7b3b | 2005-10-24 18:03:34 -0400 | [diff] [blame] | 431 | static inline unsigned int sdev_channel(struct scsi_device *sdev) |
| 432 | { |
| 433 | return sdev->channel; |
| 434 | } |
| 435 | |
| 436 | static inline unsigned int sdev_id(struct scsi_device *sdev) |
| 437 | { |
| 438 | return sdev->id; |
| 439 | } |
| 440 | |
| 441 | #define scmd_id(scmd) sdev_id((scmd)->device) |
| 442 | #define scmd_channel(scmd) sdev_channel((scmd)->device) |
| 443 | |
James Bottomley | 0f1d87a | 2008-08-22 16:43:59 -0500 | [diff] [blame] | 444 | /* |
| 445 | * checks for positions of the SCSI state machine |
| 446 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 447 | static inline int scsi_device_online(struct scsi_device *sdev) |
| 448 | { |
Hannes Reinecke | 0762a48 | 2009-01-12 09:28:55 +0100 | [diff] [blame] | 449 | return (sdev->sdev_state != SDEV_OFFLINE && |
Mike Christie | 1b8d262 | 2012-05-17 23:56:56 -0500 | [diff] [blame] | 450 | sdev->sdev_state != SDEV_TRANSPORT_OFFLINE && |
Hannes Reinecke | 0762a48 | 2009-01-12 09:28:55 +0100 | [diff] [blame] | 451 | sdev->sdev_state != SDEV_DEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 452 | } |
James Bottomley | 0f1d87a | 2008-08-22 16:43:59 -0500 | [diff] [blame] | 453 | static inline int scsi_device_blocked(struct scsi_device *sdev) |
| 454 | { |
James Bottomley | 6f4267e | 2008-08-22 16:53:31 -0500 | [diff] [blame] | 455 | return sdev->sdev_state == SDEV_BLOCK || |
| 456 | sdev->sdev_state == SDEV_CREATED_BLOCK; |
James Bottomley | 0f1d87a | 2008-08-22 16:43:59 -0500 | [diff] [blame] | 457 | } |
| 458 | static inline int scsi_device_created(struct scsi_device *sdev) |
| 459 | { |
James Bottomley | 6f4267e | 2008-08-22 16:53:31 -0500 | [diff] [blame] | 460 | return sdev->sdev_state == SDEV_CREATED || |
| 461 | sdev->sdev_state == SDEV_CREATED_BLOCK; |
James Bottomley | 0f1d87a | 2008-08-22 16:43:59 -0500 | [diff] [blame] | 462 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 463 | |
| 464 | /* accessor functions for the SCSI parameters */ |
| 465 | static inline int scsi_device_sync(struct scsi_device *sdev) |
| 466 | { |
| 467 | return sdev->sdtr; |
| 468 | } |
| 469 | static inline int scsi_device_wide(struct scsi_device *sdev) |
| 470 | { |
| 471 | return sdev->wdtr; |
| 472 | } |
| 473 | static inline int scsi_device_dt(struct scsi_device *sdev) |
| 474 | { |
| 475 | return sdev->ppr; |
| 476 | } |
| 477 | static inline int scsi_device_dt_only(struct scsi_device *sdev) |
| 478 | { |
| 479 | if (sdev->inquiry_len < 57) |
| 480 | return 0; |
| 481 | return (sdev->inquiry[56] & 0x0c) == 0x04; |
| 482 | } |
| 483 | static inline int scsi_device_ius(struct scsi_device *sdev) |
| 484 | { |
| 485 | if (sdev->inquiry_len < 57) |
| 486 | return 0; |
| 487 | return sdev->inquiry[56] & 0x01; |
| 488 | } |
| 489 | static inline int scsi_device_qas(struct scsi_device *sdev) |
| 490 | { |
| 491 | if (sdev->inquiry_len < 57) |
| 492 | return 0; |
| 493 | return sdev->inquiry[56] & 0x02; |
| 494 | } |
James Bottomley | b30c2fc | 2008-01-20 09:09:40 -0600 | [diff] [blame] | 495 | static inline int scsi_device_enclosure(struct scsi_device *sdev) |
| 496 | { |
Krishnasamy, Somasundaram | d1e12de | 2011-02-28 18:13:22 -0500 | [diff] [blame] | 497 | return sdev->inquiry ? (sdev->inquiry[6] & (1<<6)) : 1; |
James Bottomley | b30c2fc | 2008-01-20 09:09:40 -0600 | [diff] [blame] | 498 | } |
Michael Tokarev | d7b8bcb | 2006-10-27 16:02:37 +0400 | [diff] [blame] | 499 | |
Martin K. Petersen | 7027ad7 | 2008-07-17 17:08:48 -0400 | [diff] [blame] | 500 | static inline int scsi_device_protection(struct scsi_device *sdev) |
| 501 | { |
Martin K. Petersen | d974e42 | 2012-08-28 14:29:35 -0400 | [diff] [blame] | 502 | if (sdev->no_dif) |
| 503 | return 0; |
| 504 | |
Hugh Dickins | d211f05 | 2008-08-06 18:21:18 +0100 | [diff] [blame] | 505 | return sdev->scsi_level > SCSI_2 && sdev->inquiry[5] & (1<<0); |
Martin K. Petersen | 7027ad7 | 2008-07-17 17:08:48 -0400 | [diff] [blame] | 506 | } |
| 507 | |
Hannes Reinecke | d7c48fe | 2011-08-24 10:51:13 +0200 | [diff] [blame] | 508 | static inline int scsi_device_tpgs(struct scsi_device *sdev) |
| 509 | { |
| 510 | return sdev->inquiry ? (sdev->inquiry[5] >> 4) & 0x3 : 0; |
| 511 | } |
| 512 | |
Michael Tokarev | d7b8bcb | 2006-10-27 16:02:37 +0400 | [diff] [blame] | 513 | #define MODULE_ALIAS_SCSI_DEVICE(type) \ |
| 514 | MODULE_ALIAS("scsi:t-" __stringify(type) "*") |
| 515 | #define SCSI_DEVICE_MODALIAS_FMT "scsi:t-0x%02x" |
| 516 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 517 | #endif /* _SCSI_SCSI_DEVICE_H */ |