linux/include/scsi/scsi_host.h
<<
>>
Prefs
   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 <linux/seq_file.h>
  10#include <scsi/scsi.h>
  11
  12struct request_queue;
  13struct block_device;
  14struct completion;
  15struct module;
  16struct scsi_cmnd;
  17struct scsi_device;
  18struct scsi_target;
  19struct Scsi_Host;
  20struct scsi_host_cmd_pool;
  21struct scsi_transport_template;
  22struct blk_queue_tags;
  23
  24
  25/*
  26 * The various choices mean:
  27 * NONE: Self evident.  Host adapter is not capable of scatter-gather.
  28 * ALL:  Means that the host adapter module can do scatter-gather,
  29 *       and that there is no limit to the size of the table to which
  30 *       we scatter/gather data.  The value we set here is the maximum
  31 *       single element sglist.  To use chained sglists, the adapter
  32 *       has to set a value beyond ALL (and correctly use the chain
  33 *       handling API.
  34 * Anything else:  Indicates the maximum number of chains that can be
  35 *       used in one scatter-gather request.
  36 */
  37#define SG_NONE 0
  38#define SG_ALL  SCSI_MAX_SG_SEGMENTS
  39
  40#define MODE_UNKNOWN 0x00
  41#define MODE_INITIATOR 0x01
  42#define MODE_TARGET 0x02
  43
  44#define DISABLE_CLUSTERING 0
  45#define ENABLE_CLUSTERING 1
  46
  47enum {
  48        SCSI_QDEPTH_DEFAULT,    /* default requested change, e.g. from sysfs */
  49        SCSI_QDEPTH_QFULL,      /* scsi-ml requested due to queue full */
  50        SCSI_QDEPTH_RAMP_UP,    /* scsi-ml requested due to threshold event */
  51};
  52
  53struct scsi_host_template {
  54        struct module *module;
  55        const char *name;
  56
  57        /*
  58         * Used to initialize old-style drivers.  For new-style drivers
  59         * just perform all work in your module initialization function.
  60         *
  61         * Status:  OBSOLETE
  62         */
  63        int (* detect)(struct scsi_host_template *);
  64
  65        /*
  66         * Used as unload callback for hosts with old-style drivers.
  67         *
  68         * Status: OBSOLETE
  69         */
  70        int (* release)(struct Scsi_Host *);
  71
  72        /*
  73         * The info function will return whatever useful information the
  74         * developer sees fit.  If not provided, then the name field will
  75         * be used instead.
  76         *
  77         * Status: OPTIONAL
  78         */
  79        const char *(* info)(struct Scsi_Host *);
  80
  81        /*
  82         * Ioctl interface
  83         *
  84         * Status: OPTIONAL
  85         */
  86        int (* ioctl)(struct scsi_device *dev, int cmd, void __user *arg);
  87
  88
  89#ifdef CONFIG_COMPAT
  90        /* 
  91         * Compat handler. Handle 32bit ABI.
  92         * When unknown ioctl is passed return -ENOIOCTLCMD.
  93         *
  94         * Status: OPTIONAL
  95         */
  96        int (* compat_ioctl)(struct scsi_device *dev, int cmd, void __user *arg);
  97#endif
  98
  99        /*
 100         * The queuecommand function is used to queue up a scsi
 101         * command block to the LLDD.  When the driver finished
 102         * processing the command the done callback is invoked.
 103         *
 104         * If queuecommand returns 0, then the HBA has accepted the
 105         * command.  The done() function must be called on the command
 106         * when the driver has finished with it. (you may call done on the
 107         * command before queuecommand returns, but in this case you
 108         * *must* return 0 from queuecommand).
 109         *
 110         * Queuecommand may also reject the command, in which case it may
 111         * not touch the command and must not call done() for it.
 112         *
 113         * There are two possible rejection returns:
 114         *
 115         *   SCSI_MLQUEUE_DEVICE_BUSY: Block this device temporarily, but
 116         *   allow commands to other devices serviced by this host.
 117         *
 118         *   SCSI_MLQUEUE_HOST_BUSY: Block all devices served by this
 119         *   host temporarily.
 120         *
 121         * For compatibility, any other non-zero return is treated the
 122         * same as SCSI_MLQUEUE_HOST_BUSY.
 123         *
 124         * NOTE: "temporarily" means either until the next command for#
 125         * this device/host completes, or a period of time determined by
 126         * I/O pressure in the system if there are no other outstanding
 127         * commands.
 128         *
 129         * STATUS: REQUIRED
 130         */
 131        int (* queuecommand)(struct Scsi_Host *, 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         * This function is called when one or more partitions on the
 331         * device reach beyond the end of the device.
 332         *
 333         * Status: OPTIONAL
 334         */
 335        void (*unlock_native_capacity)(struct scsi_device *);
 336
 337        /*
 338         * Can be used to export driver statistics and other infos to the
 339         * world outside the kernel ie. userspace and it also provides an
 340         * interface to feed the driver with information.
 341         *
 342         * Status: OBSOLETE
 343         */
 344        int (*show_info)(struct seq_file *, struct Scsi_Host *);
 345        int (*write_info)(struct Scsi_Host *, char *, int);
 346
 347        /*
 348         * This is an optional routine that allows the transport to become
 349         * involved when a scsi io timer fires. The return value tells the
 350         * timer routine how to finish the io timeout handling:
 351         * EH_HANDLED:          I fixed the error, please complete the command
 352         * EH_RESET_TIMER:      I need more time, reset the timer and
 353         *                      begin counting again
 354         * EH_NOT_HANDLED       Begin normal error recovery
 355         *
 356         * Status: OPTIONAL
 357         */
 358        enum blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd *);
 359
 360        /* This is an optional routine that allows transport to initiate
 361         * LLD adapter or firmware reset using sysfs attribute.
 362         *
 363         * Return values: 0 on success, -ve value on failure.
 364         *
 365         * Status: OPTIONAL
 366         */
 367
 368        int (*host_reset)(struct Scsi_Host *shost, int reset_type);
 369#define SCSI_ADAPTER_RESET      1
 370#define SCSI_FIRMWARE_RESET     2
 371
 372
 373        /*
 374         * Name of proc directory
 375         */
 376        const char *proc_name;
 377
 378        /*
 379         * Used to store the procfs directory if a driver implements the
 380         * show_info method.
 381         */
 382        struct proc_dir_entry *proc_dir;
 383
 384        /*
 385         * This determines if we will use a non-interrupt driven
 386         * or an interrupt driven scheme.  It is set to the maximum number
 387         * of simultaneous commands a given host adapter will accept.
 388         */
 389        int can_queue;
 390
 391        /*
 392         * In many instances, especially where disconnect / reconnect are
 393         * supported, our host also has an ID on the SCSI bus.  If this is
 394         * the case, then it must be reserved.  Please set this_id to -1 if
 395         * your setup is in single initiator mode, and the host lacks an
 396         * ID.
 397         */
 398        int this_id;
 399
 400        /*
 401         * This determines the degree to which the host adapter is capable
 402         * of scatter-gather.
 403         */
 404        unsigned short sg_tablesize;
 405        unsigned short sg_prot_tablesize;
 406
 407        /*
 408         * Set this if the host adapter has limitations beside segment count.
 409         */
 410        unsigned short max_sectors;
 411
 412        /*
 413         * DMA scatter gather segment boundary limit. A segment crossing this
 414         * boundary will be split in two.
 415         */
 416        unsigned long dma_boundary;
 417
 418        /*
 419         * This specifies "machine infinity" for host templates which don't
 420         * limit the transfer size.  Note this limit represents an absolute
 421         * maximum, and may be over the transfer limits allowed for
 422         * individual devices (e.g. 256 for SCSI-1).
 423         */
 424#define SCSI_DEFAULT_MAX_SECTORS        1024
 425
 426        /*
 427         * True if this host adapter can make good use of linked commands.
 428         * This will allow more than one command to be queued to a given
 429         * unit on a given host.  Set this to the maximum number of command
 430         * blocks to be provided for each device.  Set this to 1 for one
 431         * command block per lun, 2 for two, etc.  Do not set this to 0.
 432         * You should make sure that the host adapter will do the right thing
 433         * before you try setting this above 1.
 434         */
 435        short cmd_per_lun;
 436
 437        /*
 438         * present contains counter indicating how many boards of this
 439         * type were found when we did the scan.
 440         */
 441        unsigned char present;
 442
 443        /*
 444         * This specifies the mode that a LLD supports.
 445         */
 446        unsigned supported_mode:2;
 447
 448        /*
 449         * True if this host adapter uses unchecked DMA onto an ISA bus.
 450         */
 451        unsigned unchecked_isa_dma:1;
 452
 453        /*
 454         * True if this host adapter can make good use of clustering.
 455         * I originally thought that if the tablesize was large that it
 456         * was a waste of CPU cycles to prepare a cluster list, but
 457         * it works out that the Buslogic is faster if you use a smaller
 458         * number of segments (i.e. use clustering).  I guess it is
 459         * inefficient.
 460         */
 461        unsigned use_clustering:1;
 462
 463        /*
 464         * True for emulated SCSI host adapters (e.g. ATAPI).
 465         */
 466        unsigned emulated:1;
 467
 468        /*
 469         * True if the low-level driver performs its own reset-settle delays.
 470         */
 471        unsigned skip_settle_delay:1;
 472
 473        /*
 474         * True if we are using ordered write support.
 475         */
 476        unsigned ordered_tag:1;
 477
 478        /*
 479         * Countdown for host blocking with no commands outstanding.
 480         */
 481        unsigned int max_host_blocked;
 482
 483        /*
 484         * Default value for the blocking.  If the queue is empty,
 485         * host_blocked counts down in the request_fn until it restarts
 486         * host operations as zero is reached.  
 487         *
 488         * FIXME: This should probably be a value in the template
 489         */
 490#define SCSI_DEFAULT_HOST_BLOCKED       7
 491
 492        /*
 493         * Pointer to the sysfs class properties for this host, NULL terminated.
 494         */
 495        struct device_attribute **shost_attrs;
 496
 497        /*
 498         * Pointer to the SCSI device properties for this host, NULL terminated.
 499         */
 500        struct device_attribute **sdev_attrs;
 501
 502        /*
 503         * List of hosts per template.
 504         *
 505         * This is only for use by scsi_module.c for legacy templates.
 506         * For these access to it is synchronized implicitly by
 507         * module_init/module_exit.
 508         */
 509        struct list_head legacy_hosts;
 510
 511        /*
 512         * Vendor Identifier associated with the host
 513         *
 514         * Note: When specifying vendor_id, be sure to read the
 515         *   Vendor Type and ID formatting requirements specified in
 516         *   scsi_netlink.h
 517         */
 518        u64 vendor_id;
 519};
 520
 521/*
 522 * Temporary #define for host lock push down. Can be removed when all
 523 * drivers have been updated to take advantage of unlocked
 524 * queuecommand.
 525 *
 526 */
 527#define DEF_SCSI_QCMD(func_name) \
 528        int func_name(struct Scsi_Host *shost, struct scsi_cmnd *cmd)   \
 529        {                                                               \
 530                unsigned long irq_flags;                                \
 531                int rc;                                                 \
 532                spin_lock_irqsave(shost->host_lock, irq_flags);         \
 533                scsi_cmd_get_serial(shost, cmd);                        \
 534                rc = func_name##_lck (cmd, cmd->scsi_done);                     \
 535                spin_unlock_irqrestore(shost->host_lock, irq_flags);    \
 536                return rc;                                              \
 537        }
 538
 539
 540/*
 541 * shost state: If you alter this, you also need to alter scsi_sysfs.c
 542 * (for the ascii descriptions) and the state model enforcer:
 543 * scsi_host_set_state()
 544 */
 545enum scsi_host_state {
 546        SHOST_CREATED = 1,
 547        SHOST_RUNNING,
 548        SHOST_CANCEL,
 549        SHOST_DEL,
 550        SHOST_RECOVERY,
 551        SHOST_CANCEL_RECOVERY,
 552        SHOST_DEL_RECOVERY,
 553};
 554
 555struct Scsi_Host {
 556        /*
 557         * __devices is protected by the host_lock, but you should
 558         * usually use scsi_device_lookup / shost_for_each_device
 559         * to access it and don't care about locking yourself.
 560         * In the rare case of beeing in irq context you can use
 561         * their __ prefixed variants with the lock held. NEVER
 562         * access this list directly from a driver.
 563         */
 564        struct list_head        __devices;
 565        struct list_head        __targets;
 566        
 567        struct scsi_host_cmd_pool *cmd_pool;
 568        spinlock_t              free_list_lock;
 569        struct list_head        free_list; /* backup store of cmd structs */
 570        struct list_head        starved_list;
 571
 572        spinlock_t              default_lock;
 573        spinlock_t              *host_lock;
 574
 575        struct mutex            scan_mutex;/* serialize scanning activity */
 576
 577        struct list_head        eh_cmd_q;
 578        struct task_struct    * ehandler;  /* Error recovery thread. */
 579        struct completion     * eh_action; /* Wait for specific actions on the
 580                                              host. */
 581        wait_queue_head_t       host_wait;
 582        struct scsi_host_template *hostt;
 583        struct scsi_transport_template *transportt;
 584
 585        /*
 586         * Area to keep a shared tag map (if needed, will be
 587         * NULL if not).
 588         */
 589        struct blk_queue_tag    *bqt;
 590
 591        /*
 592         * The following two fields are protected with host_lock;
 593         * however, eh routines can safely access during eh processing
 594         * without acquiring the lock.
 595         */
 596        unsigned int host_busy;            /* commands actually active on low-level */
 597        unsigned int host_failed;          /* commands that failed. */
 598        unsigned int host_eh_scheduled;    /* EH scheduled without command */
 599    
 600        unsigned int host_no;  /* Used for IOCTL_GET_IDLUN, /proc/scsi et al. */
 601        int resetting; /* if set, it means that last_reset is a valid value */
 602        unsigned long last_reset;
 603
 604        /*
 605         * These three parameters can be used to allow for wide scsi,
 606         * and for host adapters that support multiple busses
 607         * The first two should be set to 1 more than the actual max id
 608         * or lun (i.e. 8 for normal systems).
 609         */
 610        unsigned int max_id;
 611        unsigned int max_lun;
 612        unsigned int max_channel;
 613
 614        /*
 615         * This is a unique identifier that must be assigned so that we
 616         * have some way of identifying each detected host adapter properly
 617         * and uniquely.  For hosts that do not support more than one card
 618         * in the system at one time, this does not need to be set.  It is
 619         * initialized to 0 in scsi_register.
 620         */
 621        unsigned int unique_id;
 622
 623        /*
 624         * The maximum length of SCSI commands that this host can accept.
 625         * Probably 12 for most host adapters, but could be 16 for others.
 626         * or 260 if the driver supports variable length cdbs.
 627         * For drivers that don't set this field, a value of 12 is
 628         * assumed.
 629         */
 630        unsigned short max_cmd_len;
 631
 632        int this_id;
 633        int can_queue;
 634        short cmd_per_lun;
 635        short unsigned int sg_tablesize;
 636        short unsigned int sg_prot_tablesize;
 637        short unsigned int max_sectors;
 638        unsigned long dma_boundary;
 639        /* 
 640         * Used to assign serial numbers to the cmds.
 641         * Protected by the host lock.
 642         */
 643        unsigned long cmd_serial_number;
 644        
 645        unsigned active_mode:2;
 646        unsigned unchecked_isa_dma:1;
 647        unsigned use_clustering:1;
 648        unsigned use_blk_tcq:1;
 649
 650        /*
 651         * Host has requested that no further requests come through for the
 652         * time being.
 653         */
 654        unsigned host_self_blocked:1;
 655    
 656        /*
 657         * Host uses correct SCSI ordering not PC ordering. The bit is
 658         * set for the minority of drivers whose authors actually read
 659         * the spec ;).
 660         */
 661        unsigned reverse_ordering:1;
 662
 663        /*
 664         * Ordered write support
 665         */
 666        unsigned ordered_tag:1;
 667
 668        /* Task mgmt function in progress */
 669        unsigned tmf_in_progress:1;
 670
 671        /* Asynchronous scan in progress */
 672        unsigned async_scan:1;
 673
 674        /* Don't resume host in EH */
 675        unsigned eh_noresume:1;
 676
 677        /*
 678         * Optional work queue to be utilized by the transport
 679         */
 680        char work_q_name[20];
 681        struct workqueue_struct *work_q;
 682
 683        /*
 684         * Host has rejected a command because it was busy.
 685         */
 686        unsigned int host_blocked;
 687
 688        /*
 689         * Value host_blocked counts down from
 690         */
 691        unsigned int max_host_blocked;
 692
 693        /* Protection Information */
 694        unsigned int prot_capabilities;
 695        unsigned char prot_guard_type;
 696
 697        /*
 698         * q used for scsi_tgt msgs, async events or any other requests that
 699         * need to be processed in userspace
 700         */
 701        struct request_queue *uspace_req_q;
 702
 703        /* legacy crap */
 704        unsigned long base;
 705        unsigned long io_port;
 706        unsigned char n_io_port;
 707        unsigned char dma_channel;
 708        unsigned int  irq;
 709        
 710
 711        enum scsi_host_state shost_state;
 712
 713        /* ldm bits */
 714        struct device           shost_gendev, shost_dev;
 715
 716        /*
 717         * List of hosts per template.
 718         *
 719         * This is only for use by scsi_module.c for legacy templates.
 720         * For these access to it is synchronized implicitly by
 721         * module_init/module_exit.
 722         */
 723        struct list_head sht_legacy_list;
 724
 725        /*
 726         * Points to the transport data (if any) which is allocated
 727         * separately
 728         */
 729        void *shost_data;
 730
 731        /*
 732         * Points to the physical bus device we'd use to do DMA
 733         * Needed just in case we have virtual hosts.
 734         */
 735        struct device *dma_dev;
 736
 737        /*
 738         * We should ensure that this is aligned, both for better performance
 739         * and also because some compilers (m68k) don't automatically force
 740         * alignment to a long boundary.
 741         */
 742        unsigned long hostdata[0]  /* Used for storage of host specific stuff */
 743                __attribute__ ((aligned (sizeof(unsigned long))));
 744};
 745
 746#define         class_to_shost(d)       \
 747        container_of(d, struct Scsi_Host, shost_dev)
 748
 749#define shost_printk(prefix, shost, fmt, a...)  \
 750        dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a)
 751
 752static inline void *shost_priv(struct Scsi_Host *shost)
 753{
 754        return (void *)shost->hostdata;
 755}
 756
 757int scsi_is_host_device(const struct device *);
 758
 759static inline struct Scsi_Host *dev_to_shost(struct device *dev)
 760{
 761        while (!scsi_is_host_device(dev)) {
 762                if (!dev->parent)
 763                        return NULL;
 764                dev = dev->parent;
 765        }
 766        return container_of(dev, struct Scsi_Host, shost_gendev);
 767}
 768
 769static inline int scsi_host_in_recovery(struct Scsi_Host *shost)
 770{
 771        return shost->shost_state == SHOST_RECOVERY ||
 772                shost->shost_state == SHOST_CANCEL_RECOVERY ||
 773                shost->shost_state == SHOST_DEL_RECOVERY ||
 774                shost->tmf_in_progress;
 775}
 776
 777extern int scsi_queue_work(struct Scsi_Host *, struct work_struct *);
 778extern void scsi_flush_work(struct Scsi_Host *);
 779
 780extern struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *, int);
 781extern int __must_check scsi_add_host_with_dma(struct Scsi_Host *,
 782                                               struct device *,
 783                                               struct device *);
 784extern void scsi_scan_host(struct Scsi_Host *);
 785extern void scsi_rescan_device(struct device *);
 786extern void scsi_remove_host(struct Scsi_Host *);
 787extern struct Scsi_Host *scsi_host_get(struct Scsi_Host *);
 788extern void scsi_host_put(struct Scsi_Host *t);
 789extern struct Scsi_Host *scsi_host_lookup(unsigned short);
 790extern const char *scsi_host_state_name(enum scsi_host_state);
 791extern void scsi_cmd_get_serial(struct Scsi_Host *, struct scsi_cmnd *);
 792
 793extern u64 scsi_calculate_bounce_limit(struct Scsi_Host *);
 794
 795static inline int __must_check scsi_add_host(struct Scsi_Host *host,
 796                                             struct device *dev)
 797{
 798        return scsi_add_host_with_dma(host, dev, dev);
 799}
 800
 801static inline struct device *scsi_get_device(struct Scsi_Host *shost)
 802{
 803        return shost->shost_gendev.parent;
 804}
 805
 806/**
 807 * scsi_host_scan_allowed - Is scanning of this host allowed
 808 * @shost:      Pointer to Scsi_Host.
 809 **/
 810static inline int scsi_host_scan_allowed(struct Scsi_Host *shost)
 811{
 812        return shost->shost_state == SHOST_RUNNING ||
 813               shost->shost_state == SHOST_RECOVERY;
 814}
 815
 816extern void scsi_unblock_requests(struct Scsi_Host *);
 817extern void scsi_block_requests(struct Scsi_Host *);
 818
 819struct class_container;
 820
 821extern struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
 822                                                void (*) (struct request_queue *));
 823/*
 824 * These two functions are used to allocate and free a pseudo device
 825 * which will connect to the host adapter itself rather than any
 826 * physical device.  You must deallocate when you are done with the
 827 * thing.  This physical pseudo-device isn't real and won't be available
 828 * from any high-level drivers.
 829 */
 830extern void scsi_free_host_dev(struct scsi_device *);
 831extern struct scsi_device *scsi_get_host_dev(struct Scsi_Host *);
 832
 833/*
 834 * DIF defines the exchange of protection information between
 835 * initiator and SBC block device.
 836 *
 837 * DIX defines the exchange of protection information between OS and
 838 * initiator.
 839 */
 840enum scsi_host_prot_capabilities {
 841        SHOST_DIF_TYPE1_PROTECTION = 1 << 0, /* T10 DIF Type 1 */
 842        SHOST_DIF_TYPE2_PROTECTION = 1 << 1, /* T10 DIF Type 2 */
 843        SHOST_DIF_TYPE3_PROTECTION = 1 << 2, /* T10 DIF Type 3 */
 844
 845        SHOST_DIX_TYPE0_PROTECTION = 1 << 3, /* DIX between OS and HBA only */
 846        SHOST_DIX_TYPE1_PROTECTION = 1 << 4, /* DIX with DIF Type 1 */
 847        SHOST_DIX_TYPE2_PROTECTION = 1 << 5, /* DIX with DIF Type 2 */
 848        SHOST_DIX_TYPE3_PROTECTION = 1 << 6, /* DIX with DIF Type 3 */
 849};
 850
 851/*
 852 * SCSI hosts which support the Data Integrity Extensions must
 853 * indicate their capabilities by setting the prot_capabilities using
 854 * this call.
 855 */
 856static inline void scsi_host_set_prot(struct Scsi_Host *shost, unsigned int mask)
 857{
 858        shost->prot_capabilities = mask;
 859}
 860
 861static inline unsigned int scsi_host_get_prot(struct Scsi_Host *shost)
 862{
 863        return shost->prot_capabilities;
 864}
 865
 866static inline int scsi_host_prot_dma(struct Scsi_Host *shost)
 867{
 868        return shost->prot_capabilities >= SHOST_DIX_TYPE0_PROTECTION;
 869}
 870
 871static inline unsigned int scsi_host_dif_capable(struct Scsi_Host *shost, unsigned int target_type)
 872{
 873        static unsigned char cap[] = { 0,
 874                                       SHOST_DIF_TYPE1_PROTECTION,
 875                                       SHOST_DIF_TYPE2_PROTECTION,
 876                                       SHOST_DIF_TYPE3_PROTECTION };
 877
 878        if (target_type >= ARRAY_SIZE(cap))
 879                return 0;
 880
 881        return shost->prot_capabilities & cap[target_type] ? target_type : 0;
 882}
 883
 884static inline unsigned int scsi_host_dix_capable(struct Scsi_Host *shost, unsigned int target_type)
 885{
 886#if defined(CONFIG_BLK_DEV_INTEGRITY)
 887        static unsigned char cap[] = { SHOST_DIX_TYPE0_PROTECTION,
 888                                       SHOST_DIX_TYPE1_PROTECTION,
 889                                       SHOST_DIX_TYPE2_PROTECTION,
 890                                       SHOST_DIX_TYPE3_PROTECTION };
 891
 892        if (target_type >= ARRAY_SIZE(cap))
 893                return 0;
 894
 895        return shost->prot_capabilities & cap[target_type];
 896#endif
 897        return 0;
 898}
 899
 900/*
 901 * All DIX-capable initiators must support the T10-mandated CRC
 902 * checksum.  Controllers can optionally implement the IP checksum
 903 * scheme which has much lower impact on system performance.  Note
 904 * that the main rationale for the checksum is to match integrity
 905 * metadata with data.  Detecting bit errors are a job for ECC memory
 906 * and buses.
 907 */
 908
 909enum scsi_host_guard_type {
 910        SHOST_DIX_GUARD_CRC = 1 << 0,
 911        SHOST_DIX_GUARD_IP  = 1 << 1,
 912};
 913
 914static inline void scsi_host_set_guard(struct Scsi_Host *shost, unsigned char type)
 915{
 916        shost->prot_guard_type = type;
 917}
 918
 919static inline unsigned char scsi_host_get_guard(struct Scsi_Host *shost)
 920{
 921        return shost->prot_guard_type;
 922}
 923
 924/* legacy interfaces */
 925extern struct Scsi_Host *scsi_register(struct scsi_host_template *, int);
 926extern void scsi_unregister(struct Scsi_Host *);
 927extern int scsi_host_set_state(struct Scsi_Host *, enum scsi_host_state);
 928
 929#endif /* _SCSI_SCSI_HOST_H */
 930
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.