GNU Linux-libre 4.19.211-gnu1
[releases.git] / include / scsi / scsi_host.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _SCSI_SCSI_HOST_H
3 #define _SCSI_SCSI_HOST_H
4
5 #include <linux/device.h>
6 #include <linux/list.h>
7 #include <linux/types.h>
8 #include <linux/workqueue.h>
9 #include <linux/mutex.h>
10 #include <linux/seq_file.h>
11 #include <linux/blk-mq.h>
12 #include <scsi/scsi.h>
13
14 struct request_queue;
15 struct block_device;
16 struct completion;
17 struct module;
18 struct scsi_cmnd;
19 struct scsi_device;
20 struct scsi_host_cmd_pool;
21 struct scsi_target;
22 struct Scsi_Host;
23 struct scsi_host_cmd_pool;
24 struct scsi_transport_template;
25 struct blk_queue_tags;
26
27
28 /*
29  * The various choices mean:
30  * NONE: Self evident.  Host adapter is not capable of scatter-gather.
31  * ALL:  Means that the host adapter module can do scatter-gather,
32  *       and that there is no limit to the size of the table to which
33  *       we scatter/gather data.  The value we set here is the maximum
34  *       single element sglist.  To use chained sglists, the adapter
35  *       has to set a value beyond ALL (and correctly use the chain
36  *       handling API.
37  * Anything else:  Indicates the maximum number of chains that can be
38  *       used in one scatter-gather request.
39  */
40 #define SG_NONE 0
41 #define SG_ALL  SG_CHUNK_SIZE
42
43 #define MODE_UNKNOWN 0x00
44 #define MODE_INITIATOR 0x01
45 #define MODE_TARGET 0x02
46
47 #define DISABLE_CLUSTERING 0
48 #define ENABLE_CLUSTERING 1
49
50 struct scsi_host_template {
51         struct module *module;
52         const char *name;
53
54         /*
55          * The info function will return whatever useful information the
56          * developer sees fit.  If not provided, then the name field will
57          * be used instead.
58          *
59          * Status: OPTIONAL
60          */
61         const char *(* info)(struct Scsi_Host *);
62
63         /*
64          * Ioctl interface
65          *
66          * Status: OPTIONAL
67          */
68         int (* ioctl)(struct scsi_device *dev, int cmd, void __user *arg);
69
70
71 #ifdef CONFIG_COMPAT
72         /* 
73          * Compat handler. Handle 32bit ABI.
74          * When unknown ioctl is passed return -ENOIOCTLCMD.
75          *
76          * Status: OPTIONAL
77          */
78         int (* compat_ioctl)(struct scsi_device *dev, int cmd, void __user *arg);
79 #endif
80
81         /*
82          * The queuecommand function is used to queue up a scsi
83          * command block to the LLDD.  When the driver finished
84          * processing the command the done callback is invoked.
85          *
86          * If queuecommand returns 0, then the HBA has accepted the
87          * command.  The done() function must be called on the command
88          * when the driver has finished with it. (you may call done on the
89          * command before queuecommand returns, but in this case you
90          * *must* return 0 from queuecommand).
91          *
92          * Queuecommand may also reject the command, in which case it may
93          * not touch the command and must not call done() for it.
94          *
95          * There are two possible rejection returns:
96          *
97          *   SCSI_MLQUEUE_DEVICE_BUSY: Block this device temporarily, but
98          *   allow commands to other devices serviced by this host.
99          *
100          *   SCSI_MLQUEUE_HOST_BUSY: Block all devices served by this
101          *   host temporarily.
102          *
103          * For compatibility, any other non-zero return is treated the
104          * same as SCSI_MLQUEUE_HOST_BUSY.
105          *
106          * NOTE: "temporarily" means either until the next command for#
107          * this device/host completes, or a period of time determined by
108          * I/O pressure in the system if there are no other outstanding
109          * commands.
110          *
111          * STATUS: REQUIRED
112          */
113         int (* queuecommand)(struct Scsi_Host *, struct scsi_cmnd *);
114
115         /*
116          * This is an error handling strategy routine.  You don't need to
117          * define one of these if you don't want to - there is a default
118          * routine that is present that should work in most cases.  For those
119          * driver authors that have the inclination and ability to write their
120          * own strategy routine, this is where it is specified.  Note - the
121          * strategy routine is *ALWAYS* run in the context of the kernel eh
122          * thread.  Thus you are guaranteed to *NOT* be in an interrupt
123          * handler when you execute this, and you are also guaranteed to
124          * *NOT* have any other commands being queued while you are in the
125          * strategy routine. When you return from this function, operations
126          * return to normal.
127          *
128          * See scsi_error.c scsi_unjam_host for additional comments about
129          * what this function should and should not be attempting to do.
130          *
131          * Status: REQUIRED     (at least one of them)
132          */
133         int (* eh_abort_handler)(struct scsi_cmnd *);
134         int (* eh_device_reset_handler)(struct scsi_cmnd *);
135         int (* eh_target_reset_handler)(struct scsi_cmnd *);
136         int (* eh_bus_reset_handler)(struct scsi_cmnd *);
137         int (* eh_host_reset_handler)(struct scsi_cmnd *);
138
139         /*
140          * Before the mid layer attempts to scan for a new device where none
141          * currently exists, it will call this entry in your driver.  Should
142          * your driver need to allocate any structs or perform any other init
143          * items in order to send commands to a currently unused target/lun
144          * combo, then this is where you can perform those allocations.  This
145          * is specifically so that drivers won't have to perform any kind of
146          * "is this a new device" checks in their queuecommand routine,
147          * thereby making the hot path a bit quicker.
148          *
149          * Return values: 0 on success, non-0 on failure
150          *
151          * Deallocation:  If we didn't find any devices at this ID, you will
152          * get an immediate call to slave_destroy().  If we find something
153          * here then you will get a call to slave_configure(), then the
154          * device will be used for however long it is kept around, then when
155          * the device is removed from the system (or * possibly at reboot
156          * time), you will then get a call to slave_destroy().  This is
157          * assuming you implement slave_configure and slave_destroy.
158          * However, if you allocate memory and hang it off the device struct,
159          * then you must implement the slave_destroy() routine at a minimum
160          * in order to avoid leaking memory
161          * each time a device is tore down.
162          *
163          * Status: OPTIONAL
164          */
165         int (* slave_alloc)(struct scsi_device *);
166
167         /*
168          * Once the device has responded to an INQUIRY and we know the
169          * device is online, we call into the low level driver with the
170          * struct scsi_device *.  If the low level device driver implements
171          * this function, it *must* perform the task of setting the queue
172          * depth on the device.  All other tasks are optional and depend
173          * on what the driver supports and various implementation details.
174          * 
175          * Things currently recommended to be handled at this time include:
176          *
177          * 1.  Setting the device queue depth.  Proper setting of this is
178          *     described in the comments for scsi_change_queue_depth.
179          * 2.  Determining if the device supports the various synchronous
180          *     negotiation protocols.  The device struct will already have
181          *     responded to INQUIRY and the results of the standard items
182          *     will have been shoved into the various device flag bits, eg.
183          *     device->sdtr will be true if the device supports SDTR messages.
184          * 3.  Allocating command structs that the device will need.
185          * 4.  Setting the default timeout on this device (if needed).
186          * 5.  Anything else the low level driver might want to do on a device
187          *     specific setup basis...
188          * 6.  Return 0 on success, non-0 on error.  The device will be marked
189          *     as offline on error so that no access will occur.  If you return
190          *     non-0, your slave_destroy routine will never get called for this
191          *     device, so don't leave any loose memory hanging around, clean
192          *     up after yourself before returning non-0
193          *
194          * Status: OPTIONAL
195          */
196         int (* slave_configure)(struct scsi_device *);
197
198         /*
199          * Immediately prior to deallocating the device and after all activity
200          * has ceased the mid layer calls this point so that the low level
201          * driver may completely detach itself from the scsi device and vice
202          * versa.  The low level driver is responsible for freeing any memory
203          * it allocated in the slave_alloc or slave_configure calls. 
204          *
205          * Status: OPTIONAL
206          */
207         void (* slave_destroy)(struct scsi_device *);
208
209         /*
210          * Before the mid layer attempts to scan for a new device attached
211          * to a target where no target currently exists, it will call this
212          * entry in your driver.  Should your driver need to allocate any
213          * structs or perform any other init items in order to send commands
214          * to a currently unused target, then this is where you can perform
215          * those allocations.
216          *
217          * Return values: 0 on success, non-0 on failure
218          *
219          * Status: OPTIONAL
220          */
221         int (* target_alloc)(struct scsi_target *);
222
223         /*
224          * Immediately prior to deallocating the target structure, and
225          * after all activity to attached scsi devices has ceased, the
226          * midlayer calls this point so that the driver may deallocate
227          * and terminate any references to the target.
228          *
229          * Status: OPTIONAL
230          */
231         void (* target_destroy)(struct scsi_target *);
232
233         /*
234          * If a host has the ability to discover targets on its own instead
235          * of scanning the entire bus, it can fill in this function and
236          * call scsi_scan_host().  This function will be called periodically
237          * until it returns 1 with the scsi_host and the elapsed time of
238          * the scan in jiffies.
239          *
240          * Status: OPTIONAL
241          */
242         int (* scan_finished)(struct Scsi_Host *, unsigned long);
243
244         /*
245          * If the host wants to be called before the scan starts, but
246          * after the midlayer has set up ready for the scan, it can fill
247          * in this function.
248          *
249          * Status: OPTIONAL
250          */
251         void (* scan_start)(struct Scsi_Host *);
252
253         /*
254          * Fill in this function to allow the queue depth of this host
255          * to be changeable (on a per device basis).  Returns either
256          * the current queue depth setting (may be different from what
257          * was passed in) or an error.  An error should only be
258          * returned if the requested depth is legal but the driver was
259          * unable to set it.  If the requested depth is illegal, the
260          * driver should set and return the closest legal queue depth.
261          *
262          * Status: OPTIONAL
263          */
264         int (* change_queue_depth)(struct scsi_device *, int);
265
266         /*
267          * This functions lets the driver expose the queue mapping
268          * to the block layer.
269          *
270          * Status: OPTIONAL
271          */
272         int (* map_queues)(struct Scsi_Host *shost);
273
274         /*
275          * This function determines the BIOS parameters for a given
276          * harddisk.  These tend to be numbers that are made up by
277          * the host adapter.  Parameters:
278          * size, device, list (heads, sectors, cylinders)
279          *
280          * Status: OPTIONAL
281          */
282         int (* bios_param)(struct scsi_device *, struct block_device *,
283                         sector_t, int []);
284
285         /*
286          * This function is called when one or more partitions on the
287          * device reach beyond the end of the device.
288          *
289          * Status: OPTIONAL
290          */
291         void (*unlock_native_capacity)(struct scsi_device *);
292
293         /*
294          * Can be used to export driver statistics and other infos to the
295          * world outside the kernel ie. userspace and it also provides an
296          * interface to feed the driver with information.
297          *
298          * Status: OBSOLETE
299          */
300         int (*show_info)(struct seq_file *, struct Scsi_Host *);
301         int (*write_info)(struct Scsi_Host *, char *, int);
302
303         /*
304          * This is an optional routine that allows the transport to become
305          * involved when a scsi io timer fires. The return value tells the
306          * timer routine how to finish the io timeout handling:
307          * EH_HANDLED:          I fixed the error, please complete the command
308          * EH_RESET_TIMER:      I need more time, reset the timer and
309          *                      begin counting again
310          * EH_DONE:             Begin normal error recovery
311          *
312          * Status: OPTIONAL
313          */
314         enum blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd *);
315
316         /* This is an optional routine that allows transport to initiate
317          * LLD adapter or firmware reset using sysfs attribute.
318          *
319          * Return values: 0 on success, -ve value on failure.
320          *
321          * Status: OPTIONAL
322          */
323
324         int (*host_reset)(struct Scsi_Host *shost, int reset_type);
325 #define SCSI_ADAPTER_RESET      1
326 #define SCSI_FIRMWARE_RESET     2
327
328
329         /*
330          * Name of proc directory
331          */
332         const char *proc_name;
333
334         /*
335          * Used to store the procfs directory if a driver implements the
336          * show_info method.
337          */
338         struct proc_dir_entry *proc_dir;
339
340         /*
341          * This determines if we will use a non-interrupt driven
342          * or an interrupt driven scheme.  It is set to the maximum number
343          * of simultaneous commands a given host adapter will accept.
344          */
345         int can_queue;
346
347         /*
348          * In many instances, especially where disconnect / reconnect are
349          * supported, our host also has an ID on the SCSI bus.  If this is
350          * the case, then it must be reserved.  Please set this_id to -1 if
351          * your setup is in single initiator mode, and the host lacks an
352          * ID.
353          */
354         int this_id;
355
356         /*
357          * This determines the degree to which the host adapter is capable
358          * of scatter-gather.
359          */
360         unsigned short sg_tablesize;
361         unsigned short sg_prot_tablesize;
362
363         /*
364          * Set this if the host adapter has limitations beside segment count.
365          */
366         unsigned int max_sectors;
367
368         /*
369          * DMA scatter gather segment boundary limit. A segment crossing this
370          * boundary will be split in two.
371          */
372         unsigned long dma_boundary;
373
374         /*
375          * This specifies "machine infinity" for host templates which don't
376          * limit the transfer size.  Note this limit represents an absolute
377          * maximum, and may be over the transfer limits allowed for
378          * individual devices (e.g. 256 for SCSI-1).
379          */
380 #define SCSI_DEFAULT_MAX_SECTORS        1024
381
382         /*
383          * True if this host adapter can make good use of linked commands.
384          * This will allow more than one command to be queued to a given
385          * unit on a given host.  Set this to the maximum number of command
386          * blocks to be provided for each device.  Set this to 1 for one
387          * command block per lun, 2 for two, etc.  Do not set this to 0.
388          * You should make sure that the host adapter will do the right thing
389          * before you try setting this above 1.
390          */
391         short cmd_per_lun;
392
393         /*
394          * present contains counter indicating how many boards of this
395          * type were found when we did the scan.
396          */
397         unsigned char present;
398
399         /* If use block layer to manage tags, this is tag allocation policy */
400         int tag_alloc_policy;
401
402         /*
403          * Track QUEUE_FULL events and reduce queue depth on demand.
404          */
405         unsigned track_queue_depth:1;
406
407         /*
408          * This specifies the mode that a LLD supports.
409          */
410         unsigned supported_mode:2;
411
412         /*
413          * True if this host adapter uses unchecked DMA onto an ISA bus.
414          */
415         unsigned unchecked_isa_dma:1;
416
417         /*
418          * True if this host adapter can make good use of clustering.
419          * I originally thought that if the tablesize was large that it
420          * was a waste of CPU cycles to prepare a cluster list, but
421          * it works out that the Buslogic is faster if you use a smaller
422          * number of segments (i.e. use clustering).  I guess it is
423          * inefficient.
424          */
425         unsigned use_clustering:1;
426
427         /*
428          * True for emulated SCSI host adapters (e.g. ATAPI).
429          */
430         unsigned emulated:1;
431
432         /*
433          * True if the low-level driver performs its own reset-settle delays.
434          */
435         unsigned skip_settle_delay:1;
436
437         /* True if the controller does not support WRITE SAME */
438         unsigned no_write_same:1;
439
440         /* True if the low-level driver supports blk-mq only */
441         unsigned force_blk_mq:1;
442
443         /*
444          * Countdown for host blocking with no commands outstanding.
445          */
446         unsigned int max_host_blocked;
447
448         /*
449          * Default value for the blocking.  If the queue is empty,
450          * host_blocked counts down in the request_fn until it restarts
451          * host operations as zero is reached.  
452          *
453          * FIXME: This should probably be a value in the template
454          */
455 #define SCSI_DEFAULT_HOST_BLOCKED       7
456
457         /*
458          * Pointer to the sysfs class properties for this host, NULL terminated.
459          */
460         struct device_attribute **shost_attrs;
461
462         /*
463          * Pointer to the SCSI device properties for this host, NULL terminated.
464          */
465         struct device_attribute **sdev_attrs;
466
467         /*
468          * Pointer to the SCSI device attribute groups for this host,
469          * NULL terminated.
470          */
471         const struct attribute_group **sdev_groups;
472
473         /*
474          * Vendor Identifier associated with the host
475          *
476          * Note: When specifying vendor_id, be sure to read the
477          *   Vendor Type and ID formatting requirements specified in
478          *   scsi_netlink.h
479          */
480         u64 vendor_id;
481
482         /*
483          * Additional per-command data allocated for the driver.
484          */
485         unsigned int cmd_size;
486         struct scsi_host_cmd_pool *cmd_pool;
487 };
488
489 /*
490  * Temporary #define for host lock push down. Can be removed when all
491  * drivers have been updated to take advantage of unlocked
492  * queuecommand.
493  *
494  */
495 #define DEF_SCSI_QCMD(func_name) \
496         int func_name(struct Scsi_Host *shost, struct scsi_cmnd *cmd)   \
497         {                                                               \
498                 unsigned long irq_flags;                                \
499                 int rc;                                                 \
500                 spin_lock_irqsave(shost->host_lock, irq_flags);         \
501                 scsi_cmd_get_serial(shost, cmd);                        \
502                 rc = func_name##_lck (cmd, cmd->scsi_done);                     \
503                 spin_unlock_irqrestore(shost->host_lock, irq_flags);    \
504                 return rc;                                              \
505         }
506
507
508 /*
509  * shost state: If you alter this, you also need to alter scsi_sysfs.c
510  * (for the ascii descriptions) and the state model enforcer:
511  * scsi_host_set_state()
512  */
513 enum scsi_host_state {
514         SHOST_CREATED = 1,
515         SHOST_RUNNING,
516         SHOST_CANCEL,
517         SHOST_DEL,
518         SHOST_RECOVERY,
519         SHOST_CANCEL_RECOVERY,
520         SHOST_DEL_RECOVERY,
521 };
522
523 struct Scsi_Host {
524         /*
525          * __devices is protected by the host_lock, but you should
526          * usually use scsi_device_lookup / shost_for_each_device
527          * to access it and don't care about locking yourself.
528          * In the rare case of being in irq context you can use
529          * their __ prefixed variants with the lock held. NEVER
530          * access this list directly from a driver.
531          */
532         struct list_head        __devices;
533         struct list_head        __targets;
534         
535         struct list_head        starved_list;
536
537         spinlock_t              default_lock;
538         spinlock_t              *host_lock;
539
540         struct mutex            scan_mutex;/* serialize scanning activity */
541
542         struct list_head        eh_cmd_q;
543         struct task_struct    * ehandler;  /* Error recovery thread. */
544         struct completion     * eh_action; /* Wait for specific actions on the
545                                               host. */
546         wait_queue_head_t       host_wait;
547         struct scsi_host_template *hostt;
548         struct scsi_transport_template *transportt;
549
550         /*
551          * Area to keep a shared tag map (if needed, will be
552          * NULL if not).
553          */
554         union {
555                 struct blk_queue_tag    *bqt;
556                 struct blk_mq_tag_set   tag_set;
557         };
558
559         atomic_t host_busy;                /* commands actually active on low-level */
560         atomic_t host_blocked;
561
562         unsigned int host_failed;          /* commands that failed.
563                                               protected by host_lock */
564         unsigned int host_eh_scheduled;    /* EH scheduled without command */
565     
566         unsigned int host_no;  /* Used for IOCTL_GET_IDLUN, /proc/scsi et al. */
567
568         /* next two fields are used to bound the time spent in error handling */
569         int eh_deadline;
570         unsigned long last_reset;
571
572
573         /*
574          * These three parameters can be used to allow for wide scsi,
575          * and for host adapters that support multiple busses
576          * The last two should be set to 1 more than the actual max id
577          * or lun (e.g. 8 for SCSI parallel systems).
578          */
579         unsigned int max_channel;
580         unsigned int max_id;
581         u64 max_lun;
582
583         /*
584          * This is a unique identifier that must be assigned so that we
585          * have some way of identifying each detected host adapter properly
586          * and uniquely.  For hosts that do not support more than one card
587          * in the system at one time, this does not need to be set.  It is
588          * initialized to 0 in scsi_register.
589          */
590         unsigned int unique_id;
591
592         /*
593          * The maximum length of SCSI commands that this host can accept.
594          * Probably 12 for most host adapters, but could be 16 for others.
595          * or 260 if the driver supports variable length cdbs.
596          * For drivers that don't set this field, a value of 12 is
597          * assumed.
598          */
599         unsigned short max_cmd_len;
600
601         int this_id;
602         int can_queue;
603         short cmd_per_lun;
604         short unsigned int sg_tablesize;
605         short unsigned int sg_prot_tablesize;
606         unsigned int max_sectors;
607         unsigned long dma_boundary;
608         /*
609          * In scsi-mq mode, the number of hardware queues supported by the LLD.
610          *
611          * Note: it is assumed that each hardware queue has a queue depth of
612          * can_queue. In other words, the total queue depth per host
613          * is nr_hw_queues * can_queue.
614          */
615         unsigned nr_hw_queues;
616         /* 
617          * Used to assign serial numbers to the cmds.
618          * Protected by the host lock.
619          */
620         unsigned long cmd_serial_number;
621         
622         unsigned active_mode:2;
623         unsigned unchecked_isa_dma:1;
624         unsigned use_clustering:1;
625
626         /*
627          * Host has requested that no further requests come through for the
628          * time being.
629          */
630         unsigned host_self_blocked:1;
631     
632         /*
633          * Host uses correct SCSI ordering not PC ordering. The bit is
634          * set for the minority of drivers whose authors actually read
635          * the spec ;).
636          */
637         unsigned reverse_ordering:1;
638
639         /* Task mgmt function in progress */
640         unsigned tmf_in_progress:1;
641
642         /* Asynchronous scan in progress */
643         unsigned async_scan:1;
644
645         /* Don't resume host in EH */
646         unsigned eh_noresume:1;
647
648         /* The controller does not support WRITE SAME */
649         unsigned no_write_same:1;
650
651         unsigned use_blk_mq:1;
652         unsigned use_cmd_list:1;
653
654         /* Host responded with short (<36 bytes) INQUIRY result */
655         unsigned short_inquiry:1;
656
657         /*
658          * Optional work queue to be utilized by the transport
659          */
660         char work_q_name[20];
661         struct workqueue_struct *work_q;
662
663         /*
664          * Task management function work queue
665          */
666         struct workqueue_struct *tmf_work_q;
667
668         /* The transport requires the LUN bits NOT to be stored in CDB[1] */
669         unsigned no_scsi2_lun_in_cdb:1;
670
671         /*
672          * Value host_blocked counts down from
673          */
674         unsigned int max_host_blocked;
675
676         /* Protection Information */
677         unsigned int prot_capabilities;
678         unsigned char prot_guard_type;
679
680         /* legacy crap */
681         unsigned long base;
682         unsigned long io_port;
683         unsigned char n_io_port;
684         unsigned char dma_channel;
685         unsigned int  irq;
686         
687
688         enum scsi_host_state shost_state;
689
690         /* ldm bits */
691         struct device           shost_gendev, shost_dev;
692
693         /*
694          * Points to the transport data (if any) which is allocated
695          * separately
696          */
697         void *shost_data;
698
699         /*
700          * Points to the physical bus device we'd use to do DMA
701          * Needed just in case we have virtual hosts.
702          */
703         struct device *dma_dev;
704
705         /*
706          * We should ensure that this is aligned, both for better performance
707          * and also because some compilers (m68k) don't automatically force
708          * alignment to a long boundary.
709          */
710         unsigned long hostdata[0]  /* Used for storage of host specific stuff */
711                 __attribute__ ((aligned (sizeof(unsigned long))));
712 };
713
714 #define         class_to_shost(d)       \
715         container_of(d, struct Scsi_Host, shost_dev)
716
717 #define shost_printk(prefix, shost, fmt, a...)  \
718         dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a)
719
720 static inline void *shost_priv(struct Scsi_Host *shost)
721 {
722         return (void *)shost->hostdata;
723 }
724
725 int scsi_is_host_device(const struct device *);
726
727 static inline struct Scsi_Host *dev_to_shost(struct device *dev)
728 {
729         while (!scsi_is_host_device(dev)) {
730                 if (!dev->parent)
731                         return NULL;
732                 dev = dev->parent;
733         }
734         return container_of(dev, struct Scsi_Host, shost_gendev);
735 }
736
737 static inline int scsi_host_in_recovery(struct Scsi_Host *shost)
738 {
739         return shost->shost_state == SHOST_RECOVERY ||
740                 shost->shost_state == SHOST_CANCEL_RECOVERY ||
741                 shost->shost_state == SHOST_DEL_RECOVERY ||
742                 shost->tmf_in_progress;
743 }
744
745 static inline bool shost_use_blk_mq(struct Scsi_Host *shost)
746 {
747         return shost->use_blk_mq;
748 }
749
750 extern int scsi_queue_work(struct Scsi_Host *, struct work_struct *);
751 extern void scsi_flush_work(struct Scsi_Host *);
752
753 extern struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *, int);
754 extern int __must_check scsi_add_host_with_dma(struct Scsi_Host *,
755                                                struct device *,
756                                                struct device *);
757 extern void scsi_scan_host(struct Scsi_Host *);
758 extern void scsi_rescan_device(struct device *);
759 extern void scsi_remove_host(struct Scsi_Host *);
760 extern struct Scsi_Host *scsi_host_get(struct Scsi_Host *);
761 extern int scsi_host_busy(struct Scsi_Host *shost);
762 extern void scsi_host_put(struct Scsi_Host *t);
763 extern struct Scsi_Host *scsi_host_lookup(unsigned short);
764 extern const char *scsi_host_state_name(enum scsi_host_state);
765 extern void scsi_cmd_get_serial(struct Scsi_Host *, struct scsi_cmnd *);
766
767 static inline int __must_check scsi_add_host(struct Scsi_Host *host,
768                                              struct device *dev)
769 {
770         return scsi_add_host_with_dma(host, dev, dev);
771 }
772
773 static inline struct device *scsi_get_device(struct Scsi_Host *shost)
774 {
775         return shost->shost_gendev.parent;
776 }
777
778 /**
779  * scsi_host_scan_allowed - Is scanning of this host allowed
780  * @shost:      Pointer to Scsi_Host.
781  **/
782 static inline int scsi_host_scan_allowed(struct Scsi_Host *shost)
783 {
784         return shost->shost_state == SHOST_RUNNING ||
785                shost->shost_state == SHOST_RECOVERY;
786 }
787
788 extern void scsi_unblock_requests(struct Scsi_Host *);
789 extern void scsi_block_requests(struct Scsi_Host *);
790
791 struct class_container;
792
793 /*
794  * These two functions are used to allocate and free a pseudo device
795  * which will connect to the host adapter itself rather than any
796  * physical device.  You must deallocate when you are done with the
797  * thing.  This physical pseudo-device isn't real and won't be available
798  * from any high-level drivers.
799  */
800 extern void scsi_free_host_dev(struct scsi_device *);
801 extern struct scsi_device *scsi_get_host_dev(struct Scsi_Host *);
802
803 /*
804  * DIF defines the exchange of protection information between
805  * initiator and SBC block device.
806  *
807  * DIX defines the exchange of protection information between OS and
808  * initiator.
809  */
810 enum scsi_host_prot_capabilities {
811         SHOST_DIF_TYPE1_PROTECTION = 1 << 0, /* T10 DIF Type 1 */
812         SHOST_DIF_TYPE2_PROTECTION = 1 << 1, /* T10 DIF Type 2 */
813         SHOST_DIF_TYPE3_PROTECTION = 1 << 2, /* T10 DIF Type 3 */
814
815         SHOST_DIX_TYPE0_PROTECTION = 1 << 3, /* DIX between OS and HBA only */
816         SHOST_DIX_TYPE1_PROTECTION = 1 << 4, /* DIX with DIF Type 1 */
817         SHOST_DIX_TYPE2_PROTECTION = 1 << 5, /* DIX with DIF Type 2 */
818         SHOST_DIX_TYPE3_PROTECTION = 1 << 6, /* DIX with DIF Type 3 */
819 };
820
821 /*
822  * SCSI hosts which support the Data Integrity Extensions must
823  * indicate their capabilities by setting the prot_capabilities using
824  * this call.
825  */
826 static inline void scsi_host_set_prot(struct Scsi_Host *shost, unsigned int mask)
827 {
828         shost->prot_capabilities = mask;
829 }
830
831 static inline unsigned int scsi_host_get_prot(struct Scsi_Host *shost)
832 {
833         return shost->prot_capabilities;
834 }
835
836 static inline int scsi_host_prot_dma(struct Scsi_Host *shost)
837 {
838         return shost->prot_capabilities >= SHOST_DIX_TYPE0_PROTECTION;
839 }
840
841 static inline unsigned int scsi_host_dif_capable(struct Scsi_Host *shost, unsigned int target_type)
842 {
843         static unsigned char cap[] = { 0,
844                                        SHOST_DIF_TYPE1_PROTECTION,
845                                        SHOST_DIF_TYPE2_PROTECTION,
846                                        SHOST_DIF_TYPE3_PROTECTION };
847
848         if (target_type >= ARRAY_SIZE(cap))
849                 return 0;
850
851         return shost->prot_capabilities & cap[target_type] ? target_type : 0;
852 }
853
854 static inline unsigned int scsi_host_dix_capable(struct Scsi_Host *shost, unsigned int target_type)
855 {
856 #if defined(CONFIG_BLK_DEV_INTEGRITY)
857         static unsigned char cap[] = { SHOST_DIX_TYPE0_PROTECTION,
858                                        SHOST_DIX_TYPE1_PROTECTION,
859                                        SHOST_DIX_TYPE2_PROTECTION,
860                                        SHOST_DIX_TYPE3_PROTECTION };
861
862         if (target_type >= ARRAY_SIZE(cap))
863                 return 0;
864
865         return shost->prot_capabilities & cap[target_type];
866 #endif
867         return 0;
868 }
869
870 /*
871  * All DIX-capable initiators must support the T10-mandated CRC
872  * checksum.  Controllers can optionally implement the IP checksum
873  * scheme which has much lower impact on system performance.  Note
874  * that the main rationale for the checksum is to match integrity
875  * metadata with data.  Detecting bit errors are a job for ECC memory
876  * and buses.
877  */
878
879 enum scsi_host_guard_type {
880         SHOST_DIX_GUARD_CRC = 1 << 0,
881         SHOST_DIX_GUARD_IP  = 1 << 1,
882 };
883
884 static inline void scsi_host_set_guard(struct Scsi_Host *shost, unsigned char type)
885 {
886         shost->prot_guard_type = type;
887 }
888
889 static inline unsigned char scsi_host_get_guard(struct Scsi_Host *shost)
890 {
891         return shost->prot_guard_type;
892 }
893
894 extern int scsi_host_set_state(struct Scsi_Host *, enum scsi_host_state);
895
896 #endif /* _SCSI_SCSI_HOST_H */