| |
| /* |
| |
| Linux Driver for BusLogic MultiMaster and FlashPoint SCSI Host Adapters |
| |
| Copyright 1995-1998 by Leonard N. Zubkoff <lnz@dandelion.com> |
| |
| 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 BusLogic_DriverVersion "2.1.16" |
| #define BusLogic_DriverDate "18 July 2002" |
| |
| #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 <scsi/scsicam.h> |
| |
| #include <asm/dma.h> |
| #include <asm/io.h> |
| #include <asm/system.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 (-1) |
| #endif |
| |
| static struct scsi_host_template Bus_Logic_template; |
| |
| /* |
| BusLogic_DriverOptionsCount 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 BusLogic_DriverOptionsCount; |
| |
| |
| /* |
| BusLogic_DriverOptions 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 BusLogic_DriverOptions BusLogic_DriverOptions[BusLogic_MaxHostAdapters]; |
| |
| |
| /* |
| BusLogic can be assigned a string by insmod. |
| */ |
| |
| MODULE_LICENSE("GPL"); |
| #ifdef MODULE |
| static char *BusLogic; |
| module_param(BusLogic, charp, 0); |
| #endif |
| |
| |
| /* |
| BusLogic_ProbeOptions is a set of Probe Options to be applied across |
| all BusLogic Host Adapters. |
| */ |
| |
| static struct BusLogic_ProbeOptions BusLogic_ProbeOptions; |
| |
| |
| /* |
| BusLogic_GlobalOptions is a set of Global Options to be applied across |
| all BusLogic Host Adapters. |
| */ |
| |
| static struct BusLogic_GlobalOptions BusLogic_GlobalOptions; |
| |
| static LIST_HEAD(BusLogic_host_list); |
| |
| /* |
| BusLogic_ProbeInfoCount is the number of entries in BusLogic_ProbeInfoList. |
| */ |
| |
| static int BusLogic_ProbeInfoCount; |
| |
| |
| /* |
| BusLogic_ProbeInfoList 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 BusLogic_ProbeInfo *BusLogic_ProbeInfoList; |
| |
| |
| /* |
| BusLogic_CommandFailureReason holds a string identifying the reason why a |
| call to BusLogic_Command failed. It is only non-NULL when BusLogic_Command |
| returns a failure code. |
| */ |
| |
| static char *BusLogic_CommandFailureReason; |
| |
| /* |
| BusLogic_AnnounceDriver announces the Driver Version and Date, Author's |
| Name, Copyright Notice, and Electronic Mail Address. |
| */ |
| |
| static void BusLogic_AnnounceDriver(struct BusLogic_HostAdapter *HostAdapter) |
| { |
| BusLogic_Announce("***** BusLogic SCSI Driver Version " BusLogic_DriverVersion " of " BusLogic_DriverDate " *****\n", HostAdapter); |
| BusLogic_Announce("Copyright 1995-1998 by Leonard N. Zubkoff " "<lnz@dandelion.com>\n", HostAdapter); |
| } |
| |
| |
| /* |
| BusLogic_DriverInfo returns the Host Adapter Name to identify this SCSI |
| Driver and Host Adapter. |
| */ |
| |
| static const char *BusLogic_DriverInfo(struct Scsi_Host *Host) |
| { |
| struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) Host->hostdata; |
| return HostAdapter->FullModelName; |
| } |
| |
| /* |
| BusLogic_InitializeCCBs initializes a group of Command Control Blocks (CCBs) |
| for Host Adapter from the BlockSize bytes located at BlockPointer. The newly |
| created CCBs are added to Host Adapter's free list. |
| */ |
| |
| static void BusLogic_InitializeCCBs(struct BusLogic_HostAdapter *HostAdapter, void *BlockPointer, int BlockSize, dma_addr_t BlockPointerHandle) |
| { |
| struct BusLogic_CCB *CCB = (struct BusLogic_CCB *) BlockPointer; |
| unsigned int offset = 0; |
| memset(BlockPointer, 0, BlockSize); |
| CCB->AllocationGroupHead = BlockPointerHandle; |
| CCB->AllocationGroupSize = BlockSize; |
| while ((BlockSize -= sizeof(struct BusLogic_CCB)) >= 0) { |
| CCB->Status = BusLogic_CCB_Free; |
| CCB->HostAdapter = HostAdapter; |
| CCB->DMA_Handle = (u32) BlockPointerHandle + offset; |
| if (BusLogic_FlashPointHostAdapterP(HostAdapter)) { |
| CCB->CallbackFunction = BusLogic_QueueCompletedCCB; |
| CCB->BaseAddress = HostAdapter->FlashPointInfo.BaseAddress; |
| } |
| CCB->Next = HostAdapter->Free_CCBs; |
| CCB->NextAll = HostAdapter->All_CCBs; |
| HostAdapter->Free_CCBs = CCB; |
| HostAdapter->All_CCBs = CCB; |
| HostAdapter->AllocatedCCBs++; |
| CCB++; |
| offset += sizeof(struct BusLogic_CCB); |
| } |
| } |
| |
| |
| /* |
| BusLogic_CreateInitialCCBs allocates the initial CCBs for Host Adapter. |
| */ |
| |
| static bool __init BusLogic_CreateInitialCCBs(struct BusLogic_HostAdapter *HostAdapter) |
| { |
| int BlockSize = BusLogic_CCB_AllocationGroupSize * sizeof(struct BusLogic_CCB); |
| void *BlockPointer; |
| dma_addr_t BlockPointerHandle; |
| while (HostAdapter->AllocatedCCBs < HostAdapter->InitialCCBs) { |
| BlockPointer = pci_alloc_consistent(HostAdapter->PCI_Device, BlockSize, &BlockPointerHandle); |
| if (BlockPointer == NULL) { |
| BusLogic_Error("UNABLE TO ALLOCATE CCB GROUP - DETACHING\n", HostAdapter); |
| return false; |
| } |
| BusLogic_InitializeCCBs(HostAdapter, BlockPointer, BlockSize, BlockPointerHandle); |
| } |
| return true; |
| } |
| |
| |
| /* |
| BusLogic_DestroyCCBs deallocates the CCBs for Host Adapter. |
| */ |
| |
| static void BusLogic_DestroyCCBs(struct BusLogic_HostAdapter *HostAdapter) |
| { |
| struct BusLogic_CCB *NextCCB = HostAdapter->All_CCBs, *CCB, *Last_CCB = NULL; |
| HostAdapter->All_CCBs = NULL; |
| HostAdapter->Free_CCBs = NULL; |
| while ((CCB = NextCCB) != NULL) { |
| NextCCB = CCB->NextAll; |
| if (CCB->AllocationGroupHead) { |
| if (Last_CCB) |
| pci_free_consistent(HostAdapter->PCI_Device, Last_CCB->AllocationGroupSize, Last_CCB, Last_CCB->AllocationGroupHead); |
| Last_CCB = CCB; |
| } |
| } |
| if (Last_CCB) |
| pci_free_consistent(HostAdapter->PCI_Device, Last_CCB->AllocationGroupSize, Last_CCB, Last_CCB->AllocationGroupHead); |
| } |
| |
| |
| /* |
| BusLogic_CreateAdditionalCCBs 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 BusLogic_CreateAdditionalCCBs(struct BusLogic_HostAdapter *HostAdapter, int AdditionalCCBs, bool SuccessMessageP) |
| { |
| int BlockSize = BusLogic_CCB_AllocationGroupSize * sizeof(struct BusLogic_CCB); |
| int PreviouslyAllocated = HostAdapter->AllocatedCCBs; |
| void *BlockPointer; |
| dma_addr_t BlockPointerHandle; |
| if (AdditionalCCBs <= 0) |
| return; |
| while (HostAdapter->AllocatedCCBs - PreviouslyAllocated < AdditionalCCBs) { |
| BlockPointer = pci_alloc_consistent(HostAdapter->PCI_Device, BlockSize, &BlockPointerHandle); |
| if (BlockPointer == NULL) |
| break; |
| BusLogic_InitializeCCBs(HostAdapter, BlockPointer, BlockSize, BlockPointerHandle); |
| } |
| if (HostAdapter->AllocatedCCBs > PreviouslyAllocated) { |
| if (SuccessMessageP) |
| BusLogic_Notice("Allocated %d additional CCBs (total now %d)\n", HostAdapter, HostAdapter->AllocatedCCBs - PreviouslyAllocated, HostAdapter->AllocatedCCBs); |
| return; |
| } |
| BusLogic_Notice("Failed to allocate additional CCBs\n", HostAdapter); |
| if (HostAdapter->DriverQueueDepth > HostAdapter->AllocatedCCBs - HostAdapter->TargetDeviceCount) { |
| HostAdapter->DriverQueueDepth = HostAdapter->AllocatedCCBs - HostAdapter->TargetDeviceCount; |
| HostAdapter->SCSI_Host->can_queue = HostAdapter->DriverQueueDepth; |
| } |
| } |
| |
| /* |
| BusLogic_AllocateCCB 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 BusLogic_CCB *BusLogic_AllocateCCB(struct BusLogic_HostAdapter |
| *HostAdapter) |
| { |
| static unsigned long SerialNumber = 0; |
| struct BusLogic_CCB *CCB; |
| CCB = HostAdapter->Free_CCBs; |
| if (CCB != NULL) { |
| CCB->SerialNumber = ++SerialNumber; |
| HostAdapter->Free_CCBs = CCB->Next; |
| CCB->Next = NULL; |
| if (HostAdapter->Free_CCBs == NULL) |
| BusLogic_CreateAdditionalCCBs(HostAdapter, HostAdapter->IncrementalCCBs, true); |
| return CCB; |
| } |
| BusLogic_CreateAdditionalCCBs(HostAdapter, HostAdapter->IncrementalCCBs, true); |
| CCB = HostAdapter->Free_CCBs; |
| if (CCB == NULL) |
| return NULL; |
| CCB->SerialNumber = ++SerialNumber; |
| HostAdapter->Free_CCBs = CCB->Next; |
| CCB->Next = NULL; |
| return CCB; |
| } |
| |
| |
| /* |
| BusLogic_DeallocateCCB 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 BusLogic_DeallocateCCB(struct BusLogic_CCB *CCB) |
| { |
| struct BusLogic_HostAdapter *HostAdapter = CCB->HostAdapter; |
| |
| scsi_dma_unmap(CCB->Command); |
| pci_unmap_single(HostAdapter->PCI_Device, CCB->SenseDataPointer, |
| CCB->SenseDataLength, PCI_DMA_FROMDEVICE); |
| |
| CCB->Command = NULL; |
| CCB->Status = BusLogic_CCB_Free; |
| CCB->Next = HostAdapter->Free_CCBs; |
| HostAdapter->Free_CCBs = CCB; |
| } |
| |
| |
| /* |
| BusLogic_Command sends the command OperationCode to HostAdapter, optionally |
| providing ParameterLength bytes of ParameterData and receiving at most |
| ReplyLength bytes of ReplyData; 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. |
| |
| BusLogic_Command 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 BusLogic_Command(struct BusLogic_HostAdapter *HostAdapter, enum BusLogic_OperationCode OperationCode, void *ParameterData, int ParameterLength, void *ReplyData, int ReplyLength) |
| { |
| unsigned char *ParameterPointer = (unsigned char *) ParameterData; |
| unsigned char *ReplyPointer = (unsigned char *) ReplyData; |
| union BusLogic_StatusRegister StatusRegister; |
| union BusLogic_InterruptRegister InterruptRegister; |
| unsigned long ProcessorFlags = 0; |
| int ReplyBytes = 0, Result; |
| long TimeoutCounter; |
| /* |
| Clear out the Reply Data if provided. |
| */ |
| if (ReplyLength > 0) |
| memset(ReplyData, 0, ReplyLength); |
| /* |
| 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 (!HostAdapter->IRQ_ChannelAcquired) |
| local_irq_save(ProcessorFlags); |
| /* |
| Wait for the Host Adapter Ready bit to be set and the Command/Parameter |
| Register Busy bit to be reset in the Status Register. |
| */ |
| TimeoutCounter = 10000; |
| while (--TimeoutCounter >= 0) { |
| StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter); |
| if (StatusRegister.sr.HostAdapterReady && !StatusRegister.sr.CommandParameterRegisterBusy) |
| break; |
| udelay(100); |
| } |
| if (TimeoutCounter < 0) { |
| BusLogic_CommandFailureReason = "Timeout waiting for Host Adapter Ready"; |
| Result = -2; |
| goto Done; |
| } |
| /* |
| Write the OperationCode to the Command/Parameter Register. |
| */ |
| HostAdapter->HostAdapterCommandCompleted = false; |
| BusLogic_WriteCommandParameterRegister(HostAdapter, OperationCode); |
| /* |
| Write any additional Parameter Bytes. |
| */ |
| TimeoutCounter = 10000; |
| while (ParameterLength > 0 && --TimeoutCounter >= 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); |
| InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter); |
| StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter); |
| if (InterruptRegister.ir.CommandComplete) |
| break; |
| if (HostAdapter->HostAdapterCommandCompleted) |
| break; |
| if (StatusRegister.sr.DataInRegisterReady) |
| break; |
| if (StatusRegister.sr.CommandParameterRegisterBusy) |
| continue; |
| BusLogic_WriteCommandParameterRegister(HostAdapter, *ParameterPointer++); |
| ParameterLength--; |
| } |
| if (TimeoutCounter < 0) { |
| BusLogic_CommandFailureReason = "Timeout waiting for Parameter Acceptance"; |
| Result = -2; |
| goto Done; |
| } |
| /* |
| The Modify I/O Address command does not cause a Command Complete Interrupt. |
| */ |
| if (OperationCode == BusLogic_ModifyIOAddress) { |
| StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter); |
| if (StatusRegister.sr.CommandInvalid) { |
| BusLogic_CommandFailureReason = "Modify I/O Address Invalid"; |
| Result = -1; |
| goto Done; |
| } |
| if (BusLogic_GlobalOptions.TraceConfiguration) |
| BusLogic_Notice("BusLogic_Command(%02X) Status = %02X: " "(Modify I/O Address)\n", HostAdapter, OperationCode, StatusRegister.All); |
| Result = 0; |
| goto Done; |
| } |
| /* |
| Select an appropriate timeout value for awaiting command completion. |
| */ |
| switch (OperationCode) { |
| case BusLogic_InquireInstalledDevicesID0to7: |
| case BusLogic_InquireInstalledDevicesID8to15: |
| case BusLogic_InquireTargetDevices: |
| /* Approximately 60 seconds. */ |
| TimeoutCounter = 60 * 10000; |
| break; |
| default: |
| /* Approximately 1 second. */ |
| TimeoutCounter = 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 (--TimeoutCounter >= 0) { |
| InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter); |
| StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter); |
| if (InterruptRegister.ir.CommandComplete) |
| break; |
| if (HostAdapter->HostAdapterCommandCompleted) |
| break; |
| if (StatusRegister.sr.DataInRegisterReady) { |
| if (++ReplyBytes <= ReplyLength) |
| *ReplyPointer++ = BusLogic_ReadDataInRegister(HostAdapter); |
| else |
| BusLogic_ReadDataInRegister(HostAdapter); |
| } |
| if (OperationCode == BusLogic_FetchHostAdapterLocalRAM && StatusRegister.sr.HostAdapterReady) |
| break; |
| udelay(100); |
| } |
| if (TimeoutCounter < 0) { |
| BusLogic_CommandFailureReason = "Timeout waiting for Command Complete"; |
| Result = -2; |
| goto Done; |
| } |
| /* |
| Clear any pending Command Complete Interrupt. |
| */ |
| BusLogic_InterruptReset(HostAdapter); |
| /* |
| Provide tracing information if requested. |
| */ |
| if (BusLogic_GlobalOptions.TraceConfiguration) { |
| int i; |
| BusLogic_Notice("BusLogic_Command(%02X) Status = %02X: %2d ==> %2d:", HostAdapter, OperationCode, StatusRegister.All, ReplyLength, ReplyBytes); |
| if (ReplyLength > ReplyBytes) |
| ReplyLength = ReplyBytes; |
| for (i = 0; i < ReplyLength; i++) |
| BusLogic_Notice(" %02X", HostAdapter, ((unsigned char *) ReplyData)[i]); |
| BusLogic_Notice("\n", HostAdapter); |
| } |
| /* |
| Process Command Invalid conditions. |
| */ |
| if (StatusRegister.sr.CommandInvalid) { |
| /* |
| 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); |
| StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter); |
| if (StatusRegister.sr.CommandInvalid || |
| StatusRegister.sr.Reserved || |
| StatusRegister.sr.DataInRegisterReady || |
| StatusRegister.sr.CommandParameterRegisterBusy || !StatusRegister.sr.HostAdapterReady || !StatusRegister.sr.InitializationRequired || StatusRegister.sr.DiagnosticActive || StatusRegister.sr.DiagnosticFailure) { |
| BusLogic_SoftReset(HostAdapter); |
| udelay(1000); |
| } |
| BusLogic_CommandFailureReason = "Command Invalid"; |
| Result = -1; |
| goto Done; |
| } |
| /* |
| Handle Excess Parameters Supplied conditions. |
| */ |
| if (ParameterLength > 0) { |
| BusLogic_CommandFailureReason = "Excess Parameters Supplied"; |
| Result = -1; |
| goto Done; |
| } |
| /* |
| Indicate the command completed successfully. |
| */ |
| BusLogic_CommandFailureReason = NULL; |
| Result = ReplyBytes; |
| /* |
| Restore the interrupt status if necessary and return. |
| */ |
| Done: |
| if (!HostAdapter->IRQ_ChannelAcquired) |
| local_irq_restore(ProcessorFlags); |
| return Result; |
| } |
| |
| |
| /* |
| BusLogic_AppendProbeAddressISA 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 BusLogic_AppendProbeAddressISA(unsigned long IO_Address) |
| { |
| struct BusLogic_ProbeInfo *ProbeInfo; |
| if (BusLogic_ProbeInfoCount >= BusLogic_MaxHostAdapters) |
| return; |
| ProbeInfo = &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++]; |
| ProbeInfo->HostAdapterType = BusLogic_MultiMaster; |
| ProbeInfo->HostAdapterBusType = BusLogic_ISA_Bus; |
| ProbeInfo->IO_Address = IO_Address; |
| ProbeInfo->PCI_Device = NULL; |
| } |
| |
| |
| /* |
| BusLogic_InitializeProbeInfoListISA 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 BusLogic_InitializeProbeInfoListISA(struct BusLogic_HostAdapter |
| *PrototypeHostAdapter) |
| { |
| /* |
| If BusLogic Driver Options specifications requested that ISA Bus Probes |
| be inhibited, do not proceed further. |
| */ |
| if (BusLogic_ProbeOptions.NoProbeISA) |
| return; |
| /* |
| Append the list of standard BusLogic MultiMaster ISA I/O Addresses. |
| */ |
| if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe330) |
| BusLogic_AppendProbeAddressISA(0x330); |
| if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe334) |
| BusLogic_AppendProbeAddressISA(0x334); |
| if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe230) |
| BusLogic_AppendProbeAddressISA(0x230); |
| if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe234) |
| BusLogic_AppendProbeAddressISA(0x234); |
| if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe130) |
| BusLogic_AppendProbeAddressISA(0x130); |
| if (!BusLogic_ProbeOptions.LimitedProbeISA || BusLogic_ProbeOptions.Probe134) |
| BusLogic_AppendProbeAddressISA(0x134); |
| } |
| |
| |
| #ifdef CONFIG_PCI |
| |
| |
| /* |
| BusLogic_SortProbeInfo sorts a section of BusLogic_ProbeInfoList in order |
| of increasing PCI Bus and Device Number. |
| */ |
| |
| static void __init BusLogic_SortProbeInfo(struct BusLogic_ProbeInfo *ProbeInfoList, int ProbeInfoCount) |
| { |
| int LastInterchange = ProbeInfoCount - 1, Bound, j; |
| while (LastInterchange > 0) { |
| Bound = LastInterchange; |
| LastInterchange = 0; |
| for (j = 0; j < Bound; j++) { |
| struct BusLogic_ProbeInfo *ProbeInfo1 = &ProbeInfoList[j]; |
| struct BusLogic_ProbeInfo *ProbeInfo2 = &ProbeInfoList[j + 1]; |
| if (ProbeInfo1->Bus > ProbeInfo2->Bus || (ProbeInfo1->Bus == ProbeInfo2->Bus && (ProbeInfo1->Device > ProbeInfo2->Device))) { |
| struct BusLogic_ProbeInfo TempProbeInfo; |
| memcpy(&TempProbeInfo, ProbeInfo1, sizeof(struct BusLogic_ProbeInfo)); |
| memcpy(ProbeInfo1, ProbeInfo2, sizeof(struct BusLogic_ProbeInfo)); |
| memcpy(ProbeInfo2, &TempProbeInfo, sizeof(struct BusLogic_ProbeInfo)); |
| LastInterchange = j; |
| } |
| } |
| } |
| } |
| |
| |
| /* |
| BusLogic_InitializeMultiMasterProbeInfo 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 BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAdapter |
| *PrototypeHostAdapter) |
| { |
| struct BusLogic_ProbeInfo *PrimaryProbeInfo = &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount]; |
| int NonPrimaryPCIMultiMasterIndex = BusLogic_ProbeInfoCount + 1; |
| int NonPrimaryPCIMultiMasterCount = 0, PCIMultiMasterCount = 0; |
| bool ForceBusDeviceScanningOrder = false; |
| bool ForceBusDeviceScanningOrderChecked = false; |
| bool StandardAddressSeen[6]; |
| struct pci_dev *PCI_Device = NULL; |
| int i; |
| if (BusLogic_ProbeInfoCount >= BusLogic_MaxHostAdapters) |
| return 0; |
| BusLogic_ProbeInfoCount++; |
| for (i = 0; i < 6; i++) |
| StandardAddressSeen[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. |
| */ |
| PrimaryProbeInfo->IO_Address = 0; |
| while ((PCI_Device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER, PCI_Device)) != NULL) { |
| struct BusLogic_HostAdapter *HostAdapter = PrototypeHostAdapter; |
| struct BusLogic_PCIHostAdapterInformation PCIHostAdapterInformation; |
| enum BusLogic_ISACompatibleIOPort ModifyIOAddressRequest; |
| unsigned char Bus; |
| unsigned char Device; |
| unsigned int IRQ_Channel; |
| unsigned long BaseAddress0; |
| unsigned long BaseAddress1; |
| unsigned long IO_Address; |
| unsigned long PCI_Address; |
| |
| 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_Channel = PCI_Device->irq; |
| IO_Address = BaseAddress0 = pci_resource_start(PCI_Device, 0); |
| PCI_Address = BaseAddress1 = pci_resource_start(PCI_Device, 1); |
| |
| if (pci_resource_flags(PCI_Device, 0) & IORESOURCE_MEM) { |
| BusLogic_Error("BusLogic: Base Address0 0x%X not I/O for " "MultiMaster Host Adapter\n", NULL, BaseAddress0); |
| BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, Bus, Device, IO_Address); |
| continue; |
| } |
| if (pci_resource_flags(PCI_Device, 1) & IORESOURCE_IO) { |
| BusLogic_Error("BusLogic: Base Address1 0x%X not Memory for " "MultiMaster Host Adapter\n", NULL, BaseAddress1); |
| BusLogic_Error("at PCI Bus %d Device %d PCI Address 0x%X\n", NULL, Bus, Device, PCI_Address); |
| continue; |
| } |
| if (IRQ_Channel == 0) { |
| BusLogic_Error("BusLogic: IRQ Channel %d invalid for " "MultiMaster Host Adapter\n", NULL, IRQ_Channel); |
| BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, Bus, Device, IO_Address); |
| continue; |
| } |
| if (BusLogic_GlobalOptions.TraceProbe) { |
| BusLogic_Notice("BusLogic: PCI MultiMaster Host Adapter " "detected at\n", NULL); |
| BusLogic_Notice("BusLogic: PCI Bus %d Device %d I/O Address " "0x%X PCI Address 0x%X\n", NULL, Bus, Device, IO_Address, PCI_Address); |
| } |
| /* |
| 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. |
| */ |
| HostAdapter->IO_Address = IO_Address; |
| BusLogic_InterruptReset(HostAdapter); |
| if (BusLogic_Command(HostAdapter, BusLogic_InquirePCIHostAdapterInformation, NULL, 0, &PCIHostAdapterInformation, sizeof(PCIHostAdapterInformation)) |
| == sizeof(PCIHostAdapterInformation)) { |
| if (PCIHostAdapterInformation.ISACompatibleIOPort < 6) |
| StandardAddressSeen[PCIHostAdapterInformation.ISACompatibleIOPort] = true; |
| } else |
| PCIHostAdapterInformation.ISACompatibleIOPort = BusLogic_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. |
| */ |
| ModifyIOAddressRequest = BusLogic_IO_Disable; |
| BusLogic_Command(HostAdapter, BusLogic_ModifyIOAddress, &ModifyIOAddressRequest, sizeof(ModifyIOAddressRequest), 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 (!ForceBusDeviceScanningOrderChecked) { |
| struct BusLogic_FetchHostAdapterLocalRAMRequest FetchHostAdapterLocalRAMRequest; |
| struct BusLogic_AutoSCSIByte45 AutoSCSIByte45; |
| struct BusLogic_BoardID BoardID; |
| FetchHostAdapterLocalRAMRequest.ByteOffset = BusLogic_AutoSCSI_BaseOffset + 45; |
| FetchHostAdapterLocalRAMRequest.ByteCount = sizeof(AutoSCSIByte45); |
| BusLogic_Command(HostAdapter, BusLogic_FetchHostAdapterLocalRAM, &FetchHostAdapterLocalRAMRequest, sizeof(FetchHostAdapterLocalRAMRequest), &AutoSCSIByte45, sizeof(AutoSCSIByte45)); |
| BusLogic_Command(HostAdapter, BusLogic_InquireBoardID, NULL, 0, &BoardID, sizeof(BoardID)); |
| if (BoardID.FirmwareVersion1stDigit == '5') |
| ForceBusDeviceScanningOrder = AutoSCSIByte45.ForceBusDeviceScanningOrder; |
| ForceBusDeviceScanningOrderChecked = 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 (PCIHostAdapterInformation.ISACompatibleIOPort == BusLogic_IO_330) { |
| PrimaryProbeInfo->HostAdapterType = BusLogic_MultiMaster; |
| PrimaryProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus; |
| PrimaryProbeInfo->IO_Address = IO_Address; |
| PrimaryProbeInfo->PCI_Address = PCI_Address; |
| PrimaryProbeInfo->Bus = Bus; |
| PrimaryProbeInfo->Device = Device; |
| PrimaryProbeInfo->IRQ_Channel = IRQ_Channel; |
| PrimaryProbeInfo->PCI_Device = pci_dev_get(PCI_Device); |
| PCIMultiMasterCount++; |
| } else if (BusLogic_ProbeInfoCount < BusLogic_MaxHostAdapters) { |
| struct BusLogic_ProbeInfo *ProbeInfo = &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++]; |
| ProbeInfo->HostAdapterType = BusLogic_MultiMaster; |
| ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus; |
| ProbeInfo->IO_Address = IO_Address; |
| ProbeInfo->PCI_Address = PCI_Address; |
| ProbeInfo->Bus = Bus; |
| ProbeInfo->Device = Device; |
| ProbeInfo->IRQ_Channel = IRQ_Channel; |
| ProbeInfo->PCI_Device = pci_dev_get(PCI_Device); |
| NonPrimaryPCIMultiMasterCount++; |
| PCIMultiMasterCount++; |
| } else |
| BusLogic_Warning("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 (ForceBusDeviceScanningOrder) |
| BusLogic_SortProbeInfo(&BusLogic_ProbeInfoList[NonPrimaryPCIMultiMasterIndex], NonPrimaryPCIMultiMasterCount); |
| /* |
| 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 (!BusLogic_ProbeOptions.NoProbeISA) |
| if (PrimaryProbeInfo->IO_Address == 0 && |
| (!BusLogic_ProbeOptions.LimitedProbeISA || |
| BusLogic_ProbeOptions.Probe330)) { |
| PrimaryProbeInfo->HostAdapterType = BusLogic_MultiMaster; |
| PrimaryProbeInfo->HostAdapterBusType = BusLogic_ISA_Bus; |
| PrimaryProbeInfo->IO_Address = 0x330; |
| } |
| /* |
| Append the list of standard BusLogic MultiMaster ISA I/O Addresses, |
| omitting the Primary I/O Address which has already been handled. |
| */ |
| if (!BusLogic_ProbeOptions.NoProbeISA) { |
| if (!StandardAddressSeen[1] && |
| (!BusLogic_ProbeOptions.LimitedProbeISA || |
| BusLogic_ProbeOptions.Probe334)) |
| BusLogic_AppendProbeAddressISA(0x334); |
| if (!StandardAddressSeen[2] && |
| (!BusLogic_ProbeOptions.LimitedProbeISA || |
| BusLogic_ProbeOptions.Probe230)) |
| BusLogic_AppendProbeAddressISA(0x230); |
| if (!StandardAddressSeen[3] && |
| (!BusLogic_ProbeOptions.LimitedProbeISA || |
| BusLogic_ProbeOptions.Probe234)) |
| BusLogic_AppendProbeAddressISA(0x234); |
| if (!StandardAddressSeen[4] && |
| (!BusLogic_ProbeOptions.LimitedProbeISA || |
| BusLogic_ProbeOptions.Probe130)) |
| BusLogic_AppendProbeAddressISA(0x130); |
| if (!StandardAddressSeen[5] && |
| (!BusLogic_ProbeOptions.LimitedProbeISA || |
| BusLogic_ProbeOptions.Probe134)) |
| BusLogic_AppendProbeAddressISA(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_Channel; |
| unsigned long IO_Address; |
| |
| 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_Channel = PCI_Device->irq; |
| IO_Address = pci_resource_start(PCI_Device, 0); |
| |
| if (IO_Address == 0 || IRQ_Channel == 0) |
| continue; |
| for (i = 0; i < BusLogic_ProbeInfoCount; i++) { |
| struct BusLogic_ProbeInfo *ProbeInfo = &BusLogic_ProbeInfoList[i]; |
| if (ProbeInfo->IO_Address == IO_Address && ProbeInfo->HostAdapterType == BusLogic_MultiMaster) { |
| ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus; |
| ProbeInfo->PCI_Address = 0; |
| ProbeInfo->Bus = Bus; |
| ProbeInfo->Device = Device; |
| ProbeInfo->IRQ_Channel = IRQ_Channel; |
| ProbeInfo->PCI_Device = pci_dev_get(PCI_Device); |
| break; |
| } |
| } |
| } |
| return PCIMultiMasterCount; |
| } |
| |
| |
| /* |
| BusLogic_InitializeFlashPointProbeInfo 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 BusLogic_InitializeFlashPointProbeInfo(struct BusLogic_HostAdapter |
| *PrototypeHostAdapter) |
| { |
| int FlashPointIndex = BusLogic_ProbeInfoCount, FlashPointCount = 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_Channel; |
| unsigned long BaseAddress0; |
| unsigned long BaseAddress1; |
| unsigned long IO_Address; |
| unsigned long PCI_Address; |
| |
| 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_Channel = PCI_Device->irq; |
| IO_Address = BaseAddress0 = pci_resource_start(PCI_Device, 0); |
| PCI_Address = BaseAddress1 = pci_resource_start(PCI_Device, 1); |
| #ifdef CONFIG_SCSI_FLASHPOINT |
| if (pci_resource_flags(PCI_Device, 0) & IORESOURCE_MEM) { |
| BusLogic_Error("BusLogic: Base Address0 0x%X not I/O for " "FlashPoint Host Adapter\n", NULL, BaseAddress0); |
| BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, Bus, Device, IO_Address); |
| continue; |
| } |
| if (pci_resource_flags(PCI_Device, 1) & IORESOURCE_IO) { |
| BusLogic_Error("BusLogic: Base Address1 0x%X not Memory for " "FlashPoint Host Adapter\n", NULL, BaseAddress1); |
| BusLogic_Error("at PCI Bus %d Device %d PCI Address 0x%X\n", NULL, Bus, Device, PCI_Address); |
| continue; |
| } |
| if (IRQ_Channel == 0) { |
| BusLogic_Error("BusLogic: IRQ Channel %d invalid for " "FlashPoint Host Adapter\n", NULL, IRQ_Channel); |
| BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, Bus, Device, IO_Address); |
| continue; |
| } |
| if (BusLogic_GlobalOptions.TraceProbe) { |
| BusLogic_Notice("BusLogic: FlashPoint Host Adapter " "detected at\n", NULL); |
| BusLogic_Notice("BusLogic: PCI Bus %d Device %d I/O Address " "0x%X PCI Address 0x%X\n", NULL, Bus, Device, IO_Address, PCI_Address); |
| } |
| if (BusLogic_ProbeInfoCount < BusLogic_MaxHostAdapters) { |
| struct BusLogic_ProbeInfo *ProbeInfo = &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++]; |
| ProbeInfo->HostAdapterType = BusLogic_FlashPoint; |
| ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus; |
| ProbeInfo->IO_Address = IO_Address; |
| ProbeInfo->PCI_Address = PCI_Address; |
| ProbeInfo->Bus = Bus; |
| ProbeInfo->Device = Device; |
| ProbeInfo->IRQ_Channel = IRQ_Channel; |
| ProbeInfo->PCI_Device = pci_dev_get(PCI_Device); |
| FlashPointCount++; |
| } else |
| BusLogic_Warning("BusLogic: Too many Host Adapters " "detected\n", NULL); |
| #else |
| BusLogic_Error("BusLogic: FlashPoint Host Adapter detected at " "PCI Bus %d Device %d\n", NULL, Bus, Device); |
| BusLogic_Error("BusLogic: I/O Address 0x%X PCI Address 0x%X, irq %d, " "but FlashPoint\n", NULL, IO_Address, PCI_Address, IRQ_Channel); |
| BusLogic_Error("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. |
| */ |
| BusLogic_SortProbeInfo(&BusLogic_ProbeInfoList[FlashPointIndex], FlashPointCount); |
| return FlashPointCount; |
| } |
| |
| |
| /* |
| BusLogic_InitializeProbeInfoList 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 BusLogic_InitializeProbeInfoList(struct BusLogic_HostAdapter |
| *PrototypeHostAdapter) |
| { |
| /* |
| If a PCI BIOS is present, interrogate it for MultiMaster and FlashPoint |
| Host Adapters; otherwise, default to the standard ISA MultiMaster probe. |
| */ |
| if (!BusLogic_ProbeOptions.NoProbePCI) { |
| if (BusLogic_ProbeOptions.MultiMasterFirst) { |
| BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter); |
| BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter); |
| } else if (BusLogic_ProbeOptions.FlashPointFirst) { |
| BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter); |
| BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter); |
| } else { |
| int FlashPointCount = BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter); |
| int PCIMultiMasterCount = BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter); |
| if (FlashPointCount > 0 && PCIMultiMasterCount > 0) { |
| struct BusLogic_ProbeInfo *ProbeInfo = &BusLogic_ProbeInfoList[FlashPointCount]; |
| struct BusLogic_HostAdapter *HostAdapter = PrototypeHostAdapter; |
| struct BusLogic_FetchHostAdapterLocalRAMRequest FetchHostAdapterLocalRAMRequest; |
| struct BusLogic_BIOSDriveMapByte Drive0MapByte; |
| while (ProbeInfo->HostAdapterBusType != BusLogic_PCI_Bus) |
| ProbeInfo++; |
| HostAdapter->IO_Address = ProbeInfo->IO_Address; |
| FetchHostAdapterLocalRAMRequest.ByteOffset = BusLogic_BIOS_BaseOffset + BusLogic_BIOS_DriveMapOffset + 0; |
| FetchHostAdapterLocalRAMRequest.ByteCount = sizeof(Drive0MapByte); |
| BusLogic_Command(HostAdapter, BusLogic_FetchHostAdapterLocalRAM, &FetchHostAdapterLocalRAMRequest, sizeof(FetchHostAdapterLocalRAMRequest), &Drive0MapByte, sizeof(Drive0MapByte)); |
| /* |
| 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 (Drive0MapByte.DiskGeometry != BusLogic_BIOS_Disk_Not_Installed) { |
| struct BusLogic_ProbeInfo SavedProbeInfo[BusLogic_MaxHostAdapters]; |
| int MultiMasterCount = BusLogic_ProbeInfoCount - FlashPointCount; |
| memcpy(SavedProbeInfo, BusLogic_ProbeInfoList, BusLogic_ProbeInfoCount * sizeof(struct BusLogic_ProbeInfo)); |
| memcpy(&BusLogic_ProbeInfoList[0], &SavedProbeInfo[FlashPointCount], MultiMasterCount * sizeof(struct BusLogic_ProbeInfo)); |
| memcpy(&BusLogic_ProbeInfoList[MultiMasterCount], &SavedProbeInfo[0], FlashPointCount * sizeof(struct BusLogic_ProbeInfo)); |
| } |
| } |
| } |
| } else |
| BusLogic_InitializeProbeInfoListISA(PrototypeHostAdapter); |
| } |
| |
| |
| #else |
| #define BusLogic_InitializeProbeInfoList(adapter) \ |
| BusLogic_InitializeProbeInfoListISA(adapter) |
| #endif /* CONFIG_PCI */ |
| |
| |
| /* |
| BusLogic_Failure prints a standardized error message, and then returns false. |
| */ |
| |
| static bool BusLogic_Failure(struct BusLogic_HostAdapter *HostAdapter, char *ErrorMessage) |
| { |
| BusLogic_AnnounceDriver(HostAdapter); |
| if (HostAdapter->HostAdapterBusType == BusLogic_PCI_Bus) { |
| BusLogic_Error("While configuring BusLogic PCI Host Adapter at\n", HostAdapter); |
| BusLogic_Error("Bus %d Device %d I/O Address 0x%X PCI Address 0x%X:\n", HostAdapter, HostAdapter->Bus, HostAdapter->Device, HostAdapter->IO_Address, HostAdapter->PCI_Address); |
| } else |
| BusLogic_Error("While configuring BusLogic Host Adapter at " "I/O Address 0x%X:\n", HostAdapter, HostAdapter->IO_Address); |
| BusLogic_Error("%s FAILED - DETACHING\n", HostAdapter, ErrorMessage); |
| if (BusLogic_CommandFailureReason != NULL) |
| BusLogic_Error("ADDITIONAL FAILURE INFO - %s\n", HostAdapter, BusLogic_CommandFailureReason); |
| return false; |
| } |
| |
| |
| /* |
| BusLogic_ProbeHostAdapter probes for a BusLogic Host Adapter. |
| */ |
| |
| static bool __init BusLogic_ProbeHostAdapter(struct BusLogic_HostAdapter *HostAdapter) |
| { |
| union BusLogic_StatusRegister StatusRegister; |
| union BusLogic_InterruptRegister InterruptRegister; |
| union BusLogic_GeometryRegister GeometryRegister; |
| /* |
| FlashPoint Host Adapters are Probed by the FlashPoint SCCB Manager. |
| */ |
| if (BusLogic_FlashPointHostAdapterP(HostAdapter)) { |
| struct FlashPoint_Info *FlashPointInfo = &HostAdapter->FlashPointInfo; |
| FlashPointInfo->BaseAddress = (u32) HostAdapter->IO_Address; |
| FlashPointInfo->IRQ_Channel = HostAdapter->IRQ_Channel; |
| FlashPointInfo->Present = false; |
| if (!(FlashPoint_ProbeHostAdapter(FlashPointInfo) == 0 && FlashPointInfo->Present)) { |
| BusLogic_Error("BusLogic: FlashPoint Host Adapter detected at " "PCI Bus %d Device %d\n", HostAdapter, HostAdapter->Bus, HostAdapter->Device); |
| BusLogic_Error("BusLogic: I/O Address 0x%X PCI Address 0x%X, " "but FlashPoint\n", HostAdapter, HostAdapter->IO_Address, HostAdapter->PCI_Address); |
| BusLogic_Error("BusLogic: Probe Function failed to validate it.\n", HostAdapter); |
| return false; |
| } |
| if (BusLogic_GlobalOptions.TraceProbe) |
| BusLogic_Notice("BusLogic_Probe(0x%X): FlashPoint Found\n", HostAdapter, HostAdapter->IO_Address); |
| /* |
| 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. |
| */ |
| StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter); |
| InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter); |
| GeometryRegister.All = BusLogic_ReadGeometryRegister(HostAdapter); |
| if (BusLogic_GlobalOptions.TraceProbe) |
| BusLogic_Notice("BusLogic_Probe(0x%X): Status 0x%02X, Interrupt 0x%02X, " "Geometry 0x%02X\n", HostAdapter, HostAdapter->IO_Address, StatusRegister.All, InterruptRegister.All, GeometryRegister.All); |
| if (StatusRegister.All == 0 || StatusRegister.sr.DiagnosticActive || StatusRegister.sr.CommandParameterRegisterBusy || StatusRegister.sr.Reserved || StatusRegister.sr.CommandInvalid || InterruptRegister.ir.Reserved != 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 BusLogic_CheckHostAdapter. 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 (GeometryRegister.All == 0xFF) |
| return false; |
| /* |
| Indicate the Host Adapter Probe completed successfully. |
| */ |
| return true; |
| } |
| |
| |
| /* |
| BusLogic_HardwareResetHostAdapter issues a Hardware Reset to the Host Adapter |
| and waits for Host Adapter Diagnostics to complete. If HardReset 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 BusLogic_HardwareResetHostAdapter(struct BusLogic_HostAdapter |
| *HostAdapter, bool HardReset) |
| { |
| union BusLogic_StatusRegister StatusRegister; |
| int TimeoutCounter; |
| /* |
| FlashPoint Host Adapters are Hard Reset by the FlashPoint SCCB Manager. |
| */ |
| if (BusLogic_FlashPointHostAdapterP(HostAdapter)) { |
| struct FlashPoint_Info *FlashPointInfo = &HostAdapter->FlashPointInfo; |
| FlashPointInfo->HostSoftReset = !HardReset; |
| FlashPointInfo->ReportDataUnderrun = true; |
| HostAdapter->CardHandle = FlashPoint_HardwareResetHostAdapter(FlashPointInfo); |
| if (HostAdapter->CardHandle == FlashPoint_BadCardHandle) |
| 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 (HardReset) |
| BusLogic_HardReset(HostAdapter); |
| else |
| BusLogic_SoftReset(HostAdapter); |
| /* |
| Wait until Diagnostic Active is set in the Status Register. |
| */ |
| TimeoutCounter = 5 * 10000; |
| while (--TimeoutCounter >= 0) { |
| StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter); |
| if (StatusRegister.sr.DiagnosticActive) |
| break; |
| udelay(100); |
| } |
| if (BusLogic_GlobalOptions.TraceHardwareReset) |
| BusLogic_Notice("BusLogic_HardwareReset(0x%X): Diagnostic Active, " "Status 0x%02X\n", HostAdapter, HostAdapter->IO_Address, StatusRegister.All); |
| if (TimeoutCounter < 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. |
| */ |
| TimeoutCounter = 10 * 10000; |
| while (--TimeoutCounter >= 0) { |
| StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter); |
| if (!StatusRegister.sr.DiagnosticActive) |
| break; |
| udelay(100); |
| } |
| if (BusLogic_GlobalOptions.TraceHardwareReset) |
| BusLogic_Notice("BusLogic_HardwareReset(0x%X): Diagnostic Completed, " "Status 0x%02X\n", HostAdapter, HostAdapter->IO_Address, StatusRegister.All); |
| if (TimeoutCounter < 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. |
| */ |
| TimeoutCounter = 10000; |
| while (--TimeoutCounter >= 0) { |
| StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter); |
| if (StatusRegister.sr.DiagnosticFailure || StatusRegister.sr.HostAdapterReady || StatusRegister.sr.DataInRegisterReady) |
| break; |
| udelay(100); |
| } |
| if (BusLogic_GlobalOptions.TraceHardwareReset) |
| BusLogic_Notice("BusLogic_HardwareReset(0x%X): Host Adapter Ready, " "Status 0x%02X\n", HostAdapter, HostAdapter->IO_Address, StatusRegister.All); |
| if (TimeoutCounter < 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 (StatusRegister.sr.DiagnosticFailure || !StatusRegister.sr.HostAdapterReady) { |
| BusLogic_CommandFailureReason = NULL; |
| BusLogic_Failure(HostAdapter, "HARD RESET DIAGNOSTICS"); |
| BusLogic_Error("HOST ADAPTER STATUS REGISTER = %02X\n", HostAdapter, StatusRegister.All); |
| if (StatusRegister.sr.DataInRegisterReady) { |
| unsigned char ErrorCode = BusLogic_ReadDataInRegister(HostAdapter); |
| BusLogic_Error("HOST ADAPTER ERROR CODE = %d\n", HostAdapter, ErrorCode); |
| } |
| return false; |
| } |
| /* |
| Indicate the Host Adapter Hard Reset completed successfully. |
| */ |
| return true; |
| } |
| |
| |
| /* |
| BusLogic_CheckHostAdapter checks to be sure this really is a BusLogic |
| Host Adapter. |
| */ |
| |
| static bool __init BusLogic_CheckHostAdapter(struct BusLogic_HostAdapter *HostAdapter) |
| { |
| struct BusLogic_ExtendedSetupInformation ExtendedSetupInformation; |
| unsigned char RequestedReplyLength; |
| bool Result = true; |
| /* |
| FlashPoint Host Adapters do not require this protection. |
| */ |
| if (BusLogic_FlashPointHostAdapterP(HostAdapter)) |
| 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. |
| */ |
| RequestedReplyLength = sizeof(ExtendedSetupInformation); |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireExtendedSetupInformation, &RequestedReplyLength, sizeof(RequestedReplyLength), &ExtendedSetupInformation, sizeof(ExtendedSetupInformation)) |
| != sizeof(ExtendedSetupInformation)) |
| Result = false; |
| /* |
| Provide tracing information if requested and return. |
| */ |
| if (BusLogic_GlobalOptions.TraceProbe) |
| BusLogic_Notice("BusLogic_Check(0x%X): MultiMaster %s\n", HostAdapter, HostAdapter->IO_Address, (Result ? "Found" : "Not Found")); |
| return Result; |
| } |
| |
| |
| /* |
| BusLogic_ReadHostAdapterConfiguration reads the Configuration Information |
| from Host Adapter and initializes the Host Adapter structure. |
| */ |
| |
| static bool __init BusLogic_ReadHostAdapterConfiguration(struct BusLogic_HostAdapter |
| *HostAdapter) |
| { |
| struct BusLogic_BoardID BoardID; |
| struct BusLogic_Configuration Configuration; |
| struct BusLogic_SetupInformation SetupInformation; |
| struct BusLogic_ExtendedSetupInformation ExtendedSetupInformation; |
| unsigned char HostAdapterModelNumber[5]; |
| unsigned char FirmwareVersion3rdDigit; |
| unsigned char FirmwareVersionLetter; |
| struct BusLogic_PCIHostAdapterInformation PCIHostAdapterInformation; |
| struct BusLogic_FetchHostAdapterLocalRAMRequest FetchHostAdapterLocalRAMRequest; |
| struct BusLogic_AutoSCSIData AutoSCSIData; |
| union BusLogic_GeometryRegister GeometryRegister; |
| unsigned char RequestedReplyLength; |
| unsigned char *TargetPointer, Character; |
| int TargetID, i; |
| /* |
| Configuration Information for FlashPoint Host Adapters is provided in the |
| FlashPoint_Info structure by the FlashPoint SCCB Manager's Probe Function. |
| Initialize fields in the Host Adapter structure from the FlashPoint_Info |
| structure. |
| */ |
| if (BusLogic_FlashPointHostAdapterP(HostAdapter)) { |
| struct FlashPoint_Info *FlashPointInfo = &HostAdapter->FlashPointInfo; |
| TargetPointer = HostAdapter->ModelName; |
| *TargetPointer++ = 'B'; |
| *TargetPointer++ = 'T'; |
| *TargetPointer++ = '-'; |
| for (i = 0; i < sizeof(FlashPointInfo->ModelNumber); i++) |
| *TargetPointer++ = FlashPointInfo->ModelNumber[i]; |
| *TargetPointer++ = '\0'; |
| strcpy(HostAdapter->FirmwareVersion, FlashPoint_FirmwareVersion); |
| HostAdapter->SCSI_ID = FlashPointInfo->SCSI_ID; |
| HostAdapter->ExtendedTranslationEnabled = FlashPointInfo->ExtendedTranslationEnabled; |
| HostAdapter->ParityCheckingEnabled = FlashPointInfo->ParityCheckingEnabled; |
| HostAdapter->BusResetEnabled = !FlashPointInfo->HostSoftReset; |
| HostAdapter->LevelSensitiveInterrupt = true; |
| HostAdapter->HostWideSCSI = FlashPointInfo->HostWideSCSI; |
| HostAdapter->HostDifferentialSCSI = false; |
| HostAdapter->HostSupportsSCAM = true; |
| HostAdapter->HostUltraSCSI = true; |
| HostAdapter->ExtendedLUNSupport = true; |
| HostAdapter->TerminationInfoValid = true; |
| HostAdapter->LowByteTerminated = FlashPointInfo->LowByteTerminated; |
| HostAdapter->HighByteTerminated = FlashPointInfo->HighByteTerminated; |
| HostAdapter->SCAM_Enabled = FlashPointInfo->SCAM_Enabled; |
| HostAdapter->SCAM_Level2 = FlashPointInfo->SCAM_Level2; |
| HostAdapter->DriverScatterGatherLimit = BusLogic_ScatterGatherLimit; |
| HostAdapter->MaxTargetDevices = (HostAdapter->HostWideSCSI ? 16 : 8); |
| HostAdapter->MaxLogicalUnits = 32; |
| HostAdapter->InitialCCBs = 4 * BusLogic_CCB_AllocationGroupSize; |
| HostAdapter->IncrementalCCBs = BusLogic_CCB_AllocationGroupSize; |
| HostAdapter->DriverQueueDepth = 255; |
| HostAdapter->HostAdapterQueueDepth = HostAdapter->DriverQueueDepth; |
| HostAdapter->SynchronousPermitted = FlashPointInfo->SynchronousPermitted; |
| HostAdapter->FastPermitted = FlashPointInfo->FastPermitted; |
| HostAdapter->UltraPermitted = FlashPointInfo->UltraPermitted; |
| HostAdapter->WidePermitted = FlashPointInfo->WidePermitted; |
| HostAdapter->DisconnectPermitted = FlashPointInfo->DisconnectPermitted; |
| HostAdapter->TaggedQueuingPermitted = 0xFFFF; |
| goto Common; |
| } |
| /* |
| Issue the Inquire Board ID command. |
| */ |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireBoardID, NULL, 0, &BoardID, sizeof(BoardID)) != sizeof(BoardID)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE BOARD ID"); |
| /* |
| Issue the Inquire Configuration command. |
| */ |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireConfiguration, NULL, 0, &Configuration, sizeof(Configuration)) |
| != sizeof(Configuration)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE CONFIGURATION"); |
| /* |
| Issue the Inquire Setup Information command. |
| */ |
| RequestedReplyLength = sizeof(SetupInformation); |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireSetupInformation, &RequestedReplyLength, sizeof(RequestedReplyLength), &SetupInformation, sizeof(SetupInformation)) |
| != sizeof(SetupInformation)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE SETUP INFORMATION"); |
| /* |
| Issue the Inquire Extended Setup Information command. |
| */ |
| RequestedReplyLength = sizeof(ExtendedSetupInformation); |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireExtendedSetupInformation, &RequestedReplyLength, sizeof(RequestedReplyLength), &ExtendedSetupInformation, sizeof(ExtendedSetupInformation)) |
| != sizeof(ExtendedSetupInformation)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE EXTENDED SETUP INFORMATION"); |
| /* |
| Issue the Inquire Firmware Version 3rd Digit command. |
| */ |
| FirmwareVersion3rdDigit = '\0'; |
| if (BoardID.FirmwareVersion1stDigit > '0') |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireFirmwareVersion3rdDigit, NULL, 0, &FirmwareVersion3rdDigit, sizeof(FirmwareVersion3rdDigit)) |
| != sizeof(FirmwareVersion3rdDigit)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE FIRMWARE 3RD DIGIT"); |
| /* |
| Issue the Inquire Host Adapter Model Number command. |
| */ |
| if (ExtendedSetupInformation.BusType == 'A' && BoardID.FirmwareVersion1stDigit == '2') |
| /* BusLogic BT-542B ISA 2.xx */ |
| strcpy(HostAdapterModelNumber, "542B"); |
| else if (ExtendedSetupInformation.BusType == 'E' && BoardID.FirmwareVersion1stDigit == '2' && (BoardID.FirmwareVersion2ndDigit <= '1' || (BoardID.FirmwareVersion2ndDigit == '2' && FirmwareVersion3rdDigit == '0'))) |
| /* BusLogic BT-742A EISA 2.1x or 2.20 */ |
| strcpy(HostAdapterModelNumber, "742A"); |
| else if (ExtendedSetupInformation.BusType == 'E' && BoardID.FirmwareVersion1stDigit == '0') |
| /* AMI FastDisk EISA Series 441 0.x */ |
| strcpy(HostAdapterModelNumber, "747A"); |
| else { |
| RequestedReplyLength = sizeof(HostAdapterModelNumber); |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireHostAdapterModelNumber, &RequestedReplyLength, sizeof(RequestedReplyLength), &HostAdapterModelNumber, sizeof(HostAdapterModelNumber)) |
| != sizeof(HostAdapterModelNumber)) |
| return BusLogic_Failure(HostAdapter, "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. |
| */ |
| TargetPointer = HostAdapter->ModelName; |
| *TargetPointer++ = 'B'; |
| *TargetPointer++ = 'T'; |
| *TargetPointer++ = '-'; |
| for (i = 0; i < sizeof(HostAdapterModelNumber); i++) { |
| Character = HostAdapterModelNumber[i]; |
| if (Character == ' ' || Character == '\0') |
| break; |
| *TargetPointer++ = Character; |
| } |
| *TargetPointer++ = '\0'; |
| /* |
| Save the Firmware Version in the Host Adapter structure. |
| */ |
| TargetPointer = HostAdapter->FirmwareVersion; |
| *TargetPointer++ = BoardID.FirmwareVersion1stDigit; |
| *TargetPointer++ = '.'; |
| *TargetPointer++ = BoardID.FirmwareVersion2ndDigit; |
| if (FirmwareVersion3rdDigit != ' ' && FirmwareVersion3rdDigit != '\0') |
| *TargetPointer++ = FirmwareVersion3rdDigit; |
| *TargetPointer = '\0'; |
| /* |
| Issue the Inquire Firmware Version Letter command. |
| */ |
| if (strcmp(HostAdapter->FirmwareVersion, "3.3") >= 0) { |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireFirmwareVersionLetter, NULL, 0, &FirmwareVersionLetter, sizeof(FirmwareVersionLetter)) |
| != sizeof(FirmwareVersionLetter)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE FIRMWARE VERSION LETTER"); |
| if (FirmwareVersionLetter != ' ' && FirmwareVersionLetter != '\0') |
| *TargetPointer++ = FirmwareVersionLetter; |
| *TargetPointer = '\0'; |
| } |
| /* |
| Save the Host Adapter SCSI ID in the Host Adapter structure. |
| */ |
| HostAdapter->SCSI_ID = Configuration.HostAdapterID; |
| /* |
| 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. |
| */ |
| HostAdapter->HostAdapterBusType = BusLogic_HostAdapterBusTypes[HostAdapter->ModelName[3] - '4']; |
| if (HostAdapter->IRQ_Channel == 0) { |
| if (Configuration.IRQ_Channel9) |
| HostAdapter->IRQ_Channel = 9; |
| else if (Configuration.IRQ_Channel10) |
| HostAdapter->IRQ_Channel = 10; |
| else if (Configuration.IRQ_Channel11) |
| HostAdapter->IRQ_Channel = 11; |
| else if (Configuration.IRQ_Channel12) |
| HostAdapter->IRQ_Channel = 12; |
| else if (Configuration.IRQ_Channel14) |
| HostAdapter->IRQ_Channel = 14; |
| else if (Configuration.IRQ_Channel15) |
| HostAdapter->IRQ_Channel = 15; |
| } |
| if (HostAdapter->HostAdapterBusType == BusLogic_ISA_Bus) { |
| if (Configuration.DMA_Channel5) |
| HostAdapter->DMA_Channel = 5; |
| else if (Configuration.DMA_Channel6) |
| HostAdapter->DMA_Channel = 6; |
| else if (Configuration.DMA_Channel7) |
| HostAdapter->DMA_Channel = 7; |
| } |
| /* |
| Determine whether Extended Translation is enabled and save it in |
| the Host Adapter structure. |
| */ |
| GeometryRegister.All = BusLogic_ReadGeometryRegister(HostAdapter); |
| HostAdapter->ExtendedTranslationEnabled = GeometryRegister.gr.ExtendedTranslationEnabled; |
| /* |
| 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. |
| */ |
| HostAdapter->HostAdapterScatterGatherLimit = ExtendedSetupInformation.ScatterGatherLimit; |
| HostAdapter->DriverScatterGatherLimit = HostAdapter->HostAdapterScatterGatherLimit; |
| if (HostAdapter->HostAdapterScatterGatherLimit > BusLogic_ScatterGatherLimit) |
| HostAdapter->DriverScatterGatherLimit = BusLogic_ScatterGatherLimit; |
| if (ExtendedSetupInformation.Misc.LevelSensitiveInterrupt) |
| HostAdapter->LevelSensitiveInterrupt = true; |
| HostAdapter->HostWideSCSI = ExtendedSetupInformation.HostWideSCSI; |
| HostAdapter->HostDifferentialSCSI = ExtendedSetupInformation.HostDifferentialSCSI; |
| HostAdapter->HostSupportsSCAM = ExtendedSetupInformation.HostSupportsSCAM; |
| HostAdapter->HostUltraSCSI = ExtendedSetupInformation.HostUltraSCSI; |
| /* |
| Determine whether Extended LUN Format CCBs are supported and save the |
| information in the Host Adapter structure. |
| */ |
| if (HostAdapter->FirmwareVersion[0] == '5' || (HostAdapter->FirmwareVersion[0] == '4' && HostAdapter->HostWideSCSI)) |
| HostAdapter->ExtendedLUNSupport = true; |
| /* |
| Issue the Inquire PCI Host Adapter Information command to read the |
| Termination Information from "W" series MultiMaster Host Adapters. |
| */ |
| if (HostAdapter->FirmwareVersion[0] == '5') { |
| if (BusLogic_Command(HostAdapter, BusLogic_InquirePCIHostAdapterInformation, NULL, 0, &PCIHostAdapterInformation, sizeof(PCIHostAdapterInformation)) |
| != sizeof(PCIHostAdapterInformation)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE PCI HOST ADAPTER INFORMATION"); |
| /* |
| Save the Termination Information in the Host Adapter structure. |
| */ |
| if (PCIHostAdapterInformation.GenericInfoValid) { |
| HostAdapter->TerminationInfoValid = true; |
| HostAdapter->LowByteTerminated = PCIHostAdapterInformation.LowByteTerminated; |
| HostAdapter->HighByteTerminated = PCIHostAdapterInformation.HighByteTerminated; |
| } |
| } |
| /* |
| Issue the Fetch Host Adapter Local RAM command to read the AutoSCSI data |
| from "W" and "C" series MultiMaster Host Adapters. |
| */ |
| if (HostAdapter->FirmwareVersion[0] >= '4') { |
| FetchHostAdapterLocalRAMRequest.ByteOffset = BusLogic_AutoSCSI_BaseOffset; |
| FetchHostAdapterLocalRAMRequest.ByteCount = sizeof(AutoSCSIData); |
| if (BusLogic_Command(HostAdapter, BusLogic_FetchHostAdapterLocalRAM, &FetchHostAdapterLocalRAMRequest, sizeof(FetchHostAdapterLocalRAMRequest), &AutoSCSIData, sizeof(AutoSCSIData)) |
| != sizeof(AutoSCSIData)) |
| return BusLogic_Failure(HostAdapter, "FETCH HOST ADAPTER LOCAL RAM"); |
| /* |
| Save the Parity Checking Enabled, Bus Reset Enabled, and Termination |
| Information in the Host Adapter structure. |
| */ |
| HostAdapter->ParityCheckingEnabled = AutoSCSIData.ParityCheckingEnabled; |
| HostAdapter->BusResetEnabled = AutoSCSIData.BusResetEnabled; |
| if (HostAdapter->FirmwareVersion[0] == '4') { |
| HostAdapter->TerminationInfoValid = true; |
| HostAdapter->LowByteTerminated = AutoSCSIData.LowByteTerminated; |
| HostAdapter->HighByteTerminated = AutoSCSIData.HighByteTerminated; |
| } |
| /* |
| Save the Wide Permitted, Fast Permitted, Synchronous Permitted, |
| Disconnect Permitted, Ultra Permitted, and SCAM Information in the |
| Host Adapter structure. |
| */ |
| HostAdapter->WidePermitted = AutoSCSIData.WidePermitted; |
| HostAdapter->FastPermitted = AutoSCSIData.FastPermitted; |
| HostAdapter->SynchronousPermitted = AutoSCSIData.SynchronousPermitted; |
| HostAdapter->DisconnectPermitted = AutoSCSIData.DisconnectPermitted; |
| if (HostAdapter->HostUltraSCSI) |
| HostAdapter->UltraPermitted = AutoSCSIData.UltraPermitted; |
| if (HostAdapter->HostSupportsSCAM) { |
| HostAdapter->SCAM_Enabled = AutoSCSIData.SCAM_Enabled; |
| HostAdapter->SCAM_Level2 = AutoSCSIData.SCAM_Level2; |
| } |
| } |
| /* |
| Initialize fields in the Host Adapter structure for "S" and "A" series |
| MultiMaster Host Adapters. |
| */ |
| if (HostAdapter->FirmwareVersion[0] < '4') { |
| if (SetupInformation.SynchronousInitiationEnabled) { |
| HostAdapter->SynchronousPermitted = 0xFF; |
| if (HostAdapter->HostAdapterBusType == BusLogic_EISA_Bus) { |
| if (ExtendedSetupInformation.Misc.FastOnEISA) |
| HostAdapter->FastPermitted = 0xFF; |
| if (strcmp(HostAdapter->ModelName, "BT-757") == 0) |
| HostAdapter->WidePermitted = 0xFF; |
| } |
| } |
| HostAdapter->DisconnectPermitted = 0xFF; |
| HostAdapter->ParityCheckingEnabled = SetupInformation.ParityCheckingEnabled; |
| HostAdapter->BusResetEnabled = true; |
| } |
| /* |
| Determine the maximum number of Target IDs and Logical Units supported by |
| this driver for Wide and Narrow Host Adapters. |
| */ |
| HostAdapter->MaxTargetDevices = (HostAdapter->HostWideSCSI ? 16 : 8); |
| HostAdapter->MaxLogicalUnits = (HostAdapter->ExtendedLUNSupport ? 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 (HostAdapter->FirmwareVersion[0] == '5') |
| HostAdapter->HostAdapterQueueDepth = 192; |
| else if (HostAdapter->FirmwareVersion[0] == '4') |
| HostAdapter->HostAdapterQueueDepth = (HostAdapter->HostAdapterBusType != BusLogic_ISA_Bus ? 100 : 50); |
| else |
| HostAdapter->HostAdapterQueueDepth = 30; |
| if (strcmp(HostAdapter->FirmwareVersion, "3.31") >= 0) { |
| HostAdapter->StrictRoundRobinModeSupport = true; |
| HostAdapter->MailboxCount = BusLogic_MaxMailboxes; |
| } else { |
| HostAdapter->StrictRoundRobinModeSupport = false; |
| HostAdapter->MailboxCount = 32; |
| } |
| HostAdapter->DriverQueueDepth = HostAdapter->MailboxCount; |
| HostAdapter->InitialCCBs = 4 * BusLogic_CCB_AllocationGroupSize; |
| HostAdapter->IncrementalCCBs = BusLogic_CCB_AllocationGroupSize; |
| /* |
| 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. |
| */ |
| HostAdapter->TaggedQueuingPermitted = 0; |
| switch (HostAdapter->FirmwareVersion[0]) { |
| case '5': |
| HostAdapter->TaggedQueuingPermitted = 0xFFFF; |
| break; |
| case '4': |
| if (strcmp(HostAdapter->FirmwareVersion, "4.22") >= 0) |
| HostAdapter->TaggedQueuingPermitted = 0xFFFF; |
| break; |
| case '3': |
| if (strcmp(HostAdapter->FirmwareVersion, "3.35") >= 0) |
| HostAdapter->TaggedQueuingPermitted = 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_Address is 0. |
| */ |
| HostAdapter->BIOS_Address = ExtendedSetupInformation.BIOS_Address << 12; |
| /* |
| ISA Host Adapters require Bounce Buffers if there is more than 16MB memory. |
| */ |
| if (HostAdapter->HostAdapterBusType == BusLogic_ISA_Bus && (void *) high_memory > (void *) MAX_DMA_ADDRESS) |
| HostAdapter->BounceBuffersRequired = 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 (HostAdapter->BIOS_Address > 0 && strcmp(HostAdapter->ModelName, "BT-445S") == 0 && strcmp(HostAdapter->FirmwareVersion, "3.37") < 0 && (void *) high_memory > (void *) MAX_DMA_ADDRESS) |
| HostAdapter->BounceBuffersRequired = true; |
| /* |
| Initialize parameters common to MultiMaster and FlashPoint Host Adapters. |
| */ |
| Common: |
| /* |
| Initialize the Host Adapter Full Model Name from the Model Name. |
| */ |
| strcpy(HostAdapter->FullModelName, "BusLogic "); |
| strcat(HostAdapter->FullModelName, HostAdapter->ModelName); |
| /* |
| 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 (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++) { |
| unsigned char QueueDepth = 0; |
| if (HostAdapter->DriverOptions != NULL && HostAdapter->DriverOptions->QueueDepth[TargetID] > 0) |
| QueueDepth = HostAdapter->DriverOptions->QueueDepth[TargetID]; |
| else if (HostAdapter->BounceBuffersRequired) |
| QueueDepth = BusLogic_TaggedQueueDepthBB; |
| HostAdapter->QueueDepth[TargetID] = QueueDepth; |
| } |
| if (HostAdapter->BounceBuffersRequired) |
| HostAdapter->UntaggedQueueDepth = BusLogic_UntaggedQueueDepthBB; |
| else |
| HostAdapter->UntaggedQueueDepth = BusLogic_UntaggedQueueDepth; |
| if (HostAdapter->DriverOptions != NULL) |
| HostAdapter->CommonQueueDepth = HostAdapter->DriverOptions->CommonQueueDepth; |
| if (HostAdapter->CommonQueueDepth > 0 && HostAdapter->CommonQueueDepth < HostAdapter->UntaggedQueueDepth) |
| HostAdapter->UntaggedQueueDepth = HostAdapter->CommonQueueDepth; |
| /* |
| Tagged Queuing is only allowed if Disconnect/Reconnect is permitted. |
| Therefore, mask the Tagged Queuing Permitted Default bits with the |
| Disconnect/Reconnect Permitted bits. |
| */ |
| HostAdapter->TaggedQueuingPermitted &= HostAdapter->DisconnectPermitted; |
| /* |
| Combine the default Tagged Queuing Permitted bits with any BusLogic Driver |
| Options Tagged Queuing specification. |
| */ |
| if (HostAdapter->DriverOptions != NULL) |
| HostAdapter->TaggedQueuingPermitted = |
| (HostAdapter->DriverOptions->TaggedQueuingPermitted & HostAdapter->DriverOptions->TaggedQueuingPermittedMask) | (HostAdapter->TaggedQueuingPermitted & ~HostAdapter->DriverOptions->TaggedQueuingPermittedMask); |
| |
| /* |
| Select an appropriate value for Bus Settle Time either from a BusLogic |
| Driver Options specification, or from BusLogic_DefaultBusSettleTime. |
| */ |
| if (HostAdapter->DriverOptions != NULL && HostAdapter->DriverOptions->BusSettleTime > 0) |
| HostAdapter->BusSettleTime = HostAdapter->DriverOptions->BusSettleTime; |
| else |
| HostAdapter->BusSettleTime = BusLogic_DefaultBusSettleTime; |
| /* |
| Indicate reading the Host Adapter Configuration completed successfully. |
| */ |
| return true; |
| } |
| |
| |
| /* |
| BusLogic_ReportHostAdapterConfiguration reports the configuration of |
| Host Adapter. |
| */ |
| |
| static bool __init BusLogic_ReportHostAdapterConfiguration(struct BusLogic_HostAdapter |
| *HostAdapter) |
| { |
| unsigned short AllTargetsMask = (1 << HostAdapter->MaxTargetDevices) - 1; |
| unsigned short SynchronousPermitted, FastPermitted; |
| unsigned short UltraPermitted, WidePermitted; |
| unsigned short DisconnectPermitted, TaggedQueuingPermitted; |
| bool CommonSynchronousNegotiation, CommonTaggedQueueDepth; |
| char SynchronousString[BusLogic_MaxTargetDevices + 1]; |
| char WideString[BusLogic_MaxTargetDevices + 1]; |
| char DisconnectString[BusLogic_MaxTargetDevices + 1]; |
| char TaggedQueuingString[BusLogic_MaxTargetDevices + 1]; |
| char *SynchronousMessage = SynchronousString; |
| char *WideMessage = WideString; |
| char *DisconnectMessage = DisconnectString; |
| char *TaggedQueuingMessage = TaggedQueuingString; |
| int TargetID; |
| BusLogic_Info("Configuring BusLogic Model %s %s%s%s%s SCSI Host Adapter\n", |
| HostAdapter, HostAdapter->ModelName, |
| BusLogic_HostAdapterBusNames[HostAdapter->HostAdapterBusType], (HostAdapter->HostWideSCSI ? " Wide" : ""), (HostAdapter->HostDifferentialSCSI ? " Differential" : ""), (HostAdapter->HostUltraSCSI ? " Ultra" : "")); |
| BusLogic_Info(" Firmware Version: %s, I/O Address: 0x%X, " "IRQ Channel: %d/%s\n", HostAdapter, HostAdapter->FirmwareVersion, HostAdapter->IO_Address, HostAdapter->IRQ_Channel, (HostAdapter->LevelSensitiveInterrupt ? "Level" : "Edge")); |
| if (HostAdapter->HostAdapterBusType != BusLogic_PCI_Bus) { |
| BusLogic_Info(" DMA Channel: ", HostAdapter); |
| if (HostAdapter->DMA_Channel > 0) |
| BusLogic_Info("%d, ", HostAdapter, HostAdapter->DMA_Channel); |
| else |
| BusLogic_Info("None, ", HostAdapter); |
| if (HostAdapter->BIOS_Address > 0) |
| BusLogic_Info("BIOS Address: 0x%X, ", HostAdapter, HostAdapter->BIOS_Address); |
| else |
| BusLogic_Info("BIOS Address: None, ", HostAdapter); |
| } else { |
| BusLogic_Info(" PCI Bus: %d, Device: %d, Address: ", HostAdapter, HostAdapter->Bus, HostAdapter->Device); |
| if (HostAdapter->PCI_Address > 0) |
| BusLogic_Info("0x%X, ", HostAdapter, HostAdapter->PCI_Address); |
| else |
| BusLogic_Info("Unassigned, ", HostAdapter); |
| } |
| BusLogic_Info("Host Adapter SCSI ID: %d\n", HostAdapter, HostAdapter->SCSI_ID); |
| BusLogic_Info(" Parity Checking: %s, Extended Translation: %s\n", HostAdapter, (HostAdapter->ParityCheckingEnabled ? "Enabled" : "Disabled"), (HostAdapter->ExtendedTranslationEnabled ? "Enabled" : "Disabled")); |
| AllTargetsMask &= ~(1 << HostAdapter->SCSI_ID); |
| SynchronousPermitted = HostAdapter->SynchronousPermitted & AllTargetsMask; |
| FastPermitted = HostAdapter->FastPermitted & AllTargetsMask; |
| UltraPermitted = HostAdapter->UltraPermitted & AllTargetsMask; |
| if ((BusLogic_MultiMasterHostAdapterP(HostAdapter) && (HostAdapter->FirmwareVersion[0] >= '4' || HostAdapter->HostAdapterBusType == BusLogic_EISA_Bus)) || BusLogic_FlashPointHostAdapterP(HostAdapter)) { |
| CommonSynchronousNegotiation = false; |
| if (SynchronousPermitted == 0) { |
| SynchronousMessage = "Disabled"; |
| CommonSynchronousNegotiation = true; |
| } else if (SynchronousPermitted == AllTargetsMask) { |
| if (FastPermitted == 0) { |
| SynchronousMessage = "Slow"; |
| CommonSynchronousNegotiation = true; |
| } else if (FastPermitted == AllTargetsMask) { |
| if (UltraPermitted == 0) { |
| SynchronousMessage = "Fast"; |
| CommonSynchronousNegotiation = true; |
| } else if (UltraPermitted == AllTargetsMask) { |
| SynchronousMessage = "Ultra"; |
| CommonSynchronousNegotiation = true; |
| } |
| } |
| } |
| if (!CommonSynchronousNegotiation) { |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| SynchronousString[TargetID] = ((!(SynchronousPermitted & (1 << TargetID))) ? 'N' : (!(FastPermitted & (1 << TargetID)) ? 'S' : (!(UltraPermitted & (1 << TargetID)) ? 'F' : 'U'))); |
| SynchronousString[HostAdapter->SCSI_ID] = '#'; |
| SynchronousString[HostAdapter->MaxTargetDevices] = '\0'; |
| } |
| } else |
| SynchronousMessage = (SynchronousPermitted == 0 ? "Disabled" : "Enabled"); |
| WidePermitted = HostAdapter->WidePermitted & AllTargetsMask; |
| if (WidePermitted == 0) |
| WideMessage = "Disabled"; |
| else if (WidePermitted == AllTargetsMask) |
| WideMessage = "Enabled"; |
| else { |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| WideString[TargetID] = ((WidePermitted & (1 << TargetID)) ? 'Y' : 'N'); |
| WideString[HostAdapter->SCSI_ID] = '#'; |
| WideString[HostAdapter->MaxTargetDevices] = '\0'; |
| } |
| DisconnectPermitted = HostAdapter->DisconnectPermitted & AllTargetsMask; |
| if (DisconnectPermitted == 0) |
| DisconnectMessage = "Disabled"; |
| else if (DisconnectPermitted == AllTargetsMask) |
| DisconnectMessage = "Enabled"; |
| else { |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| DisconnectString[TargetID] = ((DisconnectPermitted & (1 << TargetID)) ? 'Y' : 'N'); |
| DisconnectString[HostAdapter->SCSI_ID] = '#'; |
| DisconnectString[HostAdapter->MaxTargetDevices] = '\0'; |
| } |
| TaggedQueuingPermitted = HostAdapter->TaggedQueuingPermitted & AllTargetsMask; |
| if (TaggedQueuingPermitted == 0) |
| TaggedQueuingMessage = "Disabled"; |
| else if (TaggedQueuingPermitted == AllTargetsMask) |
| TaggedQueuingMessage = "Enabled"; |
| else { |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| TaggedQueuingString[TargetID] = ((TaggedQueuingPermitted & (1 << TargetID)) ? 'Y' : 'N'); |
| TaggedQueuingString[HostAdapter->SCSI_ID] = '#'; |
| TaggedQueuingString[HostAdapter->MaxTargetDevices] = '\0'; |
| } |
| BusLogic_Info(" Synchronous Negotiation: %s, Wide Negotiation: %s\n", HostAdapter, SynchronousMessage, WideMessage); |
| BusLogic_Info(" Disconnect/Reconnect: %s, Tagged Queuing: %s\n", HostAdapter, DisconnectMessage, TaggedQueuingMessage); |
| if (BusLogic_MultiMasterHostAdapterP(HostAdapter)) { |
| BusLogic_Info(" Scatter/Gather Limit: %d of %d segments, " "Mailboxes: %d\n", HostAdapter, HostAdapter->DriverScatterGatherLimit, HostAdapter->HostAdapterScatterGatherLimit, HostAdapter->MailboxCount); |
| BusLogic_Info(" Driver Queue Depth: %d, " "Host Adapter Queue Depth: %d\n", HostAdapter, HostAdapter->DriverQueueDepth, HostAdapter->HostAdapterQueueDepth); |
| } else |
| BusLogic_Info(" Driver Queue Depth: %d, " "Scatter/Gather Limit: %d segments\n", HostAdapter, HostAdapter->DriverQueueDepth, HostAdapter->DriverScatterGatherLimit); |
| BusLogic_Info(" Tagged Queue Depth: ", HostAdapter); |
| CommonTaggedQueueDepth = true; |
| for (TargetID = 1; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| if (HostAdapter->QueueDepth[TargetID] != HostAdapter->QueueDepth[0]) { |
| CommonTaggedQueueDepth = false; |
| break; |
| } |
| if (CommonTaggedQueueDepth) { |
| if (HostAdapter->QueueDepth[0] > 0) |
| BusLogic_Info("%d", HostAdapter, HostAdapter->QueueDepth[0]); |
| else |
| BusLogic_Info("Automatic", HostAdapter); |
| } else |
| BusLogic_Info("Individual", HostAdapter); |
| BusLogic_Info(", Untagged Queue Depth: %d\n", HostAdapter, HostAdapter->UntaggedQueueDepth); |
| if (HostAdapter->TerminationInfoValid) { |
| if (HostAdapter->HostWideSCSI) |
| BusLogic_Info(" SCSI Bus Termination: %s", HostAdapter, (HostAdapter->LowByteTerminated ? (HostAdapter->HighByteTerminated ? "Both Enabled" : "Low Enabled") |
| : (HostAdapter->HighByteTerminated ? "High Enabled" : "Both Disabled"))); |
| else |
| BusLogic_Info(" SCSI Bus Termination: %s", HostAdapter, (HostAdapter->LowByteTerminated ? "Enabled" : "Disabled")); |
| if (HostAdapter->HostSupportsSCAM) |
| BusLogic_Info(", SCAM: %s", HostAdapter, (HostAdapter->SCAM_Enabled ? (HostAdapter->SCAM_Level2 ? "Enabled, Level 2" : "Enabled, Level 1") |
| : "Disabled")); |
| BusLogic_Info("\n", HostAdapter); |
| } |
| /* |
| Indicate reporting the Host Adapter configuration completed successfully. |
| */ |
| return true; |
| } |
| |
| |
| /* |
| BusLogic_AcquireResources acquires the system resources necessary to use |
| Host Adapter. |
| */ |
| |
| static bool __init BusLogic_AcquireResources(struct BusLogic_HostAdapter *HostAdapter) |
| { |
| if (HostAdapter->IRQ_Channel == 0) { |
| BusLogic_Error("NO LEGAL INTERRUPT CHANNEL ASSIGNED - DETACHING\n", HostAdapter); |
| return false; |
| } |
| /* |
| Acquire shared access to the IRQ Channel. |
| */ |
| if (request_irq(HostAdapter->IRQ_Channel, BusLogic_InterruptHandler, IRQF_SHARED, HostAdapter->FullModelName, HostAdapter) < 0) { |
| BusLogic_Error("UNABLE TO ACQUIRE IRQ CHANNEL %d - DETACHING\n", HostAdapter, HostAdapter->IRQ_Channel); |
| return false; |
| } |
| HostAdapter->IRQ_ChannelAcquired = true; |
| /* |
| Acquire exclusive access to the DMA Channel. |
| */ |
| if (HostAdapter->DMA_Channel > 0) { |
| if (request_dma(HostAdapter->DMA_Channel, HostAdapter->FullModelName) < 0) { |
| BusLogic_Error("UNABLE TO ACQUIRE DMA CHANNEL %d - DETACHING\n", HostAdapter, HostAdapter->DMA_Channel); |
| return false; |
| } |
| set_dma_mode(HostAdapter->DMA_Channel, DMA_MODE_CASCADE); |
| enable_dma(HostAdapter->DMA_Channel); |
| HostAdapter->DMA_ChannelAcquired = true; |
| } |
| /* |
| Indicate the System Resource Acquisition completed successfully, |
| */ |
| return true; |
| } |
| |
| |
| /* |
| BusLogic_ReleaseResources releases any system resources previously acquired |
| by BusLogic_AcquireResources. |
| */ |
| |
| static void BusLogic_ReleaseResources(struct BusLogic_HostAdapter *HostAdapter) |
| { |
| /* |
| Release shared access to the IRQ Channel. |
| */ |
| if (HostAdapter->IRQ_ChannelAcquired) |
| free_irq(HostAdapter->IRQ_Channel, HostAdapter); |
| /* |
| Release exclusive access to the DMA Channel. |
| */ |
| if (HostAdapter->DMA_ChannelAcquired) |
| free_dma(HostAdapter->DMA_Channel); |
| /* |
| Release any allocated memory structs not released elsewhere |
| */ |
| if (HostAdapter->MailboxSpace) |
| pci_free_consistent(HostAdapter->PCI_Device, HostAdapter->MailboxSize, HostAdapter->MailboxSpace, HostAdapter->MailboxSpaceHandle); |
| pci_dev_put(HostAdapter->PCI_Device); |
| HostAdapter->MailboxSpace = NULL; |
| HostAdapter->MailboxSpaceHandle = 0; |
| HostAdapter->MailboxSize = 0; |
| } |
| |
| |
| /* |
| BusLogic_InitializeHostAdapter 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 BusLogic_InitializeHostAdapter(struct BusLogic_HostAdapter |
| *HostAdapter) |
| { |
| struct BusLogic_ExtendedMailboxRequest ExtendedMailboxRequest; |
| enum BusLogic_RoundRobinModeRequest RoundRobinModeRequest; |
| enum BusLogic_SetCCBFormatRequest SetCCBFormatRequest; |
| int TargetID; |
| /* |
| Initialize the pointers to the first and last CCBs that are queued for |
| completion processing. |
| */ |
| HostAdapter->FirstCompletedCCB = NULL; |
| HostAdapter->LastCompletedCCB = NULL; |
| /* |
| Initialize the Bus Device Reset Pending CCB, Tagged Queuing Active, |
| Command Successful Flag, Active Commands, and Commands Since Reset |
| for each Target Device. |
| */ |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) { |
| HostAdapter->BusDeviceResetPendingCCB[TargetID] = NULL; |
| HostAdapter->TargetFlags[TargetID].TaggedQueuingActive = false; |
| HostAdapter->TargetFlags[TargetID].CommandSuccessfulFlag = false; |
| HostAdapter->ActiveCommands[TargetID] = 0; |
| HostAdapter->CommandsSinceReset[TargetID] = 0; |
| } |
| /* |
| FlashPoint Host Adapters do not use Outgoing and Incoming Mailboxes. |
| */ |
| if (BusLogic_FlashPointHostAdapterP(HostAdapter)) |
| goto Done; |
| /* |
| Initialize the Outgoing and Incoming Mailbox pointers. |
| */ |
| HostAdapter->MailboxSize = HostAdapter->MailboxCount * (sizeof(struct BusLogic_OutgoingMailbox) + sizeof(struct BusLogic_IncomingMailbox)); |
| HostAdapter->MailboxSpace = pci_alloc_consistent(HostAdapter->PCI_Device, HostAdapter->MailboxSize, &HostAdapter->MailboxSpaceHandle); |
| if (HostAdapter->MailboxSpace == NULL) |
| return BusLogic_Failure(HostAdapter, "MAILBOX ALLOCATION"); |
| HostAdapter->FirstOutgoingMailbox = (struct BusLogic_OutgoingMailbox *) HostAdapter->MailboxSpace; |
| HostAdapter->LastOutgoingMailbox = HostAdapter->FirstOutgoingMailbox + HostAdapter->MailboxCount - 1; |
| HostAdapter->NextOutgoingMailbox = HostAdapter->FirstOutgoingMailbox; |
| HostAdapter->FirstIncomingMailbox = (struct BusLogic_IncomingMailbox *) (HostAdapter->LastOutgoingMailbox + 1); |
| HostAdapter->LastIncomingMailbox = HostAdapter->FirstIncomingMailbox + HostAdapter->MailboxCount - 1; |
| HostAdapter->NextIncomingMailbox = HostAdapter->FirstIncomingMailbox; |
| |
| /* |
| Initialize the Outgoing and Incoming Mailbox structures. |
| */ |
| memset(HostAdapter->FirstOutgoingMailbox, 0, HostAdapter->MailboxCount * sizeof(struct BusLogic_OutgoingMailbox)); |
| memset(HostAdapter->FirstIncomingMailbox, 0, HostAdapter->MailboxCount * sizeof(struct BusLogic_IncomingMailbox)); |
| /* |
| Initialize the Host Adapter's Pointer to the Outgoing/Incoming Mailboxes. |
| */ |
| ExtendedMailboxRequest.MailboxCount = HostAdapter->MailboxCount; |
| ExtendedMailboxRequest.BaseMailboxAddress = (u32) HostAdapter->MailboxSpaceHandle; |
| if (BusLogic_Command(HostAdapter, BusLogic_InitializeExtendedMailbox, &ExtendedMailboxRequest, sizeof(ExtendedMailboxRequest), NULL, 0) < 0) |
| return BusLogic_Failure(HostAdapter, "MAILBOX INITIALIZATION"); |
| /* |
| Enable Strict Round Robin Mode if supported by the Host Adapter. In |
| Strict Round Robin Mode, the Host Adapter only looks at the next Outgoing |
| Mailbox for each new command, rather than scanning through all the |
| Outgoing Mailboxes to find any that have new commands in them. Strict |
| Round Robin Mode is significantly more efficient. |
| */ |
| if (HostAdapter->StrictRoundRobinModeSupport) { |
| RoundRobinModeRequest = BusLogic_StrictRoundRobinMode; |
| if (BusLogic_Command(HostAdapter, BusLogic_EnableStrictRoundRobinMode, &RoundRobinModeRequest, sizeof(RoundRobinModeRequest), NULL, 0) < 0) |
| return BusLogic_Failure(HostAdapter, "ENABLE STRICT ROUND ROBIN MODE"); |
| } |
| /* |
| For Host Adapters that support Extended LUN Format CCBs, issue the Set CCB |
| Format command to allow 32 Logical Units per Target Device. |
| */ |
| if (HostAdapter->ExtendedLUNSupport) { |
| SetCCBFormatRequest = BusLogic_ExtendedLUNFormatCCB; |
| if (BusLogic_Command(HostAdapter, BusLogic_SetCCBFormat, &SetCCBFormatRequest, sizeof(SetCCBFormatRequest), NULL, 0) < 0) |
| return BusLogic_Failure(HostAdapter, "SET CCB FORMAT"); |
| } |
| /* |
| Announce Successful Initialization. |
| */ |
| Done: |
| if (!HostAdapter->HostAdapterInitialized) { |
| BusLogic_Info("*** %s Initialized Successfully ***\n", HostAdapter, HostAdapter->FullModelName); |
| BusLogic_Info("\n", HostAdapter); |
| } else |
| BusLogic_Warning("*** %s Initialized Successfully ***\n", HostAdapter, HostAdapter->FullModelName); |
| HostAdapter->HostAdapterInitialized = true; |
| /* |
| Indicate the Host Adapter Initialization completed successfully. |
| */ |
| return true; |
| } |
| |
| |
| /* |
| BusLogic_TargetDeviceInquiry inquires about the Target Devices accessible |
| through Host Adapter. |
| */ |
| |
| static bool __init BusLogic_TargetDeviceInquiry(struct BusLogic_HostAdapter |
| *HostAdapter) |
| { |
| u16 InstalledDevices; |
| u8 InstalledDevicesID0to7[8]; |
| struct BusLogic_SetupInformation SetupInformation; |
| u8 SynchronousPeriod[BusLogic_MaxTargetDevices]; |
| unsigned char RequestedReplyLength; |
| int TargetID; |
| /* |
| Wait a few seconds between the Host Adapter Hard Reset which initiates |
| a SCSI Bus Reset and issuing any SCSI Commands. Some SCSI devices get |
| confused if they receive SCSI Commands too soon after a SCSI Bus Reset. |
| */ |
| BusLogic_Delay(HostAdapter->BusSettleTime); |
| /* |
| FlashPoint Host Adapters do not provide for Target Device Inquiry. |
| */ |
| if (BusLogic_FlashPointHostAdapterP(HostAdapter)) |
| return true; |
| /* |
| Inhibit the Target Device Inquiry if requested. |
| */ |
| if (HostAdapter->DriverOptions != NULL && HostAdapter->DriverOptions->LocalOptions.InhibitTargetInquiry) |
| return true; |
| /* |
| Issue the Inquire Target Devices command for host adapters with firmware |
| version 4.25 or later, or the Inquire Installed Devices ID 0 to 7 command |
| for older host adapters. This is necessary to force Synchronous Transfer |
| Negotiation so that the Inquire Setup Information and Inquire Synchronous |
| Period commands will return valid data. The Inquire Target Devices command |
| is preferable to Inquire Installed Devices ID 0 to 7 since it only probes |
| Logical Unit 0 of each Target Device. |
| */ |
| if (strcmp(HostAdapter->FirmwareVersion, "4.25") >= 0) { |
| |
| /* |
| * Issue a Inquire Target Devices command. Inquire Target Devices only |
| * tests Logical Unit 0 of each Target Device unlike the Inquire Installed |
| * Devices commands which test Logical Units 0 - 7. Two bytes are |
| * returned, where byte 0 bit 0 set indicates that Target Device 0 exists, |
| * and so on. |
| */ |
| |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireTargetDevices, NULL, 0, &InstalledDevices, sizeof(InstalledDevices)) |
| != sizeof(InstalledDevices)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE TARGET DEVICES"); |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| HostAdapter->TargetFlags[TargetID].TargetExists = (InstalledDevices & (1 << TargetID) ? true : false); |
| } else { |
| |
| /* |
| * Issue an Inquire Installed Devices command. For each Target Device, |
| * a byte is returned where bit 0 set indicates that Logical Unit 0 |
| * exists, bit 1 set indicates that Logical Unit 1 exists, and so on. |
| */ |
| |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireInstalledDevicesID0to7, NULL, 0, &InstalledDevicesID0to7, sizeof(InstalledDevicesID0to7)) |
| != sizeof(InstalledDevicesID0to7)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE INSTALLED DEVICES ID 0 TO 7"); |
| for (TargetID = 0; TargetID < 8; TargetID++) |
| HostAdapter->TargetFlags[TargetID].TargetExists = (InstalledDevicesID0to7[TargetID] != 0 ? true : false); |
| } |
| /* |
| Issue the Inquire Setup Information command. |
| */ |
| RequestedReplyLength = sizeof(SetupInformation); |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireSetupInformation, &RequestedReplyLength, sizeof(RequestedReplyLength), &SetupInformation, sizeof(SetupInformation)) |
| != sizeof(SetupInformation)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE SETUP INFORMATION"); |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| HostAdapter->SynchronousOffset[TargetID] = (TargetID < 8 ? SetupInformation.SynchronousValuesID0to7[TargetID].Offset : SetupInformation.SynchronousValuesID8to15[TargetID - 8].Offset); |
| if (strcmp(HostAdapter->FirmwareVersion, "5.06L") >= 0) |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| HostAdapter->TargetFlags[TargetID].WideTransfersActive = (TargetID < 8 ? (SetupInformation.WideTransfersActiveID0to7 & (1 << TargetID) |
| ? true : false) |
| : (SetupInformation.WideTransfersActiveID8to15 & (1 << (TargetID - 8)) |
| ? true : false)); |
| /* |
| Issue the Inquire Synchronous Period command. |
| */ |
| if (HostAdapter->FirmwareVersion[0] >= '3') { |
| |
| /* Issue a Inquire Synchronous Period command. For each Target Device, |
| * a byte is returned which represents the Synchronous Transfer Period |
| * in units of 10 nanoseconds. |
| */ |
| |
| RequestedReplyLength = sizeof(SynchronousPeriod); |
| if (BusLogic_Command(HostAdapter, BusLogic_InquireSynchronousPeriod, &RequestedReplyLength, sizeof(RequestedReplyLength), &SynchronousPeriod, sizeof(SynchronousPeriod)) |
| != sizeof(SynchronousPeriod)) |
| return BusLogic_Failure(HostAdapter, "INQUIRE SYNCHRONOUS PERIOD"); |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| HostAdapter->SynchronousPeriod[TargetID] = SynchronousPeriod[TargetID]; |
| } else |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| if (SetupInformation.SynchronousValuesID0to7[TargetID].Offset > 0) |
| HostAdapter->SynchronousPeriod[TargetID] = 20 + 5 * SetupInformation.SynchronousValuesID0to7[TargetID] |
| .TransferPeriod; |
| /* |
| Indicate the Target Device Inquiry completed successfully. |
| */ |
| return true; |
| } |
| |
| /* |
| BusLogic_InitializeHostStructure 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 BusLogic_InitializeHostStructure(struct BusLogic_HostAdapter |
| *HostAdapter, struct Scsi_Host *Host) |
| { |
| Host->max_id = HostAdapter->MaxTargetDevices; |
| Host->max_lun = HostAdapter->MaxLogicalUnits; |
| Host->max_channel = 0; |
| Host->unique_id = HostAdapter->IO_Address; |
| Host->this_id = HostAdapter->SCSI_ID; |
| Host->can_queue = HostAdapter->DriverQueueDepth; |
| Host->sg_tablesize = HostAdapter->DriverScatterGatherLimit; |
| Host->unchecked_isa_dma = HostAdapter->BounceBuffersRequired; |
| Host->cmd_per_lun = HostAdapter->UntaggedQueueDepth; |
| } |
| |
| /* |
| BusLogic_SlaveConfigure 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 BusLogic_SlaveConfigure(struct scsi_device *Device) |
| { |
| struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) Device->host->hostdata; |
| int TargetID = Device->id; |
| int QueueDepth = HostAdapter->QueueDepth[TargetID]; |
| |
| if (HostAdapter->TargetFlags[TargetID].TaggedQueuingSupported && (HostAdapter->TaggedQueuingPermitted & (1 << TargetID))) { |
| if (QueueDepth == 0) |
| QueueDepth = BusLogic_MaxAutomaticTaggedQueueDepth; |
| HostAdapter->QueueDepth[TargetID] = QueueDepth; |
| scsi_adjust_queue_depth(Device, MSG_SIMPLE_TAG, QueueDepth); |
| } else { |
| HostAdapter->TaggedQueuingPermitted &= ~(1 << TargetID); |
| QueueDepth = HostAdapter->UntaggedQueueDepth; |
| HostAdapter->QueueDepth[TargetID] = QueueDepth; |
| scsi_adjust_queue_depth(Device, 0, QueueDepth); |
| } |
| QueueDepth = 0; |
| for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++) |
| if (HostAdapter->TargetFlags[TargetID].TargetExists) { |
| QueueDepth += HostAdapter->QueueDepth[TargetID]; |
| } |
| if (QueueDepth > HostAdapter->AllocatedCCBs) |
| BusLogic_CreateAdditionalCCBs(HostAdapter, QueueDepth - HostAdapter->AllocatedCCBs, false); |
| return 0; |
| } |
| |
| /* |
| BusLogic_DetectHostAdapter 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 BusLogic_init(void) |
| { |
| int BusLogicHostAdapterCount = 0, DriverOptionsIndex = 0, ProbeIndex; |
| struct BusLogic_HostAdapter *PrototypeHostAdapter; |
| int ret = 0; |
| |
| #ifdef MODULE |
| if (BusLogic) |
| BusLogic_Setup(BusLogic); |
| #endif |
| |
| if (BusLogic_ProbeOptions.NoProbe) |
| return -ENODEV; |
| BusLogic_ProbeInfoList = |
| kzalloc(BusLogic_MaxHostAdapters * sizeof(struct BusLogic_ProbeInfo), GFP_KERNEL); |
| if (BusLogic_ProbeInfoList == NULL) { |
| BusLogic_Error("BusLogic: Unable to allocate Probe Info List\n", NULL); |
| return -ENOMEM; |
| } |
| |
| PrototypeHostAdapter = |
| kzalloc(sizeof(struct BusLogic_HostAdapter), GFP_KERNEL); |
| if (PrototypeHostAdapter == NULL) { |
| kfree(BusLogic_ProbeInfoList); |
| BusLogic_Error("BusLogic: Unable to allocate Prototype " "Host Adapter\n", NULL); |
| return -ENOMEM; |
| } |
| |
| #ifdef MODULE |
| if (BusLogic != NULL) |
| BusLogic_Setup(BusLogic); |
| #endif |
| BusLogic_InitializeProbeInfoList(PrototypeHostAdapter); |
| for (ProbeIndex = 0; ProbeIndex < BusLogic_ProbeInfoCount; ProbeIndex++) { |
| struct BusLogic_ProbeInfo *ProbeInfo = &BusLogic_ProbeInfoList[ProbeIndex]; |
| struct BusLogic_HostAdapter *HostAdapter = PrototypeHostAdapter; |
| struct Scsi_Host *Host; |
| if (ProbeInfo->IO_Address == 0) |
| continue; |
| memset(HostAdapter, 0, sizeof(struct BusLogic_HostAdapter)); |
| HostAdapter->HostAdapterType = ProbeInfo->HostAdapterType; |
| HostAdapter->HostAdapterBusType = ProbeInfo->HostAdapterBusType; |
| HostAdapter->IO_Address = ProbeInfo->IO_Address; |
| HostAdapter->PCI_Address = ProbeInfo->PCI_Address; |
| HostAdapter->Bus = ProbeInfo->Bus; |
| HostAdapter->Device = ProbeInfo->Device; |
| HostAdapter->PCI_Device = ProbeInfo->PCI_Device; |
| HostAdapter->IRQ_Channel = ProbeInfo->IRQ_Channel; |
| HostAdapter->AddressCount = BusLogic_HostAdapterAddressCount[HostAdapter->HostAdapterType]; |
| |
| /* |
| Make sure region is free prior to probing. |
| */ |
| if (!request_region(HostAdapter->IO_Address, HostAdapter->AddressCount, |
| "BusLogic")) |
| continue; |
| /* |
| Probe the Host Adapter. If unsuccessful, abort further initialization. |
| */ |
| if (!BusLogic_ProbeHostAdapter(HostAdapter)) { |
| release_region(HostAdapter->IO_Address, HostAdapter->AddressCount); |
| continue; |
| } |
| /* |
| Hard Reset the Host Adapter. If unsuccessful, abort further |
| initialization. |
| */ |
| if (!BusLogic_HardwareResetHostAdapter(HostAdapter, true)) { |
| release_region(HostAdapter->IO_Address, HostAdapter->AddressCount); |
| continue; |
| } |
| /* |
| Check the Host Adapter. If unsuccessful, abort further initialization. |
| */ |
| if (!BusLogic_CheckHostAdapter(HostAdapter)) { |
| release_region(HostAdapter->IO_Address, HostAdapter->AddressCount); |
| continue; |
| } |
| /* |
| Initialize the Driver Options field if provided. |
| */ |
| if (DriverOptionsIndex < BusLogic_DriverOptionsCount) |
| HostAdapter->DriverOptions = &BusLogic_DriverOptions[DriverOptionsIndex++]; |
| /* |
| Announce the Driver Version and Date, Author's Name, Copyright Notice, |
| and Electronic Mail Address. |
| */ |
| BusLogic_AnnounceDriver(HostAdapter); |
| /* |
| Register the SCSI Host structure. |
| */ |
| |
| Host = scsi_host_alloc(&Bus_Logic_template, sizeof(struct BusLogic_HostAdapter)); |
| if (Host == NULL) { |
| release_region(HostAdapter->IO_Address, HostAdapter->AddressCount); |
| continue; |
| } |
| HostAdapter = (struct BusLogic_HostAdapter *) Host->hostdata; |
| memcpy(HostAdapter, PrototypeHostAdapter, sizeof(struct BusLogic_HostAdapter)); |
| HostAdapter->SCSI_Host = Host; |
| HostAdapter->HostNumber = Host->host_no; |
| /* |
| Add Host Adapter to the end of the list of registered BusLogic |
| Host Adapters. |
| */ |
| list_add_tail(&HostAdapter->host_list, &BusLogic_host_list); |
| |
| /* |
| Read the Host Adapter Configuration, Configure the Host Adapter, |
| Acquire the System Resources necessary to use the Host Adapter, then |
| Create the Initial CCBs, Initialize the Host Adapter, and finally |
| perform Target Device Inquiry. |
| |
| From this point onward, any failure will be assumed to be due to a |
| problem with the Host Adapter, rather than due to having mistakenly |
| identified this port as belonging to a BusLogic Host Adapter. The |
| I/O Address range will not be released, thereby preventing it from |
| being incorrectly identified as any other type of Host Adapter. |
| */ |
| if (BusLogic_ReadHostAdapterConfiguration(HostAdapter) && |
| BusLogic_ReportHostAdapterConfiguration(HostAdapter) && |
| BusLogic_AcquireResources(HostAdapter) && |
| BusLogic_CreateInitialCCBs(HostAdapter) && |
| BusLogic_InitializeHostAdapter(HostAdapter) && |
| BusLogic_TargetDeviceInquiry(HostAdapter)) { |
| /* |
| Initialization has been completed successfully. Release and |
| re-register usage of the I/O Address range so that the Model |
| Name of the Host Adapter will appear, and initialize the SCSI |
| Host structure. |
| */ |
| release_region(HostAdapter->IO_Address, |
| HostAdapter->AddressCount); |
| if (!request_region(HostAdapter->IO_Address, |
| HostAdapter->AddressCount, |
| HostAdapter->FullModelName)) { |
| printk(KERN_WARNING |
| "BusLogic: Release and re-register of " |
| "port 0x%04lx failed \n", |
| (unsigned long)HostAdapter->IO_Address); |
| BusLogic_DestroyCCBs(HostAdapter); |
| BusLogic_ReleaseResources(HostAdapter); |
| list_del(&HostAdapter->host_list); |
| scsi_host_put(Host); |
| ret = -ENOMEM; |
| } else { |
| BusLogic_InitializeHostStructure(HostAdapter, |
| Host); |
| if (scsi_add_host(Host, HostAdapter->PCI_Device |
| ? &HostAdapter->PCI_Device->dev |
| : NULL)) { |
| printk(KERN_WARNING |
| "BusLogic: scsi_add_host()" |
| "failed!\n"); |
| BusLogic_DestroyCCBs(HostAdapter); |
| BusLogic_ReleaseResources(HostAdapter); |
| list_del(&HostAdapter->host_list); |
| scsi_host_put(Host); |
| ret = -ENODEV; |
| } else { |
| scsi_scan_host(Host); |
| BusLogicHostAdapterCount++; |
| } |
| } |
| } else { |
| /* |
| An error occurred during Host Adapter Configuration Querying, Host |
| Adapter Configuration, Resource Acquisition, CCB Creation, Host |
| Adapter Initialization, or Target Device Inquiry, so remove Host |
| Adapter from the list of registered BusLogic Host Adapters, destroy |
| the CCBs, Release the System Resources, and Unregister the SCSI |
| Host. |
| */ |
| BusLogic_DestroyCCBs(HostAdapter); |
| BusLogic_ReleaseResources(HostAdapter); |
| list_del(&HostAdapter->host_list); |
| scsi_host_put(Host); |
| ret = -ENODEV; |
| } |
| } |
| kfree(PrototypeHostAdapter); |
| kfree(BusLogic_ProbeInfoList); |
| BusLogic_ProbeInfoList = NULL; |
| return ret; |
| } |
| |
| |
| /* |
| BusLogic_ReleaseHostAdapter 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 BusLogic_ReleaseHostAdapter(struct BusLogic_HostAdapter *HostAdapter) |
| { |
| struct Scsi_Host *Host = HostAdapter->SCSI_Host; |
| |
| scsi_remove_host(Host); |
| |
| /* |
| FlashPoint Host Adapters must first be released by the FlashPoint |
| SCCB Manager. |
| */ |
| if (BusLogic_FlashPointHostAdapterP(HostAdapter)) |
| FlashPoint_ReleaseHostAdapter(HostAdapter->CardHandle); |
| /* |
| Destroy the CCBs and release any system resources acquired to |
| support Host Adapter. |
| */ |
| BusLogic_DestroyCCBs(HostAdapter); |
| BusLogic_ReleaseResources(HostAdapter); |
| /* |
| Release usage of the I/O Address range. |
| */ |
| release_region(HostAdapter->IO_Address, HostAdapter->AddressCount); |
| /* |
| Remove Host Adapter from the list of registered BusLogic Host Adapters. |
| */ |
| list_del(&HostAdapter->host_list); |
| |
| scsi_host_put(Host); |
| return 0; |
| } |
| |
| |
| /* |
| BusLogic_QueueCompletedCCB queues CCB for completion processing. |
| */ |
| |
| static void BusLogic_QueueCompletedCCB(struct BusLogic_CCB *CCB) |
| { |
| struct BusLogic_HostAdapter *HostAdapter = CCB->HostAdapter; |
| CCB->Status = BusLogic_CCB_Completed; |
| CCB->Next = NULL; |
| if (HostAdapter->FirstCompletedCCB == NULL) { |
| HostAdapter->FirstCompletedCCB = CCB; |
| HostAdapter->LastCompletedCCB = CCB; |
| } else { |
| HostAdapter->LastCompletedCCB->Next = CCB; |
| HostAdapter->LastCompletedCCB = CCB; |
| } |
| HostAdapter->ActiveCommands[CCB->TargetID]--; |
| } |
| |
| |
| /* |
| BusLogic_ComputeResultCode computes a SCSI Subsystem Result Code from |
| the Host Adapter Status and Target Device Status. |
| */ |
| |
| static int BusLogic_ComputeResultCode(struct BusLogic_HostAdapter *HostAdapter, enum BusLogic_HostAdapterStatus HostAdapterStatus, enum BusLogic_TargetDeviceStatus TargetDeviceStatus) |
| { |
| int HostStatus; |
| switch (HostAdapterStatus) { |
| case BusLogic_CommandCompletedNormally: |
| case BusLogic_LinkedCommandCompleted: |
| case BusLogic_LinkedCommandCompletedWithFlag: |
| HostStatus = DID_OK; |
| break; |
| case BusLogic_SCSISelectionTimeout: |
| HostStatus = DID_TIME_OUT; |
| break; |
| case BusLogic_InvalidOutgoingMailboxActionCode: |
| case BusLogic_InvalidCommandOperationCode: |
| case BusLogic_InvalidCommandParameter: |
| BusLogic_Warning("BusLogic Driver Protocol Error 0x%02X\n", HostAdapter, HostAdapterStatus); |
| case BusLogic_DataUnderRun: |
| case BusLogic_DataOverRun: |
| case BusLogic_UnexpectedBusFree: |
| case BusLogic_LinkedCCBhasInvalidLUN: |
| case BusLogic_AutoRequestSenseFailed: |
| case BusLogic_TaggedQueuingMessageRejected: |
| case BusLogic_UnsupportedMessageReceived: |
| case BusLogic_HostAdapterHardwareFailed: |
| case BusLogic_TargetDeviceReconnectedImproperly: |
| case BusLogic_AbortQueueGenerated: |
| case BusLogic_HostAdapterSoftwareError: |
| case BusLogic_HostAdapterHardwareTimeoutError: |
| case BusLogic_SCSIParityErrorDetected: |
| HostStatus = DID_ERROR; |
| break; |
| case BusLogic_InvalidBusPhaseRequested: |
| case BusLogic_TargetFailedResponseToATN: |
| case BusLogic_HostAdapterAssertedRST: |
| case BusLogic_OtherDeviceAssertedRST: |
| case BusLogic_HostAdapterAssertedBusDeviceReset: |
| HostStatus = DID_RESET; |
| break; |
| default: |
| BusLogic_Warning("Unknown Host Adapter Status 0x%02X\n", HostAdapter, HostAdapterStatus); |
| HostStatus = DID_ERROR; |
| break; |
| } |
| return (HostStatus << 16) | TargetDeviceStatus; |
| } |
| |
| |
| /* |
| BusLogic_ScanIncomingMailboxes scans the Incoming Mailboxes saving any |
| Incoming Mailbox entries for completion processing. |
| */ |
| |
| static void BusLogic_ScanIncomingMailboxes(struct BusLogic_HostAdapter *HostAdapter) |
| { |
| /* |
| Scan through the Incoming Mailboxes in Strict Round Robin fashion, saving |
| any completed CCBs for further processing. It is essential that for each |
| CCB and SCSI Command issued, command completion processing is performed |
| exactly once. Therefore, only Incoming Mailboxes with completion code |
| Command Completed Without Error, Command Completed With Error, or Command |
| Aborted At Host Request are saved for completion processing. When an |
| Incoming Mailbox has a completion code of Aborted Command Not Found, the |
| CCB had already completed or been aborted before the current Abort request |
| was processed, and so completion processing has already occurred and no |
| further action should be taken. |
| */ |
| struct BusLogic_IncomingMailbox *NextIncomingMailbox = HostAdapter->NextIncomingMailbox; |
| enum BusLogic_CompletionCode CompletionCode; |
| while ((CompletionCode = NextIncomingMailbox->CompletionCode) != BusLogic_IncomingMailboxFree) { |
| /* |
| We are only allowed to do this because we limit our architectures we |
| run on to machines where bus_to_virt() actually works. There *needs* |
| to be a dma_addr_to_virt() in the new PCI DMA mapping interface to |
| replace bus_to_virt() or else this code is going to become very |
| innefficient. |
| */ |
| struct BusLogic_CCB *CCB = (struct BusLogic_CCB *) Bus_to_Virtual(NextIncomingMailbox->CCB); |
| if (CompletionCode != BusLogic_AbortedCommandNotFound) { |
| if (CCB->Status == BusLogic_CCB_Active || CCB->Status == BusLogic_CCB_Reset) { |
| /* |
| Save the Completion Code for this CCB and queue the CCB |
| for completion processing. |
| */ |
| CCB->CompletionCode = CompletionCode; |
| BusLogic_QueueCompletedCCB(CCB); |
| } else { |
| /* |
| If a CCB ever appears in an Incoming Mailbox and is not marked |
| as status Active or Reset, then there is most likely a bug in |
| the Host Adapter firmware. |
| */ |
| BusLogic_Warning("Illegal CCB #%ld status %d in " "Incoming Mailbox\n", HostAdapter, CCB->SerialNumber, CCB->Status); |
| } |
| } |
| NextIncomingMailbox->CompletionCode = BusLogic_IncomingMailboxFree; |
| if (++NextIncomingMailbox > HostAdapter->LastIncomingMailbox) |
| NextIncomingMailbox = HostAdapter->FirstIncomingMailbox; |
| } |
| HostAdapter->NextIncomingMailbox = NextIncomingMailbox; |
| } |
| |
| |
| /* |
| BusLogic_ProcessCompletedCCBs 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 BusLogic_ProcessCompletedCCBs(struct BusLogic_HostAdapter *HostAdapter) |
| { |
| if (HostAdapter->ProcessCompletedCCBsActive) |
| return; |
| HostAdapter->ProcessCompletedCCBsActive = true; |
| while (HostAdapter->FirstCompletedCCB != NULL) { |
| struct BusLogic_CCB *CCB = HostAdapter->FirstCompletedCCB; |
| struct scsi_cmnd *Command = CCB->Command; |
| HostAdapter->FirstCompletedCCB = CCB->Next; |
| if (HostAdapter->FirstCompletedCCB == NULL) |
| HostAdapter->LastCompletedCCB = NULL; |
| /* |
| Process the Completed CCB. |
| */ |
| if (CCB->Opcode == BusLogic_BusDeviceReset) { |
| int TargetID = CCB->TargetID; |
| BusLogic_Warning("Bus Device Reset CCB #%ld to Target " "%d Completed\n", HostAdapter, CCB->SerialNumber, TargetID); |
| BusLogic_IncrementErrorCounter(&HostAdapter->TargetStatistics[TargetID].BusDeviceResetsCompleted); |
| HostAdapter->TargetFlags[TargetID].TaggedQueuingActive = false; |
| HostAdapter->CommandsSinceReset[TargetID] = 0; |
| HostAdapter->LastResetCompleted[TargetID] = jiffies; |
| /* |
| Place CCB back on the Host Adapter's free list. |
| */ |
| BusLogic_DeallocateCCB(CCB); |
| #if 0 /* this needs to be redone different for new EH */ |
| /* |
| Bus Device Reset CCBs have the Command field non-NULL only when a |
| Bus Device Reset was requested for a Command that did not have a |
| currently active CCB in the Host Adapter (i.e., a Synchronous |
| Bus Device Reset), and hence would not have its Completion Routine |
| called otherwise. |
| */ |
| while (Command != NULL) { |
| struct scsi_cmnd *NextCommand = Command->reset_chain; |
| Command->reset_chain = NULL; |
| Command->result = DID_RESET << 16; |
| Command->scsi_done(Command); |
| Command = NextCommand; |
| } |
| #endif |
| /* |
| Iterate over the CCBs for this Host Adapter performing completion |
| processing for any CCBs marked as Reset for this Target. |
| */ |
| for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll) |
| if (CCB->Status == BusLogic_CCB_Reset && CCB->TargetID == TargetID) { |
| Command = CCB->Command; |
| BusLogic_DeallocateCCB(CCB); |
| HostAdapter->ActiveCommands[TargetID]--; |
| Command->result = DID_RESET << 16; |
| Command->scsi_done(Command); |
| } |
| HostAdapter->BusDeviceResetPendingCCB[TargetID] = NULL; |
| } else { |
| /* |
| Translate the Completion Code, Host Adapter Status, and Target |
| Device Status into a SCSI Subsystem Result Code. |
| */ |
| switch (CCB->CompletionCode) { |
| case BusLogic_IncomingMailboxFree: |
| case BusLogic_AbortedCommandNotFound: |
| case BusLogic_InvalidCCB: |
| BusLogic_Warning("CCB #%ld to Target %d Impossible State\n", HostAdapter, CCB->SerialNumber, CCB->TargetID); |
| break; |
| case BusLogic_CommandCompletedWithoutError: |
| HostAdapter->TargetStatistics[CCB->TargetID] |
| .CommandsCompleted++; |
| HostAdapter->TargetFlags[CCB->TargetID] |
| .CommandSuccessfulFlag = true; |
| Command->result = DID_OK << 16; |
| break; |
| case BusLogic_CommandAbortedAtHostRequest: |
| BusLogic_Warning("CCB #%ld to Target %d Aborted\n", HostAdapter, CCB->SerialNumber, CCB->TargetID); |
| BusLogic_IncrementErrorCounter(&HostAdapter->TargetStatistics[CCB->TargetID] |
| .CommandAbortsCompleted); |
| Command->result = DID_ABORT << 16; |
| break; |
| case BusLogic_CommandCompletedWithError: |
| Command->result = BusLogic_ComputeResultCode(HostAdapter, CCB->HostAdapterStatus, CCB->TargetDeviceStatus); |
| if (CCB->HostAdapterStatus != BusLogic_SCSISelectionTimeout) { |
| HostAdapter->TargetStatistics[CCB->TargetID] |
| .CommandsCompleted++; |
| if (BusLogic_GlobalOptions.TraceErrors) { |
| int i; |
| BusLogic_Notice("CCB #%ld Target %d: Result %X Host " |
| "Adapter Status %02X " "Target Status %02X\n", HostAdapter, CCB->SerialNumber, CCB->TargetID, Command->result, CCB->HostAdapterStatus, CCB->TargetDeviceStatus); |
| BusLogic_Notice("CDB ", HostAdapter); |
| for (i = 0; i < CCB->CDB_Length; i++) |
| BusLogic_Notice(" %02X", HostAdapter, CCB->CDB[i]); |
| BusLogic_Notice("\n", HostAdapter); |
| BusLogic_Notice("Sense ", HostAdapter); |
| for (i = 0; i < CCB->SenseDataLength; i++) |
| BusLogic_Notice(" %02X", HostAdapter, Command->sense_buffer[i]); |
| BusLogic_Notice("\n", HostAdapter); |
| } |
| } |
| break; |
| } |
| /* |
| When an INQUIRY command completes normally, save the |
| CmdQue (Tagged Queuing Supported) and WBus16 (16 Bit |
| Wide Data Transfers Supported) bits. |
| */ |
| if (CCB->CDB[0] == INQUIRY && CCB->CDB[1] == 0 && CCB->HostAdapterStatus == BusLogic_CommandCompletedNormally) { |
| struct BusLogic_TargetFlags *TargetFlags = &HostAdapter->TargetFlags[CCB->TargetID]; |
| struct SCSI_Inquiry *InquiryResult = |
| (struct SCSI_Inquiry *) scsi_sglist(Command); |
| TargetFlags->TargetExists = true; |
| TargetFlags->TaggedQueuingSupported = InquiryResult->CmdQue; |
| TargetFlags->WideTransfersSupported = InquiryResult->WBus16; |
| } |
| /* |
| Place CCB back on the Host Adapter's free list. |
| */ |
| BusLogic_DeallocateCCB(CCB); |
| /* |
| Call the SCSI Command Completion Routine. |
| */ |
| Command->scsi_done(Command); |
| } |
| } |
| HostAdapter->ProcessCompletedCCBsActive = false; |
| } |
| |
| |
| /* |
| BusLogic_InterruptHandler handles hardware interrupts from BusLogic Host |
| Adapters. |
| */ |
| |
| static irqreturn_t BusLogic_InterruptHandler(int IRQ_Channel, void *DeviceIdentifier) |
| { |
| struct BusLogic_HostAdapter *HostAdapter = (struct BusLogic_HostAdapter *) DeviceIdentifier; |
| unsigned long ProcessorFlags; |
| /* |
| Acquire exclusive access to Host Adapter. |
| */ |
| spin_lock_irqsave(HostAdapter->SCSI_Host->host_lock, ProcessorFlags); |
| /* |
| Handle Interrupts appropriately for each Host Adapter type. |
| */ |
| if (BusLogic_MultiMasterHostAdapterP(HostAdapter)) { |
| union BusLogic_InterruptRegister InterruptRegister; |
| /* |
| Read the Host Adapter Interrupt Register. |
| */ |
| InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter); |
| if (InterruptRegister.ir.InterruptValid) { |
| /* |
| Acknowledge the interrupt and reset the Host Adapter |
| Interrupt Register. |
| */ |
| BusLogic_InterruptReset(HostAdapter); |
| /* |
| Process valid External SCSI Bus Reset and Incoming Mailbox |
| Loaded Interrupts. Command Complete Interrupts are noted, |
| and Outgoing Mailbox Available Interrupts are ignored, as |
| they are never enabled. |
| */ |
| if (InterruptRegister.ir.ExternalBusReset) |
| HostAdapter->HostAdapterExternalReset = true; |
| else if (InterruptRegister.ir.IncomingMailboxLoaded) |
| BusLogic_ScanIncomingMailboxes(HostAdapter); |
| else if (InterruptRegister.ir.CommandComplete) |
| HostAdapter->HostAdapterCommandCompleted = true; |
| } |
| } else { |
| /* |
| Check if there is a pending interrupt for this Host Adapter. |
| */ |
| if (FlashPoint_InterruptPending(HostAdapter->CardHandle)) |
| switch (FlashPoint_HandleInterrupt(HostAdapter->CardHandle)) { |
| case FlashPoint_NormalInterrupt: |
| break; |
| case FlashPoint_ExternalBusReset: |
| HostAdapter->HostAdapterExternalReset = true; |
| break; |
| case FlashPoint_InternalError: |
| BusLogic_Warning("Internal FlashPoint Error detected" " - Resetting Host Adapter\n", HostAdapter); |
| HostAdapter->HostAdapterInternalError = true; |
| break; |
| } |
| } |
| /* |
| Process any completed CCBs. |
| */ |
| if (HostAdapter->FirstCompletedCCB != NULL) |
| BusLogic_ProcessCompletedCCBs(HostAdapter); |
| /* |
| Reset the Host Adapter if requested. |
| */ |
| if (HostAdapter->HostAdapterExternalReset) { |
| BusLogic_Warning("Resetting %s due to External SCSI Bus Reset\n", HostAdapter, HostAdapter->FullModelName); |
| BusLogic_IncrementErrorCounter(&HostAdapter->ExternalHostAdapterResets); |
| BusLogic_ResetHostAdapter(HostAdapter, false); |
| HostAdapter->HostAdapterExternalReset = false; |
| } else if (HostAdapter->HostAdapterInternalError) { |
| BusLogic_Warning("Resetting %s due to Host Adapter Internal Error\n", HostAdapter, HostAdapter->FullModelName); |
| BusLogic_IncrementErrorCounter(&HostAdapter->HostAdapterInternalErrors); |
| BusLogic_ResetHostAdapter(HostAdapter, true); |
| HostAdapter->HostAdapterInternalError = false; |
| } |
| /* |
| Release exclusive access to Host Adapter. |
| */ |
| spin_unlock_irqrestore(HostAdapter->SCSI_Host |