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