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