1.1 --- a/.rootkeys	Fri Nov 07 16:37:15 2003 +0000
     1.2 +++ b/.rootkeys	Sat Nov 08 11:06:04 2003 +0000
     1.3 @@ -334,6 +334,9 @@ 3ddb79bfkVLMq5CWjZLACPDivqxq_w xen/drive
     1.4  3ddb79bfl1H1arbB0pzAEC2uPmY_3g xen/drivers/pci/setup-irq.c
     1.5  3ddb79bfJaf0bkE1Y67bnll8-kjEPg xen/drivers/pci/setup-res.c
     1.6  3ddb79bfIcCWJsBDNcQQE3ok2Azn-Q xen/drivers/pci/syscall.c
     1.7 +3facce119oL2_kMylnMRUQlTsUw-OA xen/drivers/scsi/BusLogic.c
     1.8 +3facce12hrTrkdXJQR0MjOG3ud0K0A xen/drivers/scsi/BusLogic.h
     1.9 +3facce0dDkxv278IqO4gxypPDiw3Ow xen/drivers/scsi/FlashPoint.c.inc
    1.10  3ddb79be3kwzyKagpMHGoXZFdan7dg xen/drivers/scsi/Makefile
    1.11  3e564137sVLmo7rTnKLNzLSCvuUz8g xen/drivers/scsi/aacraid/Makefile
    1.12  3e5641379FXvLDjV-0OrRNOBTwL_Lw xen/drivers/scsi/aacraid/README

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/xen/drivers/scsi/BusLogic.c	Sat Nov 08 11:06:04 2003 +0000
     2.3 @@ -0,0 +1,5010 @@
     2.4 +/*
     2.5 +
     2.6 +  Linux Driver for BusLogic MultiMaster and FlashPoint SCSI Host Adapters
     2.7 +
     2.8 +  Copyright 1995-1998 by Leonard N. Zubkoff <lnz@dandelion.com>
     2.9 +
    2.10 +  This program is free software; you may redistribute and/or modify it under
    2.11 +  the terms of the GNU General Public License Version 2 as published by the
    2.12 +  Free Software Foundation.
    2.13 +
    2.14 +  This program is distributed in the hope that it will be useful, but
    2.15 +  WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY
    2.16 +  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    2.17 +  for complete details.
    2.18 +
    2.19 +  The author respectfully requests that any modifications to this software be
    2.20 +  sent directly to him for evaluation and testing.
    2.21 +
    2.22 +  Special thanks to Wayne Yen, Jin-Lon Hon, and Alex Win of BusLogic, whose
    2.23 +  advice has been invaluable, to David Gentzel, for writing the original Linux
    2.24 +  BusLogic driver, and to Paul Gortmaker, for being such a dedicated test site.
    2.25 +
    2.26 +  Finally, special thanks to Mylex/BusLogic for making the FlashPoint SCCB
    2.27 +  Manager available as freely redistributable source code.
    2.28 +
    2.29 +*/
    2.30 +
    2.31 +
    2.32 +#define BusLogic_DriverVersion		"2.1.15"
    2.33 +#define BusLogic_DriverDate		"17 August 1998"
    2.34 +
    2.35 +
    2.36 +#include <linux/version.h>
    2.37 +#include <linux/module.h>
    2.38 +#include <linux/config.h>
    2.39 +#include <linux/init.h>
    2.40 +#include <linux/types.h>
    2.41 +#include <linux/blk.h>
    2.42 +#include <linux/blkdev.h>
    2.43 +#include <linux/delay.h>
    2.44 +#include <linux/ioport.h>
    2.45 +#include <linux/mm.h>
    2.46 +#include <linux/sched.h>
    2.47 +/*#include <linux/stat.h>*/
    2.48 +#include <linux/pci.h>
    2.49 +#include <linux/spinlock.h>
    2.50 +#include <asm/dma.h>
    2.51 +#include <asm/io.h>
    2.52 +#include <asm/system.h>
    2.53 +#include "scsi.h"
    2.54 +#include "hosts.h"
    2.55 +#include "sd.h"
    2.56 +#include "BusLogic.h"
    2.57 +#include "FlashPoint.c.inc"
    2.58 +
    2.59 +
    2.60 +/*
    2.61 +  BusLogic_DriverOptionsCount is a count of the number of BusLogic Driver
    2.62 +  Options specifications provided via the Linux Kernel Command Line or via
    2.63 +  the Loadable Kernel Module Installation Facility.
    2.64 +*/
    2.65 +
    2.66 +static int
    2.67 +  BusLogic_DriverOptionsCount;
    2.68 +
    2.69 +
    2.70 +/*
    2.71 +  BusLogic_DriverOptions is an array of Driver Options structures representing
    2.72 +  BusLogic Driver Options specifications provided via the Linux Kernel Command
    2.73 +  Line or via the Loadable Kernel Module Installation Facility.
    2.74 +*/
    2.75 +
    2.76 +static BusLogic_DriverOptions_T
    2.77 +  BusLogic_DriverOptions[BusLogic_MaxHostAdapters];
    2.78 +
    2.79 +
    2.80 +/*
    2.81 +  BusLogic can be assigned a string by insmod.
    2.82 +*/
    2.83 +
    2.84 +#ifdef MODULE
    2.85 +static char *BusLogic;
    2.86 +MODULE_PARM(BusLogic, "s");
    2.87 +#endif
    2.88 +
    2.89 +
    2.90 +/*
    2.91 +  BusLogic_ProbeOptions is a set of Probe Options to be applied across
    2.92 +  all BusLogic Host Adapters.
    2.93 +*/
    2.94 +
    2.95 +static BusLogic_ProbeOptions_T
    2.96 +  BusLogic_ProbeOptions;
    2.97 +
    2.98 +
    2.99 +/*
   2.100 +  BusLogic_GlobalOptions is a set of Global Options to be applied across
   2.101 +  all BusLogic Host Adapters.
   2.102 +*/
   2.103 +
   2.104 +static BusLogic_GlobalOptions_T
   2.105 +  BusLogic_GlobalOptions;
   2.106 +
   2.107 +
   2.108 +/*
   2.109 +  BusLogic_FirstRegisteredHostAdapter and BusLogic_LastRegisteredHostAdapter
   2.110 +  are pointers to the first and last registered BusLogic Host Adapters.
   2.111 +*/
   2.112 +
   2.113 +static BusLogic_HostAdapter_T
   2.114 +  *BusLogic_FirstRegisteredHostAdapter,
   2.115 +  *BusLogic_LastRegisteredHostAdapter;
   2.116 +
   2.117 +
   2.118 +/*
   2.119 +  BusLogic_ProbeInfoCount is the number of entries in BusLogic_ProbeInfoList.
   2.120 +*/
   2.121 +
   2.122 +static int
   2.123 +  BusLogic_ProbeInfoCount;
   2.124 +
   2.125 +
   2.126 +/*
   2.127 +  BusLogic_ProbeInfoList is the list of I/O Addresses and Bus Probe Information
   2.128 +  to be checked for potential BusLogic Host Adapters.  It is initialized by
   2.129 +  interrogating the PCI Configuration Space on PCI machines as well as from the
   2.130 +  list of standard BusLogic I/O Addresses.
   2.131 +*/
   2.132 +
   2.133 +static BusLogic_ProbeInfo_T
   2.134 +  *BusLogic_ProbeInfoList;
   2.135 +
   2.136 +
   2.137 +/*
   2.138 +  BusLogic_CommandFailureReason holds a string identifying the reason why a
   2.139 +  call to BusLogic_Command failed.  It is only non-NULL when BusLogic_Command
   2.140 +  returns a failure code.
   2.141 +*/
   2.142 +
   2.143 +static char
   2.144 +  *BusLogic_CommandFailureReason;
   2.145 +
   2.146 +/*
   2.147 +  BusLogic_AnnounceDriver announces the Driver Version and Date, Author's
   2.148 +  Name, Copyright Notice, and Electronic Mail Address.
   2.149 +*/
   2.150 +
   2.151 +static void BusLogic_AnnounceDriver(BusLogic_HostAdapter_T *HostAdapter)
   2.152 +{
   2.153 +  BusLogic_Announce("***** BusLogic SCSI Driver Version "
   2.154 +		    BusLogic_DriverVersion " of "
   2.155 +		    BusLogic_DriverDate " *****\n", HostAdapter);
   2.156 +  BusLogic_Announce("Copyright 1995-1998 by Leonard N. Zubkoff "
   2.157 +		    "<lnz@dandelion.com>\n", HostAdapter);
   2.158 +}
   2.159 +
   2.160 +
   2.161 +/*
   2.162 +  BusLogic_DriverInfo returns the Host Adapter Name to identify this SCSI
   2.163 +  Driver and Host Adapter.
   2.164 +*/
   2.165 +
   2.166 +const char *BusLogic_DriverInfo(SCSI_Host_T *Host)
   2.167 +{
   2.168 +  BusLogic_HostAdapter_T *HostAdapter =
   2.169 +    (BusLogic_HostAdapter_T *) Host->hostdata;
   2.170 +  return HostAdapter->FullModelName;
   2.171 +}
   2.172 +
   2.173 +
   2.174 +/*
   2.175 +  BusLogic_RegisterHostAdapter adds Host Adapter to the list of registered
   2.176 +  BusLogic Host Adapters.
   2.177 +*/
   2.178 +
   2.179 +static void BusLogic_RegisterHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
   2.180 +{
   2.181 +  HostAdapter->Next = NULL;
   2.182 +  if (BusLogic_FirstRegisteredHostAdapter == NULL)
   2.183 +    {
   2.184 +      BusLogic_FirstRegisteredHostAdapter = HostAdapter;
   2.185 +      BusLogic_LastRegisteredHostAdapter = HostAdapter;
   2.186 +    }
   2.187 +  else
   2.188 +    {
   2.189 +      BusLogic_LastRegisteredHostAdapter->Next = HostAdapter;
   2.190 +      BusLogic_LastRegisteredHostAdapter = HostAdapter;
   2.191 +    }
   2.192 +}
   2.193 +
   2.194 +
   2.195 +/*
   2.196 +  BusLogic_UnregisterHostAdapter removes Host Adapter from the list of
   2.197 +  registered BusLogic Host Adapters.
   2.198 +*/
   2.199 +
   2.200 +static void BusLogic_UnregisterHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
   2.201 +{
   2.202 +  if (HostAdapter == BusLogic_FirstRegisteredHostAdapter)
   2.203 +    {
   2.204 +      BusLogic_FirstRegisteredHostAdapter =
   2.205 +	BusLogic_FirstRegisteredHostAdapter->Next;
   2.206 +      if (HostAdapter == BusLogic_LastRegisteredHostAdapter)
   2.207 +	BusLogic_LastRegisteredHostAdapter = NULL;
   2.208 +    }
   2.209 +  else
   2.210 +    {
   2.211 +      BusLogic_HostAdapter_T *PreviousHostAdapter =
   2.212 +	BusLogic_FirstRegisteredHostAdapter;
   2.213 +      while (PreviousHostAdapter != NULL &&
   2.214 +	     PreviousHostAdapter->Next != HostAdapter)
   2.215 +	PreviousHostAdapter = PreviousHostAdapter->Next;
   2.216 +      if (PreviousHostAdapter != NULL)
   2.217 +	PreviousHostAdapter->Next = HostAdapter->Next;
   2.218 +    }
   2.219 +  HostAdapter->Next = NULL;
   2.220 +}
   2.221 +
   2.222 +
   2.223 +/*
   2.224 +  BusLogic_InitializeCCBs initializes a group of Command Control Blocks (CCBs)
   2.225 +  for Host Adapter from the BlockSize bytes located at BlockPointer.  The newly
   2.226 +  created CCBs are added to Host Adapter's free list.
   2.227 +*/
   2.228 +
   2.229 +static void BusLogic_InitializeCCBs(BusLogic_HostAdapter_T *HostAdapter,
   2.230 +				    void *BlockPointer, int BlockSize)
   2.231 +{
   2.232 +  BusLogic_CCB_T *CCB = (BusLogic_CCB_T *) BlockPointer;
   2.233 +  memset(BlockPointer, 0, BlockSize);
   2.234 +  CCB->AllocationGroupHead = true;
   2.235 +  while ((BlockSize -= sizeof(BusLogic_CCB_T)) >= 0)
   2.236 +    {
   2.237 +      CCB->Status = BusLogic_CCB_Free;
   2.238 +      CCB->HostAdapter = HostAdapter;
   2.239 +      if (BusLogic_FlashPointHostAdapterP(HostAdapter))
   2.240 +	{
   2.241 +	  CCB->CallbackFunction = BusLogic_QueueCompletedCCB;
   2.242 +	  CCB->BaseAddress = HostAdapter->FlashPointInfo.BaseAddress;
   2.243 +	}
   2.244 +      CCB->Next = HostAdapter->Free_CCBs;
   2.245 +      CCB->NextAll = HostAdapter->All_CCBs;
   2.246 +      HostAdapter->Free_CCBs = CCB;
   2.247 +      HostAdapter->All_CCBs = CCB;
   2.248 +      HostAdapter->AllocatedCCBs++;
   2.249 +      CCB++;
   2.250 +    }
   2.251 +}
   2.252 +
   2.253 +
   2.254 +/*
   2.255 +  BusLogic_CreateInitialCCBs allocates the initial CCBs for Host Adapter.
   2.256 +*/
   2.257 +
   2.258 +static boolean BusLogic_CreateInitialCCBs(BusLogic_HostAdapter_T *HostAdapter)
   2.259 +{
   2.260 +  int BlockSize = BusLogic_CCB_AllocationGroupSize * sizeof(BusLogic_CCB_T);
   2.261 +  while (HostAdapter->AllocatedCCBs < HostAdapter->InitialCCBs)
   2.262 +    {
   2.263 +      void *BlockPointer = kmalloc(BlockSize,
   2.264 +				   (HostAdapter->BounceBuffersRequired
   2.265 +				    ? GFP_ATOMIC | GFP_DMA
   2.266 +				    : GFP_ATOMIC));
   2.267 +      if (BlockPointer == NULL)
   2.268 +	{
   2.269 +	  BusLogic_Error("UNABLE TO ALLOCATE CCB GROUP - DETACHING\n",
   2.270 +			 HostAdapter);
   2.271 +	  return false;
   2.272 +	}
   2.273 +      BusLogic_InitializeCCBs(HostAdapter, BlockPointer, BlockSize);
   2.274 +    }
   2.275 +  return true;
   2.276 +}
   2.277 +
   2.278 +
   2.279 +/*
   2.280 +  BusLogic_DestroyCCBs deallocates the CCBs for Host Adapter.
   2.281 +*/
   2.282 +
   2.283 +static void BusLogic_DestroyCCBs(BusLogic_HostAdapter_T *HostAdapter)
   2.284 +{
   2.285 +  BusLogic_CCB_T *NextCCB = HostAdapter->All_CCBs, *CCB;
   2.286 +  HostAdapter->All_CCBs = NULL;
   2.287 +  HostAdapter->Free_CCBs = NULL;
   2.288 +  while ((CCB = NextCCB) != NULL)
   2.289 +    {
   2.290 +      NextCCB = CCB->NextAll;
   2.291 +      if (CCB->AllocationGroupHead)
   2.292 +	kfree(CCB);
   2.293 +    }
   2.294 +}
   2.295 +
   2.296 +
   2.297 +/*
   2.298 +  BusLogic_CreateAdditionalCCBs allocates Additional CCBs for Host Adapter.  If
   2.299 +  allocation fails and there are no remaining CCBs available, the Driver Queue
   2.300 +  Depth is decreased to a known safe value to avoid potential deadlocks when
   2.301 +  multiple host adapters share the same IRQ Channel.
   2.302 +*/
   2.303 +
   2.304 +static void BusLogic_CreateAdditionalCCBs(BusLogic_HostAdapter_T *HostAdapter,
   2.305 +					  int AdditionalCCBs,
   2.306 +					  boolean SuccessMessageP)
   2.307 +{
   2.308 +  int BlockSize = BusLogic_CCB_AllocationGroupSize * sizeof(BusLogic_CCB_T);
   2.309 +  int PreviouslyAllocated = HostAdapter->AllocatedCCBs;
   2.310 +  if (AdditionalCCBs <= 0) return;
   2.311 +  while (HostAdapter->AllocatedCCBs - PreviouslyAllocated < AdditionalCCBs)
   2.312 +    {
   2.313 +      void *BlockPointer = kmalloc(BlockSize,
   2.314 +				   (HostAdapter->BounceBuffersRequired
   2.315 +				    ? GFP_ATOMIC | GFP_DMA
   2.316 +				    : GFP_ATOMIC));
   2.317 +      if (BlockPointer == NULL) break;
   2.318 +      BusLogic_InitializeCCBs(HostAdapter, BlockPointer, BlockSize);
   2.319 +    }
   2.320 +  if (HostAdapter->AllocatedCCBs > PreviouslyAllocated)
   2.321 +    {
   2.322 +      if (SuccessMessageP)
   2.323 +	BusLogic_Notice("Allocated %d additional CCBs (total now %d)\n",
   2.324 +			HostAdapter,
   2.325 +			HostAdapter->AllocatedCCBs - PreviouslyAllocated,
   2.326 +			HostAdapter->AllocatedCCBs);
   2.327 +      return;
   2.328 +    }
   2.329 +  BusLogic_Notice("Failed to allocate additional CCBs\n", HostAdapter);
   2.330 +  if (HostAdapter->DriverQueueDepth >
   2.331 +      HostAdapter->AllocatedCCBs - HostAdapter->TargetDeviceCount)
   2.332 +    {
   2.333 +      HostAdapter->DriverQueueDepth =
   2.334 +	HostAdapter->AllocatedCCBs - HostAdapter->TargetDeviceCount;
   2.335 +      HostAdapter->SCSI_Host->can_queue = HostAdapter->DriverQueueDepth;
   2.336 +    }
   2.337 +}
   2.338 +
   2.339 +
   2.340 +/*
   2.341 +  BusLogic_AllocateCCB allocates a CCB from Host Adapter's free list,
   2.342 +  allocating more memory from the Kernel if necessary.  The Host Adapter's
   2.343 +  Lock should already have been acquired by the caller.
   2.344 +*/
   2.345 +
   2.346 +static BusLogic_CCB_T *BusLogic_AllocateCCB(BusLogic_HostAdapter_T
   2.347 +					    *HostAdapter)
   2.348 +{
   2.349 +  static unsigned long SerialNumber = 0;
   2.350 +  BusLogic_CCB_T *CCB;
   2.351 +  CCB = HostAdapter->Free_CCBs;
   2.352 +  if (CCB != NULL)
   2.353 +    {
   2.354 +      CCB->SerialNumber = ++SerialNumber;
   2.355 +      HostAdapter->Free_CCBs = CCB->Next;
   2.356 +      CCB->Next = NULL;
   2.357 +      if (HostAdapter->Free_CCBs == NULL)
   2.358 +	BusLogic_CreateAdditionalCCBs(HostAdapter,
   2.359 +				      HostAdapter->IncrementalCCBs,
   2.360 +				      true);
   2.361 +      return CCB;
   2.362 +    }
   2.363 +  BusLogic_CreateAdditionalCCBs(HostAdapter,
   2.364 +				HostAdapter->IncrementalCCBs,
   2.365 +				true);
   2.366 +  CCB = HostAdapter->Free_CCBs;
   2.367 +  if (CCB == NULL) return NULL;
   2.368 +  CCB->SerialNumber = ++SerialNumber;
   2.369 +  HostAdapter->Free_CCBs = CCB->Next;
   2.370 +  CCB->Next = NULL;
   2.371 +  return CCB;
   2.372 +}
   2.373 +
   2.374 +
   2.375 +/*
   2.376 +  BusLogic_DeallocateCCB deallocates a CCB, returning it to the Host Adapter's
   2.377 +  free list.  The Host Adapter's Lock should already have been acquired by the
   2.378 +  caller.
   2.379 +*/
   2.380 +
   2.381 +static void BusLogic_DeallocateCCB(BusLogic_CCB_T *CCB)
   2.382 +{
   2.383 +  BusLogic_HostAdapter_T *HostAdapter = CCB->HostAdapter;
   2.384 +  CCB->Command = NULL;
   2.385 +  CCB->Status = BusLogic_CCB_Free;
   2.386 +  CCB->Next = HostAdapter->Free_CCBs;
   2.387 +  HostAdapter->Free_CCBs = CCB;
   2.388 +}
   2.389 +
   2.390 +
   2.391 +/*
   2.392 +  BusLogic_Command sends the command OperationCode to HostAdapter, optionally
   2.393 +  providing ParameterLength bytes of ParameterData and receiving at most
   2.394 +  ReplyLength bytes of ReplyData; any excess reply data is received but
   2.395 +  discarded.
   2.396 +
   2.397 +  On success, this function returns the number of reply bytes read from
   2.398 +  the Host Adapter (including any discarded data); on failure, it returns
   2.399 +  -1 if the command was invalid, or -2 if a timeout occurred.
   2.400 +
   2.401 +  BusLogic_Command is called exclusively during host adapter detection and
   2.402 +  initialization, so performance and latency are not critical, and exclusive
   2.403 +  access to the Host Adapter hardware is assumed.  Once the host adapter and
   2.404 +  driver are initialized, the only Host Adapter command that is issued is the
   2.405 +  single byte Execute Mailbox Command operation code, which does not require
   2.406 +  waiting for the Host Adapter Ready bit to be set in the Status Register.
   2.407 +*/
   2.408 +
   2.409 +static int BusLogic_Command(BusLogic_HostAdapter_T *HostAdapter,
   2.410 +			    BusLogic_OperationCode_T OperationCode,
   2.411 +			    void *ParameterData,
   2.412 +			    int ParameterLength,
   2.413 +			    void *ReplyData,
   2.414 +			    int ReplyLength)
   2.415 +{
   2.416 +  unsigned char *ParameterPointer = (unsigned char *) ParameterData;
   2.417 +  unsigned char *ReplyPointer = (unsigned char *) ReplyData;
   2.418 +  BusLogic_StatusRegister_T StatusRegister;
   2.419 +  BusLogic_InterruptRegister_T InterruptRegister;
   2.420 +  ProcessorFlags_T ProcessorFlags = 0;
   2.421 +  int ReplyBytes = 0, Result;
   2.422 +  long TimeoutCounter;
   2.423 +  /*
   2.424 +    Clear out the Reply Data if provided.
   2.425 +  */
   2.426 +  if (ReplyLength > 0)
   2.427 +    memset(ReplyData, 0, ReplyLength);
   2.428 +  /*
   2.429 +    If the IRQ Channel has not yet been acquired, then interrupts must be
   2.430 +    disabled while issuing host adapter commands since a Command Complete
   2.431 +    interrupt could occur if the IRQ Channel was previously enabled by another
   2.432 +    BusLogic Host Adapter or another driver sharing the same IRQ Channel.
   2.433 +  */
   2.434 +  if (!HostAdapter->IRQ_ChannelAcquired)
   2.435 +    {
   2.436 +      save_flags(ProcessorFlags);
   2.437 +      cli();
   2.438 +    }
   2.439 +  /*
   2.440 +    Wait for the Host Adapter Ready bit to be set and the Command/Parameter
   2.441 +    Register Busy bit to be reset in the Status Register.
   2.442 +  */
   2.443 +  TimeoutCounter = 10000;
   2.444 +  while (--TimeoutCounter >= 0)
   2.445 +    {
   2.446 +      StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
   2.447 +      if (StatusRegister.Bits.HostAdapterReady &&
   2.448 +	  !StatusRegister.Bits.CommandParameterRegisterBusy)
   2.449 +	break;
   2.450 +      udelay(100);
   2.451 +    }
   2.452 +  if (TimeoutCounter < 0)
   2.453 +    {
   2.454 +      BusLogic_CommandFailureReason = "Timeout waiting for Host Adapter Ready";
   2.455 +      Result = -2;
   2.456 +      goto Done;
   2.457 +    }
   2.458 +  /*
   2.459 +    Write the OperationCode to the Command/Parameter Register.
   2.460 +  */
   2.461 +  HostAdapter->HostAdapterCommandCompleted = false;
   2.462 +  BusLogic_WriteCommandParameterRegister(HostAdapter, OperationCode);
   2.463 +  /*
   2.464 +    Write any additional Parameter Bytes.
   2.465 +  */
   2.466 +  TimeoutCounter = 10000;
   2.467 +  while (ParameterLength > 0 && --TimeoutCounter >= 0)
   2.468 +    {
   2.469 +      /*
   2.470 +	Wait 100 microseconds to give the Host Adapter enough time to determine
   2.471 +	whether the last value written to the Command/Parameter Register was
   2.472 +	valid or not.  If the Command Complete bit is set in the Interrupt
   2.473 +	Register, then the Command Invalid bit in the Status Register will be
   2.474 +	reset if the Operation Code or Parameter was valid and the command
   2.475 +	has completed, or set if the Operation Code or Parameter was invalid.
   2.476 +	If the Data In Register Ready bit is set in the Status Register, then
   2.477 +	the Operation Code was valid, and data is waiting to be read back
   2.478 +	from the Host Adapter.  Otherwise, wait for the Command/Parameter
   2.479 +	Register Busy bit in the Status Register to be reset.
   2.480 +      */
   2.481 +      udelay(100);
   2.482 +      InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
   2.483 +      StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
   2.484 +      if (InterruptRegister.Bits.CommandComplete) break;
   2.485 +      if (HostAdapter->HostAdapterCommandCompleted) break;
   2.486 +      if (StatusRegister.Bits.DataInRegisterReady) break;
   2.487 +      if (StatusRegister.Bits.CommandParameterRegisterBusy) continue;
   2.488 +      BusLogic_WriteCommandParameterRegister(HostAdapter, *ParameterPointer++);
   2.489 +      ParameterLength--;
   2.490 +    }
   2.491 +  if (TimeoutCounter < 0)
   2.492 +    {
   2.493 +      BusLogic_CommandFailureReason =
   2.494 +	"Timeout waiting for Parameter Acceptance";
   2.495 +      Result = -2;
   2.496 +      goto Done;
   2.497 +    }
   2.498 +  /*
   2.499 +    The Modify I/O Address command does not cause a Command Complete Interrupt.
   2.500 +  */
   2.501 +  if (OperationCode == BusLogic_ModifyIOAddress)
   2.502 +    {
   2.503 +      StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
   2.504 +      if (StatusRegister.Bits.CommandInvalid)
   2.505 +	{
   2.506 +	  BusLogic_CommandFailureReason = "Modify I/O Address Invalid";
   2.507 +	  Result = -1;
   2.508 +	  goto Done;
   2.509 +	}
   2.510 +      if (BusLogic_GlobalOptions.TraceConfiguration)
   2.511 +	BusLogic_Notice("BusLogic_Command(%02X) Status = %02X: "
   2.512 +			"(Modify I/O Address)\n", HostAdapter,
   2.513 +			OperationCode, StatusRegister.All);
   2.514 +      Result = 0;
   2.515 +      goto Done;
   2.516 +    }
   2.517 +  /*
   2.518 +    Select an appropriate timeout value for awaiting command completion.
   2.519 +  */
   2.520 +  switch (OperationCode)
   2.521 +    {
   2.522 +    case BusLogic_InquireInstalledDevicesID0to7:
   2.523 +    case BusLogic_InquireInstalledDevicesID8to15:
   2.524 +    case BusLogic_InquireTargetDevices:
   2.525 +      /* Approximately 60 seconds. */
   2.526 +      TimeoutCounter = 60*10000;
   2.527 +      break;
   2.528 +    default:
   2.529 +      /* Approximately 1 second. */
   2.530 +      TimeoutCounter = 10000;
   2.531 +      break;
   2.532 +    }
   2.533 +  /*
   2.534 +    Receive any Reply Bytes, waiting for either the Command Complete bit to
   2.535 +    be set in the Interrupt Register, or for the Interrupt Handler to set the
   2.536 +    Host Adapter Command Completed bit in the Host Adapter structure.
   2.537 +  */
   2.538 +  while (--TimeoutCounter >= 0)
   2.539 +    {
   2.540 +      InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
   2.541 +      StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
   2.542 +      if (InterruptRegister.Bits.CommandComplete) break;
   2.543 +      if (HostAdapter->HostAdapterCommandCompleted) break;
   2.544 +      if (StatusRegister.Bits.DataInRegisterReady)
   2.545 +	{
   2.546 +	  if (++ReplyBytes <= ReplyLength)
   2.547 +	    *ReplyPointer++ = BusLogic_ReadDataInRegister(HostAdapter);
   2.548 +	  else BusLogic_ReadDataInRegister(HostAdapter);
   2.549 +	}
   2.550 +      if (OperationCode == BusLogic_FetchHostAdapterLocalRAM &&
   2.551 +	  StatusRegister.Bits.HostAdapterReady) break;
   2.552 +      udelay(100);
   2.553 +    }
   2.554 +  if (TimeoutCounter < 0)
   2.555 +    {
   2.556 +      BusLogic_CommandFailureReason = "Timeout waiting for Command Complete";
   2.557 +      Result = -2;
   2.558 +      goto Done;
   2.559 +    }
   2.560 +  /*
   2.561 +    Clear any pending Command Complete Interrupt.
   2.562 +  */
   2.563 +  BusLogic_InterruptReset(HostAdapter);
   2.564 +  /*
   2.565 +    Provide tracing information if requested.
   2.566 +  */
   2.567 +  if (BusLogic_GlobalOptions.TraceConfiguration)
   2.568 +    {
   2.569 +      int i;
   2.570 +      BusLogic_Notice("BusLogic_Command(%02X) Status = %02X: %2d ==> %2d:",
   2.571 +		      HostAdapter, OperationCode,
   2.572 +		      StatusRegister.All, ReplyLength, ReplyBytes);
   2.573 +      if (ReplyLength > ReplyBytes) ReplyLength = ReplyBytes;
   2.574 +      for (i = 0; i < ReplyLength; i++)
   2.575 +	BusLogic_Notice(" %02X", HostAdapter,
   2.576 +			((unsigned char *) ReplyData)[i]);
   2.577 +      BusLogic_Notice("\n", HostAdapter);
   2.578 +    }
   2.579 +  /*
   2.580 +    Process Command Invalid conditions.
   2.581 +  */
   2.582 +  if (StatusRegister.Bits.CommandInvalid)
   2.583 +    {
   2.584 +      /*
   2.585 +	Some early BusLogic Host Adapters may not recover properly from
   2.586 +	a Command Invalid condition, so if this appears to be the case,
   2.587 +	a Soft Reset is issued to the Host Adapter.  Potentially invalid
   2.588 +	commands are never attempted after Mailbox Initialization is
   2.589 +	performed, so there should be no Host Adapter state lost by a
   2.590 +	Soft Reset in response to a Command Invalid condition.
   2.591 +      */
   2.592 +      udelay(1000);
   2.593 +      StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
   2.594 +      if (StatusRegister.Bits.CommandInvalid ||
   2.595 +	  StatusRegister.Bits.Reserved ||
   2.596 +	  StatusRegister.Bits.DataInRegisterReady ||
   2.597 +	  StatusRegister.Bits.CommandParameterRegisterBusy ||
   2.598 +	  !StatusRegister.Bits.HostAdapterReady ||
   2.599 +	  !StatusRegister.Bits.InitializationRequired ||
   2.600 +	  StatusRegister.Bits.DiagnosticActive ||
   2.601 +	  StatusRegister.Bits.DiagnosticFailure)
   2.602 +	{
   2.603 +	  BusLogic_SoftReset(HostAdapter);
   2.604 +	  udelay(1000);
   2.605 +	}
   2.606 +      BusLogic_CommandFailureReason = "Command Invalid";
   2.607 +      Result = -1;
   2.608 +      goto Done;
   2.609 +    }
   2.610 +  /*
   2.611 +    Handle Excess Parameters Supplied conditions.
   2.612 +  */
   2.613 +  if (ParameterLength > 0)
   2.614 +    {
   2.615 +      BusLogic_CommandFailureReason = "Excess Parameters Supplied";
   2.616 +      Result = -1;
   2.617 +      goto Done;
   2.618 +    }
   2.619 +  /*
   2.620 +    Indicate the command completed successfully.
   2.621 +  */
   2.622 +  BusLogic_CommandFailureReason = NULL;
   2.623 +  Result = ReplyBytes;
   2.624 +  /*
   2.625 +    Restore the interrupt status if necessary and return.
   2.626 +  */
   2.627 +Done:
   2.628 +  if (!HostAdapter->IRQ_ChannelAcquired)
   2.629 +    restore_flags(ProcessorFlags);
   2.630 +  return Result;
   2.631 +}
   2.632 +
   2.633 +
   2.634 +/*
   2.635 +  BusLogic_AppendProbeAddressISA appends a single ISA I/O Address to the list
   2.636 +  of I/O Address and Bus Probe Information to be checked for potential BusLogic
   2.637 +  Host Adapters.
   2.638 +*/
   2.639 +
   2.640 +static void BusLogic_AppendProbeAddressISA(BusLogic_IO_Address_T IO_Address)
   2.641 +{
   2.642 +  BusLogic_ProbeInfo_T *ProbeInfo;
   2.643 +  if (BusLogic_ProbeInfoCount >= BusLogic_MaxHostAdapters) return;
   2.644 +  ProbeInfo = &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++];
   2.645 +  ProbeInfo->HostAdapterType = BusLogic_MultiMaster;
   2.646 +  ProbeInfo->HostAdapterBusType = BusLogic_ISA_Bus;
   2.647 +  ProbeInfo->IO_Address = IO_Address;
   2.648 +}
   2.649 +
   2.650 +
   2.651 +/*
   2.652 +  BusLogic_InitializeProbeInfoListISA initializes the list of I/O Address and
   2.653 +  Bus Probe Information to be checked for potential BusLogic SCSI Host Adapters
   2.654 +  only from the list of standard BusLogic MultiMaster ISA I/O Addresses.
   2.655 +*/
   2.656 +
   2.657 +static void BusLogic_InitializeProbeInfoListISA(BusLogic_HostAdapter_T
   2.658 +						*PrototypeHostAdapter)
   2.659 +{
   2.660 +  /*
   2.661 +    If BusLogic Driver Options specifications requested that ISA Bus Probes
   2.662 +    be inhibited, do not proceed further.
   2.663 +  */
   2.664 +  if (BusLogic_ProbeOptions.NoProbeISA) return;
   2.665 +  /*
   2.666 +    Append the list of standard BusLogic MultiMaster ISA I/O Addresses.
   2.667 +  */
   2.668 +  if (BusLogic_ProbeOptions.LimitedProbeISA
   2.669 +      ? BusLogic_ProbeOptions.Probe330
   2.670 +      : check_region(0x330, BusLogic_MultiMasterAddressCount) == 0)
   2.671 +    BusLogic_AppendProbeAddressISA(0x330);
   2.672 +  if (BusLogic_ProbeOptions.LimitedProbeISA
   2.673 +      ? BusLogic_ProbeOptions.Probe334
   2.674 +      : check_region(0x334, BusLogic_MultiMasterAddressCount) == 0)
   2.675 +    BusLogic_AppendProbeAddressISA(0x334);
   2.676 +  if (BusLogic_ProbeOptions.LimitedProbeISA
   2.677 +      ? BusLogic_ProbeOptions.Probe230
   2.678 +      : check_region(0x230, BusLogic_MultiMasterAddressCount) == 0)
   2.679 +    BusLogic_AppendProbeAddressISA(0x230);
   2.680 +  if (BusLogic_ProbeOptions.LimitedProbeISA
   2.681 +      ? BusLogic_ProbeOptions.Probe234
   2.682 +      : check_region(0x234, BusLogic_MultiMasterAddressCount) == 0)
   2.683 +    BusLogic_AppendProbeAddressISA(0x234);
   2.684 +  if (BusLogic_ProbeOptions.LimitedProbeISA
   2.685 +      ? BusLogic_ProbeOptions.Probe130
   2.686 +      : check_region(0x130, BusLogic_MultiMasterAddressCount) == 0)
   2.687 +    BusLogic_AppendProbeAddressISA(0x130);
   2.688 +  if (BusLogic_ProbeOptions.LimitedProbeISA
   2.689 +      ? BusLogic_ProbeOptions.Probe134
   2.690 +      : check_region(0x134, BusLogic_MultiMasterAddressCount) == 0)
   2.691 +    BusLogic_AppendProbeAddressISA(0x134);
   2.692 +}
   2.693 +
   2.694 +
   2.695 +#ifdef CONFIG_PCI
   2.696 +
   2.697 +
   2.698 +/*
   2.699 +  BusLogic_SortProbeInfo sorts a section of BusLogic_ProbeInfoList in order
   2.700 +  of increasing PCI Bus and Device Number.
   2.701 +*/
   2.702 +
   2.703 +static void BusLogic_SortProbeInfo(BusLogic_ProbeInfo_T *ProbeInfoList,
   2.704 +				   int ProbeInfoCount)
   2.705 +{
   2.706 +  int LastInterchange = ProbeInfoCount-1, Bound, j;
   2.707 +  while (LastInterchange > 0)
   2.708 +    {
   2.709 +      Bound = LastInterchange;
   2.710 +      LastInterchange = 0;
   2.711 +      for (j = 0; j < Bound; j++)
   2.712 +	{
   2.713 +	  BusLogic_ProbeInfo_T *ProbeInfo1 = &ProbeInfoList[j];
   2.714 +	  BusLogic_ProbeInfo_T *ProbeInfo2 = &ProbeInfoList[j+1];
   2.715 +	  if (ProbeInfo1->Bus > ProbeInfo2->Bus ||
   2.716 +	      (ProbeInfo1->Bus == ProbeInfo2->Bus &&
   2.717 +	       (ProbeInfo1->Device > ProbeInfo2->Device)))
   2.718 +	    {
   2.719 +	      BusLogic_ProbeInfo_T TempProbeInfo;
   2.720 +	      memcpy(&TempProbeInfo, ProbeInfo1, sizeof(BusLogic_ProbeInfo_T));
   2.721 +	      memcpy(ProbeInfo1, ProbeInfo2, sizeof(BusLogic_ProbeInfo_T));
   2.722 +	      memcpy(ProbeInfo2, &TempProbeInfo, sizeof(BusLogic_ProbeInfo_T));
   2.723 +	      LastInterchange = j;
   2.724 +	    }
   2.725 +	}
   2.726 +    }
   2.727 +}
   2.728 +
   2.729 +
   2.730 +/*
   2.731 +  BusLogic_InitializeMultiMasterProbeInfo initializes the list of I/O Address
   2.732 +  and Bus Probe Information to be checked for potential BusLogic MultiMaster
   2.733 +  SCSI Host Adapters by interrogating the PCI Configuration Space on PCI
   2.734 +  machines as well as from the list of standard BusLogic MultiMaster ISA
   2.735 +  I/O Addresses.  It returns the number of PCI MultiMaster Host Adapters found.
   2.736 +*/
   2.737 +
   2.738 +static int BusLogic_InitializeMultiMasterProbeInfo(BusLogic_HostAdapter_T
   2.739 +						   *PrototypeHostAdapter)
   2.740 +{
   2.741 +  BusLogic_ProbeInfo_T *PrimaryProbeInfo =
   2.742 +    &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount];
   2.743 +  int NonPrimaryPCIMultiMasterIndex = BusLogic_ProbeInfoCount + 1;
   2.744 +  int NonPrimaryPCIMultiMasterCount = 0, PCIMultiMasterCount = 0;
   2.745 +  boolean ForceBusDeviceScanningOrder = false;
   2.746 +  boolean ForceBusDeviceScanningOrderChecked = false;
   2.747 +  boolean StandardAddressSeen[6];
   2.748 +  PCI_Device_T *PCI_Device = NULL;
   2.749 +  int i;
   2.750 +  if (BusLogic_ProbeInfoCount >= BusLogic_MaxHostAdapters) return 0;
   2.751 +  BusLogic_ProbeInfoCount++;
   2.752 +  for (i = 0; i < 6; i++)
   2.753 +    StandardAddressSeen[i] = false;
   2.754 +  /*
   2.755 +    Iterate over the MultiMaster PCI Host Adapters.  For each enumerated host
   2.756 +    adapter, determine whether its ISA Compatible I/O Port is enabled and if
   2.757 +    so, whether it is assigned the Primary I/O Address.  A host adapter that is
   2.758 +    assigned the Primary I/O Address will always be the preferred boot device.
   2.759 +    The MultiMaster BIOS will first recognize a host adapter at the Primary I/O
   2.760 +    Address, then any other PCI host adapters, and finally any host adapters
   2.761 +    located at the remaining standard ISA I/O Addresses.  When a PCI host
   2.762 +    adapter is found with its ISA Compatible I/O Port enabled, a command is
   2.763 +    issued to disable the ISA Compatible I/O Port, and it is noted that the
   2.764 +    particular standard ISA I/O Address need not be probed.
   2.765 +  */
   2.766 +  PrimaryProbeInfo->IO_Address = 0;
   2.767 +  while ((PCI_Device = pci_find_device(PCI_VENDOR_ID_BUSLOGIC,
   2.768 +				       PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER,
   2.769 +				       PCI_Device)) != NULL)
   2.770 +    {
   2.771 +      BusLogic_HostAdapter_T *HostAdapter = PrototypeHostAdapter;
   2.772 +      BusLogic_PCIHostAdapterInformation_T PCIHostAdapterInformation;
   2.773 +      BusLogic_ModifyIOAddressRequest_T ModifyIOAddressRequest;
   2.774 +      unsigned char Bus = PCI_Device->bus->number;
   2.775 +      unsigned char Device = PCI_Device->devfn >> 3;
   2.776 +      unsigned int IRQ_Channel;
   2.777 +      unsigned long BaseAddress0;
   2.778 +      unsigned long BaseAddress1;
   2.779 +      BusLogic_IO_Address_T IO_Address;
   2.780 +      BusLogic_PCI_Address_T PCI_Address;
   2.781 +
   2.782 +      if (pci_enable_device(PCI_Device))
   2.783 +      	continue;
   2.784 +      
   2.785 +      IRQ_Channel = PCI_Device->irq;
   2.786 +      IO_Address  = BaseAddress0 = pci_resource_start(PCI_Device, 0);
   2.787 +      PCI_Address = BaseAddress1 = pci_resource_start(PCI_Device, 1);
   2.788 +
   2.789 +      if (pci_resource_flags(PCI_Device, 0) & IORESOURCE_MEM)
   2.790 +	{
   2.791 +	  BusLogic_Error("BusLogic: Base Address0 0x%X not I/O for "
   2.792 +			 "MultiMaster Host Adapter\n", NULL, BaseAddress0);
   2.793 +	  BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n",
   2.794 +			 NULL, Bus, Device, IO_Address);
   2.795 +	  continue;
   2.796 +	}
   2.797 +      if (pci_resource_flags(PCI_Device,1) & IORESOURCE_IO)
   2.798 +	{
   2.799 +	  BusLogic_Error("BusLogic: Base Address1 0x%X not Memory for "
   2.800 +			 "MultiMaster Host Adapter\n", NULL, BaseAddress1);
   2.801 +	  BusLogic_Error("at PCI Bus %d Device %d PCI Address 0x%X\n",
   2.802 +			 NULL, Bus, Device, PCI_Address);
   2.803 +	  continue;
   2.804 +	}
   2.805 +      if (IRQ_Channel == 0)
   2.806 +	{
   2.807 +	  BusLogic_Error("BusLogic: IRQ Channel %d illegal for "
   2.808 +			 "MultiMaster Host Adapter\n", NULL, IRQ_Channel);
   2.809 +	  BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n",
   2.810 +			 NULL, Bus, Device, IO_Address);
   2.811 +	  continue;
   2.812 +	}
   2.813 +      if (BusLogic_GlobalOptions.TraceProbe)
   2.814 +	{
   2.815 +	  BusLogic_Notice("BusLogic: PCI MultiMaster Host Adapter "
   2.816 +			  "detected at\n", NULL);
   2.817 +	  BusLogic_Notice("BusLogic: PCI Bus %d Device %d I/O Address "
   2.818 +			  "0x%X PCI Address 0x%X\n", NULL,
   2.819 +			  Bus, Device, IO_Address, PCI_Address);
   2.820 +	}
   2.821 +      /*
   2.822 +	Issue the Inquire PCI Host Adapter Information command to determine
   2.823 +	the ISA Compatible I/O Port.  If the ISA Compatible I/O Port is
   2.824 +	known and enabled, note that the particular Standard ISA I/O
   2.825 +	Address should not be probed.
   2.826 +      */
   2.827 +      HostAdapter->IO_Address = IO_Address;
   2.828 +      BusLogic_InterruptReset(HostAdapter);
   2.829 +      if (BusLogic_Command(HostAdapter,
   2.830 +			   BusLogic_InquirePCIHostAdapterInformation,
   2.831 +			   NULL, 0, &PCIHostAdapterInformation,
   2.832 +			   sizeof(PCIHostAdapterInformation))
   2.833 +	  == sizeof(PCIHostAdapterInformation))
   2.834 +	{
   2.835 +	  if (PCIHostAdapterInformation.ISACompatibleIOPort < 6)
   2.836 +	    StandardAddressSeen[PCIHostAdapterInformation
   2.837 +				.ISACompatibleIOPort] = true;
   2.838 +	}
   2.839 +      else PCIHostAdapterInformation.ISACompatibleIOPort =
   2.840 +	     BusLogic_IO_Disable;
   2.841 +      /*
   2.842 +	Issue the Modify I/O Address command to disable the ISA Compatible
   2.843 +	I/O Port.
   2.844 +      */
   2.845 +      ModifyIOAddressRequest = BusLogic_IO_Disable;
   2.846 +      BusLogic_Command(HostAdapter, BusLogic_ModifyIOAddress,
   2.847 +		       &ModifyIOAddressRequest,
   2.848 +		       sizeof(ModifyIOAddressRequest), NULL, 0);
   2.849 +      /*
   2.850 +	For the first MultiMaster Host Adapter enumerated, issue the Fetch
   2.851 +	Host Adapter Local RAM command to read byte 45 of the AutoSCSI area,
   2.852 +	for the setting of the "Use Bus And Device # For PCI Scanning Seq."
   2.853 +	option.  Issue the Inquire Board ID command since this option is
   2.854 +	only valid for the BT-948/958/958D.
   2.855 +      */
   2.856 +      if (!ForceBusDeviceScanningOrderChecked)
   2.857 +	{
   2.858 +	  BusLogic_FetchHostAdapterLocalRAMRequest_T
   2.859 +	    FetchHostAdapterLocalRAMRequest;
   2.860 +	  BusLogic_AutoSCSIByte45_T AutoSCSIByte45;
   2.861 +	  BusLogic_BoardID_T BoardID;
   2.862 +	  FetchHostAdapterLocalRAMRequest.ByteOffset =
   2.863 +	    BusLogic_AutoSCSI_BaseOffset + 45;
   2.864 +	  FetchHostAdapterLocalRAMRequest.ByteCount =
   2.865 +	    sizeof(AutoSCSIByte45);
   2.866 +	  BusLogic_Command(HostAdapter,
   2.867 +			   BusLogic_FetchHostAdapterLocalRAM,
   2.868 +			   &FetchHostAdapterLocalRAMRequest,
   2.869 +			   sizeof(FetchHostAdapterLocalRAMRequest),
   2.870 +			   &AutoSCSIByte45, sizeof(AutoSCSIByte45));
   2.871 +	  BusLogic_Command(HostAdapter, BusLogic_InquireBoardID,
   2.872 +			   NULL, 0, &BoardID, sizeof(BoardID));
   2.873 +	  if (BoardID.FirmwareVersion1stDigit == '5')
   2.874 +	    ForceBusDeviceScanningOrder =
   2.875 +	      AutoSCSIByte45.ForceBusDeviceScanningOrder;
   2.876 +	  ForceBusDeviceScanningOrderChecked = true;
   2.877 +	}
   2.878 +      /*
   2.879 +	Determine whether this MultiMaster Host Adapter has its ISA
   2.880 +	Compatible I/O Port enabled and is assigned the Primary I/O Address.
   2.881 +	If it does, then it is the Primary MultiMaster Host Adapter and must
   2.882 +	be recognized first.  If it does not, then it is added to the list
   2.883 +	for probing after any Primary MultiMaster Host Adapter is probed.
   2.884 +      */
   2.885 +      if (PCIHostAdapterInformation.ISACompatibleIOPort == BusLogic_IO_330)
   2.886 +	{
   2.887 +	  PrimaryProbeInfo->HostAdapterType = BusLogic_MultiMaster;
   2.888 +	  PrimaryProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
   2.889 +	  PrimaryProbeInfo->IO_Address = IO_Address;
   2.890 +	  PrimaryProbeInfo->PCI_Address = PCI_Address;
   2.891 +	  PrimaryProbeInfo->Bus = Bus;
   2.892 +	  PrimaryProbeInfo->Device = Device;
   2.893 +	  PrimaryProbeInfo->IRQ_Channel = IRQ_Channel;
   2.894 +	  PCIMultiMasterCount++;
   2.895 +	}
   2.896 +      else if (BusLogic_ProbeInfoCount < BusLogic_MaxHostAdapters)
   2.897 +	{
   2.898 +	  BusLogic_ProbeInfo_T *ProbeInfo =
   2.899 +	    &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++];
   2.900 +	  ProbeInfo->HostAdapterType = BusLogic_MultiMaster;
   2.901 +	  ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
   2.902 +	  ProbeInfo->IO_Address = IO_Address;
   2.903 +	  ProbeInfo->PCI_Address = PCI_Address;
   2.904 +	  ProbeInfo->Bus = Bus;
   2.905 +	  ProbeInfo->Device = Device;
   2.906 +	  ProbeInfo->IRQ_Channel = IRQ_Channel;
   2.907 +	  NonPrimaryPCIMultiMasterCount++;
   2.908 +	  PCIMultiMasterCount++;
   2.909 +	}
   2.910 +      else BusLogic_Warning("BusLogic: Too many Host Adapters "
   2.911 +			    "detected\n", NULL);
   2.912 +    }
   2.913 +  /*
   2.914 +    If the AutoSCSI "Use Bus And Device # For PCI Scanning Seq." option is ON
   2.915 +    for the first enumerated MultiMaster Host Adapter, and if that host adapter
   2.916 +    is a BT-948/958/958D, then the MultiMaster BIOS will recognize MultiMaster
   2.917 +    Host Adapters in the order of increasing PCI Bus and Device Number.  In
   2.918 +    that case, sort the probe information into the same order the BIOS uses.
   2.919 +    If this option is OFF, then the MultiMaster BIOS will recognize MultiMaster
   2.920 +    Host Adapters in the order they are enumerated by the PCI BIOS, and hence
   2.921 +    no sorting is necessary.
   2.922 +  */
   2.923 +  if (ForceBusDeviceScanningOrder)
   2.924 +    BusLogic_SortProbeInfo(&BusLogic_ProbeInfoList[
   2.925 +			      NonPrimaryPCIMultiMasterIndex],
   2.926 +			   NonPrimaryPCIMultiMasterCount);
   2.927 +  /*
   2.928 +    If no PCI MultiMaster Host Adapter is assigned the Primary I/O Address,
   2.929 +    then the Primary I/O Address must be probed explicitly before any PCI
   2.930 +    host adapters are probed.
   2.931 +  */
   2.932 +  if (!BusLogic_ProbeOptions.NoProbeISA)
   2.933 +    if (PrimaryProbeInfo->IO_Address == 0 &&
   2.934 +	(BusLogic_ProbeOptions.LimitedProbeISA
   2.935 +	 ? BusLogic_ProbeOptions.Probe330
   2.936 +	 : check_region(0x330, BusLogic_MultiMasterAddressCount) == 0))
   2.937 +      {
   2.938 +	PrimaryProbeInfo->HostAdapterType = BusLogic_MultiMaster;
   2.939 +	PrimaryProbeInfo->HostAdapterBusType = BusLogic_ISA_Bus;
   2.940 +	PrimaryProbeInfo->IO_Address = 0x330;
   2.941 +      }
   2.942 +  /*
   2.943 +    Append the list of standard BusLogic MultiMaster ISA I/O Addresses,
   2.944 +    omitting the Primary I/O Address which has already been handled.
   2.945 +  */
   2.946 +  if (!BusLogic_ProbeOptions.NoProbeISA)
   2.947 +    {
   2.948 +      if (!StandardAddressSeen[1] &&
   2.949 +	  (BusLogic_ProbeOptions.LimitedProbeISA
   2.950 +	   ? BusLogic_ProbeOptions.Probe334
   2.951 +	   : check_region(0x334, BusLogic_MultiMasterAddressCount) == 0))
   2.952 +	BusLogic_AppendProbeAddressISA(0x334);
   2.953 +      if (!StandardAddressSeen[2] &&
   2.954 +	  (BusLogic_ProbeOptions.LimitedProbeISA
   2.955 +	   ? BusLogic_ProbeOptions.Probe230
   2.956 +	   : check_region(0x230, BusLogic_MultiMasterAddressCount) == 0))
   2.957 +	BusLogic_AppendProbeAddressISA(0x230);
   2.958 +      if (!StandardAddressSeen[3] &&
   2.959 +	  (BusLogic_ProbeOptions.LimitedProbeISA
   2.960 +	   ? BusLogic_ProbeOptions.Probe234
   2.961 +	   : check_region(0x234, BusLogic_MultiMasterAddressCount) == 0))
   2.962 +	BusLogic_AppendProbeAddressISA(0x234);
   2.963 +      if (!StandardAddressSeen[4] &&
   2.964 +	  (BusLogic_ProbeOptions.LimitedProbeISA
   2.965 +	   ? BusLogic_ProbeOptions.Probe130
   2.966 +	   : check_region(0x130, BusLogic_MultiMasterAddressCount) == 0))
   2.967 +	BusLogic_AppendProbeAddressISA(0x130);
   2.968 +      if (!StandardAddressSeen[5] &&
   2.969 +	  (BusLogic_ProbeOptions.LimitedProbeISA
   2.970 +	   ? BusLogic_ProbeOptions.Probe134
   2.971 +	   : check_region(0x134, BusLogic_MultiMasterAddressCount) == 0))
   2.972 +	BusLogic_AppendProbeAddressISA(0x134);
   2.973 +    }
   2.974 +  /*
   2.975 +    Iterate over the older non-compliant MultiMaster PCI Host Adapters,
   2.976 +    noting the PCI bus location and assigned IRQ Channel.
   2.977 +  */
   2.978 +  PCI_Device = NULL;
   2.979 +  while ((PCI_Device = pci_find_device(PCI_VENDOR_ID_BUSLOGIC,
   2.980 +				       PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC,
   2.981 +				       PCI_Device)) != NULL)
   2.982 +    {
   2.983 +      unsigned char Bus = PCI_Device->bus->number;
   2.984 +      unsigned char Device = PCI_Device->devfn >> 3;
   2.985 +      unsigned int IRQ_Channel = PCI_Device->irq;
   2.986 +      BusLogic_IO_Address_T IO_Address = pci_resource_start(PCI_Device, 0);
   2.987 +
   2.988 +      if (pci_enable_device(PCI_Device))
   2.989 +		continue;
   2.990 +
   2.991 +      if (IO_Address == 0 || IRQ_Channel == 0) continue;
   2.992 +      for (i = 0; i < BusLogic_ProbeInfoCount; i++)
   2.993 +	{
   2.994 +	  BusLogic_ProbeInfo_T *ProbeInfo = &BusLogic_ProbeInfoList[i];
   2.995 +	  if (ProbeInfo->IO_Address == IO_Address &&
   2.996 +	      ProbeInfo->HostAdapterType == BusLogic_MultiMaster)
   2.997 +	    {
   2.998 +	      ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
   2.999 +	      ProbeInfo->PCI_Address = 0;
  2.1000 +	      ProbeInfo->Bus = Bus;
  2.1001 +	      ProbeInfo->Device = Device;
  2.1002 +	      ProbeInfo->IRQ_Channel = IRQ_Channel;
  2.1003 +	      break;
  2.1004 +	    }
  2.1005 +	}
  2.1006 +    }
  2.1007 +  return PCIMultiMasterCount;
  2.1008 +}
  2.1009 +
  2.1010 +
  2.1011 +/*
  2.1012 +  BusLogic_InitializeFlashPointProbeInfo initializes the list of I/O Address
  2.1013 +  and Bus Probe Information to be checked for potential BusLogic FlashPoint
  2.1014 +  Host Adapters by interrogating the PCI Configuration Space.  It returns the
  2.1015 +  number of FlashPoint Host Adapters found.
  2.1016 +*/
  2.1017 +
  2.1018 +static int BusLogic_InitializeFlashPointProbeInfo(BusLogic_HostAdapter_T
  2.1019 +						  *PrototypeHostAdapter)
  2.1020 +{
  2.1021 +  int FlashPointIndex = BusLogic_ProbeInfoCount, FlashPointCount = 0;
  2.1022 +  PCI_Device_T *PCI_Device = NULL;
  2.1023 +  /*
  2.1024 +    Interrogate PCI Configuration Space for any FlashPoint Host Adapters.
  2.1025 +  */
  2.1026 +  while ((PCI_Device = pci_find_device(PCI_VENDOR_ID_BUSLOGIC,
  2.1027 +				       PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT,
  2.1028 +				       PCI_Device)) != NULL)
  2.1029 +    {
  2.1030 +      unsigned char Bus = PCI_Device->bus->number;
  2.1031 +      unsigned char Device = PCI_Device->devfn >> 3;
  2.1032 +      unsigned int IRQ_Channel = PCI_Device->irq;
  2.1033 +      unsigned long BaseAddress0 = pci_resource_start(PCI_Device, 0);
  2.1034 +      unsigned long BaseAddress1 = pci_resource_start(PCI_Device, 1);
  2.1035 +      BusLogic_IO_Address_T IO_Address = BaseAddress0;
  2.1036 +      BusLogic_PCI_Address_T PCI_Address = BaseAddress1;
  2.1037 +
  2.1038 +      if (pci_enable_device(PCI_Device))
  2.1039 +		continue;
  2.1040 +
  2.1041 +#ifndef CONFIG_SCSI_OMIT_FLASHPOINT
  2.1042 +      if (pci_resource_flags(PCI_Device, 0) & IORESOURCE_MEM)
  2.1043 +	{
  2.1044 +	  BusLogic_Error("BusLogic: Base Address0 0x%X not I/O for "
  2.1045 +			 "FlashPoint Host Adapter\n", NULL, BaseAddress0);
  2.1046 +	  BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n",
  2.1047 +			 NULL, Bus, Device, IO_Address);
  2.1048 +	  continue;
  2.1049 +	}
  2.1050 +      if (pci_resource_flags(PCI_Device, 1) & IORESOURCE_IO)
  2.1051 +	{
  2.1052 +	  BusLogic_Error("BusLogic: Base Address1 0x%X not Memory for "
  2.1053 +			 "FlashPoint Host Adapter\n", NULL, BaseAddress1);
  2.1054 +	  BusLogic_Error("at PCI Bus %d Device %d PCI Address 0x%X\n",
  2.1055 +			 NULL, Bus, Device, PCI_Address);
  2.1056 +	  continue;
  2.1057 +	}
  2.1058 +      if (IRQ_Channel == 0)
  2.1059 +	{
  2.1060 +	  BusLogic_Error("BusLogic: IRQ Channel %d illegal for "
  2.1061 +			 "FlashPoint Host Adapter\n", NULL, IRQ_Channel);
  2.1062 +	  BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n",
  2.1063 +			 NULL, Bus, Device, IO_Address);
  2.1064 +	  continue;
  2.1065 +	}
  2.1066 +      if (BusLogic_GlobalOptions.TraceProbe)
  2.1067 +	{
  2.1068 +	  BusLogic_Notice("BusLogic: FlashPoint Host Adapter "
  2.1069 +			  "detected at\n", NULL);
  2.1070 +	  BusLogic_Notice("BusLogic: PCI Bus %d Device %d I/O Address "
  2.1071 +			  "0x%X PCI Address 0x%X\n", NULL,
  2.1072 +			  Bus, Device, IO_Address, PCI_Address);
  2.1073 +	}
  2.1074 +      if (BusLogic_ProbeInfoCount < BusLogic_MaxHostAdapters)
  2.1075 +	{
  2.1076 +	  BusLogic_ProbeInfo_T *ProbeInfo =
  2.1077 +	    &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++];
  2.1078 +	  ProbeInfo->HostAdapterType = BusLogic_FlashPoint;
  2.1079 +	  ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
  2.1080 +	  ProbeInfo->IO_Address = IO_Address;
  2.1081 +	  ProbeInfo->PCI_Address = PCI_Address;
  2.1082 +	  ProbeInfo->Bus = Bus;
  2.1083 +	  ProbeInfo->Device = Device;
  2.1084 +	  ProbeInfo->IRQ_Channel = IRQ_Channel;
  2.1085 +	  FlashPointCount++;
  2.1086 +	}
  2.1087 +      else BusLogic_Warning("BusLogic: Too many Host Adapters "
  2.1088 +			    "detected\n", NULL);
  2.1089 +#else
  2.1090 +      BusLogic_Error("BusLogic: FlashPoint Host Adapter detected at "
  2.1091 +		     "PCI Bus %d Device %d\n", NULL, Bus, Device);
  2.1092 +      BusLogic_Error("BusLogic: I/O Address 0x%X PCI Address 0x%X, irq %d, "
  2.1093 +		     "but FlashPoint\n", NULL, IO_Address, PCI_Address, IRQ_Channel);
  2.1094 +      BusLogic_Error("BusLogic: support was omitted in this kernel "
  2.1095 +		     "configuration.\n", NULL);
  2.1096 +#endif
  2.1097 +    }
  2.1098 +  /*
  2.1099 +    The FlashPoint BIOS will scan for FlashPoint Host Adapters in the order of
  2.1100 +    increasing PCI Bus and Device Number, so sort the probe information into
  2.1101 +    the same order the BIOS uses.
  2.1102 +  */
  2.1103 +  BusLogic_SortProbeInfo(&BusLogic_ProbeInfoList[FlashPointIndex],
  2.1104 +			 FlashPointCount);
  2.1105 +  return FlashPointCount;
  2.1106 +}
  2.1107 +
  2.1108 +
  2.1109 +/*
  2.1110 +  BusLogic_InitializeProbeInfoList initializes the list of I/O Address and Bus
  2.1111 +  Probe Information to be checked for potential BusLogic SCSI Host Adapters by
  2.1112 +  interrogating the PCI Configuration Space on PCI machines as well as from the
  2.1113 +  list of standard BusLogic MultiMaster ISA I/O Addresses.  By default, if both
  2.1114 +  FlashPoint and PCI MultiMaster Host Adapters are present, this driver will
  2.1115 +  probe for FlashPoint Host Adapters first unless the BIOS primary disk is
  2.1116 +  controlled by the first PCI MultiMaster Host Adapter, in which case
  2.1117 +  MultiMaster Host Adapters will be probed first.  The BusLogic Driver Options
  2.1118 +  specifications "MultiMasterFirst" and "FlashPointFirst" can be used to force
  2.1119 +  a particular probe order.
  2.1120 +*/
  2.1121 +
  2.1122 +static void BusLogic_InitializeProbeInfoList(BusLogic_HostAdapter_T
  2.1123 +					     *PrototypeHostAdapter)
  2.1124 +{
  2.1125 +  /*
  2.1126 +    If a PCI BIOS is present, interrogate it for MultiMaster and FlashPoint
  2.1127 +    Host Adapters; otherwise, default to the standard ISA MultiMaster probe.
  2.1128 +  */
  2.1129 +  if (!BusLogic_ProbeOptions.NoProbePCI && pci_present())
  2.1130 +    {
  2.1131 +      if (BusLogic_ProbeOptions.MultiMasterFirst)
  2.1132 +	{
  2.1133 +	  BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter);
  2.1134 +	  BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter);
  2.1135 +	}
  2.1136 +      else if (BusLogic_ProbeOptions.FlashPointFirst)
  2.1137 +	{
  2.1138 +	  BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter);
  2.1139 +	  BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter);
  2.1140 +	}
  2.1141 +      else
  2.1142 +	{
  2.1143 +	  int FlashPointCount =
  2.1144 +	    BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter);
  2.1145 +	  int PCIMultiMasterCount =
  2.1146 +	    BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter);
  2.1147 +	  if (FlashPointCount > 0 && PCIMultiMasterCount > 0)
  2.1148 +	    {
  2.1149 +	      BusLogic_ProbeInfo_T *ProbeInfo =
  2.1150 +		&BusLogic_ProbeInfoList[FlashPointCount];
  2.1151 +	      BusLogic_HostAdapter_T *HostAdapter = PrototypeHostAdapter;
  2.1152 +	      BusLogic_FetchHostAdapterLocalRAMRequest_T
  2.1153 +		FetchHostAdapterLocalRAMRequest;
  2.1154 +	      BusLogic_BIOSDriveMapByte_T Drive0MapByte;
  2.1155 +	      while (ProbeInfo->HostAdapterBusType != BusLogic_PCI_Bus)
  2.1156 +		ProbeInfo++;
  2.1157 +	      HostAdapter->IO_Address = ProbeInfo->IO_Address;
  2.1158 +	      FetchHostAdapterLocalRAMRequest.ByteOffset =
  2.1159 +		BusLogic_BIOS_BaseOffset + BusLogic_BIOS_DriveMapOffset + 0;
  2.1160 +	      FetchHostAdapterLocalRAMRequest.ByteCount =
  2.1161 +		sizeof(Drive0MapByte);
  2.1162 +	      BusLogic_Command(HostAdapter,
  2.1163 +			       BusLogic_FetchHostAdapterLocalRAM,
  2.1164 +			       &FetchHostAdapterLocalRAMRequest,
  2.1165 +			       sizeof(FetchHostAdapterLocalRAMRequest),
  2.1166 +			       &Drive0MapByte, sizeof(Drive0MapByte));
  2.1167 +	      /*
  2.1168 +		If the Map Byte for BIOS Drive 0 indicates that BIOS Drive 0
  2.1169 +		is controlled by this PCI MultiMaster Host Adapter, then
  2.1170 +		reverse the probe order so that MultiMaster Host Adapters are
  2.1171 +		probed before FlashPoint Host Adapters.
  2.1172 +	      */
  2.1173 +	      if (Drive0MapByte.DiskGeometry !=
  2.1174 +		  BusLogic_BIOS_Disk_Not_Installed)
  2.1175 +		{
  2.1176 +		  BusLogic_ProbeInfo_T
  2.1177 +		    SavedProbeInfo[BusLogic_MaxHostAdapters];
  2.1178 +		  int MultiMasterCount =
  2.1179 +		    BusLogic_ProbeInfoCount - FlashPointCount;
  2.1180 +		  memcpy(SavedProbeInfo,
  2.1181 +			 BusLogic_ProbeInfoList,
  2.1182 +			 BusLogic_ProbeInfoCount
  2.1183 +			 * sizeof(BusLogic_ProbeInfo_T));
  2.1184 +		  memcpy(&BusLogic_ProbeInfoList[0],
  2.1185 +			 &SavedProbeInfo[FlashPointCount],
  2.1186 +			 MultiMasterCount * sizeof(BusLogic_ProbeInfo_T));
  2.1187 +		  memcpy(&BusLogic_ProbeInfoList[MultiMasterCount],
  2.1188 +			 &SavedProbeInfo[0],
  2.1189 +			 FlashPointCount * sizeof(BusLogic_ProbeInfo_T));
  2.1190 +		}
  2.1191 +	    }
  2.1192 +	}
  2.1193 +    }
  2.1194 +  else BusLogic_InitializeProbeInfoListISA(PrototypeHostAdapter);
  2.1195 +}
  2.1196 +
  2.1197 +
  2.1198 +#endif  /* CONFIG_PCI */
  2.1199 +
  2.1200 +
  2.1201 +/*
  2.1202 +  BusLogic_Failure prints a standardized error message, and then returns false.
  2.1203 +*/
  2.1204 +
  2.1205 +static boolean BusLogic_Failure(BusLogic_HostAdapter_T *HostAdapter,
  2.1206 +				char *ErrorMessage)
  2.1207 +{
  2.1208 +  BusLogic_AnnounceDriver(HostAdapter);
  2.1209 +  if (HostAdapter->HostAdapterBusType == BusLogic_PCI_Bus)
  2.1210 +    {
  2.1211 +      BusLogic_Error("While configuring BusLogic PCI Host Adapter at\n",
  2.1212 +		     HostAdapter);
  2.1213 +      BusLogic_Error("Bus %d Device %d I/O Address 0x%X PCI Address 0x%X:\n",
  2.1214 +		     HostAdapter, HostAdapter->Bus, HostAdapter->Device,
  2.1215 +		     HostAdapter->IO_Address, HostAdapter->PCI_Address);
  2.1216 +    }
  2.1217 +  else BusLogic_Error("While configuring BusLogic Host Adapter at "
  2.1218 +		      "I/O Address 0x%X:\n", HostAdapter,
  2.1219 +		      HostAdapter->IO_Address);
  2.1220 +  BusLogic_Error("%s FAILED - DETACHING\n", HostAdapter, ErrorMessage);
  2.1221 +  if (BusLogic_CommandFailureReason != NULL)
  2.1222 +    BusLogic_Error("ADDITIONAL FAILURE INFO - %s\n", HostAdapter,
  2.1223 +		   BusLogic_CommandFailureReason);
  2.1224 +  return false;
  2.1225 +}
  2.1226 +
  2.1227 +
  2.1228 +/*
  2.1229 +  BusLogic_ProbeHostAdapter probes for a BusLogic Host Adapter.
  2.1230 +*/
  2.1231 +
  2.1232 +static boolean BusLogic_ProbeHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
  2.1233 +{
  2.1234 +  BusLogic_StatusRegister_T StatusRegister;
  2.1235 +  BusLogic_InterruptRegister_T InterruptRegister;
  2.1236 +  BusLogic_GeometryRegister_T GeometryRegister;
  2.1237 +  /*
  2.1238 +    FlashPoint Host Adapters are Probed by the FlashPoint SCCB Manager.
  2.1239 +  */
  2.1240 +  if (BusLogic_FlashPointHostAdapterP(HostAdapter))
  2.1241 +    {
  2.1242 +      FlashPoint_Info_T *FlashPointInfo = &HostAdapter->FlashPointInfo;
  2.1243 +      FlashPointInfo->BaseAddress =
  2.1244 +	(BusLogic_Base_Address_T) HostAdapter->IO_Address;
  2.1245 +      FlashPointInfo->IRQ_Channel = HostAdapter->IRQ_Channel;
  2.1246 +      FlashPointInfo->Present = false;
  2.1247 +      if (!(FlashPoint_ProbeHostAdapter(FlashPointInfo) == 0 &&
  2.1248 +	    FlashPointInfo->Present))
  2.1249 +	{
  2.1250 +	  BusLogic_Error("BusLogic: FlashPoint Host Adapter detected at "
  2.1251 +			 "PCI Bus %d Device %d\n", HostAdapter,
  2.1252 +			 HostAdapter->Bus, HostAdapter->Device);
  2.1253 +	  BusLogic_Error("BusLogic: I/O Address 0x%X PCI Address 0x%X, "
  2.1254 +			 "but FlashPoint\n", HostAdapter,
  2.1255 +			 HostAdapter->IO_Address, HostAdapter->PCI_Address);
  2.1256 +	  BusLogic_Error("BusLogic: Probe Function failed to validate it.\n",
  2.1257 +			 HostAdapter);
  2.1258 +	  return false;
  2.1259 +	}
  2.1260 +      if (BusLogic_GlobalOptions.TraceProbe)
  2.1261 +	BusLogic_Notice("BusLogic_Probe(0x%X): FlashPoint Found\n",
  2.1262 +			HostAdapter, HostAdapter->IO_Address);
  2.1263 +      /*
  2.1264 +	Indicate the Host Adapter Probe completed successfully.
  2.1265 +      */
  2.1266 +      return true;
  2.1267 +    }
  2.1268 +  /*
  2.1269 +    Read the Status, Interrupt, and Geometry Registers to test if there are I/O
  2.1270 +    ports that respond, and to check the values to determine if they are from a
  2.1271 +    BusLogic Host Adapter.  A nonexistent I/O port will return 0xFF, in which
  2.1272 +    case there is definitely no BusLogic Host Adapter at this base I/O Address.
  2.1273 +    The test here is a subset of that used by the BusLogic Host Adapter BIOS.
  2.1274 +  */
  2.1275 +  StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
  2.1276 +  InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
  2.1277 +  GeometryRegister.All = BusLogic_ReadGeometryRegister(HostAdapter);
  2.1278 +  if (BusLogic_GlobalOptions.TraceProbe)
  2.1279 +    BusLogic_Notice("BusLogic_Probe(0x%X): Status 0x%02X, Interrupt 0x%02X, "
  2.1280 +		    "Geometry 0x%02X\n", HostAdapter,
  2.1281 +		    HostAdapter->IO_Address, StatusRegister.All,
  2.1282 +		    InterruptRegister.All, GeometryRegister.All);
  2.1283 +  if (StatusRegister.All == 0 ||
  2.1284 +      StatusRegister.Bits.DiagnosticActive ||
  2.1285 +      StatusRegister.Bits.CommandParameterRegisterBusy ||
  2.1286 +      StatusRegister.Bits.Reserved ||
  2.1287 +      StatusRegister.Bits.CommandInvalid ||
  2.1288 +      InterruptRegister.Bits.Reserved != 0)
  2.1289 +    return false;
  2.1290 +  /*
  2.1291 +    Check the undocumented Geometry Register to test if there is an I/O port
  2.1292 +    that responded.  Adaptec Host Adapters do not implement the Geometry
  2.1293 +    Register, so this test helps serve to avoid incorrectly recognizing an
  2.1294 +    Adaptec 1542A or 1542B as a BusLogic.  Unfortunately, the Adaptec 1542C
  2.1295 +    series does respond to the Geometry Register I/O port, but it will be
  2.1296 +    rejected later when the Inquire Extended Setup Information command is
  2.1297 +    issued in BusLogic_CheckHostAdapter.  The AMI FastDisk Host Adapter is a
  2.1298 +    BusLogic clone that implements the same interface as earlier BusLogic
  2.1299 +    Host Adapters, including the undocumented commands, and is therefore
  2.1300 +    supported by this driver.  However, the AMI FastDisk always returns 0x00
  2.1301 +    upon reading the Geometry Register, so the extended translation option
  2.1302 +    should always be left disabled on the AMI FastDisk.
  2.1303 +  */
  2.1304 +  if (GeometryRegister.All == 0xFF) return false;
  2.1305 +  /*
  2.1306 +    Indicate the Host Adapter Probe completed successfully.
  2.1307 +  */
  2.1308 +  return true;
  2.1309 +}
  2.1310 +
  2.1311 +
  2.1312 +/*
  2.1313 +  BusLogic_HardwareResetHostAdapter issues a Hardware Reset to the Host Adapter
  2.1314 +  and waits for Host Adapter Diagnostics to complete.  If HardReset is true, a
  2.1315 +  Hard Reset is performed which also initiates a SCSI Bus Reset.  Otherwise, a
  2.1316 +  Soft Reset is performed which only resets the Host Adapter without forcing a
  2.1317 +  SCSI Bus Reset.
  2.1318 +*/
  2.1319 +
  2.1320 +static boolean BusLogic_HardwareResetHostAdapter(BusLogic_HostAdapter_T
  2.1321 +						   *HostAdapter,
  2.1322 +						 boolean HardReset)
  2.1323 +{
  2.1324 +  BusLogic_StatusRegister_T StatusRegister;
  2.1325 +  int TimeoutCounter;
  2.1326 +  /*
  2.1327 +    FlashPoint Host Adapters are Hard Reset by the FlashPoint SCCB Manager.
  2.1328 +  */
  2.1329 +  if (BusLogic_FlashPointHostAdapterP(HostAdapter))
  2.1330 +    {
  2.1331 +      FlashPoint_Info_T *FlashPointInfo = &HostAdapter->FlashPointInfo;
  2.1332 +      FlashPointInfo->HostSoftReset = !HardReset;
  2.1333 +      FlashPointInfo->ReportDataUnderrun = true;
  2.1334 +      HostAdapter->CardHandle =
  2.1335 +	FlashPoint_HardwareResetHostAdapter(FlashPointInfo);
  2.1336 +      if (HostAdapter->CardHandle == FlashPoint_BadCardHandle) return false;
  2.1337 +      /*
  2.1338 +	Indicate the Host Adapter Hard Reset completed successfully.
  2.1339 +      */
  2.1340 +      return true;
  2.1341 +    }
  2.1342 +  /*
  2.1343 +    Issue a Hard Reset or Soft Reset Command to the Host Adapter.  The Host
  2.1344 +    Adapter should respond by setting Diagnostic Active in the Status Register.
  2.1345 +  */
  2.1346 +  if (HardReset)
  2.1347 +    BusLogic_HardReset(HostAdapter);
  2.1348 +  else BusLogic_SoftReset(HostAdapter);
  2.1349 +  /*
  2.1350 +    Wait until Diagnostic Active is set in the Status Register.
  2.1351 +  */
  2.1352 +  TimeoutCounter = 5*10000;
  2.1353 +  while (--TimeoutCounter >= 0)
  2.1354 +    {
  2.1355 +      StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
  2.1356 +      if (StatusRegister.Bits.DiagnosticActive) break;
  2.1357 +      udelay(100);
  2.1358 +    }
  2.1359 +  if (BusLogic_GlobalOptions.TraceHardwareReset)
  2.1360 +    BusLogic_Notice("BusLogic_HardwareReset(0x%X): Diagnostic Active, "
  2.1361 +		    "Status 0x%02X\n", HostAdapter,
  2.1362 +		    HostAdapter->IO_Address, StatusRegister.All);
  2.1363 +  if (TimeoutCounter < 0) return false;
  2.1364 +  /*
  2.1365 +    Wait 100 microseconds to allow completion of any initial diagnostic
  2.1366 +    activity which might leave the contents of the Status Register
  2.1367 +    unpredictable.
  2.1368 +  */
  2.1369 +  udelay(100);
  2.1370 +  /*
  2.1371 +    Wait until Diagnostic Active is reset in the Status Register.
  2.1372 +  */
  2.1373 +  TimeoutCounter = 10*10000;
  2.1374 +  while (--TimeoutCounter >= 0)
  2.1375 +    {
  2.1376 +      StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
  2.1377 +      if (!StatusRegister.Bits.DiagnosticActive) break;
  2.1378 +      udelay(100);
  2.1379 +    }
  2.1380 +  if (BusLogic_GlobalOptions.TraceHardwareReset)
  2.1381 +    BusLogic_Notice("BusLogic_HardwareReset(0x%X): Diagnostic Completed, "
  2.1382 +		    "Status 0x%02X\n", HostAdapter,
  2.1383 +		    HostAdapter->IO_Address, StatusRegister.All);
  2.1384 +  if (TimeoutCounter < 0) return false;
  2.1385 +  /*
  2.1386 +    Wait until at least one of the Diagnostic Failure, Host Adapter Ready,
  2.1387 +    or Data In Register Ready bits is set in the Status Register.
  2.1388 +  */
  2.1389 +  TimeoutCounter = 10000;
  2.1390 +  while (--TimeoutCounter >= 0)
  2.1391 +    {
  2.1392 +      StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
  2.1393 +      if (StatusRegister.Bits.DiagnosticFailure ||
  2.1394 +	  StatusRegister.Bits.HostAdapterReady ||
  2.1395 +	  StatusRegister.Bits.DataInRegisterReady)
  2.1396 +	break;
  2.1397 +      udelay(100);
  2.1398 +    }
  2.1399 +  if (BusLogic_GlobalOptions.TraceHardwareReset)
  2.1400 +    BusLogic_Notice("BusLogic_HardwareReset(0x%X): Host Adapter Ready, "
  2.1401 +		    "Status 0x%02X\n", HostAdapter,
  2.1402 +		    HostAdapter->IO_Address, StatusRegister.All);
  2.1403 +  if (TimeoutCounter < 0) return false;
  2.1404 +  /*
  2.1405 +    If Diagnostic Failure is set or Host Adapter Ready is reset, then an
  2.1406 +    error occurred during the Host Adapter diagnostics.  If Data In Register
  2.1407 +    Ready is set, then there is an Error Code available.
  2.1408 +  */
  2.1409 +  if (StatusRegister.Bits.DiagnosticFailure ||
  2.1410 +      !StatusRegister.Bits.HostAdapterReady)
  2.1411 +    {
  2.1412 +      BusLogic_CommandFailureReason = NULL;
  2.1413 +      BusLogic_Failure(HostAdapter, "HARD RESET DIAGNOSTICS");
  2.1414 +      BusLogic_Error("HOST ADAPTER STATUS REGISTER = %02X\n",
  2.1415 +		     HostAdapter, StatusRegister.All);
  2.1416 +      if (StatusRegister.Bits.DataInRegisterReady)
  2.1417 +	{
  2.1418 +	  unsigned char ErrorCode = BusLogic_ReadDataInRegister(HostAdapter);
  2.1419 +	  BusLogic_Error("HOST ADAPTER ERROR CODE = %d\n",
  2.1420 +			 HostAdapter, ErrorCode);
  2.1421 +	}
  2.1422 +      return false;
  2.1423 +    }
  2.1424 +  /*
  2.1425 +    Indicate the Host Adapter Hard Reset completed successfully.
  2.1426 +  */
  2.1427 +  return true;
  2.1428 +}
  2.1429 +
  2.1430 +
  2.1431 +/*
  2.1432 +  BusLogic_CheckHostAdapter checks to be sure this really is a BusLogic
  2.1433 +  Host Adapter.
  2.1434 +*/
  2.1435 +
  2.1436 +static boolean BusLogic_CheckHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
  2.1437 +{
  2.1438 +  BusLogic_ExtendedSetupInformation_T ExtendedSetupInformation;
  2.1439 +  BusLogic_RequestedReplyLength_T RequestedReplyLength;
  2.1440 +  boolean Result = true;
  2.1441 +  /*
  2.1442 +    FlashPoint Host Adapters do not require this protection.
  2.1443 +  */
  2.1444 +  if (BusLogic_FlashPointHostAdapterP(HostAdapter)) return true;
  2.1445 +  /*
  2.1446 +    Issue the Inquire Extended Setup Information command.  Only genuine
  2.1447 +    BusLogic Host Adapters and true clones support this command.  Adaptec 1542C
  2.1448 +    series Host Adapters that respond to the Geometry Register I/O port will
  2.1449 +    fail this command.
  2.1450 +  */
  2.1451 +  RequestedReplyLength = sizeof(ExtendedSetupInformation);
  2.1452 +  if (BusLogic_Command(HostAdapter,
  2.1453 +		       BusLogic_InquireExtendedSetupInformation,
  2.1454 +		       &RequestedReplyLength,
  2.1455 +		       sizeof(RequestedReplyLength),
  2.1456 +		       &ExtendedSetupInformation,
  2.1457 +		       sizeof(ExtendedSetupInformation))
  2.1458 +      != sizeof(ExtendedSetupInformation))
  2.1459 +    Result = false;
  2.1460 +  /*
  2.1461 +    Provide tracing information if requested and return.
  2.1462 +  */
  2.1463 +  if (BusLogic_GlobalOptions.TraceProbe)
  2.1464 +    BusLogic_Notice("BusLogic_Check(0x%X): MultiMaster %s\n", HostAdapter,
  2.1465 +		    HostAdapter->IO_Address, (Result ? "Found" : "Not Found"));
  2.1466 +  return Result;
  2.1467 +}
  2.1468 +
  2.1469 +
  2.1470 +/*
  2.1471 +  BusLogic_ReadHostAdapterConfiguration reads the Configuration Information
  2.1472 +  from Host Adapter and initializes the Host Adapter structure.
  2.1473 +*/
  2.1474 +
  2.1475 +static boolean BusLogic_ReadHostAdapterConfiguration(BusLogic_HostAdapter_T
  2.1476 +						     *HostAdapter)
  2.1477 +{
  2.1478 +  BusLogic_BoardID_T BoardID;
  2.1479 +  BusLogic_Configuration_T Configuration;
  2.1480 +  BusLogic_SetupInformation_T SetupInformation;
  2.1481 +  BusLogic_ExtendedSetupInformation_T ExtendedSetupInformation;
  2.1482 +  BusLogic_HostAdapterModelNumber_T HostAdapterModelNumber;
  2.1483 +  BusLogic_FirmwareVersion3rdDigit_T FirmwareVersion3rdDigit;
  2.1484 +  BusLogic_FirmwareVersionLetter_T FirmwareVersionLetter;
  2.1485 +  BusLogic_PCIHostAdapterInformation_T PCIHostAdapterInformation;
  2.1486 +  BusLogic_FetchHostAdapterLocalRAMRequest_T FetchHostAdapterLocalRAMRequest;
  2.1487 +  BusLogic_AutoSCSIData_T AutoSCSIData;
  2.1488 +  BusLogic_GeometryRegister_T GeometryRegister;
  2.1489 +  BusLogic_RequestedReplyLength_T RequestedReplyLength;
  2.1490 +  unsigned char *TargetPointer, Character;
  2.1491 +  int TargetID, i;
  2.1492 +  /*
  2.1493 +    Configuration Information for FlashPoint Host Adapters is provided in the
  2.1494 +    FlashPoint_Info structure by the FlashPoint SCCB Manager's Probe Function.
  2.1495 +    Initialize fields in the Host Adapter structure from the FlashPoint_Info
  2.1496 +    structure.
  2.1497 +  */
  2.1498 +  if (BusLogic_FlashPointHostAdapterP(HostAdapter))
  2.1499 +    {
  2.1500 +      FlashPoint_Info_T *FlashPointInfo = &HostAdapter->FlashPointInfo;
  2.1501 +      TargetPointer = HostAdapter->ModelName;
  2.1502 +      *TargetPointer++ = 'B';
  2.1503 +      *TargetPointer++ = 'T';
  2.1504 +      *TargetPointer++ = '-';
  2.1505 +      for (i = 0; i < sizeof(FlashPointInfo->ModelNumber); i++)
  2.1506 +	*TargetPointer++ = FlashPointInfo->ModelNumber[i];
  2.1507 +      *TargetPointer++ = '\0';
  2.1508 +      strcpy(HostAdapter->FirmwareVersion, FlashPoint_FirmwareVersion);
  2.1509 +      HostAdapter->SCSI_ID = FlashPointInfo->SCSI_ID;
  2.1510 +      HostAdapter->ExtendedTranslationEnabled =
  2.1511 +	FlashPointInfo->ExtendedTranslationEnabled;
  2.1512 +      HostAdapter->ParityCheckingEnabled =
  2.1513 +	FlashPointInfo->ParityCheckingEnabled;
  2.1514 +      HostAdapter->BusResetEnabled = !FlashPointInfo->HostSoftReset;
  2.1515 +      HostAdapter->LevelSensitiveInterrupt = true;
  2.1516 +      HostAdapter->HostWideSCSI = FlashPointInfo->HostWideSCSI;
  2.1517 +      HostAdapter->HostDifferentialSCSI = false;
  2.1518 +      HostAdapter->HostSupportsSCAM = true;
  2.1519 +      HostAdapter->HostUltraSCSI = true;
  2.1520 +      HostAdapter->ExtendedLUNSupport = true;
  2.1521 +      HostAdapter->TerminationInfoValid = true;
  2.1522 +      HostAdapter->LowByteTerminated = FlashPointInfo->LowByteTerminated;
  2.1523 +      HostAdapter->HighByteTerminated = FlashPointInfo->HighByteTerminated;
  2.1524 +      HostAdapter->SCAM_Enabled = FlashPointInfo->SCAM_Enabled;
  2.1525 +      HostAdapter->SCAM_Level2 = FlashPointInfo->SCAM_Level2;
  2.1526 +      HostAdapter->DriverScatterGatherLimit = BusLogic_ScatterGatherLimit;
  2.1527 +      HostAdapter->MaxTargetDevices = (HostAdapter->HostWideSCSI ? 16 : 8);
  2.1528 +      HostAdapter->MaxLogicalUnits = 32;
  2.1529 +      HostAdapter->InitialCCBs = 4 * BusLogic_CCB_AllocationGroupSize;
  2.1530 +      HostAdapter->IncrementalCCBs = BusLogic_CCB_AllocationGroupSize;
  2.1531 +      HostAdapter->DriverQueueDepth = 255;
  2.1532 +      HostAdapter->HostAdapterQueueDepth = HostAdapter->DriverQueueDepth;
  2.1533 +      HostAdapter->SynchronousPermitted = FlashPointInfo->SynchronousPermitted;
  2.1534 +      HostAdapter->FastPermitted = FlashPointInfo->FastPermitted;
  2.1535 +      HostAdapter->UltraPermitted = FlashPointInfo->UltraPermitted;
  2.1536 +      HostAdapter->WidePermitted = FlashPointInfo->WidePermitted;
  2.1537 +      HostAdapter->DisconnectPermitted = FlashPointInfo->DisconnectPermitted;
  2.1538 +      HostAdapter->TaggedQueuingPermitted = 0xFFFF;
  2.1539 +      goto Common;
  2.1540 +    }
  2.1541 +  /*
  2.1542 +    Issue the Inquire Board ID command.
  2.1543 +  */
  2.1544 +  if (BusLogic_Command(HostAdapter, BusLogic_InquireBoardID, NULL, 0,
  2.1545 +		       &BoardID, sizeof(BoardID)) != sizeof(BoardID))
  2.1546 +    return BusLogic_Failure(HostAdapter, "INQUIRE BOARD ID");
  2.1547 +  /*
  2.1548 +    Issue the Inquire Configuration command.
  2.1549 +  */
  2.1550 +  if (BusLogic_Command(HostAdapter, BusLogic_InquireConfiguration, NULL, 0,
  2.1551 +		       &Configuration, sizeof(Configuration))
  2.1552 +      != sizeof(Configuration))
  2.1553 +    return BusLogic_Failure(HostAdapter, "INQUIRE CONFIGURATION");
  2.1554 +  /*
  2.1555 +    Issue the Inquire Setup Information command.
  2.1556 +  */
  2.1557 +  RequestedReplyLength = sizeof(SetupInformation);
  2.1558 +  if (BusLogic_Command(HostAdapter, BusLogic_InquireSetupInformation,
  2.1559 +		       &RequestedReplyLength, sizeof(RequestedReplyLength),
  2.1560 +		       &SetupInformation, sizeof(SetupInformation))
  2.1561 +      != sizeof(SetupInformation))
  2.1562 +    return BusLogic_Failure(HostAdapter, "INQUIRE SETUP INFORMATION");
  2.1563 +  /*
  2.1564 +    Issue the Inquire Extended Setup Information command.
  2.1565 +  */
  2.1566 +  RequestedReplyLength = sizeof(ExtendedSetupInformation);
  2.1567 +  if (BusLogic_Command(HostAdapter, BusLogic_InquireExtendedSetupInformation,
  2.1568 +		       &RequestedReplyLength, sizeof(RequestedReplyLength),
  2.1569 +		       &ExtendedSetupInformation,
  2.1570 +		       sizeof(ExtendedSetupInformation))
  2.1571 +      != sizeof(ExtendedSetupInformation))
  2.1572 +    return BusLogic_Failure(HostAdapter, "INQUIRE EXTENDED SETUP INFORMATION");
  2.1573 +  /*
  2.1574 +    Issue the Inquire Firmware Version 3rd Digit command.
  2.1575 +  */
  2.1576 +  FirmwareVersion3rdDigit = '\0';
  2.1577 +  if (BoardID.FirmwareVersion1stDigit > '0')
  2.1578 +    if (BusLogic_Command(HostAdapter, BusLogic_InquireFirmwareVersion3rdDigit,
  2.1579 +			 NULL, 0, &FirmwareVersion3rdDigit,
  2.1580 +			 sizeof(FirmwareVersion3rdDigit))
  2.1581 +	!= sizeof(FirmwareVersion3rdDigit))
  2.1582 +      return BusLogic_Failure(HostAdapter, "INQUIRE FIRMWARE 3RD DIGIT");
  2.1583 +  /*
  2.1584 +    Issue the Inquire Host Adapter Model Number command.
  2.1585 +  */
  2.1586 +  if (ExtendedSetupInformation.BusType == 'A' &&
  2.1587 +      BoardID.FirmwareVersion1stDigit == '2')
  2.1588 +    /* BusLogic BT-542B ISA 2.xx */
  2.1589 +    strcpy(HostAdapterModelNumber, "542B");
  2.1590 +  else if (ExtendedSetupInformation.BusType == 'E' &&
  2.1591 +	   BoardID.FirmwareVersion1stDigit == '2' &&
  2.1592 +	   (BoardID.FirmwareVersion2ndDigit <= '1' ||
  2.1593 +	    (BoardID.FirmwareVersion2ndDigit == '2' &&
  2.1594 +	     FirmwareVersion3rdDigit == '0')))
  2.1595 +    /* BusLogic BT-742A EISA 2.1x or 2.20 */
  2.1596 +    strcpy(HostAdapterModelNumber, "742A");
  2.1597 +  else if (ExtendedSetupInformation.BusType == 'E' &&
  2.1598 +	   BoardID.FirmwareVersion1stDigit == '0')
  2.1599 +    /* AMI FastDisk EISA Series 441 0.x */
  2.1600 +    strcpy(HostAdapterModelNumber, "747A");
  2.1601 +  else
  2.1602 +    {
  2.1603 +      RequestedReplyLength = sizeof(HostAdapterModelNumber);
  2.1604 +      if (BusLogic_Command(HostAdapter, BusLogic_InquireHostAdapterModelNumber,
  2.1605 +			   &RequestedReplyLength, sizeof(RequestedReplyLength),
  2.1606 +			   &HostAdapterModelNumber,
  2.1607 +			   sizeof(HostAdapterModelNumber))
  2.1608 +	  != sizeof(HostAdapterModelNumber))
  2.1609 +	return BusLogic_Failure(HostAdapter,
  2.1610 +				"INQUIRE HOST ADAPTER MODEL NUMBER");
  2.1611 +    }
  2.1612 +  /*
  2.1613 +    BusLogic MultiMaster Host Adapters can be identified by their model number
  2.1614 +    and the major version number of their firmware as follows:
  2.1615 +
  2.1616 +    5.xx	BusLogic "W" Series Host Adapters:
  2.1617 +		  BT-948/958/958D
  2.1618 +    4.xx	BusLogic "C" Series Host Adapters:
  2.1619 +		  BT-946C/956C/956CD/747C/757C/757CD/445C/545C/540CF
  2.1620 +    3.xx	BusLogic "S" Series Host Adapters:
  2.1621 +		  BT-747S/747D/757S/757D/445S/545S/542D
  2.1622 +		  BT-542B/742A (revision H)
  2.1623 +    2.xx	BusLogic "A" Series Host Adapters:
  2.1624 +		  BT-542B/742A (revision G and below)
  2.1625 +    0.xx	AMI FastDisk VLB/EISA BusLogic Clone Host Adapter
  2.1626 +  */
  2.1627 +  /*
  2.1628 +    Save the Model Name and Host Adapter Name in the Host Adapter structure.
  2.1629 +  */
  2.1630 +  TargetPointer = HostAdapter->ModelName;
  2.1631 +  *TargetPointer++ = 'B';
  2.1632 +  *TargetPointer++ = 'T';
  2.1633 +  *TargetPointer++ = '-';
  2.1634 +  for (i = 0; i < sizeof(HostAdapterModelNumber); i++)
  2.1635 +    {
  2.1636 +      Character = HostAdapterModelNumber[i];
  2.1637 +      if (Character == ' ' || Character == '\0') break;
  2.1638 +      *TargetPointer++ = Character;
  2.1639 +    }
  2.1640 +  *TargetPointer++ = '\0';
  2.1641 +  /*
  2.1642 +    Save the Firmware Version in the Host Adapter structure.
  2.1643 +  */
  2.1644 +  TargetPointer = HostAdapter->FirmwareVersion;
  2.1645 +  *TargetPointer++ = BoardID.FirmwareVersion1stDigit;
  2.1646 +  *TargetPointer++ = '.';
  2.1647 +  *TargetPointer++ = BoardID.FirmwareVersion2ndDigit;
  2.1648 +  if (FirmwareVersion3rdDigit != ' ' && FirmwareVersion3rdDigit != '\0')
  2.1649 +    *TargetPointer++ = FirmwareVersion3rdDigit;
  2.1650 +  *TargetPointer = '\0';
  2.1651 +  /*
  2.1652 +    Issue the Inquire Firmware Version Letter command.
  2.1653 +  */
  2.1654 +  if (strcmp(HostAdapter->FirmwareVersion, "3.3") >= 0)
  2.1655 +    {
  2.1656 +      if (BusLogic_Command(HostAdapter, BusLogic_InquireFirmwareVersionLetter,
  2.1657 +			   NULL, 0, &FirmwareVersionLetter,
  2.1658 +			   sizeof(FirmwareVersionLetter))
  2.1659 +	  != sizeof(FirmwareVersionLetter))
  2.1660 +	return BusLogic_Failure(HostAdapter,
  2.1661 +				"INQUIRE FIRMWARE VERSION LETTER");
  2.1662 +      if (FirmwareVersionLetter != ' ' && FirmwareVersionLetter != '\0')
  2.1663 +	*TargetPointer++ = FirmwareVersionLetter;
  2.1664 +      *TargetPointer = '\0';
  2.1665 +    }
  2.1666 +  /*
  2.1667 +    Save the Host Adapter SCSI ID in the Host Adapter structure.
  2.1668 +  */
  2.1669 +  HostAdapter->SCSI_ID = Configuration.HostAdapterID;
  2.1670 +  /*
  2.1671 +    Determine the Bus Type and save it in the Host Adapter structure, determine
  2.1672 +    and save the IRQ Channel if necessary, and determine and save the DMA
  2.1673 +    Channel for ISA Host Adapters.
  2.1674 +  */
  2.1675 +  HostAdapter->HostAdapterBusType =
  2.1676 +    BusLogic_HostAdapterBusTypes[HostAdapter->ModelName[3] - '4'];
  2.1677 +  if (HostAdapter->IRQ_Channel == 0)
  2.1678 +    {
  2.1679 +      if (Configuration.IRQ_Channel9)
  2.1680 +	HostAdapter->IRQ_Channel = 9;
  2.1681 +      else if (Configuration.IRQ_Channel10)
  2.1682 +	HostAdapter->IRQ_Channel = 10;
  2.1683 +      else if (Configuration.IRQ_Channel11)
  2.1684 +	HostAdapter->IRQ_Channel = 11;
  2.1685 +      else if (Configuration.IRQ_Channel12)
  2.1686 +	HostAdapter->IRQ_Channel = 12;
  2.1687 +      else if (Configuration.IRQ_Channel14)
  2.1688 +	HostAdapter->IRQ_Channel = 14;
  2.1689 +      else if (Configuration.IRQ_Channel15)
  2.1690 +	HostAdapter->IRQ_Channel = 15;
  2.1691 +    }
  2.1692 +  if (HostAdapter->HostAdapterBusType == BusLogic_ISA_Bus)
  2.1693 +    {
  2.1694 +      if (Configuration.DMA_Channel5)
  2.1695 +	HostAdapter->DMA_Channel = 5;
  2.1696 +      else if (Configuration.DMA_Channel6)
  2.1697 +	HostAdapter->DMA_Channel = 6;
  2.1698 +      else if (Configuration.DMA_Channel7)
  2.1699 +	HostAdapter->DMA_Channel = 7;
  2.1700 +    }
  2.1701 +  /*
  2.1702 +    Determine whether Extended Translation is enabled and save it in
  2.1703 +    the Host Adapter structure.
  2.1704 +  */
  2.1705 +  GeometryRegister.All = BusLogic_ReadGeometryRegister(HostAdapter);
  2.1706 +  HostAdapter->ExtendedTranslationEnabled =
  2.1707 +    GeometryRegister.Bits.ExtendedTranslationEnabled;
  2.1708 +  /*
  2.1709 +    Save the Scatter Gather Limits, Level Sensitive Interrupt flag, Wide
  2.1710 +    SCSI flag, Differential SCSI flag, SCAM Supported flag, and
  2.1711 +    Ultra SCSI flag in the Host Adapter structure.
  2.1712 +  */
  2.1713 +  HostAdapter->HostAdapterScatterGatherLimit =
  2.1714 +    ExtendedSetupInformation.ScatterGatherLimit;
  2.1715 +  HostAdapter->DriverScatterGatherLimit =
  2.1716 +    HostAdapter->HostAdapterScatterGatherLimit;
  2.1717 +  if (HostAdapter->HostAdapterScatterGatherLimit > BusLogic_ScatterGatherLimit)
  2.1718 +    HostAdapter->DriverScatterGatherLimit = BusLogic_ScatterGatherLimit;
  2.1719 +  if (ExtendedSetupInformation.Misc.LevelSensitiveInterrupt)
  2.1720 +    HostAdapter->LevelSensitiveInterrupt = true;
  2.1721 +  HostAdapter->HostWideSCSI = ExtendedSetupInformation.HostWideSCSI;
  2.1722 +  HostAdapter->HostDifferentialSCSI =
  2.1723 +    ExtendedSetupInformation.HostDifferentialSCSI;
  2.1724 +  HostAdapter->HostSupportsSCAM = ExtendedSetupInformation.HostSupportsSCAM;
  2.1725 +  HostAdapter->HostUltraSCSI = ExtendedSetupInformation.HostUltraSCSI;
  2.1726 +  /*
  2.1727 +    Determine whether Extended LUN Format CCBs are supported and save the
  2.1728 +    information in the Host Adapter structure.
  2.1729 +  */
  2.1730 +  if (HostAdapter->FirmwareVersion[0] == '5' ||
  2.1731 +      (HostAdapter->FirmwareVersion[0] == '4' && HostAdapter->HostWideSCSI))
  2.1732 +    HostAdapter->ExtendedLUNSupport = true;
  2.1733 +  /*
  2.1734 +    Issue the Inquire PCI Host Adapter Information command to read the
  2.1735 +    Termination Information from "W" series MultiMaster Host Adapters.
  2.1736 +  */
  2.1737 +  if (HostAdapter->FirmwareVersion[0] == '5')
  2.1738 +    {
  2.1739 +      if (BusLogic_Command(HostAdapter,
  2.1740 +			   BusLogic_InquirePCIHostAdapterInformation,
  2.1741 +			   NULL, 0, &PCIHostAdapterInformation,
  2.1742 +			   sizeof(PCIHostAdapterInformation))
  2.1743 +	  != sizeof(PCIHostAdapterInformation))
  2.1744 +	return BusLogic_Failure(HostAdapter,
  2.1745 +				"INQUIRE PCI HOST ADAPTER INFORMATION");
  2.1746 +      /*
  2.1747 +	Save the Termination Information in the Host Adapter structure.
  2.1748 +      */
  2.1749 +      if (PCIHostAdapterInformation.GenericInfoValid)
  2.1750 +	{
  2.1751 +	  HostAdapter->TerminationInfoValid = true;
  2.1752 +	  HostAdapter->LowByteTerminated =
  2.1753 +	    PCIHostAdapterInformation.LowByteTerminated;
  2.1754 +	  HostAdapter->HighByteTerminated =
  2.1755 +	    PCIHostAdapterInformation.HighByteTerminated;
  2.1756 +	}
  2.1757 +    }
  2.1758 +  /*
  2.1759 +    Issue the Fetch Host Adapter Local RAM command to read the AutoSCSI data
  2.1760 +    from "W" and "C" series MultiMaster Host Adapters.
  2.1761 +  */
  2.1762 +  if (HostAdapter->FirmwareVersion[0] >= '4')
  2.1763 +    {
  2.1764 +      FetchHostAdapterLocalRAMRequest.ByteOffset =
  2.1765 +	BusLogic_AutoSCSI_BaseOffset;
  2.1766 +      FetchHostAdapterLocalRAMRequest.ByteCount = sizeof(AutoSCSIData);
  2.1767 +      if (BusLogic_Command(HostAdapter,
  2.1768 +			   BusLogic_FetchHostAdapterLocalRAM,
  2.1769 +			   &FetchHostAdapterLocalRAMRequest,
  2.1770 +			   sizeof(FetchHostAdapterLocalRAMRequest),
  2.1771 +			   &AutoSCSIData, sizeof(AutoSCSIData))
  2.1772 +	  != sizeof(AutoSCSIData))
  2.1773 +	return BusLogic_Failure(HostAdapter, "FETCH HOST ADAPTER LOCAL RAM");
  2.1774 +      /*
  2.1775 +	Save the Parity Checking Enabled, Bus Reset Enabled, and Termination
  2.1776 +	Information in the Host Adapter structure.
  2.1777 +      */
  2.1778 +      HostAdapter->ParityCheckingEnabled = AutoSCSIData.ParityCheckingEnabled;
  2.1779 +      HostAdapter->BusResetEnabled = AutoSCSIData.BusResetEnabled;
  2.1780 +      if (HostAdapter->FirmwareVersion[0] == '4')
  2.1781 +	{
  2.1782 +	  HostAdapter->TerminationInfoValid = true;
  2.1783 +	  HostAdapter->LowByteTerminated = AutoSCSIData.LowByteTerminated;
  2.1784 +	  HostAdapter->HighByteTerminated = AutoSCSIData.HighByteTerminated;
  2.1785 +	}
  2.1786 +      /*
  2.1787 +	Save the Wide Permitted, Fast Permitted, Synchronous Permitted,
  2.1788 +	Disconnect Permitted, Ultra Permitted, and SCAM Information in the
  2.1789 +	Host Adapter structure.
  2.1790 +      */
  2.1791 +      HostAdapter->WidePermitted = AutoSCSIData.WidePermitted;
  2.1792 +      HostAdapter->FastPermitted = AutoSCSIData.FastPermitted;
  2.1793 +      HostAdapter->SynchronousPermitted =
  2.1794 +	AutoSCSIData.SynchronousPermitted;
  2.1795 +      HostAdapter->DisconnectPermitted =
  2.1796 +	AutoSCSIData.DisconnectPermitted;
  2.1797 +      if (HostAdapter->HostUltraSCSI)
  2.1798 +	HostAdapter->UltraPermitted = AutoSCSIData.UltraPermitted;
  2.1799 +      if (HostAdapter->HostSupportsSCAM)
  2.1800 +	{
  2.1801 +	  HostAdapter->SCAM_Enabled = AutoSCSIData.SCAM_Enabled;
  2.1802 +	  HostAdapter->SCAM_Level2 = AutoSCSIData.SCAM_Level2;
  2.1803 +	}
  2.1804 +    }
  2.1805 +  /*
  2.1806 +    Initialize fields in the Host Adapter structure for "S" and "A" series
  2.1807 +    MultiMaster Host Adapters.
  2.1808 +  */
  2.1809 +  if (HostAdapter->FirmwareVersion[0] < '4')
  2.1810 +    {
  2.1811 +      if (SetupInformation.SynchronousInitiationEnabled)
  2.1812 +	{
  2.1813 +	  HostAdapter->SynchronousPermitted = 0xFF;
  2.1814 +	  if (HostAdapter->HostAdapterBusType == BusLogic_EISA_Bus)
  2.1815 +	    {
  2.1816 +	      if (ExtendedSetupInformation.Misc.FastOnEISA)
  2.1817 +		HostAdapter->FastPermitted = 0xFF;
  2.1818 +	      if (strcmp(HostAdapter->ModelName, "BT-757") == 0)
  2.1819 +		HostAdapter->WidePermitted = 0xFF;
  2.1820 +	    }
  2.1821 +	}
  2.1822 +      HostAdapter->DisconnectPermitted = 0xFF;
  2.1823 +      HostAdapter->ParityCheckingEnabled =
  2.1824 +	SetupInformation.ParityCheckingEnabled;
  2.1825 +      HostAdapter->BusResetEnabled = true;
  2.1826 +    }
  2.1827 +  /*
  2.1828 +    Determine the maximum number of Target IDs and Logical Units supported by
  2.1829 +    this driver for Wide and Narrow Host Adapters.
  2.1830 +  */
  2.1831 +  HostAdapter->MaxTargetDevices = (HostAdapter->HostWideSCSI ? 16 : 8);
  2.1832 +  HostAdapter->MaxLogicalUnits = (HostAdapter->ExtendedLUNSupport ? 32 : 8);
  2.1833 +  /*
  2.1834 +    Select appropriate values for the Mailbox Count, Driver Queue Depth,
  2.1835 +    Initial CCBs, and Incremental CCBs variables based on whether or not Strict
  2.1836 +    Round Robin Mode is supported.  If Strict Round Robin Mode is supported,
  2.1837 +    then there is no performance degradation in using the maximum possible
  2.1838 +    number of Outgoing and Incoming Mailboxes and allowing the Tagged and
  2.1839 +    Untagged Queue Depths to determine the actual utilization.  If Strict Round
  2.1840 +    Robin Mode is not supported, then the Host Adapter must scan all the
  2.1841 +    Outgoing Mailboxes whenever an Outgoing Mailbox entry is made, which can
  2.1842 +    cause a substantial performance penalty.  The host adapters actually have
  2.1843 +    room to store the following number of CCBs internally; that is, they can
  2.1844 +    internally queue and manage this many active commands on the SCSI bus
  2.1845 +    simultaneously.  Performance measurements demonstrate that the Driver Queue
  2.1846 +    Depth should be set to the Mailbox Count, rather than the Host Adapter
  2.1847 +    Queue Depth (internal CCB capacity), as it is more efficient to have the
  2.1848 +    queued commands waiting in Outgoing Mailboxes if necessary than to block
  2.1849 +    the process in the higher levels of the SCSI Subsystem.
  2.1850 +
  2.1851 +	192	  BT-948/958/958D
  2.1852 +	100	  BT-946C/956C/956CD/747C/757C/757CD/445C
  2.1853 +	 50	  BT-545C/540CF
  2.1854 +	 30	  BT-747S/747D/757S/757D/445S/545S/542D/542B/742A
  2.1855 +  */
  2.1856 +  if (HostAdapter->FirmwareVersion[0] == '5')
  2.1857 +    HostAdapter->HostAdapterQueueDepth = 192;
  2.1858 +  else if (HostAdapter->FirmwareVersion[0] == '4')
  2.1859 +    HostAdapter->HostAdapterQueueDepth =
  2.1860 +      (HostAdapter->HostAdapterBusType != BusLogic_ISA_Bus ? 100 : 50);
  2.1861 +  else HostAdapter->HostAdapterQueueDepth = 30;
  2.1862 +  if (strcmp(HostAdapter->FirmwareVersion, "3.31") >= 0)
  2.1863 +    {
  2.1864 +      HostAdapter->StrictRoundRobinModeSupport = true;
  2.1865 +      HostAdapter->MailboxCount = BusLogic_MaxMailboxes;
  2.1866 +    }
  2.1867 +  else
  2.1868 +    {
  2.1869 +      HostAdapter->StrictRoundRobinModeSupport = false;
  2.1870 +      HostAdapter->MailboxCount = 32;
  2.1871 +    }
  2.1872 +  HostAdapter->DriverQueueDepth = HostAdapter->MailboxCount;
  2.1873 +  HostAdapter->InitialCCBs = 4 * BusLogic_CCB_AllocationGroupSize;
  2.1874 +  HostAdapter->IncrementalCCBs = BusLogic_CCB_AllocationGroupSize;
  2.1875 +  /*
  2.1876 +    Tagged Queuing support is available and operates properly on all "W" series
  2.1877 +    MultiMaster Host Adapters, on "C" series MultiMaster Host Adapters with
  2.1878 +    firmware version 4.22 and above, and on "S" series MultiMaster Host
  2.1879 +    Adapters with firmware version 3.35 and above.
  2.1880 +  */
  2.1881 +  HostAdapter->TaggedQueuingPermitted = 0;
  2.1882 +  switch (HostAdapter->FirmwareVersion[0])
  2.1883 +    {
  2.1884 +    case '5':
  2.1885 +      HostAdapter->TaggedQueuingPermitted = 0xFFFF;
  2.1886 +      break;
  2.1887 +    case '4':
  2.1888 +      if (strcmp(HostAdapter->FirmwareVersion, "4.22") >= 0)
  2.1889 +	HostAdapter->TaggedQueuingPermitted = 0xFFFF;
  2.1890 +      break;
  2.1891 +    case '3':
  2.1892 +      if (strcmp(HostAdapter->FirmwareVersion, "3.35") >= 0)
  2.1893 +	HostAdapter->TaggedQueuingPermitted = 0xFFFF;
  2.1894 +      break;
  2.1895 +    }
  2.1896 +  /*
  2.1897 +    Determine the Host Adapter BIOS Address if the BIOS is enabled and
  2.1898 +    save it in the Host Adapter structure.  The BIOS is disabled if the
  2.1899 +    BIOS_Address is 0.
  2.1900 +  */
  2.1901 +  HostAdapter->BIOS_Address = ExtendedSetupInformation.BIOS_Address << 12;
  2.1902 +  /*
  2.1903 +    ISA Host Adapters require Bounce Buffers if there is more than 16MB memory.
  2.1904 +  */
  2.1905 +  if (HostAdapter->HostAdapterBusType == BusLogic_ISA_Bus &&
  2.1906 +      /*(void *) high_memory > (void *) MAX_DMA_ADDRESS*/ 1)
  2.1907 +    HostAdapter->BounceBuffersRequired = true;
  2.1908 +  /*
  2.1909 +    BusLogic BT-445S Host Adapters prior to board revision E have a hardware
  2.1910 +    bug whereby when the BIOS is enabled, transfers to/from the same address
  2.1911 +    range the BIOS occupies modulo 16MB are handled incorrectly.  Only properly
  2.1912 +    functioning BT-445S Host Adapters have firmware version 3.37, so require
  2.1913 +    that ISA Bounce Buffers be used for the buggy BT-445S models if there is
  2.1914 +    more than 16MB memory.
  2.1915 +  */
  2.1916 +  if (HostAdapter->BIOS_Address > 0 &&
  2.1917 +      strcmp(HostAdapter->ModelName, "BT-445S") == 0 &&
  2.1918 +      strcmp(HostAdapter->FirmwareVersion, "3.37") < 0 &&
  2.1919 +      /*(void *) high_memory > (void *) MAX_DMA_ADDRESS*/ 1)
  2.1920 +    HostAdapter->BounceBuffersRequired = true;
  2.1921 +  /*
  2.1922 +    Initialize parameters common to MultiMaster and FlashPoint Host Adapters.
  2.1923 +  */
  2.1924 +Common:
  2.1925 +  /*
  2.1926 +    Initialize the Host Adapter Full Model Name from the Model Name.
  2.1927 +  */
  2.1928 +  strcpy(HostAdapter->FullModelName, "BusLogic ");
  2.1929 +  strcat(HostAdapter->FullModelName, HostAdapter->ModelName);
  2.1930 +  /*
  2.1931 +    Select an appropriate value for the Tagged Queue Depth either from a
  2.1932 +    BusLogic Driver Options specification, or based on whether this Host
  2.1933 +    Adapter requires that ISA Bounce Buffers be used.  The Tagged Queue Depth
  2.1934 +    is left at 0 for automatic determination in BusLogic_SelectQueueDepths.
  2.1935 +    Initialize the Untagged Queue Depth.
  2.1936 +  */
  2.1937 +  for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++)
  2.1938 +    {
  2.1939 +      unsigned char QueueDepth = 0;
  2.1940 +      if (HostAdapter->DriverOptions != NULL &&
  2.1941 +	  HostAdapter->DriverOptions->QueueDepth[TargetID] > 0)
  2.1942 +	QueueDepth = HostAdapter->DriverOptions->QueueDepth[TargetID];
  2.1943 +      else if (HostAdapter->BounceBuffersRequired)
  2.1944 +	QueueDepth = BusLogic_TaggedQueueDepthBB;
  2.1945 +      HostAdapter->QueueDepth[TargetID] = QueueDepth;
  2.1946 +    }
  2.1947 +  if (HostAdapter->BounceBuffersRequired)
  2.1948 +    HostAdapter->UntaggedQueueDepth = BusLogic_UntaggedQueueDepthBB;
  2.1949 +  else HostAdapter->UntaggedQueueDepth = BusLogic_UntaggedQueueDepth;
  2.1950 +  if (HostAdapter->DriverOptions != NULL)
  2.1951 +    HostAdapter->CommonQueueDepth =
  2.1952 +      HostAdapter->DriverOptions->CommonQueueDepth;
  2.1953 +  if (HostAdapter->CommonQueueDepth > 0 &&
  2.1954 +      HostAdapter->CommonQueueDepth < HostAdapter->UntaggedQueueDepth)
  2.1955 +    HostAdapter->UntaggedQueueDepth = HostAdapter->CommonQueueDepth;
  2.1956 +  /*
  2.1957 +    Tagged Queuing is only allowed if Disconnect/Reconnect is permitted.
  2.1958 +    Therefore, mask the Tagged Queuing Permitted Default bits with the
  2.1959 +    Disconnect/Reconnect Permitted bits.
  2.1960 +  */
  2.1961 +  HostAdapter->TaggedQueuingPermitted &= HostAdapter->DisconnectPermitted;
  2.1962 +  /*
  2.1963 +    Combine the default Tagged Queuing Permitted bits with any BusLogic Driver
  2.1964 +    Options Tagged Queuing specification.
  2.1965 +  */
  2.1966 +  if (HostAdapter->DriverOptions != NULL)
  2.1967 +    HostAdapter->TaggedQueuingPermitted =
  2.1968 +      (HostAdapter->DriverOptions->TaggedQueuingPermitted &
  2.1969 +       HostAdapter->DriverOptions->TaggedQueuingPermittedMask) |
  2.1970 +      (HostAdapter->TaggedQueuingPermitted &
  2.1971 +       ~HostAdapter->DriverOptions->TaggedQueuingPermittedMask);
  2.1972 +  /*
  2.1973 +    Select appropriate values for the Error Recovery Strategy array
  2.1974 +    either from a BusLogic Driver Options specification, or using
  2.1975 +    BusLogic_ErrorRecovery_Default.
  2.1976 +  */
  2.1977 +  for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++)
  2.1978 +    if (HostAdapter->DriverOptions != NULL)
  2.1979 +      HostAdapter->ErrorRecoveryStrategy[TargetID] =
  2.1980 +	HostAdapter->DriverOptions->ErrorRecoveryStrategy[TargetID];
  2.1981 +    else HostAdapter->ErrorRecoveryStrategy[TargetID] =
  2.1982 +	   BusLogic_ErrorRecovery_Default;
  2.1983 +  /*
  2.1984 +    Select an appropriate value for Bus Settle Time either from a BusLogic
  2.1985 +    Driver Options specification, or from BusLogic_DefaultBusSettleTime.
  2.1986 +  */
  2.1987 +  if (HostAdapter->DriverOptions != NULL &&
  2.1988 +      HostAdapter->DriverOptions->BusSettleTime > 0)
  2.1989 +    HostAdapter->BusSettleTime = HostAdapter->DriverOptions->BusSettleTime;
  2.1990 +  else HostAdapter->BusSettleTime = BusLogic_DefaultBusSettleTime;
  2.1991 +  /*
  2.1992 +    Indicate reading the Host Adapter Configuration completed successfully.
  2.1993 +  */
  2.1994 +  return true;
  2.1995 +}
  2.1996 +
  2.1997 +
  2.1998 +/*
  2.1999 +  BusLogic_ReportHostAdapterConfiguration reports the configuration of
  2.2000 +  Host Adapter.
  2.2001 +*/
  2.2002 +
  2.2003 +static boolean BusLogic_ReportHostAdapterConfiguration(BusLogic_HostAdapter_T
  2.2004 +						       *HostAdapter)
  2.2005 +{
  2.2006 +  unsigned short AllTargetsMask = (1 << HostAdapter->MaxTargetDevices) - 1;
  2.2007 +  unsigned short SynchronousPermitted, FastPermitted;
  2.2008 +  unsigned short UltraPermitted, WidePermitted;
  2.2009 +  unsigned short DisconnectPermitted, TaggedQueuingPermitted;
  2.2010 +  boolean CommonSynchronousNegotiation, CommonTaggedQueueDepth;
  2.2011 +  boolean CommonErrorRecovery;
  2.2012 +  char SynchronousString[BusLogic_MaxTargetDevices+1];
  2.2013 +  char WideString[BusLogic_MaxTargetDevices+1];
  2.2014 +  char DisconnectString[BusLogic_MaxTargetDevices+1];
  2.2015 +  char TaggedQueuingString[BusLogic_MaxTargetDevices+1];
  2.2016 +  char ErrorRecoveryString[BusLogic_MaxTargetDevices+1];
  2.2017 +  char *SynchronousMessage = SynchronousString;
  2.2018 +  char *WideMessage = WideString;
  2.2019 +  char *DisconnectMessage = DisconnectString;
  2.2020 +  char *TaggedQueuingMessage = TaggedQueuingString;
  2.2021 +  char *ErrorRecoveryMessage = ErrorRecoveryString;
  2.2022 +  int TargetID;
  2.2023 +  BusLogic_Info("Configuring BusLogic Model %s %s%s%s%s SCSI Host Adapter\n",
  2.2024 +		HostAdapter, HostAdapter->ModelName,
  2.2025 +		BusLogic_HostAdapterBusNames[HostAdapter->HostAdapterBusType],
  2.2026 +		(HostAdapter->HostWideSCSI ? " Wide" : ""),
  2.2027 +		(HostAdapter->HostDifferentialSCSI ? " Differential" : ""),
  2.2028 +		(HostAdapter->HostUltraSCSI ? " Ultra" : ""));
  2.2029 +  BusLogic_Info("  Firmware Version: %s, I/O Address: 0x%X, "
  2.2030 +		"IRQ Channel: %d/%s\n", HostAdapter,
  2.2031 +		HostAdapter->FirmwareVersion,
  2.2032 +		HostAdapter->IO_Address, HostAdapter->IRQ_Channel,
  2.2033 +		(HostAdapter->LevelSensitiveInterrupt ? "Level" : "Edge"));
  2.2034 +  if (HostAdapter->HostAdapterBusType != BusLogic_PCI_Bus)
  2.2035 +    {
  2.2036 +      BusLogic_Info("  DMA Channel: ", HostAdapter);
  2.2037 +      if (HostAdapter->DMA_Channel > 0)
  2.2038 +	BusLogic_Info("%d, ", HostAdapter, HostAdapter->DMA_Channel);
  2.2039 +      else BusLogic_Info("None, ", HostAdapter);
  2.2040 +      if (HostAdapter->BIOS_Address > 0)
  2.2041 +	BusLogic_Info("BIOS Address: 0x%X, ", HostAdapter,
  2.2042 +		      HostAdapter->BIOS_Address);
  2.2043 +      else BusLogic_Info("BIOS Address: None, ", HostAdapter);
  2.2044 +    }
  2.2045 +  else
  2.2046 +    {
  2.2047 +      BusLogic_Info("  PCI Bus: %d, Device: %d, Address: ",
  2.2048 +		    HostAdapter, HostAdapter->Bus, HostAdapter->Device);
  2.2049 +      if (HostAdapter->PCI_Address > 0)
  2.2050 +	BusLogic_Info("0x%X, ", HostAdapter, HostAdapter->PCI_Address);
  2.2051 +      else BusLogic_Info("Unassigned, ", HostAdapter);
  2.2052 +    }
  2.2053 +  BusLogic_Info("Host Adapter SCSI ID: %d\n", HostAdapter,
  2.2054 +		HostAdapter->SCSI_ID);
  2.2055 +  BusLogic_Info("  Parity Checking: %s, Extended Translation: %s\n",
  2.2056 +		HostAdapter,
  2.2057 +		(HostAdapter->ParityCheckingEnabled
  2.2058 +		 ? "Enabled" : "Disabled"),
  2.2059 +		(HostAdapter->ExtendedTranslationEnabled
  2.2060 +		 ? "Enabled" : "Disabled"));
  2.2061 +  AllTargetsMask &= ~(1 << HostAdapter->SCSI_ID);
  2.2062 +  SynchronousPermitted = HostAdapter->SynchronousPermitted & AllTargetsMask;
  2.2063 +  FastPermitted = HostAdapter->FastPermitted & AllTargetsMask;
  2.2064 +  UltraPermitted = HostAdapter->UltraPermitted & AllTargetsMask;
  2.2065 +  if ((BusLogic_MultiMasterHostAdapterP(HostAdapter) &&
  2.2066 +       (HostAdapter->FirmwareVersion[0] >= '4' ||
  2.2067 +	HostAdapter->HostAdapterBusType == BusLogic_EISA_Bus)) ||
  2.2068 +      BusLogic_FlashPointHostAdapterP(HostAdapter))
  2.2069 +    {
  2.2070 +      CommonSynchronousNegotiation = false;
  2.2071 +      if (SynchronousPermitted == 0)
  2.2072 +	{
  2.2073 +	  SynchronousMessage = "Disabled";
  2.2074 +	  CommonSynchronousNegotiation = true;
  2.2075 +	}
  2.2076 +      else if (SynchronousPermitted == AllTargetsMask)
  2.2077 +	{
  2.2078 +	  if (FastPermitted == 0)
  2.2079 +	    {
  2.2080 +	      SynchronousMessage = "Slow";
  2.2081 +	      CommonSynchronousNegotiation = true;
  2.2082 +	    }
  2.2083 +	  else if (FastPermitted == AllTargetsMask)
  2.2084 +	    {
  2.2085 +	      if (UltraPermitted == 0)
  2.2086 +		{
  2.2087 +		  SynchronousMessage = "Fast";
  2.2088 +		  CommonSynchronousNegotiation = true;
  2.2089 +		}
  2.2090 +	      else if (UltraPermitted == AllTargetsMask)
  2.2091 +		{
  2.2092 +		  SynchronousMessage = "Ultra";
  2.2093 +		  CommonSynchronousNegotiation = true;
  2.2094 +		}
  2.2095 +	    }
  2.2096 +	}
  2.2097 +      if (!CommonSynchronousNegotiation)
  2.2098 +	{
  2.2099 +	  for (TargetID = 0;
  2.2100 +	       TargetID < HostAdapter->MaxTargetDevices;
  2.2101 +	       TargetID++)
  2.2102 +	    SynchronousString[TargetID] =
  2.2103 +	      ((!(SynchronousPermitted & (1 << TargetID))) ? 'N' :
  2.2104 +	       (!(FastPermitted & (1 << TargetID)) ? 'S' :
  2.2105 +		(!(UltraPermitted & (1 << TargetID)) ? 'F' : 'U')));
  2.2106 +	  SynchronousString[HostAdapter->SCSI_ID] = '#';
  2.2107 +	  SynchronousString[HostAdapter->MaxTargetDevices] = '\0';
  2.2108 +	}
  2.2109 +    }
  2.2110 +  else SynchronousMessage =
  2.2111 +	 (SynchronousPermitted == 0 ? "Disabled" : "Enabled");
  2.2112 +  WidePermitted = HostAdapter->WidePermitted & AllTargetsMask;
  2.2113 +  if (WidePermitted == 0)
  2.2114 +    WideMessage = "Disabled";
  2.2115 +  else if (WidePermitted == AllTargetsMask)
  2.2116 +    WideMessage = "Enabled";
  2.2117 +  else
  2.2118 +    {
  2.2119 +      for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2120 +	 WideString[TargetID] =
  2.2121 +	   ((WidePermitted & (1 << TargetID)) ? 'Y' : 'N');
  2.2122 +      WideString[HostAdapter->SCSI_ID] = '#';
  2.2123 +      WideString[HostAdapter->MaxTargetDevices] = '\0';
  2.2124 +    }
  2.2125 +  DisconnectPermitted = HostAdapter->DisconnectPermitted & AllTargetsMask;
  2.2126 +  if (DisconnectPermitted == 0)
  2.2127 +    DisconnectMessage = "Disabled";
  2.2128 +  else if (DisconnectPermitted == AllTargetsMask)
  2.2129 +    DisconnectMessage = "Enabled";
  2.2130 +  else
  2.2131 +    {
  2.2132 +      for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2133 +	DisconnectString[TargetID] =
  2.2134 +	  ((DisconnectPermitted & (1 << TargetID)) ? 'Y' : 'N');
  2.2135 +      DisconnectString[HostAdapter->SCSI_ID] = '#';
  2.2136 +      DisconnectString[HostAdapter->MaxTargetDevices] = '\0';
  2.2137 +    }
  2.2138 +  TaggedQueuingPermitted =
  2.2139 +    HostAdapter->TaggedQueuingPermitted & AllTargetsMask;
  2.2140 +  if (TaggedQueuingPermitted == 0)
  2.2141 +    TaggedQueuingMessage = "Disabled";
  2.2142 +  else if (TaggedQueuingPermitted == AllTargetsMask)
  2.2143 +    TaggedQueuingMessage = "Enabled";
  2.2144 +  else
  2.2145 +    {
  2.2146 +      for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2147 +	TaggedQueuingString[TargetID] =
  2.2148 +	  ((TaggedQueuingPermitted & (1 << TargetID)) ? 'Y' : 'N');
  2.2149 +      TaggedQueuingString[HostAdapter->SCSI_ID] = '#';
  2.2150 +      TaggedQueuingString[HostAdapter->MaxTargetDevices] = '\0';
  2.2151 +    }
  2.2152 +  BusLogic_Info("  Synchronous Negotiation: %s, Wide Negotiation: %s\n",
  2.2153 +		HostAdapter, SynchronousMessage, WideMessage);
  2.2154 +  BusLogic_Info("  Disconnect/Reconnect: %s, Tagged Queuing: %s\n",
  2.2155 +		HostAdapter, DisconnectMessage, TaggedQueuingMessage);
  2.2156 +  if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
  2.2157 +    {
  2.2158 +      BusLogic_Info("  Scatter/Gather Limit: %d of %d segments, "
  2.2159 +		    "Mailboxes: %d\n", HostAdapter,
  2.2160 +		    HostAdapter->DriverScatterGatherLimit,
  2.2161 +		    HostAdapter->HostAdapterScatterGatherLimit,
  2.2162 +		    HostAdapter->MailboxCount);
  2.2163 +      BusLogic_Info("  Driver Queue Depth: %d, "
  2.2164 +		    "Host Adapter Queue Depth: %d\n",
  2.2165 +		    HostAdapter, HostAdapter->DriverQueueDepth,
  2.2166 +		    HostAdapter->HostAdapterQueueDepth);
  2.2167 +    }
  2.2168 +  else BusLogic_Info("  Driver Queue Depth: %d, "
  2.2169 +		     "Scatter/Gather Limit: %d segments\n",
  2.2170 +		     HostAdapter, HostAdapter->DriverQueueDepth,
  2.2171 +		     HostAdapter->DriverScatterGatherLimit);
  2.2172 +  BusLogic_Info("  Tagged Queue Depth: ", HostAdapter);
  2.2173 +  CommonTaggedQueueDepth = true;
  2.2174 +  for (TargetID = 1; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2175 +    if (HostAdapter->QueueDepth[TargetID] != HostAdapter->QueueDepth[0])
  2.2176 +      {
  2.2177 +	CommonTaggedQueueDepth = false;
  2.2178 +	break;
  2.2179 +      }
  2.2180 +  if (CommonTaggedQueueDepth)
  2.2181 +    {
  2.2182 +      if (HostAdapter->QueueDepth[0] > 0)
  2.2183 +	BusLogic_Info("%d", HostAdapter, HostAdapter->QueueDepth[0]);
  2.2184 +      else BusLogic_Info("Automatic", HostAdapter);
  2.2185 +    }
  2.2186 +  else BusLogic_Info("Individual", HostAdapter);
  2.2187 +  BusLogic_Info(", Untagged Queue Depth: %d\n", HostAdapter,
  2.2188 +		HostAdapter->UntaggedQueueDepth);
  2.2189 +  CommonErrorRecovery = true;
  2.2190 +  for (TargetID = 1; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2191 +    if (HostAdapter->ErrorRecoveryStrategy[TargetID] !=
  2.2192 +	HostAdapter->ErrorRecoveryStrategy[0])
  2.2193 +      {
  2.2194 +	CommonErrorRecovery = false;
  2.2195 +	break;
  2.2196 +      }
  2.2197 +  if (CommonErrorRecovery)
  2.2198 +    ErrorRecoveryMessage =
  2.2199 +      BusLogic_ErrorRecoveryStrategyNames[
  2.2200 +	HostAdapter->ErrorRecoveryStrategy[0]];
  2.2201 +  else
  2.2202 +    {
  2.2203 +      for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2204 +	ErrorRecoveryString[TargetID] =
  2.2205 +	  BusLogic_ErrorRecoveryStrategyLetters[
  2.2206 +	    HostAdapter->ErrorRecoveryStrategy[TargetID]];
  2.2207 +      ErrorRecoveryString[HostAdapter->SCSI_ID] = '#';
  2.2208 +      ErrorRecoveryString[HostAdapter->MaxTargetDevices] = '\0';
  2.2209 +    }
  2.2210 +  BusLogic_Info("  Error Recovery Strategy: %s, SCSI Bus Reset: %s\n",
  2.2211 +		HostAdapter, ErrorRecoveryMessage,
  2.2212 +		(HostAdapter->BusResetEnabled ? "Enabled" : "Disabled"));
  2.2213 +  if (HostAdapter->TerminationInfoValid)
  2.2214 +    {
  2.2215 +      if (HostAdapter->HostWideSCSI)
  2.2216 +	BusLogic_Info("  SCSI Bus Termination: %s", HostAdapter,
  2.2217 +		      (HostAdapter->LowByteTerminated
  2.2218 +		       ? (HostAdapter->HighByteTerminated
  2.2219 +			  ? "Both Enabled" : "Low Enabled")
  2.2220 +		       : (HostAdapter->HighByteTerminated
  2.2221 +			  ? "High Enabled" : "Both Disabled")));
  2.2222 +      else BusLogic_Info("  SCSI Bus Termination: %s", HostAdapter,
  2.2223 +			 (HostAdapter->LowByteTerminated ?
  2.2224 +			  "Enabled" : "Disabled"));
  2.2225 +      if (HostAdapter->HostSupportsSCAM)
  2.2226 +	BusLogic_Info(", SCAM: %s", HostAdapter,
  2.2227 +		      (HostAdapter->SCAM_Enabled
  2.2228 +		       ? (HostAdapter->SCAM_Level2
  2.2229 +			  ? "Enabled, Level 2" : "Enabled, Level 1")
  2.2230 +		       : "Disabled"));
  2.2231 +      BusLogic_Info("\n", HostAdapter);
  2.2232 +    }
  2.2233 +  /*
  2.2234 +    Indicate reporting the Host Adapter configuration completed successfully.
  2.2235 +  */
  2.2236 +  return true;
  2.2237 +}
  2.2238 +
  2.2239 +
  2.2240 +/*
  2.2241 +  BusLogic_AcquireResources acquires the system resources necessary to use
  2.2242 +  Host Adapter.
  2.2243 +*/
  2.2244 +
  2.2245 +static boolean BusLogic_AcquireResources(BusLogic_HostAdapter_T *HostAdapter)
  2.2246 +{
  2.2247 +  if (HostAdapter->IRQ_Channel == 0)
  2.2248 +    {
  2.2249 +      BusLogic_Error("NO LEGAL INTERRUPT CHANNEL ASSIGNED - DETACHING\n",
  2.2250 +		     HostAdapter);
  2.2251 +      return false;
  2.2252 +    }
  2.2253 +  /*
  2.2254 +    Acquire shared access to the IRQ Channel.
  2.2255 +  */
  2.2256 +  if (request_irq(HostAdapter->IRQ_Channel, BusLogic_InterruptHandler,
  2.2257 +		  SA_SHIRQ, HostAdapter->FullModelName, HostAdapter) < 0)
  2.2258 +    {
  2.2259 +      BusLogic_Error("UNABLE TO ACQUIRE IRQ CHANNEL %d - DETACHING\n",
  2.2260 +		     HostAdapter, HostAdapter->IRQ_Channel);
  2.2261 +      return false;
  2.2262 +    }
  2.2263 +  HostAdapter->IRQ_ChannelAcquired = true;
  2.2264 +  /*
  2.2265 +    Acquire exclusive access to the DMA Channel.
  2.2266 +  */
  2.2267 +  if (HostAdapter->DMA_Channel > 0)
  2.2268 +    {
  2.2269 +#if 0 /* XEN */
  2.2270 +      if (request_dma(HostAdapter->DMA_Channel,
  2.2271 +		      HostAdapter->FullModelName) < 0)
  2.2272 +	{
  2.2273 +	  BusLogic_Error("UNABLE TO ACQUIRE DMA CHANNEL %d - DETACHING\n",
  2.2274 +			 HostAdapter, HostAdapter->DMA_Channel);
  2.2275 +	  return false;
  2.2276 +	}
  2.2277 +#endif
  2.2278 +      set_dma_mode(HostAdapter->DMA_Channel, DMA_MODE_CASCADE);
  2.2279 +      enable_dma(HostAdapter->DMA_Channel);
  2.2280 +      HostAdapter->DMA_ChannelAcquired = true;
  2.2281 +    }
  2.2282 +  /*
  2.2283 +    Indicate the System Resource Acquisition completed successfully,
  2.2284 +  */
  2.2285 +  return true;
  2.2286 +}
  2.2287 +
  2.2288 +
  2.2289 +/*
  2.2290 +  BusLogic_ReleaseResources releases any system resources previously acquired
  2.2291 +  by BusLogic_AcquireResources.
  2.2292 +*/
  2.2293 +
  2.2294 +static void BusLogic_ReleaseResources(BusLogic_HostAdapter_T *HostAdapter)
  2.2295 +{
  2.2296 +  /*
  2.2297 +    Release shared access to the IRQ Channel.
  2.2298 +  */
  2.2299 +  if (HostAdapter->IRQ_ChannelAcquired)
  2.2300 +    free_irq(HostAdapter->IRQ_Channel, HostAdapter);
  2.2301 +#if 0 /* XEN */
  2.2302 +  /*
  2.2303 +    Release exclusive access to the DMA Channel.
  2.2304 +  */
  2.2305 +  if (HostAdapter->DMA_ChannelAcquired)
  2.2306 +    free_dma(HostAdapter->DMA_Channel);
  2.2307 +#endif
  2.2308 +}
  2.2309 +
  2.2310 +
  2.2311 +/*
  2.2312 +  BusLogic_InitializeHostAdapter initializes Host Adapter.  This is the only
  2.2313 +  function called during SCSI Host Adapter detection which modifies the state
  2.2314 +  of the Host Adapter from its initial power on or hard reset state.
  2.2315 +*/
  2.2316 +
  2.2317 +static boolean BusLogic_InitializeHostAdapter(BusLogic_HostAdapter_T
  2.2318 +					      *HostAdapter)
  2.2319 +{
  2.2320 +  BusLogic_ExtendedMailboxRequest_T ExtendedMailboxRequest;
  2.2321 +  BusLogic_RoundRobinModeRequest_T RoundRobinModeRequest;
  2.2322 +  BusLogic_SetCCBFormatRequest_T SetCCBFormatRequest;
  2.2323 +  int TargetID;
  2.2324 +  /*
  2.2325 +    Initialize the pointers to the first and last CCBs that are queued for
  2.2326 +    completion processing.
  2.2327 +  */
  2.2328 +  HostAdapter->FirstCompletedCCB = NULL;
  2.2329 +  HostAdapter->LastCompletedCCB = NULL;
  2.2330 +  /*
  2.2331 +    Initialize the Bus Device Reset Pending CCB, Tagged Queuing Active,
  2.2332 +    Command Successful Flag, Active Commands, and Commands Since Reset
  2.2333 +    for each Target Device.
  2.2334 +  */
  2.2335 +  for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2336 +    {
  2.2337 +      HostAdapter->BusDeviceResetPendingCCB[TargetID] = NULL;
  2.2338 +      HostAdapter->TargetFlags[TargetID].TaggedQueuingActive = false;
  2.2339 +      HostAdapter->TargetFlags[TargetID].CommandSuccessfulFlag = false;
  2.2340 +      HostAdapter->ActiveCommands[TargetID] = 0;
  2.2341 +      HostAdapter->CommandsSinceReset[TargetID] = 0;
  2.2342 +    }
  2.2343 +  /*
  2.2344 +    FlashPoint Host Adapters do not use Outgoing and Incoming Mailboxes.
  2.2345 +  */
  2.2346 +  if (BusLogic_FlashPointHostAdapterP(HostAdapter)) goto Done;
  2.2347 +  /*
  2.2348 +    Initialize the Outgoing and Incoming Mailbox pointers.
  2.2349 +  */
  2.2350 +  HostAdapter->FirstOutgoingMailbox =
  2.2351 +    (BusLogic_OutgoingMailbox_T *) HostAdapter->MailboxSpace;
  2.2352 +  HostAdapter->LastOutgoingMailbox =
  2.2353 +    HostAdapter->FirstOutgoingMailbox + HostAdapter->MailboxCount - 1;
  2.2354 +  HostAdapter->NextOutgoingMailbox = HostAdapter->FirstOutgoingMailbox;
  2.2355 +  HostAdapter->FirstIncomingMailbox =
  2.2356 +    (BusLogic_IncomingMailbox_T *) (HostAdapter->LastOutgoingMailbox + 1);
  2.2357 +  HostAdapter->LastIncomingMailbox =
  2.2358 +    HostAdapter->FirstIncomingMailbox + HostAdapter->MailboxCount - 1;
  2.2359 +  HostAdapter->NextIncomingMailbox = HostAdapter->FirstIncomingMailbox;
  2.2360 +  /*
  2.2361 +    Initialize the Outgoing and Incoming Mailbox structures.
  2.2362 +  */
  2.2363 +  memset(HostAdapter->FirstOutgoingMailbox, 0,
  2.2364 +	 HostAdapter->MailboxCount * sizeof(BusLogic_OutgoingMailbox_T));
  2.2365 +  memset(HostAdapter->FirstIncomingMailbox, 0,
  2.2366 +	 HostAdapter->MailboxCount * sizeof(BusLogic_IncomingMailbox_T));
  2.2367 +  /*
  2.2368 +    Initialize the Host Adapter's Pointer to the Outgoing/Incoming Mailboxes.
  2.2369 +  */
  2.2370 +  ExtendedMailboxRequest.MailboxCount = HostAdapter->MailboxCount;
  2.2371 +  ExtendedMailboxRequest.BaseMailboxAddress =
  2.2372 +    Virtual_to_Bus(HostAdapter->FirstOutgoingMailbox);
  2.2373 +  if (BusLogic_Command(HostAdapter, BusLogic_InitializeExtendedMailbox,
  2.2374 +		       &ExtendedMailboxRequest,
  2.2375 +		       sizeof(ExtendedMailboxRequest), NULL, 0) < 0)
  2.2376 +    return BusLogic_Failure(HostAdapter, "MAILBOX INITIALIZATION");
  2.2377 +  /*
  2.2378 +    Enable Strict Round Robin Mode if supported by the Host Adapter.  In
  2.2379 +    Strict Round Robin Mode, the Host Adapter only looks at the next Outgoing
  2.2380 +    Mailbox for each new command, rather than scanning through all the
  2.2381 +    Outgoing Mailboxes to find any that have new commands in them.  Strict
  2.2382 +    Round Robin Mode is significantly more efficient.
  2.2383 +  */
  2.2384 +  if (HostAdapter->StrictRoundRobinModeSupport)
  2.2385 +    {
  2.2386 +      RoundRobinModeRequest = BusLogic_StrictRoundRobinMode;
  2.2387 +      if (BusLogic_Command(HostAdapter, BusLogic_EnableStrictRoundRobinMode,
  2.2388 +			   &RoundRobinModeRequest,
  2.2389 +			   sizeof(RoundRobinModeRequest), NULL, 0) < 0)
  2.2390 +	return BusLogic_Failure(HostAdapter, "ENABLE STRICT ROUND ROBIN MODE");
  2.2391 +    }
  2.2392 +  /*
  2.2393 +    For Host Adapters that support Extended LUN Format CCBs, issue the Set CCB
  2.2394 +    Format command to allow 32 Logical Units per Target Device.
  2.2395 +  */
  2.2396 +  if (HostAdapter->ExtendedLUNSupport)
  2.2397 +    {
  2.2398 +      SetCCBFormatRequest = BusLogic_ExtendedLUNFormatCCB;
  2.2399 +      if (BusLogic_Command(HostAdapter, BusLogic_SetCCBFormat,
  2.2400 +			   &SetCCBFormatRequest, sizeof(SetCCBFormatRequest),
  2.2401 +			   NULL, 0) < 0)
  2.2402 +	return BusLogic_Failure(HostAdapter, "SET CCB FORMAT");
  2.2403 +    }
  2.2404 +  /*
  2.2405 +    Announce Successful Initialization.
  2.2406 +  */
  2.2407 +Done:
  2.2408 +  if (!HostAdapter->HostAdapterInitialized)
  2.2409 +    {
  2.2410 +      BusLogic_Info("*** %s Initialized Successfully ***\n",
  2.2411 +		    HostAdapter, HostAdapter->FullModelName);
  2.2412 +      BusLogic_Info("\n", HostAdapter);
  2.2413 +    }
  2.2414 +  else BusLogic_Warning("*** %s Initialized Successfully ***\n",
  2.2415 +			HostAdapter, HostAdapter->FullModelName);
  2.2416 +  HostAdapter->HostAdapterInitialized = true;
  2.2417 +  /*
  2.2418 +    Indicate the Host Adapter Initialization completed successfully.
  2.2419 +  */
  2.2420 +  return true;
  2.2421 +}
  2.2422 +
  2.2423 +
  2.2424 +/*
  2.2425 +  BusLogic_TargetDeviceInquiry inquires about the Target Devices accessible
  2.2426 +  through Host Adapter.
  2.2427 +*/
  2.2428 +
  2.2429 +static boolean BusLogic_TargetDeviceInquiry(BusLogic_HostAdapter_T
  2.2430 +					    *HostAdapter)
  2.2431 +{
  2.2432 +  BusLogic_InstalledDevices_T InstalledDevices;
  2.2433 +  BusLogic_InstalledDevices8_T InstalledDevicesID0to7;
  2.2434 +  BusLogic_SetupInformation_T SetupInformation;
  2.2435 +  BusLogic_SynchronousPeriod_T SynchronousPeriod;
  2.2436 +  BusLogic_RequestedReplyLength_T RequestedReplyLength;
  2.2437 +  int TargetID;
  2.2438 +  /*
  2.2439 +    Wait a few seconds between the Host Adapter Hard Reset which initiates
  2.2440 +    a SCSI Bus Reset and issuing any SCSI Commands.  Some SCSI devices get
  2.2441 +    confused if they receive SCSI Commands too soon after a SCSI Bus Reset.
  2.2442 +  */
  2.2443 +  BusLogic_Delay(HostAdapter->BusSettleTime);
  2.2444 +  /*
  2.2445 +    FlashPoint Host Adapters do not provide for Target Device Inquiry.
  2.2446 +  */
  2.2447 +  if (BusLogic_FlashPointHostAdapterP(HostAdapter)) return true;
  2.2448 +  /*
  2.2449 +    Inhibit the Target Device Inquiry if requested.
  2.2450 +  */
  2.2451 +  if (HostAdapter->DriverOptions != NULL &&
  2.2452 +      HostAdapter->DriverOptions->LocalOptions.InhibitTargetInquiry)
  2.2453 +    return true;
  2.2454 +  /*
  2.2455 +    Issue the Inquire Target Devices command for host adapters with firmware
  2.2456 +    version 4.25 or later, or the Inquire Installed Devices ID 0 to 7 command
  2.2457 +    for older host adapters.  This is necessary to force Synchronous Transfer
  2.2458 +    Negotiation so that the Inquire Setup Information and Inquire Synchronous
  2.2459 +    Period commands will return valid data.  The Inquire Target Devices command
  2.2460 +    is preferable to Inquire Installed Devices ID 0 to 7 since it only probes
  2.2461 +    Logical Unit 0 of each Target Device.
  2.2462 +  */
  2.2463 +  if (strcmp(HostAdapter->FirmwareVersion, "4.25") >= 0)
  2.2464 +    {
  2.2465 +      if (BusLogic_Command(HostAdapter, BusLogic_InquireTargetDevices, NULL, 0,
  2.2466 +			   &InstalledDevices, sizeof(InstalledDevices))
  2.2467 +	  != sizeof(InstalledDevices))
  2.2468 +	return BusLogic_Failure(HostAdapter, "INQUIRE TARGET DEVICES");
  2.2469 +      for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2470 +	HostAdapter->TargetFlags[TargetID].TargetExists =
  2.2471 +	  (InstalledDevices & (1 << TargetID) ? true : false);
  2.2472 +    }
  2.2473 +  else
  2.2474 +    {
  2.2475 +      if (BusLogic_Command(HostAdapter, BusLogic_InquireInstalledDevicesID0to7,
  2.2476 +			   NULL, 0, &InstalledDevicesID0to7,
  2.2477 +			   sizeof(InstalledDevicesID0to7))
  2.2478 +	  != sizeof(InstalledDevicesID0to7))
  2.2479 +	return BusLogic_Failure(HostAdapter,
  2.2480 +				"INQUIRE INSTALLED DEVICES ID 0 TO 7");
  2.2481 +      for (TargetID = 0; TargetID < 8; TargetID++)
  2.2482 +	HostAdapter->TargetFlags[TargetID].TargetExists =
  2.2483 +	  (InstalledDevicesID0to7[TargetID] != 0 ? true : false);
  2.2484 +    }
  2.2485 +  /*
  2.2486 +    Issue the Inquire Setup Information command.
  2.2487 +  */
  2.2488 +  RequestedReplyLength = sizeof(SetupInformation);
  2.2489 +  if (BusLogic_Command(HostAdapter, BusLogic_InquireSetupInformation,
  2.2490 +		       &RequestedReplyLength, sizeof(RequestedReplyLength),
  2.2491 +		       &SetupInformation, sizeof(SetupInformation))
  2.2492 +      != sizeof(SetupInformation))
  2.2493 +    return BusLogic_Failure(HostAdapter, "INQUIRE SETUP INFORMATION");
  2.2494 +  for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2495 +      HostAdapter->SynchronousOffset[TargetID] =
  2.2496 +	(TargetID < 8
  2.2497 +	 ? SetupInformation.SynchronousValuesID0to7[TargetID].Offset
  2.2498 +	 : SetupInformation.SynchronousValuesID8to15[TargetID-8].Offset);
  2.2499 +  if (strcmp(HostAdapter->FirmwareVersion, "5.06L") >= 0)
  2.2500 +    for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2501 +      HostAdapter->TargetFlags[TargetID].WideTransfersActive =
  2.2502 +	(TargetID < 8
  2.2503 +	 ? (SetupInformation.WideTransfersActiveID0to7 & (1 << TargetID)
  2.2504 +	    ? true : false)
  2.2505 +	 : (SetupInformation.WideTransfersActiveID8to15 & (1 << (TargetID-8))
  2.2506 +	    ? true : false));
  2.2507 +  /*
  2.2508 +    Issue the Inquire Synchronous Period command.
  2.2509 +  */
  2.2510 +  if (HostAdapter->FirmwareVersion[0] >= '3')
  2.2511 +    {
  2.2512 +      RequestedReplyLength = sizeof(SynchronousPeriod);
  2.2513 +      if (BusLogic_Command(HostAdapter, BusLogic_InquireSynchronousPeriod,
  2.2514 +			   &RequestedReplyLength, sizeof(RequestedReplyLength),
  2.2515 +			   &SynchronousPeriod, sizeof(SynchronousPeriod))
  2.2516 +	  != sizeof(SynchronousPeriod))
  2.2517 +	return BusLogic_Failure(HostAdapter, "INQUIRE SYNCHRONOUS PERIOD");
  2.2518 +      for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2519 +	HostAdapter->SynchronousPeriod[TargetID] = SynchronousPeriod[TargetID];
  2.2520 +    }
  2.2521 +  else
  2.2522 +    for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2523 +      if (SetupInformation.SynchronousValuesID0to7[TargetID].Offset > 0)
  2.2524 +	HostAdapter->SynchronousPeriod[TargetID] =
  2.2525 +	  20 + 5 * SetupInformation.SynchronousValuesID0to7[TargetID]
  2.2526 +				   .TransferPeriod;
  2.2527 +  /*
  2.2528 +    Indicate the Target Device Inquiry completed successfully.
  2.2529 +  */
  2.2530 +  return true;
  2.2531 +}
  2.2532 +
  2.2533 +
  2.2534 +/*
  2.2535 +  BusLogic_ReportTargetDeviceInfo reports about the Target Devices accessible
  2.2536 +  through Host Adapter.
  2.2537 +*/
  2.2538 +
  2.2539 +static void BusLogic_ReportTargetDeviceInfo(BusLogic_HostAdapter_T
  2.2540 +					    *HostAdapter)
  2.2541 +{
  2.2542 +  int TargetID;
  2.2543 +  /*
  2.2544 +    Inhibit the Target Device Inquiry and Reporting if requested.
  2.2545 +  */
  2.2546 +  if (BusLogic_MultiMasterHostAdapterP(HostAdapter) &&
  2.2547 +      HostAdapter->DriverOptions != NULL &&
  2.2548 +      HostAdapter->DriverOptions->LocalOptions.InhibitTargetInquiry)
  2.2549 +    return;
  2.2550 +  /*
  2.2551 +    Report on the Target Devices found.
  2.2552 +  */
  2.2553 +  for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2554 +    {
  2.2555 +      BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
  2.2556 +      if (TargetFlags->TargetExists && !TargetFlags->TargetInfoReported)
  2.2557 +	{
  2.2558 +	  int SynchronousTransferRate = 0;
  2.2559 +	  if (BusLogic_FlashPointHostAdapterP(HostAdapter))
  2.2560 +	    {
  2.2561 +	      unsigned char WideTransfersActive;
  2.2562 +	      FlashPoint_InquireTargetInfo(
  2.2563 +		HostAdapter->CardHandle, TargetID,
  2.2564 +		&HostAdapter->SynchronousPeriod[TargetID],
  2.2565 +		&HostAdapter->SynchronousOffset[TargetID],
  2.2566 +		&WideTransfersActive);
  2.2567 +	      TargetFlags->WideTransfersActive = WideTransfersActive;
  2.2568 +	    }
  2.2569 +	  else if (TargetFlags->WideTransfersSupported &&
  2.2570 +		   (HostAdapter->WidePermitted & (1 << TargetID)) &&
  2.2571 +		   strcmp(HostAdapter->FirmwareVersion, "5.06L") < 0)
  2.2572 +	    TargetFlags->WideTransfersActive = true;
  2.2573 +	  if (HostAdapter->SynchronousPeriod[TargetID] > 0)
  2.2574 +	    SynchronousTransferRate =
  2.2575 +	      100000 / HostAdapter->SynchronousPeriod[TargetID];
  2.2576 +	  if (TargetFlags->WideTransfersActive)
  2.2577 +	    SynchronousTransferRate <<= 1;
  2.2578 +	  if (SynchronousTransferRate >= 9950)
  2.2579 +	    {
  2.2580 +	      SynchronousTransferRate = (SynchronousTransferRate + 50) / 100;
  2.2581 +	      BusLogic_Info("Target %d: Queue Depth %d, %sSynchronous at "
  2.2582 +			    "%d.%01d MB/sec, offset %d\n",
  2.2583 +			    HostAdapter, TargetID,
  2.2584 +			    HostAdapter->QueueDepth[TargetID],
  2.2585 +			    (TargetFlags->WideTransfersActive ? "Wide " : ""),
  2.2586 +			    SynchronousTransferRate / 10,
  2.2587 +			    SynchronousTransferRate % 10,
  2.2588 +			    HostAdapter->SynchronousOffset[TargetID]);
  2.2589 +	    }
  2.2590 +	  else if (SynchronousTransferRate > 0)
  2.2591 +	    {
  2.2592 +	      SynchronousTransferRate = (SynchronousTransferRate + 5) / 10;
  2.2593 +	      BusLogic_Info("Target %d: Queue Depth %d, %sSynchronous at "
  2.2594 +			    "%d.%02d MB/sec, offset %d\n",
  2.2595 +			    HostAdapter, TargetID,
  2.2596 +			    HostAdapter->QueueDepth[TargetID],
  2.2597 +			    (TargetFlags->WideTransfersActive ? "Wide " : ""),
  2.2598 +			    SynchronousTransferRate / 100,
  2.2599 +			    SynchronousTransferRate % 100,
  2.2600 +			    HostAdapter->SynchronousOffset[TargetID]);
  2.2601 +	    }
  2.2602 +	  else BusLogic_Info("Target %d: Queue Depth %d, Asynchronous\n",
  2.2603 +			     HostAdapter, TargetID,
  2.2604 +			     HostAdapter->QueueDepth[TargetID]);
  2.2605 +	  TargetFlags->TargetInfoReported = true;
  2.2606 +	}
  2.2607 +    }
  2.2608 +}
  2.2609 +
  2.2610 +
  2.2611 +/*
  2.2612 +  BusLogic_InitializeHostStructure initializes the fields in the SCSI Host
  2.2613 +  structure.  The base, io_port, n_io_ports, irq, and dma_channel fields in the
  2.2614 +  SCSI Host structure are intentionally left uninitialized, as this driver
  2.2615 +  handles acquisition and release of these resources explicitly, as well as
  2.2616 +  ensuring exclusive access to the Host Adapter hardware and data structures
  2.2617 +  through explicit acquisition and release of the Host Adapter's Lock.
  2.2618 +*/
  2.2619 +
  2.2620 +static void BusLogic_InitializeHostStructure(BusLogic_HostAdapter_T
  2.2621 +					       *HostAdapter,
  2.2622 +					     SCSI_Host_T *Host)
  2.2623 +{
  2.2624 +  Host->max_id = HostAdapter->MaxTargetDevices;
  2.2625 +  Host->max_lun = HostAdapter->MaxLogicalUnits;
  2.2626 +  Host->max_channel = 0;
  2.2627 +  Host->unique_id = HostAdapter->IO_Address;
  2.2628 +  Host->this_id = HostAdapter->SCSI_ID;
  2.2629 +  Host->can_queue = HostAdapter->DriverQueueDepth;
  2.2630 +  Host->sg_tablesize = HostAdapter->DriverScatterGatherLimit;
  2.2631 +  Host->unchecked_isa_dma = HostAdapter->BounceBuffersRequired;
  2.2632 +  Host->cmd_per_lun = HostAdapter->UntaggedQueueDepth;
  2.2633 +}
  2.2634 +
  2.2635 +
  2.2636 +/*
  2.2637 +  BusLogic_SelectQueueDepths selects Queue Depths for each Target Device based
  2.2638 +  on the Host Adapter's Total Queue Depth and the number, type, speed, and
  2.2639 +  capabilities of the Target Devices.  When called for the last Host Adapter,
  2.2640 +  it reports on the Target Device Information for all BusLogic Host Adapters
  2.2641 +  since all the Target Devices have now been probed.
  2.2642 +*/
  2.2643 +
  2.2644 +static void BusLogic_SelectQueueDepths(SCSI_Host_T *Host,
  2.2645 +				       SCSI_Device_T *DeviceList)
  2.2646 +{
  2.2647 +  BusLogic_HostAdapter_T *HostAdapter =
  2.2648 +    (BusLogic_HostAdapter_T *) Host->hostdata;
  2.2649 +  int TaggedDeviceCount = 0, AutomaticTaggedDeviceCount = 0;
  2.2650 +  int UntaggedDeviceCount = 0, AutomaticTaggedQueueDepth = 0;
  2.2651 +  int AllocatedQueueDepth = 0;
  2.2652 +  SCSI_Device_T *Device;
  2.2653 +  int TargetID;
  2.2654 +  for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2655 +    if (HostAdapter->TargetFlags[TargetID].TargetExists)
  2.2656 +      {
  2.2657 +	int QueueDepth = HostAdapter->QueueDepth[TargetID];
  2.2658 +	if (HostAdapter->TargetFlags[TargetID].TaggedQueuingSupported &&
  2.2659 +	    (HostAdapter->TaggedQueuingPermitted & (1 << TargetID)))
  2.2660 +	  {
  2.2661 +	    TaggedDeviceCount++;
  2.2662 +	    if (QueueDepth == 0) AutomaticTaggedDeviceCount++;
  2.2663 +	  }
  2.2664 +	else
  2.2665 +	  {
  2.2666 +	    UntaggedDeviceCount++;
  2.2667 +	    if (QueueDepth == 0 ||
  2.2668 +		QueueDepth > HostAdapter->UntaggedQueueDepth)
  2.2669 +	      {
  2.2670 +		QueueDepth = HostAdapter->UntaggedQueueDepth;
  2.2671 +		HostAdapter->QueueDepth[TargetID] = QueueDepth;
  2.2672 +	      }
  2.2673 +	  }
  2.2674 +	AllocatedQueueDepth += QueueDepth;
  2.2675 +	if (QueueDepth == 1)
  2.2676 +	  HostAdapter->TaggedQueuingPermitted &= ~(1 << TargetID);
  2.2677 +      }
  2.2678 +  HostAdapter->TargetDeviceCount = TaggedDeviceCount + UntaggedDeviceCount;
  2.2679 +  if (AutomaticTaggedDeviceCount > 0)
  2.2680 +    {
  2.2681 +      AutomaticTaggedQueueDepth =
  2.2682 +	(HostAdapter->HostAdapterQueueDepth - AllocatedQueueDepth)
  2.2683 +	/ AutomaticTaggedDeviceCount;
  2.2684 +      if (AutomaticTaggedQueueDepth > BusLogic_MaxAutomaticTaggedQueueDepth)
  2.2685 +	AutomaticTaggedQueueDepth = BusLogic_MaxAutomaticTaggedQueueDepth;
  2.2686 +      if (AutomaticTaggedQueueDepth < BusLogic_MinAutomaticTaggedQueueDepth)
  2.2687 +	AutomaticTaggedQueueDepth = BusLogic_MinAutomaticTaggedQueueDepth;
  2.2688 +      for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.2689 +	if (HostAdapter->TargetFlags[TargetID].TargetExists &&
  2.2690 +	    HostAdapter->QueueDepth[TargetID] == 0)
  2.2691 +	  {
  2.2692 +	    AllocatedQueueDepth += AutomaticTaggedQueueDepth;
  2.2693 +	    HostAdapter->QueueDepth[TargetID] = AutomaticTaggedQueueDepth;
  2.2694 +	  }
  2.2695 +    }
  2.2696 +  for (Device = DeviceList; Device != NULL; Device = Device->next)
  2.2697 +    if (Device->host == Host)
  2.2698 +      Device->queue_depth = HostAdapter->QueueDepth[Device->id];
  2.2699 +  /* Allocate an extra CCB for each Target Device for a Bus Device Reset. */
  2.2700 +  AllocatedQueueDepth += HostAdapter->TargetDeviceCount;
  2.2701 +  if (AllocatedQueueDepth > HostAdapter->DriverQueueDepth)
  2.2702 +    AllocatedQueueDepth = HostAdapter->DriverQueueDepth;
  2.2703 +  BusLogic_CreateAdditionalCCBs(HostAdapter,
  2.2704 +				AllocatedQueueDepth
  2.2705 +				- HostAdapter->AllocatedCCBs,
  2.2706 +				false);
  2.2707 +  if (HostAdapter == BusLogic_LastRegisteredHostAdapter)
  2.2708 +    for (HostAdapter = BusLogic_FirstRegisteredHostAdapter;
  2.2709 +	 HostAdapter != NULL;
  2.2710 +	 HostAdapter = HostAdapter->Next)
  2.2711 +      BusLogic_ReportTargetDeviceInfo(HostAdapter);
  2.2712 +}
  2.2713 +
  2.2714 +
  2.2715 +/*
  2.2716 +  BusLogic_DetectHostAdapter probes for BusLogic Host Adapters at the standard
  2.2717 +  I/O Addresses where they may be located, initializing, registering, and
  2.2718 +  reporting the configuration of each BusLogic Host Adapter it finds.  It
  2.2719 +  returns the number of BusLogic Host Adapters successfully initialized and
  2.2720 +  registered.
  2.2721 +*/
  2.2722 +
  2.2723 +int BusLogic_DetectHostAdapter(SCSI_Host_Template_T *HostTemplate)
  2.2724 +{
  2.2725 +  int BusLogicHostAdapterCount = 0, DriverOptionsIndex = 0, ProbeIndex;
  2.2726 +  BusLogic_HostAdapter_T *PrototypeHostAdapter;
  2.2727 +  if (BusLogic_ProbeOptions.NoProbe) return 0;
  2.2728 +  BusLogic_ProbeInfoList = (BusLogic_ProbeInfo_T *)
  2.2729 +    kmalloc(BusLogic_MaxHostAdapters * sizeof(BusLogic_ProbeInfo_T),
  2.2730 +	    GFP_ATOMIC);
  2.2731 +  if (BusLogic_ProbeInfoList == NULL)
  2.2732 +    {
  2.2733 +      BusLogic_Error("BusLogic: Unable to allocate Probe Info List\n", NULL);
  2.2734 +      return 0;
  2.2735 +    }
  2.2736 +  memset(BusLogic_ProbeInfoList, 0,
  2.2737 +	 BusLogic_MaxHostAdapters * sizeof(BusLogic_ProbeInfo_T));
  2.2738 +  PrototypeHostAdapter = (BusLogic_HostAdapter_T *)
  2.2739 +    kmalloc(sizeof(BusLogic_HostAdapter_T), GFP_ATOMIC);
  2.2740 +  if (PrototypeHostAdapter == NULL)
  2.2741 +    {
  2.2742 +      kfree(BusLogic_ProbeInfoList);
  2.2743 +      BusLogic_Error("BusLogic: Unable to allocate Prototype "
  2.2744 +		     "Host Adapter\n", NULL);
  2.2745 +      return 0;
  2.2746 +    }
  2.2747 +  memset(PrototypeHostAdapter, 0, sizeof(BusLogic_HostAdapter_T));
  2.2748 +#ifdef MODULE
  2.2749 +  if (BusLogic != NULL)
  2.2750 +    BusLogic_Setup(BusLogic);
  2.2751 +#endif
  2.2752 +  BusLogic_InitializeProbeInfoList(PrototypeHostAdapter);
  2.2753 +  for (ProbeIndex = 0; ProbeIndex < BusLogic_ProbeInfoCount; ProbeIndex++)
  2.2754 +    {
  2.2755 +      BusLogic_ProbeInfo_T *ProbeInfo = &BusLogic_ProbeInfoList[ProbeIndex];
  2.2756 +      BusLogic_HostAdapter_T *HostAdapter = PrototypeHostAdapter;
  2.2757 +      SCSI_Host_T *Host;
  2.2758 +      if (ProbeInfo->IO_Address == 0) continue;
  2.2759 +      memset(HostAdapter, 0, sizeof(BusLogic_HostAdapter_T));
  2.2760 +      HostAdapter->HostAdapterType = ProbeInfo->HostAdapterType;
  2.2761 +      HostAdapter->HostAdapterBusType = ProbeInfo->HostAdapterBusType;
  2.2762 +      HostAdapter->IO_Address = ProbeInfo->IO_Address;
  2.2763 +      HostAdapter->PCI_Address = ProbeInfo->PCI_Address;
  2.2764 +      HostAdapter->Bus = ProbeInfo->Bus;
  2.2765 +      HostAdapter->Device = ProbeInfo->Device;
  2.2766 +      HostAdapter->IRQ_Channel = ProbeInfo->IRQ_Channel;
  2.2767 +      HostAdapter->AddressCount =
  2.2768 +	BusLogic_HostAdapterAddressCount[HostAdapter->HostAdapterType];
  2.2769 +      /*
  2.2770 +	Probe the Host Adapter.  If unsuccessful, abort further initialization.
  2.2771 +      */
  2.2772 +      if (!BusLogic_ProbeHostAdapter(HostAdapter)) continue;
  2.2773 +      /*
  2.2774 +	Hard Reset the Host Adapter.  If unsuccessful, abort further
  2.2775 +	initialization.
  2.2776 +      */
  2.2777 +      if (!BusLogic_HardwareResetHostAdapter(HostAdapter, true)) continue;
  2.2778 +      /*
  2.2779 +	Check the Host Adapter.  If unsuccessful, abort further initialization.
  2.2780 +      */
  2.2781 +      if (!BusLogic_CheckHostAdapter(HostAdapter)) continue;
  2.2782 +      /*
  2.2783 +	Initialize the Driver Options field if provided.
  2.2784 +      */
  2.2785 +      if (DriverOptionsIndex < BusLogic_DriverOptionsCount)
  2.2786 +	HostAdapter->DriverOptions =
  2.2787 +	  &BusLogic_DriverOptions[DriverOptionsIndex++];
  2.2788 +      /*
  2.2789 +	Announce the Driver Version and Date, Author's Name, Copyright Notice,
  2.2790 +	and Electronic Mail Address.
  2.2791 +      */
  2.2792 +      BusLogic_AnnounceDriver(HostAdapter);
  2.2793 +      /*
  2.2794 +	Register usage of the I/O Address range.  From this point onward, any
  2.2795 +	failure will be assumed to be due to a problem with the Host Adapter,
  2.2796 +	rather than due to having mistakenly identified this port as belonging
  2.2797 +	to a BusLogic Host Adapter.  The I/O Address range will not be
  2.2798 +	released, thereby preventing it from being incorrectly identified as
  2.2799 +	any other type of Host Adapter.
  2.2800 +      */
  2.2801 +      request_region(HostAdapter->IO_Address, HostAdapter->AddressCount,
  2.2802 +		     "BusLogic");
  2.2803 +      /*
  2.2804 +	Register the SCSI Host structure.
  2.2805 +      */
  2.2806 +      Host = scsi_register(HostTemplate, sizeof(BusLogic_HostAdapter_T));
  2.2807 +      if(Host==NULL)
  2.2808 +      {
  2.2809 +      	release_region(HostAdapter->IO_Address, HostAdapter->AddressCount);
  2.2810 +      	continue;
  2.2811 +      }
  2.2812 +      HostAdapter = (BusLogic_HostAdapter_T *) Host->hostdata;
  2.2813 +      memcpy(HostAdapter, PrototypeHostAdapter, sizeof(BusLogic_HostAdapter_T));
  2.2814 +      HostAdapter->SCSI_Host = Host;
  2.2815 +      HostAdapter->HostNumber = Host->host_no;
  2.2816 +      Host->select_queue_depths = BusLogic_SelectQueueDepths;
  2.2817 +      /*
  2.2818 +	Add Host Adapter to the end of the list of registered BusLogic
  2.2819 +	Host Adapters.
  2.2820 +      */
  2.2821 +      BusLogic_RegisterHostAdapter(HostAdapter);
  2.2822 +      /*
  2.2823 +	Read the Host Adapter Configuration, Configure the Host Adapter,
  2.2824 +	Acquire the System Resources necessary to use the Host Adapter, then
  2.2825 +	Create the Initial CCBs, Initialize the Host Adapter, and finally
  2.2826 +	perform Target Device Inquiry.
  2.2827 +      */
  2.2828 +      if (BusLogic_ReadHostAdapterConfiguration(HostAdapter) &&
  2.2829 +	  BusLogic_ReportHostAdapterConfiguration(HostAdapter) &&
  2.2830 +	  BusLogic_AcquireResources(HostAdapter) &&
  2.2831 +	  BusLogic_CreateInitialCCBs(HostAdapter) &&
  2.2832 +	  BusLogic_InitializeHostAdapter(HostAdapter) &&
  2.2833 +	  BusLogic_TargetDeviceInquiry(HostAdapter))
  2.2834 +	{
  2.2835 +	  /*
  2.2836 +	    Initialization has been completed successfully.  Release and
  2.2837 +	    re-register usage of the I/O Address range so that the Model
  2.2838 +	    Name of the Host Adapter will appear, and initialize the SCSI
  2.2839 +	    Host structure.
  2.2840 +	  */
  2.2841 +	  release_region(HostAdapter->IO_Address,
  2.2842 +			 HostAdapter->AddressCount);
  2.2843 +	  request_region(HostAdapter->IO_Address,
  2.2844 +			 HostAdapter->AddressCount,
  2.2845 +			 HostAdapter->FullModelName);
  2.2846 +	  BusLogic_InitializeHostStructure(HostAdapter, Host);
  2.2847 +	  BusLogicHostAdapterCount++;
  2.2848 +	}
  2.2849 +      else
  2.2850 +	{
  2.2851 +	  /*
  2.2852 +	    An error occurred during Host Adapter Configuration Querying, Host
  2.2853 +	    Adapter Configuration, Resource Acquisition, CCB Creation, Host
  2.2854 +	    Adapter Initialization, or Target Device Inquiry, so remove Host
  2.2855 +	    Adapter from the list of registered BusLogic Host Adapters, destroy
  2.2856 +	    the CCBs, Release the System Resources, and Unregister the SCSI
  2.2857 +	    Host.
  2.2858 +	  */
  2.2859 +	  BusLogic_DestroyCCBs(HostAdapter);
  2.2860 +	  BusLogic_ReleaseResources(HostAdapter);
  2.2861 +	  BusLogic_UnregisterHostAdapter(HostAdapter);
  2.2862 +	  scsi_unregister(Host);
  2.2863 +	}
  2.2864 +    }
  2.2865 +  kfree(PrototypeHostAdapter);
  2.2866 +  kfree(BusLogic_ProbeInfoList);
  2.2867 +  BusLogic_ProbeInfoList = NULL;
  2.2868 +  return BusLogicHostAdapterCount;
  2.2869 +}
  2.2870 +
  2.2871 +
  2.2872 +/*
  2.2873 +  BusLogic_ReleaseHostAdapter releases all resources previously acquired to
  2.2874 +  support a specific Host Adapter, including the I/O Address range, and
  2.2875 +  unregisters the BusLogic Host Adapter.
  2.2876 +*/
  2.2877 +
  2.2878 +int BusLogic_ReleaseHostAdapter(SCSI_Host_T *Host)
  2.2879 +{
  2.2880 +  BusLogic_HostAdapter_T *HostAdapter =
  2.2881 +    (BusLogic_HostAdapter_T *) Host->hostdata;
  2.2882 +  /*
  2.2883 +    FlashPoint Host Adapters must first be released by the FlashPoint
  2.2884 +    SCCB Manager.
  2.2885 +  */
  2.2886 +  if (BusLogic_FlashPointHostAdapterP(HostAdapter))
  2.2887 +    FlashPoint_ReleaseHostAdapter(HostAdapter->CardHandle);
  2.2888 +  /*
  2.2889 +    Destroy the CCBs and release any system resources acquired to
  2.2890 +    support Host Adapter.
  2.2891 +  */
  2.2892 +  BusLogic_DestroyCCBs(HostAdapter);
  2.2893 +  BusLogic_ReleaseResources(HostAdapter);
  2.2894 +  /*
  2.2895 +    Release usage of the I/O Address range.
  2.2896 +  */
  2.2897 +  release_region(HostAdapter->IO_Address, HostAdapter->AddressCount);
  2.2898 +  /*
  2.2899 +    Remove Host Adapter from the list of registered BusLogic Host Adapters.
  2.2900 +  */
  2.2901 +  BusLogic_UnregisterHostAdapter(HostAdapter);
  2.2902 +  return 0;
  2.2903 +}
  2.2904 +
  2.2905 +
  2.2906 +/*
  2.2907 +  BusLogic_QueueCompletedCCB queues CCB for completion processing.
  2.2908 +*/
  2.2909 +
  2.2910 +static void BusLogic_QueueCompletedCCB(BusLogic_CCB_T *CCB)
  2.2911 +{
  2.2912 +  BusLogic_HostAdapter_T *HostAdapter = CCB->HostAdapter;
  2.2913 +  CCB->Status = BusLogic_CCB_Completed;
  2.2914 +  CCB->Next = NULL;
  2.2915 +  if (HostAdapter->FirstCompletedCCB == NULL)
  2.2916 +    {
  2.2917 +      HostAdapter->FirstCompletedCCB = CCB;
  2.2918 +      HostAdapter->LastCompletedCCB = CCB;
  2.2919 +    }
  2.2920 +  else
  2.2921 +    {
  2.2922 +      HostAdapter->LastCompletedCCB->Next = CCB;
  2.2923 +      HostAdapter->LastCompletedCCB = CCB;
  2.2924 +    }
  2.2925 +  HostAdapter->ActiveCommands[CCB->TargetID]--;
  2.2926 +}
  2.2927 +
  2.2928 +
  2.2929 +/*
  2.2930 +  BusLogic_ComputeResultCode computes a SCSI Subsystem Result Code from
  2.2931 +  the Host Adapter Status and Target Device Status.
  2.2932 +*/
  2.2933 +
  2.2934 +static int BusLogic_ComputeResultCode(BusLogic_HostAdapter_T *HostAdapter,
  2.2935 +				      BusLogic_HostAdapterStatus_T
  2.2936 +					HostAdapterStatus,
  2.2937 +				      BusLogic_TargetDeviceStatus_T
  2.2938 +					TargetDeviceStatus)
  2.2939 +{
  2.2940 +  int HostStatus;
  2.2941 +  switch (HostAdapterStatus)
  2.2942 +    {
  2.2943 +    case BusLogic_CommandCompletedNormally:
  2.2944 +    case BusLogic_LinkedCommandCompleted:
  2.2945 +    case BusLogic_LinkedCommandCompletedWithFlag:
  2.2946 +      HostStatus = DID_OK;
  2.2947 +      break;
  2.2948 +    case BusLogic_SCSISelectionTimeout:
  2.2949 +      HostStatus = DID_TIME_OUT;
  2.2950 +      break;
  2.2951 +    case BusLogic_InvalidOutgoingMailboxActionCode:
  2.2952 +    case BusLogic_InvalidCommandOperationCode:
  2.2953 +    case BusLogic_InvalidCommandParameter:
  2.2954 +      BusLogic_Warning("BusLogic Driver Protocol Error 0x%02X\n",
  2.2955 +		       HostAdapter, HostAdapterStatus);
  2.2956 +    case BusLogic_DataUnderRun:
  2.2957 +    case BusLogic_DataOverRun:
  2.2958 +    case BusLogic_UnexpectedBusFree:
  2.2959 +    case BusLogic_LinkedCCBhasInvalidLUN:
  2.2960 +    case BusLogic_AutoRequestSenseFailed:
  2.2961 +    case BusLogic_TaggedQueuingMessageRejected:
  2.2962 +    case BusLogic_UnsupportedMessageReceived:
  2.2963 +    case BusLogic_HostAdapterHardwareFailed:
  2.2964 +    case BusLogic_TargetDeviceReconnectedImproperly:
  2.2965 +    case BusLogic_AbortQueueGenerated:
  2.2966 +    case BusLogic_HostAdapterSoftwareError:
  2.2967 +    case BusLogic_HostAdapterHardwareTimeoutError:
  2.2968 +    case BusLogic_SCSIParityErrorDetected:
  2.2969 +      HostStatus = DID_ERROR;
  2.2970 +      break;
  2.2971 +    case BusLogic_InvalidBusPhaseRequested:
  2.2972 +    case BusLogic_TargetFailedResponseToATN:
  2.2973 +    case BusLogic_HostAdapterAssertedRST:
  2.2974 +    case BusLogic_OtherDeviceAssertedRST:
  2.2975 +    case BusLogic_HostAdapterAssertedBusDeviceReset:
  2.2976 +      HostStatus = DID_RESET;
  2.2977 +      break;
  2.2978 +    default:
  2.2979 +      BusLogic_Warning("Unknown Host Adapter Status 0x%02X\n",
  2.2980 +		       HostAdapter, HostAdapterStatus);
  2.2981 +      HostStatus = DID_ERROR;
  2.2982 +      break;
  2.2983 +    }
  2.2984 +  return (HostStatus << 16) | TargetDeviceStatus;
  2.2985 +}
  2.2986 +
  2.2987 +
  2.2988 +/*
  2.2989 +  BusLogic_ScanIncomingMailboxes scans the Incoming Mailboxes saving any
  2.2990 +  Incoming Mailbox entries for completion processing.
  2.2991 +*/
  2.2992 +
  2.2993 +static void BusLogic_ScanIncomingMailboxes(BusLogic_HostAdapter_T *HostAdapter)
  2.2994 +{
  2.2995 +  /*
  2.2996 +    Scan through the Incoming Mailboxes in Strict Round Robin fashion, saving
  2.2997 +    any completed CCBs for further processing.  It is essential that for each
  2.2998 +    CCB and SCSI Command issued, command completion processing is performed
  2.2999 +    exactly once.  Therefore, only Incoming Mailboxes with completion code
  2.3000 +    Command Completed Without Error, Command Completed With Error, or Command
  2.3001 +    Aborted At Host Request are saved for completion processing.  When an
  2.3002 +    Incoming Mailbox has a completion code of Aborted Command Not Found, the
  2.3003 +    CCB had already completed or been aborted before the current Abort request
  2.3004 +    was processed, and so completion processing has already occurred and no
  2.3005 +    further action should be taken.
  2.3006 +  */
  2.3007 +  BusLogic_IncomingMailbox_T *NextIncomingMailbox =
  2.3008 +    HostAdapter->NextIncomingMailbox;
  2.3009 +  BusLogic_CompletionCode_T CompletionCode;
  2.3010 +  while ((CompletionCode = NextIncomingMailbox->CompletionCode) !=
  2.3011 +	 BusLogic_IncomingMailboxFree)
  2.3012 +    {
  2.3013 +      BusLogic_CCB_T *CCB = (BusLogic_CCB_T *)
  2.3014 +	Bus_to_Virtual(NextIncomingMailbox->CCB);
  2.3015 +      if (CompletionCode != BusLogic_AbortedCommandNotFound)
  2.3016 +	{
  2.3017 +	  if (CCB->Status == BusLogic_CCB_Active ||
  2.3018 +	      CCB->Status == BusLogic_CCB_Reset)
  2.3019 +	    {
  2.3020 +	      /*
  2.3021 +		Save the Completion Code for this CCB and queue the CCB
  2.3022 +		for completion processing.
  2.3023 +	      */
  2.3024 +	      CCB->CompletionCode = CompletionCode;
  2.3025 +	      BusLogic_QueueCompletedCCB(CCB);
  2.3026 +	    }
  2.3027 +	  else
  2.3028 +	    {
  2.3029 +	      /*
  2.3030 +		If a CCB ever appears in an Incoming Mailbox and is not marked
  2.3031 +		as status Active or Reset, then there is most likely a bug in
  2.3032 +		the Host Adapter firmware.
  2.3033 +	      */
  2.3034 +	      BusLogic_Warning("Illegal CCB #%ld status %d in "
  2.3035 +			       "Incoming Mailbox\n", HostAdapter,
  2.3036 +			       CCB->SerialNumber, CCB->Status);
  2.3037 +	    }
  2.3038 +	}
  2.3039 +      NextIncomingMailbox->CompletionCode = BusLogic_IncomingMailboxFree;
  2.3040 +      if (++NextIncomingMailbox > HostAdapter->LastIncomingMailbox)
  2.3041 +	NextIncomingMailbox = HostAdapter->FirstIncomingMailbox;
  2.3042 +    }
  2.3043 +  HostAdapter->NextIncomingMailbox = NextIncomingMailbox;
  2.3044 +}
  2.3045 +
  2.3046 +
  2.3047 +/*
  2.3048 +  BusLogic_ProcessCompletedCCBs iterates over the completed CCBs for Host
  2.3049 +  Adapter setting the SCSI Command Result Codes, deallocating the CCBs, and
  2.3050 +  calling the SCSI Subsystem Completion Routines.  The Host Adapter's Lock
  2.3051 +  should already have been acquired by the caller.
  2.3052 +*/
  2.3053 +
  2.3054 +static void BusLogic_ProcessCompletedCCBs(BusLogic_HostAdapter_T *HostAdapter)
  2.3055 +{
  2.3056 +  if (HostAdapter->ProcessCompletedCCBsActive) return;
  2.3057 +  HostAdapter->ProcessCompletedCCBsActive = true;
  2.3058 +  while (HostAdapter->FirstCompletedCCB != NULL)
  2.3059 +    {
  2.3060 +      BusLogic_CCB_T *CCB = HostAdapter->FirstCompletedCCB;
  2.3061 +      SCSI_Command_T *Command = CCB->Command;
  2.3062 +      HostAdapter->FirstCompletedCCB = CCB->Next;
  2.3063 +      if (HostAdapter->FirstCompletedCCB == NULL)
  2.3064 +	HostAdapter->LastCompletedCCB = NULL;
  2.3065 +      /*
  2.3066 +	Process the Completed CCB.
  2.3067 +      */
  2.3068 +      if (CCB->Opcode == BusLogic_BusDeviceReset)
  2.3069 +	{
  2.3070 +	  int TargetID = CCB->TargetID;
  2.3071 +	  BusLogic_Warning("Bus Device Reset CCB #%ld to Target "
  2.3072 +			   "%d Completed\n", HostAdapter,
  2.3073 +			   CCB->SerialNumber, TargetID);
  2.3074 +	  BusLogic_IncrementErrorCounter(
  2.3075 +	    &HostAdapter->TargetStatistics[TargetID].BusDeviceResetsCompleted);
  2.3076 +	  HostAdapter->TargetFlags[TargetID].TaggedQueuingActive = false;
  2.3077 +	  HostAdapter->CommandsSinceReset[TargetID] = 0;
  2.3078 +	  HostAdapter->LastResetCompleted[TargetID] = jiffies;
  2.3079 +	  /*
  2.3080 +	    Place CCB back on the Host Adapter's free list.
  2.3081 +	  */
  2.3082 +	  BusLogic_DeallocateCCB(CCB);
  2.3083 +	  /*
  2.3084 +	    Bus Device Reset CCBs have the Command field non-NULL only when a
  2.3085 +	    Bus Device Reset was requested for a Command that did not have a
  2.3086 +	    currently active CCB in the Host Adapter (i.e., a Synchronous
  2.3087 +	    Bus Device Reset), and hence would not have its Completion Routine
  2.3088 +	    called otherwise.
  2.3089 +	  */
  2.3090 +	  while (Command != NULL)
  2.3091 +	    {
  2.3092 +	      SCSI_Command_T *NextCommand = Command->reset_chain;
  2.3093 +	      Command->reset_chain = NULL;
  2.3094 +	      Command->result = DID_RESET << 16;
  2.3095 +	      Command->scsi_done(Command);
  2.3096 +	      Command = NextCommand;
  2.3097 +	    }
  2.3098 +	  /*
  2.3099 +	    Iterate over the CCBs for this Host Adapter performing completion
  2.3100 +	    processing for any CCBs marked as Reset for this Target.
  2.3101 +	  */
  2.3102 +	  for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
  2.3103 +	    if (CCB->Status == BusLogic_CCB_Reset && CCB->TargetID == TargetID)
  2.3104 +	      {
  2.3105 +		Command = CCB->Command;
  2.3106 +		BusLogic_DeallocateCCB(CCB);
  2.3107 +		HostAdapter->ActiveCommands[TargetID]--;
  2.3108 +		Command->result = DID_RESET << 16;
  2.3109 +		Command->scsi_done(Command);
  2.3110 +	      }
  2.3111 +	  HostAdapter->BusDeviceResetPendingCCB[TargetID] = NULL;
  2.3112 +	}
  2.3113 +      else
  2.3114 +	{
  2.3115 +	  /*
  2.3116 +	    Translate the Completion Code, Host Adapter Status, and Target
  2.3117 +	    Device Status into a SCSI Subsystem Result Code.
  2.3118 +	  */
  2.3119 +	  switch (CCB->CompletionCode)
  2.3120 +	    {
  2.3121 +	    case BusLogic_IncomingMailboxFree:
  2.3122 +	    case BusLogic_AbortedCommandNotFound:
  2.3123 +	    case BusLogic_InvalidCCB:
  2.3124 +	      BusLogic_Warning("CCB #%ld to Target %d Impossible State\n",
  2.3125 +			       HostAdapter, CCB->SerialNumber, CCB->TargetID);
  2.3126 +	      break;
  2.3127 +	    case BusLogic_CommandCompletedWithoutError:
  2.3128 +	      HostAdapter->TargetStatistics[CCB->TargetID]
  2.3129 +			   .CommandsCompleted++;
  2.3130 +	      HostAdapter->TargetFlags[CCB->TargetID]
  2.3131 +			   .CommandSuccessfulFlag = true;
  2.3132 +	      Command->result = DID_OK << 16;
  2.3133 +	      break;
  2.3134 +	    case BusLogic_CommandAbortedAtHostRequest:
  2.3135 +	      BusLogic_Warning("CCB #%ld to Target %d Aborted\n",
  2.3136 +			       HostAdapter, CCB->SerialNumber, CCB->TargetID);
  2.3137 +	      BusLogic_IncrementErrorCounter(
  2.3138 +		&HostAdapter->TargetStatistics[CCB->TargetID]
  2.3139 +			      .CommandAbortsCompleted);
  2.3140 +	      Command->result = DID_ABORT << 16;
  2.3141 +	      break;
  2.3142 +	    case BusLogic_CommandCompletedWithError:
  2.3143 +	      Command->result =
  2.3144 +		BusLogic_ComputeResultCode(HostAdapter,
  2.3145 +					   CCB->HostAdapterStatus,
  2.3146 +					   CCB->TargetDeviceStatus);
  2.3147 +	      if (CCB->HostAdapterStatus != BusLogic_SCSISelectionTimeout)
  2.3148 +		{
  2.3149 +		  HostAdapter->TargetStatistics[CCB->TargetID]
  2.3150 +			       .CommandsCompleted++;
  2.3151 +		  if (BusLogic_GlobalOptions.TraceErrors)
  2.3152 +		    {
  2.3153 +		      int i;
  2.3154 +		      BusLogic_Notice("CCB #%ld Target %d: Result %X Host "
  2.3155 +				      "Adapter Status %02X "
  2.3156 +				      "Target Status %02X\n",
  2.3157 +				      HostAdapter, CCB->SerialNumber,
  2.3158 +				      CCB->TargetID, Command->result,
  2.3159 +				      CCB->HostAdapterStatus,
  2.3160 +				      CCB->TargetDeviceStatus);
  2.3161 +		      BusLogic_Notice("CDB   ", HostAdapter);
  2.3162 +		      for (i = 0; i < CCB->CDB_Length; i++)
  2.3163 +			BusLogic_Notice(" %02X", HostAdapter, CCB->CDB[i]);
  2.3164 +		      BusLogic_Notice("\n", HostAdapter);
  2.3165 +		      BusLogic_Notice("Sense ", HostAdapter);
  2.3166 +		      for (i = 0; i < CCB->SenseDataLength; i++)
  2.3167 +			BusLogic_Notice(" %02X", HostAdapter,
  2.3168 +					Command->sense_buffer[i]);
  2.3169 +		      BusLogic_Notice("\n", HostAdapter);
  2.3170 +		    }
  2.3171 +		}
  2.3172 +	      break;
  2.3173 +	    }
  2.3174 +	  /*
  2.3175 +	    When an INQUIRY command completes normally, save the
  2.3176 +	    CmdQue (Tagged Queuing Supported) and WBus16 (16 Bit
  2.3177 +	    Wide Data Transfers Supported) bits.
  2.3178 +	  */
  2.3179 +	  if (CCB->CDB[0] == INQUIRY && CCB->CDB[1] == 0 &&
  2.3180 +	      CCB->HostAdapterStatus == BusLogic_CommandCompletedNormally)
  2.3181 +	    {
  2.3182 +	      BusLogic_TargetFlags_T *TargetFlags =
  2.3183 +		&HostAdapter->TargetFlags[CCB->TargetID];
  2.3184 +	      SCSI_Inquiry_T *InquiryResult =
  2.3185 +		(SCSI_Inquiry_T *) Command->request_buffer;
  2.3186 +	      TargetFlags->TargetExists = true;
  2.3187 +	      TargetFlags->TaggedQueuingSupported = InquiryResult->CmdQue;
  2.3188 +	      TargetFlags->WideTransfersSupported = InquiryResult->WBus16;
  2.3189 +	    }
  2.3190 +	  /*
  2.3191 +	    Place CCB back on the Host Adapter's free list.
  2.3192 +	  */
  2.3193 +	  BusLogic_DeallocateCCB(CCB);
  2.3194 +	  /*
  2.3195 +	    Call the SCSI Command Completion Routine.
  2.3196 +	  */
  2.3197 +	  Command->scsi_done(Command);
  2.3198 +	}
  2.3199 +    }
  2.3200 +  HostAdapter->ProcessCompletedCCBsActive = false;
  2.3201 +}
  2.3202 +
  2.3203 +
  2.3204 +/*
  2.3205 +  BusLogic_InterruptHandler handles hardware interrupts from BusLogic Host
  2.3206 +  Adapters.
  2.3207 +*/
  2.3208 +
  2.3209 +static void BusLogic_InterruptHandler(int IRQ_Channel,
  2.3210 +				      void *DeviceIdentifier,
  2.3211 +				      Registers_T *InterruptRegisters)
  2.3212 +{
  2.3213 +  BusLogic_HostAdapter_T *HostAdapter =
  2.3214 +    (BusLogic_HostAdapter_T *) DeviceIdentifier;
  2.3215 +  ProcessorFlags_T ProcessorFlags;
  2.3216 +  /*
  2.3217 +    Acquire exclusive access to Host Adapter.
  2.3218 +  */
  2.3219 +  BusLogic_AcquireHostAdapterLockIH(HostAdapter, &ProcessorFlags);
  2.3220 +  /*
  2.3221 +    Handle Interrupts appropriately for each Host Adapter type.
  2.3222 +  */
  2.3223 +  if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
  2.3224 +    {
  2.3225 +      BusLogic_InterruptRegister_T InterruptRegister;
  2.3226 +      /*
  2.3227 +	Read the Host Adapter Interrupt Register.
  2.3228 +      */
  2.3229 +      InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
  2.3230 +      if (InterruptRegister.Bits.InterruptValid)
  2.3231 +	{
  2.3232 +	  /*
  2.3233 +	    Acknowledge the interrupt and reset the Host Adapter
  2.3234 +	    Interrupt Register.
  2.3235 +	  */
  2.3236 +	  BusLogic_InterruptReset(HostAdapter);
  2.3237 +	  /*
  2.3238 +	    Process valid External SCSI Bus Reset and Incoming Mailbox
  2.3239 +	    Loaded Interrupts.  Command Complete Interrupts are noted,
  2.3240 +	    and Outgoing Mailbox Available Interrupts are ignored, as
  2.3241 +	    they are never enabled.
  2.3242 +	  */
  2.3243 +	  if (InterruptRegister.Bits.ExternalBusReset)
  2.3244 +	    HostAdapter->HostAdapterExternalReset = true;
  2.3245 +	  else if (InterruptRegister.Bits.IncomingMailboxLoaded)
  2.3246 +	    BusLogic_ScanIncomingMailboxes(HostAdapter);
  2.3247 +	  else if (InterruptRegister.Bits.CommandComplete)
  2.3248 +	    HostAdapter->HostAdapterCommandCompleted = true;
  2.3249 +	}
  2.3250 +    }
  2.3251 +  else
  2.3252 +    {
  2.3253 +      /*
  2.3254 +	Check if there is a pending interrupt for this Host Adapter.
  2.3255 +      */
  2.3256 +      if (FlashPoint_InterruptPending(HostAdapter->CardHandle))
  2.3257 +	switch (FlashPoint_HandleInterrupt(HostAdapter->CardHandle))
  2.3258 +	  {
  2.3259 +	  case FlashPoint_NormalInterrupt:
  2.3260 +	    break;
  2.3261 +	  case FlashPoint_ExternalBusReset:
  2.3262 +	    HostAdapter->HostAdapterExternalReset = true;
  2.3263 +	    break;
  2.3264 +	  case FlashPoint_InternalError:
  2.3265 +	    BusLogic_Warning("Internal FlashPoint Error detected"
  2.3266 +			     " - Resetting Host Adapter\n", HostAdapter);
  2.3267 +	    HostAdapter->HostAdapterInternalError = true;
  2.3268 +	    break;
  2.3269 +	  }
  2.3270 +    }
  2.3271 +  /*
  2.3272 +    Process any completed CCBs.
  2.3273 +  */
  2.3274 +  if (HostAdapter->FirstCompletedCCB != NULL)
  2.3275 +    BusLogic_ProcessCompletedCCBs(HostAdapter);
  2.3276 +  /*
  2.3277 +    Reset the Host Adapter if requested.
  2.3278 +  */
  2.3279 +  if (HostAdapter->HostAdapterExternalReset ||
  2.3280 +      HostAdapter->HostAdapterInternalError)
  2.3281 +    {
  2.3282 +      BusLogic_ResetHostAdapter(HostAdapter, NULL, 0);
  2.3283 +      HostAdapter->HostAdapterExternalReset = false;
  2.3284 +      HostAdapter->HostAdapterInternalError = false;
  2.3285 +#if 0 /* XEN */
  2.3286 +      scsi_mark_host_reset(HostAdapter->SCSI_Host);
  2.3287 +#endif
  2.3288 +    }
  2.3289 +  /*
  2.3290 +    Release exclusive access to Host Adapter.
  2.3291 +  */
  2.3292 +  BusLogic_ReleaseHostAdapterLockIH(HostAdapter, &ProcessorFlags);
  2.3293 +}
  2.3294 +
  2.3295 +
  2.3296 +/*
  2.3297 +  BusLogic_WriteOutgoingMailbox places CCB and Action Code into an Outgoing
  2.3298 +  Mailbox for execution by Host Adapter.  The Host Adapter's Lock should
  2.3299 +  already have been acquired by the caller.
  2.3300 +*/
  2.3301 +
  2.3302 +static boolean BusLogic_WriteOutgoingMailbox(BusLogic_HostAdapter_T
  2.3303 +					       *HostAdapter,
  2.3304 +					     BusLogic_ActionCode_T ActionCode,
  2.3305 +					     BusLogic_CCB_T *CCB)
  2.3306 +{
  2.3307 +  BusLogic_OutgoingMailbox_T *NextOutgoingMailbox;
  2.3308 +  NextOutgoingMailbox = HostAdapter->NextOutgoingMailbox;
  2.3309 +  if (NextOutgoingMailbox->ActionCode == BusLogic_OutgoingMailboxFree)
  2.3310 +    {
  2.3311 +      CCB->Status = BusLogic_CCB_Active;
  2.3312 +      /*
  2.3313 +	The CCB field must be written before the Action Code field since
  2.3314 +	the Host Adapter is operating asynchronously and the locking code
  2.3315 +	does not protect against simultaneous access by the Host Adapter.
  2.3316 +      */
  2.3317 +      NextOutgoingMailbox->CCB = Virtual_to_Bus(CCB);
  2.3318 +      NextOutgoingMailbox->ActionCode = ActionCode;
  2.3319 +      BusLogic_StartMailboxCommand(HostAdapter);
  2.3320 +      if (++NextOutgoingMailbox > HostAdapter->LastOutgoingMailbox)
  2.3321 +	NextOutgoingMailbox = HostAdapter->FirstOutgoingMailbox;
  2.3322 +      HostAdapter->NextOutgoingMailbox = NextOutgoingMailbox;
  2.3323 +      if (ActionCode == BusLogic_MailboxStartCommand)
  2.3324 +	{
  2.3325 +	  HostAdapter->ActiveCommands[CCB->TargetID]++;
  2.3326 +	  if (CCB->Opcode != BusLogic_BusDeviceReset)
  2.3327 +	    HostAdapter->TargetStatistics[CCB->TargetID].CommandsAttempted++;
  2.3328 +	}
  2.3329 +      return true;
  2.3330 +    }
  2.3331 +  return false;
  2.3332 +}
  2.3333 +
  2.3334 +
  2.3335 +/*
  2.3336 +  BusLogic_QueueCommand creates a CCB for Command and places it into an
  2.3337 +  Outgoing Mailbox for execution by the associated Host Adapter.
  2.3338 +*/
  2.3339 +
  2.3340 +int BusLogic_QueueCommand(SCSI_Command_T *Command,
  2.3341 +			  void (*CompletionRoutine)(SCSI_Command_T *))
  2.3342 +{
  2.3343 +  BusLogic_HostAdapter_T *HostAdapter =
  2.3344 +    (BusLogic_HostAdapter_T *) Command->host->hostdata;
  2.3345 +  BusLogic_TargetFlags_T *TargetFlags =
  2.3346 +    &HostAdapter->TargetFlags[Command->target];
  2.3347 +  BusLogic_TargetStatistics_T *TargetStatistics =
  2.3348 +    HostAdapter->TargetStatistics;
  2.3349 +  unsigned char *CDB = Command->cmnd;
  2.3350 +  int CDB_Length = Command->cmd_len;
  2.3351 +  int TargetID = Command->target;
  2.3352 +  int LogicalUnit = Command->lun;
  2.3353 +  void *BufferPointer = Command->request_buffer;
  2.3354 +  int BufferLength = Command->request_bufflen;
  2.3355 +  int SegmentCount = Command->use_sg;
  2.3356 +  ProcessorFlags_T ProcessorFlags;
  2.3357 +  BusLogic_CCB_T *CCB;
  2.3358 +  /*
  2.3359 +    SCSI REQUEST_SENSE commands will be executed automatically by the Host
  2.3360 +    Adapter for any errors, so they should not be executed explicitly unless
  2.3361 +    the Sense Data is zero indicating that no error occurred.
  2.3362 +  */
  2.3363 +  if (CDB[0] == REQUEST_SENSE && Command->sense_buffer[0] != 0)
  2.3364 +    {
  2.3365 +      Command->result = DID_OK << 16;
  2.3366 +      CompletionRoutine(Command);
  2.3367 +      return 0;
  2.3368 +    }
  2.3369 +  /*
  2.3370 +    Acquire exclusive access to Host Adapter.
  2.3371 +  */
  2.3372 +  BusLogic_AcquireHostAdapterLock(HostAdapter, &ProcessorFlags);
  2.3373 +  /*
  2.3374 +    Allocate a CCB from the Host Adapter's free list.  In the unlikely event
  2.3375 +    that there are none available and memory allocation fails, wait 1 second
  2.3376 +    and try again.  If that fails, the Host Adapter is probably hung so signal
  2.3377 +    an error as a Host Adapter Hard Reset should be initiated soon.
  2.3378 +  */
  2.3379 +  CCB = BusLogic_AllocateCCB(HostAdapter);
  2.3380 +  if (CCB == NULL)
  2.3381 +    {
  2.3382 +      BusLogic_Delay(1);
  2.3383 +      CCB = BusLogic_AllocateCCB(HostAdapter);
  2.3384 +      if (CCB == NULL)
  2.3385 +	{
  2.3386 +	  Command->result = DID_ERROR << 16;
  2.3387 +	  CompletionRoutine(Command);
  2.3388 +	  goto Done;
  2.3389 +	}
  2.3390 +    }
  2.3391 +  /*
  2.3392 +    Initialize the fields in the BusLogic Command Control Block (CCB).
  2.3393 +  */
  2.3394 +  if (SegmentCount == 0)
  2.3395 +    {
  2.3396 +      CCB->Opcode = BusLogic_InitiatorCCB;
  2.3397 +      CCB->DataLength = BufferLength;
  2.3398 +      CCB->DataPointer = Virtual_to_Bus(BufferPointer);
  2.3399 +    }
  2.3400 +  else
  2.3401 +    {
  2.3402 +      SCSI_ScatterList_T *ScatterList = (SCSI_ScatterList_T *) BufferPointer;
  2.3403 +      int Segment;
  2.3404 +      CCB->Opcode = BusLogic_InitiatorCCB_ScatterGather;
  2.3405 +      CCB->DataLength = SegmentCount * sizeof(BusLogic_ScatterGatherSegment_T);
  2.3406 +      if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
  2.3407 +	CCB->DataPointer = Virtual_to_Bus(CCB->ScatterGatherList);
  2.3408 +      else CCB->DataPointer = Virtual_to_32Bit_Virtual(CCB->ScatterGatherList);
  2.3409 +      for (Segment = 0; Segment < SegmentCount; Segment++)
  2.3410 +	{
  2.3411 +	  CCB->ScatterGatherList[Segment].SegmentByteCount =
  2.3412 +	    ScatterList[Segment].length;
  2.3413 +	  CCB->ScatterGatherList[Segment].SegmentDataPointer =
  2.3414 +	    Virtual_to_Bus(ScatterList[Segment].address);
  2.3415 +	}
  2.3416 +    }
  2.3417 +  switch (CDB[0])
  2.3418 +    {
  2.3419 +    case READ_6:
  2.3420 +    case READ_10:
  2.3421 +      CCB->DataDirection = BusLogic_DataInLengthChecked;
  2.3422 +      TargetStatistics[TargetID].ReadCommands++;
  2.3423 +      BusLogic_IncrementByteCounter(
  2.3424 +	&TargetStatistics[TargetID].TotalBytesRead, BufferLength);
  2.3425 +      BusLogic_IncrementSizeBucket(
  2.3426 +	TargetStatistics[TargetID].ReadCommandSizeBuckets, BufferLength);
  2.3427 +      break;
  2.3428 +    case WRITE_6:
  2.3429 +    case WRITE_10:
  2.3430 +      CCB->DataDirection = BusLogic_DataOutLengthChecked;
  2.3431 +      TargetStatistics[TargetID].WriteCommands++;
  2.3432 +      BusLogic_IncrementByteCounter(
  2.3433 +	&TargetStatistics[TargetID].TotalBytesWritten, BufferLength);
  2.3434 +      BusLogic_IncrementSizeBucket(
  2.3435 +	TargetStatistics[TargetID].WriteCommandSizeBuckets, BufferLength);
  2.3436 +      break;
  2.3437 +    default:
  2.3438 +      CCB->DataDirection = BusLogic_UncheckedDataTransfer;
  2.3439 +      break;
  2.3440 +    }
  2.3441 +  CCB->CDB_Length = CDB_Length;
  2.3442 +  CCB->SenseDataLength = sizeof(Command->sense_buffer);
  2.3443 +  CCB->HostAdapterStatus = 0;
  2.3444 +  CCB->TargetDeviceStatus = 0;
  2.3445 +  CCB->TargetID = TargetID;
  2.3446 +  CCB->LogicalUnit = LogicalUnit;
  2.3447 +  CCB->TagEnable = false;
  2.3448 +  CCB->LegacyTagEnable = false;
  2.3449 +  /*
  2.3450 +    BusLogic recommends that after a Reset the first couple of commands that
  2.3451 +    are sent to a Target Device be sent in a non Tagged Queue fashion so that
  2.3452 +    the Host Adapter and Target Device can establish Synchronous and Wide
  2.3453 +    Transfer before Queue Tag messages can interfere with the Synchronous and
  2.3454 +    Wide Negotiation messages.  By waiting to enable Tagged Queuing until after
  2.3455 +    the first BusLogic_MaxTaggedQueueDepth commands have been queued, it is
  2.3456 +    assured that after a Reset any pending commands are requeued before Tagged
  2.3457 +    Queuing is enabled and that the Tagged Queuing message will not occur while
  2.3458 +    the partition table is being printed.  In addition, some devices do not
  2.3459 +    properly handle the transition from non-tagged to tagged commands, so it is
  2.3460 +    necessary to wait until there are no pending commands for a target device
  2.3461 +    before queuing tagged commands.
  2.3462 +  */
  2.3463 +  if (HostAdapter->CommandsSinceReset[TargetID]++ >=
  2.3464 +	BusLogic_MaxTaggedQueueDepth &&
  2.3465 +      !TargetFlags->TaggedQueuingActive &&
  2.3466 +      HostAdapter->ActiveCommands[TargetID] == 0 &&
  2.3467 +      TargetFlags->TaggedQueuingSupported &&
  2.3468 +      (HostAdapter->TaggedQueuingPermitted & (1 << TargetID)))
  2.3469 +    {
  2.3470 +      TargetFlags->TaggedQueuingActive = true;
  2.3471 +      BusLogic_Notice("Tagged Queuing now active for Target %d\n",
  2.3472 +		      HostAdapter, TargetID);
  2.3473 +    }
  2.3474 +  if (TargetFlags->TaggedQueuingActive)
  2.3475 +    {
  2.3476 +      BusLogic_QueueTag_T QueueTag = BusLogic_SimpleQueueTag;
  2.3477 +      /*
  2.3478 +	When using Tagged Queuing with Simple Queue Tags, it appears that disk
  2.3479 +	drive controllers do not guarantee that a queued command will not
  2.3480 +	remain in a disconnected state indefinitely if commands that read or
  2.3481 +	write nearer the head position continue to arrive without interruption.
  2.3482 +	Therefore, for each Target Device this driver keeps track of the last
  2.3483 +	time either the queue was empty or an Ordered Queue Tag was issued.  If
  2.3484 +	more than 4 seconds (one fifth of the 20 second disk timeout) have
  2.3485 +	elapsed since this last sequence point, this command will be issued
  2.3486 +	with an Ordered Queue Tag rather than a Simple Queue Tag, which forces
  2.3487 +	the Target Device to complete all previously queued commands before
  2.3488 +	this command may be executed.
  2.3489 +      */
  2.3490 +      if (HostAdapter->ActiveCommands[TargetID] == 0)
  2.3491 +	HostAdapter->LastSequencePoint[TargetID] = jiffies;
  2.3492 +      else if (jiffies - HostAdapter->LastSequencePoint[TargetID] > 4*HZ)
  2.3493 +	{
  2.3494 +	  HostAdapter->LastSequencePoint[TargetID] = jiffies;
  2.3495 +	  QueueTag = BusLogic_OrderedQueueTag;
  2.3496 +	}
  2.3497 +      if (HostAdapter->ExtendedLUNSupport)
  2.3498 +	{
  2.3499 +	  CCB->TagEnable = true;
  2.3500 +	  CCB->QueueTag = QueueTag;
  2.3501 +	}
  2.3502 +      else
  2.3503 +	{
  2.3504 +	  CCB->LegacyTagEnable = true;
  2.3505 +	  CCB->LegacyQueueTag = QueueTag;
  2.3506 +	}
  2.3507 +    }
  2.3508 +  memcpy(CCB->CDB, CDB, CDB_Length);
  2.3509 +  CCB->SenseDataPointer = Virtual_to_Bus(&Command->sense_buffer);
  2.3510 +  CCB->Command = Command;
  2.3511 +  Command->scsi_done = CompletionRoutine;
  2.3512 +  if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
  2.3513 +    {
  2.3514 +      /*
  2.3515 +	Place the CCB in an Outgoing Mailbox.  The higher levels of the SCSI
  2.3516 +	Subsystem should not attempt to queue more commands than can be placed
  2.3517 +	in Outgoing Mailboxes, so there should always be one free.  In the
  2.3518 +	unlikely event that there are none available, wait 1 second and try
  2.3519 +	again.  If that fails, the Host Adapter is probably hung so signal an
  2.3520 +	error as a Host Adapter Hard Reset should be initiated soon.
  2.3521 +      */
  2.3522 +      if (!BusLogic_WriteOutgoingMailbox(
  2.3523 +	     HostAdapter, BusLogic_MailboxStartCommand, CCB))
  2.3524 +	{
  2.3525 +	  BusLogic_Warning("Unable to write Outgoing Mailbox - "
  2.3526 +			   "Pausing for 1 second\n", HostAdapter);
  2.3527 +	  BusLogic_Delay(1);
  2.3528 +	  if (!BusLogic_WriteOutgoingMailbox(
  2.3529 +		 HostAdapter, BusLogic_MailboxStartCommand, CCB))
  2.3530 +	    {
  2.3531 +	      BusLogic_Warning("Still unable to write Outgoing Mailbox - "
  2.3532 +			       "Host Adapter Dead?\n", HostAdapter);
  2.3533 +	      BusLogic_DeallocateCCB(CCB);
  2.3534 +	      Command->result = DID_ERROR << 16;
  2.3535 +	      Command->scsi_done(Command);
  2.3536 +	    }
  2.3537 +	}
  2.3538 +    }
  2.3539 +  else
  2.3540 +    {
  2.3541 +      /*
  2.3542 +	Call the FlashPoint SCCB Manager to start execution of the CCB.
  2.3543 +      */
  2.3544 +      CCB->Status = BusLogic_CCB_Active;
  2.3545 +      HostAdapter->ActiveCommands[TargetID]++;
  2.3546 +      TargetStatistics[TargetID].CommandsAttempted++;
  2.3547 +      FlashPoint_StartCCB(HostAdapter->CardHandle, CCB);
  2.3548 +      /*
  2.3549 +	The Command may have already completed and BusLogic_QueueCompletedCCB
  2.3550 +	been called, or it may still be pending.
  2.3551 +      */
  2.3552 +      if (CCB->Status == BusLogic_CCB_Completed)
  2.3553 +	BusLogic_ProcessCompletedCCBs(HostAdapter);
  2.3554 +    }
  2.3555 +  /*
  2.3556 +    Release exclusive access to Host Adapter.
  2.3557 +  */
  2.3558 +Done:
  2.3559 +  BusLogic_ReleaseHostAdapterLock(HostAdapter, &ProcessorFlags);
  2.3560 +  return 0;
  2.3561 +}
  2.3562 +
  2.3563 +
  2.3564 +/*
  2.3565 +  BusLogic_AbortCommand aborts Command if possible.
  2.3566 +*/
  2.3567 +
  2.3568 +int BusLogic_AbortCommand(SCSI_Command_T *Command)
  2.3569 +{
  2.3570 +  BusLogic_HostAdapter_T *HostAdapter =
  2.3571 +    (BusLogic_HostAdapter_T *) Command->host->hostdata;
  2.3572 +  int TargetID = Command->target;
  2.3573 +  ProcessorFlags_T ProcessorFlags;
  2.3574 +  BusLogic_CCB_T *CCB;
  2.3575 +  int Result;
  2.3576 +  BusLogic_IncrementErrorCounter(
  2.3577 +    &HostAdapter->TargetStatistics[TargetID].CommandAbortsRequested);
  2.3578 +  /*
  2.3579 +    Acquire exclusive access to Host Adapter.
  2.3580 +  */
  2.3581 +  BusLogic_AcquireHostAdapterLock(HostAdapter, &ProcessorFlags);
  2.3582 +  /*
  2.3583 +    If this Command has already completed, then no Abort is necessary.
  2.3584 +  */
  2.3585 +  if (Command->serial_number != Command->serial_number_at_timeout)
  2.3586 +    {
  2.3587 +      BusLogic_Warning("Unable to Abort Command to Target %d - "
  2.3588 +		       "Already Completed\n", HostAdapter, TargetID);
  2.3589 +      Result = SCSI_ABORT_NOT_RUNNING;
  2.3590 +      goto Done;
  2.3591 +    }
  2.3592 +  /*
  2.3593 +    Attempt to find an Active CCB for this Command.  If no Active CCB for this
  2.3594 +    Command is found, then no Abort is necessary.
  2.3595 +  */
  2.3596 +  for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
  2.3597 +    if (CCB->Command == Command) break;
  2.3598 +  if (CCB == NULL)
  2.3599 +    {
  2.3600 +      BusLogic_Warning("Unable to Abort Command to Target %d - "
  2.3601 +		       "No CCB Found\n", HostAdapter, TargetID);
  2.3602 +      Result = SCSI_ABORT_NOT_RUNNING;
  2.3603 +      goto Done;
  2.3604 +    }
  2.3605 +  else if (CCB->Status == BusLogic_CCB_Completed)
  2.3606 +    {
  2.3607 +      BusLogic_Warning("Unable to Abort Command to Target %d - "
  2.3608 +		       "CCB Completed\n", HostAdapter, TargetID);
  2.3609 +      Result = SCSI_ABORT_NOT_RUNNING;
  2.3610 +      goto Done;
  2.3611 +    }
  2.3612 +  else if (CCB->Status == BusLogic_CCB_Reset)
  2.3613 +    {
  2.3614 +      BusLogic_Warning("Unable to Abort Command to Target %d - "
  2.3615 +		       "CCB Reset\n", HostAdapter, TargetID);
  2.3616 +      Result = SCSI_ABORT_PENDING;
  2.3617 +      goto Done;
  2.3618 +    }
  2.3619 +  if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
  2.3620 +    {
  2.3621 +      /*
  2.3622 +	Attempt to Abort this CCB.  MultiMaster Firmware versions prior to 5.xx
  2.3623 +	do not generate Abort Tag messages, but only generate the non-tagged
  2.3624 +	Abort message.  Since non-tagged commands are not sent by the Host
  2.3625 +	Adapter until the queue of outstanding tagged commands has completed,
  2.3626 +	and the Abort message is treated as a non-tagged command, it is
  2.3627 +	effectively impossible to abort commands when Tagged Queuing is active.
  2.3628 +	Firmware version 5.xx does generate Abort Tag messages, so it is
  2.3629 +	possible to abort commands when Tagged Queuing is active.
  2.3630 +      */
  2.3631 +      if (HostAdapter->TargetFlags[TargetID].TaggedQueuingActive &&
  2.3632 +	  HostAdapter->FirmwareVersion[0] < '5')
  2.3633 +	{
  2.3634 +	  BusLogic_Warning("Unable to Abort CCB #%ld to Target %d - "
  2.3635 +			   "Abort Tag Not Supported\n",
  2.3636 +			   HostAdapter, CCB->SerialNumber, TargetID);
  2.3637 +	  Result = SCSI_ABORT_SNOOZE;
  2.3638 +	}
  2.3639 +      else if (BusLogic_WriteOutgoingMailbox(
  2.3640 +		 HostAdapter, BusLogic_MailboxAbortCommand, CCB))
  2.3641 +	{
  2.3642 +	  BusLogic_Warning("Aborting CCB #%ld to Target %d\n",
  2.3643 +			   HostAdapter, CCB->SerialNumber, TargetID);
  2.3644 +	  BusLogic_IncrementErrorCounter(
  2.3645 +	    &HostAdapter->TargetStatistics[TargetID].CommandAbortsAttempted);
  2.3646 +	  Result = SCSI_ABORT_PENDING;
  2.3647 +	}
  2.3648 +      else
  2.3649 +	{
  2.3650 +	  BusLogic_Warning("Unable to Abort CCB #%ld to Target %d - "
  2.3651 +			   "No Outgoing Mailboxes\n",
  2.3652 +			    HostAdapter, CCB->SerialNumber, TargetID);
  2.3653 +	  Result = SCSI_ABORT_BUSY;
  2.3654 +	}
  2.3655 +    }
  2.3656 +  else
  2.3657 +    {
  2.3658 +      /*
  2.3659 +	Call the FlashPoint SCCB Manager to abort execution of the CCB.
  2.3660 +      */
  2.3661 +      BusLogic_Warning("Aborting CCB #%ld to Target %d\n",
  2.3662 +		       HostAdapter, CCB->SerialNumber, TargetID);
  2.3663 +      BusLogic_IncrementErrorCounter(
  2.3664 +	&HostAdapter->TargetStatistics[TargetID].CommandAbortsAttempted);
  2.3665 +      FlashPoint_AbortCCB(HostAdapter->CardHandle, CCB);
  2.3666 +      /*
  2.3667 +	The Abort may have already been completed and
  2.3668 +	BusLogic_QueueCompletedCCB been called, or it
  2.3669 +	may still be pending.
  2.3670 +      */
  2.3671 +      Result = SCSI_ABORT_PENDING;
  2.3672 +      if (CCB->Status == BusLogic_CCB_Completed)
  2.3673 +	{
  2.3674 +	  BusLogic_ProcessCompletedCCBs(HostAdapter);
  2.3675 +	  Result = SCSI_ABORT_SUCCESS;
  2.3676 +	}
  2.3677 +    }
  2.3678 +  /*
  2.3679 +    Release exclusive access to Host Adapter.
  2.3680 +  */
  2.3681 +Done:
  2.3682 +  BusLogic_ReleaseHostAdapterLock(HostAdapter, &ProcessorFlags);
  2.3683 +  return Result;
  2.3684 +}
  2.3685 +
  2.3686 +
  2.3687 +/*
  2.3688 +  BusLogic_ResetHostAdapter resets Host Adapter if possible, marking all
  2.3689 +  currently executing SCSI Commands as having been Reset.
  2.3690 +*/
  2.3691 +
  2.3692 +static int BusLogic_ResetHostAdapter(BusLogic_HostAdapter_T *HostAdapter,
  2.3693 +				     SCSI_Command_T *Command,
  2.3694 +				     unsigned int ResetFlags)
  2.3695 +{
  2.3696 +  ProcessorFlags_T ProcessorFlags;
  2.3697 +  BusLogic_CCB_T *CCB;
  2.3698 +  int TargetID, Result;
  2.3699 +  boolean HardReset;
  2.3700 +  if (HostAdapter->HostAdapterExternalReset)
  2.3701 +    {
  2.3702 +      BusLogic_IncrementErrorCounter(&HostAdapter->ExternalHostAdapterResets);
  2.3703 +      HardReset = false;
  2.3704 +    }
  2.3705 +  else if (HostAdapter->HostAdapterInternalError)
  2.3706 +    {
  2.3707 +      BusLogic_IncrementErrorCounter(&HostAdapter->HostAdapterInternalErrors);
  2.3708 +      HardReset = true;
  2.3709 +    }
  2.3710 +  else
  2.3711 +    {
  2.3712 +      BusLogic_IncrementErrorCounter(
  2.3713 +	&HostAdapter->TargetStatistics[Command->target]
  2.3714 +		      .HostAdapterResetsRequested);
  2.3715 +      HardReset = true;
  2.3716 +    }
  2.3717 +  /*
  2.3718 +    Acquire exclusive access to Host Adapter.
  2.3719 +  */
  2.3720 +  BusLogic_AcquireHostAdapterLock(HostAdapter, &ProcessorFlags);
  2.3721 +  /*
  2.3722 +    If this is an Asynchronous Reset and this Command has already completed,
  2.3723 +    then no Reset is necessary.
  2.3724 +  */
  2.3725 +  if (ResetFlags & SCSI_RESET_ASYNCHRONOUS)
  2.3726 +    {
  2.3727 +      TargetID = Command->target;
  2.3728 +      if (Command->serial_number != Command->serial_number_at_timeout)
  2.3729 +	{
  2.3730 +	  BusLogic_Warning("Unable to Reset Command to Target %d - "
  2.3731 +			   "Already Completed or Reset\n",
  2.3732 +			   HostAdapter, TargetID);
  2.3733 +	  Result = SCSI_RESET_NOT_RUNNING;
  2.3734 +	  goto Done;
  2.3735 +      }
  2.3736 +      for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
  2.3737 +	if (CCB->Command == Command) break;
  2.3738 +      if (CCB == NULL)
  2.3739 +	{
  2.3740 +	  BusLogic_Warning("Unable to Reset Command to Target %d - "
  2.3741 +			   "No CCB Found\n", HostAdapter, TargetID);
  2.3742 +	  Result = SCSI_RESET_NOT_RUNNING;
  2.3743 +	  goto Done;
  2.3744 +	}
  2.3745 +      else if (CCB->Status == BusLogic_CCB_Completed)
  2.3746 +	{
  2.3747 +	  BusLogic_Warning("Unable to Reset Command to Target %d - "
  2.3748 +			   "CCB Completed\n", HostAdapter, TargetID);
  2.3749 +	  Result = SCSI_RESET_NOT_RUNNING;
  2.3750 +	  goto Done;
  2.3751 +	}
  2.3752 +      else if (CCB->Status == BusLogic_CCB_Reset &&
  2.3753 +	       HostAdapter->BusDeviceResetPendingCCB[TargetID] == NULL)
  2.3754 +	{
  2.3755 +	  BusLogic_Warning("Unable to Reset Command to Target %d - "
  2.3756 +			   "Reset Pending\n", HostAdapter, TargetID);
  2.3757 +	  Result = SCSI_RESET_PENDING;
  2.3758 +	  goto Done;
  2.3759 +	}
  2.3760 +    }
  2.3761 +  if (Command == NULL)
  2.3762 +    {
  2.3763 +      if (HostAdapter->HostAdapterInternalError)
  2.3764 +	BusLogic_Warning("Resetting %s due to Host Adapter Internal Error\n",
  2.3765 +			 HostAdapter, HostAdapter->FullModelName);
  2.3766 +      else BusLogic_Warning("Resetting %s due to External SCSI Bus Reset\n",
  2.3767 +			    HostAdapter, HostAdapter->FullModelName);
  2.3768 +    }
  2.3769 +  else
  2.3770 +    {
  2.3771 +      BusLogic_Warning("Resetting %s due to Target %d\n", HostAdapter,
  2.3772 +		       HostAdapter->FullModelName, Command->target);
  2.3773 +      BusLogic_IncrementErrorCounter(
  2.3774 +	&HostAdapter->TargetStatistics[Command->target]
  2.3775 +		      .HostAdapterResetsAttempted);
  2.3776 +    }
  2.3777 +  /*
  2.3778 +    Attempt to Reset and Reinitialize the Host Adapter.
  2.3779 +  */
  2.3780 +  if (!(BusLogic_HardwareResetHostAdapter(HostAdapter, HardReset) &&
  2.3781 +	BusLogic_InitializeHostAdapter(HostAdapter)))
  2.3782 +    {
  2.3783 +      BusLogic_Error("Resetting %s Failed\n", HostAdapter,
  2.3784 +		     HostAdapter->FullModelName);
  2.3785 +      Result = SCSI_RESET_ERROR;
  2.3786 +      goto Done;
  2.3787 +    }
  2.3788 +  if (Command != NULL)
  2.3789 +    BusLogic_IncrementErrorCounter(
  2.3790 +      &HostAdapter->TargetStatistics[Command->target]
  2.3791 +		    .HostAdapterResetsCompleted);
  2.3792 +  /*
  2.3793 +    Mark all currently executing CCBs as having been Reset.
  2.3794 +  */
  2.3795 +  for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
  2.3796 +    if (CCB->Status == BusLogic_CCB_Active)
  2.3797 +      CCB->Status = BusLogic_CCB_Reset;
  2.3798 +  /*
  2.3799 +    Wait a few seconds between the Host Adapter Hard Reset which initiates
  2.3800 +    a SCSI Bus Reset and issuing any SCSI Commands.  Some SCSI devices get
  2.3801 +    confused if they receive SCSI Commands too soon after a SCSI Bus Reset.
  2.3802 +    Note that a timer interrupt may occur here, but all active CCBs have
  2.3803 +    already been marked Reset and so a reentrant call will return Pending.
  2.3804 +  */
  2.3805 +  if (HardReset)
  2.3806 +    BusLogic_Delay(HostAdapter->BusSettleTime);
  2.3807 +  /*
  2.3808 +    If this is a Synchronous Reset, perform completion processing for
  2.3809 +    the Command being Reset.
  2.3810 +  */
  2.3811 +  if (ResetFlags & SCSI_RESET_SYNCHRONOUS)
  2.3812 +    {
  2.3813 +      Command->result = DID_RESET << 16;
  2.3814 +      Command->scsi_done(Command);
  2.3815 +    }
  2.3816 +  /*
  2.3817 +    Perform completion processing for all CCBs marked as Reset.
  2.3818 +  */
  2.3819 +  for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
  2.3820 +    if (CCB->Status == BusLogic_CCB_Reset)
  2.3821 +      {
  2.3822 +	Command = CCB->Command;
  2.3823 +	BusLogic_DeallocateCCB(CCB);
  2.3824 +	while (Command != NULL)
  2.3825 +	  {
  2.3826 +	    SCSI_Command_T *NextCommand = Command->reset_chain;
  2.3827 +	    Command->reset_chain = NULL;
  2.3828 +	    Command->result = DID_RESET << 16;
  2.3829 +	    Command->scsi_done(Command);
  2.3830 +	    Command = NextCommand;
  2.3831 +	  }
  2.3832 +      }
  2.3833 +  for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.3834 +    {
  2.3835 +      HostAdapter->LastResetAttempted[TargetID] = jiffies;
  2.3836 +      HostAdapter->LastResetCompleted[TargetID] = jiffies;
  2.3837 +    }
  2.3838 +  Result = SCSI_RESET_SUCCESS | SCSI_RESET_HOST_RESET;
  2.3839 +  /*
  2.3840 +    Release exclusive access to Host Adapter.
  2.3841 +  */
  2.3842 +Done:
  2.3843 +  BusLogic_ReleaseHostAdapterLock(HostAdapter, &ProcessorFlags);
  2.3844 +  return Result;
  2.3845 +}
  2.3846 +
  2.3847 +
  2.3848 +/*
  2.3849 +  BusLogic_SendBusDeviceReset sends a Bus Device Reset to the Target
  2.3850 +  Device associated with Command.
  2.3851 +*/
  2.3852 +
  2.3853 +static int BusLogic_SendBusDeviceReset(BusLogic_HostAdapter_T *HostAdapter,
  2.3854 +				       SCSI_Command_T *Command,
  2.3855 +				       unsigned int ResetFlags)
  2.3856 +{
  2.3857 +  int TargetID = Command->target;
  2.3858 +  BusLogic_CCB_T *CCB, *XCCB;
  2.3859 +  ProcessorFlags_T ProcessorFlags;
  2.3860 +  int Result = -1;
  2.3861 +  BusLogic_IncrementErrorCounter(
  2.3862 +    &HostAdapter->TargetStatistics[TargetID].BusDeviceResetsRequested);
  2.3863 +  /*
  2.3864 +    Acquire exclusive access to Host Adapter.
  2.3865 +  */
  2.3866 +  BusLogic_AcquireHostAdapterLock(HostAdapter, &ProcessorFlags);
  2.3867 +  /*
  2.3868 +    If this is an Asynchronous Reset and this Command has already completed,
  2.3869 +    then no Reset is necessary.
  2.3870 +  */
  2.3871 +  if (ResetFlags & SCSI_RESET_ASYNCHRONOUS)
  2.3872 +    {
  2.3873 +      if (Command->serial_number != Command->serial_number_at_timeout)
  2.3874 +	{
  2.3875 +	  BusLogic_Warning("Unable to Reset Command to Target %d - "
  2.3876 +			   "Already Completed\n", HostAdapter, TargetID);
  2.3877 +	  Result = SCSI_RESET_NOT_RUNNING;
  2.3878 +	  goto Done;
  2.3879 +	}
  2.3880 +      for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
  2.3881 +	if (CCB->Command == Command) break;
  2.3882 +      if (CCB == NULL)
  2.3883 +	{
  2.3884 +	  BusLogic_Warning("Unable to Reset Command to Target %d - "
  2.3885 +			   "No CCB Found\n", HostAdapter, TargetID);
  2.3886 +	  Result = SCSI_RESET_NOT_RUNNING;
  2.3887 +	  goto Done;
  2.3888 +	}
  2.3889 +      else if (CCB->Status == BusLogic_CCB_Completed)
  2.3890 +	{
  2.3891 +	  BusLogic_Warning("Unable to Reset Command to Target %d - "
  2.3892 +			   "CCB Completed\n", HostAdapter, TargetID);
  2.3893 +	  Result = SCSI_RESET_NOT_RUNNING;
  2.3894 +	  goto Done;
  2.3895 +	}
  2.3896 +      else if (CCB->Status == BusLogic_CCB_Reset)
  2.3897 +	{
  2.3898 +	  BusLogic_Warning("Unable to Reset Command to Target %d - "
  2.3899 +			   "Reset Pending\n", HostAdapter, TargetID);
  2.3900 +	  Result = SCSI_RESET_PENDING;
  2.3901 +	  goto Done;
  2.3902 +	}
  2.3903 +      else if (HostAdapter->BusDeviceResetPendingCCB[TargetID] != NULL)
  2.3904 +	{
  2.3905 +	  BusLogic_Warning("Bus Device Reset already pending to Target %d\n",
  2.3906 +			   HostAdapter, TargetID);
  2.3907 +	  goto Done;
  2.3908 +	}
  2.3909 +    }
  2.3910 +  /*
  2.3911 +    If this is a Synchronous Reset and a Bus Device Reset is already pending
  2.3912 +    for this Target Device, do not send a second one.  Add this Command to
  2.3913 +    the list of Commands for which completion processing must be performed
  2.3914 +    when the Bus Device Reset CCB completes.
  2.3915 +  */
  2.3916 +  if (ResetFlags & SCSI_RESET_SYNCHRONOUS)
  2.3917 +    if ((CCB = HostAdapter->BusDeviceResetPendingCCB[TargetID]) != NULL)
  2.3918 +      {
  2.3919 +	Command->reset_chain = CCB->Command;
  2.3920 +	CCB->Command = Command;
  2.3921 +	BusLogic_Warning("Unable to Reset Command to Target %d - "
  2.3922 +			 "Reset Pending\n", HostAdapter, TargetID);
  2.3923 +	Result = SCSI_RESET_PENDING;
  2.3924 +	goto Done;
  2.3925 +      }
  2.3926 +  if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
  2.3927 +    {
  2.3928 +      /*
  2.3929 +	MultiMaster Firmware versions prior to 5.xx treat a Bus Device Reset as
  2.3930 +	a non-tagged command.  Since non-tagged commands are not sent by the
  2.3931 +	Host Adapter until the queue of outstanding tagged commands has
  2.3932 +	completed, it is effectively impossible to send a Bus Device Reset
  2.3933 +	while there are tagged commands outstanding.  Therefore, in that case a
  2.3934 +	full Host Adapter Hard Reset and SCSI Bus Reset must be done.
  2.3935 +      */
  2.3936 +      if (HostAdapter->TargetFlags[TargetID].TaggedQueuingActive &&
  2.3937 +	  HostAdapter->ActiveCommands[TargetID] > 0 &&
  2.3938 +	  HostAdapter->FirmwareVersion[0] < '5')
  2.3939 +	goto Done;
  2.3940 +    }
  2.3941 +  /*
  2.3942 +    Allocate a CCB from the Host Adapter's free list.  In the unlikely event
  2.3943 +    that there are none available and memory allocation fails, attempt a full
  2.3944 +    Host Adapter Hard Reset and SCSI Bus Reset.
  2.3945 +  */
  2.3946 +  CCB = BusLogic_AllocateCCB(HostAdapter);
  2.3947 +  if (CCB == NULL) goto Done;
  2.3948 +  BusLogic_Warning("Sending Bus Device Reset CCB #%ld to Target %d\n",
  2.3949 +		   HostAdapter, CCB->SerialNumber, TargetID);
  2.3950 +  CCB->Opcode = BusLogic_BusDeviceReset;
  2.3951 +  CCB->TargetID = TargetID;
  2.3952 +  /*
  2.3953 +    For Synchronous Resets, arrange for the interrupt handler to perform
  2.3954 +    completion processing for the Command being Reset.
  2.3955 +  */
  2.3956 +  if (ResetFlags & SCSI_RESET_SYNCHRONOUS)
  2.3957 +    {
  2.3958 +      Command->reset_chain = NULL;
  2.3959 +      CCB->Command = Command;
  2.3960 +    }
  2.3961 +  if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
  2.3962 +    {
  2.3963 +      /*
  2.3964 +	Attempt to write an Outgoing Mailbox with the Bus Device Reset CCB.
  2.3965 +	If sending a Bus Device Reset is impossible, attempt a full Host
  2.3966 +	Adapter Hard Reset and SCSI Bus Reset.
  2.3967 +      */
  2.3968 +      if (!(BusLogic_WriteOutgoingMailbox(
  2.3969 +	      HostAdapter, BusLogic_MailboxStartCommand, CCB)))
  2.3970 +	{
  2.3971 +	  BusLogic_Warning("Unable to write Outgoing Mailbox for "
  2.3972 +			   "Bus Device Reset\n", HostAdapter);
  2.3973 +	  BusLogic_DeallocateCCB(CCB);
  2.3974 +	  goto Done;
  2.3975 +	}
  2.3976 +    }
  2.3977 +  else
  2.3978 +    {
  2.3979 +      /*
  2.3980 +	Call the FlashPoint SCCB Manager to start execution of the CCB.
  2.3981 +      */
  2.3982 +      CCB->Status = BusLogic_CCB_Active;
  2.3983 +      HostAdapter->ActiveCommands[TargetID]++;
  2.3984 +      FlashPoint_StartCCB(HostAdapter->CardHandle, CCB);
  2.3985 +    }
  2.3986 +  /*
  2.3987 +    If there is a currently executing CCB in the Host Adapter for this Command
  2.3988 +    (i.e. this is an Asynchronous Reset), then an Incoming Mailbox entry may be
  2.3989 +    made with a completion code of BusLogic_HostAdapterAssertedBusDeviceReset.
  2.3990 +    If there is no active CCB for this Command (i.e. this is a Synchronous
  2.3991 +    Reset), then the Bus Device Reset CCB's Command field will have been set
  2.3992 +    to the Command so that the interrupt for the completion of the Bus Device
  2.3993 +    Reset can call the Completion Routine for the Command.  On successful
  2.3994 +    execution of a Bus Device Reset, older firmware versions did return the
  2.3995 +    pending CCBs with the appropriate completion code, but more recent firmware
  2.3996 +    versions only return the Bus Device Reset CCB itself.  This driver handles
  2.3997 +    both cases by marking all the currently executing CCBs to this Target
  2.3998 +    Device as Reset.  When the Bus Device Reset CCB is processed by the
  2.3999 +    interrupt handler, any remaining CCBs marked as Reset will have completion
  2.4000 +    processing performed.
  2.4001 +  */
  2.4002 +  BusLogic_IncrementErrorCounter(
  2.4003 +    &HostAdapter->TargetStatistics[TargetID].BusDeviceResetsAttempted);
  2.4004 +  HostAdapter->BusDeviceResetPendingCCB[TargetID] = CCB;
  2.4005 +  HostAdapter->LastResetAttempted[TargetID] = jiffies;
  2.4006 +  for (XCCB = HostAdapter->All_CCBs; XCCB != NULL; XCCB = XCCB->NextAll)
  2.4007 +    if (XCCB->Status == BusLogic_CCB_Active && XCCB->TargetID == TargetID)
  2.4008 +      XCCB->Status = BusLogic_CCB_Reset;
  2.4009 +  /*
  2.4010 +    FlashPoint Host Adapters may have already completed the Bus Device
  2.4011 +    Reset and BusLogic_QueueCompletedCCB been called, or it may still be
  2.4012 +    pending.
  2.4013 +  */
  2.4014 +  Result = SCSI_RESET_PENDING;
  2.4015 +  if (BusLogic_FlashPointHostAdapterP(HostAdapter))
  2.4016 +    if (CCB->Status == BusLogic_CCB_Completed)
  2.4017 +      {
  2.4018 +	BusLogic_ProcessCompletedCCBs(HostAdapter);
  2.4019 +	Result = SCSI_RESET_SUCCESS;
  2.4020 +      }
  2.4021 +  /*
  2.4022 +    If a Bus Device Reset was not possible for some reason, force a full
  2.4023 +    Host Adapter Hard Reset and SCSI Bus Reset.
  2.4024 +  */
  2.4025 +Done:
  2.4026 +  if (Result < 0)
  2.4027 +    Result = BusLogic_ResetHostAdapter(HostAdapter, Command, ResetFlags);
  2.4028 +  /*
  2.4029 +    Release exclusive access to Host Adapter.
  2.4030 +  */
  2.4031 +  BusLogic_ReleaseHostAdapterLock(HostAdapter, &ProcessorFlags);
  2.4032 +  return Result;
  2.4033 +}
  2.4034 +
  2.4035 +
  2.4036 +/*
  2.4037 +  BusLogic_ResetCommand takes appropriate action to reset Command.
  2.4038 +*/
  2.4039 +
  2.4040 +int BusLogic_ResetCommand(SCSI_Command_T *Command, unsigned int ResetFlags)
  2.4041 +{
  2.4042 +  BusLogic_HostAdapter_T *HostAdapter =
  2.4043 +    (BusLogic_HostAdapter_T *) Command->host->hostdata;
  2.4044 +  int TargetID = Command->target;
  2.4045 +  BusLogic_ErrorRecoveryStrategy_T
  2.4046 +    ErrorRecoveryStrategy = HostAdapter->ErrorRecoveryStrategy[TargetID];
  2.4047 +  /*
  2.4048 +    Disable Tagged Queuing if it is active for this Target Device and if
  2.4049 +    it has been less than 10 minutes since the last reset occurred, or since
  2.4050 +    the system was initialized if no prior resets have occurred.
  2.4051 +  */
  2.4052 +  if (HostAdapter->TargetFlags[TargetID].TaggedQueuingActive &&
  2.4053 +      jiffies - HostAdapter->LastResetCompleted[TargetID] < 10*60*HZ)
  2.4054 +    {
  2.4055 +      HostAdapter->TaggedQueuingPermitted &= ~(1 << TargetID);
  2.4056 +      HostAdapter->TargetFlags[TargetID].TaggedQueuingActive = false;
  2.4057 +      BusLogic_Warning("Tagged Queuing now disabled for Target %d\n",
  2.4058 +		       HostAdapter, TargetID);
  2.4059 +    }
  2.4060 +  switch (ErrorRecoveryStrategy)
  2.4061 +    {
  2.4062 +    case BusLogic_ErrorRecovery_Default:
  2.4063 +      if (ResetFlags & SCSI_RESET_SUGGEST_HOST_RESET)
  2.4064 +	return BusLogic_ResetHostAdapter(HostAdapter, Command, ResetFlags);
  2.4065 +      else if (ResetFlags & SCSI_RESET_SUGGEST_BUS_RESET)
  2.4066 +	return BusLogic_ResetHostAdapter(HostAdapter, Command, ResetFlags);
  2.4067 +      /* Fall through to Bus Device Reset case. */
  2.4068 +    case BusLogic_ErrorRecovery_BusDeviceReset:
  2.4069 +      /*
  2.4070 +	The Bus Device Reset Error Recovery Strategy only graduates to a Hard
  2.4071 +	Reset when no commands have completed successfully since the last Bus
  2.4072 +	Device Reset and it has been at least 100 milliseconds.  This prevents
  2.4073 +	a sequence of commands that all timeout together from immediately
  2.4074 +	forcing a Hard Reset before the Bus Device Reset has had a chance to
  2.4075 +	clear the error condition.
  2.4076 +      */
  2.4077 +      if (HostAdapter->TargetFlags[TargetID].CommandSuccessfulFlag ||
  2.4078 +	  jiffies - HostAdapter->LastResetAttempted[TargetID] < HZ/10)
  2.4079 +	{
  2.4080 +	  HostAdapter->TargetFlags[TargetID].CommandSuccessfulFlag = false;
  2.4081 +	  return BusLogic_SendBusDeviceReset(HostAdapter, Command, ResetFlags);
  2.4082 +	}
  2.4083 +      /* Fall through to Hard Reset case. */
  2.4084 +    case BusLogic_ErrorRecovery_HardReset:
  2.4085 +      return BusLogic_ResetHostAdapter(HostAdapter, Command, ResetFlags);
  2.4086 +    case BusLogic_ErrorRecovery_None:
  2.4087 +      BusLogic_Warning("Error Recovery for Target %d Suppressed\n",
  2.4088 +		       HostAdapter, TargetID);
  2.4089 +      break;
  2.4090 +    }
  2.4091 +  return SCSI_RESET_PUNT;
  2.4092 +}
  2.4093 +
  2.4094 +
  2.4095 +#if 0 /* XEN */
  2.4096 +/*
  2.4097 +  BusLogic_BIOSDiskParameters returns the Heads/Sectors/Cylinders BIOS Disk
  2.4098 +  Parameters for Disk.  The default disk geometry is 64 heads, 32 sectors, and
  2.4099 +  the appropriate number of cylinders so as not to exceed drive capacity.  In
  2.4100 +  order for disks equal to or larger than 1 GB to be addressable by the BIOS
  2.4101 +  without exceeding the BIOS limitation of 1024 cylinders, Extended Translation
  2.4102 +  may be enabled in AutoSCSI on FlashPoint Host Adapters and on "W" and "C"
  2.4103 +  series MultiMaster Host Adapters, or by a dip switch setting on "S" and "A"
  2.4104 +  series MultiMaster Host Adapters.  With Extended Translation enabled, drives
  2.4105 +  between 1 GB inclusive and 2 GB exclusive are given a disk geometry of 128
  2.4106 +  heads and 32 sectors, and drives above 2 GB inclusive are given a disk
  2.4107 +  geometry of 255 heads and 63 sectors.  However, if the BIOS detects that the
  2.4108 +  Extended Translation setting does not match the geometry in the partition
  2.4109 +  table, then the translation inferred from the partition table will be used by
  2.4110 +  the BIOS, and a warning may be displayed.
  2.4111 +*/
  2.4112 +
  2.4113 +int BusLogic_BIOSDiskParameters(SCSI_Disk_T *Disk, KernelDevice_T Device,
  2.4114 +				int *Parameters)
  2.4115 +{
  2.4116 +  BusLogic_HostAdapter_T *HostAdapter =
  2.4117 +    (BusLogic_HostAdapter_T *) Disk->device->host->hostdata;
  2.4118 +  BIOS_DiskParameters_T *DiskParameters = (BIOS_DiskParameters_T *) Parameters;
  2.4119 +  struct buffer_head *BufferHead;
  2.4120 +  if (HostAdapter->ExtendedTranslationEnabled &&
  2.4121 +      Disk->capacity >= 2*1024*1024 /* 1 GB in 512 byte sectors */)
  2.4122 +    {
  2.4123 +      if (Disk->capacity >= 4*1024*1024 /* 2 GB in 512 byte sectors */)
  2.4124 +	{
  2.4125 +	  DiskParameters->Heads = 255;
  2.4126 +	  DiskParameters->Sectors = 63;
  2.4127 +	}
  2.4128 +      else
  2.4129 +	{
  2.4130 +	  DiskParameters->Heads = 128;
  2.4131 +	  DiskParameters->Sectors = 32;
  2.4132 +	}
  2.4133 +    }
  2.4134 +  else
  2.4135 +    {
  2.4136 +      DiskParameters->Heads = 64;
  2.4137 +      DiskParameters->Sectors = 32;
  2.4138 +    }
  2.4139 +  DiskParameters->Cylinders =
  2.4140 +    Disk->capacity / (DiskParameters->Heads * DiskParameters->Sectors);
  2.4141 +  /*
  2.4142 +    Attempt to read the first 1024 bytes from the disk device.
  2.4143 +  */
  2.4144 +  BufferHead = bread(MKDEV(MAJOR(Device), MINOR(Device) & ~0x0F), 0, block_size(Device));
  2.4145 +  if (BufferHead == NULL) return 0;
  2.4146 +  /*
  2.4147 +    If the boot sector partition table flag is valid, search for a partition
  2.4148 +    table entry whose end_head matches one of the standard BusLogic geometry
  2.4149 +    translations (64/32, 128/32, or 255/63).
  2.4150 +  */
  2.4151 +  if (*(unsigned short *) (BufferHead->b_data + 0x1FE) == 0xAA55)
  2.4152 +    {
  2.4153 +      PartitionTable_T *FirstPartitionEntry =
  2.4154 +	(PartitionTable_T *) (BufferHead->b_data + 0x1BE);
  2.4155 +      PartitionTable_T *PartitionEntry = FirstPartitionEntry;
  2.4156 +      int SavedCylinders = DiskParameters->Cylinders, PartitionNumber;
  2.4157 +      unsigned char PartitionEntryEndHead, PartitionEntryEndSector;
  2.4158 +      for (PartitionNumber = 0; PartitionNumber < 4; PartitionNumber++)
  2.4159 +	{
  2.4160 +	  PartitionEntryEndHead = PartitionEntry->end_head;
  2.4161 +	  PartitionEntryEndSector = PartitionEntry->end_sector & 0x3F;
  2.4162 +	  if (PartitionEntryEndHead == 64-1)
  2.4163 +	    {
  2.4164 +	      DiskParameters->Heads = 64;
  2.4165 +	      DiskParameters->Sectors = 32;
  2.4166 +	      break;
  2.4167 +	    }
  2.4168 +	  else if (PartitionEntryEndHead == 128-1)
  2.4169 +	    {
  2.4170 +	      DiskParameters->Heads = 128;
  2.4171 +	      DiskParameters->Sectors = 32;
  2.4172 +	      break;
  2.4173 +	    }
  2.4174 +	  else if (PartitionEntryEndHead == 255-1)
  2.4175 +	    {
  2.4176 +	      DiskParameters->Heads = 255;
  2.4177 +	      DiskParameters->Sectors = 63;
  2.4178 +	      break;
  2.4179 +	    }
  2.4180 +	  PartitionEntry++;
  2.4181 +	}
  2.4182 +      if (PartitionNumber == 4)
  2.4183 +	{
  2.4184 +	  PartitionEntryEndHead = FirstPartitionEntry->end_head;
  2.4185 +	  PartitionEntryEndSector = FirstPartitionEntry->end_sector & 0x3F;
  2.4186 +	}
  2.4187 +      DiskParameters->Cylinders =
  2.4188 +	Disk->capacity / (DiskParameters->Heads * DiskParameters->Sectors);
  2.4189 +      if (PartitionNumber < 4 &&
  2.4190 +	  PartitionEntryEndSector == DiskParameters->Sectors)
  2.4191 +	{
  2.4192 +	  if (DiskParameters->Cylinders != SavedCylinders)
  2.4193 +	    BusLogic_Warning("Adopting Geometry %d/%d from Partition Table\n",
  2.4194 +			     HostAdapter,
  2.4195 +			     DiskParameters->Heads, DiskParameters->Sectors);
  2.4196 +	}
  2.4197 +      else if (PartitionEntryEndHead > 0 || PartitionEntryEndSector > 0)
  2.4198 +	{
  2.4199 +	  BusLogic_Warning("Warning: Partition Table appears to "
  2.4200 +			   "have Geometry %d/%d which is\n", HostAdapter,
  2.4201 +			   PartitionEntryEndHead + 1,
  2.4202 +			   PartitionEntryEndSector);
  2.4203 +	  BusLogic_Warning("not compatible with current BusLogic "
  2.4204 +			   "Host Adapter Geometry %d/%d\n", HostAdapter,
  2.4205 +			   DiskParameters->Heads, DiskParameters->Sectors);
  2.4206 +	}
  2.4207 +    }
  2.4208 +  brelse(BufferHead);
  2.4209 +  return 0;
  2.4210 +}
  2.4211 +
  2.4212 +
  2.4213 +/*
  2.4214 +  BugLogic_ProcDirectoryInfo implements /proc/scsi/BusLogic/<N>.
  2.4215 +*/
  2.4216 +
  2.4217 +int BusLogic_ProcDirectoryInfo(char *ProcBuffer, char **StartPointer,
  2.4218 +			       off_t Offset, int BytesAvailable,
  2.4219 +			       int HostNumber, int WriteFlag)
  2.4220 +{
  2.4221 +  BusLogic_HostAdapter_T *HostAdapter;
  2.4222 +  BusLogic_TargetStatistics_T *TargetStatistics;
  2.4223 +  int TargetID, Length;
  2.4224 +  char *Buffer;
  2.4225 +  for (HostAdapter = BusLogic_FirstRegisteredHostAdapter;
  2.4226 +       HostAdapter != NULL;
  2.4227 +       HostAdapter = HostAdapter->Next)
  2.4228 +    if (HostAdapter->HostNumber == HostNumber) break;
  2.4229 +  if (HostAdapter == NULL)
  2.4230 +    {
  2.4231 +      BusLogic_Error("Cannot find Host Adapter for SCSI Host %d\n",
  2.4232 +		     NULL, HostNumber);
  2.4233 +      return 0;
  2.4234 +    }
  2.4235 +  TargetStatistics = HostAdapter->TargetStatistics;
  2.4236 +  if (WriteFlag)
  2.4237 +    {
  2.4238 +      HostAdapter->ExternalHostAdapterResets = 0;
  2.4239 +      HostAdapter->HostAdapterInternalErrors = 0;
  2.4240 +      memset(TargetStatistics, 0,
  2.4241 +	     BusLogic_MaxTargetDevices * sizeof(BusLogic_TargetStatistics_T));
  2.4242 +      return 0;
  2.4243 +    }
  2.4244 +  Buffer = HostAdapter->MessageBuffer;
  2.4245 +  Length = HostAdapter->MessageBufferLength;
  2.4246 +  Length += sprintf(&Buffer[Length], "\n\
  2.4247 +Current Driver Queue Depth:	%d\n\
  2.4248 +Currently Allocated CCBs:	%d\n",
  2.4249 +		    HostAdapter->DriverQueueDepth,
  2.4250 +		    HostAdapter->AllocatedCCBs);
  2.4251 +  Length += sprintf(&Buffer[Length], "\n\n\
  2.4252 +			   DATA TRANSFER STATISTICS\n\
  2.4253 +\n\
  2.4254 +Target	Tagged Queuing	Queue Depth  Active  Attempted	Completed\n\
  2.4255 +======	==============	===========  ======  =========	=========\n");
  2.4256 +  for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.4257 +    {
  2.4258 +      BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
  2.4259 +      if (!TargetFlags->TargetExists) continue;
  2.4260 +      Length +=
  2.4261 +	sprintf(&Buffer[Length], "  %2d	%s", TargetID,
  2.4262 +		(TargetFlags->TaggedQueuingSupported
  2.4263 +		 ? (TargetFlags->TaggedQueuingActive
  2.4264 +		    ? "    Active"
  2.4265 +		    : (HostAdapter->TaggedQueuingPermitted & (1 << TargetID)
  2.4266 +		       ? "  Permitted" : "   Disabled"))
  2.4267 +		 : "Not Supported"));
  2.4268 +      Length += sprintf(&Buffer[Length],
  2.4269 +			"	    %3d       %3u    %9u	%9u\n",
  2.4270 +			HostAdapter->QueueDepth[TargetID],
  2.4271 +			HostAdapter->ActiveCommands[TargetID],
  2.4272 +			TargetStatistics[TargetID].CommandsAttempted,
  2.4273 +			TargetStatistics[TargetID].CommandsCompleted);
  2.4274 +    }
  2.4275 +  Length += sprintf(&Buffer[Length], "\n\
  2.4276 +Target  Read Commands  Write Commands   Total Bytes Read    Total Bytes Written\n\
  2.4277 +======  =============  ==============  ===================  ===================\n");
  2.4278 +  for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.4279 +    {
  2.4280 +      BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
  2.4281 +      if (!TargetFlags->TargetExists) continue;
  2.4282 +      Length +=
  2.4283 +	sprintf(&Buffer[Length], "  %2d	  %9u	 %9u", TargetID,
  2.4284 +		TargetStatistics[TargetID].ReadCommands,
  2.4285 +		TargetStatistics[TargetID].WriteCommands);
  2.4286 +      if (TargetStatistics[TargetID].TotalBytesRead.Billions > 0)
  2.4287 +	Length +=
  2.4288 +	  sprintf(&Buffer[Length], "     %9u%09u",
  2.4289 +		  TargetStatistics[TargetID].TotalBytesRead.Billions,
  2.4290 +		  TargetStatistics[TargetID].TotalBytesRead.Units);
  2.4291 +      else
  2.4292 +	Length +=
  2.4293 +	  sprintf(&Buffer[Length], "		%9u",
  2.4294 +		  TargetStatistics[TargetID].TotalBytesRead.Units);
  2.4295 +      if (TargetStatistics[TargetID].TotalBytesWritten.Billions > 0)
  2.4296 +	Length +=
  2.4297 +	  sprintf(&Buffer[Length], "   %9u%09u\n",
  2.4298 +		  TargetStatistics[TargetID].TotalBytesWritten.Billions,
  2.4299 +		  TargetStatistics[TargetID].TotalBytesWritten.Units);
  2.4300 +      else
  2.4301 +	Length +=
  2.4302 +	  sprintf(&Buffer[Length], "	     %9u\n",
  2.4303 +		  TargetStatistics[TargetID].TotalBytesWritten.Units);
  2.4304 +    }
  2.4305 +  Length += sprintf(&Buffer[Length], "\n\
  2.4306 +Target  Command    0-1KB      1-2KB      2-4KB      4-8KB     8-16KB\n\
  2.4307 +======  =======  =========  =========  =========  =========  =========\n");
  2.4308 +  for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.4309 +    {
  2.4310 +      BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
  2.4311 +      if (!TargetFlags->TargetExists) continue;
  2.4312 +      Length +=
  2.4313 +	sprintf(&Buffer[Length],
  2.4314 +		"  %2d	 Read	 %9u  %9u  %9u  %9u  %9u\n", TargetID,
  2.4315 +		TargetStatistics[TargetID].ReadCommandSizeBuckets[0],
  2.4316 +		TargetStatistics[TargetID].ReadCommandSizeBuckets[1],
  2.4317 +		TargetStatistics[TargetID].ReadCommandSizeBuckets[2],
  2.4318 +		TargetStatistics[TargetID].ReadCommandSizeBuckets[3],
  2.4319 +		TargetStatistics[TargetID].ReadCommandSizeBuckets[4]);
  2.4320 +      Length +=
  2.4321 +	sprintf(&Buffer[Length],
  2.4322 +		"  %2d	 Write	 %9u  %9u  %9u  %9u  %9u\n", TargetID,
  2.4323 +		TargetStatistics[TargetID].WriteCommandSizeBuckets[0],
  2.4324 +		TargetStatistics[TargetID].WriteCommandSizeBuckets[1],
  2.4325 +		TargetStatistics[TargetID].WriteCommandSizeBuckets[2],
  2.4326 +		TargetStatistics[TargetID].WriteCommandSizeBuckets[3],
  2.4327 +		TargetStatistics[TargetID].WriteCommandSizeBuckets[4]);
  2.4328 +    }
  2.4329 +  Length += sprintf(&Buffer[Length], "\n\
  2.4330 +Target  Command   16-32KB    32-64KB   64-128KB   128-256KB   256KB+\n\
  2.4331 +======  =======  =========  =========  =========  =========  =========\n");
  2.4332 +  for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.4333 +    {
  2.4334 +      BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
  2.4335 +      if (!TargetFlags->TargetExists) continue;
  2.4336 +      Length +=
  2.4337 +	sprintf(&Buffer[Length],
  2.4338 +		"  %2d	 Read	 %9u  %9u  %9u  %9u  %9u\n", TargetID,
  2.4339 +		TargetStatistics[TargetID].ReadCommandSizeBuckets[5],
  2.4340 +		TargetStatistics[TargetID].ReadCommandSizeBuckets[6],
  2.4341 +		TargetStatistics[TargetID].ReadCommandSizeBuckets[7],
  2.4342 +		TargetStatistics[TargetID].ReadCommandSizeBuckets[8],
  2.4343 +		TargetStatistics[TargetID].ReadCommandSizeBuckets[9]);
  2.4344 +      Length +=
  2.4345 +	sprintf(&Buffer[Length],
  2.4346 +		"  %2d	 Write	 %9u  %9u  %9u  %9u  %9u\n", TargetID,
  2.4347 +		TargetStatistics[TargetID].WriteCommandSizeBuckets[5],
  2.4348 +		TargetStatistics[TargetID].WriteCommandSizeBuckets[6],
  2.4349 +		TargetStatistics[TargetID].WriteCommandSizeBuckets[7],
  2.4350 +		TargetStatistics[TargetID].WriteCommandSizeBuckets[8],
  2.4351 +		TargetStatistics[TargetID].WriteCommandSizeBuckets[9]);
  2.4352 +    }
  2.4353 +  Length += sprintf(&Buffer[Length], "\n\n\
  2.4354 +			   ERROR RECOVERY STATISTICS\n\
  2.4355 +\n\
  2.4356 +	  Command Aborts      Bus Device Resets	  Host Adapter Resets\n\
  2.4357 +Target	Requested Completed  Requested Completed  Requested Completed\n\
  2.4358 +  ID	\\\\\\\\ Attempted ////  \\\\\\\\ Attempted ////  \\\\\\\\ Attempted ////\n\
  2.4359 +======	 ===== ===== =====    ===== ===== =====	   ===== ===== =====\n");
  2.4360 +  for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
  2.4361 +    {
  2.4362 +      BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
  2.4363 +      if (!TargetFlags->TargetExists) continue;
  2.4364 +      Length +=
  2.4365 +	sprintf(&Buffer[Length], "\
  2.4366 +  %2d	 %5d %5d %5d    %5d %5d %5d	   %5d %5d %5d\n", TargetID,
  2.4367 +		TargetStatistics[TargetID].CommandAbortsRequested,
  2.4368 +		TargetStatistics[TargetID].CommandAbortsAttempted,
  2.4369 +		TargetStatistics[TargetID].CommandAbortsCompleted,
  2.4370 +		TargetStatistics[TargetID].BusDeviceResetsRequested,
  2.4371 +		TargetStatistics[TargetID].BusDeviceResetsAttempted,
  2.4372 +		TargetStatistics[TargetID].BusDeviceResetsCompleted,
  2.4373 +		TargetStatistics[TargetID].HostAdapterResetsRequested,
  2.4374 +		TargetStatistics[TargetID].HostAdapterResetsAttempted,
  2.4375 +		TargetStatistics[TargetID].HostAdapterResetsCompleted);
  2.4376 +    }
  2.4377 +  Length += sprintf(&Buffer[Length], "\nExternal Host Adapter Resets: %d\n",
  2.4378 +		    HostAdapter->ExternalHostAdapterResets);
  2.4379 +  Length += sprintf(&Buffer[Length], "Host Adapter Internal Errors: %d\n",
  2.4380 +		    HostAdapter->HostAdapterInternalErrors);
  2.4381 +  if (Length >= BusLogic_MessageBufferSize)
  2.4382 +    BusLogic_Error("Message Buffer length %d exceeds size %d\n",
  2.4383 +		   HostAdapter, Length, BusLogic_MessageBufferSize);
  2.4384 +  if ((Length -= Offset) <= 0) return 0;
  2.4385 +  if (Length >= BytesAvailable) Length = BytesAvailable;
  2.4386 +  memcpy(ProcBuffer, HostAdapter->MessageBuffer + Offset, Length);
  2.4387 +  *StartPointer = ProcBuffer;
  2.4388 +  return Length;
  2.4389 +}
  2.4390 +
  2.4391 +#endif /* !XEN */
  2.4392 +
  2.4393 +/*
  2.4394 +  BusLogic_Message prints Driver Messages.
  2.4395 +*/
  2.4396 +
  2.4397 +static void BusLogic_Message(BusLogic_MessageLevel_T MessageLevel,
  2.4398 +			     char *Format,
  2.4399 +			     BusLogic_HostAdapter_T *HostAdapter,
  2.4400 +			     ...)
  2.4401 +{
  2.4402 +  static char Buffer[BusLogic_LineBufferSize];
  2.4403 +  static boolean BeginningOfLine = true;
  2.4404 +  va_list Arguments;
  2.4405 +  int Length = 0;
  2.4406 +  va_start(Arguments, HostAdapter);
  2.4407 +  Length = vsprintf(Buffer, Format, Arguments);
  2.4408 +  va_end(Arguments);
  2.4409 +  if (MessageLevel == BusLogic_AnnounceLevel)
  2.4410 +    {
  2.4411 +      static int AnnouncementLines = 0;
  2.4412 +      strcpy(&HostAdapter->MessageBuffer[HostAdapter->MessageBufferLength],
  2.4413 +	     Buffer);
  2.4414 +      HostAdapter->MessageBufferLength += Length;
  2.4415 +      if (++AnnouncementLines <= 2)
  2.4416 +	printk("%sscsi: %s", BusLogic_MessageLevelMap[MessageLevel], Buffer);
  2.4417 +    }
  2.4418 +  else if (MessageLevel == BusLogic_InfoLevel)
  2.4419 +    {
  2.4420 +      strcpy(&HostAdapter->MessageBuffer[HostAdapter->MessageBufferLength],
  2.4421 +	     Buffer);
  2.4422 +      HostAdapter->MessageBufferLength += Length;
  2.4423 +      if (BeginningOfLine)
  2.4424 +	{
  2.4425 +	  if (Buffer[0] != '\n' || Length > 1)
  2.4426 +	    printk("%sscsi%d: %s", BusLogic_MessageLevelMap[MessageLevel],
  2.4427 +		   HostAdapter->HostNumber, Buffer);
  2.4428 +	}
  2.4429 +      else printk("%s", Buffer);
  2.4430 +    }
  2.4431 +  else
  2.4432 +    {
  2.4433 +      if (BeginningOfLine)
  2.4434 +	{
  2.4435 +	  if (HostAdapter != NULL && HostAdapter->HostAdapterInitialized)
  2.4436 +	    printk("%sscsi%d: %s", BusLogic_MessageLevelMap[MessageLevel],
  2.4437 +		   HostAdapter->HostNumber, Buffer);
  2.4438 +	  else printk("%s%s", BusLogic_MessageLevelMap[MessageLevel], Buffer);
  2.4439 +	}
  2.4440 +      else printk("%s", Buffer);
  2.4441 +    }
  2.4442 +  BeginningOfLine = (Buffer[Length-1] == '\n');
  2.4443 +}
  2.4444 +
  2.4445 +
  2.4446 +/*
  2.4447 +  BusLogic_ParseKeyword parses an individual option keyword.  It returns true
  2.4448 +  and updates the pointer if the keyword is recognized and false otherwise.
  2.4449 +*/
  2.4450 +
  2.4451 +static boolean BusLogic_ParseKeyword(char **StringPointer, char *Keyword)
  2.4452 +{
  2.4453 +  char *Pointer = *StringPointer;
  2.4454 +  while (*Keyword != '\0')
  2.4455 +    {
  2.4456 +      char StringChar = *Pointer++;
  2.4457 +      char KeywordChar = *Keyword++;
  2.4458 +      if (StringChar >= 'A' && StringChar <= 'Z')
  2.4459 +	StringChar += 'a' - 'Z';
  2.4460 +      if (KeywordChar >= 'A' && KeywordChar <= 'Z')
  2.4461 +	KeywordChar += 'a' - 'Z';
  2.4462 +      if (StringChar != KeywordChar) return false;
  2.4463 +    }
  2.4464 +  *StringPointer = Pointer;
  2.4465 +  return true;
  2.4466 +}
  2.4467 +
  2.4468 +#if 0 /* XEN */
  2.4469 +/*
  2.4470 +  BusLogic_ParseDriverOptions handles processing of BusLogic Driver Options
  2.4471 +  specifications.
  2.4472 +
  2.4473 +  BusLogic Driver Options may be specified either via the Linux Kernel Command
  2.4474 +  Line or via the Loadable Kernel Module Installation Facility.  Driver Options
  2.4475 +  for multiple host adapters may be specified either by separating the option
  2.4476 +  strings by a semicolon, or by specifying multiple "BusLogic=" strings on the
  2.4477 +  command line.  Individual option specifications for a single host adapter are
  2.4478 +  separated by commas.  The Probing and Debugging Options apply to all host
  2.4479 +  adapters whereas the remaining options apply individually only to the
  2.4480 +  selected host adapter.
  2.4481 +
  2.4482 +  The BusLogic Driver Probing Options comprise the following:
  2.4483 +
  2.4484 +  IO:<integer>
  2.4485 +
  2.4486 +    The "IO:" option specifies an ISA I/O Address to be probed for a non-PCI
  2.4487 +    MultiMaster Host Adapter.  If neither "IO:" nor "NoProbeISA" options are
  2.4488 +    specified, then the standard list of BusLogic MultiMaster ISA I/O Addresses
  2.4489 +    will be probed (0x330, 0x334, 0x230, 0x234, 0x130, and 0x134).  Multiple
  2.4490 +    "IO:" options may be specified to precisely determine the I/O Addresses to
  2.4491 +    be probed, but the probe order will always follow the standard list.
  2.4492 +
  2.4493 +  NoProbe
  2.4494 +
  2.4495 +    The "NoProbe" option disables all probing and therefore no BusLogic Host
  2.4496 +    Adapters will be detected.
  2.4497 +
  2.4498 +  NoProbeISA
  2.4499 +
  2.4500 +    The "NoProbeISA" option disables probing of the standard BusLogic ISA I/O
  2.4501 +    Addresses and therefore only PCI MultiMaster and FlashPoint Host Adapters
  2.4502 +    will be detected.
  2.4503 +
  2.4504 +  NoProbePCI
  2.4505 +
  2.4506 +    The "NoProbePCI" options disables the interrogation of PCI Configuration
  2.4507 +    Space and therefore only ISA Multimaster Host Adapters will be detected, as
  2.4508 +    well as PCI Multimaster Host Adapters that have their ISA Compatible I/O
  2.4509 +    Port set to "Primary" or "Alternate".
  2.4510 +
  2.4511 +  NoSortPCI
  2.4512 +
  2.4513 +    The "NoSortPCI" option forces PCI MultiMaster Host Adapters to be
  2.4514 +    enumerated in the order provided by the PCI BIOS, ignoring any setting of
  2.4515 +    the AutoSCSI "Use Bus And Device # For PCI Scanning Seq." option.
  2.4516 +
  2.4517 +  MultiMasterFirst
  2.4518 +
  2.4519 +    The "MultiMasterFirst" option forces MultiMaster Host Adapters to be probed
  2.4520 +    before FlashPoint Host Adapters.  By default, if both FlashPoint and PCI
  2.4521 +    MultiMaster Host Adapters are present, this driver will probe for
  2.4522 +    FlashPoint Host Adapters first unless the BIOS primary disk is controlled
  2.4523 +    by the first PCI MultiMaster Host Adapter, in which case MultiMaster Host
  2.4524 +    Adapters will be probed first.
  2.4525 +
  2.4526 +  FlashPointFirst
  2.4527 +
  2.4528 +    The "FlashPointFirst" option forces FlashPoint Host Adapters to be probed
  2.4529 +    before MultiMaster Host Adapters.
  2.4530 +
  2.4531 +  The BusLogic Driver Tagged Queuing Options allow for explicitly specifying
  2.4532 +  the Queue Depth and whether Tagged Queuing is permitted for each Target
  2.4533 +  Device (assuming that the Target Device supports Tagged Queuing).  The Queue
  2.4534 +  Depth is the number of SCSI Commands that are allowed to be concurrently
  2.4535 +  presented for execution (either to the Host Adapter or Target Device).  Note
  2.4536 +  that explicitly enabling Tagged Queuing may lead to problems; the option to
  2.4537 +  enable or disable Tagged Queuing is provided primarily to allow disabling
  2.4538 +  Tagged Queuing on Target Devices that do not implement it correctly.  The
  2.4539 +  following options are available:
  2.4540 +
  2.4541 +  QueueDepth:<integer>
  2.4542 +
  2.4543 +    The "QueueDepth:" or QD:" option specifies the Queue Depth to use for all
  2.4544 +    Target Devices that support Tagged Queuing, as well as the maximum Queue
  2.4545 +    Depth for devices that do not support Tagged Queuing.  If no Queue Depth
  2.4546 +    option is provided, the Queue Depth will be determined automatically based
  2.4547 +    on the Host Adapter's Total Queue Depth and the number, type, speed, and
  2.4548 +    capabilities of the detected Target Devices.  For Host Adapters that
  2.4549 +    require ISA Bounce Buffers, the Queue Depth is automatically set by default
  2.4550 +    to BusLogic_TaggedQueueDepthBB or BusLogic_UntaggedQueueDepthBB to avoid
  2.4551 +    excessive preallocation of DMA Bounce Buffer memory.  Target Devices that
  2.4552 +    do not support Tagged Queuing always have their Queue Depth set to
  2.4553 +    BusLogic_UntaggedQueueDepth or BusLogic_UntaggedQueueDepthBB, unless a
  2.4554 +    lower Queue Depth option is provided.  A Queue Depth of 1 automatically
  2.4555 +    disables Tagged Queuing.
  2.4556 +
  2.4557 +  QueueDepth:[<integer>,<integer>...]
  2.4558 +
  2.4559 +    The "QueueDepth:[...]" or "QD:[...]" option specifies the Queue Depth
  2.4560 +    individually for each Target Device.  If an <integer> is omitted, the
  2.4561 +    associated Target Device will have its Queue Depth selected automatically.
  2.4562 +
  2.4563 +  TaggedQueuing:Default
  2.4564 +
  2.4565 +    The "TaggedQueuing:Default" or "TQ:Default" option permits Tagged Queuing
  2.4566 +    based on the firmware version of the BusLogic Host Adapter and based on
  2.4567 +    whether the Queue Depth allows queuing multiple commands.
  2.4568 +
  2.4569 +  TaggedQueuing:Enable
  2.4570 +
  2.4571 +    The "TaggedQueuing:Enable" or "TQ:Enable" option enables Tagged Queuing for
  2.4572 +    all Target Devices on this Host Adapter, overriding any limitation that
  2.4573 +    would otherwise be imposed based on the Host Adapter firmware version.
  2.4574 +
  2.4575 +  TaggedQueuing:Disable
  2.4576 +
  2.4577 +    The "TaggedQueuing:Disable" or "TQ:Disable" option disables Tagged Queuing
  2.4578 +    for all Target Devices on this Host Adapter.
  2.4579 +
  2.4580 +  TaggedQueuing:<Target-Spec>
  2.4581 +
  2.4582 +    The "TaggedQueuing:<Target-Spec>" or "TQ:<Target-Spec>" option controls
  2.4583 +    Tagged Queuing individually for each Target Device.  <Target-Spec> is a
  2.4584 +    sequence of "Y", "N", and "X" characters.  "Y" enables Tagged Queuing, "N"
  2.4585 +    disables Tagged Queuing, and "X" accepts the default based on the firmware
  2.4586 +    version.  The first character refers to Target Device 0, the second to
  2.4587 +    Target Device 1, and so on; if the sequence of "Y", "N", and "X" characters
  2.4588 +    does not cover all the Target Devices, unspecified characters are assumed
  2.4589 +    to be "X".
  2.4590 +
  2.4591 +  The BusLogic Driver Error Recovery Option allows for explicitly specifying
  2.4592 +  the Error Recovery action to be performed when BusLogic_ResetCommand is
  2.4593 +  called due to a SCSI Command failing to complete successfully.  The following
  2.4594 +  options are available:
  2.4595 +
  2.4596 +  ErrorRecovery:Default
  2.4597 +
  2.4598 +    The "ErrorRecovery:Default" or "ER:Default" option selects between the Hard
  2.4599 +    Reset and Bus Device Reset options based on the recommendation of the SCSI
  2.4600 +    Subsystem.
  2.4601 +
  2.4602 +  ErrorRecovery:HardReset
  2.4603 +
  2.4604 +    The "ErrorRecovery:HardReset" or "ER:HardReset" option will initiate a Host
  2.4605 +    Adapter Hard Reset which also causes a SCSI Bus Reset.
  2.4606 +
  2.4607 +  ErrorRecovery:BusDeviceReset
  2.4608 +
  2.4609 +    The "ErrorRecovery:BusDeviceReset" or "ER:BusDeviceReset" option will send
  2.4610 +    a Bus Device Reset message to the individual Target Device causing the
  2.4611 +    error.  If Error Recovery is again initiated for this Target Device and no
  2.4612 +    SCSI Command to this Target Device has completed successfully since the Bus
  2.4613 +    Device Reset message was sent, then a Hard Reset will be attempted.
  2.4614 +
  2.4615 +  ErrorRecovery:None
  2.4616 +
  2.4617 +    The "ErrorRecovery:None" or "ER:None" option suppresses Error Recovery.
  2.4618 +    This option should only be selected if a SCSI Bus Reset or Bus Device Reset
  2.4619 +    will cause the Target Device or a critical operation to suffer a complete
  2.4620 +    and unrecoverable failure.
  2.4621 +
  2.4622 +  ErrorRecovery:<Target-Spec>
  2.4623 +
  2.4624 +    The "ErrorRecovery:<Target-Spec>" or "ER:<Target-Spec>" option controls
  2.4625 +    Error Recovery individually for each Target Device.  <Target-Spec> is a
  2.4626 +    sequence of "D", "H", "B", and "N" characters.  "D" selects Default, "H"
  2.4627 +    selects Hard Reset, "B" selects Bus Device Reset, and "N" selects None.
  2.4628 +    The first character refers to Target Device 0, the second to Target Device
  2.4629 +    1, and so on; if the sequence of "D", "H", "B", and "N" characters does not
  2.4630 +    cover all the possible Target Devices, unspecified characters are assumed
  2.4631 +    to be "D".
  2.4632 +
  2.4633 +  The BusLogic Driver Miscellaneous Options comprise the following:
  2.4634 +
  2.4635 +  BusSettleTime:<seconds>
  2.4636 +
  2.4637 +    The "BusSettleTime:" or "BST:" option specifies the Bus Settle Time in
  2.4638 +    seconds.  The Bus Settle Time is the amount of time to wait between a Host
  2.4639 +    Adapter Hard Reset which initiates a SCSI Bus Reset and issuing any SCSI
  2.4640 +    Commands.  If unspecified, it defaults to BusLogic_DefaultBusSettleTime.
  2.4641 +
  2.4642 +  InhibitTargetInquiry
  2.4643 +
  2.4644 +    The "InhibitTargetInquiry" option inhibits the execution of an Inquire
  2.4645 +    Target Devices or Inquire Installed Devices command on MultiMaster Host
  2.4646 +    Adapters.  This may be necessary with some older Target Devices that do not
  2.4647 +    respond correctly when Logical Units above 0 are addressed.
  2.4648 +
  2.4649 +  The BusLogic Driver Debugging Options comprise the following:
  2.4650 +
  2.4651 +  TraceProbe
  2.4652 +
  2.4653 +    The "TraceProbe" option enables tracing of Host Adapter Probing.
  2.4654 +
  2.4655 +  TraceHardwareReset
  2.4656 +
  2.4657 +    The "TraceHardwareReset" option enables tracing of Host Adapter Hardware
  2.4658 +    Reset.
  2.4659 +
  2.4660 +  TraceConfiguration
  2.4661 +
  2.4662 +    The "TraceConfiguration" option enables tracing of Host Adapter
  2.4663 +    Configuration.
  2.4664 +
  2.4665 +  TraceErrors
  2.4666 +
  2.4667 +    The "TraceErrors" option enables tracing of SCSI Commands that return an
  2.4668 +    error from the Target Device.  The CDB and Sense Data will be printed for
  2.4669 +    each SCSI Command that fails.
  2.4670 +
  2.4671 +  Debug
  2.4672 +
  2.4673 +    The "Debug" option enables all debugging options.
  2.4674 +
  2.4675 +  The following examples demonstrate setting the Queue Depth for Target Devices
  2.4676 +  1 and 2 on the first host adapter to 7 and 15, the Queue Depth for all Target
  2.4677 +  Devices on the second host adapter to 31, and the Bus Settle Time on the
  2.4678 +  second host adapter to 30 seconds.
  2.4679 +
  2.4680 +  Linux Kernel Command Line:
  2.4681 +
  2.4682 +    linux BusLogic=QueueDepth:[,7,15];QueueDepth:31,BusSettleTime:30
  2.4683 +
  2.4684 +  LILO Linux Boot Loader (in /etc/lilo.conf):
  2.4685 +
  2.4686 +    append = "BusLogic=QueueDepth:[,7,15];QueueDepth:31,BusSettleTime:30"
  2.4687 +
  2.4688 +  INSMOD Loadable Kernel Module Installation Facility:
  2.4689 +
  2.4690 +    insmod BusLogic.o \
  2.4691 +	'BusLogic="QueueDepth:[,7,15];QueueDepth:31,BusSettleTime:30"'
  2.4692 +
  2.4693 +  NOTE: Module Utilities 2.1.71 or later is required for correct parsing
  2.4694 +	of driver options containing commas.
  2.4695 +
  2.4696 +*/
  2.4697 +
  2.4698 +static int __init BusLogic_ParseDriverOptions(char *OptionsString)
  2.4699 +{
  2.4700 +  while (true)
  2.4701 +    {
  2.4702 +      BusLogic_DriverOptions_T *DriverOptions =
  2.4703 +	&BusLogic_DriverOptions[BusLogic_DriverOptionsCount++];
  2.4704 +      int TargetID;
  2.4705 +      memset(DriverOptions, 0, sizeof(BusLogic_DriverOptions_T));
  2.4706 +      for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++)
  2.4707 +	DriverOptions->ErrorRecoveryStrategy[TargetID] =
  2.4708 +	  BusLogic_ErrorRecovery_Default;
  2.4709 +      while (*OptionsString != '\0' && *OptionsString != ';')
  2.4710 +	{
  2.4711 +	  /* Probing Options. */
  2.4712 +	  if (BusLogic_ParseKeyword(&OptionsString, "IO:"))
  2.4713 +	    {
  2.4714 +	      BusLogic_IO_Address_T IO_Address =
  2.4715 +		simple_strtoul(OptionsString, &OptionsString, 0);
  2.4716 +	      BusLogic_ProbeOptions.LimitedProbeISA = true;
  2.4717 +	      switch (IO_Address)
  2.4718 +		{
  2.4719 +		case 0x330:
  2.4720 +		  BusLogic_ProbeOptions.Probe330 = true;
  2.4721 +		  break;
  2.4722 +		case 0x334:
  2.4723 +		  BusLogic_ProbeOptions.Probe334 = true;
  2.4724 +		  break;
  2.4725 +		case 0x230:
  2.4726 +		  BusLogic_ProbeOptions.Probe230 = true;
  2.4727 +		  break;
  2.4728 +		case 0x234:
  2.4729 +		  BusLogic_ProbeOptions.Probe234 = true;
  2.4730 +		  break;
  2.4731 +		case 0x130:
  2.4732 +		  BusLogic_ProbeOptions.Probe130 = true;
  2.4733 +		  break;
  2.4734 +		case 0x134:
  2.4735 +		  BusLogic_ProbeOptions.Probe134 = true;
  2.4736 +		  break;
  2.4737 +		default:
  2.4738 +		  BusLogic_Error("BusLogic: Invalid Driver Options "
  2.4739 +				 "(illegal I/O Address 0x%X)\n",
  2.4740 +				 NULL, IO_Address);
  2.4741 +		  return 0;
  2.4742 +		}
  2.4743 +	    }
  2.4744 +	  else if (BusLogic_ParseKeyword(&OptionsString, "NoProbeISA"))
  2.4745 +	    BusLogic_ProbeOptions.NoProbeISA = true;
  2.4746 +	  else if (BusLogic_ParseKeyword(&OptionsString, "NoProbePCI"))
  2.4747 +	    BusLogic_ProbeOptions.NoProbePCI = true;
  2.4748 +	  else if (BusLogic_ParseKeyword(&OptionsString, "NoProbe"))
  2.4749 +	    BusLogic_ProbeOptions.NoProbe = true;
  2.4750 +	  else if (BusLogic_ParseKeyword(&OptionsString, "NoSortPCI"))
  2.4751 +	    BusLogic_ProbeOptions.NoSortPCI = true;
  2.4752 +	  else if (BusLogic_ParseKeyword(&OptionsString, "MultiMasterFirst"))
  2.4753 +	    BusLogic_ProbeOptions.MultiMasterFirst = true;
  2.4754 +	  else if (BusLogic_ParseKeyword(&OptionsString, "FlashPointFirst"))
  2.4755 +	    BusLogic_ProbeOptions.FlashPointFirst = true;
  2.4756 +	  /* Tagged Queuing Options. */
  2.4757 +	  else if (BusLogic_ParseKeyword(&OptionsString, "QueueDepth:[") ||
  2.4758 +		   BusLogic_ParseKeyword(&OptionsString, "QD:["))
  2.4759 +	    {
  2.4760 +	      for (TargetID = 0;
  2.4761 +		   TargetID < BusLogic_MaxTargetDevices;
  2.4762 +		   TargetID++)
  2.4763 +		{
  2.4764 +		  unsigned short QueueDepth =
  2.4765 +		    simple_strtoul(OptionsString, &OptionsString, 0);
  2.4766 +		  if (QueueDepth > BusLogic_MaxTaggedQueueDepth)
  2.4767 +		    {
  2.4768 +		      BusLogic_Error("BusLogic: Invalid Driver Options "
  2.4769 +				     "(illegal Queue Depth %d)\n",
  2.4770 +				     NULL, QueueDepth);
  2.4771 +		      return 0;
  2.4772 +		    }
  2.4773 +		  DriverOptions->QueueDepth[TargetID] = QueueDepth;
  2.4774 +		  if (*OptionsString == ',')
  2.4775 +		    OptionsString++;
  2.4776 +		  else if (*OptionsString == ']')
  2.4777 +		    break;
  2.4778 +		  else
  2.4779 +		    {
  2.4780 +		      BusLogic_Error("BusLogic: Invalid Driver Options "
  2.4781 +				     "(',' or ']' expected at '%s')\n",
  2.4782 +				     NULL, OptionsString);
  2.4783 +		      return 0;
  2.4784 +		    }
  2.4785 +		}
  2.4786 +	      if (*OptionsString != ']')
  2.4787 +		{
  2.4788 +		  BusLogic_Error("BusLogic: Invalid Driver Options "
  2.4789 +				 "(']' expected at '%s')\n",
  2.4790 +				 NULL, OptionsString);
  2.4791 +		  return 0;
  2.4792 +		}
  2.4793 +	      else OptionsString++;
  2.4794 +	    }
  2.4795 +	  else if (BusLogic_ParseKeyword(&OptionsString, "QueueDepth:") ||
  2.4796 +		   BusLogic_ParseKeyword(&OptionsString, "QD:"))
  2.4797 +	    {
  2.4798 +	      unsigned short QueueDepth =
  2.4799 +		simple_strtoul(OptionsString, &OptionsString, 0);
  2.4800 +	      if (QueueDepth == 0 || QueueDepth > BusLogic_MaxTaggedQueueDepth)
  2.4801 +		{
  2.4802 +		  BusLogic_Error("BusLogic: Invalid Driver Options "
  2.4803 +				 "(illegal Queue Depth %d)\n",
  2.4804 +				 NULL, QueueDepth);
  2.4805 +		  return 0;
  2.4806 +		}
  2.4807 +	      DriverOptions->CommonQueueDepth = QueueDepth;
  2.4808 +	      for (TargetID = 0;
  2.4809 +		   TargetID < BusLogic_MaxTargetDevices;
  2.4810 +		   TargetID++)
  2.4811 +		DriverOptions->QueueDepth[TargetID] = QueueDepth;
  2.4812 +	    }
  2.4813 +	  else if (BusLogic_ParseKeyword(&OptionsString, "TaggedQueuing:") ||
  2.4814 +		   BusLogic_ParseKeyword(&OptionsString, "TQ:"))
  2.4815 +	    {
  2.4816 +	      if (BusLogic_ParseKeyword(&OptionsString, "Default"))
  2.4817 +		{
  2.4818 +		  DriverOptions->TaggedQueuingPermitted = 0x0000;
  2.4819 +		  DriverOptions->TaggedQueuingPermittedMask = 0x0000;
  2.4820 +		}
  2.4821 +	      else if (BusLogic_ParseKeyword(&OptionsString, "Enable"))
  2.4822 +		{
  2.4823 +		  DriverOptions->TaggedQueuingPermitted = 0xFFFF;
  2.4824 +		  DriverOptions->TaggedQueuingPermittedMask = 0xFFFF;
  2.4825 +		}
  2.4826 +	      else if (BusLogic_ParseKeyword(&OptionsString, "Disable"))
  2.4827 +		{
  2.4828 +		  DriverOptions->TaggedQueuingPermitted = 0x0000;
  2.4829 +		  DriverOptions->TaggedQueuingPermittedMask = 0xFFFF;
  2.4830 +		}
  2.4831 +	      else
  2.4832 +		{
  2.4833 +		  unsigned short TargetBit;
  2.4834 +		  for (TargetID = 0, TargetBit = 1;
  2.4835 +		       TargetID < BusLogic_MaxTargetDevices;
  2.4836 +		       TargetID++, TargetBit <<= 1)
  2.4837 +		    switch (*OptionsString++)
  2.4838 +		      {
  2.4839 +		      case 'Y':
  2.4840 +			DriverOptions->TaggedQueuingPermitted |= TargetBit;
  2.4841 +			DriverOptions->TaggedQueuingPermittedMask |= TargetBit;
  2.4842 +			break;
  2.4843 +		      case 'N':
  2.4844 +			DriverOptions->TaggedQueuingPermitted &= ~TargetBit;
  2.4845 +			DriverOptions->TaggedQueuingPermittedMask |= TargetBit;
  2.4846 +			break;
  2.4847 +		      case 'X':
  2.4848 +			break;
  2.4849 +		      default:
  2.4850 +			OptionsString--;
  2.4851 +			TargetID = BusLogic_MaxTargetDevices;
  2.4852 +			break;
  2.4853 +		      }
  2.4854 +		}
  2.4855 +	    }
  2.4856 +	  /* Error Recovery Option. */
  2.4857 +	  else if (BusLogic_ParseKeyword(&OptionsString, "ErrorRecovery:") ||
  2.4858 +		   BusLogic_ParseKeyword(&OptionsString, "ER:"))
  2.4859 +	    {
  2.4860 +	      if (BusLogic_ParseKeyword(&OptionsString, "Default"))
  2.4861 +		for (TargetID = 0;
  2.4862 +		     TargetID < BusLogic_MaxTargetDevices;
  2.4863 +		     TargetID++)
  2.4864 +		  DriverOptions->ErrorRecoveryStrategy[TargetID] =
  2.4865 +		    BusLogic_ErrorRecovery_Default;
  2.4866 +	      else if (BusLogic_ParseKeyword(&OptionsString, "HardReset"))
  2.4867 +		for (TargetID = 0;
  2.4868 +		     TargetID < BusLogic_MaxTargetDevices;
  2.4869 +		     TargetID++)
  2.4870 +		  DriverOptions->ErrorRecoveryStrategy[TargetID] =
  2.4871 +		    BusLogic_ErrorRecovery_HardReset;
  2.4872 +	      else if (BusLogic_ParseKeyword(&OptionsString, "BusDeviceReset"))
  2.4873 +		for (TargetID = 0;
  2.4874 +		     TargetID < BusLogic_MaxTargetDevices;
  2.4875 +		     TargetID++)
  2.4876 +		  DriverOptions->ErrorRecoveryStrategy[TargetID] =
  2.4877 +		    BusLogic_ErrorRecovery_BusDeviceReset;
  2.4878 +	      else if (BusLogic_ParseKeyword(&OptionsString, "None"))
  2.4879 +		for (TargetID = 0;
  2.4880 +		     TargetID < BusLogic_MaxTargetDevices;
  2.4881 +		     TargetID++)
  2.4882 +		  DriverOptions->ErrorRecoveryStrategy[TargetID] =
  2.4883 +		    BusLogic_ErrorRecovery_None;
  2.4884 +	      else
  2.4885 +		for (TargetID = 0;
  2.4886 +		     TargetID < BusLogic_MaxTargetDevices;
  2.4887 +		     TargetID++)
  2.4888 +		  switch (*OptionsString++)
  2.4889 +		    {
  2.4890 +		    case 'D':
  2.4891 +		      DriverOptions->ErrorRecoveryStrategy[TargetID] =
  2.4892 +			BusLogic_ErrorRecovery_Default;
  2.4893 +		      break;
  2.4894 +		    case 'H':
  2.4895 +		      DriverOptions->ErrorRecoveryStrategy[TargetID] =
  2.4896 +			BusLogic_ErrorRecovery_HardReset;
  2.4897 +		      break;
  2.4898 +		    case 'B':
  2.4899 +		      DriverOptions->ErrorRecoveryStrategy[TargetID] =
  2.4900 +			BusLogic_ErrorRecovery_BusDeviceReset;
  2.4901 +		      break;
  2.4902 +		    case 'N':
  2.4903 +		      DriverOptions->ErrorRecoveryStrategy[TargetID] =
  2.4904 +			BusLogic_ErrorRecovery_None;
  2.4905 +		      break;
  2.4906 +		    default:
  2.4907 +		      OptionsString--;
  2.4908 +		      TargetID = BusLogic_MaxTargetDevices;
  2.4909 +		      break;
  2.4910 +		    }
  2.4911 +	    }
  2.4912 +	  /* Miscellaneous Options. */
  2.4913 +	  else if (BusLogic_ParseKeyword(&OptionsString, "BusSettleTime:") ||
  2.4914 +		   BusLogic_ParseKeyword(&OptionsString, "BST:"))
  2.4915 +	    {
  2.4916 +	      unsigned short BusSettleTime =
  2.4917 +		simple_strtoul(OptionsString, &OptionsString, 0);
  2.4918 +	      if (BusSettleTime > 5 * 60)
  2.4919 +		{
  2.4920 +		  BusLogic_Error("BusLogic: Invalid Driver Options "
  2.4921 +				 "(illegal Bus Settle Time %d)\n",
  2.4922 +				 NULL, BusSettleTime);
  2.4923 +		  return 0;
  2.4924 +		}
  2.4925 +	      DriverOptions->BusSettleTime = BusSettleTime;
  2.4926 +	    }
  2.4927 +	  else if (BusLogic_ParseKeyword(&OptionsString,
  2.4928 +					 "InhibitTargetInquiry"))
  2.4929 +	    DriverOptions->LocalOptions.InhibitTargetInquiry = true;
  2.4930 +	  /* Debugging Options. */
  2.4931 +	  else if (BusLogic_ParseKeyword(&OptionsString, "TraceProbe"))
  2.4932 +	      BusLogic_GlobalOptions.TraceProbe = true;
  2.4933 +	  else if (BusLogic_ParseKeyword(&OptionsString, "TraceHardwareReset"))
  2.4934 +	      BusLogic_GlobalOptions.TraceHardwareReset = true;
  2.4935 +	  else if (BusLogic_ParseKeyword(&OptionsString, "TraceConfiguration"))
  2.4936 +	      BusLogic_GlobalOptions.TraceConfiguration = true;
  2.4937 +	  else if (BusLogic_ParseKeyword(&OptionsString, "TraceErrors"))
  2.4938 +	      BusLogic_GlobalOptions.TraceErrors = true;
  2.4939 +	  else if (BusLogic_ParseKeyword(&OptionsString, "Debug"))
  2.4940 +	    {
  2.4941 +	      BusLogic_GlobalOptions.TraceProbe = true;
  2.4942 +	      BusLogic_GlobalOptions.TraceHardwareReset = true;
  2.4943 +	      BusLogic_GlobalOptions.TraceConfiguration = true;
  2.4944 +	      BusLogic_GlobalOptions.TraceErrors = true;
  2.4945 +	    }
  2.4946 +	  if (*OptionsString == ',')
  2.4947 +	    OptionsString++;
  2.4948 +	  else if (*OptionsString != ';' && *OptionsString != '\0')
  2.4949 +	    {
  2.4950 +	      BusLogic_Error("BusLogic: Unexpected Driver Option '%s' "
  2.4951 +			     "ignored\n", NULL, OptionsString);
  2.4952 +	      *OptionsString = '\0';
  2.4953 +	    }
  2.4954 +	}
  2.4955 +      if (!(BusLogic_DriverOptionsCount == 0 ||
  2.4956 +	    BusLogic_ProbeInfoCount == 0 ||
  2.4957 +	    BusLogic_DriverOptionsCount == BusLogic_ProbeInfoCount))
  2.4958 +	{
  2.4959 +	  BusLogic_Error("BusLogic: Invalid Driver Options "
  2.4960 +			 "(all or no I/O Addresses must be specified)\n", NULL);
  2.4961 +	  return 0;
  2.4962 +	}
  2.4963 +      /*
  2.4964 +	Tagged Queuing is disabled when the Queue Depth is 1 since queuing
  2.4965 +	multiple commands is not possible.
  2.4966 +      */
  2.4967 +      for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++)
  2.4968 +	if (DriverOptions->QueueDepth[TargetID] == 1)
  2.4969 +	  {
  2.4970 +	    unsigned short TargetBit = 1 << TargetID;
  2.4971 +	    DriverOptions->TaggedQueuingPermitted &= ~TargetBit;
  2.4972 +	    DriverOptions->TaggedQueuingPermittedMask |= TargetBit;
  2.4973 +	  }
  2.4974 +      if (*OptionsString == ';') OptionsString++;
  2.4975 +      if (*OptionsString == '\0') return 0;
  2.4976 +    }
  2.4977 +    return 1;
  2.4978 +}
  2.4979 +
  2.4980 +
  2.4981 +/*
  2.4982 +  BusLogic_Setup handles processing of Kernel Command Line Arguments.
  2.4983 +*/
  2.4984 +
  2.4985 +static int __init 
  2.4986 +BusLogic_Setup(char *str)
  2.4987 +{
  2.4988 +	int ints[3];
  2.4989 +
  2.4990 +	(void)get_options(str, ARRAY_SIZE(ints), ints);
  2.4991 +
  2.4992 +	if (ints[0] != 0) {
  2.4993 +		BusLogic_Error("BusLogic: Obsolete Command Line Entry "
  2.4994 +				"Format Ignored\n", NULL);
  2.4995 +		return 0;
  2.4996 +	}
  2.4997 +	if (str == NULL || *str == '\0')
  2.4998 +		return 0;
  2.4999 +	return BusLogic_ParseDriverOptions(str);
  2.5000 +}
  2.5001 +
  2.5002 +__setup("BusLogic=", BusLogic_Setup);
  2.5003 +
  2.5004 +#endif /* !XEN */
  2.5005 +
  2.5006 +/*
  2.5007 +  Get it all started
  2.5008 +*/
  2.5009 +MODULE_LICENSE("GPL");
  2.5010 +
  2.5011 +static SCSI_Host_Template_T driver_template = BUSLOGIC;
  2.5012 +
  2.5013 +#include "scsi_module.c.inc"