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