/* Linux Driver for BusLogic MultiMaster and FlashPoint SCSI Host Adapters Copyright 1995-1998 by Leonard N. Zubkoff This program is free software; you may redistribute and/or modify it under the terms of the GNU General Public License Version 2 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for complete details. 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 "2.1.17" #define blogic_drvr_date "12 September 2013" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "BusLogic.h" #include "FlashPoint.c" #ifndef FAILURE #define FAILURE (-1) #endif static 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_LICENSE("GPL"); #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_announce("***** BusLogic SCSI Driver Version " blogic_drvr_version " of " blogic_drvr_date " *****\n", adapter); blogic_announce("Copyright 1995-1998 by Leonard N. Zubkoff " "\n", 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) { struct blogic_adapter *adapter = (struct blogic_adapter *) host->hostdata; return adapter->full_model; } /* 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) { struct blogic_ccb *ccb = (struct blogic_ccb *) blk_pointer; unsigned int offset = 0; memset(blk_pointer, 0, blk_size); ccb->allocgrp_head = blkp; ccb->allocgrp_size = blk_size; while ((blk_size -= sizeof(struct blogic_ccb)) >= 0) { ccb->status = BLOGIC_CCB_FREE; ccb->adapter = adapter; ccb->dma_handle = (u32) blkp + offset; if (blogic_flashpoint_type(adapter)) { ccb->callback = blogic_qcompleted_ccb; ccb->base_addr = adapter->fpinfo.base_addr; } ccb->next = adapter->free_ccbs; ccb->next_all = adapter->all_ccbs; adapter->free_ccbs = ccb; adapter->all_ccbs = ccb; adapter->alloc_ccbs++; ccb++; offset += sizeof(struct blogic_ccb); } } /* blogic_create_initccbs allocates the initial CCBs for Host Adapter. */ static bool __init blogic_create_initccbs(struct blogic_adapter *adapter) { int blk_size = BLOGIC_CCB_GRP_ALLOCSIZE * sizeof(struct blogic_ccb); void *blk_pointer; dma_addr_t blkp; while (adapter->alloc_ccbs < adapter->initccbs) { blk_pointer = pci_alloc_consistent(adapter->pci_device, blk_size, &blkp); if (blk_pointer == NULL) { blogic_err("UNABLE TO ALLOCATE CCB GROUP - DETACHING\n", adapter); return false; } blogic_init_ccbs(adapter, blk_pointer, blk_size, blkp); } return true; } /* blogic_destroy_ccbs deallocates the CCBs for Host Adapter. */ static void blogic_destroy_ccbs(struct blogic_adapter *adapter) { struct blogic_ccb *next_ccb = adapter->all_ccbs, *ccb, *lastccb = NULL; adapter->all_ccbs = NULL; adapter->free_ccbs = NULL; while ((ccb = next_ccb) != NULL) { next_ccb = ccb->next_all; if (ccb->allocgrp_head) { if (lastccb) pci_free_consistent(adapter->pci_device, lastccb->allocgrp_size, lastccb, lastccb->allocgrp_head); lastccb = ccb; } } if (lastccb) pci_free_consistent(adapter->pci_device, lastccb->allocgrp_size, lastccb, lastccb->allocgrp_head); } /* 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) { int blk_size = BLOGIC_CCB_GRP_ALLOCSIZE * sizeof(struct blogic_ccb); int prev_alloc = adapter->alloc_ccbs; void *blk_pointer; dma_addr_t blkp; if (addl_ccbs <= 0) return; while (adapter->alloc_ccbs - prev_alloc < addl_ccbs) { blk_pointer = pci_alloc_consistent(adapter->pci_device, blk_size, &blkp); if (blk_pointer == NULL) break; blogic_init_ccbs(adapter, blk_pointer, blk_size, blkp); } if (adapter->alloc_ccbs > prev_alloc) { if (print_success) blogic_notice("Allocated %d additional CCBs (total now %d)\n", adapter, adapter->alloc_ccbs - prev_alloc, adapter->alloc_ccbs); return; } blogic_notice("Failed to allocate additional CCBs\n", adapter); if (adapter->drvr_qdepth > adapter->alloc_ccbs - adapter->tgt_count) { adapter->drvr_qdepth = adapter->alloc_ccbs - adapter->tgt_count; adapter->scsi_host->can_queue = adapter->drvr_qdepth; } } /* 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) { static unsigned long serial; struct blogic_ccb *ccb; ccb = adapter->free_ccbs; if (ccb != NULL) { ccb->serial = ++serial; adapter->free_ccbs = ccb->next; ccb->next = NULL; if (adapter->free_ccbs == NULL) blogic_create_addlccbs(adapter, adapter->inc_ccbs, true); return ccb; } blogic_create_addlccbs(adapter, adapter->inc_ccbs, true); ccb = adapter->free_ccbs; if (ccb == NULL) return NULL; ccb->serial = ++serial; adapter->free_ccbs = ccb->next; ccb->next = NULL; return ccb; } /* 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) { struct blogic_adapter *adapter = ccb->adapter; if (ccb->command != NULL) scsi_dma_unmap(ccb->command); if (dma_unmap) pci_unmap_single(adapter->pci_device, ccb->sensedata, ccb->sense_datalen, PCI_DMA_FROMDEVICE); ccb->command = NULL; ccb->status = BLOGIC_CCB_FREE; ccb->next = adapter->free_ccbs; adapter->free_ccbs = ccb; } /* 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) { unsigned char *param_p = (unsigned char *) param; unsigned char *reply_p = (unsigned char *) reply; union blogic_stat_reg statusreg; union blogic_int_reg intreg; unsigned long processor_flag = 0; int reply_b = 0, result; long timeout; /* Clear out the Reply Data if provided. */ if (replylen > 0) memset(reply, 0, replylen); /* If the IRQ Channel has not yet been acquired, then interrupts must be disabled while issuing host adapter commands since a Command Complete interrupt could occur if the IRQ Channel was previously enabled by another BusLogic Host Adapter or another driver sharing the same IRQ Channel. */ if (!adapter->irq_acquired) local_irq_save(processor_flag); /* Wait for the Host Adapter Ready bit to be set and the Command/Parameter Register Busy bit to be reset in the Status Register. */ timeout = 10000; while (--timeout >= 0) { statusreg.all = blogic_rdstatus(adapter); if (statusreg.sr.adapter_ready && !statusreg.sr.cmd_param_busy) break; udelay(100); } if (timeout < 0) { blogic_cmd_failure_reason = "Timeout waiting for Host Adapter Ready"; result = -2; goto done; } /* Write the opcode to the Command/Parameter Register. */ adapter->adapter_cmd_complete = false; blogic_setcmdparam(adapter, opcode); /* Write any additional Parameter Bytes. */ timeout = 10000; while (paramlen > 0 && --timeout >= 0) { /* Wait 100 microseconds to give the Host Adapter enough time to determine whether the last value written to the Command/Parameter Register was valid or not. If the Command Complete bit is set in the Interrupt Register, then the Command Invalid bit in the Status Register will be reset if the Operation Code or Parameter was valid and the command has completed, or set if the Operation Code or Parameter was invalid. If the Data In Register Ready bit is set in the Status Register, then the Operation Code was valid, and data is waiting to be read back from the Host Adapter. Otherwise, wait for the Command/Parameter Register Busy bit in the Status Register to be reset. */ udelay(100); intreg.all = blogic_rdint(adapter); statusreg.all = blogic_rdstatus(adapter); if (intreg.ir.cmd_complete) break; if (adapter->adapter_cmd_complete) break; if (statusreg.sr.datain_ready) break; if (statusreg.sr.cmd_param_busy) continue; blogic_setcmdparam(adapter, *param_p++); paramlen--; } if (timeout < 0) { blogic_cmd_failure_reason = "Timeout waiting for Parameter Acceptance"; result = -2; goto done; } /* The Modify I/O Address command does not cause a Command Complete Interrupt. */ if (opcode == BLOGIC_MOD_IOADDR) { statusreg.all = blogic_rdstatus(adapter); if (statusreg.sr.cmd_invalid) { blogic_cmd_failure_reason = "Modify I/O Address Invalid"; result = -1; goto done; } if (blogic_global_options.trace_config) blogic_notice("blogic_cmd(%02X) Status = %02X: " "(Modify I/O Address)\n", adapter, opcode, statusreg.all); result = 0; goto done; } /* Select an appropriate timeout value for awaiting command completion. */ switch (opcode) { case BLOGIC_INQ_DEV0TO7: case BLOGIC_INQ_DEV8TO15: case BLOGIC_INQ_DEV: /* Approximately 60 seconds. */ timeout = 60 * 10000; break; default: /* Approximately 1 second. */ timeout = 10000; break; } /* Receive any Reply Bytes, waiting for either the Command Complete bit to be set in the Interrupt Register, or for the Interrupt Handler to set the Host Adapter Command Completed bit in the Host Adapter structure. */ while (--timeout >= 0) { intreg.all = blogic_rdint(adapter); statusreg.all = blogic_rdstatus(adapter); if (intreg.ir.cmd_complete) break; if (adapter->adapter_cmd_complete) break; if (statusreg.sr.datain_ready) { if (++reply_b <= replylen) *reply_p++ = blogic_rddatain(adapter); else blogic_rddatain(adapter); } if (opcode == BLOGIC_FETCH_LOCALRAM && statusreg.sr.adapter_ready) break; udelay(100); } if (timeout < 0) { blogic_cmd_failure_reason = "Timeout waiting for Command Complete"; result = -2; goto done; } /* Clear any pending Command Complete Interrupt. */ blogic_intreset(adapter); /* Provide tracing information if requested. */ if (blogic_global_options.trace_config) { int i; blogic_notice("blogic_cmd(%02X) Status = %02X: %2d ==> %2d:", adapter, opcode, statusreg.all, replylen, reply_b); if (replylen > reply_b) replylen = reply_b; for (i = 0; i < replylen; i++) blogic_notice(" %02X", adapter, ((unsigned char *) reply)[i]); blogic_notice("\n", adapter); } /* Process Command Invalid conditions. */ if (statusreg.sr.cmd_invalid) { /* Some early BusLogic Host Adapters may not recover properly from a Command Invalid condition, so if this appears to be the case, a Soft Reset is issued to the Host Adapter. Potentially invalid commands are never attempted after Mailbox Initialization is performed, so there should be no Host Adapter state lost by a Soft Reset in response to a Command Invalid condition. */ udelay(1000); statusreg.all = blogic_rdstatus(adapter); if (statusreg.sr.cmd_invalid || statusreg.sr.rsvd || statusreg.sr.datain_ready || statusreg.sr.cmd_param_busy || !statusreg.sr.adapter_ready || !statusreg.sr.init_reqd || statusreg.sr.diag_active || statusreg.sr.diag_failed) { blogic_softreset(adapter); udelay(1000); } blogic_cmd_failure_reason = "Command Invalid"; result = -1; goto done; } /* Handle Excess Parameters Supplied conditions. */ if (paramlen > 0) { blogic_cmd_failure_reason = "Excess Parameters Supplied"; result = -1; goto done; } /* Indicate the command completed successfully. */ blogic_cmd_failure_reason = NULL; result = reply_b; /* Restore the interrupt status if necessary and return. */ done: if (!adapter->irq_acquired) local_irq_restore(processor_flag); return result; } /* blogic_add_probeaddr_isa appends a single ISA I/O Address to the list of I/O Address and Bus Probe Information to be checked for potential BusLogic Host Adapters. */ static void __init blogic_add_probeaddr_isa(unsigned long io_addr) { struct blogic_probeinfo *probeinfo; if (blogic_probeinfo_count >= BLOGIC_MAX_ADAPTERS) return; probeinfo = &blogic_probeinfo_list[blogic_probeinfo_count++]; probeinfo->adapter_type = BLOGIC_MULTIMASTER; probeinfo->adapter_bus_type = BLOGIC_ISA_BUS; probeinfo->io_addr = io_addr; probeinfo->pci_device = NULL; } /* blogic_init_probeinfo_isa initializes the list of I/O Address and Bus Probe Information to be checked for potential BusLogic SCSI Host Adapters only from the list of standard BusLogic MultiMaster ISA I/O Addresses. */ static void __init blogic_init_probeinfo_isa(struct blogic_adapter *adapter) { /* If BusLogic Driver Options specifications requested that ISA Bus Probes be inhibited, do not proceed further. */ if (blogic_probe_options.noprobe_isa) return; /* Append the list of standard BusLogic MultiMaster ISA I/O Addresses. */ if (!blogic_probe_options.limited_isa || blogic_probe_options.probe330) blogic_add_probeaddr_isa(0x330); if (!blogic_probe_options.limited_isa || blogic_probe_options.probe334) blogic_add_probeaddr_isa(0x334); if (!blogic_probe_options.limited_isa || blogic_probe_options.probe230) blogic_add_probeaddr_isa(0x230); if (!blogic_probe_options.limited_isa || blogic_probe_options.probe234) blogic_add_probeaddr_isa(0x234); if (!blogic_probe_options.limited_isa || blogic_probe_options.probe130) blogic_add_probeaddr_isa(0x130); if (!blogic_probe_options.limited_isa || blogic_probe_options.probe134) blogic_add_probeaddr_isa(0x134); } #ifdef CONFIG_PCI /* 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) { int last_exchange = probeinfo_cnt - 1, bound, j; while (last_exchange > 0) { bound = last_exchange; last_exchange = 0; for (j = 0; j < bound; j++) { struct blogic_probeinfo *probeinfo1 = &probeinfo_list[j]; struct blogic_probeinfo *probeinfo2 = &probeinfo_list[j + 1]; if (probeinfo1->bus > probeinfo2->bus || (probeinfo1->bus == probeinfo2->bus && (probeinfo1->dev > probeinfo2->dev))) { struct blogic_probeinfo tmp_probeinfo; memcpy(&tmp_probeinfo, probeinfo1, sizeof(struct blogic_probeinfo)); memcpy(probeinfo1, probeinfo2, sizeof(struct blogic_probeinfo)); memcpy(probeinfo2, &tmp_probeinfo, sizeof(struct blogic_probeinfo)); last_exchange = j; } } } } /* 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) { struct blogic_probeinfo *pr_probeinfo = &blogic_probeinfo_list[blogic_probeinfo_count]; int nonpr_mmindex = blogic_probeinfo_count + 1; int nonpr_mmcount = 0, mmcount = 0; bool force_scan_order = false; bool force_scan_order_checked = false; bool addr_seen[6]; struct pci_dev *pci_device = NULL; int i; if (blogic_probeinfo_count >= BLOGIC_MAX_ADAPTERS) return 0; blogic_probeinfo_count++; for (i = 0; i < 6; i++) addr_seen[i] = false; /* Iterate over the MultiMaster PCI Host Adapters. For each enumerated host adapter, determine whether its ISA Compatible I/O Port is enabled and if so, whether it is assigned the Primary I/O Address. A host adapter that is assigned the Primary I/O Address will always be the preferred boot device. The MultiMaster BIOS will first recognize a host adapter at the Primary I/O Address, then any other PCI host adapters, and finally any host adapters located at the remaining standard ISA I/O Addresses. When a PCI host adapter is found with its ISA Compatible I/O Port enabled, a command is issued to disable the ISA Compatible I/O Port, and it is noted that the particular standard ISA I/O Address need not be probed. */ pr_probeinfo->io_addr = 0; while ((pci_device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER, pci_device)) != NULL) { struct blogic_adapter *host_adapter = adapter; struct blogic_adapter_info adapter_info; enum blogic_isa_ioport mod_ioaddr_req; unsigned char bus; unsigned char device; unsigned int irq_ch; unsigned long base_addr0; unsigned long base_addr1; unsigned long io_addr; unsigned long pci_addr; if (pci_enable_device(pci_device)) continue; if (pci_set_dma_mask(pci_device, DMA_BIT_MASK(32))) continue; bus = pci_device->bus->number; device = pci_device->devfn >> 3; irq_ch = pci_device->irq; io_addr = base_addr0 = pci_resource_start(pci_device, 0); pci_addr = base_addr1 = pci_resource_start(pci_device, 1); if (pci_resource_flags(pci_device, 0) & IORESOURCE_MEM) { blogic_err("BusLogic: Base Address0 0x%X not I/O for " "MultiMaster Host Adapter\n", NULL, base_addr0); blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr); continue; } if (pci_resource_flags(pci_device, 1) & IORESOURCE_IO) { blogic_err("BusLogic: Base Address1 0x%X not Memory for " "MultiMaster Host Adapter\n", NULL, base_addr1); blogic_err("at PCI Bus %d Device %d PCI Address 0x%X\n", NULL, bus, device, pci_addr); continue; } if (irq_ch == 0) { blogic_err("BusLogic: IRQ Channel %d invalid for " "MultiMaster Host Adapter\n", NULL, irq_ch); blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr); continue; } if (blogic_global_options.trace_probe) { blogic_notice("BusLogic: PCI MultiMaster Host Adapter " "detected at\n", NULL); blogic_notice("BusLogic: PCI Bus %d Device %d I/O Address " "0x%X PCI Address 0x%X\n", NULL, bus, device, io_addr, pci_addr); } /* Issue the Inquire PCI Host Adapter Information command to determine the ISA Compatible I/O Port. If the ISA Compatible I/O Port is known and enabled, note that the particular Standard ISA I/O Address should not be probed. */ host_adapter->io_addr = io_addr; blogic_intreset(host_adapter); if (blogic_cmd(host_adapter, BLOGIC_INQ_PCI_INFO, NULL, 0, &adapter_info, sizeof(adapter_info)) == sizeof(adapter_info)) { if (adapter_info.isa_port < 6) addr_seen[adapter_info.isa_port] = true; } else adapter_info.isa_port = BLOGIC_IO_DISABLE; /* Issue the Modify I/O Address command to disable the ISA Compatible I/O Port. On PCI Host Adapters, the Modify I/O Address command allows modification of the ISA compatible I/O Address that the Host Adapter responds to; it does not affect the PCI compliant I/O Address assigned at system initialization. */ mod_ioaddr_req = BLOGIC_IO_DISABLE; blogic_cmd(host_adapter, BLOGIC_MOD_IOADDR, &mod_ioaddr_req, sizeof(mod_ioaddr_req), NULL, 0); /* For the first MultiMaster Host Adapter enumerated, issue the Fetch Host Adapter Local RAM command to read byte 45 of the AutoSCSI area, for the setting of the "Use Bus And Device # For PCI Scanning Seq." option. Issue the Inquire Board ID command since this option is only valid for the BT-948/958/958D. */ if (!force_scan_order_checked) { struct blogic_fetch_localram fetch_localram; struct blogic_autoscsi_byte45 autoscsi_byte45; struct blogic_board_id id; fetch_localram.offset = BLOGIC_AUTOSCSI_BASE + 45; fetch_localram.count = sizeof(autoscsi_byte45); blogic_cmd(host_adapter, BLOGIC_FETCH_LOCALRAM, &fetch_localram, sizeof(fetch_localram), &autoscsi_byte45, sizeof(autoscsi_byte45)); blogic_cmd(host_adapter, BLOGIC_GET_BOARD_ID, NULL, 0, &id, sizeof(id)); if (id.fw_ver_digit1 == '5') force_scan_order = autoscsi_byte45.force_scan_order; force_scan_order_checked = true; } /* Determine whether this MultiMaster Host Adapter has its ISA Compatible I/O Port enabled and is assigned the Primary I/O Address. If it does, then it is the Primary MultiMaster Host Adapter and must be recognized first. If it does not, then it is added to the list for probing after any Primary MultiMaster Host Adapter is probed. */ if (adapter_info.isa_port == BLOGIC_IO_330) { pr_probeinfo->adapter_type = BLOGIC_MULTIMASTER; pr_probeinfo->adapter_bus_type = BLOGIC_PCI_BUS; pr_probeinfo->io_addr = io_addr; pr_probeinfo->pci_addr = pci_addr; pr_probeinfo->bus = bus; pr_probeinfo->dev = device; pr_probeinfo->irq_ch = irq_ch; pr_probeinfo->pci_device = pci_dev_get(pci_device); mmcount++; } else if (blogic_probeinfo_count < BLOGIC_MAX_ADAPTERS) { struct blogic_probeinfo *probeinfo = &blogic_probeinfo_list[blogic_probeinfo_count++]; probeinfo->adapter_type = BLOGIC_MULTIMASTER; probeinfo->adapter_bus_type = BLOGIC_PCI_BUS; probeinfo->io_addr = io_addr; probeinfo->pci_addr = pci_addr; probeinfo->bus = bus; probeinfo->dev = device; probeinfo->irq_ch = irq_ch; probeinfo->pci_device = pci_dev_get(pci_device); nonpr_mmcount++; mmcount++; } else blogic_warn("BusLogic: Too many Host Adapters " "detected\n", NULL); } /* If the AutoSCSI "Use Bus And Device # For PCI Scanning Seq." option is ON for the first enumerated MultiMaster Host Adapter, and if that host adapter is a BT-948/958/958D, then the MultiMaster BIOS will recognize MultiMaster Host Adapters in the order of increasing PCI Bus and Device Number. In that case, sort the probe information into the same order the BIOS uses. If this option is OFF, then the MultiMaster BIOS will recognize MultiMaster Host Adapters in the order they are enumerated by the PCI BIOS, and hence no sorting is necessary. */ if (force_scan_order) blogic_sort_probeinfo(&blogic_probeinfo_list[nonpr_mmindex], nonpr_mmcount); /* If no PCI MultiMaster Host Adapter is assigned the Primary I/O Address, then the Primary I/O Address must be probed explicitly before any PCI host adapters are probed. */ if (!blogic_probe_options.noprobe_isa) if (pr_probeinfo->io_addr == 0 && (!blogic_probe_options.limited_isa || blogic_probe_options.probe330)) { pr_probeinfo->adapter_type = BLOGIC_MULTIMASTER; pr_probeinfo->adapter_bus_type = BLOGIC_ISA_BUS; pr_probeinfo->io_addr = 0x330; } /* Append the list of standard BusLogic MultiMaster ISA I/O Addresses, omitting the Primary I/O Address which has already been handled. */ if (!blogic_probe_options.noprobe_isa) { if (!addr_seen[1] && (!blogic_probe_options.limited_isa || blogic_probe_options.probe334)) blogic_add_probeaddr_isa(0x334); if (!addr_seen[2] && (!blogic_probe_options.limited_isa || blogic_probe_options.probe230)) blogic_add_probeaddr_isa(0x230); if (!addr_seen[3] && (!blogic_probe_options.limited_isa || blogic_probe_options.probe234)) blogic_add_probeaddr_isa(0x234); if (!addr_seen[4] && (!blogic_probe_options.limited_isa || blogic_probe_options.probe130)) blogic_add_probeaddr_isa(0x130); if (!addr_seen[5] && (!blogic_probe_options.limited_isa || blogic_probe_options.probe134)) blogic_add_probeaddr_isa(0x134); } /* Iterate over the older non-compliant MultiMaster PCI Host Adapters, noting the PCI bus location and assigned IRQ Channel. */ pci_device = NULL; while ((pci_device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC, pci_device)) != NULL) { unsigned char bus; unsigned char device; unsigned int irq_ch; unsigned long io_addr; if (pci_enable_device(pci_device)) continue; if (pci_set_dma_mask(pci_device, DMA_BIT_MASK(32))) continue; bus = pci_device->bus->number; device = pci_device->devfn >> 3; irq_ch = pci_device->irq; io_addr = pci_resource_start(pci_device, 0); if (io_addr == 0 || irq_ch == 0) continue; for (i = 0; i < blogic_probeinfo_count; i++) { struct blogic_probeinfo *probeinfo = &blogic_probeinfo_list[i]; if (probeinfo->io_addr == io_addr && probeinfo->adapter_type == BLOGIC_MULTIMASTER) { probeinfo->adapter_bus_type = BLOGIC_PCI_BUS; probeinfo->pci_addr = 0; probeinfo->bus = bus; probeinfo->dev = device; probeinfo->irq_ch = irq_ch; probeinfo->pci_device = pci_dev_get(pci_device); break; } } } return mmcount; } /* 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) { int fpindex = blogic_probeinfo_count, fpcount = 0; struct pci_dev *pci_device = NULL; /* Interrogate PCI Configuration Space for any FlashPoint Host Adapters. */ while ((pci_device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT, pci_device)) != NULL) { unsigned char bus; unsigned char device; unsigned int irq_ch; unsigned long base_addr0; unsigned long base_addr1; unsigned long io_addr; unsigned long pci_addr; if (pci_enable_device(pci_device)) continue; if (pci_set_dma_mask(pci_device, DMA_BIT_MASK(32))) continue; bus = pci_device->bus->number; device = pci_device->devfn >> 3; irq_ch = pci_device->irq; io_addr = base_addr0 = pci_resource_start(pci_device, 0); pci_addr = base_addr1 = pci_resource_start(pci_device, 1); #ifdef CONFIG_SCSI_FLASHPOINT if (pci_resource_flags(pci_device, 0) & IORESOURCE_MEM) { blogic_err("BusLogic: Base Address0 0x%X not I/O for " "FlashPoint Host Adapter\n", NULL, base_addr0); blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr); continue; } if (pci_resource_flags(pci_device, 1) & IORESOURCE_IO) { blogic_err("BusLogic: Base Address1 0x%X not Memory for " "FlashPoint Host Adapter\n", NULL, base_addr1); blogic_err("at PCI Bus %d Device %d PCI Address 0x%X\n", NULL, bus, device, pci_addr); continue; } if (irq_ch == 0) { blogic_err("BusLogic: IRQ Channel %d invalid for " "FlashPoint Host Adapter\n", NULL, irq_ch); blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr); continue; } if (blogic_global_options.trace_probe) { blogic_notice("BusLogic: FlashPoint Host Adapter " "detected at\n", NULL); blogic_notice("BusLogic: PCI Bus %d Device %d I/O Address " "0x%X PCI Address 0x%X\n", NULL, bus, device, io_addr, pci_addr); } if (blogic_probeinfo_count < BLOGIC_MAX_ADAPTERS) { struct blogic_probeinfo *probeinfo = &blogic_probeinfo_list[blogic_probeinfo_count++]; probeinfo->adapter_type = BLOGIC_FLASHPOINT; probeinfo->adapter_bus_type = BLOGIC_PCI_BUS; probeinfo->io_addr = io_addr; probeinfo->pci_addr = pci_addr; probeinfo->bus = bus; probeinfo->dev = device; probeinfo->irq_ch = irq_ch; probeinfo->pci_device = pci_dev_get(pci_device); fpcount++; } else blogic_warn("BusLogic: Too many Host Adapters " "detected\n", NULL); #else blogic_err("BusLogic: FlashPoint Host Adapter detected at " "PCI Bus %d Device %d\n", NULL, bus, device); blogic_err("BusLogic: I/O Address 0x%X PCI Address 0x%X, irq %d, " "but FlashPoint\n", NULL, io_addr, pci_addr, irq_ch); blogic_err("BusLogic: support was omitted in this kernel " "configuration.\n", NULL); #endif } /* The FlashPoint BIOS will scan for FlashPoint Host Adapters in the order of increasing PCI Bus and Device Number, so sort the probe information into the same order the BIOS uses. */ blogic_sort_probeinfo(&blogic_probeinfo_list[fpindex], fpcount); return fpcount; } /* 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) { /* If a PCI BIOS is present, interrogate it for MultiMaster and FlashPoint Host Adapters; otherwise, default to the standard ISA MultiMaster probe. */ if (!blogic_probe_options.noprobe_pci) { if (blogic_probe_options.multimaster_first) { blogic_init_mm_probeinfo(adapter); blogic_init_fp_probeinfo(adapter); } else if (blogic_probe_options.flashpoint_first) { blogic_init_fp_probeinfo(adapter); blogic_init_mm_probeinfo(adapter); } else { int fpcount = blogic_init_fp_probeinfo(adapter); int mmcount = blogic_init_mm_probeinfo(adapter); if (fpcount > 0 && mmcount > 0) { struct blogic_probeinfo *probeinfo = &blogic_probeinfo_list[fpcount]; struct blogic_adapter *myadapter = adapter; struct blogic_fetch_localram fetch_localram; struct blogic_bios_drvmap d0_mapbyte; while (probeinfo->adapter_bus_type != BLOGIC_PCI_BUS) probeinfo++; myadapter->io_addr = probeinfo->io_addr; fetch_localram.offset = BLOGIC_BIOS_BASE + BLOGIC_BIOS_DRVMAP; fetch_localram.count = sizeof(d0_mapbyte); blogic_cmd(myadapter, BLOGIC_FETCH_LOCALRAM, &fetch_localram, sizeof(fetch_localram), &d0_mapbyte, sizeof(d0_mapbyte)); /* If the Map Byte for BIOS Drive 0 indicates that BIOS Drive 0 is controlled by this PCI MultiMaster Host Adapter, then reverse the probe order so that MultiMaster Host Adapters are probed before FlashPoint Host Adapters. */ if (d0_mapbyte.diskgeom != BLOGIC_BIOS_NODISK) { struct blogic_probeinfo saved_probeinfo[BLOGIC_MAX_ADAPTERS]; int mmcount = blogic_probeinfo_count - fpcount; memcpy(saved_probeinfo, blogic_probeinfo_list, blogic_probeinfo_count * sizeof(struct blogic_probeinfo)); memcpy(&blogic_probeinfo_list[0], &saved_probeinfo[fpcount], mmcount * sizeof(struct blogic_probeinfo)); memcpy(&blogic_probeinfo_list[mmcount], &saved_probeinfo[0], fpcount * sizeof(struct blogic_probeinfo)); } } } } else { blogic_init_probeinfo_isa(adapter); } } #else #define blogic_init_probeinfo_list(adapter) \ blogic_init_probeinfo_isa(adapter) #endif /* CONFIG_PCI */ /* blogic_failure prints a standardized error message, and then returns false. */ static bool blogic_failure(struct blogic_adapter *adapter, char *msg) { blogic_announce_drvr(adapter); if (adapter->adapter_bus_type == BLOGIC_PCI_BUS) { blogic_err("While configuring BusLogic PCI Host Adapter at\n", adapter); blogic_err("Bus %d Device %d I/O Address 0x%X PCI Address 0x%X:\n", adapter, adapter->bus, adapter->dev, adapter->io_addr, adapter->pci_addr); } else blogic_err("While configuring BusLogic Host Adapter at " "I/O Address 0x%X:\n", adapter, adapter->io_addr); blogic_err("%s FAILED - DETACHING\n", adapter, msg); if (blogic_cmd_failure_reason != NULL) blogic_err("ADDITIONAL FAILURE INFO - %s\n", adapter, blogic_cmd_failure_reason); return false; } /* blogic_probe probes for a BusLogic Host Adapter. */ static bool __init blogic_probe(struct blogic_adapter *adapter) { union blogic_stat_reg statusreg; union blogic_int_reg intreg; union blogic_geo_reg georeg; /* FlashPoint Host Adapters are Probed by the FlashPoint SCCB Manager. */ if (blogic_flashpoint_type(adapter)) { struct fpoint_info *fpinfo = &adapter->fpinfo; fpinfo->base_addr = (u32) adapter->io_addr; fpinfo->irq_ch = adapter->irq_ch; fpinfo->present = false; if (!(FlashPoint_ProbeHostAdapter(fpinfo) == 0 && fpinfo->present)) { blogic_err("BusLogic: FlashPoint Host Adapter detected at " "PCI Bus %d Device %d\n", adapter, adapter->bus, adapter->dev); blogic_err("BusLogic: I/O Address 0x%X PCI Address 0x%X, " "but FlashPoint\n", adapter, adapter->io_addr, adapter->pci_addr); blogic_err("BusLogic: Probe Function failed to validate it.\n", adapter); return false; } if (blogic_global_options.trace_probe) blogic_notice("BusLogic_Probe(0x%X): FlashPoint Found\n", adapter, adapter->io_addr); /* Indicate the Host Adapter Probe completed successfully. */ return true; } /* Read the Status, Interrupt, and Geometry Registers to test if there are I/O ports that respond, and to check the values to determine if they are from a BusLogic Host Adapter. A nonexistent I/O port will return 0xFF, in which case there is definitely no BusLogic Host Adapter at this base I/O Address. The test here is a subset of that used by the BusLogic Host Adapter BIOS. */ statusreg.all = blogic_rdstatus(adapter); intreg.all = blogic_rdint(adapter); georeg.all = blogic_rdgeom(adapter); if (blogic_global_options.trace_probe) blogic_notice("BusLogic_Probe(0x%X): Status 0x%02X, Interrupt 0x%02X, " "Geometry 0x%02X\n", adapter, adapter->io_addr, statusreg.all, intreg.all, georeg.all); if (statusreg.all == 0 || statusreg.sr.diag_active || statusreg.sr.cmd_param_busy || statusreg.sr.rsvd || statusreg.sr.cmd_invalid || intreg.ir.rsvd != 0) return false; /* Check the undocumented Geometry Register to test if there is an I/O port that responded. Adaptec Host Adapters do not implement the Geometry Register, so this test helps serve to avoid incorrectly recognizing an Adaptec 1542A or 1542B as a BusLogic. Unfortunately, the Adaptec 1542C series does respond to the Geometry Register I/O port, but it will be rejected later when the Inquire Extended Setup Information command is issued in blogic_checkadapter. The AMI FastDisk Host Adapter is a BusLogic clone that implements the same interface as earlier BusLogic Host Adapters, including the undocumented commands, and is therefore supported by this driver. However, the AMI FastDisk always returns 0x00 upon reading the Geometry Register, so the extended translation option should always be left disabled on the AMI FastDisk. */ if (georeg.all == 0xFF) return false; /* Indicate the Host Adapter Probe completed successfully. */ return true; } /* 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) { union blogic_stat_reg statusreg; int timeout; /* FlashPoint Host Adapters are Hard Reset by the FlashPoint SCCB Manager. */ if (blogic_flashpoint_type(adapter)) { struct fpoint_info *fpinfo = &adapter->fpinfo; fpinfo->softreset = !hard_reset; fpinfo->report_underrun = true; adapter->cardhandle = FlashPoint_HardwareResetHostAdapter(fpinfo); if (adapter->cardhandle == (void *)FPOINT_BADCARD_HANDLE) return false; /* Indicate the Host Adapter Hard Reset completed successfully. */ return true; } /* Issue a Hard Reset or Soft Reset Command to the Host Adapter. The Host Adapter should respond by setting Diagnostic Active in the Status Register. */ if (hard_reset) blogic_hardreset(adapter); else blogic_softreset(adapter); /* Wait until Diagnostic Active is set in the Status Register. */ timeout = 5 * 10000; while (--timeout >= 0) { statusreg.all = blogic_rdstatus(adapter); if (statusreg.sr.diag_active) break; udelay(100); } if (blogic_global_options.trace_hw_reset) blogic_notice("BusLogic_HardwareReset(0x%X): Diagnostic Active, " "Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all); if (timeout < 0) return false; /* Wait 100 microseconds to allow completion of any initial diagnostic activity which might leave the contents of the Status Register unpredictable. */ udelay(100); /* Wait until Diagnostic Active is reset in the Status Register. */ timeout = 10 * 10000; while (--timeout >= 0) { statusreg.all = blogic_rdstatus(adapter); if (!statusreg.sr.diag_active) break; udelay(100); } if (blogic_global_options.trace_hw_reset) blogic_notice("BusLogic_HardwareReset(0x%X): Diagnostic Completed, " "Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all); if (timeout < 0) return false; /* Wait until at least one of the Diagnostic Failure, Host Adapter Ready, or Data In Register Ready bits is set in the Status Register. */ timeout = 10000; while (--timeout >= 0) { statusreg.all = blogic_rdstatus(adapter); if (statusreg.sr.diag_failed || statusreg.sr.adapter_ready || statusreg.sr.datain_ready) break; udelay(100); } if (blogic_global_options.trace_hw_reset) blogic_notice("BusLogic_HardwareReset(0x%X): Host Adapter Ready, " "Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all); if (timeout < 0) return false; /* If Diagnostic Failure is set or Host Adapter Ready is reset, then an error occurred during the Host Adapter diagnostics. If Data In Register Ready is set, then there is an Error Code available. */ if (statusreg.sr.diag_failed || !statusreg.sr.adapter_ready) { blogic_cmd_failure_reason = NULL; blogic_failure(adapter, "HARD RESET DIAGNOSTICS"); blogic_err("HOST ADAPTER STATUS REGISTER = %02X\n", adapter, statusreg.all); if (statusreg.sr.datain_ready) blogic_err("HOST ADAPTER ERROR CODE = %d\n", adapter, blogic_rddatain(adapter)); return false; } /* Indicate the Host Adapter Hard Reset completed successfully. */ return true; } /* blogic_checkadapter checks to be sure this really is a BusLogic Host Adapter. */ static bool __init blogic_checkadapter(struct blogic_adapter *adapter) { struct blogic_ext_setup ext_setupinfo; unsigned char req_replylen; bool result = true; /* FlashPoint Host Adapters do not require this protection. */ if (blogic_flashpoint_type(adapter)) return true; /* Issue the Inquire Extended Setup Information command. Only genuine BusLogic Host Adapters and true clones support this command. Adaptec 1542C series Host Adapters that respond to the Geometry Register I/O port will fail this command. */ req_replylen = sizeof(ext_setupinfo); if (blogic_cmd(adapter, BLOGIC_INQ_EXTSETUP, &req_replylen, sizeof(req_replylen), &ext_setupinfo, sizeof(ext_setupinfo)) != sizeof(ext_setupinfo)) result = false; /* Provide tracing information if requested and return. */ if (blogic_global_options.trace_probe) blogic_notice("BusLogic_Check(0x%X): MultiMaster %s\n", adapter, adapter->io_addr, (result ? "Found" : "Not Found")); return result; } /* blogic_rdconfig reads the Configuration Information from Host Adapter and initializes the Host Adapter structure. */ static bool __init blogic_rdconfig(struct blogic_adapter *adapter) { struct blogic_board_id id; struct blogic_config config; struct blogic_setup_info setupinfo; struct blogic_ext_setup ext_setupinfo; unsigned char model[5]; unsigned char fw_ver_digit3; unsigned char fw_ver_letter; struct blogic_adapter_info adapter_info; struct blogic_fetch_localram fetch_localram; struct blogic_autoscsi autoscsi; union blogic_geo_reg georeg; unsigned char req_replylen; unsigned char *tgt, ch; int tgt_id, i; /* Configuration Information for FlashPoint Host Adapters is provided in the fpoint_info structure by the FlashPoint SCCB Manager's Probe Function. Initialize fields in the Host Adapter structure from the fpoint_info structure. */ if (blogic_flashpoint_type(adapter)) { struct fpoint_info *fpinfo = &adapter->fpinfo; tgt = adapter->model; *tgt++ = 'B'; *tgt++ = 'T'; *tgt++ = '-'; for (i = 0; i < sizeof(fpinfo->model); i++) *tgt++ = fpinfo->model[i]; *tgt++ = '\0'; strcpy(adapter->fw_ver, FLASHPOINT_FW_VER); adapter->scsi_id = fpinfo->scsi_id; adapter->ext_trans_enable = fpinfo->ext_trans_enable; adapter->parity = fpinfo->parity; adapter->reset_enabled = !fpinfo->softreset; adapter->level_int = true; adapter->wide = fpinfo->wide; adapter->differential = false; adapter->scam = true; adapter->ultra = true; adapter->ext_lun = true; adapter->terminfo_valid = true; adapter->low_term = fpinfo->low_term; adapter->high_term = fpinfo->high_term; adapter->scam_enabled = fpinfo->scam_enabled; adapter->scam_lev2 = fpinfo->scam_lev2; adapter->drvr_sglimit = BLOGIC_SG_LIMIT; adapter->maxdev = (adapter->wide ? 16 : 8); adapter->maxlun = 32; adapter->initccbs = 4 * BLOGIC_CCB_GRP_ALLOCSIZE; adapter->inc_ccbs = BLOGIC_CCB_GRP_ALLOCSIZE; adapter->drvr_qdepth = 255; adapter->adapter_qdepth = adapter->drvr_qdepth; adapter->sync_ok = fpinfo->sync_ok; adapter->fast_ok = fpinfo->fast_ok; adapter->ultra_ok = fpinfo->ultra_ok; adapter->wide_ok = fpinfo->wide_ok; adapter->discon_ok = fpinfo->discon_ok; adapter->tagq_ok = 0xFFFF; goto common; } /* Issue the Inquire Board ID command. */ if (blogic_cmd(adapter, BLOGIC_GET_BOARD_ID, NULL, 0, &id, sizeof(id)) != sizeof(id)) return blogic_failure(adapter, "INQUIRE BOARD ID"); /* Issue the Inquire Configuration command. */ if (blogic_cmd(adapter, BLOGIC_INQ_CONFIG, NULL, 0, &config, sizeof(config)) != sizeof(config)) return blogic_failure(adapter, "INQUIRE CONFIGURATION"); /* Issue the Inquire Setup Information command. */ req_replylen = sizeof(setupinfo); if (blogic_cmd(adapter, BLOGIC_INQ_SETUPINFO, &req_replylen, sizeof(req_replylen), &setupinfo, sizeof(setupinfo)) != sizeof(setupinfo)) return blogic_failure(adapter, "INQUIRE SETUP INFORMATION"); /* Issue the Inquire Extended Setup Information command. */ req_replylen = sizeof(ext_setupinfo); if (blogic_cmd(adapter, BLOGIC_INQ_EXTSETUP, &req_replylen, sizeof(req_replylen), &ext_setupinfo, sizeof(ext_setupinfo)) != sizeof(ext_setupinfo)) return blogic_failure(adapter, "INQUIRE EXTENDED SETUP INFORMATION"); /* Issue the Inquire Firmware Version 3rd Digit command. */ fw_ver_digit3 = '\0'; if (id.fw_ver_digit1 > '0') if (blogic_cmd(adapter, BLOGIC_INQ_FWVER_D3, NULL, 0, &fw_ver_digit3, sizeof(fw_ver_digit3)) != sizeof(fw_ver_digit3)) return blogic_failure(adapter, "INQUIRE FIRMWARE 3RD DIGIT"); /* Issue the Inquire Host Adapter Model Number command. */ if (ext_setupinfo.bus_type == 'A' && id.fw_ver_digit1 == '2') /* BusLogic BT-542B ISA 2.xx */ strcpy(model, "542B"); else if (ext_setupinfo.bus_type == 'E' && id.fw_ver_digit1 == '2' && (id.fw_ver_digit2 <= '1' || (id.fw_ver_digit2 == '2' && fw_ver_digit3 == '0'))) /* BusLogic BT-742A EISA 2.1x or 2.20 */ strcpy(model, "742A"); else if (ext_setupinfo.bus_type == 'E' && id.fw_ver_digit1 == '0') /* AMI FastDisk EISA Series 441 0.x */ strcpy(model, "747A"); else { req_replylen = sizeof(model); if (blogic_cmd(adapter, BLOGIC_INQ_MODELNO, &req_replylen, sizeof(req_replylen), &model, sizeof(model)) != sizeof(model)) return blogic_failure(adapter, "INQUIRE HOST ADAPTER MODEL NUMBER"); } /* BusLogic MultiMaster Host Adapters can be identified by their model number and the major version number of their firmware as follows: 5.xx BusLogic "W" Series Host Adapters: BT-948/958/958D 4.xx BusLogic "C" Series Host Adapters: BT-946C/956C/956CD/747C/757C/757CD/445C/545C/540CF 3.xx BusLogic "S" Series Host Adapters: BT-747S/747D/757S/757D/445S/545S/542D BT-542B/742A (revision H) 2.xx BusLogic "A" Series Host Adapters: BT-542B/742A (revision G and below) 0.xx AMI FastDisk VLB/EISA BusLogic Clone Host Adapter */ /* Save the Model Name and Host Adapter Name in the Host Adapter structure. */ tgt = adapter->model; *tgt++ = 'B'; *tgt++ = 'T'; *tgt++ = '-'; for (i = 0; i < sizeof(model); i++) { ch = model[i]; if (ch == ' ' || ch == '\0') break; *tgt++ = ch; } *tgt++ = '\0'; /* Save the Firmware Version in the Host Adapter structure. */ tgt = adapter->fw_ver; *tgt++ = id.fw_ver_digit1; *tgt++ = '.'; *tgt++ = id.fw_ver_digit2; if (fw_ver_digit3 != ' ' && fw_ver_digit3 != '\0') *tgt++ = fw_ver_digit3; *tgt = '\0'; /* Issue the Inquire Firmware Version Letter command. */ if (strcmp(adapter->fw_ver, "3.3") >= 0) { if (blogic_cmd(adapter, BLOGIC_INQ_FWVER_LETTER, NULL, 0, &fw_ver_letter, sizeof(fw_ver_letter)) != sizeof(fw_ver_letter)) return blogic_failure(adapter, "INQUIRE FIRMWARE VERSION LETTER"); if (fw_ver_letter != ' ' && fw_ver_letter != '\0') *tgt++ = fw_ver_letter; *tgt = '\0'; } /* Save the Host Adapter SCSI ID in the Host Adapter structure. */ adapter->scsi_id = config.id; /* Determine the Bus Type and save it in the Host Adapter structure, determine and save the IRQ Channel if necessary, and determine and save the DMA Channel for ISA Host Adapters. */ adapter->adapter_bus_type = blogic_adater_bus_types[adapter->model[3] - '4']; if (adapter->irq_ch == 0) { if (config.irq_ch9) adapter->irq_ch = 9; else if (config.irq_ch10) adapter->irq_ch = 10; else if (config.irq_ch11) adapter->irq_ch = 11; else if (config.irq_ch12) adapter->irq_ch = 12; else if (config.irq_ch14) adapter->irq_ch = 14; else if (config.irq_ch15) adapter->irq_ch = 15; } if (adapter->adapter_bus_type == BLOGIC_ISA_BUS) { if (config.dma_ch5) adapter->dma_ch = 5; else if (config.dma_ch6) adapter->dma_ch = 6; else if (config.dma_ch7) adapter->dma_ch = 7; } /* Determine whether Extended Translation is enabled and save it in the Host Adapter structure. */ georeg.all = blogic_rdgeom(adapter); adapter->ext_trans_enable = georeg.gr.ext_trans_enable; /* Save the Scatter Gather Limits, Level Sensitive Interrupt flag, Wide SCSI flag, Differential SCSI flag, SCAM Supported flag, and Ultra SCSI flag in the Host Adapter structure. */ adapter->adapter_sglimit = ext_setupinfo.sg_limit; adapter->drvr_sglimit = adapter->adapter_sglimit; if (adapter->adapter_sglimit > BLOGIC_SG_LIMIT) adapter->drvr_sglimit = BLOGIC_SG_LIMIT; if (ext_setupinfo.misc.level_int) adapter->level_int = true; adapter->wide = ext_setupinfo.wide; adapter->differential = ext_setupinfo.differential; adapter->scam = ext_setupinfo.scam; adapter->ultra = ext_setupinfo.ultra; /* Determine whether Extended LUN Format CCBs are supported and save the information in the Host Adapter structure. */ if (adapter->fw_ver[0] == '5' || (adapter->fw_ver[0] == '4' && adapter->wide)) adapter->ext_lun = true; /* Issue the Inquire PCI Host Adapter Information command to read the Termination Information from "W" series MultiMaster Host Adapters. */ if (adapter->fw_ver[0] == '5') { if (blogic_cmd(adapter, BLOGIC_INQ_PCI_INFO, NULL, 0, &adapter_info, sizeof(adapter_info)) != sizeof(adapter_info)) return blogic_failure(adapter, "INQUIRE PCI HOST ADAPTER INFORMATION"); /* Save the Termination Information in the Host Adapter structure. */ if (adapter_info.genericinfo_valid) { adapter->terminfo_valid = true; adapter->low_term = adapter_info.low_term; adapter->high_term = adapter_info.high_term; } } /* Issue the Fetch Host Adapter Local RAM command to read the AutoSCSI data from "W" and "C" series MultiMaster Host Adapters. */ if (adapter->fw_ver[0] >= '4') { fetch_localram.offset = BLOGIC_AUTOSCSI_BASE; fetch_localram.count = sizeof(autoscsi); if (blogic_cmd(adapter, BLOGIC_FETCH_LOCALRAM, &fetch_localram, sizeof(fetch_localram), &autoscsi, sizeof(autoscsi)) != sizeof(autoscsi)) return blogic_failure(adapter, "FETCH HOST ADAPTER LOCAL RAM"); /* Save the Parity Checking Enabled, Bus Reset Enabled, and Termination Information in the Host Adapter structure. */ adapter->parity = autoscsi.parity; adapter->reset_enabled = autoscsi.reset_enabled; if (adapter->fw_ver[0] == '4') { adapter->terminfo_valid = true; adapter->low_term = autoscsi.low_term; adapter->high_term = autoscsi.high_term; } /* Save the Wide Permitted, Fast Permitted, Synchronous Permitted, Disconnect Permitted, Ultra Permitted, and SCAM Information in the Host Adapter structure. */ adapter->wide_ok = autoscsi.wide_ok; adapter->fast_ok = autoscsi.fast_ok; adapter->sync_ok = autoscsi.sync_ok; adapter->discon_ok = autoscsi.discon_ok; if (adapter->ultra) adapter->ultra_ok = autoscsi.ultra_ok; if (adapter->scam) { adapter->scam_enabled = autoscsi.scam_enabled; adapter->scam_lev2 = autoscsi.scam_lev2; } } /* Initialize fields in the Host Adapter structure for "S" and "A" series MultiMaster Host Adapters. */ if (adapter->fw_ver[0] < '4') { if (setupinfo.sync) { adapter->sync_ok = 0xFF; if (adapter->adapter_bus_type == BLOGIC_EISA_BUS) { if (ext_setupinfo.misc.fast_on_eisa) adapter->fast_ok = 0xFF; if (strcmp(adapter->model, "BT-757") == 0) adapter->wide_ok = 0xFF; } } adapter->discon_ok = 0xFF; adapter->parity = setupinfo.parity; adapter->reset_enabled = true; } /* Determine the maximum number of Target IDs and Logical Units supported by this driver for Wide and Narrow Host Adapters. */ adapter->maxdev = (adapter->wide ? 16 : 8); adapter->maxlun = (adapter->ext_lun ? 32 : 8); /* Select appropriate values for the Mailbox Count, Driver Queue Depth, Initial CCBs, and Incremental CCBs variables based on whether or not Strict Round Robin Mode is supported. If Strict Round Robin Mode is supported, then there is no performance degradation in using the maximum possible number of Outgoing and Incoming Mailboxes and allowing the Tagged and Untagged Queue Depths to determine the actual utilization. If Strict Round Robin Mode is not supported, then the Host Adapter must scan all the Outgoing Mailboxes whenever an Outgoing Mailbox entry is made, which can cause a substantial performance penalty. The host adapters actually have room to store the following number of CCBs internally; that is, they can internally queue and manage this many active commands on the SCSI bus simultaneously. Performance measurements demonstrate that the Driver Queue Depth should be set to the Mailbox Count, rather than the Host Adapter Queue Depth (internal CCB capacity), as it is more efficient to have the queued commands waiting in Outgoing Mailboxes if necessary than to block the process in the higher levels of the SCSI Subsystem. 192 BT-948/958/958D 100 BT-946C/956C/956CD/747C/757C/757CD/445C 50 BT-545C/540CF 30 BT-747S/747D/757S/757D/445S/545S/542D/542B/742A */ if (adapter->fw_ver[0] == '5') adapter->adapter_qdepth = 192; else if (adapter->fw_ver[0] == '4') adapter->adapter_qdepth = (adapter->adapter_bus_type != BLOGIC_ISA_BUS ? 100 : 50); else adapter->adapter_qdepth = 30; if (strcmp(adapter->fw_ver, "3.31") >= 0) { adapter->strict_rr = true; adapter->mbox_count = BLOGIC_MAX_MAILBOX; } else { adapter->strict_rr = false; adapter->mbox_count = 32; } adapter->drvr_qdepth = adapter->mbox_count; adapter->initccbs = 4 * BLOGIC_CCB_GRP_ALLOCSIZE; adapter->inc_ccbs = BLOGIC_CCB_GRP_ALLOCSIZE; /* Tagged Queuing support is available and operates properly on all "W" series MultiMaster Host Adapters, on "C" series MultiMaster Host Adapters with firmware version 4.22 and above, and on "S" series MultiMaster Host Adapters with firmware version 3.35 and above. */ adapter->tagq_ok = 0; switch (adapter->fw_ver[0]) { case '5': adapter->tagq_ok = 0xFFFF; break; case '4': if (strcmp(adapter->fw_ver, "4.22") >= 0) adapter->tagq_ok = 0xFFFF; break; case '3': if (strcmp(adapter->fw_ver, "3.35") >= 0) adapter->tagq_ok = 0xFFFF; break; } /* Determine the Host Adapter BIOS Address if the BIOS is enabled and save it in the Host Adapter structure. The BIOS is disabled if the bios_addr is 0. */ adapter->bios_addr = ext_setupinfo.bios_addr << 12; /* ISA Host Adapters require Bounce Buffers if there is more than 16MB memory. */ if (adapter->adapter_bus_type == BLOGIC_ISA_BUS && (void *) high_memory > (void *) MAX_DMA_ADDRESS) adapter->need_bouncebuf = true; /* BusLogic BT-445S Host Adapters prior to board revision E have a hardware bug whereby when the BIOS is enabled, transfers to/from the same address range the BIOS occupies modulo 16MB are handled incorrectly. Only properly functioning BT-445S Host Adapters have firmware version 3.37, so require that ISA Bounce Buffers be used for the buggy BT-445S models if there is more than 16MB memory. */ if (adapter->bios_addr > 0 && strcmp(adapter->model, "BT-445S") == 0 && strcmp(adapter->fw_ver, "3.37") < 0 && (void *) high_memory > (void *) MAX_DMA_ADDRESS) adapter->need_bouncebuf = true; /* Initialize parameters common to MultiMaster and FlashPoint Host Adapters. */ common: /* Initialize the Host Adapter Full Model Name from the Model Name. */ strcpy(adapter->full_model, "BusLogic "); strcat(adapter->full_model, adapter->model); /* Select an appropriate value for the Tagged Queue Depth either from a BusLogic Driver Options specification, or based on whether this Host Adapter requires that ISA Bounce Buffers be used. The Tagged Queue Depth is left at 0 for automatic determination in BusLogic_SelectQueueDepths. Initialize the Untagged Queue Depth. */ for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++) { unsigned char qdepth = 0; if (adapter->drvr_opts != NULL && adapter->drvr_opts->qdepth[tgt_id] > 0) qdepth = adapter->drvr_opts->qdepth[tgt_id]; else if (adapter->need_bouncebuf) qdepth = BLOGIC_TAG_DEPTH_BB; adapter->qdepth[tgt_id] = qdepth; } if (adapter->need_bouncebuf) adapter->untag_qdepth = BLOGIC_UNTAG_DEPTH_BB; else adapter->untag_qdepth = BLOGIC_UNTAG_DEPTH; if (adapter->drvr_opts != NULL) adapter->common_qdepth = adapter->drvr_opts->common_qdepth; if (adapter->common_qdepth > 0 && adapter->common_qdepth < adapter->untag_qdepth) adapter->untag_qdepth = adapter->common_qdepth; /* Tagged Queuing is only allowed if Disconnect/Reconnect is permitted. Therefore, mask the Tagged Queuing Permitted Default bits with the Disconnect/Reconnect Permitted bits. */ adapter->tagq_ok &= adapter->discon_ok; /* Combine the default Tagged Queuing Permitted bits with any BusLogic Driver Options Tagged Queuing specification. */ if (adapter->drvr_opts != NULL) adapter->tagq_ok = (adapter->drvr_opts->tagq_ok & adapter->drvr_opts->tagq_ok_mask) | (adapter->tagq_ok & ~adapter->drvr_opts->tagq_ok_mask); /* Select an appropriate value for Bus Settle Time either from a BusLogic Driver Options specification, or from BLOGIC_BUS_SETTLE_TIME. */ if (adapter->drvr_opts != NULL && adapter->drvr_opts->bus_settle_time > 0) adapter->bus_settle_time = adapter->drvr_opts->bus_settle_time; else adapter->bus_settle_time = BLOGIC_BUS_SETTLE_TIME; /* Indicate reading the Host Adapter Configuration completed successfully. */ return true; } /* blogic_reportconfig reports the configuration of Host Adapter. */ static bool __init blogic_reportconfig(struct blogic_adapter *adapter) { unsigned short alltgt_mask = (1 << adapter->maxdev) - 1; unsigned short sync_ok, fast_ok; unsigned short ultra_ok, wide_ok; unsigned short discon_ok, tagq_ok; bool common_syncneg, common_tagq_depth; char syncstr[BLOGIC_MAXDEV + 1]; char widestr[BLOGIC_MAXDEV + 1]; char discon_str[BLOGIC_MAXDEV + 1]; char tagq_str[BLOGIC_MAXDEV + 1]; char *syncmsg = syncstr; char *widemsg = widestr; char *discon_msg = discon_str; char *tagq_msg = tagq_str; int tgt_id; blogic_info("Configuring BusLogic Model %s %s%s%s%s SCSI Host Adapter\n", adapter, adapter->model, blogic_adapter_busnames[adapter->adapter_bus_type], (adapter->wide ? " Wide" : ""), (adapter->differential ? " Differential" : ""), (adapter->ultra ? " Ultra" : "")); blogic_info(" Firmware Version: %s, I/O Address: 0x%X, " "IRQ Channel: %d/%s\n", adapter, adapter->fw_ver, adapter->io_addr, adapter->irq_ch, (adapter->level_int ? "Level" : "Edge")); if (adapter->adapter_bus_type != BLOGIC_PCI_BUS) { blogic_info(" DMA Channel: ", adapter); if (adapter->dma_ch > 0) blogic_info("%d, ", adapter, adapter->dma_ch); else blogic_info("None, ", adapter); if (adapter->bios_addr > 0) blogic_info("BIOS Address: 0x%X, ", adapter, adapter->bios_addr); else blogic_info("BIOS Address: None, ", adapter); } else { blogic_info(" PCI Bus: %d, Device: %d, Address: ", adapter, adapter->bus, adapter->dev); if (adapter->pci_addr > 0) blogic_info("0x%X, ", adapter, adapter->pci_addr); else blogic_info("Unassigned, ", adapter); } blogic_info("Host Adapter SCSI ID: %d\n", adapter, adapter->scsi_id); blogic_info(" Parity Checking: %s, Extended Translation: %s\n", adapter, (adapter->parity ? "Enabled" : "Disabled"), (adapter->ext_trans_enable ? "Enabled" : "Disabled")); alltgt_mask &= ~(1 << adapter->scsi_id); sync_ok = adapter->sync_ok & alltgt_mask; fast_ok = adapter->fast_ok & alltgt_mask; ultra_ok = adapter->ultra_ok & alltgt_mask; if ((blogic_multimaster_type(adapter) && (adapter->fw_ver[0] >= '4' || adapter->adapter_bus_type == BLOGIC_EISA_BUS)) || blogic_flashpoint_type(adapter)) { common_syncneg = false; if (sync_ok == 0) { syncmsg = "Disabled"; common_syncneg = true; } else if (sync_ok == alltgt_mask) { if (fast_ok == 0) { syncmsg = "Slow"; common_syncneg = true; } else if (fast_ok == alltgt_mask) { if (ultra_ok == 0) { syncmsg = "Fast"; common_syncneg = true; } else if (ultra_ok == alltgt_mask) { syncmsg = "Ultra"; common_syncneg = true; } } } if (!common_syncneg) { for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) syncstr[tgt_id] = ((!(sync_ok & (1 << tgt_id))) ? 'N' : (!(fast_ok & (1 << tgt_id)) ? 'S' : (!(ultra_ok & (1 << tgt_id)) ? 'F' : 'U'))); syncstr[adapter->scsi_id] = '#'; syncstr[adapter->maxdev] = '\0'; } } else syncmsg = (sync_ok == 0 ? "Disabled" : "Enabled"); wide_ok = adapter->wide_ok & alltgt_mask; if (wide_ok == 0) widemsg = "Disabled"; else if (wide_ok == alltgt_mask) widemsg = "Enabled"; else { for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) widestr[tgt_id] = ((wide_ok & (1 << tgt_id)) ? 'Y' : 'N'); widestr[adapter->scsi_id] = '#'; widestr[adapter->maxdev] = '\0'; } discon_ok = adapter->discon_ok & alltgt_mask; if (discon_ok == 0) discon_msg = "Disabled"; else if (discon_ok == alltgt_mask) discon_msg = "Enabled"; else { for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) discon_str[tgt_id] = ((discon_ok & (1 << tgt_id)) ? 'Y' : 'N'); discon_str[adapter->scsi_id] = '#'; discon_str[adapter->maxdev] = '\0'; } tagq_ok = adapter->tagq_ok & alltgt_mask; if (tagq_ok == 0) tagq_msg = "Disabled"; else if (tagq_ok == alltgt_mask) tagq_msg = "Enabled"; else { for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) tagq_str[tgt_id] = ((tagq_ok & (1 << tgt_id)) ? 'Y' : 'N'); tagq_str[adapter->scsi_id] = '#'; tagq_str[adapter->maxdev] = '\0'; } blogic_info(" Synchronous Negotiation: %s, Wide Negotiation: %s