LCOV - code coverage report
Current view: top level - include/scsi - scsi_host.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 4 4 100.0 %
Date: 2017-01-25 Functions: 1 1 100.0 %

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

Generated by: LCOV version 1.10