1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _SCSI_SCSI_DEVICE_H
3#define _SCSI_SCSI_DEVICE_H
4
5#include <linux/list.h>
6#include <linux/spinlock.h>
7#include <linux/workqueue.h>
8#include <linux/blk-mq.h>
9#include <scsi/scsi.h>
10#include <linux/atomic.h>
11#include <linux/sbitmap.h>
12
13struct bsg_device;
14struct device;
15struct request_queue;
16struct scsi_cmnd;
17struct scsi_lun;
18struct scsi_sense_hdr;
19
20typedef __u64 __bitwise blist_flags_t;
21
22#define SCSI_SENSE_BUFFERSIZE	96
23
24struct scsi_mode_data {
25	__u32	length;
26	__u16	block_descriptor_length;
27	__u8	medium_type;
28	__u8	device_specific;
29	__u8	header_length;
30	__u8	longlba:1;
31};
32
33/*
34 * sdev state: If you alter this, you also need to alter scsi_sysfs.c
35 * (for the ascii descriptions) and the state model enforcer:
36 * scsi_lib:scsi_device_set_state().
37 */
38enum scsi_device_state {
39	SDEV_CREATED = 1,	/* device created but not added to sysfs
40				 * Only internal commands allowed (for inq) */
41	SDEV_RUNNING,		/* device properly configured
42				 * All commands allowed */
43	SDEV_CANCEL,		/* beginning to delete device
44				 * Only error handler commands allowed */
45	SDEV_DEL,		/* device deleted
46				 * no commands allowed */
47	SDEV_QUIESCE,		/* Device quiescent.  No block commands
48				 * will be accepted, only specials (which
49				 * originate in the mid-layer) */
50	SDEV_OFFLINE,		/* Device offlined (by error handling or
51				 * user request */
52	SDEV_TRANSPORT_OFFLINE,	/* Offlined by transport class error handler */
53	SDEV_BLOCK,		/* Device blocked by scsi lld.  No
54				 * scsi commands from user or midlayer
55				 * should be issued to the scsi
56				 * lld. */
57	SDEV_CREATED_BLOCK,	/* same as above but for created devices */
58};
59
60enum scsi_scan_mode {
61	SCSI_SCAN_INITIAL = 0,
62	SCSI_SCAN_RESCAN,
63	SCSI_SCAN_MANUAL,
64};
65
66enum scsi_device_event {
67	SDEV_EVT_MEDIA_CHANGE	= 1,	/* media has changed */
68	SDEV_EVT_INQUIRY_CHANGE_REPORTED,		/* 3F 03  UA reported */
69	SDEV_EVT_CAPACITY_CHANGE_REPORTED,		/* 2A 09  UA reported */
70	SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED,	/* 38 07  UA reported */
71	SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED,	/* 2A 01  UA reported */
72	SDEV_EVT_LUN_CHANGE_REPORTED,			/* 3F 0E  UA reported */
73	SDEV_EVT_ALUA_STATE_CHANGE_REPORTED,		/* 2A 06  UA reported */
74	SDEV_EVT_POWER_ON_RESET_OCCURRED,		/* 29 00  UA reported */
75
76	SDEV_EVT_FIRST		= SDEV_EVT_MEDIA_CHANGE,
77	SDEV_EVT_LAST		= SDEV_EVT_POWER_ON_RESET_OCCURRED,
78
79	SDEV_EVT_MAXBITS	= SDEV_EVT_LAST + 1
80};
81
82struct scsi_event {
83	enum scsi_device_event	evt_type;
84	struct list_head	node;
85
86	/* put union of data structures, for non-simple event types,
87	 * here
88	 */
89};
90
91/**
92 * struct scsi_vpd - SCSI Vital Product Data
93 * @rcu: For kfree_rcu().
94 * @len: Length in bytes of @data.
95 * @data: VPD data as defined in various T10 SCSI standard documents.
96 */
97struct scsi_vpd {
98	struct rcu_head	rcu;
99	int		len;
100	unsigned char	data[];
101};
102
103struct scsi_device {
104	struct Scsi_Host *host;
105	struct request_queue *request_queue;
106
107	/* the next two are protected by the host->host_lock */
108	struct list_head    siblings;   /* list of all devices on this host */
109	struct list_head    same_target_siblings; /* just the devices sharing same target id */
110
111	struct sbitmap budget_map;
112	atomic_t device_blocked;	/* Device returned QUEUE_FULL. */
113
114	atomic_t restarts;
115	spinlock_t list_lock;
116	struct list_head starved_entry;
117	unsigned short queue_depth;	/* How deep of a queue we want */
118	unsigned short max_queue_depth;	/* max queue depth */
119	unsigned short last_queue_full_depth; /* These two are used by */
120	unsigned short last_queue_full_count; /* scsi_track_queue_full() */
121	unsigned long last_queue_full_time;	/* last queue full time */
122	unsigned long queue_ramp_up_period;	/* ramp up period in jiffies */
123#define SCSI_DEFAULT_RAMP_UP_PERIOD	(120 * HZ)
124
125	unsigned long last_queue_ramp_up;	/* last queue ramp up time */
126
127	unsigned int id, channel;
128	u64 lun;
129	unsigned int manufacturer;	/* Manufacturer of device, for using
130					 * vendor-specific cmd's */
131	unsigned sector_size;	/* size in bytes */
132
133	void *hostdata;		/* available to low-level driver */
134	unsigned char type;
135	char scsi_level;
136	char inq_periph_qual;	/* PQ from INQUIRY data */
137	struct mutex inquiry_mutex;
138	unsigned char inquiry_len;	/* valid bytes in 'inquiry' */
139	unsigned char * inquiry;	/* INQUIRY response data */
140	const char * vendor;		/* [back_compat] point into 'inquiry' ... */
141	const char * model;		/* ... after scan; point to static string */
142	const char * rev;		/* ... "nullnullnullnull" before scan */
143
144#define SCSI_DEFAULT_VPD_LEN	255	/* default SCSI VPD page size (max) */
145	struct scsi_vpd __rcu *vpd_pg0;
146	struct scsi_vpd __rcu *vpd_pg83;
147	struct scsi_vpd __rcu *vpd_pg80;
148	struct scsi_vpd __rcu *vpd_pg89;
149	struct scsi_vpd __rcu *vpd_pgb0;
150	struct scsi_vpd __rcu *vpd_pgb1;
151	struct scsi_vpd __rcu *vpd_pgb2;
152	struct scsi_vpd __rcu *vpd_pgb7;
153
154	struct scsi_target      *sdev_target;
155
156	blist_flags_t		sdev_bflags; /* black/white flags as also found in
157				 * scsi_devinfo.[hc]. For now used only to
158				 * pass settings from slave_alloc to scsi
159				 * core. */
160	unsigned int eh_timeout; /* Error handling timeout */
161
162	/*
163	 * If true, let the high-level device driver (sd) manage the device
164	 * power state for system suspend/resume (suspend to RAM and
165	 * hibernation) operations.
166	 */
167	unsigned manage_system_start_stop:1;
168
169	/*
170	 * If true, let the high-level device driver (sd) manage the device
171	 * power state for runtime device suspand and resume operations.
172	 */
173	unsigned manage_runtime_start_stop:1;
174
175	/*
176	 * If true, let the high-level device driver (sd) manage the device
177	 * power state for system shutdown (power off) operations.
178	 */
179	unsigned manage_shutdown:1;
180
181	/*
182	 * If set and if the device is runtime suspended, ask the high-level
183	 * device driver (sd) to force a runtime resume of the device.
184	 */
185	unsigned force_runtime_start_on_system_start:1;
186
187	unsigned removable:1;
188	unsigned changed:1;	/* Data invalid due to media change */
189	unsigned busy:1;	/* Used to prevent races */
190	unsigned lockable:1;	/* Able to prevent media removal */
191	unsigned locked:1;      /* Media removal disabled */
192	unsigned borken:1;	/* Tell the Seagate driver to be
193				 * painfully slow on this device */
194	unsigned disconnect:1;	/* can disconnect */
195	unsigned soft_reset:1;	/* Uses soft reset option */
196	unsigned sdtr:1;	/* Device supports SDTR messages */
197	unsigned wdtr:1;	/* Device supports WDTR messages */
198	unsigned ppr:1;		/* Device supports PPR messages */
199	unsigned tagged_supported:1;	/* Supports SCSI-II tagged queuing */
200	unsigned simple_tags:1;	/* simple queue tag messages are enabled */
201	unsigned was_reset:1;	/* There was a bus reset on the bus for
202				 * this device */
203	unsigned expecting_cc_ua:1; /* Expecting a CHECK_CONDITION/UNIT_ATTN
204				     * because we did a bus reset. */
205	unsigned use_10_for_rw:1; /* first try 10-byte read / write */
206	unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
207	unsigned set_dbd_for_ms:1; /* Set "DBD" field in mode sense */
208	unsigned read_before_ms:1;	/* perform a READ before MODE SENSE */
209	unsigned no_report_opcodes:1;	/* no REPORT SUPPORTED OPERATION CODES */
210	unsigned no_write_same:1;	/* no WRITE SAME command */
211	unsigned use_16_for_rw:1; /* Use read/write(16) over read/write(10) */
212	unsigned use_16_for_sync:1;	/* Use sync (16) over sync (10) */
213	unsigned skip_ms_page_8:1;	/* do not use MODE SENSE page 0x08 */
214	unsigned skip_ms_page_3f:1;	/* do not use MODE SENSE page 0x3f */
215	unsigned skip_vpd_pages:1;	/* do not read VPD pages */
216	unsigned try_vpd_pages:1;	/* attempt to read VPD pages */
217	unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
218	unsigned no_start_on_add:1;	/* do not issue start on add */
219	unsigned allow_restart:1; /* issue START_UNIT in error handler */
220	unsigned start_stop_pwr_cond:1;	/* Set power cond. in START_STOP_UNIT */
221	unsigned no_uld_attach:1; /* disable connecting to upper level drivers */
222	unsigned select_no_atn:1;
223	unsigned fix_capacity:1;	/* READ_CAPACITY is too high by 1 */
224	unsigned guess_capacity:1;	/* READ_CAPACITY might be too high by 1 */
225	unsigned retry_hwerror:1;	/* Retry HARDWARE_ERROR */
226	unsigned last_sector_bug:1;	/* do not use multisector accesses on
227					   SD_LAST_BUGGY_SECTORS */
228	unsigned no_read_disc_info:1;	/* Avoid READ_DISC_INFO cmds */
229	unsigned no_read_capacity_16:1; /* Avoid READ_CAPACITY_16 cmds */
230	unsigned try_rc_10_first:1;	/* Try READ_CAPACACITY_10 first */
231	unsigned security_supported:1;	/* Supports Security Protocols */
232	unsigned is_visible:1;	/* is the device visible in sysfs */
233	unsigned wce_default_on:1;	/* Cache is ON by default */
234	unsigned no_dif:1;	/* T10 PI (DIF) should be disabled */
235	unsigned broken_fua:1;		/* Don't set FUA bit */
236	unsigned lun_in_cdb:1;		/* Store LUN bits in CDB[1] */
237	unsigned unmap_limit_for_ws:1;	/* Use the UNMAP limit for WRITE SAME */
238	unsigned rpm_autosuspend:1;	/* Enable runtime autosuspend at device
239					 * creation time */
240	unsigned ignore_media_change:1; /* Ignore MEDIA CHANGE on resume */
241	unsigned silence_suspend:1;	/* Do not print runtime PM related messages */
242	unsigned no_vpd_size:1;		/* No VPD size reported in header */
243
244	unsigned cdl_supported:1;	/* Command duration limits supported */
245	unsigned cdl_enable:1;		/* Enable/disable Command duration limits */
246
247	unsigned int queue_stopped;	/* request queue is quiesced */
248	bool offline_already;		/* Device offline message logged */
249
250	atomic_t disk_events_disable_depth; /* disable depth for disk events */
251
252	DECLARE_BITMAP(supported_events, SDEV_EVT_MAXBITS); /* supported events */
253	DECLARE_BITMAP(pending_events, SDEV_EVT_MAXBITS); /* pending events */
254	struct list_head event_list;	/* asserted events */
255	struct work_struct event_work;
256
257	unsigned int max_device_blocked; /* what device_blocked counts down from  */
258#define SCSI_DEFAULT_DEVICE_BLOCKED	3
259
260	atomic_t iorequest_cnt;
261	atomic_t iodone_cnt;
262	atomic_t ioerr_cnt;
263	atomic_t iotmo_cnt;
264
265	struct device		sdev_gendev,
266				sdev_dev;
267
268	struct work_struct	requeue_work;
269
270	struct scsi_device_handler *handler;
271	void			*handler_data;
272
273	size_t			dma_drain_len;
274	void			*dma_drain_buf;
275
276	unsigned int		sg_timeout;
277	unsigned int		sg_reserved_size;
278
279	struct bsg_device	*bsg_dev;
280	unsigned char		access_state;
281	struct mutex		state_mutex;
282	enum scsi_device_state sdev_state;
283	struct task_struct	*quiesced_by;
284	unsigned long		sdev_data[];
285} __attribute__((aligned(sizeof(unsigned long))));
286
287#define	to_scsi_device(d)	\
288	container_of(d, struct scsi_device, sdev_gendev)
289#define	class_to_sdev(d)	\
290	container_of(d, struct scsi_device, sdev_dev)
291#define transport_class_to_sdev(class_dev) \
292	to_scsi_device(class_dev->parent)
293
294#define sdev_dbg(sdev, fmt, a...) \
295	dev_dbg(&(sdev)->sdev_gendev, fmt, ##a)
296
297/*
298 * like scmd_printk, but the device name is passed in
299 * as a string pointer
300 */
301__printf(4, 5) void
302sdev_prefix_printk(const char *, const struct scsi_device *, const char *,
303		const char *, ...);
304
305#define sdev_printk(l, sdev, fmt, a...)				\
306	sdev_prefix_printk(l, sdev, NULL, fmt, ##a)
307
308__printf(3, 4) void
309scmd_printk(const char *, const struct scsi_cmnd *, const char *, ...);
310
311#define scmd_dbg(scmd, fmt, a...)					\
312	do {								\
313		struct request *__rq = scsi_cmd_to_rq((scmd));		\
314									\
315		if (__rq->q->disk)					\
316			sdev_dbg((scmd)->device, "[%s] " fmt,		\
317				 __rq->q->disk->disk_name, ##a);	\
318		else							\
319			sdev_dbg((scmd)->device, fmt, ##a);		\
320	} while (0)
321
322enum scsi_target_state {
323	STARGET_CREATED = 1,
324	STARGET_RUNNING,
325	STARGET_REMOVE,
326	STARGET_CREATED_REMOVE,
327	STARGET_DEL,
328};
329
330/*
331 * scsi_target: representation of a scsi target, for now, this is only
332 * used for single_lun devices. If no one has active IO to the target,
333 * starget_sdev_user is NULL, else it points to the active sdev.
334 */
335struct scsi_target {
336	struct scsi_device	*starget_sdev_user;
337	struct list_head	siblings;
338	struct list_head	devices;
339	struct device		dev;
340	struct kref		reap_ref; /* last put renders target invisible */
341	unsigned int		channel;
342	unsigned int		id; /* target id ... replace
343				     * scsi_device.id eventually */
344	unsigned int		create:1; /* signal that it needs to be added */
345	unsigned int		single_lun:1;	/* Indicates we should only
346						 * allow I/O to one of the luns
347						 * for the device at a time. */
348	unsigned int		pdt_1f_for_no_lun:1;	/* PDT = 0x1f
349						 * means no lun present. */
350	unsigned int		no_report_luns:1;	/* Don't use
351						 * REPORT LUNS for scanning. */
352	unsigned int		expecting_lun_change:1;	/* A device has reported
353						 * a 3F/0E UA, other devices on
354						 * the same target will also. */
355	/* commands actually active on LLD. */
356	atomic_t		target_busy;
357	atomic_t		target_blocked;
358
359	/*
360	 * LLDs should set this in the slave_alloc host template callout.
361	 * If set to zero then there is not limit.
362	 */
363	unsigned int		can_queue;
364	unsigned int		max_target_blocked;
365#define SCSI_DEFAULT_TARGET_BLOCKED	3
366
367	char			scsi_level;
368	enum scsi_target_state	state;
369	void 			*hostdata; /* available to low-level driver */
370	unsigned long		starget_data[]; /* for the transport */
371	/* starget_data must be the last element!!!! */
372} __attribute__((aligned(sizeof(unsigned long))));
373
374#define to_scsi_target(d)	container_of(d, struct scsi_target, dev)
375static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
376{
377	return to_scsi_target(sdev->sdev_gendev.parent);
378}
379#define transport_class_to_starget(class_dev) \
380	to_scsi_target(class_dev->parent)
381
382#define starget_printk(prefix, starget, fmt, a...)	\
383	dev_printk(prefix, &(starget)->dev, fmt, ##a)
384
385extern struct scsi_device *__scsi_add_device(struct Scsi_Host *,
386		uint, uint, u64, void *hostdata);
387extern int scsi_add_device(struct Scsi_Host *host, uint channel,
388			   uint target, u64 lun);
389extern int scsi_register_device_handler(struct scsi_device_handler *scsi_dh);
390extern void scsi_remove_device(struct scsi_device *);
391extern int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh);
392void scsi_attach_vpd(struct scsi_device *sdev);
393void scsi_cdl_check(struct scsi_device *sdev);
394int scsi_cdl_enable(struct scsi_device *sdev, bool enable);
395
396extern struct scsi_device *scsi_device_from_queue(struct request_queue *q);
397extern int __must_check scsi_device_get(struct scsi_device *);
398extern void scsi_device_put(struct scsi_device *);
399extern struct scsi_device *scsi_device_lookup(struct Scsi_Host *,
400					      uint, uint, u64);
401extern struct scsi_device *__scsi_device_lookup(struct Scsi_Host *,
402						uint, uint, u64);
403extern struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *,
404							u64);
405extern struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *,
406							  u64);
407extern void starget_for_each_device(struct scsi_target *, void *,
408		     void (*fn)(struct scsi_device *, void *));
409extern void __starget_for_each_device(struct scsi_target *, void *,
410				      void (*fn)(struct scsi_device *,
411						 void *));
412
413/* only exposed to implement shost_for_each_device */
414extern struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *,
415						  struct scsi_device *);
416
417/**
418 * shost_for_each_device - iterate over all devices of a host
419 * @sdev: the &struct scsi_device to use as a cursor
420 * @shost: the &struct scsi_host to iterate over
421 *
422 * Iterator that returns each device attached to @shost.  This loop
423 * takes a reference on each device and releases it at the end.  If
424 * you break out of the loop, you must call scsi_device_put(sdev).
425 */
426#define shost_for_each_device(sdev, shost) \
427	for ((sdev) = __scsi_iterate_devices((shost), NULL); \
428	     (sdev); \
429	     (sdev) = __scsi_iterate_devices((shost), (sdev)))
430
431/**
432 * __shost_for_each_device - iterate over all devices of a host (UNLOCKED)
433 * @sdev: the &struct scsi_device to use as a cursor
434 * @shost: the &struct scsi_host to iterate over
435 *
436 * Iterator that returns each device attached to @shost.  It does _not_
437 * take a reference on the scsi_device, so the whole loop must be
438 * protected by shost->host_lock.
439 *
440 * Note: The only reason to use this is because you need to access the
441 * device list in interrupt context.  Otherwise you really want to use
442 * shost_for_each_device instead.
443 */
444#define __shost_for_each_device(sdev, shost) \
445	list_for_each_entry((sdev), &((shost)->__devices), siblings)
446
447extern int scsi_change_queue_depth(struct scsi_device *, int);
448extern int scsi_track_queue_full(struct scsi_device *, int);
449
450extern int scsi_set_medium_removal(struct scsi_device *, char);
451
452int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
453		    int subpage, unsigned char *buffer, int len, int timeout,
454		    int retries, struct scsi_mode_data *data,
455		    struct scsi_sense_hdr *);
456extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
457			    unsigned char *buffer, int len, int timeout,
458			    int retries, struct scsi_mode_data *data,
459			    struct scsi_sense_hdr *);
460extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
461				int retries, struct scsi_sense_hdr *sshdr);
462extern int scsi_get_vpd_page(struct scsi_device *, u8 page, unsigned char *buf,
463			     int buf_len);
464int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
465		       unsigned int len, unsigned char opcode,
466		       unsigned short sa);
467extern int scsi_device_set_state(struct scsi_device *sdev,
468				 enum scsi_device_state state);
469extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
470					  gfp_t gfpflags);
471extern void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt);
472extern void sdev_evt_send_simple(struct scsi_device *sdev,
473			  enum scsi_device_event evt_type, gfp_t gfpflags);
474extern int scsi_device_quiesce(struct scsi_device *sdev);
475extern void scsi_device_resume(struct scsi_device *sdev);
476extern void scsi_target_quiesce(struct scsi_target *);
477extern void scsi_target_resume(struct scsi_target *);
478extern void scsi_scan_target(struct device *parent, unsigned int channel,
479			     unsigned int id, u64 lun,
480			     enum scsi_scan_mode rescan);
481extern void scsi_target_reap(struct scsi_target *);
482void scsi_block_targets(struct Scsi_Host *shost, struct device *dev);
483extern void scsi_target_unblock(struct device *, enum scsi_device_state);
484extern void scsi_remove_target(struct device *);
485extern const char *scsi_device_state_name(enum scsi_device_state);
486extern int scsi_is_sdev_device(const struct device *);
487extern int scsi_is_target_device(const struct device *);
488extern void scsi_sanitize_inquiry_string(unsigned char *s, int len);
489
490/*
491 * scsi_execute_cmd users can set scsi_failure.result to have
492 * scsi_check_passthrough fail/retry a command. scsi_failure.result can be a
493 * specific host byte or message code, or SCMD_FAILURE_RESULT_ANY can be used
494 * to match any host or message code.
495 */
496#define SCMD_FAILURE_RESULT_ANY	0x7fffffff
497/*
498 * Set scsi_failure.result to SCMD_FAILURE_STAT_ANY to fail/retry any failure
499 * scsi_status_is_good returns false for.
500 */
501#define SCMD_FAILURE_STAT_ANY	0xff
502/*
503 * The following can be set to the scsi_failure sense, asc and ascq fields to
504 * match on any sense, ASC, or ASCQ value.
505 */
506#define SCMD_FAILURE_SENSE_ANY	0xff
507#define SCMD_FAILURE_ASC_ANY	0xff
508#define SCMD_FAILURE_ASCQ_ANY	0xff
509/* Always retry a matching failure. */
510#define SCMD_FAILURE_NO_LIMIT	-1
511
512struct scsi_failure {
513	int result;
514	u8 sense;
515	u8 asc;
516	u8 ascq;
517	/*
518	 * Number of times scsi_execute_cmd will retry the failure. It does
519	 * not count for the total_allowed.
520	 */
521	s8 allowed;
522	/* Number of times the failure has been retried. */
523	s8 retries;
524};
525
526struct scsi_failures {
527	/*
528	 * If a scsi_failure does not have a retry limit setup this limit will
529	 * be used.
530	 */
531	int total_allowed;
532	int total_retries;
533	struct scsi_failure *failure_definitions;
534};
535
536/* Optional arguments to scsi_execute_cmd */
537struct scsi_exec_args {
538	unsigned char *sense;		/* sense buffer */
539	unsigned int sense_len;		/* sense buffer len */
540	struct scsi_sense_hdr *sshdr;	/* decoded sense header */
541	blk_mq_req_flags_t req_flags;	/* BLK_MQ_REQ flags */
542	int scmd_flags;			/* SCMD flags */
543	int *resid;			/* residual length */
544	struct scsi_failures *failures;	/* failures to retry */
545};
546
547int scsi_execute_cmd(struct scsi_device *sdev, const unsigned char *cmd,
548		     blk_opf_t opf, void *buffer, unsigned int bufflen,
549		     int timeout, int retries,
550		     const struct scsi_exec_args *args);
551void scsi_failures_reset_retries(struct scsi_failures *failures);
552
553extern void sdev_disable_disk_events(struct scsi_device *sdev);
554extern void sdev_enable_disk_events(struct scsi_device *sdev);
555extern int scsi_vpd_lun_id(struct scsi_device *, char *, size_t);
556extern int scsi_vpd_tpg_id(struct scsi_device *, int *);
557
558#ifdef CONFIG_PM
559extern int scsi_autopm_get_device(struct scsi_device *);
560extern void scsi_autopm_put_device(struct scsi_device *);
561#else
562static inline int scsi_autopm_get_device(struct scsi_device *d) { return 0; }
563static inline void scsi_autopm_put_device(struct scsi_device *d) {}
564#endif /* CONFIG_PM */
565
566static inline int __must_check scsi_device_reprobe(struct scsi_device *sdev)
567{
568	return device_reprobe(&sdev->sdev_gendev);
569}
570
571static inline unsigned int sdev_channel(struct scsi_device *sdev)
572{
573	return sdev->channel;
574}
575
576static inline unsigned int sdev_id(struct scsi_device *sdev)
577{
578	return sdev->id;
579}
580
581#define scmd_id(scmd) sdev_id((scmd)->device)
582#define scmd_channel(scmd) sdev_channel((scmd)->device)
583
584/*
585 * checks for positions of the SCSI state machine
586 */
587static inline int scsi_device_online(struct scsi_device *sdev)
588{
589	return (sdev->sdev_state != SDEV_OFFLINE &&
590		sdev->sdev_state != SDEV_TRANSPORT_OFFLINE &&
591		sdev->sdev_state != SDEV_DEL);
592}
593static inline int scsi_device_blocked(struct scsi_device *sdev)
594{
595	return sdev->sdev_state == SDEV_BLOCK ||
596		sdev->sdev_state == SDEV_CREATED_BLOCK;
597}
598static inline int scsi_device_created(struct scsi_device *sdev)
599{
600	return sdev->sdev_state == SDEV_CREATED ||
601		sdev->sdev_state == SDEV_CREATED_BLOCK;
602}
603
604int scsi_internal_device_block_nowait(struct scsi_device *sdev);
605int scsi_internal_device_unblock_nowait(struct scsi_device *sdev,
606					enum scsi_device_state new_state);
607
608/* accessor functions for the SCSI parameters */
609static inline int scsi_device_sync(struct scsi_device *sdev)
610{
611	return sdev->sdtr;
612}
613static inline int scsi_device_wide(struct scsi_device *sdev)
614{
615	return sdev->wdtr;
616}
617static inline int scsi_device_dt(struct scsi_device *sdev)
618{
619	return sdev->ppr;
620}
621static inline int scsi_device_dt_only(struct scsi_device *sdev)
622{
623	if (sdev->inquiry_len < 57)
624		return 0;
625	return (sdev->inquiry[56] & 0x0c) == 0x04;
626}
627static inline int scsi_device_ius(struct scsi_device *sdev)
628{
629	if (sdev->inquiry_len < 57)
630		return 0;
631	return sdev->inquiry[56] & 0x01;
632}
633static inline int scsi_device_qas(struct scsi_device *sdev)
634{
635	if (sdev->inquiry_len < 57)
636		return 0;
637	return sdev->inquiry[56] & 0x02;
638}
639static inline int scsi_device_enclosure(struct scsi_device *sdev)
640{
641	return sdev->inquiry ? (sdev->inquiry[6] & (1<<6)) : 1;
642}
643
644static inline int scsi_device_protection(struct scsi_device *sdev)
645{
646	if (sdev->no_dif)
647		return 0;
648
649	return sdev->scsi_level > SCSI_2 && sdev->inquiry[5] & (1<<0);
650}
651
652static inline int scsi_device_tpgs(struct scsi_device *sdev)
653{
654	return sdev->inquiry ? (sdev->inquiry[5] >> 4) & 0x3 : 0;
655}
656
657/**
658 * scsi_device_supports_vpd - test if a device supports VPD pages
659 * @sdev: the &struct scsi_device to test
660 *
661 * If the 'try_vpd_pages' flag is set it takes precedence.
662 * Otherwise we will assume VPD pages are supported if the
663 * SCSI level is at least SPC-3 and 'skip_vpd_pages' is not set.
664 */
665static inline int scsi_device_supports_vpd(struct scsi_device *sdev)
666{
667	/* Attempt VPD inquiry if the device blacklist explicitly calls
668	 * for it.
669	 */
670	if (sdev->try_vpd_pages)
671		return 1;
672	/*
673	 * Although VPD inquiries can go to SCSI-2 type devices,
674	 * some USB ones crash on receiving them, and the pages
675	 * we currently ask for are mandatory for SPC-2 and beyond
676	 */
677	if (sdev->scsi_level >= SCSI_SPC_2 && !sdev->skip_vpd_pages)
678		return 1;
679	return 0;
680}
681
682static inline int scsi_device_busy(struct scsi_device *sdev)
683{
684	return sbitmap_weight(&sdev->budget_map);
685}
686
687#define MODULE_ALIAS_SCSI_DEVICE(type) \
688	MODULE_ALIAS("scsi:t-" __stringify(type) "*")
689#define SCSI_DEVICE_MODALIAS_FMT "scsi:t-0x%02x"
690
691#endif /* _SCSI_SCSI_DEVICE_H */
692