drivers/scsi/BusLogic.c

   1
   2 /*
   3
   4   Linux Driver for BusLogic MultiMaster and FlashPoint SCSI Host Adapters
   5
   6   Copyright 1995-1998 by Leonard N. Zubkoff <lnz@dandelion.com>
   7
   8   This program is free software; you may redistribute and/or modify it under
   9   the terms of the GNU General Public License Version 2 as published by the
  10   Free Software Foundation.
  11
  12   This program is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY
  14   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15   for complete details.
  16
  17   The author respectfully requests that any modifications to this software be
  18   sent directly to him for evaluation and testing.
  19
  20   Special thanks to Wayne Yen, Jin-Lon Hon, and Alex Win of BusLogic, whose
  21   advice has been invaluable, to David Gentzel, for writing the original Linux
  22   BusLogic driver, and to Paul Gortmaker, for being such a dedicated test site.
  23
  24   Finally, special thanks to Mylex/BusLogic for making the FlashPoint SCCB
  25   Manager available as freely redistributable source code.
  26
  27 */
  28
  29 #define blogic_drvr_version             "2.1.17"
  30 #define blogic_drvr_date                "12 September 2013"
  31
  32 #include <linux/module.h>
  33 #include <linux/init.h>
  34 #include <linux/interrupt.h>
  35 #include <linux/types.h>
  36 #include <linux/blkdev.h>
  37 #include <linux/delay.h>
  38 #include <linux/ioport.h>
  39 #include <linux/mm.h>
  40 #include <linux/stat.h>
  41 #include <linux/pci.h>
  42 #include <linux/spinlock.h>
  43 #include <linux/jiffies.h>
  44 #include <linux/dma-mapping.h>
  45 #include <linux/slab.h>
  46 #include <scsi/scsicam.h>
  47
  48 #include <asm/dma.h>
  49 #include <asm/io.h>
  50
  51 #include <scsi/scsi.h>
  52 #include <scsi/scsi_cmnd.h>
  53 #include <scsi/scsi_device.h>
  54 #include <scsi/scsi_host.h>
  55 #include <scsi/scsi_tcq.h>
  56 #include "BusLogic.h"
  57 #include "FlashPoint.c"
  58
  59 #ifndef FAILURE
  60 #define FAILURE (-1)
  61 #endif
  62
  63 static struct scsi_host_template blogic_template;
  64
  65 /*
  66   blogic_drvr_options_count is a count of the number of BusLogic Driver
  67   Options specifications provided via the Linux Kernel Command Line or via
  68   the Loadable Kernel Module Installation Facility.
  69 */
  70
  71 static int blogic_drvr_options_count;
  72
  73
  74 /*
  75   blogic_drvr_options is an array of Driver Options structures representing
  76   BusLogic Driver Options specifications provided via the Linux Kernel Command
  77   Line or via the Loadable Kernel Module Installation Facility.
  78 */
  79
  80 static struct blogic_drvr_options blogic_drvr_options[BLOGIC_MAX_ADAPTERS];
  81
  82
  83 /*
  84   BusLogic can be assigned a string by insmod.
  85 */
  86
  87 MODULE_LICENSE("GPL");
  88 #ifdef MODULE
  89 static char *BusLogic;
  90 module_param(BusLogic, charp, 0);
  91 #endif
  92
  93
  94 /*
  95   blogic_probe_options is a set of Probe Options to be applied across
  96   all BusLogic Host Adapters.
  97 */
  98
  99 static struct blogic_probe_options blogic_probe_options;
 100
 101
 102 /*
 103   blogic_global_options is a set of Global Options to be applied across
 104   all BusLogic Host Adapters.
 105 */
 106
 107 static struct blogic_global_options blogic_global_options;
 108
 109 static LIST_HEAD(blogic_host_list);
 110
 111 /*
 112   blogic_probeinfo_count is the number of entries in blogic_probeinfo_list.
 113 */
 114
 115 static int blogic_probeinfo_count;
 116
 117
 118 /*
 119   blogic_probeinfo_list is the list of I/O Addresses and Bus Probe Information
 120   to be checked for potential BusLogic Host Adapters.  It is initialized by
 121   interrogating the PCI Configuration Space on PCI machines as well as from the
 122   list of standard BusLogic I/O Addresses.
 123 */
 124
 125 static struct blogic_probeinfo *blogic_probeinfo_list;
 126
 127
 128 /*
 129   blogic_cmd_failure_reason holds a string identifying the reason why a
 130   call to blogic_cmd failed.  It is only non-NULL when blogic_cmd
 131   returns a failure code.
 132 */
 133
 134 static char *blogic_cmd_failure_reason;
 135
 136 /*
 137   blogic_announce_drvr announces the Driver Version and Date, Author's
 138   Name, Copyright Notice, and Electronic Mail Address.
 139 */
 140
 141 static void blogic_announce_drvr(struct blogic_adapter *adapter)
 142 {
 143         blogic_announce("***** BusLogic SCSI Driver Version " blogic_drvr_version " of " blogic_drvr_date " *****\n", adapter);
 144         blogic_announce("Copyright 1995-1998 by Leonard N. Zubkoff " "<lnz@dandelion.com>\n", adapter);
 145 }
 146
 147
 148 /*
 149   blogic_drvr_info returns the Host Adapter Name to identify this SCSI
 150   Driver and Host Adapter.
 151 */
 152
 153 static const char *blogic_drvr_info(struct Scsi_Host *host)
 154 {
 155         struct blogic_adapter *adapter =
 156                                 (struct blogic_adapter *) host->hostdata;
 157         return adapter->full_model;
 158 }
 159
 160 /*
 161   blogic_init_ccbs initializes a group of Command Control Blocks (CCBs)
 162   for Host Adapter from the blk_size bytes located at blk_pointer.  The newly
 163   created CCBs are added to Host Adapter's free list.
 164 */
 165
 166 static void blogic_init_ccbs(struct blogic_adapter *adapter, void *blk_pointer,
 167                                 int blk_size, dma_addr_t blkp)
 168 {
 169         struct blogic_ccb *ccb = (struct blogic_ccb *) blk_pointer;
 170         unsigned int offset = 0;
 171         memset(blk_pointer, 0, blk_size);
 172         ccb->allocgrp_head = blkp;
 173         ccb->allocgrp_size = blk_size;
 174         while ((blk_size -= sizeof(struct blogic_ccb)) >= 0) {
 175                 ccb->status = BLOGIC_CCB_FREE;
 176                 ccb->adapter = adapter;
 177                 ccb->dma_handle = (u32) blkp + offset;
 178                 if (blogic_flashpoint_type(adapter)) {
 179                         ccb->callback = blogic_qcompleted_ccb;
 180                         ccb->base_addr = adapter->fpinfo.base_addr;
 181                 }
 182                 ccb->next = adapter->free_ccbs;
 183                 ccb->next_all = adapter->all_ccbs;
 184                 adapter->free_ccbs = ccb;
 185                 adapter->all_ccbs = ccb;
 186                 adapter->alloc_ccbs++;
 187                 ccb++;
 188                 offset += sizeof(struct blogic_ccb);
 189         }
 190 }
 191
 192
 193 /*
 194   blogic_create_initccbs allocates the initial CCBs for Host Adapter.
 195 */
 196
 197 static bool __init blogic_create_initccbs(struct blogic_adapter *adapter)
 198 {
 199         int blk_size = BLOGIC_CCB_GRP_ALLOCSIZE * sizeof(struct blogic_ccb);
 200         void *blk_pointer;
 201         dma_addr_t blkp;
 202
 203         while (adapter->alloc_ccbs < adapter->initccbs) {
 204                 blk_pointer = dma_alloc_coherent(&adapter->pci_device->dev,
 205                                 blk_size, &blkp, GFP_KERNEL);
 206                 if (blk_pointer == NULL) {
 207                         blogic_err("UNABLE TO ALLOCATE CCB GROUP - DETACHING\n",
 208                                         adapter);
 209                         return false;
 210                 }
 211                 blogic_init_ccbs(adapter, blk_pointer, blk_size, blkp);
 212         }
 213         return true;
 214 }
 215
 216
 217 /*
 218   blogic_destroy_ccbs deallocates the CCBs for Host Adapter.
 219 */
 220
 221 static void blogic_destroy_ccbs(struct blogic_adapter *adapter)
 222 {
 223         struct blogic_ccb *next_ccb = adapter->all_ccbs, *ccb, *lastccb = NULL;
 224         adapter->all_ccbs = NULL;
 225         adapter->free_ccbs = NULL;
 226         while ((ccb = next_ccb) != NULL) {
 227                 next_ccb = ccb->next_all;
 228                 if (ccb->allocgrp_head) {
 229                         if (lastccb)
 230                                 dma_free_coherent(&adapter->pci_device->dev,
 231                                                 lastccb->allocgrp_size, lastccb,
 232                                                 lastccb->allocgrp_head);
 233                         lastccb = ccb;
 234                 }
 235         }
 236         if (lastccb)
 237                 dma_free_coherent(&adapter->pci_device->dev,
 238                                 lastccb->allocgrp_size, lastccb,
 239                                 lastccb->allocgrp_head);
 240 }
 241
 242
 243 /*
 244   blogic_create_addlccbs allocates Additional CCBs for Host Adapter.  If
 245   allocation fails and there are no remaining CCBs available, the Driver Queue
 246   Depth is decreased to a known safe value to avoid potential deadlocks when
 247   multiple host adapters share the same IRQ Channel.
 248 */
 249
 250 static void blogic_create_addlccbs(struct blogic_adapter *adapter,
 251                                         int addl_ccbs, bool print_success)
 252 {
 253         int blk_size = BLOGIC_CCB_GRP_ALLOCSIZE * sizeof(struct blogic_ccb);
 254         int prev_alloc = adapter->alloc_ccbs;
 255         void *blk_pointer;
 256         dma_addr_t blkp;
 257         if (addl_ccbs <= 0)
 258                 return;
 259         while (adapter->alloc_ccbs - prev_alloc < addl_ccbs) {
 260                 blk_pointer = dma_alloc_coherent(&adapter->pci_device->dev,
 261                                 blk_size, &blkp, GFP_KERNEL);
 262                 if (blk_pointer == NULL)
 263                         break;
 264                 blogic_init_ccbs(adapter, blk_pointer, blk_size, blkp);
 265         }
 266         if (adapter->alloc_ccbs > prev_alloc) {
 267                 if (print_success)
 268                         blogic_notice("Allocated %d additional CCBs (total now %d)\n", adapter, adapter->alloc_ccbs - prev_alloc, adapter->alloc_ccbs);
 269                 return;
 270         }
 271         blogic_notice("Failed to allocate additional CCBs\n", adapter);
 272         if (adapter->drvr_qdepth > adapter->alloc_ccbs - adapter->tgt_count) {
 273                 adapter->drvr_qdepth = adapter->alloc_ccbs - adapter->tgt_count;
 274                 adapter->scsi_host->can_queue = adapter->drvr_qdepth;
 275         }
 276 }
 277
 278 /*
 279   blogic_alloc_ccb allocates a CCB from Host Adapter's free list,
 280   allocating more memory from the Kernel if necessary.  The Host Adapter's
 281   Lock should already have been acquired by the caller.
 282 */
 283
 284 static struct blogic_ccb *blogic_alloc_ccb(struct blogic_adapter *adapter)
 285 {
 286         static unsigned long serial;
 287         struct blogic_ccb *ccb;
 288         ccb = adapter->free_ccbs;
 289         if (ccb != NULL) {
 290                 ccb->serial = ++serial;
 291                 adapter->free_ccbs = ccb->next;
 292                 ccb->next = NULL;
 293                 if (adapter->free_ccbs == NULL)
 294                         blogic_create_addlccbs(adapter, adapter->inc_ccbs,
 295                                                 true);
 296                 return ccb;
 297         }
 298         blogic_create_addlccbs(adapter, adapter->inc_ccbs, true);
 299         ccb = adapter->free_ccbs;
 300         if (ccb == NULL)
 301                 return NULL;
 302         ccb->serial = ++serial;
 303         adapter->free_ccbs = ccb->next;
 304         ccb->next = NULL;
 305         return ccb;
 306 }
 307
 308
 309 /*
 310   blogic_dealloc_ccb deallocates a CCB, returning it to the Host Adapter's
 311   free list.  The Host Adapter's Lock should already have been acquired by the
 312   caller.
 313 */
 314
 315 static void blogic_dealloc_ccb(struct blogic_ccb *ccb, int dma_unmap)
 316 {
 317         struct blogic_adapter *adapter = ccb->adapter;
 318
 319         if (ccb->command != NULL)
 320                 scsi_dma_unmap(ccb->command);
 321         if (dma_unmap)
 322                 dma_unmap_single(&adapter->pci_device->dev, ccb->sensedata,
 323                          ccb->sense_datalen, DMA_FROM_DEVICE);
 324
 325         ccb->command = NULL;
 326         ccb->status = BLOGIC_CCB_FREE;
 327         ccb->next = adapter->free_ccbs;
 328         adapter->free_ccbs = ccb;
 329 }
 330
 331
 332 /*
 333   blogic_cmd sends the command opcode to adapter, optionally
 334   providing paramlen bytes of param and receiving at most
 335   replylen bytes of reply; any excess reply data is received but
 336   discarded.
 337
 338   On success, this function returns the number of reply bytes read from
 339   the Host Adapter (including any discarded data); on failure, it returns
 340   -1 if the command was invalid, or -2 if a timeout occurred.
 341
 342   blogic_cmd is called exclusively during host adapter detection and
 343   initialization, so performance and latency are not critical, and exclusive
 344   access to the Host Adapter hardware is assumed.  Once the host adapter and
 345   driver are initialized, the only Host Adapter command that is issued is the
 346   single byte Execute Mailbox Command operation code, which does not require
 347   waiting for the Host Adapter Ready bit to be set in the Status Register.
 348 */
 349
 350 static int blogic_cmd(struct blogic_adapter *adapter, enum blogic_opcode opcode,
 351                         void *param, int paramlen, void *reply, int replylen)
 352 {
 353         unsigned char *param_p = (unsigned char *) param;
 354         unsigned char *reply_p = (unsigned char *) reply;
 355         union blogic_stat_reg statusreg;
 356         union blogic_int_reg intreg;
 357         unsigned long processor_flag = 0;
 358         int reply_b = 0, result;
 359         long timeout;
 360         /*
 361            Clear out the Reply Data if provided.
 362          */
 363         if (replylen > 0)
 364                 memset(reply, 0, replylen);
 365         /*
 366            If the IRQ Channel has not yet been acquired, then interrupts
 367            must be disabled while issuing host adapter commands since a
 368            Command Complete interrupt could occur if the IRQ Channel was
 369            previously enabled by another BusLogic Host Adapter or another
 370            driver sharing the same IRQ Channel.
 371          */
 372         if (!adapter->irq_acquired)
 373                 local_irq_save(processor_flag);
 374         /*
 375            Wait for the Host Adapter Ready bit to be set and the
 376            Command/Parameter Register Busy bit to be reset in the Status
 377            Register.
 378          */
 379         timeout = 10000;
 380         while (--timeout >= 0) {
 381                 statusreg.all = blogic_rdstatus(adapter);
 382                 if (statusreg.sr.adapter_ready && !statusreg.sr.cmd_param_busy)
 383                         break;
 384                 udelay(100);
 385         }
 386         if (timeout < 0) {
 387                 blogic_cmd_failure_reason =
 388                                 "Timeout waiting for Host Adapter Ready";
 389                 result = -2;
 390                 goto done;
 391         }
 392         /*
 393            Write the opcode to the Command/Parameter Register.
 394          */
 395         adapter->adapter_cmd_complete = false;
 396         blogic_setcmdparam(adapter, opcode);
 397         /*
 398            Write any additional Parameter Bytes.
 399          */
 400         timeout = 10000;
 401         while (paramlen > 0 && --timeout >= 0) {
 402                 /*
 403                    Wait 100 microseconds to give the Host Adapter enough
 404                    time to determine whether the last value written to the
 405                    Command/Parameter Register was valid or not. If the
 406                    Command Complete bit is set in the Interrupt Register,
 407                    then the Command Invalid bit in the Status Register will
 408                    be reset if the Operation Code or Parameter was valid
 409                    and the command has completed, or set if the Operation
 410                    Code or Parameter was invalid. If the Data In Register
 411                    Ready bit is set in the Status Register, then the
 412                    Operation Code was valid, and data is waiting to be read
 413                    back from the Host Adapter. Otherwise, wait for the
 414                    Command/Parameter Register Busy bit in the Status
 415                    Register to be reset.
 416                  */
 417                 udelay(100);
 418                 intreg.all = blogic_rdint(adapter);
 419                 statusreg.all = blogic_rdstatus(adapter);
 420                 if (intreg.ir.cmd_complete)
 421                         break;
 422                 if (adapter->adapter_cmd_complete)
 423                         break;
 424                 if (statusreg.sr.datain_ready)
 425                         break;
 426                 if (statusreg.sr.cmd_param_busy)
 427                         continue;
 428                 blogic_setcmdparam(adapter, *param_p++);
 429                 paramlen--;
 430         }
 431         if (timeout < 0) {
 432                 blogic_cmd_failure_reason =
 433                                 "Timeout waiting for Parameter Acceptance";
 434                 result = -2;
 435                 goto done;
 436         }
 437         /*
 438            The Modify I/O Address command does not cause a Command Complete
 439            Interrupt.
 440          */
 441         if (opcode == BLOGIC_MOD_IOADDR) {
 442                 statusreg.all = blogic_rdstatus(adapter);
 443                 if (statusreg.sr.cmd_invalid) {
 444                         blogic_cmd_failure_reason =
 445                                         "Modify I/O Address Invalid";
 446                         result = -1;
 447                         goto done;
 448                 }
 449                 if (blogic_global_options.trace_config)
 450                         blogic_notice("blogic_cmd(%02X) Status = %02X: " "(Modify I/O Address)\n", adapter, opcode, statusreg.all);
 451                 result = 0;
 452                 goto done;
 453         }
 454         /*
 455            Select an appropriate timeout value for awaiting command completion.
 456          */
 457         switch (opcode) {
 458         case BLOGIC_INQ_DEV0TO7:
 459         case BLOGIC_INQ_DEV8TO15:
 460         case BLOGIC_INQ_DEV:
 461                 /* Approximately 60 seconds. */
 462                 timeout = 60 * 10000;
 463                 break;
 464         default:
 465                 /* Approximately 1 second. */
 466                 timeout = 10000;
 467                 break;
 468         }
 469         /*
 470            Receive any Reply Bytes, waiting for either the Command
 471            Complete bit to be set in the Interrupt Register, or for the
 472            Interrupt Handler to set the Host Adapter Command Completed
 473            bit in the Host Adapter structure.
 474          */
 475         while (--timeout >= 0) {
 476                 intreg.all = blogic_rdint(adapter);
 477                 statusreg.all = blogic_rdstatus(adapter);
 478                 if (intreg.ir.cmd_complete)
 479                         break;
 480                 if (adapter->adapter_cmd_complete)
 481                         break;
 482                 if (statusreg.sr.datain_ready) {
 483                         if (++reply_b <= replylen)
 484                                 *reply_p++ = blogic_rddatain(adapter);
 485                         else
 486                                 blogic_rddatain(adapter);
 487                 }
 488                 if (opcode == BLOGIC_FETCH_LOCALRAM &&
 489                                 statusreg.sr.adapter_ready)
 490                         break;
 491                 udelay(100);
 492         }
 493         if (timeout < 0) {
 494                 blogic_cmd_failure_reason =
 495                                         "Timeout waiting for Command Complete";
 496                 result = -2;
 497                 goto done;
 498         }
 499         /*
 500            Clear any pending Command Complete Interrupt.
 501          */
 502         blogic_intreset(adapter);
 503         /*
 504            Provide tracing information if requested.
 505          */
 506         if (blogic_global_options.trace_config) {
 507                 int i;
 508                 blogic_notice("blogic_cmd(%02X) Status = %02X: %2d ==> %2d:",
 509                                 adapter, opcode, statusreg.all, replylen,
 510                                 reply_b);
 511                 if (replylen > reply_b)
 512                         replylen = reply_b;
 513                 for (i = 0; i < replylen; i++)
 514                         blogic_notice(" %02X", adapter,
 515                                         ((unsigned char *) reply)[i]);
 516                 blogic_notice("\n", adapter);
 517         }
 518         /*
 519            Process Command Invalid conditions.
 520          */
 521         if (statusreg.sr.cmd_invalid) {
 522                 /*
 523                    Some early BusLogic Host Adapters may not recover
 524                    properly from a Command Invalid condition, so if this
 525                    appears to be the case, a Soft Reset is issued to the
 526                    Host Adapter.  Potentially invalid commands are never
 527                    attempted after Mailbox Initialization is performed,
 528                    so there should be no Host Adapter state lost by a
 529                    Soft Reset in response to a Command Invalid condition.
 530                  */
 531                 udelay(1000);
 532                 statusreg.all = blogic_rdstatus(adapter);
 533                 if (statusreg.sr.cmd_invalid || statusreg.sr.rsvd ||
 534                                 statusreg.sr.datain_ready ||
 535                                 statusreg.sr.cmd_param_busy ||
 536                                 !statusreg.sr.adapter_ready ||
 537                                 !statusreg.sr.init_reqd ||
 538                                 statusreg.sr.diag_active ||
 539                                 statusreg.sr.diag_failed) {
 540                         blogic_softreset(adapter);
 541                         udelay(1000);
 542                 }
 543                 blogic_cmd_failure_reason = "Command Invalid";
 544                 result = -1;
 545                 goto done;
 546         }
 547         /*
 548            Handle Excess Parameters Supplied conditions.
 549          */
 550         if (paramlen > 0) {
 551                 blogic_cmd_failure_reason = "Excess Parameters Supplied";
 552                 result = -1;
 553                 goto done;
 554         }
 555         /*
 556            Indicate the command completed successfully.
 557          */
 558         blogic_cmd_failure_reason = NULL;
 559         result = reply_b;
 560         /*
 561            Restore the interrupt status if necessary and return.
 562          */
 563 done:
 564         if (!adapter->irq_acquired)
 565                 local_irq_restore(processor_flag);
 566         return result;
 567 }
 568
 569
 570 /*
 571   blogic_add_probeaddr_isa appends a single ISA I/O Address to the list
 572   of I/O Address and Bus Probe Information to be checked for potential BusLogic
 573   Host Adapters.
 574 */
 575
 576 static void __init blogic_add_probeaddr_isa(unsigned long io_addr)
 577 {
 578         struct blogic_probeinfo *probeinfo;
 579         if (blogic_probeinfo_count >= BLOGIC_MAX_ADAPTERS)
 580                 return;
 581         probeinfo = &blogic_probeinfo_list[blogic_probeinfo_count++];
 582         probeinfo->adapter_type = BLOGIC_MULTIMASTER;
 583         probeinfo->adapter_bus_type = BLOGIC_ISA_BUS;
 584         probeinfo->io_addr = io_addr;
 585         probeinfo->pci_device = NULL;
 586 }
 587
 588
 589 /*
 590   blogic_init_probeinfo_isa initializes the list of I/O Address and
 591   Bus Probe Information to be checked for potential BusLogic SCSI Host Adapters
 592   only from the list of standard BusLogic MultiMaster ISA I/O Addresses.
 593 */
 594
 595 static void __init blogic_init_probeinfo_isa(struct blogic_adapter *adapter)
 596 {
 597         /*
 598            If BusLogic Driver Options specifications requested that ISA
 599            Bus Probes be inhibited, do not proceed further.
 600          */
 601         if (blogic_probe_options.noprobe_isa)
 602                 return;
 603         /*
 604            Append the list of standard BusLogic MultiMaster ISA I/O Addresses.
 605          */
 606         if (!blogic_probe_options.limited_isa || blogic_probe_options.probe330)
 607                 blogic_add_probeaddr_isa(0x330);
 608         if (!blogic_probe_options.limited_isa || blogic_probe_options.probe334)
 609                 blogic_add_probeaddr_isa(0x334);
 610         if (!blogic_probe_options.limited_isa || blogic_probe_options.probe230)
 611                 blogic_add_probeaddr_isa(0x230);
 612         if (!blogic_probe_options.limited_isa || blogic_probe_options.probe234)
 613                 blogic_add_probeaddr_isa(0x234);
 614         if (!blogic_probe_options.limited_isa || blogic_probe_options.probe130)
 615                 blogic_add_probeaddr_isa(0x130);
 616         if (!blogic_probe_options.limited_isa || blogic_probe_options.probe134)
 617                 blogic_add_probeaddr_isa(0x134);
 618 }
 619
 620
 621 #ifdef CONFIG_PCI
 622
 623
 624 /*
 625   blogic_sort_probeinfo sorts a section of blogic_probeinfo_list in order
 626   of increasing PCI Bus and Device Number.
 627 */
 628
 629 static void __init blogic_sort_probeinfo(struct blogic_probeinfo
 630                                         *probeinfo_list, int probeinfo_cnt)
 631 {
 632         int last_exchange = probeinfo_cnt - 1, bound, j;
 633
 634         while (last_exchange > 0) {
 635                 bound = last_exchange;
 636                 last_exchange = 0;
 637                 for (j = 0; j < bound; j++) {
 638                         struct blogic_probeinfo *probeinfo1 =
 639                                                         &probeinfo_list[j];
 640                         struct blogic_probeinfo *probeinfo2 =
 641                                                         &probeinfo_list[j + 1];
 642                         if (probeinfo1->bus > probeinfo2->bus ||
 643                                 (probeinfo1->bus == probeinfo2->bus &&
 644                                 (probeinfo1->dev > probeinfo2->dev))) {
 645                                 struct blogic_probeinfo tmp_probeinfo;
 646
 647                                 memcpy(&tmp_probeinfo, probeinfo1,
 648                                         sizeof(struct blogic_probeinfo));
 649                                 memcpy(probeinfo1, probeinfo2,
 650                                         sizeof(struct blogic_probeinfo));
 651                                 memcpy(probeinfo2, &tmp_probeinfo,
 652                                         sizeof(struct blogic_probeinfo));
 653                                 last_exchange = j;
 654                         }
 655                 }
 656         }
 657 }
 658
 659
 660 /*
 661   blogic_init_mm_probeinfo initializes the list of I/O Address
 662   and Bus Probe Information to be checked for potential BusLogic MultiMaster
 663   SCSI Host Adapters by interrogating the PCI Configuration Space on PCI
 664   machines as well as from the list of standard BusLogic MultiMaster ISA
 665   I/O Addresses.  It returns the number of PCI MultiMaster Host Adapters found.
 666 */
 667
 668 static int __init blogic_init_mm_probeinfo(struct blogic_adapter *adapter)
 669 {
 670         struct blogic_probeinfo *pr_probeinfo =
 671                 &blogic_probeinfo_list[blogic_probeinfo_count];
 672         int nonpr_mmindex = blogic_probeinfo_count + 1;
 673         int nonpr_mmcount = 0, mmcount = 0;
 674         bool force_scan_order = false;
 675         bool force_scan_order_checked = false;
 676         bool addr_seen[6];
 677         struct pci_dev *pci_device = NULL;
 678         int i;
 679         if (blogic_probeinfo_count >= BLOGIC_MAX_ADAPTERS)
 680                 return 0;
 681         blogic_probeinfo_count++;
 682         for (i = 0; i < 6; i++)
 683                 addr_seen[i] = false;
 684         /*
 685            Iterate over the MultiMaster PCI Host Adapters.  For each
 686            enumerated host adapter, determine whether its ISA Compatible
 687            I/O Port is enabled and if so, whether it is assigned the
 688            Primary I/O Address.  A host adapter that is assigned the
 689            Primary I/O Address will always be the preferred boot device.
 690            The MultiMaster BIOS will first recognize a host adapter at
 691            the Primary I/O Address, then any other PCI host adapters,
 692            and finally any host adapters located at the remaining
 693            standard ISA I/O Addresses.  When a PCI host adapter is found
 694            with its ISA Compatible I/O Port enabled, a command is issued
 695            to disable the ISA Compatible I/O Port, and it is noted that the
 696            particular standard ISA I/O Address need not be probed.
 697          */
 698         pr_probeinfo->io_addr = 0;
 699         while ((pci_device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC,
 700                                         PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER,
 701                                         pci_device)) != NULL) {
 702                 struct blogic_adapter *host_adapter = adapter;
 703                 struct blogic_adapter_info adapter_info;
 704                 enum blogic_isa_ioport mod_ioaddr_req;
 705                 unsigned char bus;
 706                 unsigned char device;
 707                 unsigned int irq_ch;
 708                 unsigned long base_addr0;
 709                 unsigned long base_addr1;
 710                 unsigned long io_addr;
 711                 unsigned long pci_addr;
 712
 713                 if (pci_enable_device(pci_device))
 714                         continue;
 715
 716                 if (dma_set_mask(&pci_device->dev, DMA_BIT_MASK(32)))
 717                         continue;
 718
 719                 bus = pci_device->bus->number;
 720                 device = pci_device->devfn >> 3;
 721                 irq_ch = pci_device->irq;
 722                 io_addr = base_addr0 = pci_resource_start(pci_device, 0);
 723                 pci_addr = base_addr1 = pci_resource_start(pci_device, 1);
 724
 725                 if (pci_resource_flags(pci_device, 0) & IORESOURCE_MEM) {
 726                         blogic_err("BusLogic: Base Address0 0x%X not I/O for " "MultiMaster Host Adapter\n", NULL, base_addr0);
 727                         blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr);
 728                         continue;
 729                 }
 730                 if (pci_resource_flags(pci_device, 1) & IORESOURCE_IO) {
 731                         blogic_err("BusLogic: Base Address1 0x%X not Memory for " "MultiMaster Host Adapter\n", NULL, base_addr1);
 732                         blogic_err("at PCI Bus %d Device %d PCI Address 0x%X\n", NULL, bus, device, pci_addr);
 733                         continue;
 734                 }
 735                 if (irq_ch == 0) {
 736                         blogic_err("BusLogic: IRQ Channel %d invalid for " "MultiMaster Host Adapter\n", NULL, irq_ch);
 737                         blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr);
 738                         continue;
 739                 }
 740                 if (blogic_global_options.trace_probe) {
 741                         blogic_notice("BusLogic: PCI MultiMaster Host Adapter " "detected at\n", NULL);
 742                         blogic_notice("BusLogic: PCI Bus %d Device %d I/O Address " "0x%X PCI Address 0x%X\n", NULL, bus, device, io_addr, pci_addr);
 743                 }
 744                 /*
 745                    Issue the Inquire PCI Host Adapter Information command to determine
 746                    the ISA Compatible I/O Port.  If the ISA Compatible I/O Port is
 747                    known and enabled, note that the particular Standard ISA I/O
 748                    Address should not be probed.
 749                  */
 750                 host_adapter->io_addr = io_addr;
 751                 blogic_intreset(host_adapter);
 752                 if (blogic_cmd(host_adapter, BLOGIC_INQ_PCI_INFO, NULL, 0,
 753                                 &adapter_info, sizeof(adapter_info)) ==
 754                                 sizeof(adapter_info)) {
 755                         if (adapter_info.isa_port < 6)
 756                                 addr_seen[adapter_info.isa_port] = true;
 757                 } else
 758                         adapter_info.isa_port = BLOGIC_IO_DISABLE;
 759                 /*
 760                    Issue the Modify I/O Address command to disable the
 761                    ISA Compatible I/O Port. On PCI Host Adapters, the
 762                    Modify I/O Address command allows modification of the
 763                    ISA compatible I/O Address that the Host Adapter
 764                    responds to; it does not affect the PCI compliant
 765                    I/O Address assigned at system initialization.
 766                  */
 767                 mod_ioaddr_req = BLOGIC_IO_DISABLE;
 768                 blogic_cmd(host_adapter, BLOGIC_MOD_IOADDR, &mod_ioaddr_req,
 769                                 sizeof(mod_ioaddr_req), NULL, 0);
 770                 /*
 771                    For the first MultiMaster Host Adapter enumerated,
 772                    issue the Fetch Host Adapter Local RAM command to read
 773                    byte 45 of the AutoSCSI area, for the setting of the
 774                    "Use Bus And Device # For PCI Scanning Seq." option.
 775                    Issue the Inquire Board ID command since this option is
 776                    only valid for the BT-948/958/958D.
 777                  */
 778                 if (!force_scan_order_checked) {
 779                         struct blogic_fetch_localram fetch_localram;
 780                         struct blogic_autoscsi_byte45 autoscsi_byte45;
 781                         struct blogic_board_id id;
 782
 783                         fetch_localram.offset = BLOGIC_AUTOSCSI_BASE + 45;
 784                         fetch_localram.count = sizeof(autoscsi_byte45);
 785                         blogic_cmd(host_adapter, BLOGIC_FETCH_LOCALRAM,
 786                                         &fetch_localram, sizeof(fetch_localram),
 787                                         &autoscsi_byte45,
 788                                         sizeof(autoscsi_byte45));
 789                         blogic_cmd(host_adapter, BLOGIC_GET_BOARD_ID, NULL, 0,
 790                                         &id, sizeof(id));
 791                         if (id.fw_ver_digit1 == '5')
 792                                 force_scan_order =
 793                                         autoscsi_byte45.force_scan_order;
 794                         force_scan_order_checked = true;
 795                 }
 796                 /*
 797                    Determine whether this MultiMaster Host Adapter has its
 798                    ISA Compatible I/O Port enabled and is assigned the
 799                    Primary I/O Address. If it does, then it is the Primary
 800                    MultiMaster Host Adapter and must be recognized first.
 801                    If it does not, then it is added to the list for probing
 802                    after any Primary MultiMaster Host Adapter is probed.
 803                  */
 804                 if (adapter_info.isa_port == BLOGIC_IO_330) {
 805                         pr_probeinfo->adapter_type = BLOGIC_MULTIMASTER;
 806                         pr_probeinfo->adapter_bus_type = BLOGIC_PCI_BUS;
 807                         pr_probeinfo->io_addr = io_addr;
 808                         pr_probeinfo->pci_addr = pci_addr;
 809                         pr_probeinfo->bus = bus;
 810                         pr_probeinfo->dev = device;
 811                         pr_probeinfo->irq_ch = irq_ch;
 812                         pr_probeinfo->pci_device = pci_dev_get(pci_device);
 813                         mmcount++;
 814                 } else if (blogic_probeinfo_count < BLOGIC_MAX_ADAPTERS) {
 815                         struct blogic_probeinfo *probeinfo =
 816                                 &blogic_probeinfo_list[blogic_probeinfo_count++];
 817                         probeinfo->adapter_type = BLOGIC_MULTIMASTER;
 818                         probeinfo->adapter_bus_type = BLOGIC_PCI_BUS;
 819                         probeinfo->io_addr = io_addr;
 820                         probeinfo->pci_addr = pci_addr;
 821                         probeinfo->bus = bus;
 822                         probeinfo->dev = device;
 823                         probeinfo->irq_ch = irq_ch;
 824                         probeinfo->pci_device = pci_dev_get(pci_device);
 825                         nonpr_mmcount++;
 826                         mmcount++;
 827                 } else
 828                         blogic_warn("BusLogic: Too many Host Adapters " "detected\n", NULL);
 829         }
 830         /*
 831            If the AutoSCSI "Use Bus And Device # For PCI Scanning Seq."
 832            option is ON for the first enumerated MultiMaster Host Adapter,
 833            and if that host adapter is a BT-948/958/958D, then the
 834            MultiMaster BIOS will recognize MultiMaster Host Adapters in
 835            the order of increasing PCI Bus and Device Number. In that case,
 836            sort the probe information into the same order the BIOS uses.
 837            If this option is OFF, then the MultiMaster BIOS will recognize
 838            MultiMaster Host Adapters in the order they are enumerated by
 839            the PCI BIOS, and hence no sorting is necessary.
 840          */
 841         if (force_scan_order)
 842                 blogic_sort_probeinfo(&blogic_probeinfo_list[nonpr_mmindex],
 843                                         nonpr_mmcount);
 844         /*
 845            If no PCI MultiMaster Host Adapter is assigned the Primary
 846            I/O Address, then the Primary I/O Address must be probed
 847            explicitly before any PCI host adapters are probed.
 848          */
 849         if (!blogic_probe_options.noprobe_isa)
 850                 if (pr_probeinfo->io_addr == 0 &&
 851                                 (!blogic_probe_options.limited_isa ||
 852                                  blogic_probe_options.probe330)) {
 853                         pr_probeinfo->adapter_type = BLOGIC_MULTIMASTER;
 854                         pr_probeinfo->adapter_bus_type = BLOGIC_ISA_BUS;
 855                         pr_probeinfo->io_addr = 0x330;
 856                 }
 857         /*
 858            Append the list of standard BusLogic MultiMaster ISA I/O Addresses,
 859            omitting the Primary I/O Address which has already been handled.
 860          */
 861         if (!blogic_probe_options.noprobe_isa) {
 862                 if (!addr_seen[1] &&
 863                                 (!blogic_probe_options.limited_isa ||
 864                                  blogic_probe_options.probe334))
 865                         blogic_add_probeaddr_isa(0x334);
 866                 if (!addr_seen[2] &&
 867                                 (!blogic_probe_options.limited_isa ||
 868                                  blogic_probe_options.probe230))
 869                         blogic_add_probeaddr_isa(0x230);
 870                 if (!addr_seen[3] &&
 871                                 (!blogic_probe_options.limited_isa ||
 872                                  blogic_probe_options.probe234))
 873                         blogic_add_probeaddr_isa(0x234);
 874                 if (!addr_seen[4] &&
 875                                 (!blogic_probe_options.limited_isa ||
 876                                  blogic_probe_options.probe130))
 877                         blogic_add_probeaddr_isa(0x130);
 878                 if (!addr_seen[5] &&
 879                                 (!blogic_probe_options.limited_isa ||
 880                                  blogic_probe_options.probe134))
 881                         blogic_add_probeaddr_isa(0x134);
 882         }
 883         /*
 884            Iterate over the older non-compliant MultiMaster PCI Host Adapters,
 885            noting the PCI bus location and assigned IRQ Channel.
 886          */
 887         pci_device = NULL;
 888         while ((pci_device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC,
 889                                         PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC,
 890                                         pci_device)) != NULL) {
 891                 unsigned char bus;
 892                 unsigned char device;
 893                 unsigned int irq_ch;
 894                 unsigned long io_addr;
 895
 896                 if (pci_enable_device(pci_device))
 897                         continue;
 898
 899                 if (dma_set_mask(&pci_device->dev, DMA_BIT_MASK(32)))
 900                         continue;
 901
 902                 bus = pci_device->bus->number;
 903                 device = pci_device->devfn >> 3;
 904                 irq_ch = pci_device->irq;
 905                 io_addr = pci_resource_start(pci_device, 0);
 906
 907                 if (io_addr == 0 || irq_ch == 0)
 908                         continue;
 909                 for (i = 0; i < blogic_probeinfo_count; i++) {
 910                         struct blogic_probeinfo *probeinfo =
 911                                                 &blogic_probeinfo_list[i];
 912                         if (probeinfo->io_addr == io_addr &&
 913                                 probeinfo->adapter_type == BLOGIC_MULTIMASTER) {
 914                                 probeinfo->adapter_bus_type = BLOGIC_PCI_BUS;
 915                                 probeinfo->pci_addr = 0;
 916                                 probeinfo->bus = bus;
 917                                 probeinfo->dev = device;
 918                                 probeinfo->irq_ch = irq_ch;
 919                                 probeinfo->pci_device = pci_dev_get(pci_device);
 920                                 break;
 921                         }
 922                 }
 923         }
 924         return mmcount;
 925 }
 926
 927
 928 /*
 929   blogic_init_fp_probeinfo initializes the list of I/O Address
 930   and Bus Probe Information to be checked for potential BusLogic FlashPoint
 931   Host Adapters by interrogating the PCI Configuration Space.  It returns the
 932   number of FlashPoint Host Adapters found.
 933 */
 934
 935 static int __init blogic_init_fp_probeinfo(struct blogic_adapter *adapter)
 936 {
 937         int fpindex = blogic_probeinfo_count, fpcount = 0;
 938         struct pci_dev *pci_device = NULL;
 939         /*
 940            Interrogate PCI Configuration Space for any FlashPoint Host Adapters.
 941          */
 942         while ((pci_device = pci_get_device(PCI_VENDOR_ID_BUSLOGIC,
 943                                         PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT,
 944                                         pci_device)) != NULL) {
 945                 unsigned char bus;
 946                 unsigned char device;
 947                 unsigned int irq_ch;
 948                 unsigned long base_addr0;
 949                 unsigned long base_addr1;
 950                 unsigned long io_addr;
 951                 unsigned long pci_addr;
 952
 953                 if (pci_enable_device(pci_device))
 954                         continue;
 955
 956                 if (dma_set_mask(&pci_device->dev, DMA_BIT_MASK(32)))
 957                         continue;
 958
 959                 bus = pci_device->bus->number;
 960                 device = pci_device->devfn >> 3;
 961                 irq_ch = pci_device->irq;
 962                 io_addr = base_addr0 = pci_resource_start(pci_device, 0);
 963                 pci_addr = base_addr1 = pci_resource_start(pci_device, 1);
 964 #ifdef CONFIG_SCSI_FLASHPOINT
 965                 if (pci_resource_flags(pci_device, 0) & IORESOURCE_MEM) {
 966                         blogic_err("BusLogic: Base Address0 0x%X not I/O for " "FlashPoint Host Adapter\n", NULL, base_addr0);
 967                         blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr);
 968                         continue;
 969                 }
 970                 if (pci_resource_flags(pci_device, 1) & IORESOURCE_IO) {
 971                         blogic_err("BusLogic: Base Address1 0x%X not Memory for " "FlashPoint Host Adapter\n", NULL, base_addr1);
 972                         blogic_err("at PCI Bus %d Device %d PCI Address 0x%X\n", NULL, bus, device, pci_addr);
 973                         continue;
 974                 }
 975                 if (irq_ch == 0) {
 976                         blogic_err("BusLogic: IRQ Channel %d invalid for " "FlashPoint Host Adapter\n", NULL, irq_ch);
 977                         blogic_err("at PCI Bus %d Device %d I/O Address 0x%X\n", NULL, bus, device, io_addr);
 978                         continue;
 979                 }
 980                 if (blogic_global_options.trace_probe) {
 981                         blogic_notice("BusLogic: FlashPoint Host Adapter " "detected at\n", NULL);
 982                         blogic_notice("BusLogic: PCI Bus %d Device %d I/O Address " "0x%X PCI Address 0x%X\n", NULL, bus, device, io_addr, pci_addr);
 983                 }
 984                 if (blogic_probeinfo_count < BLOGIC_MAX_ADAPTERS) {
 985                         struct blogic_probeinfo *probeinfo =
 986                                 &blogic_probeinfo_list[blogic_probeinfo_count++];
 987                         probeinfo->adapter_type = BLOGIC_FLASHPOINT;
 988                         probeinfo->adapter_bus_type = BLOGIC_PCI_BUS;
 989                         probeinfo->io_addr = io_addr;
 990                         probeinfo->pci_addr = pci_addr;
 991                         probeinfo->bus = bus;
 992                         probeinfo->dev = device;
 993                         probeinfo->irq_ch = irq_ch;
 994                         probeinfo->pci_device = pci_dev_get(pci_device);
 995                         fpcount++;
 996                 } else
 997                         blogic_warn("BusLogic: Too many Host Adapters " "detected\n", NULL);
 998 #else
 999                 blogic_err("BusLogic: FlashPoint Host Adapter detected at " "PCI Bus %d Device %d\n", NULL, bus, device);
1000                 blogic_err("BusLogic: I/O Address 0x%X PCI Address 0x%X, irq %d, " "but FlashPoint\n", NULL, io_addr, pci_addr, irq_ch);
1001                 blogic_err("BusLogic: support was omitted in this kernel " "configuration.\n", NULL);
1002 #endif
1003         }
1004         /*
1005            The FlashPoint BIOS will scan for FlashPoint Host Adapters in the order of
1006            increasing PCI Bus and Device Number, so sort the probe information into
1007            the same order the BIOS uses.
1008          */
1009         blogic_sort_probeinfo(&blogic_probeinfo_list[fpindex], fpcount);
1010         return fpcount;
1011 }
1012
1013
1014 /*
1015   blogic_init_probeinfo_list initializes the list of I/O Address and Bus
1016   Probe Information to be checked for potential BusLogic SCSI Host Adapters by
1017   interrogating the PCI Configuration Space on PCI machines as well as from the
1018   list of standard BusLogic MultiMaster ISA I/O Addresses.  By default, if both
1019   FlashPoint and PCI MultiMaster Host Adapters are present, this driver will
1020   probe for FlashPoint Host Adapters first unless the BIOS primary disk is
1021   controlled by the first PCI MultiMaster Host Adapter, in which case
1022   MultiMaster Host Adapters will be probed first.  The BusLogic Driver Options
1023   specifications "MultiMasterFirst" and "FlashPointFirst" can be used to force
1024   a particular probe order.
1025 */
1026
1027 static void __init blogic_init_probeinfo_list(struct blogic_adapter *adapter)
1028 {
1029         /*
1030            If a PCI BIOS is present, interrogate it for MultiMaster and
1031            FlashPoint Host Adapters; otherwise, default to the standard
1032            ISA MultiMaster probe.
1033          */
1034         if (!blogic_probe_options.noprobe_pci) {
1035                 if (blogic_probe_options.multimaster_first) {
1036                         blogic_init_mm_probeinfo(adapter);
1037                         blogic_init_fp_probeinfo(adapter);
1038                 } else if (blogic_probe_options.flashpoint_first) {
1039                         blogic_init_fp_probeinfo(adapter);
1040                         blogic_init_mm_probeinfo(adapter);
1041                 } else {
1042                         int fpcount = blogic_init_fp_probeinfo(adapter);
1043                         int mmcount = blogic_init_mm_probeinfo(adapter);
1044                         if (fpcount > 0 && mmcount > 0) {
1045                                 struct blogic_probeinfo *probeinfo =
1046                                         &blogic_probeinfo_list[fpcount];
1047                                 struct blogic_adapter *myadapter = adapter;
1048                                 struct blogic_fetch_localram fetch_localram;
1049                                 struct blogic_bios_drvmap d0_mapbyte;
1050
1051                                 while (probeinfo->adapter_bus_type !=
1052                                                 BLOGIC_PCI_BUS)
1053                                         probeinfo++;
1054                                 myadapter->io_addr = probeinfo->io_addr;
1055                                 fetch_localram.offset =
1056                                         BLOGIC_BIOS_BASE + BLOGIC_BIOS_DRVMAP;
1057                                 fetch_localram.count = sizeof(d0_mapbyte);
1058                                 blogic_cmd(myadapter, BLOGIC_FETCH_LOCALRAM,
1059                                                 &fetch_localram,
1060                                                 sizeof(fetch_localram),
1061                                                 &d0_mapbyte,
1062                                                 sizeof(d0_mapbyte));
1063                                 /*
1064                                    If the Map Byte for BIOS Drive 0 indicates
1065                                    that BIOS Drive 0 is controlled by this
1066                                    PCI MultiMaster Host Adapter, then reverse
1067                                    the probe order so that MultiMaster Host
1068                                    Adapters are probed before FlashPoint Host
1069                                    Adapters.
1070                                  */
1071                                 if (d0_mapbyte.diskgeom != BLOGIC_BIOS_NODISK) {
1072                                         struct blogic_probeinfo saved_probeinfo[BLOGIC_MAX_ADAPTERS];
1073                                         int mmcount = blogic_probeinfo_count - fpcount;
1074
1075                                         memcpy(saved_probeinfo,
1076                                                 blogic_probeinfo_list,
1077                                                 blogic_probeinfo_count * sizeof(struct blogic_probeinfo));
1078                                         memcpy(&blogic_probeinfo_list[0],
1079                                                 &saved_probeinfo[fpcount],
1080                                                 mmcount * sizeof(struct blogic_probeinfo));
1081                                         memcpy(&blogic_probeinfo_list[mmcount],
1082                                                 &saved_probeinfo[0],
1083                                                 fpcount * sizeof(struct blogic_probeinfo));
1084                                 }
1085                         }
1086                 }
1087         } else {
1088                 blogic_init_probeinfo_isa(adapter);
1089         }
1090 }
1091
1092
1093 #else
1094 #define blogic_init_probeinfo_list(adapter) \
1095                 blogic_init_probeinfo_isa(adapter)
1096 #endif                          /* CONFIG_PCI */
1097
1098
1099 /*
1100   blogic_failure prints a standardized error message, and then returns false.
1101 */
1102
1103 static bool blogic_failure(struct blogic_adapter *adapter, char *msg)
1104 {
1105         blogic_announce_drvr(adapter);
1106         if (adapter->adapter_bus_type == BLOGIC_PCI_BUS) {
1107                 blogic_err("While configuring BusLogic PCI Host Adapter at\n",
1108                                 adapter);
1109                 blogic_err("Bus %d Device %d I/O Address 0x%X PCI Address 0x%X:\n", adapter, adapter->bus, adapter->dev, adapter->io_addr, adapter->pci_addr);
1110         } else
1111                 blogic_err("While configuring BusLogic Host Adapter at " "I/O Address 0x%X:\n", adapter, adapter->io_addr);
1112         blogic_err("%s FAILED - DETACHING\n", adapter, msg);
1113         if (blogic_cmd_failure_reason != NULL)
1114                 blogic_err("ADDITIONAL FAILURE INFO - %s\n", adapter,
1115                                 blogic_cmd_failure_reason);
1116         return false;
1117 }
1118
1119
1120 /*
1121   blogic_probe probes for a BusLogic Host Adapter.
1122 */
1123
1124 static bool __init blogic_probe(struct blogic_adapter *adapter)
1125 {
1126         union blogic_stat_reg statusreg;
1127         union blogic_int_reg intreg;
1128         union blogic_geo_reg georeg;
1129         /*
1130            FlashPoint Host Adapters are Probed by the FlashPoint SCCB Manager.
1131          */
1132         if (blogic_flashpoint_type(adapter)) {
1133                 struct fpoint_info *fpinfo = &adapter->fpinfo;
1134                 fpinfo->base_addr = (u32) adapter->io_addr;
1135                 fpinfo->irq_ch = adapter->irq_ch;
1136                 fpinfo->present = false;
1137                 if (!(FlashPoint_ProbeHostAdapter(fpinfo) == 0 &&
1138                                         fpinfo->present)) {
1139                         blogic_err("BusLogic: FlashPoint Host Adapter detected at " "PCI Bus %d Device %d\n", adapter, adapter->bus, adapter->dev);
1140                         blogic_err("BusLogic: I/O Address 0x%X PCI Address 0x%X, " "but FlashPoint\n", adapter, adapter->io_addr, adapter->pci_addr);
1141                         blogic_err("BusLogic: Probe Function failed to validate it.\n", adapter);
1142                         return false;
1143                 }
1144                 if (blogic_global_options.trace_probe)
1145                         blogic_notice("BusLogic_Probe(0x%X): FlashPoint Found\n", adapter, adapter->io_addr);
1146                 /*
1147                    Indicate the Host Adapter Probe completed successfully.
1148                  */
1149                 return true;
1150         }
1151         /*
1152            Read the Status, Interrupt, and Geometry Registers to test if there are I/O
1153            ports that respond, and to check the values to determine if they are from a
1154            BusLogic Host Adapter.  A nonexistent I/O port will return 0xFF, in which
1155            case there is definitely no BusLogic Host Adapter at this base I/O Address.
1156            The test here is a subset of that used by the BusLogic Host Adapter BIOS.
1157          */
1158         statusreg.all = blogic_rdstatus(adapter);
1159         intreg.all = blogic_rdint(adapter);
1160         georeg.all = blogic_rdgeom(adapter);
1161         if (blogic_global_options.trace_probe)
1162                 blogic_notice("BusLogic_Probe(0x%X): Status 0x%02X, Interrupt 0x%02X, " "Geometry 0x%02X\n", adapter, adapter->io_addr, statusreg.all, intreg.all, georeg.all);
1163         if (statusreg.all == 0 || statusreg.sr.diag_active ||
1164                         statusreg.sr.cmd_param_busy || statusreg.sr.rsvd ||
1165                         statusreg.sr.cmd_invalid || intreg.ir.rsvd != 0)
1166                 return false;
1167         /*
1168            Check the undocumented Geometry Register to test if there is
1169            an I/O port that responded.  Adaptec Host Adapters do not
1170            implement the Geometry Register, so this test helps serve to
1171            avoid incorrectly recognizing an Adaptec 1542A or 1542B as a
1172            BusLogic.  Unfortunately, the Adaptec 1542C series does respond
1173            to the Geometry Register I/O port, but it will be rejected
1174            later when the Inquire Extended Setup Information command is
1175            issued in blogic_checkadapter.  The AMI FastDisk Host Adapter
1176            is a BusLogic clone that implements the same interface as
1177            earlier BusLogic Host Adapters, including the undocumented
1178            commands, and is therefore supported by this driver. However,
1179            the AMI FastDisk always returns 0x00 upon reading the Geometry
1180            Register, so the extended translation option should always be
1181            left disabled on the AMI FastDisk.
1182          */
1183         if (georeg.all == 0xFF)
1184                 return false;
1185         /*
1186            Indicate the Host Adapter Probe completed successfully.
1187          */
1188         return true;
1189 }
1190
1191
1192 /*
1193   blogic_hwreset issues a Hardware Reset to the Host Adapter
1194   and waits for Host Adapter Diagnostics to complete.  If hard_reset is true, a
1195   Hard Reset is performed which also initiates a SCSI Bus Reset.  Otherwise, a
1196   Soft Reset is performed which only resets the Host Adapter without forcing a
1197   SCSI Bus Reset.
1198 */
1199
1200 static bool blogic_hwreset(struct blogic_adapter *adapter, bool hard_reset)
1201 {
1202         union blogic_stat_reg statusreg;
1203         int timeout;
1204         /*
1205            FlashPoint Host Adapters are Hard Reset by the FlashPoint
1206            SCCB Manager.
1207          */
1208         if (blogic_flashpoint_type(adapter)) {
1209                 struct fpoint_info *fpinfo = &adapter->fpinfo;
1210                 fpinfo->softreset = !hard_reset;
1211                 fpinfo->report_underrun = true;
1212                 adapter->cardhandle =
1213                         FlashPoint_HardwareResetHostAdapter(fpinfo);
1214                 if (adapter->cardhandle == (void *)FPOINT_BADCARD_HANDLE)
1215                         return false;
1216                 /*
1217                    Indicate the Host Adapter Hard Reset completed successfully.
1218                  */
1219                 return true;
1220         }
1221         /*
1222            Issue a Hard Reset or Soft Reset Command to the Host Adapter.
1223            The Host Adapter should respond by setting Diagnostic Active in
1224            the Status Register.
1225          */
1226         if (hard_reset)
1227                 blogic_hardreset(adapter);
1228         else
1229                 blogic_softreset(adapter);
1230         /*
1231            Wait until Diagnostic Active is set in the Status Register.
1232          */
1233         timeout = 5 * 10000;
1234         while (--timeout >= 0) {
1235                 statusreg.all = blogic_rdstatus(adapter);
1236                 if (statusreg.sr.diag_active)
1237                         break;
1238                 udelay(100);
1239         }
1240         if (blogic_global_options.trace_hw_reset)
1241                 blogic_notice("BusLogic_HardwareReset(0x%X): Diagnostic Active, " "Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all);
1242         if (timeout < 0)
1243                 return false;
1244         /*
1245            Wait 100 microseconds to allow completion of any initial diagnostic
1246            activity which might leave the contents of the Status Register
1247            unpredictable.
1248          */
1249         udelay(100);
1250         /*
1251            Wait until Diagnostic Active is reset in the Status Register.
1252          */
1253         timeout = 10 * 10000;
1254         while (--timeout >= 0) {
1255                 statusreg.all = blogic_rdstatus(adapter);
1256                 if (!statusreg.sr.diag_active)
1257                         break;
1258                 udelay(100);
1259         }
1260         if (blogic_global_options.trace_hw_reset)
1261                 blogic_notice("BusLogic_HardwareReset(0x%X): Diagnostic Completed, " "Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all);
1262         if (timeout < 0)
1263                 return false;
1264         /*
1265            Wait until at least one of the Diagnostic Failure, Host Adapter
1266            Ready, or Data In Register Ready bits is set in the Status Register.
1267          */
1268         timeout = 10000;
1269         while (--timeout >= 0) {
1270                 statusreg.all = blogic_rdstatus(adapter);
1271                 if (statusreg.sr.diag_failed || statusreg.sr.adapter_ready ||
1272                                 statusreg.sr.datain_ready)
1273                         break;
1274                 udelay(100);
1275         }
1276         if (blogic_global_options.trace_hw_reset)
1277                 blogic_notice("BusLogic_HardwareReset(0x%X): Host Adapter Ready, " "Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all);
1278         if (timeout < 0)
1279                 return false;
1280         /*
1281            If Diagnostic Failure is set or Host Adapter Ready is reset,
1282            then an error occurred during the Host Adapter diagnostics.
1283            If Data In Register Ready is set, then there is an Error Code
1284            available.
1285          */
1286         if (statusreg.sr.diag_failed || !statusreg.sr.adapter_ready) {
1287                 blogic_cmd_failure_reason = NULL;
1288                 blogic_failure(adapter, "HARD RESET DIAGNOSTICS");
1289                 blogic_err("HOST ADAPTER STATUS REGISTER = %02X\n", adapter,
1290                                 statusreg.all);
1291                 if (statusreg.sr.datain_ready)
1292                         blogic_err("HOST ADAPTER ERROR CODE = %d\n", adapter,
1293                                         blogic_rddatain(adapter));
1294                 return false;
1295         }
1296         /*
1297            Indicate the Host Adapter Hard Reset completed successfully.
1298          */
1299         return true;
1300 }
1301
1302
1303 /*
1304   blogic_checkadapter checks to be sure this really is a BusLogic
1305   Host Adapter.
1306 */
1307
1308 static bool __init blogic_checkadapter(struct blogic_adapter *adapter)
1309 {
1310         struct blogic_ext_setup ext_setupinfo;
1311         unsigned char req_replylen;
1312         bool result = true;
1313         /*
1314            FlashPoint Host Adapters do not require this protection.
1315          */
1316         if (blogic_flashpoint_type(adapter))
1317                 return true;
1318         /*
1319            Issue the Inquire Extended Setup Information command. Only genuine
1320            BusLogic Host Adapters and true clones support this command.
1321            Adaptec 1542C series Host Adapters that respond to the Geometry
1322            Register I/O port will fail this command.
1323          */
1324         req_replylen = sizeof(ext_setupinfo);
1325         if (blogic_cmd(adapter, BLOGIC_INQ_EXTSETUP, &req_replylen,
1326                                 sizeof(req_replylen), &ext_setupinfo,
1327                                 sizeof(ext_setupinfo)) != sizeof(ext_setupinfo))
1328                 result = false;
1329         /*
1330            Provide tracing information if requested and return.
1331          */
1332         if (blogic_global_options.trace_probe)
1333                 blogic_notice("BusLogic_Check(0x%X): MultiMaster %s\n", adapter,
1334                                 adapter->io_addr,
1335                                 (result ? "Found" : "Not Found"));
1336         return result;
1337 }
1338
1339
1340 /*
1341   blogic_rdconfig reads the Configuration Information
1342   from Host Adapter and initializes the Host Adapter structure.
1343 */
1344
1345 static bool __init blogic_rdconfig(struct blogic_adapter *adapter)
1346 {
1347         struct blogic_board_id id;
1348         struct blogic_config config;
1349         struct blogic_setup_info setupinfo;
1350         struct blogic_ext_setup ext_setupinfo;
1351         unsigned char model[5];
1352         unsigned char fw_ver_digit3;
1353         unsigned char fw_ver_letter;
1354         struct blogic_adapter_info adapter_info;
1355         struct blogic_fetch_localram fetch_localram;
1356         struct blogic_autoscsi autoscsi;
1357         union blogic_geo_reg georeg;
1358         unsigned char req_replylen;
1359         unsigned char *tgt, ch;
1360         int tgt_id, i;
1361         /*
1362            Configuration Information for FlashPoint Host Adapters is
1363            provided in the fpoint_info structure by the FlashPoint
1364            SCCB Manager's Probe Function. Initialize fields in the
1365            Host Adapter structure from the fpoint_info structure.
1366          */
1367         if (blogic_flashpoint_type(adapter)) {
1368                 struct fpoint_info *fpinfo = &adapter->fpinfo;
1369                 tgt = adapter->model;
1370                 *tgt++ = 'B';
1371                 *tgt++ = 'T';
1372                 *tgt++ = '-';
1373                 for (i = 0; i < sizeof(fpinfo->model); i++)
1374                         *tgt++ = fpinfo->model[i];
1375                 *tgt++ = '\0';
1376                 strcpy(adapter->fw_ver, FLASHPOINT_FW_VER);
1377                 adapter->scsi_id = fpinfo->scsi_id;
1378                 adapter->ext_trans_enable = fpinfo->ext_trans_enable;
1379                 adapter->parity = fpinfo->parity;
1380                 adapter->reset_enabled = !fpinfo->softreset;
1381                 adapter->level_int = true;
1382                 adapter->wide = fpinfo->wide;
1383                 adapter->differential = false;
1384                 adapter->scam = true;
1385                 adapter->ultra = true;
1386                 adapter->ext_lun = true;
1387                 adapter->terminfo_valid = true;
1388                 adapter->low_term = fpinfo->low_term;
1389                 adapter->high_term = fpinfo->high_term;
1390                 adapter->scam_enabled = fpinfo->scam_enabled;
1391                 adapter->scam_lev2 = fpinfo->scam_lev2;
1392                 adapter->drvr_sglimit = BLOGIC_SG_LIMIT;
1393                 adapter->maxdev = (adapter->wide ? 16 : 8);
1394                 adapter->maxlun = 32;
1395                 adapter->initccbs = 4 * BLOGIC_CCB_GRP_ALLOCSIZE;
1396                 adapter->inc_ccbs = BLOGIC_CCB_GRP_ALLOCSIZE;
1397                 adapter->drvr_qdepth = 255;
1398                 adapter->adapter_qdepth = adapter->drvr_qdepth;
1399                 adapter->sync_ok = fpinfo->sync_ok;
1400                 adapter->fast_ok = fpinfo->fast_ok;
1401                 adapter->ultra_ok = fpinfo->ultra_ok;
1402                 adapter->wide_ok = fpinfo->wide_ok;
1403                 adapter->discon_ok = fpinfo->discon_ok;
1404                 adapter->tagq_ok = 0xFFFF;
1405                 goto common;
1406         }
1407         /*
1408            Issue the Inquire Board ID command.
1409          */
1410         if (blogic_cmd(adapter, BLOGIC_GET_BOARD_ID, NULL, 0, &id,
1411                                 sizeof(id)) != sizeof(id))
1412                 return blogic_failure(adapter, "INQUIRE BOARD ID");
1413         /*
1414            Issue the Inquire Configuration command.
1415          */
1416         if (blogic_cmd(adapter, BLOGIC_INQ_CONFIG, NULL, 0, &config,
1417                                 sizeof(config))
1418             != sizeof(config))
1419                 return blogic_failure(adapter, "INQUIRE CONFIGURATION");
1420         /*
1421            Issue the Inquire Setup Information command.
1422          */
1423         req_replylen = sizeof(setupinfo);
1424         if (blogic_cmd(adapter, BLOGIC_INQ_SETUPINFO, &req_replylen,
1425                                 sizeof(req_replylen), &setupinfo,
1426                                 sizeof(setupinfo)) != sizeof(setupinfo))
1427                 return blogic_failure(adapter, "INQUIRE SETUP INFORMATION");
1428         /*
1429            Issue the Inquire Extended Setup Information command.
1430          */
1431         req_replylen = sizeof(ext_setupinfo);
1432         if (blogic_cmd(adapter, BLOGIC_INQ_EXTSETUP, &req_replylen,
1433                                 sizeof(req_replylen), &ext_setupinfo,
1434                                 sizeof(ext_setupinfo)) != sizeof(ext_setupinfo))
1435                 return blogic_failure(adapter,
1436                                         "INQUIRE EXTENDED SETUP INFORMATION");
1437         /*
1438            Issue the Inquire Firmware Version 3rd Digit command.
1439          */
1440         fw_ver_digit3 = '\0';
1441         if (id.fw_ver_digit1 > '0')
1442                 if (blogic_cmd(adapter, BLOGIC_INQ_FWVER_D3, NULL, 0,
1443                                 &fw_ver_digit3,
1444                                 sizeof(fw_ver_digit3)) != sizeof(fw_ver_digit3))
1445                         return blogic_failure(adapter,
1446                                                 "INQUIRE FIRMWARE 3RD DIGIT");
1447         /*
1448            Issue the Inquire Host Adapter Model Number command.
1449          */
1450         if (ext_setupinfo.bus_type == 'A' && id.fw_ver_digit1 == '2')
1451                 /* BusLogic BT-542B ISA 2.xx */
1452                 strcpy(model, "542B");
1453         else if (ext_setupinfo.bus_type == 'E' && id.fw_ver_digit1 == '2' &&
1454                         (id.fw_ver_digit2 <= '1' || (id.fw_ver_digit2 == '2' &&
1455                                                      fw_ver_digit3 == '0')))
1456                 /* BusLogic BT-742A EISA 2.1x or 2.20 */
1457                 strcpy(model, "742A");
1458         else if (ext_setupinfo.bus_type == 'E' && id.fw_ver_digit1 == '0')
1459                 /* AMI FastDisk EISA Series 441 0.x */
1460                 strcpy(model, "747A");
1461         else {
1462                 req_replylen = sizeof(model);
1463                 if (blogic_cmd(adapter, BLOGIC_INQ_MODELNO, &req_replylen,
1464                                         sizeof(req_replylen), &model,
1465                                         sizeof(model)) != sizeof(model))
1466                         return blogic_failure(adapter,
1467                                         "INQUIRE HOST ADAPTER MODEL NUMBER");
1468         }
1469         /*
1470            BusLogic MultiMaster Host Adapters can be identified by their
1471            model number and the major version number of their firmware
1472            as follows:
1473
1474            5.xx       BusLogic "W" Series Host Adapters:
1475            BT-948/958/958D
1476            4.xx       BusLogic "C" Series Host Adapters:
1477            BT-946C/956C/956CD/747C/757C/757CD/445C/545C/540CF
1478            3.xx       BusLogic "S" Series Host Adapters:
1479            BT-747S/747D/757S/757D/445S/545S/542D
1480            BT-542B/742A (revision H)
1481            2.xx       BusLogic "A" Series Host Adapters:
1482            BT-542B/742A (revision G and below)
1483            0.xx       AMI FastDisk VLB/EISA BusLogic Clone Host Adapter
1484          */
1485         /*
1486            Save the Model Name and Host Adapter Name in the Host Adapter
1487            structure.
1488          */
1489         tgt = adapter->model;
1490         *tgt++ = 'B';
1491         *tgt++ = 'T';
1492         *tgt++ = '-';
1493         for (i = 0; i < sizeof(model); i++) {
1494                 ch = model[i];
1495                 if (ch == ' ' || ch == '\0')
1496                         break;
1497                 *tgt++ = ch;
1498         }
1499         *tgt++ = '\0';
1500         /*
1501            Save the Firmware Version in the Host Adapter structure.
1502          */
1503         tgt = adapter->fw_ver;
1504         *tgt++ = id.fw_ver_digit1;
1505         *tgt++ = '.';
1506         *tgt++ = id.fw_ver_digit2;
1507         if (fw_ver_digit3 != ' ' && fw_ver_digit3 != '\0')
1508                 *tgt++ = fw_ver_digit3;
1509         *tgt = '\0';
1510         /*
1511            Issue the Inquire Firmware Version Letter command.
1512          */
1513         if (strcmp(adapter->fw_ver, "3.3") >= 0) {
1514                 if (blogic_cmd(adapter, BLOGIC_INQ_FWVER_LETTER, NULL, 0,
1515                                 &fw_ver_letter,
1516                                 sizeof(fw_ver_letter)) != sizeof(fw_ver_letter))
1517                         return blogic_failure(adapter,
1518                                         "INQUIRE FIRMWARE VERSION LETTER");
1519                 if (fw_ver_letter != ' ' && fw_ver_letter != '\0')
1520                         *tgt++ = fw_ver_letter;
1521                 *tgt = '\0';
1522         }
1523         /*
1524            Save the Host Adapter SCSI ID in the Host Adapter structure.
1525          */
1526         adapter->scsi_id = config.id;
1527         /*
1528            Determine the Bus Type and save it in the Host Adapter structure,
1529            determine and save the IRQ Channel if necessary, and determine
1530            and save the DMA Channel for ISA Host Adapters.
1531          */
1532         adapter->adapter_bus_type =
1533                         blogic_adater_bus_types[adapter->model[3] - '4'];
1534         if (adapter->irq_ch == 0) {
1535                 if (config.irq_ch9)
1536                         adapter->irq_ch = 9;
1537                 else if (config.irq_ch10)
1538                         adapter->irq_ch = 10;
1539                 else if (config.irq_ch11)
1540                         adapter->irq_ch = 11;
1541                 else if (config.irq_ch12)
1542                         adapter->irq_ch = 12;
1543                 else if (config.irq_ch14)
1544                         adapter->irq_ch = 14;
1545                 else if (config.irq_ch15)
1546                         adapter->irq_ch = 15;
1547         }
1548         if (adapter->adapter_bus_type == BLOGIC_ISA_BUS) {
1549                 if (config.dma_ch5)
1550                         adapter->dma_ch = 5;
1551                 else if (config.dma_ch6)
1552                         adapter->dma_ch = 6;
1553                 else if (config.dma_ch7)
1554                         adapter->dma_ch = 7;
1555         }
1556         /*
1557            Determine whether Extended Translation is enabled and save it in
1558            the Host Adapter structure.
1559          */
1560         georeg.all = blogic_rdgeom(adapter);
1561         adapter->ext_trans_enable = georeg.gr.ext_trans_enable;
1562         /*
1563            Save the Scatter Gather Limits, Level Sensitive Interrupt flag, Wide
1564            SCSI flag, Differential SCSI flag, SCAM Supported flag, and
1565            Ultra SCSI flag in the Host Adapter structure.
1566          */
1567         adapter->adapter_sglimit = ext_setupinfo.sg_limit;
1568         adapter->drvr_sglimit = adapter->adapter_sglimit;
1569         if (adapter->adapter_sglimit > BLOGIC_SG_LIMIT)
1570                 adapter->drvr_sglimit = BLOGIC_SG_LIMIT;
1571         if (ext_setupinfo.misc.level_int)
1572                 adapter->level_int = true;
1573         adapter->wide = ext_setupinfo.wide;
1574         adapter->differential = ext_setupinfo.differential;
1575         adapter->scam = ext_setupinfo.scam;
1576         adapter->ultra = ext_setupinfo.ultra;
1577         /*
1578            Determine whether Extended LUN Format CCBs are supported and save the
1579            information in the Host Adapter structure.
1580          */
1581         if (adapter->fw_ver[0] == '5' || (adapter->fw_ver[0] == '4' &&
1582                                 adapter->wide))
1583                 adapter->ext_lun = true;
1584         /*
1585            Issue the Inquire PCI Host Adapter Information command to read the
1586            Termination Information from "W" series MultiMaster Host Adapters.
1587          */
1588         if (adapter->fw_ver[0] == '5') {
1589                 if (blogic_cmd(adapter, BLOGIC_INQ_PCI_INFO, NULL, 0,
1590                                 &adapter_info,
1591                                 sizeof(adapter_info)) != sizeof(adapter_info))
1592                         return blogic_failure(adapter,
1593                                         "INQUIRE PCI HOST ADAPTER INFORMATION");
1594                 /*
1595                    Save the Termination Information in the Host Adapter
1596                    structure.
1597                  */
1598                 if (adapter_info.genericinfo_valid) {
1599                         adapter->terminfo_valid = true;
1600                         adapter->low_term = adapter_info.low_term;
1601                         adapter->high_term = adapter_info.high_term;
1602                 }
1603         }
1604         /*
1605            Issue the Fetch Host Adapter Local RAM command to read the
1606            AutoSCSI data from "W" and "C" series MultiMaster Host Adapters.
1607          */
1608         if (adapter->fw_ver[0] >= '4') {
1609                 fetch_localram.offset = BLOGIC_AUTOSCSI_BASE;
1610                 fetch_localram.count = sizeof(autoscsi);
1611                 if (blogic_cmd(adapter, BLOGIC_FETCH_LOCALRAM, &fetch_localram,
1612                                         sizeof(fetch_localram), &autoscsi,
1613                                         sizeof(autoscsi)) != sizeof(autoscsi))
1614                         return blogic_failure(adapter,
1615                                                 "FETCH HOST ADAPTER LOCAL RAM");
1616                 /*
1617                    Save the Parity Checking Enabled, Bus Reset Enabled,
1618                    and Termination Information in the Host Adapter structure.
1619                  */
1620                 adapter->parity = autoscsi.parity;
1621                 adapter->reset_enabled = autoscsi.reset_enabled;
1622                 if (adapter->fw_ver[0] == '4') {
1623                         adapter->terminfo_valid = true;
1624                         adapter->low_term = autoscsi.low_term;
1625                         adapter->high_term = autoscsi.high_term;
1626                 }
1627                 /*
1628                    Save the Wide Permitted, Fast Permitted, Synchronous
1629                    Permitted, Disconnect Permitted, Ultra Permitted, and
1630                    SCAM Information in the Host Adapter structure.
1631                  */
1632                 adapter->wide_ok = autoscsi.wide_ok;
1633                 adapter->fast_ok = autoscsi.fast_ok;
1634                 adapter->sync_ok = autoscsi.sync_ok;
1635                 adapter->discon_ok = autoscsi.discon_ok;
1636                 if (adapter->ultra)
1637                         adapter->ultra_ok = autoscsi.ultra_ok;
1638                 if (adapter->scam) {
1639                         adapter->scam_enabled = autoscsi.scam_enabled;
1640                         adapter->scam_lev2 = autoscsi.scam_lev2;
1641                 }
1642         }
1643         /*
1644            Initialize fields in the Host Adapter structure for "S" and "A"
1645            series MultiMaster Host Adapters.
1646          */
1647         if (adapter->fw_ver[0] < '4') {
1648                 if (setupinfo.sync) {
1649                         adapter->sync_ok = 0xFF;
1650                         if (adapter->adapter_bus_type == BLOGIC_EISA_BUS) {
1651                                 if (ext_setupinfo.misc.fast_on_eisa)
1652                                         adapter->fast_ok = 0xFF;
1653                                 if (strcmp(adapter->model, "BT-757") == 0)
1654                                         adapter->wide_ok = 0xFF;
1655                         }
1656                 }
1657                 adapter->discon_ok = 0xFF;
1658                 adapter->parity = setupinfo.parity;
1659                 adapter->reset_enabled = true;
1660         }
1661         /*
1662            Determine the maximum number of Target IDs and Logical Units
1663            supported by this driver for Wide and Narrow Host Adapters.
1664          */
1665         adapter->maxdev = (adapter->wide ? 16 : 8);
1666         adapter->maxlun = (adapter->ext_lun ? 32 : 8);
1667         /*
1668            Select appropriate values for the Mailbox Count, Driver Queue Depth,
1669            Initial CCBs, and Incremental CCBs variables based on whether
1670            or not Strict Round Robin Mode is supported.  If Strict Round
1671            Robin Mode is supported, then there is no performance degradation
1672            in using the maximum possible number of Outgoing and Incoming
1673            Mailboxes and allowing the Tagged and Untagged Queue Depths to
1674            determine the actual utilization.  If Strict Round Robin Mode is
1675            not supported, then the Host Adapter must scan all the Outgoing
1676            Mailboxes whenever an Outgoing Mailbox entry is made, which can
1677            cause a substantial performance penalty.  The host adapters
1678            actually have room to store the following number of CCBs
1679            internally; that is, they can internally queue and manage this
1680            many active commands on the SCSI bus simultaneously.  Performance
1681            measurements demonstrate that the Driver Queue Depth should be
1682            set to the Mailbox Count, rather than the Host Adapter Queue
1683            Depth (internal CCB capacity), as it is more efficient to have the
1684            queued commands waiting in Outgoing Mailboxes if necessary than
1685            to block the process in the higher levels of the SCSI Subsystem.
1686
1687            192          BT-948/958/958D
1688            100          BT-946C/956C/956CD/747C/757C/757CD/445C
1689            50   BT-545C/540CF
1690            30   BT-747S/747D/757S/757D/445S/545S/542D/542B/742A
1691          */
1692         if (adapter->fw_ver[0] == '5')
1693                 adapter->adapter_qdepth = 192;
1694         else if (adapter->fw_ver[0] == '4')
1695                 adapter->adapter_qdepth = (adapter->adapter_bus_type !=
1696                                                 BLOGIC_ISA_BUS ? 100 : 50);
1697         else
1698                 adapter->adapter_qdepth = 30;
1699         if (strcmp(adapter->fw_ver, "3.31") >= 0) {
1700                 adapter->strict_rr = true;
1701                 adapter->mbox_count = BLOGIC_MAX_MAILBOX;
1702         } else {
1703                 adapter->strict_rr = false;
1704                 adapter->mbox_count = 32;
1705         }
1706         adapter->drvr_qdepth = adapter->mbox_count;
1707         adapter->initccbs = 4 * BLOGIC_CCB_GRP_ALLOCSIZE;
1708         adapter->inc_ccbs = BLOGIC_CCB_GRP_ALLOCSIZE;
1709         /*
1710            Tagged Queuing support is available and operates properly on
1711            all "W" series MultiMaster Host Adapters, on "C" series
1712            MultiMaster Host Adapters with firmware version 4.22 and above,
1713            and on "S" series MultiMaster Host Adapters with firmware version
1714            3.35 and above.
1715          */
1716         adapter->tagq_ok = 0;
1717         switch (adapter->fw_ver[0]) {
1718         case '5':
1719                 adapter->tagq_ok = 0xFFFF;
1720                 break;
1721         case '4':
1722                 if (strcmp(adapter->fw_ver, "4.22") >= 0)
1723                         adapter->tagq_ok = 0xFFFF;
1724                 break;
1725         case '3':
1726                 if (strcmp(adapter->fw_ver, "3.35") >= 0)
1727                         adapter->tagq_ok = 0xFFFF;
1728                 break;
1729         }
1730         /*
1731            Determine the Host Adapter BIOS Address if the BIOS is enabled and
1732            save it in the Host Adapter structure.  The BIOS is disabled if the
1733            bios_addr is 0.
1734          */
1735         adapter->bios_addr = ext_setupinfo.bios_addr << 12;
1736         /*
1737            ISA Host Adapters require Bounce Buffers if there is more than
1738            16MB memory.
1739          */
1740         if (adapter->adapter_bus_type == BLOGIC_ISA_BUS &&
1741                         (void *) high_memory > (void *) MAX_DMA_ADDRESS)
1742                 adapter->need_bouncebuf = true;
1743         /*
1744            BusLogic BT-445S Host Adapters prior to board revision E have a
1745            hardware bug whereby when the BIOS is enabled, transfers to/from
1746            the same address range the BIOS occupies modulo 16MB are handled
1747            incorrectly.  Only properly functioning BT-445S Host Adapters
1748            have firmware version 3.37, so require that ISA Bounce Buffers
1749            be used for the buggy BT-445S models if there is more than 16MB
1750            memory.
1751          */
1752         if (adapter->bios_addr > 0 && strcmp(adapter->model, "BT-445S") == 0 &&
1753                         strcmp(adapter->fw_ver, "3.37") < 0 &&
1754                         (void *) high_memory > (void *) MAX_DMA_ADDRESS)
1755                 adapter->need_bouncebuf = true;
1756         /*
1757            Initialize parameters common to MultiMaster and FlashPoint
1758            Host Adapters.
1759          */
1760 common:
1761         /*
1762            Initialize the Host Adapter Full Model Name from the Model Name.
1763          */
1764         strcpy(adapter->full_model, "BusLogic ");
1765         strcat(adapter->full_model, adapter->model);
1766         /*
1767            Select an appropriate value for the Tagged Queue Depth either from a
1768            BusLogic Driver Options specification, or based on whether this Host
1769            Adapter requires that ISA Bounce Buffers be used.  The Tagged Queue
1770            Depth is left at 0 for automatic determination in
1771            BusLogic_SelectQueueDepths. Initialize the Untagged Queue Depth.
1772          */
1773         for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++) {
1774                 unsigned char qdepth = 0;
1775                 if (adapter->drvr_opts != NULL &&
1776                                 adapter->drvr_opts->qdepth[tgt_id] > 0)
1777                         qdepth = adapter->drvr_opts->qdepth[tgt_id];
1778                 else if (adapter->need_bouncebuf)
1779                         qdepth = BLOGIC_TAG_DEPTH_BB;
1780                 adapter->qdepth[tgt_id] = qdepth;
1781         }
1782         if (adapter->need_bouncebuf)
1783                 adapter->untag_qdepth = BLOGIC_UNTAG_DEPTH_BB;
1784         else
1785                 adapter->untag_qdepth = BLOGIC_UNTAG_DEPTH;
1786         if (adapter->drvr_opts != NULL)
1787                 adapter->common_qdepth = adapter->drvr_opts->common_qdepth;
1788         if (adapter->common_qdepth > 0 &&
1789                         adapter->common_qdepth < adapter->untag_qdepth)
1790                 adapter->untag_qdepth = adapter->common_qdepth;
1791         /*
1792            Tagged Queuing is only allowed if Disconnect/Reconnect is permitted.
1793            Therefore, mask the Tagged Queuing Permitted Default bits with the
1794            Disconnect/Reconnect Permitted bits.
1795          */
1796         adapter->tagq_ok &= adapter->discon_ok;
1797         /*
1798            Combine the default Tagged Queuing Permitted bits with any
1799            BusLogic Driver Options Tagged Queuing specification.
1800          */
1801         if (adapter->drvr_opts != NULL)
1802                 adapter->tagq_ok = (adapter->drvr_opts->tagq_ok &
1803                                 adapter->drvr_opts->tagq_ok_mask) |
1804                         (adapter->tagq_ok & ~adapter->drvr_opts->tagq_ok_mask);
1805
1806         /*
1807            Select an appropriate value for Bus Settle Time either from a
1808            BusLogic Driver Options specification, or from
1809            BLOGIC_BUS_SETTLE_TIME.
1810          */
1811         if (adapter->drvr_opts != NULL &&
1812                         adapter->drvr_opts->bus_settle_time > 0)
1813                 adapter->bus_settle_time = adapter->drvr_opts->bus_settle_time;
1814         else
1815                 adapter->bus_settle_time = BLOGIC_BUS_SETTLE_TIME;
1816         /*
1817            Indicate reading the Host Adapter Configuration completed
1818            successfully.
1819          */
1820         return true;
1821 }
1822
1823
1824 /*
1825   blogic_reportconfig reports the configuration of Host Adapter.
1826 */
1827
1828 static bool __init blogic_reportconfig(struct blogic_adapter *adapter)
1829 {
1830         unsigned short alltgt_mask = (1 << adapter->maxdev) - 1;
1831         unsigned short sync_ok, fast_ok;
1832         unsigned short ultra_ok, wide_ok;
1833         unsigned short discon_ok, tagq_ok;
1834         bool common_syncneg, common_tagq_depth;
1835         char syncstr[BLOGIC_MAXDEV + 1];
1836         char widestr[BLOGIC_MAXDEV + 1];
1837         char discon_str[BLOGIC_MAXDEV + 1];
1838         char tagq_str[BLOGIC_MAXDEV + 1];
1839         char *syncmsg = syncstr;
1840         char *widemsg = widestr;
1841         char *discon_msg = discon_str;
1842         char *tagq_msg = tagq_str;
1843         int tgt_id;
1844
1845         blogic_info("Configuring BusLogic Model %s %s%s%s%s SCSI Host Adapter\n", adapter, adapter->model, blogic_adapter_busnames[adapter->adapter_bus_type], (adapter->wide ? " Wide" : ""), (adapter->differential ? " Differential" : ""), (adapter->ultra ? " Ultra" : ""));
1846         blogic_info("  Firmware Version: %s, I/O Address: 0x%X, " "IRQ Channel: %d/%s\n", adapter, adapter->fw_ver, adapter->io_addr, adapter->irq_ch, (adapter->level_int ? "Level" : "Edge"));
1847         if (adapter->adapter_bus_type != BLOGIC_PCI_BUS) {
1848                 blogic_info("  DMA Channel: ", adapter);
1849                 if (adapter->dma_ch > 0)
1850                         blogic_info("%d, ", adapter, adapter->dma_ch);
1851                 else
1852                         blogic_info("None, ", adapter);
1853                 if (adapter->bios_addr > 0)
1854                         blogic_info("BIOS Address: 0x%X, ", adapter,
1855                                         adapter->bios_addr);
1856                 else
1857                         blogic_info("BIOS Address: None, ", adapter);
1858         } else {
1859                 blogic_info("  PCI Bus: %d, Device: %d, Address: ", adapter,
1860                                 adapter->bus, adapter->dev);
1861                 if (adapter->pci_addr > 0)
1862                         blogic_info("0x%X, ", adapter, adapter->pci_addr);
1863                 else
1864                         blogic_info("Unassigned, ", adapter);
1865         }
1866         blogic_info("Host Adapter SCSI ID: %d\n", adapter, adapter->scsi_id);
1867         blogic_info("  Parity Checking: %s, Extended Translation: %s\n",
1868                         adapter, (adapter->parity ? "Enabled" : "Disabled"),
1869                         (adapter->ext_trans_enable ? "Enabled" : "Disabled"));
1870         alltgt_mask &= ~(1 << adapter->scsi_id);
1871         sync_ok = adapter->sync_ok & alltgt_mask;
1872         fast_ok = adapter->fast_ok & alltgt_mask;
1873         ultra_ok = adapter->ultra_ok & alltgt_mask;
1874         if ((blogic_multimaster_type(adapter) &&
1875                         (adapter->fw_ver[0] >= '4' ||
1876                          adapter->adapter_bus_type == BLOGIC_EISA_BUS)) ||
1877                         blogic_flashpoint_type(adapter)) {
1878                 common_syncneg = false;
1879                 if (sync_ok == 0) {
1880                         syncmsg = "Disabled";
1881                         common_syncneg = true;
1882                 } else if (sync_ok == alltgt_mask) {
1883                         if (fast_ok == 0) {
1884                                 syncmsg = "Slow";
1885                                 common_syncneg = true;
1886                         } else if (fast_ok == alltgt_mask) {
1887                                 if (ultra_ok == 0) {
1888                                         syncmsg = "Fast";
1889                                         common_syncneg = true;
1890                                 } else if (ultra_ok == alltgt_mask) {
1891                                         syncmsg = "Ultra";
1892                                         common_syncneg = true;
1893                                 }
1894                         }
1895                 }
1896                 if (!common_syncneg) {
1897                         for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
1898                                 syncstr[tgt_id] = ((!(sync_ok & (1 << tgt_id))) ? 'N' : (!(fast_ok & (1 << tgt_id)) ? 'S' : (!(ultra_ok & (1 << tgt_id)) ? 'F' : 'U')));
1899                         syncstr[adapter->scsi_id] = '#';
1900                         syncstr[adapter->maxdev] = '\0';
1901                 }
1902         } else
1903                 syncmsg = (sync_ok == 0 ? "Disabled" : "Enabled");
1904         wide_ok = adapter->wide_ok & alltgt_mask;
1905         if (wide_ok == 0)
1906                 widemsg = "Disabled";
1907         else if (wide_ok == alltgt_mask)
1908                 widemsg = "Enabled";
1909         else {
1910                 for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
1911                         widestr[tgt_id] = ((wide_ok & (1 << tgt_id)) ? 'Y' : 'N');
1912                 widestr[adapter->scsi_id] = '#';
1913                 widestr[adapter->maxdev] = '\0';
1914         }
1915         discon_ok = adapter->discon_ok & alltgt_mask;
1916         if (discon_ok == 0)
1917                 discon_msg = "Disabled";
1918         else if (discon_ok == alltgt_mask)
1919                 discon_msg = "Enabled";
1920         else {
1921                 for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
1922                         discon_str[tgt_id] = ((discon_ok & (1 << tgt_id)) ? 'Y' : 'N');
1923                 discon_str[adapter->scsi_id] = '#';
1924                 discon_str[adapter->maxdev] = '\0';
1925         }
1926         tagq_ok = adapter->tagq_ok & alltgt_mask;
1927         if (tagq_ok == 0)
1928                 tagq_msg = "Disabled";
1929         else if (tagq_ok == alltgt_mask)
1930                 tagq_msg = "Enabled";
1931         else {
1932                 for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
1933                         tagq_str[tgt_id] = ((tagq_ok & (1 << tgt_id)) ? 'Y' : 'N');
1934                 tagq_str[adapter->scsi_id] = '#';
1935                 tagq_str[adapter->maxdev] = '\0';
1936         }
1937         blogic_info("  Synchronous Negotiation: %s, Wide Negotiation: %s\n",
1938                         adapter, syncmsg, widemsg);
1939         blogic_info("  Disconnect/Reconnect: %s, Tagged Queuing: %s\n", adapter,
1940                         discon_msg, tagq_msg);
1941         if (blogic_multimaster_type(adapter)) {
1942                 blogic_info("  Scatter/Gather Limit: %d of %d segments, " "Mailboxes: %d\n", adapter, adapter->drvr_sglimit, adapter->adapter_sglimit, adapter->mbox_count);
1943                 blogic_info("  Driver Queue Depth: %d, " "Host Adapter Queue Depth: %d\n", adapter, adapter->drvr_qdepth, adapter->adapter_qdepth);
1944         } else
1945                 blogic_info("  Driver Queue Depth: %d, " "Scatter/Gather Limit: %d segments\n", adapter, adapter->drvr_qdepth, adapter->drvr_sglimit);
1946         blogic_info("  Tagged Queue Depth: ", adapter);
1947         common_tagq_depth = true;
1948         for (tgt_id = 1; tgt_id < adapter->maxdev; tgt_id++)
1949                 if (adapter->qdepth[tgt_id] != adapter->qdepth[0]) {
1950                         common_tagq_depth = false;
1951                         break;
1952                 }
1953         if (common_tagq_depth) {
1954                 if (adapter->qdepth[0] > 0)
1955                         blogic_info("%d", adapter, adapter->qdepth[0]);
1956                 else
1957                         blogic_info("Automatic", adapter);
1958         } else
1959                 blogic_info("Individual", adapter);
1960         blogic_info(", Untagged Queue Depth: %d\n", adapter,
1961                         adapter->untag_qdepth);
1962         if (adapter->terminfo_valid) {
1963                 if (adapter->wide)
1964                         blogic_info("  SCSI Bus Termination: %s", adapter,
1965                                 (adapter->low_term ? (adapter->high_term ? "Both Enabled" : "Low Enabled") : (adapter->high_term ? "High Enabled" : "Both Disabled")));
1966                 else
1967                         blogic_info("  SCSI Bus Termination: %s", adapter,
1968                                 (adapter->low_term ? "Enabled" : "Disabled"));
1969                 if (adapter->scam)
1970                         blogic_info(", SCAM: %s", adapter,
1971                                 (adapter->scam_enabled ? (adapter->scam_lev2 ? "Enabled, Level 2" : "Enabled, Level 1") : "Disabled"));
1972                 blogic_info("\n", adapter);
1973         }
1974         /*
1975            Indicate reporting the Host Adapter configuration completed
1976            successfully.
1977          */
1978         return true;
1979 }
1980
1981
1982 /*
1983   blogic_getres acquires the system resources necessary to use
1984   Host Adapter.
1985 */
1986
1987 static bool __init blogic_getres(struct blogic_adapter *adapter)
1988 {
1989         if (adapter->irq_ch == 0) {
1990                 blogic_err("NO LEGAL INTERRUPT CHANNEL ASSIGNED - DETACHING\n",
1991                                 adapter);
1992                 return false;
1993         }
1994         /*
1995            Acquire shared access to the IRQ Channel.
1996          */
1997         if (request_irq(adapter->irq_ch, blogic_inthandler, IRQF_SHARED,
1998                                 adapter->full_model, adapter) < 0) {
1999                 blogic_err("UNABLE TO ACQUIRE IRQ CHANNEL %d - DETACHING\n",
2000                                 adapter, adapter->irq_ch);
2001                 return false;
2002         }
2003         adapter->irq_acquired = true;
2004         /*
2005            Acquire exclusive access to the DMA Channel.
2006          */
2007         if (adapter->dma_ch > 0) {
2008                 if (request_dma(adapter->dma_ch, adapter->full_model) < 0) {
2009                         blogic_err("UNABLE TO ACQUIRE DMA CHANNEL %d - DETACHING\n", adapter, adapter->dma_ch);
2010                         return false;
2011                 }
2012                 set_dma_mode(adapter->dma_ch, DMA_MODE_CASCADE);
2013                 enable_dma(adapter->dma_ch);
2014                 adapter->dma_chan_acquired = true;
2015         }
2016         /*
2017            Indicate the System Resource Acquisition completed successfully,
2018          */
2019         return true;
2020 }
2021
2022
2023 /*
2024   blogic_relres releases any system resources previously acquired
2025   by blogic_getres.
2026 */
2027
2028 static void blogic_relres(struct blogic_adapter *adapter)
2029 {
2030         /*
2031            Release shared access to the IRQ Channel.
2032          */
2033         if (adapter->irq_acquired)
2034                 free_irq(adapter->irq_ch, adapter);
2035         /*
2036            Release exclusive access to the DMA Channel.
2037          */
2038         if (adapter->dma_chan_acquired)
2039                 free_dma(adapter->dma_ch);
2040         /*
2041            Release any allocated memory structs not released elsewhere
2042          */
2043         if (adapter->mbox_space)
2044                 dma_free_coherent(&adapter->pci_device->dev, adapter->mbox_sz,
2045                         adapter->mbox_space, adapter->mbox_space_handle);
2046         pci_dev_put(adapter->pci_device);
2047         adapter->mbox_space = NULL;
2048         adapter->mbox_space_handle = 0;
2049         adapter->mbox_sz = 0;
2050 }
2051
2052
2053 /*
2054   blogic_initadapter initializes Host Adapter.  This is the only
2055   function called during SCSI Host Adapter detection which modifies the state
2056   of the Host Adapter from its initial power on or hard reset state.
2057 */
2058
2059 static bool blogic_initadapter(struct blogic_adapter *adapter)
2060 {
2061         struct blogic_extmbox_req extmbox_req;
2062         enum blogic_rr_req rr_req;
2063         enum blogic_setccb_fmt setccb_fmt;
2064         int tgt_id;
2065
2066         /*
2067            Initialize the pointers to the first and last CCBs that are
2068            queued for completion processing.
2069          */
2070         adapter->firstccb = NULL;
2071         adapter->lastccb = NULL;
2072
2073         /*
2074            Initialize the Bus Device Reset Pending CCB, Tagged Queuing Active,
2075            Command Successful Flag, Active Commands, and Commands Since Reset
2076            for each Target Device.
2077          */
2078         for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) {
2079                 adapter->bdr_pend[tgt_id] = NULL;
2080                 adapter->tgt_flags[tgt_id].tagq_active = false;
2081                 adapter->tgt_flags[tgt_id].cmd_good = false;
2082                 adapter->active_cmds[tgt_id] = 0;
2083                 adapter->cmds_since_rst[tgt_id] = 0;
2084         }
2085
2086         /*
2087            FlashPoint Host Adapters do not use Outgoing and Incoming Mailboxes.
2088          */
2089         if (blogic_flashpoint_type(adapter))
2090                 goto done;
2091
2092         /*
2093            Initialize the Outgoing and Incoming Mailbox pointers.
2094          */
2095         adapter->mbox_sz = adapter->mbox_count * (sizeof(struct blogic_outbox) + sizeof(struct blogic_inbox));
2096         adapter->mbox_space = dma_alloc_coherent(&adapter->pci_device->dev,
2097                                 adapter->mbox_sz, &adapter->mbox_space_handle,
2098                                 GFP_KERNEL);
2099         if (adapter->mbox_space == NULL)
2100                 return blogic_failure(adapter, "MAILBOX ALLOCATION");
2101         adapter->first_outbox = (struct blogic_outbox *) adapter->mbox_space;
2102         adapter->last_outbox = adapter->first_outbox + adapter->mbox_count - 1;
2103         adapter->next_outbox = adapter->first_outbox;
2104         adapter->first_inbox = (struct blogic_inbox *) (adapter->last_outbox + 1);
2105         adapter->last_inbox = adapter->first_inbox + adapter->mbox_count - 1;
2106         adapter->next_inbox = adapter->first_inbox;
2107
2108         /*
2109            Initialize the Outgoing and Incoming Mailbox structures.
2110          */
2111         memset(adapter->first_outbox, 0,
2112                         adapter->mbox_count * sizeof(struct blogic_outbox));
2113         memset(adapter->first_inbox, 0,
2114                         adapter->mbox_count * sizeof(struct blogic_inbox));
2115
2116         /*
2117            Initialize the Host Adapter's Pointer to the Outgoing/Incoming
2118            Mailboxes.
2119          */
2120         extmbox_req.mbox_count = adapter->mbox_count;
2121         extmbox_req.base_mbox_addr = (u32) adapter->mbox_space_handle;
2122         if (blogic_cmd(adapter, BLOGIC_INIT_EXT_MBOX, &extmbox_req,
2123                                 sizeof(extmbox_req), NULL, 0) < 0)
2124                 return blogic_failure(adapter, "MAILBOX INITIALIZATION");
2125         /*
2126            Enable Strict Round Robin Mode if supported by the Host Adapter. In
2127            Strict Round Robin Mode, the Host Adapter only looks at the next
2128            Outgoing Mailbox for each new command, rather than scanning
2129            through all the Outgoing Mailboxes to find any that have new
2130            commands in them.  Strict Round Robin Mode is significantly more
2131            efficient.
2132          */
2133         if (adapter->strict_rr) {
2134                 rr_req = BLOGIC_STRICT_RR_MODE;
2135                 if (blogic_cmd(adapter, BLOGIC_STRICT_RR, &rr_req,
2136                                         sizeof(rr_req), NULL, 0) < 0)
2137                         return blogic_failure(adapter,
2138                                         "ENABLE STRICT ROUND ROBIN MODE");
2139         }
2140
2141         /*
2142            For Host Adapters that support Extended LUN Format CCBs, issue the
2143            Set CCB Format command to allow 32 Logical Units per Target Device.
2144          */
2145         if (adapter->ext_lun) {
2146                 setccb_fmt = BLOGIC_EXT_LUN_CCB;
2147                 if (blogic_cmd(adapter, BLOGIC_SETCCB_FMT, &setccb_fmt,
2148                                         sizeof(setccb_fmt), NULL, 0) < 0)
2149                         return blogic_failure(adapter, "SET CCB FORMAT");
2150         }
2151
2152         /*
2153            Announce Successful Initialization.
2154          */
2155 done:
2156         if (!adapter->adapter_initd) {
2157                 blogic_info("*** %s Initialized Successfully ***\n", adapter,
2158                                 adapter->full_model);
2159                 blogic_info("\n", adapter);
2160         } else
2161                 blogic_warn("*** %s Initialized Successfully ***\n", adapter,
2162                                 adapter->full_model);
2163         adapter->adapter_initd = true;
2164
2165         /*
2166            Indicate the Host Adapter Initialization completed successfully.
2167          */
2168         return true;
2169 }
2170
2171
2172 /*
2173   blogic_inquiry inquires about the Target Devices accessible
2174   through Host Adapter.
2175 */
2176
2177 static bool __init blogic_inquiry(struct blogic_adapter *adapter)
2178 {
2179         u16 installed_devs;
2180         u8 installed_devs0to7[8];
2181         struct blogic_setup_info setupinfo;
2182         u8 sync_period[BLOGIC_MAXDEV];
2183         unsigned char req_replylen;
2184         int tgt_id;
2185
2186         /*
2187            Wait a few seconds between the Host Adapter Hard Reset which
2188            initiates a SCSI Bus Reset and issuing any SCSI Commands. Some
2189            SCSI devices get confused if they receive SCSI Commands too soon
2190            after a SCSI Bus Reset.
2191          */
2192         blogic_delay(adapter->bus_settle_time);
2193         /*
2194            FlashPoint Host Adapters do not provide for Target Device Inquiry.
2195          */
2196         if (blogic_flashpoint_type(adapter))
2197                 return true;
2198         /*
2199            Inhibit the Target Device Inquiry if requested.
2200          */
2201         if (adapter->drvr_opts != NULL && adapter->drvr_opts->stop_tgt_inquiry)
2202                 return true;
2203         /*
2204            Issue the Inquire Target Devices command for host adapters with
2205            firmware version 4.25 or later, or the Inquire Installed Devices
2206            ID 0 to 7 command for older host adapters.  This is necessary to
2207            force Synchronous Transfer Negotiation so that the Inquire Setup
2208            Information and Inquire Synchronous Period commands will return
2209            valid data.  The Inquire Target Devices command is preferable to
2210            Inquire Installed Devices ID 0 to 7 since it only probes Logical
2211            Unit 0 of each Target Device.
2212          */
2213         if (strcmp(adapter->fw_ver, "4.25") >= 0) {
2214
2215                 /*
2216                    Issue a Inquire Target Devices command. Inquire Target
2217                    Devices only tests Logical Unit 0 of each Target Device
2218                    unlike the Inquire Installed Devices commands which test
2219                    Logical Units 0 - 7.  Two bytes are returned, where byte
2220                    0 bit 0 set indicates that Target Device 0 exists, and so on.
2221                  */
2222
2223                 if (blogic_cmd(adapter, BLOGIC_INQ_DEV, NULL, 0,
2224                                         &installed_devs, sizeof(installed_devs))
2225                     != sizeof(installed_devs))
2226                         return blogic_failure(adapter, "INQUIRE TARGET DEVICES");
2227                 for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
2228                         adapter->tgt_flags[tgt_id].tgt_exists =
2229                                 (installed_devs & (1 << tgt_id) ? true : false);
2230         } else {
2231
2232                 /*
2233                    Issue an Inquire Installed Devices command. For each
2234                    Target Device, a byte is returned where bit 0 set
2235                    indicates that Logical Unit 0 * exists, bit 1 set
2236                    indicates that Logical Unit 1 exists, and so on.
2237                  */
2238
2239                 if (blogic_cmd(adapter, BLOGIC_INQ_DEV0TO7, NULL, 0,
2240                                 &installed_devs0to7, sizeof(installed_devs0to7))
2241                     != sizeof(installed_devs0to7))
2242                         return blogic_failure(adapter,
2243                                         "INQUIRE INSTALLED DEVICES ID 0 TO 7");
2244                 for (tgt_id = 0; tgt_id < 8; tgt_id++)
2245                         adapter->tgt_flags[tgt_id].tgt_exists =
2246                                 (installed_devs0to7[tgt_id] != 0 ? true : false);
2247         }
2248         /*
2249            Issue the Inquire Setup Information command.
2250          */
2251         req_replylen = sizeof(setupinfo);
2252         if (blogic_cmd(adapter, BLOGIC_INQ_SETUPINFO, &req_replylen,
2253                         sizeof(req_replylen), &setupinfo, sizeof(setupinfo))
2254             != sizeof(setupinfo))
2255                 return blogic_failure(adapter, "INQUIRE SETUP INFORMATION");
2256         for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
2257                 adapter->sync_offset[tgt_id] = (tgt_id < 8 ? setupinfo.sync0to7[tgt_id].offset : setupinfo.sync8to15[tgt_id - 8].offset);
2258         if (strcmp(adapter->fw_ver, "5.06L") >= 0)
2259                 for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
2260                         adapter->tgt_flags[tgt_id].wide_active = (tgt_id < 8 ? (setupinfo.wide_tx_active0to7 & (1 << tgt_id) ? true : false) : (setupinfo.wide_tx_active8to15 & (1 << (tgt_id - 8)) ? true : false));
2261         /*
2262            Issue the Inquire Synchronous Period command.
2263          */
2264         if (adapter->fw_ver[0] >= '3') {
2265
2266                 /* Issue a Inquire Synchronous Period command. For each
2267                    Target Device, a byte is returned which represents the
2268                    Synchronous Transfer Period in units of 10 nanoseconds.
2269                  */
2270
2271                 req_replylen = sizeof(sync_period);
2272                 if (blogic_cmd(adapter, BLOGIC_INQ_SYNC_PERIOD, &req_replylen,
2273                                 sizeof(req_replylen), &sync_period,
2274                                 sizeof(sync_period)) != sizeof(sync_period))
2275                         return blogic_failure(adapter,
2276                                         "INQUIRE SYNCHRONOUS PERIOD");
2277                 for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
2278                         adapter->sync_period[tgt_id] = sync_period[tgt_id];
2279         } else
2280                 for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
2281                         if (setupinfo.sync0to7[tgt_id].offset > 0)
2282                                 adapter->sync_period[tgt_id] = 20 + 5 * setupinfo.sync0to7[tgt_id].tx_period;
2283         /*
2284            Indicate the Target Device Inquiry completed successfully.
2285          */
2286         return true;
2287 }
2288
2289 /*
2290   blogic_inithoststruct initializes the fields in the SCSI Host
2291   structure.  The base, io_port, n_io_ports, irq, and dma_channel fields in the
2292   SCSI Host structure are intentionally left uninitialized, as this driver
2293   handles acquisition and release of these resources explicitly, as well as
2294   ensuring exclusive access to the Host Adapter hardware and data structures
2295   through explicit acquisition and release of the Host Adapter's Lock.
2296 */
2297
2298 static void __init blogic_inithoststruct(struct blogic_adapter *adapter,
2299                 struct Scsi_Host *host)
2300 {
2301         host->max_id = adapter->maxdev;
2302         host->max_lun = adapter->maxlun;
2303         host->max_channel = 0;
2304         host->unique_id = adapter->io_addr;
2305         host->this_id = adapter->scsi_id;
2306         host->can_queue = adapter->drvr_qdepth;
2307         host->sg_tablesize = adapter->drvr_sglimit;
2308         host->unchecked_isa_dma = adapter->need_bouncebuf;
2309         host->cmd_per_lun = adapter->untag_qdepth;
2310 }
2311
2312 /*
2313   blogic_slaveconfig will actually set the queue depth on individual
2314   scsi devices as they are permanently added to the device chain.  We
2315   shamelessly rip off the SelectQueueDepths code to make this work mostly
2316   like it used to.  Since we don't get called once at the end of the scan
2317   but instead get called for each device, we have to do things a bit
2318   differently.
2319 */
2320 static int blogic_slaveconfig(struct scsi_device *dev)
2321 {
2322         struct blogic_adapter *adapter =
2323                 (struct blogic_adapter *) dev->host->hostdata;
2324         int tgt_id = dev->id;
2325         int qdepth = adapter->qdepth[tgt_id];
2326
2327         if (adapter->tgt_flags[tgt_id].tagq_ok &&
2328                         (adapter->tagq_ok & (1 << tgt_id))) {
2329                 if (qdepth == 0)
2330                         qdepth = BLOGIC_MAX_AUTO_TAG_DEPTH;
2331                 adapter->qdepth[tgt_id] = qdepth;
2332                 scsi_change_queue_depth(dev, qdepth);
2333         } else {
2334                 adapter->tagq_ok &= ~(1 << tgt_id);
2335                 qdepth = adapter->untag_qdepth;
2336                 adapter->qdepth[tgt_id] = qdepth;
2337                 scsi_change_queue_depth(dev, qdepth);
2338         }
2339         qdepth = 0;
2340         for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
2341                 if (adapter->tgt_flags[tgt_id].tgt_exists)
2342                         qdepth += adapter->qdepth[tgt_id];
2343         if (qdepth > adapter->alloc_ccbs)
2344                 blogic_create_addlccbs(adapter, qdepth - adapter->alloc_ccbs,
2345                                 false);
2346         return 0;
2347 }
2348
2349 /*
2350   blogic_init probes for BusLogic Host Adapters at the standard
2351   I/O Addresses where they may be located, initializing, registering, and
2352   reporting the configuration of each BusLogic Host Adapter it finds.  It
2353   returns the number of BusLogic Host Adapters successfully initialized and
2354   registered.
2355 */
2356
2357 static int __init blogic_init(void)
2358 {
2359         int adapter_count = 0, drvr_optindex = 0, probeindex;
2360         struct blogic_adapter *adapter;
2361         int ret = 0;
2362
2363 #ifdef MODULE
2364         if (BusLogic)
2365                 blogic_setup(BusLogic);
2366 #endif
2367
2368         if (blogic_probe_options.noprobe)
2369                 return -ENODEV;
2370         blogic_probeinfo_list =
2371             kcalloc(BLOGIC_MAX_ADAPTERS, sizeof(struct blogic_probeinfo),
2372                             GFP_KERNEL);
2373         if (blogic_probeinfo_list == NULL) {
2374                 blogic_err("BusLogic: Unable to allocate Probe Info List\n",
2375                                 NULL);
2376                 return -ENOMEM;
2377         }
2378
2379         adapter = kzalloc(sizeof(struct blogic_adapter), GFP_KERNEL);
2380         if (adapter == NULL) {
2381                 kfree(blogic_probeinfo_list);
2382                 blogic_err("BusLogic: Unable to allocate Prototype Host Adapter\n", NULL);
2383                 return -ENOMEM;
2384         }
2385
2386 #ifdef MODULE
2387         if (BusLogic != NULL)
2388                 blogic_setup(BusLogic);
2389 #endif
2390         blogic_init_probeinfo_list(adapter);
2391         for (probeindex = 0; probeindex < blogic_probeinfo_count; probeindex++) {
2392                 struct blogic_probeinfo *probeinfo =
2393                         &blogic_probeinfo_list[probeindex];
2394                 struct blogic_adapter *myadapter = adapter;
2395                 struct Scsi_Host *host;
2396
2397                 if (probeinfo->io_addr == 0)
2398                         continue;
2399                 memset(myadapter, 0, sizeof(struct blogic_adapter));
2400                 myadapter->adapter_type = probeinfo->adapter_type;
2401                 myadapter->adapter_bus_type = probeinfo->adapter_bus_type;
2402                 myadapter->io_addr = probeinfo->io_addr;
2403                 myadapter->pci_addr = probeinfo->pci_addr;
2404                 myadapter->bus = probeinfo->bus;
2405                 myadapter->dev = probeinfo->dev;
2406                 myadapter->pci_device = probeinfo->pci_device;
2407                 myadapter->irq_ch = probeinfo->irq_ch;
2408                 myadapter->addr_count =
2409                         blogic_adapter_addr_count[myadapter->adapter_type];
2410
2411                 /*
2412                    Make sure region is free prior to probing.
2413                  */
2414                 if (!request_region(myadapter->io_addr, myadapter->addr_count,
2415                                         "BusLogic"))
2416                         continue;
2417                 /*
2418                    Probe the Host Adapter. If unsuccessful, abort further
2419                    initialization.
2420                  */
2421                 if (!blogic_probe(myadapter)) {
2422                         release_region(myadapter->io_addr,
2423                                         myadapter->addr_count);
2424                         continue;
2425                 }
2426                 /*
2427                    Hard Reset the Host Adapter.  If unsuccessful, abort further
2428                    initialization.
2429                  */
2430                 if (!blogic_hwreset(myadapter, true)) {
2431                         release_region(myadapter->io_addr,
2432                                         myadapter->addr_count);
2433                         continue;
2434                 }
2435                 /*
2436                    Check the Host Adapter.  If unsuccessful, abort further
2437                    initialization.
2438                  */
2439                 if (!blogic_checkadapter(myadapter)) {
2440                         release_region(myadapter->io_addr,
2441                                         myadapter->addr_count);
2442                         continue;
2443                 }
2444                 /*
2445                    Initialize the Driver Options field if provided.
2446                  */
2447                 if (drvr_optindex < blogic_drvr_options_count)
2448                         myadapter->drvr_opts =
2449                                 &blogic_drvr_options[drvr_optindex++];
2450                 /*
2451                    Announce the Driver Version and Date, Author's Name,
2452                    Copyright Notice, and Electronic Mail Address.
2453                  */
2454                 blogic_announce_drvr(myadapter);
2455                 /*
2456                    Register the SCSI Host structure.
2457                  */
2458
2459                 host = scsi_host_alloc(&blogic_template,
2460                                 sizeof(struct blogic_adapter));
2461                 if (host == NULL) {
2462                         release_region(myadapter->io_addr,
2463                                         myadapter->addr_count);
2464                         continue;
2465                 }
2466                 myadapter = (struct blogic_adapter *) host->hostdata;
2467                 memcpy(myadapter, adapter, sizeof(struct blogic_adapter));
2468                 myadapter->scsi_host = host;
2469                 myadapter->host_no = host->host_no;
2470                 /*
2471                    Add Host Adapter to the end of the list of registered
2472                    BusLogic Host Adapters.
2473                  */
2474                 list_add_tail(&myadapter->host_list, &blogic_host_list);
2475
2476                 /*
2477                    Read the Host Adapter Configuration, Configure the Host
2478                    Adapter, Acquire the System Resources necessary to use
2479                    the Host Adapter, then Create the Initial CCBs, Initialize
2480                    the Host Adapter, and finally perform Target Device
2481                    Inquiry. From this point onward, any failure will be
2482                    assumed to be due to a problem with the Host Adapter,
2483                    rather than due to having mistakenly identified this port
2484                    as belonging to a BusLogic Host Adapter. The I/O Address
2485                    range will not be released, thereby preventing it from
2486                    being incorrectly identified as any other type of Host
2487                    Adapter.
2488                  */
2489                 if (blogic_rdconfig(myadapter) &&
2490                     blogic_reportconfig(myadapter) &&
2491                     blogic_getres(myadapter) &&
2492                     blogic_create_initccbs(myadapter) &&
2493                     blogic_initadapter(myadapter) &&
2494                     blogic_inquiry(myadapter)) {
2495                         /*
2496                            Initialization has been completed successfully.
2497                            Release and re-register usage of the I/O Address
2498                            range so that the Model Name of the Host Adapter
2499                            will appear, and initialize the SCSI Host structure.
2500                          */
2501                         release_region(myadapter->io_addr,
2502                                        myadapter->addr_count);
2503                         if (!request_region(myadapter->io_addr,
2504                                             myadapter->addr_count,
2505                                             myadapter->full_model)) {
2506                                 printk(KERN_WARNING
2507                                         "BusLogic: Release and re-register of "
2508                                         "port 0x%04lx failed \n",
2509                                         (unsigned long)myadapter->io_addr);
2510                                 blogic_destroy_ccbs(myadapter);
2511                                 blogic_relres(myadapter);
2512                                 list_del(&myadapter->host_list);
2513                                 scsi_host_put(host);
2514                                 ret = -ENOMEM;
2515                         } else {
2516                                 blogic_inithoststruct(myadapter,
2517                                                                  host);
2518                                 if (scsi_add_host(host, myadapter->pci_device
2519                                                 ? &myadapter->pci_device->dev
2520                                                   : NULL)) {
2521                                         printk(KERN_WARNING
2522                                                "BusLogic: scsi_add_host()"
2523                                                "failed!\n");
2524                                         blogic_destroy_ccbs(myadapter);
2525                                         blogic_relres(myadapter);
2526                                         list_del(&myadapter->host_list);
2527                                         scsi_host_put(host);
2528                                         ret = -ENODEV;
2529                                 } else {
2530                                         scsi_scan_host(host);
2531                                         adapter_count++;
2532                                 }
2533                         }
2534                 } else {
2535                         /*
2536                            An error occurred during Host Adapter Configuration
2537                            Querying, Host Adapter Configuration, Resource
2538                            Acquisition, CCB Creation, Host Adapter
2539                            Initialization, or Target Device Inquiry, so
2540                            remove Host Adapter from the list of registered
2541                            BusLogic Host Adapters, destroy the CCBs, Release
2542                            the System Resources, and Unregister the SCSI
2543                            Host.
2544                          */
2545                         blogic_destroy_ccbs(myadapter);
2546                         blogic_relres(myadapter);
2547                         list_del(&myadapter->host_list);
2548                         scsi_host_put(host);
2549                         ret = -ENODEV;
2550                 }
2551         }
2552         kfree(adapter);
2553         kfree(blogic_probeinfo_list);
2554         blogic_probeinfo_list = NULL;
2555         return ret;
2556 }
2557
2558
2559 /*
2560   blogic_deladapter releases all resources previously acquired to
2561   support a specific Host Adapter, including the I/O Address range, and
2562   unregisters the BusLogic Host Adapter.
2563 */
2564
2565 static int __exit blogic_deladapter(struct blogic_adapter *adapter)
2566 {
2567         struct Scsi_Host *host = adapter->scsi_host;
2568
2569         scsi_remove_host(host);
2570
2571         /*
2572            FlashPoint Host Adapters must first be released by the FlashPoint
2573            SCCB Manager.
2574          */
2575         if (blogic_flashpoint_type(adapter))
2576                 FlashPoint_ReleaseHostAdapter(adapter->cardhandle);
2577         /*
2578            Destroy the CCBs and release any system resources acquired to
2579            support Host Adapter.
2580          */
2581         blogic_destroy_ccbs(adapter);
2582         blogic_relres(adapter);
2583         /*
2584            Release usage of the I/O Address range.
2585          */
2586         release_region(adapter->io_addr, adapter->addr_count);
2587         /*
2588            Remove Host Adapter from the list of registered BusLogic
2589            Host Adapters.
2590          */
2591         list_del(&adapter->host_list);
2592
2593         scsi_host_put(host);
2594         return 0;
2595 }
2596
2597
2598 /*
2599   blogic_qcompleted_ccb queues CCB for completion processing.
2600 */
2601
2602 static void blogic_qcompleted_ccb(struct blogic_ccb *ccb)
2603 {
2604         struct blogic_adapter *adapter = ccb->adapter;
2605
2606         ccb->status = BLOGIC_CCB_COMPLETE;
2607         ccb->next = NULL;
2608         if (adapter->firstccb == NULL) {
2609                 adapter->firstccb = ccb;
2610                 adapter->lastccb = ccb;
2611         } else {
2612                 adapter->lastccb->next = ccb;
2613                 adapter->lastccb = ccb;
2614         }
2615         adapter->active_cmds[ccb->tgt_id]--;
2616 }
2617
2618
2619 /*
2620   blogic_resultcode computes a SCSI Subsystem Result Code from
2621   the Host Adapter Status and Target Device Status.
2622 */
2623
2624 static int blogic_resultcode(struct blogic_adapter *adapter,
2625                 enum blogic_adapter_status adapter_status,
2626                 enum blogic_tgt_status tgt_status)
2627 {
2628         int hoststatus;
2629
2630         switch (adapter_status) {
2631         case BLOGIC_CMD_CMPLT_NORMAL:
2632         case BLOGIC_LINK_CMD_CMPLT:
2633         case BLOGIC_LINK_CMD_CMPLT_FLAG:
2634                 hoststatus = DID_OK;
2635                 break;
2636         case BLOGIC_SELECT_TIMEOUT:
2637                 hoststatus = DID_TIME_OUT;
2638                 break;
2639         case BLOGIC_INVALID_OUTBOX_CODE:
2640         case BLOGIC_INVALID_CMD_CODE:
2641         case BLOGIC_BAD_CMD_PARAM:
2642                 blogic_warn("BusLogic Driver Protocol Error 0x%02X\n",
2643                                 adapter, adapter_status);
2644         case BLOGIC_DATA_UNDERRUN:
2645         case BLOGIC_DATA_OVERRUN:
2646         case BLOGIC_NOEXPECT_BUSFREE:
2647         case BLOGIC_LINKCCB_BADLUN:
2648         case BLOGIC_AUTOREQSENSE_FAIL:
2649         case BLOGIC_TAGQUEUE_REJECT:
2650         case BLOGIC_BAD_MSG_RCVD:
2651         case BLOGIC_HW_FAIL:
2652         case BLOGIC_BAD_RECONNECT:
2653         case BLOGIC_ABRT_QUEUE:
2654         case BLOGIC_ADAPTER_SW_ERROR:
2655         case BLOGIC_HW_TIMEOUT:
2656         case BLOGIC_PARITY_ERR:
2657                 hoststatus = DID_ERROR;
2658                 break;
2659         case BLOGIC_INVALID_BUSPHASE:
2660         case BLOGIC_NORESPONSE_TO_ATN:
2661         case BLOGIC_HW_RESET:
2662         case BLOGIC_RST_FROM_OTHERDEV:
2663         case BLOGIC_HW_BDR:
2664                 hoststatus = DID_RESET;
2665                 break;
2666         default:
2667                 blogic_warn("Unknown Host Adapter Status 0x%02X\n", adapter,
2668                                 adapter_status);
2669                 hoststatus = DID_ERROR;
2670                 break;
2671         }
2672         return (hoststatus << 16) | tgt_status;
2673 }
2674
2675
2676 /*
2677   blogic_scan_inbox scans the Incoming Mailboxes saving any
2678   Incoming Mailbox entries for completion processing.
2679 */
2680
2681 static void blogic_scan_inbox(struct blogic_adapter *adapter)
2682 {
2683         /*
2684            Scan through the Incoming Mailboxes in Strict Round Robin
2685            fashion, saving any completed CCBs for further processing. It
2686            is essential that for each CCB and SCSI Command issued, command
2687            completion processing is performed exactly once.  Therefore,
2688            only Incoming Mailboxes with completion code Command Completed
2689            Without Error, Command Completed With Error, or Command Aborted
2690            At Host Request are saved for completion processing. When an
2691            Incoming Mailbox has a completion code of Aborted Command Not
2692            Found, the CCB had already completed or been aborted before the
2693            current Abort request was processed, and so completion processing
2694            has already occurred and no further action should be taken.
2695          */
2696         struct blogic_inbox *next_inbox = adapter->next_inbox;
2697         enum blogic_cmplt_code comp_code;
2698
2699         while ((comp_code = next_inbox->comp_code) != BLOGIC_INBOX_FREE) {
2700                 /*
2701                    We are only allowed to do this because we limit our
2702                    architectures we run on to machines where bus_to_virt(
2703                    actually works.  There *needs* to be a dma_addr_to_virt()
2704                    in the new PCI DMA mapping interface to replace
2705                    bus_to_virt() or else this code is going to become very
2706                    innefficient.
2707                  */
2708                 struct blogic_ccb *ccb =
2709                         (struct blogic_ccb *) bus_to_virt(next_inbox->ccb);
2710                 if (comp_code != BLOGIC_CMD_NOTFOUND) {
2711                         if (ccb->status == BLOGIC_CCB_ACTIVE ||
2712                                         ccb->status == BLOGIC_CCB_RESET) {
2713                                 /*
2714                                    Save the Completion Code for this CCB and
2715                                    queue the CCB for completion processing.
2716                                  */
2717                                 ccb->comp_code = comp_code;
2718                                 blogic_qcompleted_ccb(ccb);
2719                         } else {
2720                                 /*
2721                                    If a CCB ever appears in an Incoming Mailbox
2722                                    and is not marked as status Active or Reset,
2723                                    then there is most likely a bug in
2724                                    the Host Adapter firmware.
2725                                  */
2726                                 blogic_warn("Illegal CCB #%ld status %d in " "Incoming Mailbox\n", adapter, ccb->serial, ccb->status);
2727                         }
2728                 }
2729                 next_inbox->comp_code = BLOGIC_INBOX_FREE;
2730                 if (++next_inbox > adapter->last_inbox)
2731                         next_inbox = adapter->first_inbox;
2732         }
2733         adapter->next_inbox = next_inbox;
2734 }
2735
2736
2737 /*
2738   blogic_process_ccbs iterates over the completed CCBs for Host
2739   Adapter setting the SCSI Command Result Codes, deallocating the CCBs, and
2740   calling the SCSI Subsystem Completion Routines.  The Host Adapter's Lock
2741   should already have been acquired by the caller.
2742 */
2743
2744 static void blogic_process_ccbs(struct blogic_adapter *adapter)
2745 {
2746         if (adapter->processing_ccbs)
2747                 return;
2748         adapter->processing_ccbs = true;
2749         while (adapter->firstccb != NULL) {
2750                 struct blogic_ccb *ccb = adapter->firstccb;
2751                 struct scsi_cmnd *command = ccb->command;
2752                 adapter->firstccb = ccb->next;
2753                 if (adapter->firstccb == NULL)
2754                         adapter->lastccb = NULL;
2755                 /*
2756                    Process the Completed CCB.
2757                  */
2758                 if (ccb->opcode == BLOGIC_BDR) {
2759                         int tgt_id = ccb->tgt_id;
2760
2761                         blogic_warn("Bus Device Reset CCB #%ld to Target " "%d Completed\n", adapter, ccb->serial, tgt_id);
2762                         blogic_inc_count(&adapter->tgt_stats[tgt_id].bdr_done);
2763                         adapter->tgt_flags[tgt_id].tagq_active = false;
2764                         adapter->cmds_since_rst[tgt_id] = 0;
2765                         adapter->last_resetdone[tgt_id] = jiffies;
2766                         /*
2767                            Place CCB back on the Host Adapter's free list.
2768                          */
2769                         blogic_dealloc_ccb(ccb, 1);
2770 #if 0                   /* this needs to be redone different for new EH */
2771                         /*
2772                            Bus Device Reset CCBs have the command field
2773                            non-NULL only when a Bus Device Reset was requested
2774                            for a command that did not have a currently active
2775                            CCB in the Host Adapter (i.e., a Synchronous Bus
2776                            Device Reset), and hence would not have its
2777                            Completion Routine called otherwise.
2778                          */
2779                         while (command != NULL) {
2780                                 struct scsi_cmnd *nxt_cmd =
2781                                         command->reset_chain;
2782                                 command->reset_chain = NULL;
2783                                 command->result = DID_RESET << 16;
2784                                 command->scsi_done(command);
2785                                 command = nxt_cmd;
2786                         }
2787 #endif
2788                         /*
2789                            Iterate over the CCBs for this Host Adapter
2790                            performing completion processing for any CCBs
2791                            marked as Reset for this Target.
2792                          */
2793                         for (ccb = adapter->all_ccbs; ccb != NULL;
2794                                         ccb = ccb->next_all)
2795                                 if (ccb->status == BLOGIC_CCB_RESET &&
2796                                                 ccb->tgt_id == tgt_id) {
2797                                         command = ccb->command;
2798                                         blogic_dealloc_ccb(ccb, 1);
2799                                         adapter->active_cmds[tgt_id]--;
2800                                         command->result = DID_RESET << 16;
2801                                         command->scsi_done(command);
2802                                 }
2803                         adapter->bdr_pend[tgt_id] = NULL;
2804                 } else {
2805                         /*
2806                            Translate the Completion Code, Host Adapter Status,
2807                            and Target Device Status into a SCSI Subsystem
2808                            Result Code.
2809                          */
2810                         switch (ccb->comp_code) {
2811                         case BLOGIC_INBOX_FREE:
2812                         case BLOGIC_CMD_NOTFOUND:
2813                         case BLOGIC_INVALID_CCB:
2814                                 blogic_warn("CCB #%ld to Target %d Impossible State\n", adapter, ccb->serial, ccb->tgt_id);
2815                                 break;
2816                         case BLOGIC_CMD_COMPLETE_GOOD:
2817                                 adapter->tgt_stats[ccb->tgt_id]
2818                                     .cmds_complete++;
2819                                 adapter->tgt_flags[ccb->tgt_id]
2820                                     .cmd_good = true;
2821                                 command->result = DID_OK << 16;
2822                                 break;
2823                         case BLOGIC_CMD_ABORT_BY_HOST:
2824                                 blogic_warn("CCB #%ld to Target %d Aborted\n",
2825                                         adapter, ccb->serial, ccb->tgt_id);
2826                                 blogic_inc_count(&adapter->tgt_stats[ccb->tgt_id].aborts_done);
2827                                 command->result = DID_ABORT << 16;
2828                                 break;
2829                         case BLOGIC_CMD_COMPLETE_ERROR:
2830                                 command->result = blogic_resultcode(adapter,
2831                                         ccb->adapter_status, ccb->tgt_status);
2832                                 if (ccb->adapter_status != BLOGIC_SELECT_TIMEOUT) {
2833                                         adapter->tgt_stats[ccb->tgt_id]
2834                                             .cmds_complete++;
2835                                         if (blogic_global_options.trace_err) {
2836                                                 int i;
2837                                                 blogic_notice("CCB #%ld Target %d: Result %X Host "
2838                                                                 "Adapter Status %02X " "Target Status %02X\n", adapter, ccb->serial, ccb->tgt_id, command->result, ccb->adapter_status, ccb->tgt_status);
2839                                                 blogic_notice("CDB   ", adapter);
2840                                                 for (i = 0; i < ccb->cdblen; i++)
2841                                                         blogic_notice(" %02X", adapter, ccb->cdb[i]);
2842                                                 blogic_notice("\n", adapter);
2843                                                 blogic_notice("Sense ", adapter);
2844                                                 for (i = 0; i < ccb->sense_datalen; i++)
2845                                                         blogic_notice(" %02X", adapter, command->sense_buffer[i]);
2846                                                 blogic_notice("\n", adapter);
2847                                         }
2848                                 }
2849                                 break;
2850                         }
2851                         /*
2852                            When an INQUIRY command completes normally, save the
2853                            CmdQue (Tagged Queuing Supported) and WBus16 (16 Bit
2854                            Wide Data Transfers Supported) bits.
2855                          */
2856                         if (ccb->cdb[0] == INQUIRY && ccb->cdb[1] == 0 &&
2857                                 ccb->adapter_status == BLOGIC_CMD_CMPLT_NORMAL) {
2858                                 struct blogic_tgt_flags *tgt_flags =
2859                                         &adapter->tgt_flags[ccb->tgt_id];
2860                                 struct scsi_inquiry *inquiry =
2861                                         (struct scsi_inquiry *) scsi_sglist(command);
2862                                 tgt_flags->tgt_exists = true;
2863                                 tgt_flags->tagq_ok = inquiry->CmdQue;
2864                                 tgt_flags->wide_ok = inquiry->WBus16;
2865                         }
2866                         /*
2867                            Place CCB back on the Host Adapter's free list.
2868                          */
2869                         blogic_dealloc_ccb(ccb, 1);
2870                         /*
2871                            Call the SCSI Command Completion Routine.
2872                          */
2873                         command->scsi_done(command);
2874                 }
2875         }
2876         adapter->processing_ccbs = false;
2877 }
2878
2879
2880 /*
2881   blogic_inthandler handles hardware interrupts from BusLogic Host
2882   Adapters.
2883 */
2884
2885 static irqreturn_t blogic_inthandler(int irq_ch, void *devid)
2886 {
2887         struct blogic_adapter *adapter = (struct blogic_adapter *) devid;
2888         unsigned long processor_flag;
2889         /*
2890            Acquire exclusive access to Host Adapter.
2891          */
2892         spin_lock_irqsave(adapter->scsi_host->host_lock, processor_flag);
2893         /*
2894            Handle Interrupts appropriately for each Host Adapter type.
2895          */
2896         if (blogic_multimaster_type(adapter)) {
2897                 union blogic_int_reg intreg;
2898                 /*
2899                    Read the Host Adapter Interrupt Register.
2900                  */
2901                 intreg.all = blogic_rdint(adapter);
2902                 if (intreg.ir.int_valid) {
2903                         /*
2904                            Acknowledge the interrupt and reset the Host Adapter
2905                            Interrupt Register.
2906                          */
2907                         blogic_intreset(adapter);
2908                         /*
2909                            Process valid External SCSI Bus Reset and Incoming
2910                            Mailbox Loaded Interrupts. Command Complete
2911                            Interrupts are noted, and Outgoing Mailbox Available
2912                            Interrupts are ignored, as they are never enabled.
2913                          */
2914                         if (intreg.ir.ext_busreset)
2915                                 adapter->adapter_extreset = true;
2916                         else if (intreg.ir.mailin_loaded)
2917                                 blogic_scan_inbox(adapter);
2918                         else if (intreg.ir.cmd_complete)
2919                                 adapter->adapter_cmd_complete = true;
2920                 }
2921         } else {
2922                 /*
2923                    Check if there is a pending interrupt for this Host Adapter.
2924                  */
2925                 if (FlashPoint_InterruptPending(adapter->cardhandle))
2926                         switch (FlashPoint_HandleInterrupt(adapter->cardhandle)) {
2927                         case FPOINT_NORMAL_INT:
2928                                 break;
2929                         case FPOINT_EXT_RESET:
2930                                 adapter->adapter_extreset = true;
2931                                 break;
2932                         case FPOINT_INTERN_ERR:
2933                                 blogic_warn("Internal FlashPoint Error detected - Resetting Host Adapter\n", adapter);
2934                                 adapter->adapter_intern_err = true;
2935                                 break;
2936                         }
2937         }
2938         /*
2939            Process any completed CCBs.
2940          */
2941         if (adapter->firstccb != NULL)
2942                 blogic_process_ccbs(adapter);
2943         /*
2944            Reset the Host Adapter if requested.
2945          */
2946         if (adapter->adapter_extreset) {
2947                 blogic_warn("Resetting %s due to External SCSI Bus Reset\n", adapter, adapter->full_model);
2948                 blogic_inc_count(&adapter->ext_resets);
2949                 blogic_resetadapter(adapter, false);
2950                 adapter->adapter_extreset = false;
2951         } else if (adapter->adapter_intern_err) {
2952                 blogic_warn("Resetting %s due to Host Adapter Internal Error\n", adapter, adapter->full_model);
2953                 blogic_inc_count(&adapter->adapter_intern_errors);
2954                 blogic_resetadapter(adapter, true);
2955                 adapter->adapter_intern_err = false;
2956         }
2957         /*
2958            Release exclusive access to Host Adapter.
2959          */
2960         spin_unlock_irqrestore(adapter->scsi_host->host_lock, processor_flag);
2961         return IRQ_HANDLED;
2962 }
2963
2964
2965 /*
2966   blogic_write_outbox places CCB and Action Code into an Outgoing
2967   Mailbox for execution by Host Adapter.  The Host Adapter's Lock should
2968   already have been acquired by the caller.
2969 */
2970
2971 static bool blogic_write_outbox(struct blogic_adapter *adapter,
2972                 enum blogic_action action, struct blogic_ccb *ccb)
2973 {
2974         struct blogic_outbox *next_outbox;
2975
2976         next_outbox = adapter->next_outbox;
2977         if (next_outbox->action == BLOGIC_OUTBOX_FREE) {
2978                 ccb->status = BLOGIC_CCB_ACTIVE;
2979                 /*
2980                    The CCB field must be written before the Action Code field
2981                    since the Host Adapter is operating asynchronously and the
2982                    locking code does not protect against simultaneous access
2983                    by the Host Adapter.
2984                  */
2985                 next_outbox->ccb = ccb->dma_handle;
2986                 next_outbox->action = action;
2987                 blogic_execmbox(adapter);
2988                 if (++next_outbox > adapter->last_outbox)
2989                         next_outbox = adapter->first_outbox;
2990                 adapter->next_outbox = next_outbox;
2991                 if (action == BLOGIC_MBOX_START) {
2992                         adapter->active_cmds[ccb->tgt_id]++;
2993                         if (ccb->opcode != BLOGIC_BDR)
2994                                 adapter->tgt_stats[ccb->tgt_id].cmds_tried++;
2995                 }
2996                 return true;
2997         }
2998         return false;
2999 }
3000
3001 /* Error Handling (EH) support */
3002
3003 static int blogic_hostreset(struct scsi_cmnd *SCpnt)
3004 {
3005         struct blogic_adapter *adapter =
3006                 (struct blogic_adapter *) SCpnt->device->host->hostdata;
3007
3008         unsigned int id = SCpnt->device->id;
3009         struct blogic_tgt_stats *stats = &adapter->tgt_stats[id];
3010         int rc;
3011
3012         spin_lock_irq(SCpnt->device->host->host_lock);
3013
3014         blogic_inc_count(&stats->adapter_reset_req);
3015
3016         rc = blogic_resetadapter(adapter, false);
3017         spin_unlock_irq(SCpnt->device->host->host_lock);
3018         return rc;
3019 }
3020
3021 /*
3022   blogic_qcmd creates a CCB for Command and places it into an
3023   Outgoing Mailbox for execution by the associated Host Adapter.
3024 */
3025
3026 static int blogic_qcmd_lck(struct scsi_cmnd *command,
3027                 void (*comp_cb) (struct scsi_cmnd *))
3028 {
3029         struct blogic_adapter *adapter =
3030                 (struct blogic_adapter *) command->device->host->hostdata;
3031         struct blogic_tgt_flags *tgt_flags =
3032                 &adapter->tgt_flags[command->device->id];
3033         struct blogic_tgt_stats *tgt_stats = adapter->tgt_stats;
3034         unsigned char *cdb = command->cmnd;
3035         int cdblen = command->cmd_len;
3036         int tgt_id = command->device->id;
3037         int lun = command->device->lun;
3038         int buflen = scsi_bufflen(command);
3039         int count;
3040         struct blogic_ccb *ccb;
3041         dma_addr_t sense_buf;
3042
3043         /*
3044            SCSI REQUEST_SENSE commands will be executed automatically by the
3045            Host Adapter for any errors, so they should not be executed
3046            explicitly unless the Sense Data is zero indicating that no error
3047            occurred.
3048          */
3049         if (cdb[0] == REQUEST_SENSE && command->sense_buffer[0] != 0) {
3050                 command->result = DID_OK << 16;
3051                 comp_cb(command);
3052                 return 0;
3053         }
3054         /*
3055            Allocate a CCB from the Host Adapter's free list. In the unlikely
3056            event that there are none available and memory allocation fails,
3057            wait 1 second and try again. If that fails, the Host Adapter is
3058            probably hung so signal an error as a Host Adapter Hard Reset
3059            should be initiated soon.
3060          */
3061         ccb = blogic_alloc_ccb(adapter);
3062         if (ccb == NULL) {
3063                 spin_unlock_irq(adapter->scsi_host->host_lock);
3064                 blogic_delay(1);
3065                 spin_lock_irq(adapter->scsi_host->host_lock);
3066                 ccb = blogic_alloc_ccb(adapter);
3067                 if (ccb == NULL) {
3068                         command->result = DID_ERROR << 16;
3069                         comp_cb(command);
3070                         return 0;
3071                 }
3072         }
3073
3074         /*
3075            Initialize the fields in the BusLogic Command Control Block (CCB).
3076          */
3077         count = scsi_dma_map(command);
3078         BUG_ON(count < 0);
3079         if (count) {
3080                 struct scatterlist *sg;
3081                 int i;
3082
3083                 ccb->opcode = BLOGIC_INITIATOR_CCB_SG;
3084                 ccb->datalen = count * sizeof(struct blogic_sg_seg);
3085                 if (blogic_multimaster_type(adapter))
3086                         ccb->data = (void *)((unsigned int) ccb->dma_handle +
3087                                         ((unsigned long) &ccb->sglist -
3088                                         (unsigned long) ccb));
3089                 else
3090                         ccb->data = ccb->sglist;
3091
3092                 scsi_for_each_sg(command, sg, count, i) {
3093                         ccb->sglist[i].segbytes = sg_dma_len(sg);
3094                         ccb->sglist[i].segdata = sg_dma_address(sg);
3095                 }
3096         } else if (!count) {
3097                 ccb->opcode = BLOGIC_INITIATOR_CCB;
3098                 ccb->datalen = buflen;
3099                 ccb->data = 0;
3100         }
3101
3102         switch (cdb[0]) {
3103         case READ_6:
3104         case READ_10:
3105                 ccb->datadir = BLOGIC_DATAIN_CHECKED;
3106                 tgt_stats[tgt_id].read_cmds++;
3107                 blogic_addcount(&tgt_stats[tgt_id].bytesread, buflen);
3108                 blogic_incszbucket(tgt_stats[tgt_id].read_sz_buckets, buflen);
3109                 break;
3110         case WRITE_6:
3111         case WRITE_10:
3112                 ccb->datadir = BLOGIC_DATAOUT_CHECKED;
3113                 tgt_stats[tgt_id].write_cmds++;
3114                 blogic_addcount(&tgt_stats[tgt_id].byteswritten, buflen);
3115                 blogic_incszbucket(tgt_stats[tgt_id].write_sz_buckets, buflen);
3116                 break;
3117         default:
3118                 ccb->datadir = BLOGIC_UNCHECKED_TX;
3119                 break;
3120         }
3121         ccb->cdblen = cdblen;
3122         ccb->adapter_status = 0;
3123         ccb->tgt_status = 0;
3124         ccb->tgt_id = tgt_id;
3125         ccb->lun = lun;
3126         ccb->tag_enable = false;
3127         ccb->legacytag_enable = false;
3128         /*
3129            BusLogic recommends that after a Reset the first couple of
3130            commands that are sent to a Target Device be sent in a non
3131            Tagged Queue fashion so that the Host Adapter and Target Device
3132            can establish Synchronous and Wide Transfer before Queue Tag
3133            messages can interfere with the Synchronous and Wide Negotiation
3134            messages.  By waiting to enable Tagged Queuing until after the
3135            first BLOGIC_MAX_TAG_DEPTH commands have been queued, it is
3136            assured that after a Reset any pending commands are requeued
3137            before Tagged Queuing is enabled and that the Tagged Queuing
3138            message will not occur while the partition table is being printed.
3139            In addition, some devices do not properly handle the transition
3140            from non-tagged to tagged commands, so it is necessary to wait
3141            until there are no pending commands for a target device
3142            before queuing tagged commands.
3143          */
3144         if (adapter->cmds_since_rst[tgt_id]++ >= BLOGIC_MAX_TAG_DEPTH &&
3145                         !tgt_flags->tagq_active &&
3146                         adapter->active_cmds[tgt_id] == 0
3147                         && tgt_flags->tagq_ok &&
3148                         (adapter->tagq_ok & (1 << tgt_id))) {
3149                 tgt_flags->tagq_active = true;
3150                 blogic_notice("Tagged Queuing now active for Target %d\n",
3151                                         adapter, tgt_id);
3152         }
3153         if (tgt_flags->tagq_active) {
3154                 enum blogic_queuetag queuetag = BLOGIC_SIMPLETAG;
3155                 /*
3156                    When using Tagged Queuing with Simple Queue Tags, it
3157                    appears that disk drive controllers do not guarantee that
3158                    a queued command will not remain in a disconnected state
3159                    indefinitely if commands that read or write nearer the
3160                    head position continue to arrive without interruption.
3161                    Therefore, for each Target Device this driver keeps track
3162                    of the last time either the queue was empty or an Ordered
3163                    Queue Tag was issued. If more than 4 seconds (one fifth
3164                    of the 20 second disk timeout) have elapsed since this
3165                    last sequence point, this command will be issued with an
3166                    Ordered Queue Tag rather than a Simple Queue Tag, which
3167                    forces the Target Device to complete all previously
3168                    queued commands before this command may be executed.
3169                  */
3170                 if (adapter->active_cmds[tgt_id] == 0)
3171                         adapter->last_seqpoint[tgt_id] = jiffies;
3172                 else if (time_after(jiffies,
3173                                 adapter->last_seqpoint[tgt_id] + 4 * HZ)) {
3174                         adapter->last_seqpoint[tgt_id] = jiffies;
3175                         queuetag = BLOGIC_ORDEREDTAG;
3176                 }
3177                 if (adapter->ext_lun) {
3178                         ccb->tag_enable = true;
3179                         ccb->queuetag = queuetag;
3180                 } else {
3181                         ccb->legacytag_enable = true;
3182                         ccb->legacy_tag = queuetag;
3183                 }
3184         }
3185         memcpy(ccb->cdb, cdb, cdblen);
3186         ccb->sense_datalen = SCSI_SENSE_BUFFERSIZE;
3187         ccb->command = command;
3188         sense_buf = dma_map_single(&adapter->pci_device->dev,
3189                                 command->sense_buffer, ccb->sense_datalen,
3190                                 DMA_FROM_DEVICE);
3191         if (dma_mapping_error(&adapter->pci_device->dev, sense_buf)) {
3192                 blogic_err("DMA mapping for sense data buffer failed\n",
3193                                 adapter);
3194                 blogic_dealloc_ccb(ccb, 0);
3195                 return SCSI_MLQUEUE_HOST_BUSY;
3196         }
3197         ccb->sensedata = sense_buf;
3198         command->scsi_done = comp_cb;
3199         if (blogic_multimaster_type(adapter)) {
3200                 /*
3201                    Place the CCB in an Outgoing Mailbox. The higher levels
3202                    of the SCSI Subsystem should not attempt to queue more
3203                    commands than can be placed in Outgoing Mailboxes, so
3204                    there should always be one free.  In the unlikely event
3205                    that there are none available, wait 1 second and try
3206                    again. If that fails, the Host Adapter is probably hung
3207                    so signal an error as a Host Adapter Hard Reset should
3208                    be initiated soon.
3209                  */
3210                 if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START, ccb)) {
3211                         spin_unlock_irq(adapter->scsi_host->host_lock);
3212                         blogic_warn("Unable to write Outgoing Mailbox - " "Pausing for 1 second\n", adapter);
3213                         blogic_delay(1);
3214                         spin_lock_irq(adapter->scsi_host->host_lock);
3215                         if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START,
3216                                                 ccb)) {
3217                                 blogic_warn("Still unable to write Outgoing Mailbox - " "Host Adapter Dead?\n", adapter);
3218                                 blogic_dealloc_ccb(ccb, 1);
3219                                 command->result = DID_ERROR << 16;
3220                                 command->scsi_done(command);
3221                         }
3222                 }
3223         } else {
3224                 /*
3225                    Call the FlashPoint SCCB Manager to start execution of
3226                    the CCB.
3227                  */
3228                 ccb->status = BLOGIC_CCB_ACTIVE;
3229                 adapter->active_cmds[tgt_id]++;
3230                 tgt_stats[tgt_id].cmds_tried++;
3231                 FlashPoint_StartCCB(adapter->cardhandle, ccb);
3232                 /*
3233                    The Command may have already completed and
3234                    blogic_qcompleted_ccb been called, or it may still be
3235                    pending.
3236                  */
3237                 if (ccb->status == BLOGIC_CCB_COMPLETE)
3238                         blogic_process_ccbs(adapter);
3239         }
3240         return 0;
3241 }
3242
3243 static DEF_SCSI_QCMD(blogic_qcmd)
3244
3245 #if 0
3246 /*
3247   blogic_abort aborts Command if possible.
3248 */
3249
3250 static int blogic_abort(struct scsi_cmnd *command)
3251 {
3252         struct blogic_adapter *adapter =
3253                 (struct blogic_adapter *) command->device->host->hostdata;
3254
3255         int tgt_id = command->device->id;
3256         struct blogic_ccb *ccb;
3257         blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_request);
3258
3259         /*
3260            Attempt to find an Active CCB for this Command. If no Active
3261            CCB for this Command is found, then no Abort is necessary.
3262          */
3263         for (ccb = adapter->all_ccbs; ccb != NULL; ccb = ccb->next_all)
3264                 if (ccb->command == command)
3265                         break;
3266         if (ccb == NULL) {
3267                 blogic_warn("Unable to Abort Command to Target %d - No CCB Found\n", adapter, tgt_id);
3268                 return SUCCESS;
3269         } else if (ccb->status == BLOGIC_CCB_COMPLETE) {
3270                 blogic_warn("Unable to Abort Command to Target %d - CCB Completed\n", adapter, tgt_id);
3271                 return SUCCESS;
3272         } else if (ccb->status == BLOGIC_CCB_RESET) {
3273                 blogic_warn("Unable to Abort Command to Target %d - CCB Reset\n", adapter, tgt_id);
3274                 return SUCCESS;
3275         }
3276         if (blogic_multimaster_type(adapter)) {
3277                 /*
3278                    Attempt to Abort this CCB.  MultiMaster Firmware versions
3279                    prior to 5.xx do not generate Abort Tag messages, but only
3280                    generate the non-tagged Abort message.  Since non-tagged
3281                    commands are not sent by the Host Adapter until the queue
3282                    of outstanding tagged commands has completed, and the
3283                    Abort message is treated as a non-tagged command, it is
3284                    effectively impossible to abort commands when Tagged
3285                    Queuing is active. Firmware version 5.xx does generate
3286                    Abort Tag messages, so it is possible to abort commands
3287                    when Tagged Queuing is active.
3288                  */
3289                 if (adapter->tgt_flags[tgt_id].tagq_active &&
3290                                 adapter->fw_ver[0] < '5') {
3291                         blogic_warn("Unable to Abort CCB #%ld to Target %d - Abort Tag Not Supported\n", adapter, ccb->serial, tgt_id);
3292                         return FAILURE;
3293                 } else if (blogic_write_outbox(adapter, BLOGIC_MBOX_ABORT,
3294                                         ccb)) {
3295                         blogic_warn("Aborting CCB #%ld to Target %d\n",
3296                                         adapter, ccb->serial, tgt_id);
3297                         blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_tried);
3298                         return SUCCESS;
3299                 } else {
3300                         blogic_warn("Unable to Abort CCB #%ld to Target %d - No Outgoing Mailboxes\n", adapter, ccb->serial, tgt_id);
3301                         return FAILURE;
3302                 }
3303         } else {
3304                 /*
3305                    Call the FlashPoint SCCB Manager to abort execution of
3306                    the CCB.
3307                  */
3308                 blogic_warn("Aborting CCB #%ld to Target %d\n", adapter,
3309                                 ccb->serial, tgt_id);
3310                 blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_tried);
3311                 FlashPoint_AbortCCB(adapter->cardhandle, ccb);
3312                 /*
3313                    The Abort may have already been completed and
3314                    blogic_qcompleted_ccb been called, or it
3315                    may still be pending.
3316                  */
3317                 if (ccb->status == BLOGIC_CCB_COMPLETE)
3318                         blogic_process_ccbs(adapter);
3319                 return SUCCESS;
3320         }
3321         return SUCCESS;
3322 }
3323
3324 #endif
3325 /*
3326   blogic_resetadapter resets Host Adapter if possible, marking all
3327   currently executing SCSI Commands as having been Reset.
3328 */
3329
3330 static int blogic_resetadapter(struct blogic_adapter *adapter, bool hard_reset)
3331 {
3332         struct blogic_ccb *ccb;
3333         int tgt_id;
3334
3335         /*
3336          * Attempt to Reset and Reinitialize the Host Adapter.
3337          */
3338
3339         if (!(blogic_hwreset(adapter, hard_reset) &&
3340                                 blogic_initadapter(adapter))) {
3341                 blogic_err("Resetting %s Failed\n", adapter,
3342                                                 adapter->full_model);
3343                 return FAILURE;
3344         }
3345
3346         /*
3347          * Deallocate all currently executing CCBs.
3348          */
3349
3350         for (ccb = adapter->all_ccbs; ccb != NULL; ccb = ccb->next_all)
3351                 if (ccb->status == BLOGIC_CCB_ACTIVE)
3352                         blogic_dealloc_ccb(ccb, 1);
3353         /*
3354          * Wait a few seconds between the Host Adapter Hard Reset which
3355          * initiates a SCSI Bus Reset and issuing any SCSI Commands.  Some
3356          * SCSI devices get confused if they receive SCSI Commands too soon
3357          * after a SCSI Bus Reset.
3358          */
3359
3360         if (hard_reset) {
3361                 spin_unlock_irq(adapter->scsi_host->host_lock);
3362                 blogic_delay(adapter->bus_settle_time);
3363                 spin_lock_irq(adapter->scsi_host->host_lock);
3364         }
3365
3366         for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) {
3367                 adapter->last_resettried[tgt_id] = jiffies;
3368                 adapter->last_resetdone[tgt_id] = jiffies;
3369         }
3370         return SUCCESS;
3371 }
3372
3373 /*
3374   blogic_diskparam returns the Heads/Sectors/Cylinders BIOS Disk
3375   Parameters for Disk.  The default disk geometry is 64 heads, 32 sectors, and
3376   the appropriate number of cylinders so as not to exceed drive capacity.  In
3377   order for disks equal to or larger than 1 GB to be addressable by the BIOS
3378   without exceeding the BIOS limitation of 1024 cylinders, Extended Translation
3379   may be enabled in AutoSCSI on FlashPoint Host Adapters and on "W" and "C"
3380   series MultiMaster Host Adapters, or by a dip switch setting on "S" and "A"
3381   series MultiMaster Host Adapters.  With Extended Translation enabled, drives
3382   between 1 GB inclusive and 2 GB exclusive are given a disk geometry of 128
3383   heads and 32 sectors, and drives above 2 GB inclusive are given a disk
3384   geometry of 255 heads and 63 sectors.  However, if the BIOS detects that the
3385   Extended Translation setting does not match the geometry in the partition
3386   table, then the translation inferred from the partition table will be used by
3387   the BIOS, and a warning may be displayed.
3388 */
3389
3390 static int blogic_diskparam(struct scsi_device *sdev, struct block_device *dev,
3391                 sector_t capacity, int *params)
3392 {
3393         struct blogic_adapter *adapter =
3394                                 (struct blogic_adapter *) sdev->host->hostdata;
3395         struct bios_diskparam *diskparam = (struct bios_diskparam *) params;
3396         unsigned char *buf;
3397
3398         if (adapter->ext_trans_enable && capacity >= 2 * 1024 * 1024 /* 1 GB in 512 byte sectors */) {
3399                 if (capacity >= 4 * 1024 * 1024 /* 2 GB in 512 byte sectors */) {
3400                         diskparam->heads = 255;
3401                         diskparam->sectors = 63;
3402                 } else {
3403                         diskparam->heads = 128;
3404                         diskparam->sectors = 32;
3405                 }
3406         } else {
3407                 diskparam->heads = 64;
3408                 diskparam->sectors = 32;
3409         }
3410         diskparam->cylinders = (unsigned long) capacity / (diskparam->heads * diskparam->sectors);
3411         buf = scsi_bios_ptable(dev);
3412         if (buf == NULL)
3413                 return 0;
3414         /*
3415            If the boot sector partition table flag is valid, search for
3416            a partition table entry whose end_head matches one of the
3417            standard BusLogic geometry translations (64/32, 128/32, or 255/63).
3418          */
3419         if (*(unsigned short *) (buf + 64) == 0xAA55) {
3420                 struct partition *part1_entry = (struct partition *) buf;
3421                 struct partition *part_entry = part1_entry;
3422                 int saved_cyl = diskparam->cylinders, part_no;
3423                 unsigned char part_end_head = 0, part_end_sector = 0;
3424
3425                 for (part_no = 0; part_no < 4; part_no++) {
3426                         part_end_head = part_entry->end_head;
3427                         part_end_sector = part_entry->end_sector & 0x3F;
3428                         if (part_end_head == 64 - 1) {
3429                                 diskparam->heads = 64;
3430                                 diskparam->sectors = 32;
3431                                 break;
3432                         } else if (part_end_head == 128 - 1) {
3433                                 diskparam->heads = 128;
3434                                 diskparam->sectors = 32;
3435                                 break;
3436                         } else if (part_end_head == 255 - 1) {
3437                                 diskparam->heads = 255;
3438                                 diskparam->sectors = 63;
3439                                 break;
3440                         }
3441                         part_entry++;
3442                 }
3443                 if (part_no == 4) {
3444                         part_end_head = part1_entry->end_head;
3445                         part_end_sector = part1_entry->end_sector & 0x3F;
3446                 }
3447                 diskparam->cylinders = (unsigned long) capacity / (diskparam->heads * diskparam->sectors);
3448                 if (part_no < 4 && part_end_sector == diskparam->sectors) {
3449                         if (diskparam->cylinders != saved_cyl)
3450                                 blogic_warn("Adopting Geometry %d/%d from Partition Table\n", adapter, diskparam->heads, diskparam->sectors);
3451                 } else if (part_end_head > 0 || part_end_sector > 0) {
3452                         blogic_warn("Warning: Partition Table appears to " "have Geometry %d/%d which is\n", adapter, part_end_head + 1, part_end_sector);
3453                         blogic_warn("not compatible with current BusLogic " "Host Adapter Geometry %d/%d\n", adapter, diskparam->heads, diskparam->sectors);
3454                 }
3455         }
3456         kfree(buf);
3457         return 0;
3458 }
3459
3460
3461 /*
3462   BugLogic_ProcDirectoryInfo implements /proc/scsi/BusLogic/<N>.
3463 */
3464
3465 static int blogic_write_info(struct Scsi_Host *shost, char *procbuf,
3466                                 int bytes_avail)
3467 {
3468         struct blogic_adapter *adapter =
3469                                 (struct blogic_adapter *) shost->hostdata;
3470         struct blogic_tgt_stats *tgt_stats;
3471
3472         tgt_stats = adapter->tgt_stats;
3473         adapter->ext_resets = 0;
3474         adapter->adapter_intern_errors = 0;
3475         memset(tgt_stats, 0, BLOGIC_MAXDEV * sizeof(struct blogic_tgt_stats));
3476         return 0;
3477 }
3478
3479 static int blogic_show_info(struct seq_file *m, struct Scsi_Host *shost)
3480 {
3481         struct blogic_adapter *adapter = (struct blogic_adapter *) shost->hostdata;
3482         struct blogic_tgt_stats *tgt_stats;
3483         int tgt;
3484
3485         tgt_stats = adapter->tgt_stats;
3486         seq_write(m, adapter->msgbuf, adapter->msgbuflen);
3487         seq_printf(m, "\n\
3488 Current Driver Queue Depth:     %d\n\
3489 Currently Allocated CCBs:       %d\n", adapter->drvr_qdepth, adapter->alloc_ccbs);
3490         seq_puts(m, "\n\n\
3491                            DATA TRANSFER STATISTICS\n\
3492 \n\
3493 Target  Tagged Queuing  Queue Depth  Active  Attempted  Completed\n\
3494 ======  ==============  ===========  ======  =========  =========\n");
3495         for (tgt = 0; tgt < adapter->maxdev; tgt++) {
3496                 struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
3497                 if (!tgt_flags->tgt_exists)
3498                         continue;
3499                 seq_printf(m, "  %2d    %s", tgt, (tgt_flags->tagq_ok ? (tgt_flags->tagq_active ? "    Active" : (adapter->tagq_ok & (1 << tgt)
3500                                                                                                                                                                     ? "  Permitted" : "   Disabled"))
3501                                                                           : "Not Supported"));
3502                 seq_printf(m,
3503                                   "         %3d       %3u    %9u        %9u\n", adapter->qdepth[tgt], adapter->active_cmds[tgt], tgt_stats[tgt].cmds_tried, tgt_stats[tgt].cmds_complete);
3504         }
3505         seq_puts(m, "\n\
3506 Target  Read Commands  Write Commands   Total Bytes Read    Total Bytes Written\n\
3507 ======  =============  ==============  ===================  ===================\n");
3508         for (tgt = 0; tgt < adapter->maxdev; tgt++) {
3509                 struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
3510                 if (!tgt_flags->tgt_exists)
3511                         continue;
3512                 seq_printf(m, "  %2d      %9u    %9u", tgt, tgt_stats[tgt].read_cmds, tgt_stats[tgt].write_cmds);
3513                 if (tgt_stats[tgt].bytesread.billions > 0)
3514                         seq_printf(m, "     %9u%09u", tgt_stats[tgt].bytesread.billions, tgt_stats[tgt].bytesread.units);
3515                 else
3516                         seq_printf(m, "         %9u", tgt_stats[tgt].bytesread.units);
3517                 if (tgt_stats[tgt].byteswritten.billions > 0)
3518                         seq_printf(m, "   %9u%09u\n", tgt_stats[tgt].byteswritten.billions, tgt_stats[tgt].byteswritten.units);
3519                 else
3520                         seq_printf(m, "      %9u\n", tgt_stats[tgt].byteswritten.units);
3521         }
3522         seq_puts(m, "\n\
3523 Target  Command    0-1KB      1-2KB      2-4KB      4-8KB     8-16KB\n\
3524 ======  =======  =========  =========  =========  =========  =========\n");
3525         for (tgt = 0; tgt < adapter->maxdev; tgt++) {
3526                 struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
3527                 if (!tgt_flags->tgt_exists)
3528                         continue;
3529                 seq_printf(m,
3530                             "  %2d       Read    %9u  %9u  %9u  %9u  %9u\n", tgt,
3531                             tgt_stats[tgt].read_sz_buckets[0],
3532                             tgt_stats[tgt].read_sz_buckets[1], tgt_stats[tgt].read_sz_buckets[2], tgt_stats[tgt].read_sz_buckets[3], tgt_stats[tgt].read_sz_buckets[4]);
3533                 seq_printf(m,
3534                             "  %2d       Write   %9u  %9u  %9u  %9u  %9u\n", tgt,
3535                             tgt_stats[tgt].write_sz_buckets[0],
3536                             tgt_stats[tgt].write_sz_buckets[1], tgt_stats[tgt].write_sz_buckets[2], tgt_stats[tgt].write_sz_buckets[3], tgt_stats[tgt].write_sz_buckets[4]);
3537         }
3538         seq_puts(m, "\n\
3539 Target  Command   16-32KB    32-64KB   64-128KB   128-256KB   256KB+\n\
3540 ======  =======  =========  =========  =========  =========  =========\n");
3541         for (tgt = 0; tgt < adapter->maxdev; tgt++) {
3542                 struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
3543                 if (!tgt_flags->tgt_exists)
3544                         continue;
3545                 seq_printf(m,
3546                             "  %2d       Read    %9u  %9u  %9u  %9u  %9u\n", tgt,
3547                             tgt_stats[tgt].read_sz_buckets[5],
3548                             tgt_stats[tgt].read_sz_buckets[6], tgt_stats[tgt].read_sz_buckets[7], tgt_stats[tgt].read_sz_buckets[8], tgt_stats[tgt].read_sz_buckets[9]);
3549                 seq_printf(m,
3550                             "  %2d       Write   %9u  %9u  %9u  %9u  %9u\n", tgt,
3551                             tgt_stats[tgt].write_sz_buckets[5],
3552                             tgt_stats[tgt].write_sz_buckets[6], tgt_stats[tgt].write_sz_buckets[7], tgt_stats[tgt].write_sz_buckets[8], tgt_stats[tgt].write_sz_buckets[9]);
3553         }
3554         seq_puts(m, "\n\n\
3555                            ERROR RECOVERY STATISTICS\n\
3556 \n\
3557           Command Aborts      Bus Device Resets   Host Adapter Resets\n\
3558 Target  Requested Completed  Requested Completed  Requested Completed\n\
3559   ID    \\\\\\\\ Attempted ////  \\\\\\\\ Attempted ////  \\\\\\\\ Attempted ////\n\
3560 ======   ===== ===== =====    ===== ===== =====    ===== ===== =====\n");
3561         for (tgt = 0; tgt < adapter->maxdev; tgt++) {
3562                 struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
3563                 if (!tgt_flags->tgt_exists)
3564                         continue;
3565                 seq_printf(m, "  %2d     %5d %5d %5d    %5d %5d %5d        %5d %5d %5d\n",
3566                            tgt, tgt_stats[tgt].aborts_request,
3567                            tgt_stats[tgt].aborts_tried,
3568                            tgt_stats[tgt].aborts_done,
3569                            tgt_stats[tgt].bdr_request,
3570                            tgt_stats[tgt].bdr_tried,
3571                            tgt_stats[tgt].bdr_done,
3572                            tgt_stats[tgt].adapter_reset_req,
3573                            tgt_stats[tgt].adapter_reset_attempt,
3574                            tgt_stats[tgt].adapter_reset_done);
3575         }
3576         seq_printf(m, "\nExternal Host Adapter Resets: %d\n", adapter->ext_resets);
3577         seq_printf(m, "Host Adapter Internal Errors: %d\n", adapter->adapter_intern_errors);
3578         return 0;
3579 }
3580
3581
3582 /*
3583   blogic_msg prints Driver Messages.
3584 */
3585
3586 static void blogic_msg(enum blogic_msglevel msglevel, char *fmt,
3587                         struct blogic_adapter *adapter, ...)
3588 {
3589         static char buf[BLOGIC_LINEBUF_SIZE];
3590         static bool begin = true;
3591         va_list args;
3592         int len = 0;
3593
3594         va_start(args, adapter);
3595         len = vsprintf(buf, fmt, args);
3596         va_end(args);
3597         if (msglevel == BLOGIC_ANNOUNCE_LEVEL) {
3598                 static int msglines = 0;
3599                 strcpy(&adapter->msgbuf[adapter->msgbuflen], buf);
3600                 adapter->msgbuflen += len;
3601                 if (++msglines <= 2)
3602                         printk("%sscsi: %s", blogic_msglevelmap[msglevel], buf);
3603         } else if (msglevel == BLOGIC_INFO_LEVEL) {
3604                 strcpy(&adapter->msgbuf[adapter->msgbuflen], buf);
3605                 adapter->msgbuflen += len;
3606                 if (begin) {
3607                         if (buf[0] != '\n' || len > 1)
3608                                 printk("%sscsi%d: %s", blogic_msglevelmap[msglevel], adapter->host_no, buf);
3609                 } else
3610                         printk("%s", buf);
3611         } else {
3612                 if (begin) {
3613                         if (adapter != NULL && adapter->adapter_initd)
3614                                 printk("%sscsi%d: %s", blogic_msglevelmap[msglevel], adapter->host_no, buf);
3615                         else
3616                                 printk("%s%s", blogic_msglevelmap[msglevel], buf);
3617                 } else
3618                         printk("%s", buf);
3619         }
3620         begin = (buf[len - 1] == '\n');
3621 }
3622
3623
3624 /*
3625   blogic_parse parses an individual option keyword.  It returns true
3626   and updates the pointer if the keyword is recognized and false otherwise.
3627 */
3628
3629 static bool __init blogic_parse(char **str, char *keyword)
3630 {
3631         char *pointer = *str;
3632         while (*keyword != '\0') {
3633                 char strch = *pointer++;
3634                 char keywordch = *keyword++;
3635                 if (strch >= 'A' && strch <= 'Z')
3636                         strch += 'a' - 'Z';
3637                 if (keywordch >= 'A' && keywordch <= 'Z')
3638                         keywordch += 'a' - 'Z';
3639                 if (strch != keywordch)
3640                         return false;
3641         }
3642         *str = pointer;
3643         return true;
3644 }
3645
3646
3647 /*
3648   blogic_parseopts handles processing of BusLogic Driver Options
3649   specifications.
3650
3651   BusLogic Driver Options may be specified either via the Linux Kernel Command
3652   Line or via the Loadable Kernel Module Installation Facility.  Driver Options
3653   for multiple host adapters may be specified either by separating the option
3654   strings by a semicolon, or by specifying multiple "BusLogic=" strings on the
3655   command line.  Individual option specifications for a single host adapter are
3656   separated by commas.  The Probing and Debugging Options apply to all host
3657   adapters whereas the remaining options apply individually only to the
3658   selected host adapter.
3659
3660   The BusLogic Driver Probing Options are described in
3661   <file:Documentation/scsi/BusLogic.txt>.
3662 */
3663
3664 static int __init blogic_parseopts(char *options)
3665 {
3666         while (true) {
3667                 struct blogic_drvr_options *drvr_opts =
3668                         &blogic_drvr_options[blogic_drvr_options_count++];
3669                 int tgt_id;
3670
3671                 memset(drvr_opts, 0, sizeof(struct blogic_drvr_options));
3672                 while (*options != '\0' && *options != ';') {
3673                         /* Probing Options. */
3674                         if (blogic_parse(&options, "IO:")) {
3675                                 unsigned long io_addr = simple_strtoul(options,
3676                                                                 &options, 0);
3677                                 blogic_probe_options.limited_isa = true;
3678                                 switch (io_addr) {
3679                                 case 0x330:
3680                                         blogic_probe_options.probe330 = true;
3681                                         break;
3682                                 case 0x334:
3683                                         blogic_probe_options.probe334 = true;
3684                                         break;
3685                                 case 0x230:
3686                                         blogic_probe_options.probe230 = true;
3687                                         break;
3688                                 case 0x234:
3689                                         blogic_probe_options.probe234 = true;
3690                                         break;
3691                                 case 0x130:
3692                                         blogic_probe_options.probe130 = true;
3693                                         break;
3694                                 case 0x134:
3695                                         blogic_probe_options.probe134 = true;
3696                                         break;
3697                                 default:
3698                                         blogic_err("BusLogic: Invalid Driver Options " "(invalid I/O Address 0x%X)\n", NULL, io_addr);
3699                                         return 0;
3700                                 }
3701                         } else if (blogic_parse(&options, "NoProbeISA"))
3702                                 blogic_probe_options.noprobe_isa = true;
3703                         else if (blogic_parse(&options, "NoProbePCI"))
3704                                 blogic_probe_options.noprobe_pci = true;
3705                         else if (blogic_parse(&options, "NoProbe"))
3706                                 blogic_probe_options.noprobe = true;
3707                         else if (blogic_parse(&options, "NoSortPCI"))
3708                                 blogic_probe_options.nosort_pci = true;
3709                         else if (blogic_parse(&options, "MultiMasterFirst"))
3710                                 blogic_probe_options.multimaster_first = true;
3711                         else if (blogic_parse(&options, "FlashPointFirst"))
3712                                 blogic_probe_options.flashpoint_first = true;
3713                         /* Tagged Queuing Options. */
3714                         else if (blogic_parse(&options, "QueueDepth:[") ||
3715                                         blogic_parse(&options, "QD:[")) {
3716                                 for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++) {
3717                                         unsigned short qdepth = simple_strtoul(options, &options, 0);
3718                                         if (qdepth > BLOGIC_MAX_TAG_DEPTH) {
3719                                                 blogic_err("BusLogic: Invalid Driver Options " "(invalid Queue Depth %d)\n", NULL, qdepth);
3720                                                 return 0;
3721                                         }
3722                                         drvr_opts->qdepth[tgt_id] = qdepth;
3723                                         if (*options == ',')
3724                                                 options++;
3725                                         else if (*options == ']')
3726                                                 break;
3727                                         else {
3728                                                 blogic_err("BusLogic: Invalid Driver Options " "(',' or ']' expected at '%s')\n", NULL, options);
3729                                                 return 0;
3730                                         }
3731                                 }
3732                                 if (*options != ']') {
3733                                         blogic_err("BusLogic: Invalid Driver Options " "(']' expected at '%s')\n", NULL, options);
3734                                         return 0;
3735                                 } else
3736                                         options++;
3737                         } else if (blogic_parse(&options, "QueueDepth:") || blogic_parse(&options, "QD:")) {
3738                                 unsigned short qdepth = simple_strtoul(options, &options, 0);
3739                                 if (qdepth == 0 ||
3740                                                 qdepth > BLOGIC_MAX_TAG_DEPTH) {
3741                                         blogic_err("BusLogic: Invalid Driver Options " "(invalid Queue Depth %d)\n", NULL, qdepth);
3742                                         return 0;
3743                                 }
3744                                 drvr_opts->common_qdepth = qdepth;
3745                                 for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++)
3746                                         drvr_opts->qdepth[tgt_id] = qdepth;
3747                         } else if (blogic_parse(&options, "TaggedQueuing:") ||
3748                                         blogic_parse(&options, "TQ:")) {
3749                                 if (blogic_parse(&options, "Default")) {
3750                                         drvr_opts->tagq_ok = 0x0000;
3751                                         drvr_opts->tagq_ok_mask = 0x0000;
3752                                 } else if (blogic_parse(&options, "Enable")) {
3753                                         drvr_opts->tagq_ok = 0xFFFF;
3754                                         drvr_opts->tagq_ok_mask = 0xFFFF;
3755                                 } else if (blogic_parse(&options, "Disable")) {
3756                                         drvr_opts->tagq_ok = 0x0000;
3757                                         drvr_opts->tagq_ok_mask = 0xFFFF;
3758                                 } else {
3759                                         unsigned short tgt_bit;
3760                                         for (tgt_id = 0, tgt_bit = 1;
3761                                                 tgt_id < BLOGIC_MAXDEV;
3762                                                 tgt_id++, tgt_bit <<= 1)
3763                                                 switch (*options++) {
3764                                                 case 'Y':
3765                                                         drvr_opts->tagq_ok |= tgt_bit;
3766                                                         drvr_opts->tagq_ok_mask |= tgt_bit;
3767                                                         break;
3768                                                 case 'N':
3769                                                         drvr_opts->tagq_ok &= ~tgt_bit;
3770                                                         drvr_opts->tagq_ok_mask |= tgt_bit;
3771                                                         break;
3772                                                 case 'X':
3773                                                         break;
3774                                                 default:
3775                                                         options--;
3776                                                         tgt_id = BLOGIC_MAXDEV;
3777                                                         break;
3778                                                 }
3779                                 }
3780                         }
3781                         /* Miscellaneous Options. */
3782                         else if (blogic_parse(&options, "BusSettleTime:") ||
3783                                         blogic_parse(&options, "BST:")) {
3784                                 unsigned short bus_settle_time =
3785                                         simple_strtoul(options, &options, 0);
3786                                 if (bus_settle_time > 5 * 60) {
3787                                         blogic_err("BusLogic: Invalid Driver Options " "(invalid Bus Settle Time %d)\n", NULL, bus_settle_time);
3788                                         return 0;
3789                                 }
3790                                 drvr_opts->bus_settle_time = bus_settle_time;
3791                         } else if (blogic_parse(&options,
3792                                                 "InhibitTargetInquiry"))
3793                                 drvr_opts->stop_tgt_inquiry = true;
3794                         /* Debugging Options. */
3795                         else if (blogic_parse(&options, "TraceProbe"))
3796                                 blogic_global_options.trace_probe = true;
3797                         else if (blogic_parse(&options, "TraceHardwareReset"))
3798                                 blogic_global_options.trace_hw_reset = true;
3799                         else if (blogic_parse(&options, "TraceConfiguration"))
3800                                 blogic_global_options.trace_config = true;
3801                         else if (blogic_parse(&options, "TraceErrors"))
3802                                 blogic_global_options.trace_err = true;
3803                         else if (blogic_parse(&options, "Debug")) {
3804                                 blogic_global_options.trace_probe = true;
3805                                 blogic_global_options.trace_hw_reset = true;
3806                                 blogic_global_options.trace_config = true;
3807                                 blogic_global_options.trace_err = true;
3808                         }
3809                         if (*options == ',')
3810                                 options++;
3811                         else if (*options != ';' && *options != '\0') {
3812                                 blogic_err("BusLogic: Unexpected Driver Option '%s' " "ignored\n", NULL, options);
3813                                 *options = '\0';
3814                         }
3815                 }
3816                 if (!(blogic_drvr_options_count == 0 ||
3817                         blogic_probeinfo_count == 0 ||
3818                         blogic_drvr_options_count == blogic_probeinfo_count)) {
3819                         blogic_err("BusLogic: Invalid Driver Options " "(all or no I/O Addresses must be specified)\n", NULL);
3820                         return 0;
3821                 }
3822                 /*
3823                    Tagged Queuing is disabled when the Queue Depth is 1 since queuing
3824                    multiple commands is not possible.
3825                  */
3826                 for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++)
3827                         if (drvr_opts->qdepth[tgt_id] == 1) {
3828                                 unsigned short tgt_bit = 1 << tgt_id;
3829                                 drvr_opts->tagq_ok &= ~tgt_bit;
3830                                 drvr_opts->tagq_ok_mask |= tgt_bit;
3831                         }
3832                 if (*options == ';')
3833                         options++;
3834                 if (*options == '\0')
3835                         return 0;
3836         }
3837         return 1;
3838 }
3839
3840 /*
3841   Get it all started
3842 */
3843
3844 static struct scsi_host_template blogic_template = {
3845         .module = THIS_MODULE,
3846         .proc_name = "BusLogic",
3847         .write_info = blogic_write_info,
3848         .show_info = blogic_show_info,
3849         .name = "BusLogic",
3850         .info = blogic_drvr_info,
3851         .queuecommand = blogic_qcmd,
3852         .slave_configure = blogic_slaveconfig,
3853         .bios_param = blogic_diskparam,
3854         .eh_host_reset_handler = blogic_hostreset,
3855 #if 0
3856         .eh_abort_handler = blogic_abort,
3857 #endif
3858         .unchecked_isa_dma = 1,
3859         .max_sectors = 128,
3860         .use_clustering = ENABLE_CLUSTERING,
3861 };
3862
3863 /*
3864   blogic_setup handles processing of Kernel Command Line Arguments.
3865 */
3866
3867 static int __init blogic_setup(char *str)
3868 {
3869         int ints[3];
3870
3871         (void) get_options(str, ARRAY_SIZE(ints), ints);
3872
3873         if (ints[0] != 0) {
3874                 blogic_err("BusLogic: Obsolete Command Line Entry " "Format Ignored\n", NULL);
3875                 return 0;
3876         }
3877         if (str == NULL || *str == '\0')
3878                 return 0;
3879         return blogic_parseopts(str);
3880 }
3881
3882 /*
3883  * Exit function.  Deletes all hosts associated with this driver.
3884  */
3885
3886 static void __exit blogic_exit(void)
3887 {
3888         struct blogic_adapter *ha, *next;
3889
3890         list_for_each_entry_safe(ha, next, &blogic_host_list, host_list)
3891                 blogic_deladapter(ha);
3892 }
3893
3894 __setup("BusLogic=", blogic_setup);
3895
3896 #ifdef MODULE
3897 /*static struct pci_device_id blogic_pci_tbl[] = {
3898         { PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER,
3899           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
3900         { PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC,
3901           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
3902         { PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT,
3903           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
3904         { }
3905 };*/
3906 static const struct pci_device_id blogic_pci_tbl[] = {
3907         {PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER)},
3908         {PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC)},
3909         {PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT)},
3910         {0, },
3911 };
3912 #endif
3913 MODULE_DEVICE_TABLE(pci, blogic_pci_tbl);
3914
3915 module_init(blogic_init);
3916 module_exit(blogic_exit);