// SPDX-License-Identifier: GPL-2.0-only /* Linux Driver for BusLogic MultiMaster and FlashPoint SCSI Host Adapters Copyright 1995-1998 by Leonard N. Zubkoff <[email protected]> The author respectfully requests that any modifications to this software be sent directly to him for evaluation and testing. Special thanks to Wayne Yen, Jin-Lon Hon, and Alex Win of BusLogic, whose advice has been invaluable, to David Gentzel, for writing the original Linux BusLogic driver, and to Paul Gortmaker, for being such a dedicated test site. Finally, special thanks to Mylex/BusLogic for making the FlashPoint SCCB Manager available as freely redistributable source code. */ #define blogic_drvr_version … #define blogic_drvr_date … #include <linux/module.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/types.h> #include <linux/blkdev.h> #include <linux/delay.h> #include <linux/ioport.h> #include <linux/mm.h> #include <linux/stat.h> #include <linux/pci.h> #include <linux/spinlock.h> #include <linux/jiffies.h> #include <linux/dma-mapping.h> #include <linux/slab.h> #include <linux/msdos_partition.h> #include <scsi/scsicam.h> #include <asm/dma.h> #include <asm/io.h> #include <scsi/scsi.h> #include <scsi/scsi_cmnd.h> #include <scsi/scsi_device.h> #include <scsi/scsi_host.h> #include <scsi/scsi_tcq.h> #include "BusLogic.h" #include "FlashPoint.c" #ifndef FAILURE #define FAILURE … #endif static const struct scsi_host_template blogic_template; /* blogic_drvr_options_count is a count of the number of BusLogic Driver Options specifications provided via the Linux Kernel Command Line or via the Loadable Kernel Module Installation Facility. */ static int blogic_drvr_options_count; /* blogic_drvr_options is an array of Driver Options structures representing BusLogic Driver Options specifications provided via the Linux Kernel Command Line or via the Loadable Kernel Module Installation Facility. */ static struct blogic_drvr_options blogic_drvr_options[BLOGIC_MAX_ADAPTERS]; /* BusLogic can be assigned a string by insmod. */ MODULE_DESCRIPTION(…) …; MODULE_LICENSE(…) …; #ifdef MODULE static char *BusLogic; module_param(BusLogic, charp, 0); #endif /* blogic_probe_options is a set of Probe Options to be applied across all BusLogic Host Adapters. */ static struct blogic_probe_options blogic_probe_options; /* blogic_global_options is a set of Global Options to be applied across all BusLogic Host Adapters. */ static struct blogic_global_options blogic_global_options; static LIST_HEAD(blogic_host_list); /* blogic_probeinfo_count is the number of entries in blogic_probeinfo_list. */ static int blogic_probeinfo_count; /* blogic_probeinfo_list is the list of I/O Addresses and Bus Probe Information to be checked for potential BusLogic Host Adapters. It is initialized by interrogating the PCI Configuration Space on PCI machines as well as from the list of standard BusLogic I/O Addresses. */ static struct blogic_probeinfo *blogic_probeinfo_list; /* blogic_cmd_failure_reason holds a string identifying the reason why a call to blogic_cmd failed. It is only non-NULL when blogic_cmd returns a failure code. */ static char *blogic_cmd_failure_reason; /* blogic_announce_drvr announces the Driver Version and Date, Author's Name, Copyright Notice, and Electronic Mail Address. */ static void blogic_announce_drvr(struct blogic_adapter *adapter) { … } /* blogic_drvr_info returns the Host Adapter Name to identify this SCSI Driver and Host Adapter. */ static const char *blogic_drvr_info(struct Scsi_Host *host) { … } /* blogic_init_ccbs initializes a group of Command Control Blocks (CCBs) for Host Adapter from the blk_size bytes located at blk_pointer. The newly created CCBs are added to Host Adapter's free list. */ static void blogic_init_ccbs(struct blogic_adapter *adapter, void *blk_pointer, int blk_size, dma_addr_t blkp) { … } /* blogic_create_initccbs allocates the initial CCBs for Host Adapter. */ static bool __init blogic_create_initccbs(struct blogic_adapter *adapter) { … } /* blogic_destroy_ccbs deallocates the CCBs for Host Adapter. */ static void blogic_destroy_ccbs(struct blogic_adapter *adapter) { … } /* blogic_create_addlccbs allocates Additional CCBs for Host Adapter. If allocation fails and there are no remaining CCBs available, the Driver Queue Depth is decreased to a known safe value to avoid potential deadlocks when multiple host adapters share the same IRQ Channel. */ static void blogic_create_addlccbs(struct blogic_adapter *adapter, int addl_ccbs, bool print_success) { … } /* blogic_alloc_ccb allocates a CCB from Host Adapter's free list, allocating more memory from the Kernel if necessary. The Host Adapter's Lock should already have been acquired by the caller. */ static struct blogic_ccb *blogic_alloc_ccb(struct blogic_adapter *adapter) { … } /* blogic_dealloc_ccb deallocates a CCB, returning it to the Host Adapter's free list. The Host Adapter's Lock should already have been acquired by the caller. */ static void blogic_dealloc_ccb(struct blogic_ccb *ccb, int dma_unmap) { … } /* blogic_cmd sends the command opcode to adapter, optionally providing paramlen bytes of param and receiving at most replylen bytes of reply; any excess reply data is received but discarded. On success, this function returns the number of reply bytes read from the Host Adapter (including any discarded data); on failure, it returns -1 if the command was invalid, or -2 if a timeout occurred. blogic_cmd is called exclusively during host adapter detection and initialization, so performance and latency are not critical, and exclusive access to the Host Adapter hardware is assumed. Once the host adapter and driver are initialized, the only Host Adapter command that is issued is the single byte Execute Mailbox Command operation code, which does not require waiting for the Host Adapter Ready bit to be set in the Status Register. */ static int blogic_cmd(struct blogic_adapter *adapter, enum blogic_opcode opcode, void *param, int paramlen, void *reply, int replylen) { … } /* blogic_sort_probeinfo sorts a section of blogic_probeinfo_list in order of increasing PCI Bus and Device Number. */ static void __init blogic_sort_probeinfo(struct blogic_probeinfo *probeinfo_list, int probeinfo_cnt) { … } /* blogic_init_mm_probeinfo initializes the list of I/O Address and Bus Probe Information to be checked for potential BusLogic MultiMaster SCSI Host Adapters by interrogating the PCI Configuration Space on PCI machines as well as from the list of standard BusLogic MultiMaster ISA I/O Addresses. It returns the number of PCI MultiMaster Host Adapters found. */ static int __init blogic_init_mm_probeinfo(struct blogic_adapter *adapter) { … } /* blogic_init_fp_probeinfo initializes the list of I/O Address and Bus Probe Information to be checked for potential BusLogic FlashPoint Host Adapters by interrogating the PCI Configuration Space. It returns the number of FlashPoint Host Adapters found. */ static int __init blogic_init_fp_probeinfo(struct blogic_adapter *adapter) { … } /* blogic_init_probeinfo_list initializes the list of I/O Address and Bus Probe Information to be checked for potential BusLogic SCSI Host Adapters by interrogating the PCI Configuration Space on PCI machines as well as from the list of standard BusLogic MultiMaster ISA I/O Addresses. By default, if both FlashPoint and PCI MultiMaster Host Adapters are present, this driver will probe for FlashPoint Host Adapters first unless the BIOS primary disk is controlled by the first PCI MultiMaster Host Adapter, in which case MultiMaster Host Adapters will be probed first. The BusLogic Driver Options specifications "MultiMasterFirst" and "FlashPointFirst" can be used to force a particular probe order. */ static void __init blogic_init_probeinfo_list(struct blogic_adapter *adapter) { … } /* blogic_failure prints a standardized error message, and then returns false. */ static bool blogic_failure(struct blogic_adapter *adapter, char *msg) { … } /* blogic_probe probes for a BusLogic Host Adapter. */ static bool __init blogic_probe(struct blogic_adapter *adapter) { … } /* blogic_hwreset issues a Hardware Reset to the Host Adapter and waits for Host Adapter Diagnostics to complete. If hard_reset is true, a Hard Reset is performed which also initiates a SCSI Bus Reset. Otherwise, a Soft Reset is performed which only resets the Host Adapter without forcing a SCSI Bus Reset. */ static bool blogic_hwreset(struct blogic_adapter *adapter, bool hard_reset) { … } /* blogic_checkadapter checks to be sure this really is a BusLogic Host Adapter. */ static bool __init blogic_checkadapter(struct blogic_adapter *adapter) { … } /* blogic_rdconfig reads the Configuration Information from Host Adapter and initializes the Host Adapter structure. */ static bool __init blogic_rdconfig(struct blogic_adapter *adapter) { … } /* blogic_reportconfig reports the configuration of Host Adapter. */ static bool __init blogic_reportconfig(struct blogic_adapter *adapter) { … } /* blogic_getres acquires the system resources necessary to use Host Adapter. */ static bool __init blogic_getres(struct blogic_adapter *adapter) { … } /* blogic_relres releases any system resources previously acquired by blogic_getres. */ static void blogic_relres(struct blogic_adapter *adapter) { … } /* blogic_initadapter initializes Host Adapter. This is the only function called during SCSI Host Adapter detection which modifies the state of the Host Adapter from its initial power on or hard reset state. */ static bool blogic_initadapter(struct blogic_adapter *adapter) { … } /* blogic_inquiry inquires about the Target Devices accessible through Host Adapter. */ static bool __init blogic_inquiry(struct blogic_adapter *adapter) { … } /* blogic_inithoststruct initializes the fields in the SCSI Host structure. The base, io_port, n_io_ports, irq, and dma_channel fields in the SCSI Host structure are intentionally left uninitialized, as this driver handles acquisition and release of these resources explicitly, as well as ensuring exclusive access to the Host Adapter hardware and data structures through explicit acquisition and release of the Host Adapter's Lock. */ static void __init blogic_inithoststruct(struct blogic_adapter *adapter, struct Scsi_Host *host) { … } /* blogic_slaveconfig will actually set the queue depth on individual scsi devices as they are permanently added to the device chain. We shamelessly rip off the SelectQueueDepths code to make this work mostly like it used to. Since we don't get called once at the end of the scan but instead get called for each device, we have to do things a bit differently. */ static int blogic_slaveconfig(struct scsi_device *dev) { … } /* blogic_init probes for BusLogic Host Adapters at the standard I/O Addresses where they may be located, initializing, registering, and reporting the configuration of each BusLogic Host Adapter it finds. It returns the number of BusLogic Host Adapters successfully initialized and registered. */ static int __init blogic_init(void) { … } /* blogic_deladapter releases all resources previously acquired to support a specific Host Adapter, including the I/O Address range, and unregisters the BusLogic Host Adapter. */ static int __exit blogic_deladapter(struct blogic_adapter *adapter) { … } /* blogic_qcompleted_ccb queues CCB for completion processing. */ static void blogic_qcompleted_ccb(struct blogic_ccb *ccb) { … } /* blogic_resultcode computes a SCSI Subsystem Result Code from the Host Adapter Status and Target Device Status. */ static int blogic_resultcode(struct blogic_adapter *adapter, enum blogic_adapter_status adapter_status, enum blogic_tgt_status tgt_status) { … } /* * turn the dma address from an inbox into a ccb pointer * This is rather inefficient. */ static struct blogic_ccb * blogic_inbox_to_ccb(struct blogic_adapter *adapter, struct blogic_inbox *inbox) { … } /* blogic_scan_inbox scans the Incoming Mailboxes saving any Incoming Mailbox entries for completion processing. */ static void blogic_scan_inbox(struct blogic_adapter *adapter) { … } /* blogic_process_ccbs iterates over the completed CCBs for Host Adapter setting the SCSI Command Result Codes, deallocating the CCBs, and calling the SCSI Subsystem Completion Routines. The Host Adapter's Lock should already have been acquired by the caller. */ static void blogic_process_ccbs(struct blogic_adapter *adapter) { … } /* blogic_inthandler handles hardware interrupts from BusLogic Host Adapters. */ static irqreturn_t blogic_inthandler(int irq_ch, void *devid) { … } /* blogic_write_outbox places CCB and Action Code into an Outgoing Mailbox for execution by Host Adapter. The Host Adapter's Lock should already have been acquired by the caller. */ static bool blogic_write_outbox(struct blogic_adapter *adapter, enum blogic_action action, struct blogic_ccb *ccb) { … } /* Error Handling (EH) support */ static int blogic_hostreset(struct scsi_cmnd *SCpnt) { … } /* blogic_qcmd creates a CCB for Command and places it into an Outgoing Mailbox for execution by the associated Host Adapter. */ static int blogic_qcmd_lck(struct scsi_cmnd *command) { … } static DEF_SCSI_QCMD(blogic_qcmd) #if 0 /* blogic_abort aborts Command if possible. */ static int blogic_abort(struct scsi_cmnd *command) { struct blogic_adapter *adapter = (struct blogic_adapter *) command->device->host->hostdata; int tgt_id = command->device->id; struct blogic_ccb *ccb; blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_request); /* Attempt to find an Active CCB for this Command. If no Active CCB for this Command is found, then no Abort is necessary. */ for (ccb = adapter->all_ccbs; ccb != NULL; ccb = ccb->next_all) if (ccb->command == command) break; if (ccb == NULL) { blogic_warn("Unable to Abort Command to Target %d - No CCB Found\n", adapter, tgt_id); return SUCCESS; } else if (ccb->status == BLOGIC_CCB_COMPLETE) { blogic_warn("Unable to Abort Command to Target %d - CCB Completed\n", adapter, tgt_id); return SUCCESS; } else if (ccb->status == BLOGIC_CCB_RESET) { blogic_warn("Unable to Abort Command to Target %d - CCB Reset\n", adapter, tgt_id); return SUCCESS; } if (blogic_multimaster_type(adapter)) { /* Attempt to Abort this CCB. MultiMaster Firmware versions prior to 5.xx do not generate Abort Tag messages, but only generate the non-tagged Abort message. Since non-tagged commands are not sent by the Host Adapter until the queue of outstanding tagged commands has completed, and the Abort message is treated as a non-tagged command, it is effectively impossible to abort commands when Tagged Queuing is active. Firmware version 5.xx does generate Abort Tag messages, so it is possible to abort commands when Tagged Queuing is active. */ if (adapter->tgt_flags[tgt_id].tagq_active && adapter->fw_ver[0] < '5') { blogic_warn("Unable to Abort CCB #%ld to Target %d - Abort Tag Not Supported\n", adapter, ccb->serial, tgt_id); return FAILURE; } else if (blogic_write_outbox(adapter, BLOGIC_MBOX_ABORT, ccb)) { blogic_warn("Aborting CCB #%ld to Target %d\n", adapter, ccb->serial, tgt_id); blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_tried); return SUCCESS; } else { blogic_warn("Unable to Abort CCB #%ld to Target %d - No Outgoing Mailboxes\n", adapter, ccb->serial, tgt_id); return FAILURE; } } else { /* Call the FlashPoint SCCB Manager to abort execution of the CCB. */ blogic_warn("Aborting CCB #%ld to Target %d\n", adapter, ccb->serial, tgt_id); blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_tried); FlashPoint_AbortCCB(adapter->cardhandle, ccb); /* The Abort may have already been completed and blogic_qcompleted_ccb been called, or it may still be pending. */ if (ccb->status == BLOGIC_CCB_COMPLETE) blogic_process_ccbs(adapter); return SUCCESS; } return SUCCESS; } #endif /* blogic_resetadapter resets Host Adapter if possible, marking all currently executing SCSI Commands as having been Reset. */ static int blogic_resetadapter(struct blogic_adapter *adapter, bool hard_reset) { … } /* blogic_diskparam returns the Heads/Sectors/Cylinders BIOS Disk Parameters for Disk. The default disk geometry is 64 heads, 32 sectors, and the appropriate number of cylinders so as not to exceed drive capacity. In order for disks equal to or larger than 1 GB to be addressable by the BIOS without exceeding the BIOS limitation of 1024 cylinders, Extended Translation may be enabled in AutoSCSI on FlashPoint Host Adapters and on "W" and "C" series MultiMaster Host Adapters, or by a dip switch setting on "S" and "A" series MultiMaster Host Adapters. With Extended Translation enabled, drives between 1 GB inclusive and 2 GB exclusive are given a disk geometry of 128 heads and 32 sectors, and drives above 2 GB inclusive are given a disk geometry of 255 heads and 63 sectors. However, if the BIOS detects that the Extended Translation setting does not match the geometry in the partition table, then the translation inferred from the partition table will be used by the BIOS, and a warning may be displayed. */ static int blogic_diskparam(struct scsi_device *sdev, struct block_device *dev, sector_t capacity, int *params) { … } /* BugLogic_ProcDirectoryInfo implements /proc/scsi/BusLogic/<N>. */ static int blogic_write_info(struct Scsi_Host *shost, char *procbuf, int bytes_avail) { … } static int blogic_show_info(struct seq_file *m, struct Scsi_Host *shost) { … } /* blogic_msg prints Driver Messages. */ __printf(2, 4) static void blogic_msg(enum blogic_msglevel msglevel, char *fmt, struct blogic_adapter *adapter, ...) { … } /* blogic_parse parses an individual option keyword. It returns true and updates the pointer if the keyword is recognized and false otherwise. */ static bool __init blogic_parse(char **str, char *keyword) { … } /* blogic_parseopts handles processing of BusLogic Driver Options specifications. BusLogic Driver Options may be specified either via the Linux Kernel Command Line or via the Loadable Kernel Module Installation Facility. Driver Options for multiple host adapters may be specified either by separating the option strings by a semicolon, or by specifying multiple "BusLogic=" strings on the command line. Individual option specifications for a single host adapter are separated by commas. The Probing and Debugging Options apply to all host adapters whereas the remaining options apply individually only to the selected host adapter. The BusLogic Driver Probing Options are described in <file:Documentation/scsi/BusLogic.rst>. */ static int __init blogic_parseopts(char *options) { … } /* Get it all started */ static const struct scsi_host_template blogic_template = …; /* blogic_setup handles processing of Kernel Command Line Arguments. */ static int __init blogic_setup(char *str) { … } /* * Exit function. Deletes all hosts associated with this driver. */ static void __exit blogic_exit(void) { … } __setup(…); #ifdef MODULE /*static struct pci_device_id blogic_pci_tbl[] = { { PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, { PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, { PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, { } };*/ static const struct pci_device_id blogic_pci_tbl[] = { {PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER)}, {PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC)}, {PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT)}, {0, }, }; #endif MODULE_DEVICE_TABLE(pci, blogic_pci_tbl); module_init(…) …; module_exit(blogic_exit);
Codebase Browser
linux