| .. SPDX-License-Identifier: GPL-2.0 |
| |
| ============================================= |
| SCSI mid_level - lower_level driver interface |
| ============================================= |
| |
| Introduction |
| ============ |
| This document outlines the interface between the Linux SCSI mid level and |
| SCSI lower level drivers. Lower level drivers (LLDs) are variously called |
| host bus adapter (HBA) drivers and host drivers (HD). A "host" in this |
| context is a bridge between a computer IO bus (e.g. PCI or ISA) and a |
| single SCSI initiator port on a SCSI transport. An "initiator" port |
| (SCSI terminology, see SAM-3 at http://www.t10.org) sends SCSI commands |
| to "target" SCSI ports (e.g. disks). There can be many LLDs in a running |
| system, but only one per hardware type. Most LLDs can control one or more |
| SCSI HBAs. Some HBAs contain multiple hosts. |
| |
| In some cases the SCSI transport is an external bus that already has |
| its own subsystem in Linux (e.g. USB and ieee1394). In such cases the |
| SCSI subsystem LLD is a software bridge to the other driver subsystem. |
| Examples are the usb-storage driver (found in the drivers/usb/storage |
| directory) and the ieee1394/sbp2 driver (found in the drivers/ieee1394 |
| directory). |
| |
| For example, the aic7xxx LLD controls Adaptec SCSI parallel interface |
| (SPI) controllers based on that company's 7xxx chip series. The aic7xxx |
| LLD can be built into the kernel or loaded as a module. There can only be |
| one aic7xxx LLD running in a Linux system but it may be controlling many |
| HBAs. These HBAs might be either on PCI daughter-boards or built into |
| the motherboard (or both). Some aic7xxx based HBAs are dual controllers |
| and thus represent two hosts. Like most modern HBAs, each aic7xxx host |
| has its own PCI device address. [The one-to-one correspondence between |
| a SCSI host and a PCI device is common but not required (e.g. with |
| ISA adapters).] |
| |
| The SCSI mid level isolates an LLD from other layers such as the SCSI |
| upper layer drivers and the block layer. |
| |
| This version of the document roughly matches linux kernel version 2.6.8 . |
| |
| Documentation |
| ============= |
| There is a SCSI documentation directory within the kernel source tree, |
| typically Documentation/scsi . Most documents are in plain |
| (i.e. ASCII) text. This file is named scsi_mid_low_api.txt and can be |
| found in that directory. A more recent copy of this document may be found |
| at http://web.archive.org/web/20070107183357rn_1/sg.torque.net/scsi/. |
| Many LLDs are documented there (e.g. aic7xxx.txt). The SCSI mid-level is |
| briefly described in scsi.txt which contains a url to a document |
| describing the SCSI subsystem in the lk 2.4 series. Two upper level |
| drivers have documents in that directory: st.txt (SCSI tape driver) and |
| scsi-generic.txt (for the sg driver). |
| |
| Some documentation (or urls) for LLDs may be found in the C source code |
| or in the same directory as the C source code. For example to find a url |
| about the USB mass storage driver see the |
| /usr/src/linux/drivers/usb/storage directory. |
| |
| Driver structure |
| ================ |
| Traditionally an LLD for the SCSI subsystem has been at least two files in |
| the drivers/scsi directory. For example, a driver called "xyz" has a header |
| file "xyz.h" and a source file "xyz.c". [Actually there is no good reason |
| why this couldn't all be in one file; the header file is superfluous.] Some |
| drivers that have been ported to several operating systems have more than |
| two files. For example the aic7xxx driver has separate files for generic |
| and OS-specific code (e.g. FreeBSD and Linux). Such drivers tend to have |
| their own directory under the drivers/scsi directory. |
| |
| When a new LLD is being added to Linux, the following files (found in the |
| drivers/scsi directory) will need some attention: Makefile and Kconfig . |
| It is probably best to study how existing LLDs are organized. |
| |
| As the 2.5 series development kernels evolve into the 2.6 series |
| production series, changes are being introduced into this interface. An |
| example of this is driver initialization code where there are now 2 models |
| available. The older one, similar to what was found in the lk 2.4 series, |
| is based on hosts that are detected at HBA driver load time. This will be |
| referred to the "passive" initialization model. The newer model allows HBAs |
| to be hot plugged (and unplugged) during the lifetime of the LLD and will |
| be referred to as the "hotplug" initialization model. The newer model is |
| preferred as it can handle both traditional SCSI equipment that is |
| permanently connected as well as modern "SCSI" devices (e.g. USB or |
| IEEE 1394 connected digital cameras) that are hotplugged. Both |
| initialization models are discussed in the following sections. |
| |
| An LLD interfaces to the SCSI subsystem several ways: |
| |
| a) directly invoking functions supplied by the mid level |
| b) passing a set of function pointers to a registration function |
| supplied by the mid level. The mid level will then invoke these |
| functions at some point in the future. The LLD will supply |
| implementations of these functions. |
| c) direct access to instances of well known data structures maintained |
| by the mid level |
| |
| Those functions in group a) are listed in a section entitled "Mid level |
| supplied functions" below. |
| |
| Those functions in group b) are listed in a section entitled "Interface |
| functions" below. Their function pointers are placed in the members of |
| "struct scsi_host_template", an instance of which is passed to |
| scsi_host_alloc() [#]_. Those interface functions that the LLD does not |
| wish to supply should have NULL placed in the corresponding member of |
| struct scsi_host_template. Defining an instance of struct |
| scsi_host_template at file scope will cause NULL to be placed in function |
| pointer members not explicitly initialized. |
| |
| Those usages in group c) should be handled with care, especially in a |
| "hotplug" environment. LLDs should be aware of the lifetime of instances |
| that are shared with the mid level and other layers. |
| |
| All functions defined within an LLD and all data defined at file scope |
| should be static. For example the slave_alloc() function in an LLD |
| called "xxx" could be defined as |
| ``static int xxx_slave_alloc(struct scsi_device * sdev) { /* code */ }`` |
| |
| .. [#] the scsi_host_alloc() function is a replacement for the rather vaguely |
| named scsi_register() function in most situations. |
| |
| |
| Hotplug initialization model |
| ============================ |
| In this model an LLD controls when SCSI hosts are introduced and removed |
| from the SCSI subsystem. Hosts can be introduced as early as driver |
| initialization and removed as late as driver shutdown. Typically a driver |
| will respond to a sysfs probe() callback that indicates an HBA has been |
| detected. After confirming that the new device is one that the LLD wants |
| to control, the LLD will initialize the HBA and then register a new host |
| with the SCSI mid level. |
| |
| During LLD initialization the driver should register itself with the |
| appropriate IO bus on which it expects to find HBA(s) (e.g. the PCI bus). |
| This can probably be done via sysfs. Any driver parameters (especially |
| those that are writable after the driver is loaded) could also be |
| registered with sysfs at this point. The SCSI mid level first becomes |
| aware of an LLD when that LLD registers its first HBA. |
| |
| At some later time, the LLD becomes aware of an HBA and what follows |
| is a typical sequence of calls between the LLD and the mid level. |
| This example shows the mid level scanning the newly introduced HBA for 3 |
| scsi devices of which only the first 2 respond:: |
| |
| HBA PROBE: assume 2 SCSI devices found in scan |
| LLD mid level LLD |
| ===-------------------=========--------------------===------ |
| scsi_host_alloc() --> |
| scsi_add_host() ----> |
| scsi_scan_host() -------+ |
| | |
| slave_alloc() |
| slave_configure() --> scsi_change_queue_depth() |
| | |
| slave_alloc() |
| slave_configure() |
| | |
| slave_alloc() *** |
| slave_destroy() *** |
| |
| |
| *** For scsi devices that the mid level tries to scan but do not |
| respond, a slave_alloc(), slave_destroy() pair is called. |
| |
| If the LLD wants to adjust the default queue settings, it can invoke |
| scsi_change_queue_depth() in its slave_configure() routine. |
| |
| When an HBA is being removed it could be as part of an orderly shutdown |
| associated with the LLD module being unloaded (e.g. with the "rmmod" |
| command) or in response to a "hot unplug" indicated by sysfs()'s |
| remove() callback being invoked. In either case, the sequence is the |
| same:: |
| |
| HBA REMOVE: assume 2 SCSI devices attached |
| LLD mid level LLD |
| ===----------------------=========-----------------===------ |
| scsi_remove_host() ---------+ |
| | |
| slave_destroy() |
| slave_destroy() |
| scsi_host_put() |
| |
| It may be useful for a LLD to keep track of struct Scsi_Host instances |
| (a pointer is returned by scsi_host_alloc()). Such instances are "owned" |
| by the mid-level. struct Scsi_Host instances are freed from |
| scsi_host_put() when the reference count hits zero. |
| |
| Hot unplugging an HBA that controls a disk which is processing SCSI |
| commands on a mounted file system is an interesting situation. Reference |
| counting logic is being introduced into the mid level to cope with many |
| of the issues involved. See the section on reference counting below. |
| |
| |
| The hotplug concept may be extended to SCSI devices. Currently, when an |
| HBA is added, the scsi_scan_host() function causes a scan for SCSI devices |
| attached to the HBA's SCSI transport. On newer SCSI transports the HBA |
| may become aware of a new SCSI device _after_ the scan has completed. |
| An LLD can use this sequence to make the mid level aware of a SCSI device:: |
| |
| SCSI DEVICE hotplug |
| LLD mid level LLD |
| ===-------------------=========--------------------===------ |
| scsi_add_device() ------+ |
| | |
| slave_alloc() |
| slave_configure() [--> scsi_change_queue_depth()] |
| |
| In a similar fashion, an LLD may become aware that a SCSI device has been |
| removed (unplugged) or the connection to it has been interrupted. Some |
| existing SCSI transports (e.g. SPI) may not become aware that a SCSI |
| device has been removed until a subsequent SCSI command fails which will |
| probably cause that device to be set offline by the mid level. An LLD that |
| detects the removal of a SCSI device can instigate its removal from |
| upper layers with this sequence:: |
| |
| SCSI DEVICE hot unplug |
| LLD mid level LLD |
| ===----------------------=========-----------------===------ |
| scsi_remove_device() -------+ |
| | |
| slave_destroy() |
| |
| It may be useful for an LLD to keep track of struct scsi_device instances |
| (a pointer is passed as the parameter to slave_alloc() and |
| slave_configure() callbacks). Such instances are "owned" by the mid-level. |
| struct scsi_device instances are freed after slave_destroy(). |
| |
| |
| Reference Counting |
| ================== |
| The Scsi_Host structure has had reference counting infrastructure added. |
| This effectively spreads the ownership of struct Scsi_Host instances |
| across the various SCSI layers which use them. Previously such instances |
| were exclusively owned by the mid level. LLDs would not usually need to |
| directly manipulate these reference counts but there may be some cases |
| where they do. |
| |
| There are 3 reference counting functions of interest associated with |
| struct Scsi_Host: |
| |
| - scsi_host_alloc(): |
| returns a pointer to new instance of struct |
| Scsi_Host which has its reference count ^^ set to 1 |
| |
| - scsi_host_get(): |
| adds 1 to the reference count of the given instance |
| |
| - scsi_host_put(): |
| decrements 1 from the reference count of the given |
| instance. If the reference count reaches 0 then the given instance |
| is freed |
| |
| The scsi_device structure has had reference counting infrastructure added. |
| This effectively spreads the ownership of struct scsi_device instances |
| across the various SCSI layers which use them. Previously such instances |
| were exclusively owned by the mid level. See the access functions declared |
| towards the end of include/scsi/scsi_device.h . If an LLD wants to keep |
| a copy of a pointer to a scsi_device instance it should use scsi_device_get() |
| to bump its reference count. When it is finished with the pointer it can |
| use scsi_device_put() to decrement its reference count (and potentially |
| delete it). |
| |
| .. Note:: |
| |
| struct Scsi_Host actually has 2 reference counts which are manipulated |
| in parallel by these functions. |
| |
| |
| Conventions |
| =========== |
| First, Linus Torvalds's thoughts on C coding style can be found in the |
| Documentation/process/coding-style.rst file. |
| |
| Also, most C99 enhancements are encouraged to the extent they are supported |
| by the relevant gcc compilers. So C99 style structure and array |
| initializers are encouraged where appropriate. Don't go too far, |
| VLAs are not properly supported yet. An exception to this is the use of |
| ``//`` style comments; ``/*...*/`` comments are still preferred in Linux. |
| |
| Well written, tested and documented code, need not be re-formatted to |
| comply with the above conventions. For example, the aic7xxx driver |
| comes to Linux from FreeBSD and Adaptec's own labs. No doubt FreeBSD |
| and Adaptec have their own coding conventions. |
| |
| |
| Mid level supplied functions |
| ============================ |
| These functions are supplied by the SCSI mid level for use by LLDs. |
| The names (i.e. entry points) of these functions are exported |
| so an LLD that is a module can access them. The kernel will |
| arrange for the SCSI mid level to be loaded and initialized before any LLD |
| is initialized. The functions below are listed alphabetically and their |
| names all start with ``scsi_``. |
| |
| Summary: |
| |
| - scsi_add_device - creates new scsi device (lu) instance |
| - scsi_add_host - perform sysfs registration and set up transport class |
| - scsi_change_queue_depth - change the queue depth on a SCSI device |
| - scsi_bios_ptable - return copy of block device's partition table |
| - scsi_block_requests - prevent further commands being queued to given host |
| - scsi_host_alloc - return a new scsi_host instance whose refcount==1 |
| - scsi_host_get - increments Scsi_Host instance's refcount |
| - scsi_host_put - decrements Scsi_Host instance's refcount (free if 0) |
| - scsi_register - create and register a scsi host adapter instance. |
| - scsi_remove_device - detach and remove a SCSI device |
| - scsi_remove_host - detach and remove all SCSI devices owned by host |
| - scsi_report_bus_reset - report scsi _bus_ reset observed |
| - scsi_scan_host - scan SCSI bus |
| - scsi_track_queue_full - track successive QUEUE_FULL events |
| - scsi_unblock_requests - allow further commands to be queued to given host |
| - scsi_unregister - [calls scsi_host_put()] |
| |
| |
| Details:: |
| |
| /** |
| * scsi_add_device - creates new scsi device (lu) instance |
| * @shost: pointer to scsi host instance |
| * @channel: channel number (rarely other than 0) |
| * @id: target id number |
| * @lun: logical unit number |
| * |
| * Returns pointer to new struct scsi_device instance or |
| * ERR_PTR(-ENODEV) (or some other bent pointer) if something is |
| * wrong (e.g. no lu responds at given address) |
| * |
| * Might block: yes |
| * |
| * Notes: This call is usually performed internally during a scsi |
| * bus scan when an HBA is added (i.e. scsi_scan_host()). So it |
| * should only be called if the HBA becomes aware of a new scsi |
| * device (lu) after scsi_scan_host() has completed. If successful |
| * this call can lead to slave_alloc() and slave_configure() callbacks |
| * into the LLD. |
| * |
| * Defined in: drivers/scsi/scsi_scan.c |
| **/ |
| struct scsi_device * scsi_add_device(struct Scsi_Host *shost, |
| unsigned int channel, |
| unsigned int id, unsigned int lun) |
| |
| |
| /** |
| * scsi_add_host - perform sysfs registration and set up transport class |
| * @shost: pointer to scsi host instance |
| * @dev: pointer to struct device of type scsi class |
| * |
| * Returns 0 on success, negative errno of failure (e.g. -ENOMEM) |
| * |
| * Might block: no |
| * |
| * Notes: Only required in "hotplug initialization model" after a |
| * successful call to scsi_host_alloc(). This function does not |
| * scan the bus; this can be done by calling scsi_scan_host() or |
| * in some other transport-specific way. The LLD must set up |
| * the transport template before calling this function and may only |
| * access the transport class data after this function has been called. |
| * |
| * Defined in: drivers/scsi/hosts.c |
| **/ |
| int scsi_add_host(struct Scsi_Host *shost, struct device * dev) |
| |
| |
| /** |
| * scsi_change_queue_depth - allow LLD to change queue depth on a SCSI device |
| * @sdev: pointer to SCSI device to change queue depth on |
| * @tags Number of tags allowed if tagged queuing enabled, |
| * or number of commands the LLD can queue up |
| * in non-tagged mode (as per cmd_per_lun). |
| * |
| * Returns nothing |
| * |
| * Might block: no |
| * |
| * Notes: Can be invoked any time on a SCSI device controlled by this |
| * LLD. [Specifically during and after slave_configure() and prior to |
| * slave_destroy().] Can safely be invoked from interrupt code. |
| * |
| * Defined in: drivers/scsi/scsi.c [see source code for more notes] |
| * |
| **/ |
| int scsi_change_queue_depth(struct scsi_device *sdev, int tags) |
| |
| |
| /** |
| * scsi_bios_ptable - return copy of block device's partition table |
| * @dev: pointer to block device |
| * |
| * Returns pointer to partition table, or NULL for failure |
| * |
| * Might block: yes |
| * |
| * Notes: Caller owns memory returned (free with kfree() ) |
| * |
| * Defined in: drivers/scsi/scsicam.c |
| **/ |
| unsigned char *scsi_bios_ptable(struct block_device *dev) |
| |
| |
| /** |
| * scsi_block_requests - prevent further commands being queued to given host |
| * |
| * @shost: pointer to host to block commands on |
| * |
| * Returns nothing |
| * |
| * Might block: no |
| * |
| * Notes: There is no timer nor any other means by which the requests |
| * get unblocked other than the LLD calling scsi_unblock_requests(). |
| * |
| * Defined in: drivers/scsi/scsi_lib.c |
| **/ |
| void scsi_block_requests(struct Scsi_Host * shost) |
| |
| |
| /** |
| * scsi_host_alloc - create a scsi host adapter instance and perform basic |
| * initialization. |
| * @sht: pointer to scsi host template |
| * @privsize: extra bytes to allocate in hostdata array (which is the |
| * last member of the returned Scsi_Host instance) |
| * |
| * Returns pointer to new Scsi_Host instance or NULL on failure |
| * |
| * Might block: yes |
| * |
| * Notes: When this call returns to the LLD, the SCSI bus scan on |
| * this host has _not_ yet been done. |
| * The hostdata array (by default zero length) is a per host scratch |
| * area for the LLD's exclusive use. |
| * Both associated refcounting objects have their refcount set to 1. |
| * Full registration (in sysfs) and a bus scan are performed later when |
| * scsi_add_host() and scsi_scan_host() are called. |
| * |
| * Defined in: drivers/scsi/hosts.c . |
| **/ |
| struct Scsi_Host * scsi_host_alloc(struct scsi_host_template * sht, |
| int privsize) |
| |
| |
| /** |
| * scsi_host_get - increment Scsi_Host instance refcount |
| * @shost: pointer to struct Scsi_Host instance |
| * |
| * Returns nothing |
| * |
| * Might block: currently may block but may be changed to not block |
| * |
| * Notes: Actually increments the counts in two sub-objects |
| * |
| * Defined in: drivers/scsi/hosts.c |
| **/ |
| void scsi_host_get(struct Scsi_Host *shost) |
| |
| |
| /** |
| * scsi_host_put - decrement Scsi_Host instance refcount, free if 0 |
| * @shost: pointer to struct Scsi_Host instance |
| * |
| * Returns nothing |
| * |
| * Might block: currently may block but may be changed to not block |
| * |
| * Notes: Actually decrements the counts in two sub-objects. If the |
| * latter refcount reaches 0, the Scsi_Host instance is freed. |
| * The LLD need not worry exactly when the Scsi_Host instance is |
| * freed, it just shouldn't access the instance after it has balanced |
| * out its refcount usage. |
| * |
| * Defined in: drivers/scsi/hosts.c |
| **/ |
| void scsi_host_put(struct Scsi_Host *shost) |
| |
| |
| /** |
| * scsi_register - create and register a scsi host adapter instance. |
| * @sht: pointer to scsi host template |
| * @privsize: extra bytes to allocate in hostdata array (which is the |
| * last member of the returned Scsi_Host instance) |
| * |
| * Returns pointer to new Scsi_Host instance or NULL on failure |
| * |
| * Might block: yes |
| * |
| * Notes: When this call returns to the LLD, the SCSI bus scan on |
| * this host has _not_ yet been done. |
| * The hostdata array (by default zero length) is a per host scratch |
| * area for the LLD. |
| * |
| * Defined in: drivers/scsi/hosts.c . |
| **/ |
| struct Scsi_Host * scsi_register(struct scsi_host_template * sht, |
| int privsize) |
| |
| |
| /** |
| * scsi_remove_device - detach and remove a SCSI device |
| * @sdev: a pointer to a scsi device instance |
| * |
| * Returns value: 0 on success, -EINVAL if device not attached |
| * |
| * Might block: yes |
| * |
| * Notes: If an LLD becomes aware that a scsi device (lu) has |
| * been removed but its host is still present then it can request |
| * the removal of that scsi device. If successful this call will |
| * lead to the slave_destroy() callback being invoked. sdev is an |
| * invalid pointer after this call. |
| * |
| * Defined in: drivers/scsi/scsi_sysfs.c . |
| **/ |
| int scsi_remove_device(struct scsi_device *sdev) |
| |
| |
| /** |
| * scsi_remove_host - detach and remove all SCSI devices owned by host |
| * @shost: a pointer to a scsi host instance |
| * |
| * Returns value: 0 on success, 1 on failure (e.g. LLD busy ??) |
| * |
| * Might block: yes |
| * |
| * Notes: Should only be invoked if the "hotplug initialization |
| * model" is being used. It should be called _prior_ to |
| * scsi_unregister(). |
| * |
| * Defined in: drivers/scsi/hosts.c . |
| **/ |
| int scsi_remove_host(struct Scsi_Host *shost) |
| |
| |
| /** |
| * scsi_report_bus_reset - report scsi _bus_ reset observed |
| * @shost: a pointer to a scsi host involved |
| * @channel: channel (within) host on which scsi bus reset occurred |
| * |
| * Returns nothing |
| * |
| * Might block: no |
| * |
| * Notes: This only needs to be called if the reset is one which |
| * originates from an unknown location. Resets originated by the |
| * mid level itself don't need to call this, but there should be |
| * no harm. The main purpose of this is to make sure that a |
| * CHECK_CONDITION is properly treated. |
| * |
| * Defined in: drivers/scsi/scsi_error.c . |
| **/ |
| void scsi_report_bus_reset(struct Scsi_Host * shost, int channel) |
| |
| |
| /** |
| * scsi_scan_host - scan SCSI bus |
| * @shost: a pointer to a scsi host instance |
| * |
| * Might block: yes |
| * |
| * Notes: Should be called after scsi_add_host() |
| * |
| * Defined in: drivers/scsi/scsi_scan.c |
| **/ |
| void scsi_scan_host(struct Scsi_Host *shost) |
| |
| |
| /** |
| * scsi_track_queue_full - track successive QUEUE_FULL events on given |
| * device to determine if and when there is a need |
| * to adjust the queue depth on the device. |
| * @sdev: pointer to SCSI device instance |
| * @depth: Current number of outstanding SCSI commands on this device, |
| * not counting the one returned as QUEUE_FULL. |
| * |
| * Returns 0 - no change needed |
| * >0 - adjust queue depth to this new depth |
| * -1 - drop back to untagged operation using host->cmd_per_lun |
| * as the untagged command depth |
| * |
| * Might block: no |
| * |
| * Notes: LLDs may call this at any time and we will do "The Right |
| * Thing"; interrupt context safe. |
| * |
| * Defined in: drivers/scsi/scsi.c . |
| **/ |
| int scsi_track_queue_full(struct scsi_device *sdev, int depth) |
| |
| |
| /** |
| * scsi_unblock_requests - allow further commands to be queued to given host |
| * |
| * @shost: pointer to host to unblock commands on |
| * |
| * Returns nothing |
| * |
| * Might block: no |
| * |
| * Defined in: drivers/scsi/scsi_lib.c . |
| **/ |
| void scsi_unblock_requests(struct Scsi_Host * shost) |
| |
| |
| /** |
| * scsi_unregister - unregister and free memory used by host instance |
| * @shp: pointer to scsi host instance to unregister. |
| * |
| * Returns nothing |
| * |
| * Might block: no |
| * |
| * Notes: Should not be invoked if the "hotplug initialization |
| * model" is being used. Called internally by exit_this_scsi_driver() |
| * in the "passive initialization model". Hence a LLD has no need to |
| * call this function directly. |
| * |
| * Defined in: drivers/scsi/hosts.c . |
| **/ |
| void scsi_unregister(struct Scsi_Host * shp) |
| |
| |
| |
| |
| Interface Functions |
| =================== |
| Interface functions are supplied (defined) by LLDs and their function |
| pointers are placed in an instance of struct scsi_host_template which |
| is passed to scsi_host_alloc() [or scsi_register() / init_this_scsi_driver()]. |
| Some are mandatory. Interface functions should be declared static. The |
| accepted convention is that driver "xyz" will declare its slave_configure() |
| function as:: |
| |
| static int xyz_slave_configure(struct scsi_device * sdev); |
| |
| and so forth for all interface functions listed below. |
| |
| A pointer to this function should be placed in the 'slave_configure' member |
| of a "struct scsi_host_template" instance. A pointer to such an instance |
| should be passed to the mid level's scsi_host_alloc() [or scsi_register() / |
| init_this_scsi_driver()]. |
| |
| The interface functions are also described in the include/scsi/scsi_host.h |
| file immediately above their definition point in "struct scsi_host_template". |
| In some cases more detail is given in scsi_host.h than below. |
| |
| The interface functions are listed below in alphabetical order. |
| |
| Summary: |
| |
| - bios_param - fetch head, sector, cylinder info for a disk |
| - eh_timed_out - notify the host that a command timer expired |
| - eh_abort_handler - abort given command |
| - eh_bus_reset_handler - issue SCSI bus reset |
| - eh_device_reset_handler - issue SCSI device reset |
| - eh_host_reset_handler - reset host (host bus adapter) |
| - info - supply information about given host |
| - ioctl - driver can respond to ioctls |
| - proc_info - supports /proc/scsi/{driver_name}/{host_no} |
| - queuecommand - queue scsi command, invoke 'done' on completion |
| - slave_alloc - prior to any commands being sent to a new device |
| - slave_configure - driver fine tuning for given device after attach |
| - slave_destroy - given device is about to be shut down |
| |
| |
| Details:: |
| |
| /** |
| * bios_param - fetch head, sector, cylinder info for a disk |
| * @sdev: pointer to scsi device context (defined in |
| * include/scsi/scsi_device.h) |
| * @bdev: pointer to block device context (defined in fs.h) |
| * @capacity: device size (in 512 byte sectors) |
| * @params: three element array to place output: |
| * params[0] number of heads (max 255) |
| * params[1] number of sectors (max 63) |
| * params[2] number of cylinders |
| * |
| * Return value is ignored |
| * |
| * Locks: none |
| * |
| * Calling context: process (sd) |
| * |
| * Notes: an arbitrary geometry (based on READ CAPACITY) is used |
| * if this function is not provided. The params array is |
| * pre-initialized with made up values just in case this function |
| * doesn't output anything. |
| * |
| * Optionally defined in: LLD |
| **/ |
| int bios_param(struct scsi_device * sdev, struct block_device *bdev, |
| sector_t capacity, int params[3]) |
| |
| |
| /** |
| * eh_timed_out - The timer for the command has just fired |
| * @scp: identifies command timing out |
| * |
| * Returns: |
| * |
| * EH_HANDLED: I fixed the error, please complete the command |
| * EH_RESET_TIMER: I need more time, reset the timer and |
| * begin counting again |
| * EH_NOT_HANDLED Begin normal error recovery |
| * |
| * |
| * Locks: None held |
| * |
| * Calling context: interrupt |
| * |
| * Notes: This is to give the LLD an opportunity to do local recovery. |
| * This recovery is limited to determining if the outstanding command |
| * will ever complete. You may not abort and restart the command from |
| * this callback. |
| * |
| * Optionally defined in: LLD |
| **/ |
| int eh_timed_out(struct scsi_cmnd * scp) |
| |
| |
| /** |
| * eh_abort_handler - abort command associated with scp |
| * @scp: identifies command to be aborted |
| * |
| * Returns SUCCESS if command aborted else FAILED |
| * |
| * Locks: None held |
| * |
| * Calling context: kernel thread |
| * |
| * Notes: If 'no_async_abort' is defined this callback |
| * will be invoked from scsi_eh thread. No other commands |
| * will then be queued on current host during eh. |
| * Otherwise it will be called whenever scsi_times_out() |
| * is called due to a command timeout. |
| * |
| * Optionally defined in: LLD |
| **/ |
| int eh_abort_handler(struct scsi_cmnd * scp) |
| |
| |
| /** |
| * eh_bus_reset_handler - issue SCSI bus reset |
| * @scp: SCSI bus that contains this device should be reset |
| * |
| * Returns SUCCESS if command aborted else FAILED |
| * |
| * Locks: None held |
| * |
| * Calling context: kernel thread |
| * |
| * Notes: Invoked from scsi_eh thread. No other commands will be |
| * queued on current host during eh. |
| * |
| * Optionally defined in: LLD |
| **/ |
| int eh_bus_reset_handler(struct scsi_cmnd * scp) |
| |
| |
| /** |
| * eh_device_reset_handler - issue SCSI device reset |
| * @scp: identifies SCSI device to be reset |
| * |
| * Returns SUCCESS if command aborted else FAILED |
| * |
| * Locks: None held |
| * |
| * Calling context: kernel thread |
| * |
| * Notes: Invoked from scsi_eh thread. No other commands will be |
| * queued on current host during eh. |
| * |
| * Optionally defined in: LLD |
| **/ |
| int eh_device_reset_handler(struct scsi_cmnd * scp) |
| |
| |
| /** |
| * eh_host_reset_handler - reset host (host bus adapter) |
| * @scp: SCSI host that contains this device should be reset |
| * |
| * Returns SUCCESS if command aborted else FAILED |
| * |
| * Locks: None held |
| * |
| * Calling context: kernel thread |
| * |
| * Notes: Invoked from scsi_eh thread. No other commands will be |
| * queued on current host during eh. |
| * With the default eh_strategy in place, if none of the _abort_, |
| * _device_reset_, _bus_reset_ or this eh handler function are |
| * defined (or they all return FAILED) then the device in question |
| * will be set offline whenever eh is invoked. |
| * |
| * Optionally defined in: LLD |
| **/ |
| int eh_host_reset_handler(struct scsi_cmnd * scp) |
| |
| |
| /** |
| * info - supply information about given host: driver name plus data |
| * to distinguish given host |
| * @shp: host to supply information about |
| * |
| * Return ASCII null terminated string. [This driver is assumed to |
| * manage the memory pointed to and maintain it, typically for the |
| * lifetime of this host.] |
| * |
| * Locks: none |
| * |
| * Calling context: process |
| * |
| * Notes: Often supplies PCI or ISA information such as IO addresses |
| * and interrupt numbers. If not supplied struct Scsi_Host::name used |
| * instead. It is assumed the returned information fits on one line |
| * (i.e. does not included embedded newlines). |
| * The SCSI_IOCTL_PROBE_HOST ioctl yields the string returned by this |
| * function (or struct Scsi_Host::name if this function is not |
| * available). |
| * In a similar manner, init_this_scsi_driver() outputs to the console |
| * each host's "info" (or name) for the driver it is registering. |
| * Also if proc_info() is not supplied, the output of this function |
| * is used instead. |
| * |
| * Optionally defined in: LLD |
| **/ |
| const char * info(struct Scsi_Host * shp) |
| |
| |
| /** |
| * ioctl - driver can respond to ioctls |
| * @sdp: device that ioctl was issued for |
| * @cmd: ioctl number |
| * @arg: pointer to read or write data from. Since it points to |
| * user space, should use appropriate kernel functions |
| * (e.g. copy_from_user() ). In the Unix style this argument |
| * can also be viewed as an unsigned long. |
| * |
| * Returns negative "errno" value when there is a problem. 0 or a |
| * positive value indicates success and is returned to the user space. |
| * |
| * Locks: none |
| * |
| * Calling context: process |
| * |
| * Notes: The SCSI subsystem uses a "trickle down" ioctl model. |
| * The user issues an ioctl() against an upper level driver |
| * (e.g. /dev/sdc) and if the upper level driver doesn't recognize |
| * the 'cmd' then it is passed to the SCSI mid level. If the SCSI |
| * mid level does not recognize it, then the LLD that controls |
| * the device receives the ioctl. According to recent Unix standards |
| * unsupported ioctl() 'cmd' numbers should return -ENOTTY. |
| * |
| * Optionally defined in: LLD |
| **/ |
| int ioctl(struct scsi_device *sdp, int cmd, void *arg) |
| |
| |
| /** |
| * proc_info - supports /proc/scsi/{driver_name}/{host_no} |
| * @buffer: anchor point to output to (0==writeto1_read0) or fetch from |
| * (1==writeto1_read0). |
| * @start: where "interesting" data is written to. Ignored when |
| * 1==writeto1_read0. |
| * @offset: offset within buffer 0==writeto1_read0 is actually |
| * interested in. Ignored when 1==writeto1_read0 . |
| * @length: maximum (or actual) extent of buffer |
| * @host_no: host number of interest (struct Scsi_Host::host_no) |
| * @writeto1_read0: 1 -> data coming from user space towards driver |
| * (e.g. "echo some_string > /proc/scsi/xyz/2") |
| * 0 -> user what data from this driver |
| * (e.g. "cat /proc/scsi/xyz/2") |
| * |
| * Returns length when 1==writeto1_read0. Otherwise number of chars |
| * output to buffer past offset. |
| * |
| * Locks: none held |
| * |
| * Calling context: process |
| * |
| * Notes: Driven from scsi_proc.c which interfaces to proc_fs. proc_fs |
| * support can now be configured out of the scsi subsystem. |
| * |
| * Optionally defined in: LLD |
| **/ |
| int proc_info(char * buffer, char ** start, off_t offset, |
| int length, int host_no, int writeto1_read0) |
| |
| |
| /** |
| * queuecommand - queue scsi command, invoke scp->scsi_done on completion |
| * @shost: pointer to the scsi host object |
| * @scp: pointer to scsi command object |
| * |
| * Returns 0 on success. |
| * |
| * If there's a failure, return either: |
| * |
| * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or |
| * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full |
| * |
| * On both of these returns, the mid-layer will requeue the I/O |
| * |
| * - if the return is SCSI_MLQUEUE_DEVICE_BUSY, only that particular |
| * device will be paused, and it will be unpaused when a command to |
| * the device returns (or after a brief delay if there are no more |
| * outstanding commands to it). Commands to other devices continue |
| * to be processed normally. |
| * |
| * - if the return is SCSI_MLQUEUE_HOST_BUSY, all I/O to the host |
| * is paused and will be unpaused when any command returns from |
| * the host (or after a brief delay if there are no outstanding |
| * commands to the host). |
| * |
| * For compatibility with earlier versions of queuecommand, any |
| * other return value is treated the same as |
| * SCSI_MLQUEUE_HOST_BUSY. |
| * |
| * Other types of errors that are detected immediately may be |
| * flagged by setting scp->result to an appropriate value, |
| * invoking the scp->scsi_done callback, and then returning 0 |
| * from this function. If the command is not performed |
| * immediately (and the LLD is starting (or will start) the given |
| * command) then this function should place 0 in scp->result and |
| * return 0. |
| * |
| * Command ownership. If the driver returns zero, it owns the |
| * command and must take responsibility for ensuring the |
| * scp->scsi_done callback is executed. Note: the driver may |
| * call scp->scsi_done before returning zero, but after it has |
| * called scp->scsi_done, it may not return any value other than |
| * zero. If the driver makes a non-zero return, it must not |
| * execute the command's scsi_done callback at any time. |
| * |
| * Locks: up to and including 2.6.36, struct Scsi_Host::host_lock |
| * held on entry (with "irqsave") and is expected to be |
| * held on return. From 2.6.37 onwards, queuecommand is |
| * called without any locks held. |
| * |
| * Calling context: in interrupt (soft irq) or process context |
| * |
| * Notes: This function should be relatively fast. Normally it |
| * will not wait for IO to complete. Hence the scp->scsi_done |
| * callback is invoked (often directly from an interrupt service |
| * routine) some time after this function has returned. In some |
| * cases (e.g. pseudo adapter drivers that manufacture the |
| * response to a SCSI INQUIRY) the scp->scsi_done callback may be |
| * invoked before this function returns. If the scp->scsi_done |
| * callback is not invoked within a certain period the SCSI mid |
| * level will commence error processing. If a status of CHECK |
| * CONDITION is placed in "result" when the scp->scsi_done |
| * callback is invoked, then the LLD driver should perform |
| * autosense and fill in the struct scsi_cmnd::sense_buffer |
| * array. The scsi_cmnd::sense_buffer array is zeroed prior to |
| * the mid level queuing a command to an LLD. |
| * |
| * Defined in: LLD |
| **/ |
| int queuecommand(struct Scsi_Host *shost, struct scsi_cmnd * scp) |
| |
| |
| /** |
| * slave_alloc - prior to any commands being sent to a new device |
| * (i.e. just prior to scan) this call is made |
| * @sdp: pointer to new device (about to be scanned) |
| * |
| * Returns 0 if ok. Any other return is assumed to be an error and |
| * the device is ignored. |
| * |
| * Locks: none |
| * |
| * Calling context: process |
| * |
| * Notes: Allows the driver to allocate any resources for a device |
| * prior to its initial scan. The corresponding scsi device may not |
| * exist but the mid level is just about to scan for it (i.e. send |
| * and INQUIRY command plus ...). If a device is found then |
| * slave_configure() will be called while if a device is not found |
| * slave_destroy() is called. |
| * For more details see the include/scsi/scsi_host.h file. |
| * |
| * Optionally defined in: LLD |
| **/ |
| int slave_alloc(struct scsi_device *sdp) |
| |
| |
| /** |
| * slave_configure - driver fine tuning for given device just after it |
| * has been first scanned (i.e. it responded to an |
| * INQUIRY) |
| * @sdp: device that has just been attached |
| * |
| * Returns 0 if ok. Any other return is assumed to be an error and |
| * the device is taken offline. [offline devices will _not_ have |
| * slave_destroy() called on them so clean up resources.] |
| * |
| * Locks: none |
| * |
| * Calling context: process |
| * |
| * Notes: Allows the driver to inspect the response to the initial |
| * INQUIRY done by the scanning code and take appropriate action. |
| * For more details see the include/scsi/scsi_host.h file. |
| * |
| * Optionally defined in: LLD |
| **/ |
| int slave_configure(struct scsi_device *sdp) |
| |
| |
| /** |
| * slave_destroy - given device is about to be shut down. All |
| * activity has ceased on this device. |
| * @sdp: device that is about to be shut down |
| * |
| * Returns nothing |
| * |
| * Locks: none |
| * |
| * Calling context: process |
| * |
| * Notes: Mid level structures for given device are still in place |
| * but are about to be torn down. Any per device resources allocated |
| * by this driver for given device should be freed now. No further |
| * commands will be sent for this sdp instance. [However the device |
| * could be re-attached in the future in which case a new instance |
| * of struct scsi_device would be supplied by future slave_alloc() |
| * and slave_configure() calls.] |
| * |
| * Optionally defined in: LLD |
| **/ |
| void slave_destroy(struct scsi_device *sdp) |
| |
| |
| |
| Data Structures |
| =============== |
| struct scsi_host_template |
| ------------------------- |
| There is one "struct scsi_host_template" instance per LLD [#]_. It is |
| typically initialized as a file scope static in a driver's header file. That |
| way members that are not explicitly initialized will be set to 0 or NULL. |
| Member of interest: |
| |
| name |
| - name of driver (may contain spaces, please limit to |
| less than 80 characters) |
| |
| proc_name |
| - name used in "/proc/scsi/<proc_name>/<host_no>" and |
| by sysfs in one of its "drivers" directories. Hence |
| "proc_name" should only contain characters acceptable |
| to a Unix file name. |
| |
| ``(*queuecommand)()`` |
| - primary callback that the mid level uses to inject |
| SCSI commands into an LLD. |
| |
| The structure is defined and commented in include/scsi/scsi_host.h |
| |
| .. [#] In extreme situations a single driver may have several instances |
| if it controls several different classes of hardware (e.g. an LLD |
| that handles both ISA and PCI cards and has a separate instance of |
| struct scsi_host_template for each class). |
| |
| struct Scsi_Host |
| ---------------- |
| There is one struct Scsi_Host instance per host (HBA) that an LLD |
| controls. The struct Scsi_Host structure has many members in common |
| with "struct scsi_host_template". When a new struct Scsi_Host instance |
| is created (in scsi_host_alloc() in hosts.c) those common members are |
| initialized from the driver's struct scsi_host_template instance. Members |
| of interest: |
| |
| host_no |
| - system wide unique number that is used for identifying |
| this host. Issued in ascending order from 0. |
| can_queue |
| - must be greater than 0; do not send more than can_queue |
| commands to the adapter. |
| this_id |
| - scsi id of host (scsi initiator) or -1 if not known |
| sg_tablesize |
| - maximum scatter gather elements allowed by host. |
| Set this to SG_ALL or less to avoid chained SG lists. |
| Must be at least 1. |
| max_sectors |
| - maximum number of sectors (usually 512 bytes) allowed |
| in a single SCSI command. The default value of 0 leads |
| to a setting of SCSI_DEFAULT_MAX_SECTORS (defined in |
| scsi_host.h) which is currently set to 1024. So for a |
| disk the maximum transfer size is 512 KB when max_sectors |
| is not defined. Note that this size may not be sufficient |
| for disk firmware uploads. |
| cmd_per_lun |
| - maximum number of commands that can be queued on devices |
| controlled by the host. Overridden by LLD calls to |
| scsi_change_queue_depth(). |
| unchecked_isa_dma |
| - 1=>only use bottom 16 MB of ram (ISA DMA addressing |
| restriction), 0=>can use full 32 bit (or better) DMA |
| address space |
| no_async_abort |
| - 1=>Asynchronous aborts are not supported |
| - 0=>Timed-out commands will be aborted asynchronously |
| hostt |
| - pointer to driver's struct scsi_host_template from which |
| this struct Scsi_Host instance was spawned |
| hostt->proc_name |
| - name of LLD. This is the driver name that sysfs uses |
| transportt |
| - pointer to driver's struct scsi_transport_template instance |
| (if any). FC and SPI transports currently supported. |
| sh_list |
| - a double linked list of pointers to all struct Scsi_Host |
| instances (currently ordered by ascending host_no) |
| my_devices |
| - a double linked list of pointers to struct scsi_device |
| instances that belong to this host. |
| hostdata[0] |
| - area reserved for LLD at end of struct Scsi_Host. Size |
| is set by the second argument (named 'xtr_bytes') to |
| scsi_host_alloc() or scsi_register(). |
| vendor_id |
| - a unique value that identifies the vendor supplying |
| the LLD for the Scsi_Host. Used most often in validating |
| vendor-specific message requests. Value consists of an |
| identifier type and a vendor-specific value. |
| See scsi_netlink.h for a description of valid formats. |
| |
| The scsi_host structure is defined in include/scsi/scsi_host.h |
| |
| struct scsi_device |
| ------------------ |
| Generally, there is one instance of this structure for each SCSI logical unit |
| on a host. Scsi devices connected to a host are uniquely identified by a |
| channel number, target id and logical unit number (lun). |
| The structure is defined in include/scsi/scsi_device.h |
| |
| struct scsi_cmnd |
| ---------------- |
| Instances of this structure convey SCSI commands to the LLD and responses |
| back to the mid level. The SCSI mid level will ensure that no more SCSI |
| commands become queued against the LLD than are indicated by |
| scsi_change_queue_depth() (or struct Scsi_Host::cmd_per_lun). There will |
| be at least one instance of struct scsi_cmnd available for each SCSI device. |
| Members of interest: |
| |
| cmnd |
| - array containing SCSI command |
| cmnd_len |
| - length (in bytes) of SCSI command |
| sc_data_direction |
| - direction of data transfer in data phase. See |
| "enum dma_data_direction" in include/linux/dma-mapping.h |
| request_bufflen |
| - number of data bytes to transfer (0 if no data phase) |
| use_sg |
| - ==0 -> no scatter gather list, hence transfer data |
| to/from request_buffer |
| - >0 -> scatter gather list (actually an array) in |
| request_buffer with use_sg elements |
| request_buffer |
| - either contains data buffer or scatter gather list |
| depending on the setting of use_sg. Scatter gather |
| elements are defined by 'struct scatterlist' found |
| in include/linux/scatterlist.h . |
| done |
| - function pointer that should be invoked by LLD when the |
| SCSI command is completed (successfully or otherwise). |
| Should only be called by an LLD if the LLD has accepted |
| the command (i.e. queuecommand() returned or will return |
| 0). The LLD may invoke 'done' prior to queuecommand() |
| finishing. |
| result |
| - should be set by LLD prior to calling 'done'. A value |
| of 0 implies a successfully completed command (and all |
| data (if any) has been transferred to or from the SCSI |
| target device). 'result' is a 32 bit unsigned integer that |
| can be viewed as 4 related bytes. The SCSI status value is |
| in the LSB. See include/scsi/scsi.h status_byte(), |
| msg_byte(), host_byte() and driver_byte() macros and |
| related constants. |
| sense_buffer |
| - an array (maximum size: SCSI_SENSE_BUFFERSIZE bytes) that |
| should be written when the SCSI status (LSB of 'result') |
| is set to CHECK_CONDITION (2). When CHECK_CONDITION is |
| set, if the top nibble of sense_buffer[0] has the value 7 |
| then the mid level will assume the sense_buffer array |
| contains a valid SCSI sense buffer; otherwise the mid |
| level will issue a REQUEST_SENSE SCSI command to |
| retrieve the sense buffer. The latter strategy is error |
| prone in the presence of command queuing so the LLD should |
| always "auto-sense". |
| device |
| - pointer to scsi_device object that this command is |
| associated with. |
| resid |
| - an LLD should set this signed integer to the requested |
| transfer length (i.e. 'request_bufflen') less the number |
| of bytes that are actually transferred. 'resid' is |
| preset to 0 so an LLD can ignore it if it cannot detect |
| underruns (overruns should be rare). If possible an LLD |
| should set 'resid' prior to invoking 'done'. The most |
| interesting case is data transfers from a SCSI target |
| device (e.g. READs) that underrun. |
| underflow |
| - LLD should place (DID_ERROR << 16) in 'result' if |
| actual number of bytes transferred is less than this |
| figure. Not many LLDs implement this check and some that |
| do just output an error message to the log rather than |
| report a DID_ERROR. Better for an LLD to implement |
| 'resid'. |
| |
| It is recommended that a LLD set 'resid' on data transfers from a SCSI |
| target device (e.g. READs). It is especially important that 'resid' is set |
| when such data transfers have sense keys of MEDIUM ERROR and HARDWARE ERROR |
| (and possibly RECOVERED ERROR). In these cases if a LLD is in doubt how much |
| data has been received then the safest approach is to indicate no bytes have |
| been received. For example: to indicate that no valid data has been received |
| a LLD might use these helpers:: |
| |
| scsi_set_resid(SCpnt, scsi_bufflen(SCpnt)); |
| |
| where 'SCpnt' is a pointer to a scsi_cmnd object. To indicate only three 512 |
| bytes blocks has been received 'resid' could be set like this:: |
| |
| scsi_set_resid(SCpnt, scsi_bufflen(SCpnt) - (3 * 512)); |
| |
| The scsi_cmnd structure is defined in include/scsi/scsi_cmnd.h |
| |
| |
| Locks |
| ===== |
| Each struct Scsi_Host instance has a spin_lock called struct |
| Scsi_Host::default_lock which is initialized in scsi_host_alloc() [found in |
| hosts.c]. Within the same function the struct Scsi_Host::host_lock pointer |
| is initialized to point at default_lock. Thereafter lock and unlock |
| operations performed by the mid level use the struct Scsi_Host::host_lock |
| pointer. Previously drivers could override the host_lock pointer but |
| this is not allowed anymore. |
| |
| |
| Autosense |
| ========= |
| Autosense (or auto-sense) is defined in the SAM-2 document as "the |
| automatic return of sense data to the application client coincident |
| with the completion of a SCSI command" when a status of CHECK CONDITION |
| occurs. LLDs should perform autosense. This should be done when the LLD |
| detects a CHECK CONDITION status by either: |
| |
| a) instructing the SCSI protocol (e.g. SCSI Parallel Interface (SPI)) |
| to perform an extra data in phase on such responses |
| b) or, the LLD issuing a REQUEST SENSE command itself |
| |
| Either way, when a status of CHECK CONDITION is detected, the mid level |
| decides whether the LLD has performed autosense by checking struct |
| scsi_cmnd::sense_buffer[0] . If this byte has an upper nibble of 7 (or 0xf) |
| then autosense is assumed to have taken place. If it has another value (and |
| this byte is initialized to 0 before each command) then the mid level will |
| issue a REQUEST SENSE command. |
| |
| In the presence of queued commands the "nexus" that maintains sense |
| buffer data from the command that failed until a following REQUEST SENSE |
| may get out of synchronization. This is why it is best for the LLD |
| to perform autosense. |
| |
| |
| Changes since lk 2.4 series |
| =========================== |
| io_request_lock has been replaced by several finer grained locks. The lock |
| relevant to LLDs is struct Scsi_Host::host_lock and there is |
| one per SCSI host. |
| |
| The older error handling mechanism has been removed. This means the |
| LLD interface functions abort() and reset() have been removed. |
| The struct scsi_host_template::use_new_eh_code flag has been removed. |
| |
| In the 2.4 series the SCSI subsystem configuration descriptions were |
| aggregated with the configuration descriptions from all other Linux |
| subsystems in the Documentation/Configure.help file. In the 2.6 series, |
| the SCSI subsystem now has its own (much smaller) drivers/scsi/Kconfig |
| file that contains both configuration and help information. |
| |
| struct SHT has been renamed to struct scsi_host_template. |
| |
| Addition of the "hotplug initialization model" and many extra functions |
| to support it. |
| |
| |
| Credits |
| ======= |
| The following people have contributed to this document: |
| |
| - Mike Anderson <andmike at us dot ibm dot com> |
| - James Bottomley <James dot Bottomley at hansenpartnership dot com> |
| - Patrick Mansfield <patmans at us dot ibm dot com> |
| - Christoph Hellwig <hch at infradead dot org> |
| - Doug Ledford <dledford at redhat dot com> |
| - Andries Brouwer <Andries dot Brouwer at cwi dot nl> |
| - Randy Dunlap <rdunlap at xenotime dot net> |
| - Alan Stern <stern at rowland dot harvard dot edu> |
| |
| |
| Douglas Gilbert |
| dgilbert at interlog dot com |
| |
| 21st September 2004 |
