brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-only2 3/*4 5  Linux Driver for BusLogic MultiMaster and FlashPoint SCSI Host Adapters6 7  Copyright 1995-1998 by Leonard N. Zubkoff <lnz@dandelion.com>8 9 10  The author respectfully requests that any modifications to this software be11  sent directly to him for evaluation and testing.12 13  Special thanks to Wayne Yen, Jin-Lon Hon, and Alex Win of BusLogic, whose14  advice has been invaluable, to David Gentzel, for writing the original Linux15  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 SCCB18  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 FAILURE54#define FAILURE (-1)55#endif56 57static const struct scsi_host_template blogic_template;58 59/*60  blogic_drvr_options_count is a count of the number of BusLogic Driver61  Options specifications provided via the Linux Kernel Command Line or via62  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 representing70  BusLogic Driver Options specifications provided via the Linux Kernel Command71  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 MODULE84static char *BusLogic;85module_param(BusLogic, charp, 0);86#endif87 88 89/*90  blogic_probe_options is a set of Probe Options to be applied across91  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 across99  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 Information115  to be checked for potential BusLogic Host Adapters.  It is initialized by116  interrogating the PCI Configuration Space on PCI machines as well as from the117  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 a125  call to blogic_cmd failed.  It is only non-NULL when blogic_cmd126  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's133  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 SCSI145  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 newly158  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.  If240  allocation fails and there are no remaining CCBs available, the Driver Queue241  Depth is decreased to a known safe value to avoid potential deadlocks when242  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's276  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's306  free list.  The Host Adapter's Lock should already have been acquired by the307  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, optionally329  providing paramlen bytes of param and receiving at most330  replylen bytes of reply; any excess reply data is received but331  discarded.332 333  On success, this function returns the number of reply bytes read from334  the Host Adapter (including any discarded data); on failure, it returns335  -1 if the command was invalid, or -2 if a timeout occurred.336 337  blogic_cmd is called exclusively during host adapter detection and338  initialization, so performance and latency are not critical, and exclusive339  access to the Host Adapter hardware is assumed.  Once the host adapter and340  driver are initialized, the only Host Adapter command that is issued is the341  single byte Execute Mailbox Command operation code, which does not require342  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 interrupts362	   must be disabled while issuing host adapter commands since a363	   Command Complete interrupt could occur if the IRQ Channel was364	   previously enabled by another BusLogic Host Adapter or another365	   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 the371	   Command/Parameter Register Busy bit to be reset in the Status372	   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 enough399		   time to determine whether the last value written to the400		   Command/Parameter Register was valid or not. If the401		   Command Complete bit is set in the Interrupt Register,402		   then the Command Invalid bit in the Status Register will403		   be reset if the Operation Code or Parameter was valid404		   and the command has completed, or set if the Operation405		   Code or Parameter was invalid. If the Data In Register406		   Ready bit is set in the Status Register, then the407		   Operation Code was valid, and data is waiting to be read408		   back from the Host Adapter. Otherwise, wait for the409		   Command/Parameter Register Busy bit in the Status410		   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 Complete434	   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 Command466	   Complete bit to be set in the Interrupt Register, or for the467	   Interrupt Handler to set the Host Adapter Command Completed468	   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			else481				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 recover519		   properly from a Command Invalid condition, so if this520		   appears to be the case, a Soft Reset is issued to the521		   Host Adapter.  Potentially invalid commands are never522		   attempted after Mailbox Initialization is performed,523		   so there should be no Host Adapter state lost by a524		   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 order567  of increasing PCI Bus and Device Number.568*/569 570static void __init blogic_sort_probeinfo(struct blogic_probeinfo571					*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 Address603  and Bus Probe Information to be checked for potential BusLogic MultiMaster604  SCSI Host Adapters by interrogating the PCI Configuration Space on PCI605  machines as well as from the list of standard BusLogic MultiMaster ISA606  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 each624	   enumerated host adapter, determine whether its ISA Compatible625	   I/O Port is enabled and if so, whether it is assigned the626	   Primary I/O Address.  A host adapter that is assigned the627	   Primary I/O Address will always be the preferred boot device.628	   The MultiMaster BIOS will first recognize a host adapter at629	   the Primary I/O Address, then any other PCI host adapters,630	   and finally any host adapters located at the remaining631	   standard ISA I/O Addresses.  When a PCI host adapter is found632	   with its ISA Compatible I/O Port enabled, a command is issued633	   to disable the ISA Compatible I/O Port, and it is noted that the634	   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 determine684		   the ISA Compatible I/O Port.  If the ISA Compatible I/O Port is685		   known and enabled, note that the particular Standard ISA I/O686		   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 the696		   ISA Compatible I/O Port. On PCI Host Adapters, the697		   Modify I/O Address command allows modification of the698		   ISA compatible I/O Address that the Host Adapter699		   responds to; it does not affect the PCI compliant700		   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 read708		   byte 45 of the AutoSCSI area, for the setting of the709		   "Use Bus And Device # For PCI Scanning Seq." option.710		   Issue the Inquire Board ID command since this option is711		   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 its733		   ISA Compatible I/O Port enabled and is assigned the734		   Primary I/O Address. If it does, then it is the Primary735		   MultiMaster Host Adapter and must be recognized first.736		   If it does not, then it is added to the list for probing737		   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		} else763			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 the769	   MultiMaster BIOS will recognize MultiMaster Host Adapters in770	   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 recognize773	   MultiMaster Host Adapters in the order they are enumerated by774	   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 Address826  and Bus Probe Information to be checked for potential BusLogic FlashPoint827  Host Adapters by interrogating the PCI Configuration Space.  It returns the828  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_FLASHPOINT861		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		} else893			blogic_warn("BusLogic: Too many Host Adapters detected\n", NULL);894#else895		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#endif899	}900	/*901	   The FlashPoint BIOS will scan for FlashPoint Host Adapters in the order of902	   increasing PCI Bus and Device Number, so sort the probe information into903	   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 Bus912  Probe Information to be checked for potential BusLogic SCSI Host Adapters by913  interrogating the PCI Configuration Space on PCI machines as well as from the914  list of standard BusLogic MultiMaster ISA I/O Addresses.  By default, if both915  FlashPoint and PCI MultiMaster Host Adapters are present, this driver will916  probe for FlashPoint Host Adapters first unless the BIOS primary disk is917  controlled by the first PCI MultiMaster Host Adapter, in which case918  MultiMaster Host Adapters will be probed first.  The BusLogic Driver Options919  specifications "MultiMasterFirst" and "FlashPointFirst" can be used to force920  a particular probe order.921*/922 923static void __init blogic_init_probeinfo_list(struct blogic_adapter *adapter)924{925	/*926	   If a PCI BIOS is present, interrogate it for MultiMaster and927	   FlashPoint Host Adapters; otherwise, default to the standard928	   ISA MultiMaster probe.929	 */930	if (!blogic_probe_options.noprobe_pci) {931		if (blogic_probe_options.multimaster_first) {932			blogic_init_mm_probeinfo(adapter);933			blogic_init_fp_probeinfo(adapter);934		} else if (blogic_probe_options.flashpoint_first) {935			blogic_init_fp_probeinfo(adapter);936			blogic_init_mm_probeinfo(adapter);937		} else {938			int fpcount = blogic_init_fp_probeinfo(adapter);939			int mmcount = blogic_init_mm_probeinfo(adapter);940			if (fpcount > 0 && mmcount > 0) {941				struct blogic_probeinfo *probeinfo =942					&blogic_probeinfo_list[fpcount];943				struct blogic_adapter *myadapter = adapter;944				struct blogic_fetch_localram fetch_localram;945				struct blogic_bios_drvmap d0_mapbyte;946 947				while (probeinfo->adapter_bus_type !=948						BLOGIC_PCI_BUS)949					probeinfo++;950				myadapter->io_addr = probeinfo->io_addr;951				fetch_localram.offset =952					BLOGIC_BIOS_BASE + BLOGIC_BIOS_DRVMAP;953				fetch_localram.count = sizeof(d0_mapbyte);954				blogic_cmd(myadapter, BLOGIC_FETCH_LOCALRAM,955						&fetch_localram,956						sizeof(fetch_localram),957						&d0_mapbyte,958						sizeof(d0_mapbyte));959				/*960				   If the Map Byte for BIOS Drive 0 indicates961				   that BIOS Drive 0 is controlled by this962				   PCI MultiMaster Host Adapter, then reverse963				   the probe order so that MultiMaster Host964				   Adapters are probed before FlashPoint Host965				   Adapters.966				 */967				if (d0_mapbyte.diskgeom != BLOGIC_BIOS_NODISK) {968					struct blogic_probeinfo saved_probeinfo[BLOGIC_MAX_ADAPTERS];969					int mmcount = blogic_probeinfo_count - fpcount;970 971					memcpy(saved_probeinfo,972						blogic_probeinfo_list,973						blogic_probeinfo_count * sizeof(struct blogic_probeinfo));974					memcpy(&blogic_probeinfo_list[0],975						&saved_probeinfo[fpcount],976						mmcount * sizeof(struct blogic_probeinfo));977					memcpy(&blogic_probeinfo_list[mmcount],978						&saved_probeinfo[0],979						fpcount * sizeof(struct blogic_probeinfo));980				}981			}982		}983	}984}985 986 987/*988  blogic_failure prints a standardized error message, and then returns false.989*/990 991static bool blogic_failure(struct blogic_adapter *adapter, char *msg)992{993	blogic_announce_drvr(adapter);994	if (adapter->adapter_bus_type == BLOGIC_PCI_BUS) {995		blogic_err("While configuring BusLogic PCI Host Adapter at\n",996				adapter);997		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);998	} else999		blogic_err("While configuring BusLogic Host Adapter at I/O Address 0x%lX:\n", adapter, adapter->io_addr);1000	blogic_err("%s FAILED - DETACHING\n", adapter, msg);1001	if (blogic_cmd_failure_reason != NULL)1002		blogic_err("ADDITIONAL FAILURE INFO - %s\n", adapter,1003				blogic_cmd_failure_reason);1004	return false;1005}1006 1007 1008/*1009  blogic_probe probes for a BusLogic Host Adapter.1010*/1011 1012static bool __init blogic_probe(struct blogic_adapter *adapter)1013{1014	union blogic_stat_reg statusreg;1015	union blogic_int_reg intreg;1016	union blogic_geo_reg georeg;1017	/*1018	   FlashPoint Host Adapters are Probed by the FlashPoint SCCB Manager.1019	 */1020	if (blogic_flashpoint_type(adapter)) {1021		struct fpoint_info *fpinfo = &adapter->fpinfo;1022		fpinfo->base_addr = (u32) adapter->io_addr;1023		fpinfo->irq_ch = adapter->irq_ch;1024		fpinfo->present = false;1025		if (!(FlashPoint_ProbeHostAdapter(fpinfo) == 0 &&1026					fpinfo->present)) {1027			blogic_err("BusLogic: FlashPoint Host Adapter detected at PCI Bus %d Device %d\n", adapter, adapter->bus, adapter->dev);1028			blogic_err("BusLogic: I/O Address 0x%lX PCI Address 0x%lX, but FlashPoint\n", adapter, adapter->io_addr, adapter->pci_addr);1029			blogic_err("BusLogic: Probe Function failed to validate it.\n", adapter);1030			return false;1031		}1032		if (blogic_global_options.trace_probe)1033			blogic_notice("BusLogic_Probe(0x%lX): FlashPoint Found\n", adapter, adapter->io_addr);1034		/*1035		   Indicate the Host Adapter Probe completed successfully.1036		 */1037		return true;1038	}1039	/*1040	   Read the Status, Interrupt, and Geometry Registers to test if there are I/O1041	   ports that respond, and to check the values to determine if they are from a1042	   BusLogic Host Adapter.  A nonexistent I/O port will return 0xFF, in which1043	   case there is definitely no BusLogic Host Adapter at this base I/O Address.1044	   The test here is a subset of that used by the BusLogic Host Adapter BIOS.1045	 */1046	statusreg.all = blogic_rdstatus(adapter);1047	intreg.all = blogic_rdint(adapter);1048	georeg.all = blogic_rdgeom(adapter);1049	if (blogic_global_options.trace_probe)1050		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);1051	if (statusreg.all == 0 || statusreg.sr.diag_active ||1052			statusreg.sr.cmd_param_busy || statusreg.sr.rsvd ||1053			statusreg.sr.cmd_invalid || intreg.ir.rsvd != 0)1054		return false;1055	/*1056	   Check the undocumented Geometry Register to test if there is1057	   an I/O port that responded.  Adaptec Host Adapters do not1058	   implement the Geometry Register, so this test helps serve to1059	   avoid incorrectly recognizing an Adaptec 1542A or 1542B as a1060	   BusLogic.  Unfortunately, the Adaptec 1542C series does respond1061	   to the Geometry Register I/O port, but it will be rejected1062	   later when the Inquire Extended Setup Information command is1063	   issued in blogic_checkadapter.  The AMI FastDisk Host Adapter1064	   is a BusLogic clone that implements the same interface as1065	   earlier BusLogic Host Adapters, including the undocumented1066	   commands, and is therefore supported by this driver. However,1067	   the AMI FastDisk always returns 0x00 upon reading the Geometry1068	   Register, so the extended translation option should always be1069	   left disabled on the AMI FastDisk.1070	 */1071	if (georeg.all == 0xFF)1072		return false;1073	/*1074	   Indicate the Host Adapter Probe completed successfully.1075	 */1076	return true;1077}1078 1079 1080/*1081  blogic_hwreset issues a Hardware Reset to the Host Adapter1082  and waits for Host Adapter Diagnostics to complete.  If hard_reset is true, a1083  Hard Reset is performed which also initiates a SCSI Bus Reset.  Otherwise, a1084  Soft Reset is performed which only resets the Host Adapter without forcing a1085  SCSI Bus Reset.1086*/1087 1088static bool blogic_hwreset(struct blogic_adapter *adapter, bool hard_reset)1089{1090	union blogic_stat_reg statusreg;1091	int timeout;1092	/*1093	   FlashPoint Host Adapters are Hard Reset by the FlashPoint1094	   SCCB Manager.1095	 */1096	if (blogic_flashpoint_type(adapter)) {1097		struct fpoint_info *fpinfo = &adapter->fpinfo;1098		fpinfo->softreset = !hard_reset;1099		fpinfo->report_underrun = true;1100		adapter->cardhandle =1101			FlashPoint_HardwareResetHostAdapter(fpinfo);1102		if (adapter->cardhandle == (void *)FPOINT_BADCARD_HANDLE)1103			return false;1104		/*1105		   Indicate the Host Adapter Hard Reset completed successfully.1106		 */1107		return true;1108	}1109	/*1110	   Issue a Hard Reset or Soft Reset Command to the Host Adapter.1111	   The Host Adapter should respond by setting Diagnostic Active in1112	   the Status Register.1113	 */1114	if (hard_reset)1115		blogic_hardreset(adapter);1116	else1117		blogic_softreset(adapter);1118	/*1119	   Wait until Diagnostic Active is set in the Status Register.1120	 */1121	timeout = 5 * 10000;1122	while (--timeout >= 0) {1123		statusreg.all = blogic_rdstatus(adapter);1124		if (statusreg.sr.diag_active)1125			break;1126		udelay(100);1127	}1128	if (blogic_global_options.trace_hw_reset)1129		blogic_notice("BusLogic_HardwareReset(0x%lX): Diagnostic Active, Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all);1130	if (timeout < 0)1131		return false;1132	/*1133	   Wait 100 microseconds to allow completion of any initial diagnostic1134	   activity which might leave the contents of the Status Register1135	   unpredictable.1136	 */1137	udelay(100);1138	/*1139	   Wait until Diagnostic Active is reset in the Status Register.1140	 */1141	timeout = 10 * 10000;1142	while (--timeout >= 0) {1143		statusreg.all = blogic_rdstatus(adapter);1144		if (!statusreg.sr.diag_active)1145			break;1146		udelay(100);1147	}1148	if (blogic_global_options.trace_hw_reset)1149		blogic_notice("BusLogic_HardwareReset(0x%lX): Diagnostic Completed, Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all);1150	if (timeout < 0)1151		return false;1152	/*1153	   Wait until at least one of the Diagnostic Failure, Host Adapter1154	   Ready, or Data In Register Ready bits is set in the Status Register.1155	 */1156	timeout = 10000;1157	while (--timeout >= 0) {1158		statusreg.all = blogic_rdstatus(adapter);1159		if (statusreg.sr.diag_failed || statusreg.sr.adapter_ready ||1160				statusreg.sr.datain_ready)1161			break;1162		udelay(100);1163	}1164	if (blogic_global_options.trace_hw_reset)1165		blogic_notice("BusLogic_HardwareReset(0x%lX): Host Adapter Ready, Status 0x%02X\n", adapter, adapter->io_addr, statusreg.all);1166	if (timeout < 0)1167		return false;1168	/*1169	   If Diagnostic Failure is set or Host Adapter Ready is reset,1170	   then an error occurred during the Host Adapter diagnostics.1171	   If Data In Register Ready is set, then there is an Error Code1172	   available.1173	 */1174	if (statusreg.sr.diag_failed || !statusreg.sr.adapter_ready) {1175		blogic_cmd_failure_reason = NULL;1176		blogic_failure(adapter, "HARD RESET DIAGNOSTICS");1177		blogic_err("HOST ADAPTER STATUS REGISTER = %02X\n", adapter,1178				statusreg.all);1179		if (statusreg.sr.datain_ready)1180			blogic_err("HOST ADAPTER ERROR CODE = %d\n", adapter,1181					blogic_rddatain(adapter));1182		return false;1183	}1184	/*1185	   Indicate the Host Adapter Hard Reset completed successfully.1186	 */1187	return true;1188}1189 1190 1191/*1192  blogic_checkadapter checks to be sure this really is a BusLogic1193  Host Adapter.1194*/1195 1196static bool __init blogic_checkadapter(struct blogic_adapter *adapter)1197{1198	struct blogic_ext_setup ext_setupinfo;1199	unsigned char req_replylen;1200	bool result = true;1201	/*1202	   FlashPoint Host Adapters do not require this protection.1203	 */1204	if (blogic_flashpoint_type(adapter))1205		return true;1206	/*1207	   Issue the Inquire Extended Setup Information command. Only genuine1208	   BusLogic Host Adapters and true clones support this command.1209	   Adaptec 1542C series Host Adapters that respond to the Geometry1210	   Register I/O port will fail this command.1211	 */1212	req_replylen = sizeof(ext_setupinfo);1213	if (blogic_cmd(adapter, BLOGIC_INQ_EXTSETUP, &req_replylen,1214				sizeof(req_replylen), &ext_setupinfo,1215				sizeof(ext_setupinfo)) != sizeof(ext_setupinfo))1216		result = false;1217	/*1218	   Provide tracing information if requested and return.1219	 */1220	if (blogic_global_options.trace_probe)1221		blogic_notice("BusLogic_Check(0x%lX): MultiMaster %s\n", adapter,1222				adapter->io_addr,1223				(result ? "Found" : "Not Found"));1224	return result;1225}1226 1227 1228/*1229  blogic_rdconfig reads the Configuration Information1230  from Host Adapter and initializes the Host Adapter structure.1231*/1232 1233static bool __init blogic_rdconfig(struct blogic_adapter *adapter)1234{1235	struct blogic_board_id id;1236	struct blogic_config config;1237	struct blogic_setup_info setupinfo;1238	struct blogic_ext_setup ext_setupinfo;1239	unsigned char model[5];1240	unsigned char fw_ver_digit3;1241	unsigned char fw_ver_letter;1242	struct blogic_adapter_info adapter_info;1243	struct blogic_fetch_localram fetch_localram;1244	struct blogic_autoscsi autoscsi;1245	union blogic_geo_reg georeg;1246	unsigned char req_replylen;1247	unsigned char *tgt, ch;1248	int tgt_id, i;1249	/*1250	   Configuration Information for FlashPoint Host Adapters is1251	   provided in the fpoint_info structure by the FlashPoint1252	   SCCB Manager's Probe Function. Initialize fields in the1253	   Host Adapter structure from the fpoint_info structure.1254	 */1255	if (blogic_flashpoint_type(adapter)) {1256		struct fpoint_info *fpinfo = &adapter->fpinfo;1257		tgt = adapter->model;1258		*tgt++ = 'B';1259		*tgt++ = 'T';1260		*tgt++ = '-';1261		for (i = 0; i < sizeof(fpinfo->model); i++)1262			*tgt++ = fpinfo->model[i];1263		*tgt++ = '\0';1264		strcpy(adapter->fw_ver, FLASHPOINT_FW_VER);1265		adapter->scsi_id = fpinfo->scsi_id;1266		adapter->ext_trans_enable = fpinfo->ext_trans_enable;1267		adapter->parity = fpinfo->parity;1268		adapter->reset_enabled = !fpinfo->softreset;1269		adapter->level_int = true;1270		adapter->wide = fpinfo->wide;1271		adapter->differential = false;1272		adapter->scam = true;1273		adapter->ultra = true;1274		adapter->ext_lun = true;1275		adapter->terminfo_valid = true;1276		adapter->low_term = fpinfo->low_term;1277		adapter->high_term = fpinfo->high_term;1278		adapter->scam_enabled = fpinfo->scam_enabled;1279		adapter->scam_lev2 = fpinfo->scam_lev2;1280		adapter->drvr_sglimit = BLOGIC_SG_LIMIT;1281		adapter->maxdev = (adapter->wide ? 16 : 8);1282		adapter->maxlun = 32;1283		adapter->initccbs = 4 * BLOGIC_CCB_GRP_ALLOCSIZE;1284		adapter->inc_ccbs = BLOGIC_CCB_GRP_ALLOCSIZE;1285		adapter->drvr_qdepth = 255;1286		adapter->adapter_qdepth = adapter->drvr_qdepth;1287		adapter->sync_ok = fpinfo->sync_ok;1288		adapter->fast_ok = fpinfo->fast_ok;1289		adapter->ultra_ok = fpinfo->ultra_ok;1290		adapter->wide_ok = fpinfo->wide_ok;1291		adapter->discon_ok = fpinfo->discon_ok;1292		adapter->tagq_ok = 0xFFFF;1293		goto common;1294	}1295	/*1296	   Issue the Inquire Board ID command.1297	 */1298	if (blogic_cmd(adapter, BLOGIC_GET_BOARD_ID, NULL, 0, &id,1299				sizeof(id)) != sizeof(id))1300		return blogic_failure(adapter, "INQUIRE BOARD ID");1301	/*1302	   Issue the Inquire Configuration command.1303	 */1304	if (blogic_cmd(adapter, BLOGIC_INQ_CONFIG, NULL, 0, &config,1305				sizeof(config))1306	    != sizeof(config))1307		return blogic_failure(adapter, "INQUIRE CONFIGURATION");1308	/*1309	   Issue the Inquire Setup Information command.1310	 */1311	req_replylen = sizeof(setupinfo);1312	if (blogic_cmd(adapter, BLOGIC_INQ_SETUPINFO, &req_replylen,1313				sizeof(req_replylen), &setupinfo,1314				sizeof(setupinfo)) != sizeof(setupinfo))1315		return blogic_failure(adapter, "INQUIRE SETUP INFORMATION");1316	/*1317	   Issue the Inquire Extended Setup Information command.1318	 */1319	req_replylen = sizeof(ext_setupinfo);1320	if (blogic_cmd(adapter, BLOGIC_INQ_EXTSETUP, &req_replylen,1321				sizeof(req_replylen), &ext_setupinfo,1322				sizeof(ext_setupinfo)) != sizeof(ext_setupinfo))1323		return blogic_failure(adapter,1324					"INQUIRE EXTENDED SETUP INFORMATION");1325	/*1326	   Issue the Inquire Firmware Version 3rd Digit command.1327	 */1328	fw_ver_digit3 = '\0';1329	if (id.fw_ver_digit1 > '0')1330		if (blogic_cmd(adapter, BLOGIC_INQ_FWVER_D3, NULL, 0,1331				&fw_ver_digit3,1332				sizeof(fw_ver_digit3)) != sizeof(fw_ver_digit3))1333			return blogic_failure(adapter,1334						"INQUIRE FIRMWARE 3RD DIGIT");1335	/*1336	   Issue the Inquire Host Adapter Model Number command.1337	 */1338	if (ext_setupinfo.bus_type == 'A' && id.fw_ver_digit1 == '2')1339		/* BusLogic BT-542B ISA 2.xx */1340		strcpy(model, "542B");1341	else if (ext_setupinfo.bus_type == 'E' && id.fw_ver_digit1 == '2' &&1342			(id.fw_ver_digit2 <= '1' || (id.fw_ver_digit2 == '2' &&1343						     fw_ver_digit3 == '0')))1344		/* BusLogic BT-742A EISA 2.1x or 2.20 */1345		strcpy(model, "742A");1346	else if (ext_setupinfo.bus_type == 'E' && id.fw_ver_digit1 == '0')1347		/* AMI FastDisk EISA Series 441 0.x */1348		strcpy(model, "747A");1349	else {1350		req_replylen = sizeof(model);1351		if (blogic_cmd(adapter, BLOGIC_INQ_MODELNO, &req_replylen,1352					sizeof(req_replylen), &model,1353					sizeof(model)) != sizeof(model))1354			return blogic_failure(adapter,1355					"INQUIRE HOST ADAPTER MODEL NUMBER");1356	}1357	/*1358	   BusLogic MultiMaster Host Adapters can be identified by their1359	   model number and the major version number of their firmware1360	   as follows:1361 1362	   5.xx       BusLogic "W" Series Host Adapters:1363	   BT-948/958/958D1364	   4.xx       BusLogic "C" Series Host Adapters:1365	   BT-946C/956C/956CD/747C/757C/757CD/445C/545C/540CF1366	   3.xx       BusLogic "S" Series Host Adapters:1367	   BT-747S/747D/757S/757D/445S/545S/542D1368	   BT-542B/742A (revision H)1369	   2.xx       BusLogic "A" Series Host Adapters:1370	   BT-542B/742A (revision G and below)1371	   0.xx       AMI FastDisk VLB/EISA BusLogic Clone Host Adapter1372	 */1373	/*1374	   Save the Model Name and Host Adapter Name in the Host Adapter1375	   structure.1376	 */1377	tgt = adapter->model;1378	*tgt++ = 'B';1379	*tgt++ = 'T';1380	*tgt++ = '-';1381	for (i = 0; i < sizeof(model); i++) {1382		ch = model[i];1383		if (ch == ' ' || ch == '\0')1384			break;1385		*tgt++ = ch;1386	}1387	*tgt++ = '\0';1388	/*1389	   Save the Firmware Version in the Host Adapter structure.1390	 */1391	tgt = adapter->fw_ver;1392	*tgt++ = id.fw_ver_digit1;1393	*tgt++ = '.';1394	*tgt++ = id.fw_ver_digit2;1395	if (fw_ver_digit3 != ' ' && fw_ver_digit3 != '\0')1396		*tgt++ = fw_ver_digit3;1397	*tgt = '\0';1398	/*1399	   Issue the Inquire Firmware Version Letter command.1400	 */1401	if (strcmp(adapter->fw_ver, "3.3") >= 0) {1402		if (blogic_cmd(adapter, BLOGIC_INQ_FWVER_LETTER, NULL, 0,1403				&fw_ver_letter,1404				sizeof(fw_ver_letter)) != sizeof(fw_ver_letter))1405			return blogic_failure(adapter,1406					"INQUIRE FIRMWARE VERSION LETTER");1407		if (fw_ver_letter != ' ' && fw_ver_letter != '\0')1408			*tgt++ = fw_ver_letter;1409		*tgt = '\0';1410	}1411	/*1412	   Save the Host Adapter SCSI ID in the Host Adapter structure.1413	 */1414	adapter->scsi_id = config.id;1415	/*1416	   Determine the Bus Type and save it in the Host Adapter structure,1417	   determine and save the IRQ Channel if necessary, and determine1418	   and save the DMA Channel for ISA Host Adapters.1419	 */1420	adapter->adapter_bus_type =1421			blogic_adater_bus_types[adapter->model[3] - '4'];1422	if (adapter->irq_ch == 0) {1423		if (config.irq_ch9)1424			adapter->irq_ch = 9;1425		else if (config.irq_ch10)1426			adapter->irq_ch = 10;1427		else if (config.irq_ch11)1428			adapter->irq_ch = 11;1429		else if (config.irq_ch12)1430			adapter->irq_ch = 12;1431		else if (config.irq_ch14)1432			adapter->irq_ch = 14;1433		else if (config.irq_ch15)1434			adapter->irq_ch = 15;1435	}1436	/*1437	   Determine whether Extended Translation is enabled and save it in1438	   the Host Adapter structure.1439	 */1440	georeg.all = blogic_rdgeom(adapter);1441	adapter->ext_trans_enable = georeg.gr.ext_trans_enable;1442	/*1443	   Save the Scatter Gather Limits, Level Sensitive Interrupt flag, Wide1444	   SCSI flag, Differential SCSI flag, SCAM Supported flag, and1445	   Ultra SCSI flag in the Host Adapter structure.1446	 */1447	adapter->adapter_sglimit = ext_setupinfo.sg_limit;1448	adapter->drvr_sglimit = adapter->adapter_sglimit;1449	if (adapter->adapter_sglimit > BLOGIC_SG_LIMIT)1450		adapter->drvr_sglimit = BLOGIC_SG_LIMIT;1451	if (ext_setupinfo.misc.level_int)1452		adapter->level_int = true;1453	adapter->wide = ext_setupinfo.wide;1454	adapter->differential = ext_setupinfo.differential;1455	adapter->scam = ext_setupinfo.scam;1456	adapter->ultra = ext_setupinfo.ultra;1457	/*1458	   Determine whether Extended LUN Format CCBs are supported and save the1459	   information in the Host Adapter structure.1460	 */1461	if (adapter->fw_ver[0] == '5' || (adapter->fw_ver[0] == '4' &&1462				adapter->wide))1463		adapter->ext_lun = true;1464	/*1465	   Issue the Inquire PCI Host Adapter Information command to read the1466	   Termination Information from "W" series MultiMaster Host Adapters.1467	 */1468	if (adapter->fw_ver[0] == '5') {1469		if (blogic_cmd(adapter, BLOGIC_INQ_PCI_INFO, NULL, 0,1470				&adapter_info,1471				sizeof(adapter_info)) != sizeof(adapter_info))1472			return blogic_failure(adapter,1473					"INQUIRE PCI HOST ADAPTER INFORMATION");1474		/*1475		   Save the Termination Information in the Host Adapter1476		   structure.1477		 */1478		if (adapter_info.genericinfo_valid) {1479			adapter->terminfo_valid = true;1480			adapter->low_term = adapter_info.low_term;1481			adapter->high_term = adapter_info.high_term;1482		}1483	}1484	/*1485	   Issue the Fetch Host Adapter Local RAM command to read the1486	   AutoSCSI data from "W" and "C" series MultiMaster Host Adapters.1487	 */1488	if (adapter->fw_ver[0] >= '4') {1489		fetch_localram.offset = BLOGIC_AUTOSCSI_BASE;1490		fetch_localram.count = sizeof(autoscsi);1491		if (blogic_cmd(adapter, BLOGIC_FETCH_LOCALRAM, &fetch_localram,1492					sizeof(fetch_localram), &autoscsi,1493					sizeof(autoscsi)) != sizeof(autoscsi))1494			return blogic_failure(adapter,1495						"FETCH HOST ADAPTER LOCAL RAM");1496		/*1497		   Save the Parity Checking Enabled, Bus Reset Enabled,1498		   and Termination Information in the Host Adapter structure.1499		 */1500		adapter->parity = autoscsi.parity;1501		adapter->reset_enabled = autoscsi.reset_enabled;1502		if (adapter->fw_ver[0] == '4') {1503			adapter->terminfo_valid = true;1504			adapter->low_term = autoscsi.low_term;1505			adapter->high_term = autoscsi.high_term;1506		}1507		/*1508		   Save the Wide Permitted, Fast Permitted, Synchronous1509		   Permitted, Disconnect Permitted, Ultra Permitted, and1510		   SCAM Information in the Host Adapter structure.1511		 */1512		adapter->wide_ok = autoscsi.wide_ok;1513		adapter->fast_ok = autoscsi.fast_ok;1514		adapter->sync_ok = autoscsi.sync_ok;1515		adapter->discon_ok = autoscsi.discon_ok;1516		if (adapter->ultra)1517			adapter->ultra_ok = autoscsi.ultra_ok;1518		if (adapter->scam) {1519			adapter->scam_enabled = autoscsi.scam_enabled;1520			adapter->scam_lev2 = autoscsi.scam_lev2;1521		}1522	}1523	/*1524	   Initialize fields in the Host Adapter structure for "S" and "A"1525	   series MultiMaster Host Adapters.1526	 */1527	if (adapter->fw_ver[0] < '4') {1528		if (setupinfo.sync) {1529			adapter->sync_ok = 0xFF;1530			if (adapter->adapter_bus_type == BLOGIC_EISA_BUS) {1531				if (ext_setupinfo.misc.fast_on_eisa)1532					adapter->fast_ok = 0xFF;1533				if (strcmp(adapter->model, "BT-757") == 0)1534					adapter->wide_ok = 0xFF;1535			}1536		}1537		adapter->discon_ok = 0xFF;1538		adapter->parity = setupinfo.parity;1539		adapter->reset_enabled = true;1540	}1541	/*1542	   Determine the maximum number of Target IDs and Logical Units1543	   supported by this driver for Wide and Narrow Host Adapters.1544	 */1545	adapter->maxdev = (adapter->wide ? 16 : 8);1546	adapter->maxlun = (adapter->ext_lun ? 32 : 8);1547	/*1548	   Select appropriate values for the Mailbox Count, Driver Queue Depth,1549	   Initial CCBs, and Incremental CCBs variables based on whether1550	   or not Strict Round Robin Mode is supported.  If Strict Round1551	   Robin Mode is supported, then there is no performance degradation1552	   in using the maximum possible number of Outgoing and Incoming1553	   Mailboxes and allowing the Tagged and Untagged Queue Depths to1554	   determine the actual utilization.  If Strict Round Robin Mode is1555	   not supported, then the Host Adapter must scan all the Outgoing1556	   Mailboxes whenever an Outgoing Mailbox entry is made, which can1557	   cause a substantial performance penalty.  The host adapters1558	   actually have room to store the following number of CCBs1559	   internally; that is, they can internally queue and manage this1560	   many active commands on the SCSI bus simultaneously.  Performance1561	   measurements demonstrate that the Driver Queue Depth should be1562	   set to the Mailbox Count, rather than the Host Adapter Queue1563	   Depth (internal CCB capacity), as it is more efficient to have the1564	   queued commands waiting in Outgoing Mailboxes if necessary than1565	   to block the process in the higher levels of the SCSI Subsystem.1566 1567	   192          BT-948/958/958D1568	   100          BT-946C/956C/956CD/747C/757C/757CD/445C1569	   50   BT-545C/540CF1570	   30   BT-747S/747D/757S/757D/445S/545S/542D/542B/742A1571	 */1572	if (adapter->fw_ver[0] == '5')1573		adapter->adapter_qdepth = 192;1574	else if (adapter->fw_ver[0] == '4')1575		adapter->adapter_qdepth = 100;1576	else1577		adapter->adapter_qdepth = 30;1578	if (strcmp(adapter->fw_ver, "3.31") >= 0) {1579		adapter->strict_rr = true;1580		adapter->mbox_count = BLOGIC_MAX_MAILBOX;1581	} else {1582		adapter->strict_rr = false;1583		adapter->mbox_count = 32;1584	}1585	adapter->drvr_qdepth = adapter->mbox_count;1586	adapter->initccbs = 4 * BLOGIC_CCB_GRP_ALLOCSIZE;1587	adapter->inc_ccbs = BLOGIC_CCB_GRP_ALLOCSIZE;1588	/*1589	   Tagged Queuing support is available and operates properly on1590	   all "W" series MultiMaster Host Adapters, on "C" series1591	   MultiMaster Host Adapters with firmware version 4.22 and above,1592	   and on "S" series MultiMaster Host Adapters with firmware version1593	   3.35 and above.1594	 */1595	adapter->tagq_ok = 0;1596	switch (adapter->fw_ver[0]) {1597	case '5':1598		adapter->tagq_ok = 0xFFFF;1599		break;1600	case '4':1601		if (strcmp(adapter->fw_ver, "4.22") >= 0)1602			adapter->tagq_ok = 0xFFFF;1603		break;1604	case '3':1605		if (strcmp(adapter->fw_ver, "3.35") >= 0)1606			adapter->tagq_ok = 0xFFFF;1607		break;1608	}1609	/*1610	   Determine the Host Adapter BIOS Address if the BIOS is enabled and1611	   save it in the Host Adapter structure.  The BIOS is disabled if the1612	   bios_addr is 0.1613	 */1614	adapter->bios_addr = ext_setupinfo.bios_addr << 12;1615	/*1616	   BusLogic BT-445S Host Adapters prior to board revision E have a1617	   hardware bug whereby when the BIOS is enabled, transfers to/from1618	   the same address range the BIOS occupies modulo 16MB are handled1619	   incorrectly.  Only properly functioning BT-445S Host Adapters1620	   have firmware version 3.37.1621	 */1622	if (adapter->bios_addr > 0 &&1623	    strcmp(adapter->model, "BT-445S") == 0 &&1624	    strcmp(adapter->fw_ver, "3.37") < 0)1625		return blogic_failure(adapter, "Too old firmware");1626	/*1627	   Initialize parameters common to MultiMaster and FlashPoint1628	   Host Adapters.1629	 */1630common:1631	/*1632	   Initialize the Host Adapter Full Model Name from the Model Name.1633	 */1634	strcpy(adapter->full_model, "BusLogic ");1635	strcat(adapter->full_model, adapter->model);1636	/*1637	   Select an appropriate value for the Tagged Queue Depth either from a1638	   BusLogic Driver Options specification, or based on whether this Host1639	   Adapter requires that ISA Bounce Buffers be used.  The Tagged Queue1640	   Depth is left at 0 for automatic determination in1641	   BusLogic_SelectQueueDepths. Initialize the Untagged Queue Depth.1642	 */1643	for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++) {1644		unsigned char qdepth = 0;1645		if (adapter->drvr_opts != NULL &&1646				adapter->drvr_opts->qdepth[tgt_id] > 0)1647			qdepth = adapter->drvr_opts->qdepth[tgt_id];1648		adapter->qdepth[tgt_id] = qdepth;1649	}1650	adapter->untag_qdepth = BLOGIC_UNTAG_DEPTH;1651	if (adapter->drvr_opts != NULL)1652		adapter->common_qdepth = adapter->drvr_opts->common_qdepth;1653	if (adapter->common_qdepth > 0 &&1654			adapter->common_qdepth < adapter->untag_qdepth)1655		adapter->untag_qdepth = adapter->common_qdepth;1656	/*1657	   Tagged Queuing is only allowed if Disconnect/Reconnect is permitted.1658	   Therefore, mask the Tagged Queuing Permitted Default bits with the1659	   Disconnect/Reconnect Permitted bits.1660	 */1661	adapter->tagq_ok &= adapter->discon_ok;1662	/*1663	   Combine the default Tagged Queuing Permitted bits with any1664	   BusLogic Driver Options Tagged Queuing specification.1665	 */1666	if (adapter->drvr_opts != NULL)1667		adapter->tagq_ok = (adapter->drvr_opts->tagq_ok &1668				adapter->drvr_opts->tagq_ok_mask) |1669			(adapter->tagq_ok & ~adapter->drvr_opts->tagq_ok_mask);1670 1671	/*1672	   Select an appropriate value for Bus Settle Time either from a1673	   BusLogic Driver Options specification, or from1674	   BLOGIC_BUS_SETTLE_TIME.1675	 */1676	if (adapter->drvr_opts != NULL &&1677			adapter->drvr_opts->bus_settle_time > 0)1678		adapter->bus_settle_time = adapter->drvr_opts->bus_settle_time;1679	else1680		adapter->bus_settle_time = BLOGIC_BUS_SETTLE_TIME;1681	/*1682	   Indicate reading the Host Adapter Configuration completed1683	   successfully.1684	 */1685	return true;1686}1687 1688 1689/*1690  blogic_reportconfig reports the configuration of Host Adapter.1691*/1692 1693static bool __init blogic_reportconfig(struct blogic_adapter *adapter)1694{1695	unsigned short alltgt_mask = (1 << adapter->maxdev) - 1;1696	unsigned short sync_ok, fast_ok;1697	unsigned short ultra_ok, wide_ok;1698	unsigned short discon_ok, tagq_ok;1699	bool common_syncneg, common_tagq_depth;1700	char syncstr[BLOGIC_MAXDEV + 1];1701	char widestr[BLOGIC_MAXDEV + 1];1702	char discon_str[BLOGIC_MAXDEV + 1];1703	char tagq_str[BLOGIC_MAXDEV + 1];1704	char *syncmsg = syncstr;1705	char *widemsg = widestr;1706	char *discon_msg = discon_str;1707	char *tagq_msg = tagq_str;1708	int tgt_id;1709 1710	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" : ""));1711	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"));1712	if (adapter->adapter_bus_type != BLOGIC_PCI_BUS) {1713		blogic_info("  DMA Channel: None, ", adapter);1714		if (adapter->bios_addr > 0)1715			blogic_info("BIOS Address: 0x%X, ", adapter,1716					adapter->bios_addr);1717		else1718			blogic_info("BIOS Address: None, ", adapter);1719	} else {1720		blogic_info("  PCI Bus: %d, Device: %d, Address: ", adapter,1721				adapter->bus, adapter->dev);1722		if (adapter->pci_addr > 0)1723			blogic_info("0x%lX, ", adapter, adapter->pci_addr);1724		else1725			blogic_info("Unassigned, ", adapter);1726	}1727	blogic_info("Host Adapter SCSI ID: %d\n", adapter, adapter->scsi_id);1728	blogic_info("  Parity Checking: %s, Extended Translation: %s\n",1729			adapter, (adapter->parity ? "Enabled" : "Disabled"),1730			(adapter->ext_trans_enable ? "Enabled" : "Disabled"));1731	alltgt_mask &= ~(1 << adapter->scsi_id);1732	sync_ok = adapter->sync_ok & alltgt_mask;1733	fast_ok = adapter->fast_ok & alltgt_mask;1734	ultra_ok = adapter->ultra_ok & alltgt_mask;1735	if ((blogic_multimaster_type(adapter) &&1736			(adapter->fw_ver[0] >= '4' ||1737			 adapter->adapter_bus_type == BLOGIC_EISA_BUS)) ||1738			blogic_flashpoint_type(adapter)) {1739		common_syncneg = false;1740		if (sync_ok == 0) {1741			syncmsg = "Disabled";1742			common_syncneg = true;1743		} else if (sync_ok == alltgt_mask) {1744			if (fast_ok == 0) {1745				syncmsg = "Slow";1746				common_syncneg = true;1747			} else if (fast_ok == alltgt_mask) {1748				if (ultra_ok == 0) {1749					syncmsg = "Fast";1750					common_syncneg = true;1751				} else if (ultra_ok == alltgt_mask) {1752					syncmsg = "Ultra";1753					common_syncneg = true;1754				}1755			}1756		}1757		if (!common_syncneg) {1758			for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)1759				syncstr[tgt_id] = ((!(sync_ok & (1 << tgt_id))) ? 'N' : (!(fast_ok & (1 << tgt_id)) ? 'S' : (!(ultra_ok & (1 << tgt_id)) ? 'F' : 'U')));1760			syncstr[adapter->scsi_id] = '#';1761			syncstr[adapter->maxdev] = '\0';1762		}1763	} else1764		syncmsg = (sync_ok == 0 ? "Disabled" : "Enabled");1765	wide_ok = adapter->wide_ok & alltgt_mask;1766	if (wide_ok == 0)1767		widemsg = "Disabled";1768	else if (wide_ok == alltgt_mask)1769		widemsg = "Enabled";1770	else {1771		for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)1772			widestr[tgt_id] = ((wide_ok & (1 << tgt_id)) ? 'Y' : 'N');1773		widestr[adapter->scsi_id] = '#';1774		widestr[adapter->maxdev] = '\0';1775	}1776	discon_ok = adapter->discon_ok & alltgt_mask;1777	if (discon_ok == 0)1778		discon_msg = "Disabled";1779	else if (discon_ok == alltgt_mask)1780		discon_msg = "Enabled";1781	else {1782		for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)1783			discon_str[tgt_id] = ((discon_ok & (1 << tgt_id)) ? 'Y' : 'N');1784		discon_str[adapter->scsi_id] = '#';1785		discon_str[adapter->maxdev] = '\0';1786	}1787	tagq_ok = adapter->tagq_ok & alltgt_mask;1788	if (tagq_ok == 0)1789		tagq_msg = "Disabled";1790	else if (tagq_ok == alltgt_mask)1791		tagq_msg = "Enabled";1792	else {1793		for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)1794			tagq_str[tgt_id] = ((tagq_ok & (1 << tgt_id)) ? 'Y' : 'N');1795		tagq_str[adapter->scsi_id] = '#';1796		tagq_str[adapter->maxdev] = '\0';1797	}1798	blogic_info("  Synchronous Negotiation: %s, Wide Negotiation: %s\n",1799			adapter, syncmsg, widemsg);1800	blogic_info("  Disconnect/Reconnect: %s, Tagged Queuing: %s\n", adapter,1801			discon_msg, tagq_msg);1802	if (blogic_multimaster_type(adapter)) {1803		blogic_info("  Scatter/Gather Limit: %d of %d segments, Mailboxes: %d\n", adapter, adapter->drvr_sglimit, adapter->adapter_sglimit, adapter->mbox_count);1804		blogic_info("  Driver Queue Depth: %d, Host Adapter Queue Depth: %d\n", adapter, adapter->drvr_qdepth, adapter->adapter_qdepth);1805	} else1806		blogic_info("  Driver Queue Depth: %d, Scatter/Gather Limit: %d segments\n", adapter, adapter->drvr_qdepth, adapter->drvr_sglimit);1807	blogic_info("  Tagged Queue Depth: ", adapter);1808	common_tagq_depth = true;1809	for (tgt_id = 1; tgt_id < adapter->maxdev; tgt_id++)1810		if (adapter->qdepth[tgt_id] != adapter->qdepth[0]) {1811			common_tagq_depth = false;1812			break;1813		}1814	if (common_tagq_depth) {1815		if (adapter->qdepth[0] > 0)1816			blogic_info("%d", adapter, adapter->qdepth[0]);1817		else1818			blogic_info("Automatic", adapter);1819	} else1820		blogic_info("Individual", adapter);1821	blogic_info(", Untagged Queue Depth: %d\n", adapter,1822			adapter->untag_qdepth);1823	if (adapter->terminfo_valid) {1824		if (adapter->wide)1825			blogic_info("  SCSI Bus Termination: %s", adapter,1826				(adapter->low_term ? (adapter->high_term ? "Both Enabled" : "Low Enabled") : (adapter->high_term ? "High Enabled" : "Both Disabled")));1827		else1828			blogic_info("  SCSI Bus Termination: %s", adapter,1829				(adapter->low_term ? "Enabled" : "Disabled"));1830		if (adapter->scam)1831			blogic_info(", SCAM: %s", adapter,1832				(adapter->scam_enabled ? (adapter->scam_lev2 ? "Enabled, Level 2" : "Enabled, Level 1") : "Disabled"));1833		blogic_info("\n", adapter);1834	}1835	/*1836	   Indicate reporting the Host Adapter configuration completed1837	   successfully.1838	 */1839	return true;1840}1841 1842 1843/*1844  blogic_getres acquires the system resources necessary to use1845  Host Adapter.1846*/1847 1848static bool __init blogic_getres(struct blogic_adapter *adapter)1849{1850	if (adapter->irq_ch == 0) {1851		blogic_err("NO LEGAL INTERRUPT CHANNEL ASSIGNED - DETACHING\n",1852				adapter);1853		return false;1854	}1855	/*1856	   Acquire shared access to the IRQ Channel.1857	 */1858	if (request_irq(adapter->irq_ch, blogic_inthandler, IRQF_SHARED,1859				adapter->full_model, adapter) < 0) {1860		blogic_err("UNABLE TO ACQUIRE IRQ CHANNEL %d - DETACHING\n",1861				adapter, adapter->irq_ch);1862		return false;1863	}1864	adapter->irq_acquired = true;1865	/*1866	   Indicate the System Resource Acquisition completed successfully,1867	 */1868	return true;1869}1870 1871 1872/*1873  blogic_relres releases any system resources previously acquired1874  by blogic_getres.1875*/1876 1877static void blogic_relres(struct blogic_adapter *adapter)1878{1879	/*1880	   Release shared access to the IRQ Channel.1881	 */1882	if (adapter->irq_acquired)1883		free_irq(adapter->irq_ch, adapter);1884	/*1885	   Release any allocated memory structs not released elsewhere1886	 */1887	if (adapter->mbox_space)1888		dma_free_coherent(&adapter->pci_device->dev, adapter->mbox_sz,1889			adapter->mbox_space, adapter->mbox_space_handle);1890	pci_dev_put(adapter->pci_device);1891	adapter->mbox_space = NULL;1892	adapter->mbox_space_handle = 0;1893	adapter->mbox_sz = 0;1894}1895 1896 1897/*1898  blogic_initadapter initializes Host Adapter.  This is the only1899  function called during SCSI Host Adapter detection which modifies the state1900  of the Host Adapter from its initial power on or hard reset state.1901*/1902 1903static bool blogic_initadapter(struct blogic_adapter *adapter)1904{1905	struct blogic_extmbox_req extmbox_req;1906	enum blogic_rr_req rr_req;1907	enum blogic_setccb_fmt setccb_fmt;1908	int tgt_id;1909 1910	/*1911	   Initialize the pointers to the first and last CCBs that are1912	   queued for completion processing.1913	 */1914	adapter->firstccb = NULL;1915	adapter->lastccb = NULL;1916 1917	/*1918	   Initialize the Bus Device Reset Pending CCB, Tagged Queuing Active,1919	   Command Successful Flag, Active Commands, and Commands Since Reset1920	   for each Target Device.1921	 */1922	for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) {1923		adapter->bdr_pend[tgt_id] = NULL;1924		adapter->tgt_flags[tgt_id].tagq_active = false;1925		adapter->tgt_flags[tgt_id].cmd_good = false;1926		adapter->active_cmds[tgt_id] = 0;1927		adapter->cmds_since_rst[tgt_id] = 0;1928	}1929 1930	/*1931	   FlashPoint Host Adapters do not use Outgoing and Incoming Mailboxes.1932	 */1933	if (blogic_flashpoint_type(adapter))1934		goto done;1935 1936	/*1937	   Initialize the Outgoing and Incoming Mailbox pointers.1938	 */1939	adapter->mbox_sz = adapter->mbox_count * (sizeof(struct blogic_outbox) + sizeof(struct blogic_inbox));1940	adapter->mbox_space = dma_alloc_coherent(&adapter->pci_device->dev,1941				adapter->mbox_sz, &adapter->mbox_space_handle,1942				GFP_KERNEL);1943	if (adapter->mbox_space == NULL)1944		return blogic_failure(adapter, "MAILBOX ALLOCATION");1945	adapter->first_outbox = (struct blogic_outbox *) adapter->mbox_space;1946	adapter->last_outbox = adapter->first_outbox + adapter->mbox_count - 1;1947	adapter->next_outbox = adapter->first_outbox;1948	adapter->first_inbox = (struct blogic_inbox *) (adapter->last_outbox + 1);1949	adapter->last_inbox = adapter->first_inbox + adapter->mbox_count - 1;1950	adapter->next_inbox = adapter->first_inbox;1951 1952	/*1953	   Initialize the Outgoing and Incoming Mailbox structures.1954	 */1955	memset(adapter->first_outbox, 0,1956			adapter->mbox_count * sizeof(struct blogic_outbox));1957	memset(adapter->first_inbox, 0,1958			adapter->mbox_count * sizeof(struct blogic_inbox));1959 1960	/*1961	   Initialize the Host Adapter's Pointer to the Outgoing/Incoming1962	   Mailboxes.1963	 */1964	extmbox_req.mbox_count = adapter->mbox_count;1965	extmbox_req.base_mbox_addr = (u32) adapter->mbox_space_handle;1966	if (blogic_cmd(adapter, BLOGIC_INIT_EXT_MBOX, &extmbox_req,1967				sizeof(extmbox_req), NULL, 0) < 0)1968		return blogic_failure(adapter, "MAILBOX INITIALIZATION");1969	/*1970	   Enable Strict Round Robin Mode if supported by the Host Adapter. In1971	   Strict Round Robin Mode, the Host Adapter only looks at the next1972	   Outgoing Mailbox for each new command, rather than scanning1973	   through all the Outgoing Mailboxes to find any that have new1974	   commands in them.  Strict Round Robin Mode is significantly more1975	   efficient.1976	 */1977	if (adapter->strict_rr) {1978		rr_req = BLOGIC_STRICT_RR_MODE;1979		if (blogic_cmd(adapter, BLOGIC_STRICT_RR, &rr_req,1980					sizeof(rr_req), NULL, 0) < 0)1981			return blogic_failure(adapter,1982					"ENABLE STRICT ROUND ROBIN MODE");1983	}1984 1985	/*1986	   For Host Adapters that support Extended LUN Format CCBs, issue the1987	   Set CCB Format command to allow 32 Logical Units per Target Device.1988	 */1989	if (adapter->ext_lun) {1990		setccb_fmt = BLOGIC_EXT_LUN_CCB;1991		if (blogic_cmd(adapter, BLOGIC_SETCCB_FMT, &setccb_fmt,1992					sizeof(setccb_fmt), NULL, 0) < 0)1993			return blogic_failure(adapter, "SET CCB FORMAT");1994	}1995 1996	/*1997	   Announce Successful Initialization.1998	 */1999done:2000	if (!adapter->adapter_initd) {2001		blogic_info("*** %s Initialized Successfully ***\n", adapter,2002				adapter->full_model);2003		blogic_info("\n", adapter);2004	} else2005		blogic_warn("*** %s Initialized Successfully ***\n", adapter,2006				adapter->full_model);2007	adapter->adapter_initd = true;2008 2009	/*2010	   Indicate the Host Adapter Initialization completed successfully.2011	 */2012	return true;2013}2014 2015 2016/*2017  blogic_inquiry inquires about the Target Devices accessible2018  through Host Adapter.2019*/2020 2021static bool __init blogic_inquiry(struct blogic_adapter *adapter)2022{2023	u16 installed_devs;2024	u8 installed_devs0to7[8];2025	struct blogic_setup_info setupinfo;2026	u8 sync_period[BLOGIC_MAXDEV];2027	unsigned char req_replylen;2028	int tgt_id;2029 2030	/*2031	   Wait a few seconds between the Host Adapter Hard Reset which2032	   initiates a SCSI Bus Reset and issuing any SCSI Commands. Some2033	   SCSI devices get confused if they receive SCSI Commands too soon2034	   after a SCSI Bus Reset.2035	 */2036	blogic_delay(adapter->bus_settle_time);2037	/*2038	   FlashPoint Host Adapters do not provide for Target Device Inquiry.2039	 */2040	if (blogic_flashpoint_type(adapter))2041		return true;2042	/*2043	   Inhibit the Target Device Inquiry if requested.2044	 */2045	if (adapter->drvr_opts != NULL && adapter->drvr_opts->stop_tgt_inquiry)2046		return true;2047	/*2048	   Issue the Inquire Target Devices command for host adapters with2049	   firmware version 4.25 or later, or the Inquire Installed Devices2050	   ID 0 to 7 command for older host adapters.  This is necessary to2051	   force Synchronous Transfer Negotiation so that the Inquire Setup2052	   Information and Inquire Synchronous Period commands will return2053	   valid data.  The Inquire Target Devices command is preferable to2054	   Inquire Installed Devices ID 0 to 7 since it only probes Logical2055	   Unit 0 of each Target Device.2056	 */2057	if (strcmp(adapter->fw_ver, "4.25") >= 0) {2058 2059		/*2060		   Issue a Inquire Target Devices command. Inquire Target2061		   Devices only tests Logical Unit 0 of each Target Device2062		   unlike the Inquire Installed Devices commands which test2063		   Logical Units 0 - 7.  Two bytes are returned, where byte2064		   0 bit 0 set indicates that Target Device 0 exists, and so on.2065		 */2066 2067		if (blogic_cmd(adapter, BLOGIC_INQ_DEV, NULL, 0,2068					&installed_devs, sizeof(installed_devs))2069		    != sizeof(installed_devs))2070			return blogic_failure(adapter, "INQUIRE TARGET DEVICES");2071		for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)2072			adapter->tgt_flags[tgt_id].tgt_exists =2073				(installed_devs & (1 << tgt_id) ? true : false);2074	} else {2075 2076		/*2077		   Issue an Inquire Installed Devices command. For each2078		   Target Device, a byte is returned where bit 0 set2079		   indicates that Logical Unit 0 * exists, bit 1 set2080		   indicates that Logical Unit 1 exists, and so on.2081		 */2082 2083		if (blogic_cmd(adapter, BLOGIC_INQ_DEV0TO7, NULL, 0,2084				&installed_devs0to7, sizeof(installed_devs0to7))2085		    != sizeof(installed_devs0to7))2086			return blogic_failure(adapter,2087					"INQUIRE INSTALLED DEVICES ID 0 TO 7");2088		for (tgt_id = 0; tgt_id < 8; tgt_id++)2089			adapter->tgt_flags[tgt_id].tgt_exists =2090				installed_devs0to7[tgt_id] != 0;2091	}2092	/*2093	   Issue the Inquire Setup Information command.2094	 */2095	req_replylen = sizeof(setupinfo);2096	if (blogic_cmd(adapter, BLOGIC_INQ_SETUPINFO, &req_replylen,2097			sizeof(req_replylen), &setupinfo, sizeof(setupinfo))2098	    != sizeof(setupinfo))2099		return blogic_failure(adapter, "INQUIRE SETUP INFORMATION");2100	for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)2101		adapter->sync_offset[tgt_id] = (tgt_id < 8 ? setupinfo.sync0to7[tgt_id].offset : setupinfo.sync8to15[tgt_id - 8].offset);2102	if (strcmp(adapter->fw_ver, "5.06L") >= 0)2103		for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)2104			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));2105	/*2106	   Issue the Inquire Synchronous Period command.2107	 */2108	if (adapter->fw_ver[0] >= '3') {2109 2110		/* Issue a Inquire Synchronous Period command. For each2111		   Target Device, a byte is returned which represents the2112		   Synchronous Transfer Period in units of 10 nanoseconds.2113		 */2114 2115		req_replylen = sizeof(sync_period);2116		if (blogic_cmd(adapter, BLOGIC_INQ_SYNC_PERIOD, &req_replylen,2117				sizeof(req_replylen), &sync_period,2118				sizeof(sync_period)) != sizeof(sync_period))2119			return blogic_failure(adapter,2120					"INQUIRE SYNCHRONOUS PERIOD");2121		for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)2122			adapter->sync_period[tgt_id] = sync_period[tgt_id];2123	} else2124		for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)2125			if (setupinfo.sync0to7[tgt_id].offset > 0)2126				adapter->sync_period[tgt_id] = 20 + 5 * setupinfo.sync0to7[tgt_id].tx_period;2127	/*2128	   Indicate the Target Device Inquiry completed successfully.2129	 */2130	return true;2131}2132 2133/*2134  blogic_inithoststruct initializes the fields in the SCSI Host2135  structure.  The base, io_port, n_io_ports, irq, and dma_channel fields in the2136  SCSI Host structure are intentionally left uninitialized, as this driver2137  handles acquisition and release of these resources explicitly, as well as2138  ensuring exclusive access to the Host Adapter hardware and data structures2139  through explicit acquisition and release of the Host Adapter's Lock.2140*/2141 2142static void __init blogic_inithoststruct(struct blogic_adapter *adapter,2143		struct Scsi_Host *host)2144{2145	host->max_id = adapter->maxdev;2146	host->max_lun = adapter->maxlun;2147	host->max_channel = 0;2148	host->unique_id = adapter->io_addr;2149	host->this_id = adapter->scsi_id;2150	host->can_queue = adapter->drvr_qdepth;2151	host->sg_tablesize = adapter->drvr_sglimit;2152	host->cmd_per_lun = adapter->untag_qdepth;2153}2154 2155/*2156  blogic_slaveconfig will actually set the queue depth on individual2157  scsi devices as they are permanently added to the device chain.  We2158  shamelessly rip off the SelectQueueDepths code to make this work mostly2159  like it used to.  Since we don't get called once at the end of the scan2160  but instead get called for each device, we have to do things a bit2161  differently.2162*/2163static int blogic_slaveconfig(struct scsi_device *dev)2164{2165	struct blogic_adapter *adapter =2166		(struct blogic_adapter *) dev->host->hostdata;2167	int tgt_id = dev->id;2168	int qdepth = adapter->qdepth[tgt_id];2169 2170	if (adapter->tgt_flags[tgt_id].tagq_ok &&2171			(adapter->tagq_ok & (1 << tgt_id))) {2172		if (qdepth == 0)2173			qdepth = BLOGIC_MAX_AUTO_TAG_DEPTH;2174		adapter->qdepth[tgt_id] = qdepth;2175		scsi_change_queue_depth(dev, qdepth);2176	} else {2177		adapter->tagq_ok &= ~(1 << tgt_id);2178		qdepth = adapter->untag_qdepth;2179		adapter->qdepth[tgt_id] = qdepth;2180		scsi_change_queue_depth(dev, qdepth);2181	}2182	qdepth = 0;2183	for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)2184		if (adapter->tgt_flags[tgt_id].tgt_exists)2185			qdepth += adapter->qdepth[tgt_id];2186	if (qdepth > adapter->alloc_ccbs)2187		blogic_create_addlccbs(adapter, qdepth - adapter->alloc_ccbs,2188				false);2189	return 0;2190}2191 2192/*2193  blogic_init probes for BusLogic Host Adapters at the standard2194  I/O Addresses where they may be located, initializing, registering, and2195  reporting the configuration of each BusLogic Host Adapter it finds.  It2196  returns the number of BusLogic Host Adapters successfully initialized and2197  registered.2198*/2199 2200static int __init blogic_init(void)2201{2202	int drvr_optindex = 0, probeindex;2203	struct blogic_adapter *adapter;2204	int ret = 0;2205 2206#ifdef MODULE2207	if (BusLogic)2208		blogic_setup(BusLogic);2209#endif2210 2211	if (blogic_probe_options.noprobe)2212		return -ENODEV;2213	blogic_probeinfo_list =2214	    kcalloc(BLOGIC_MAX_ADAPTERS, sizeof(struct blogic_probeinfo),2215			    GFP_KERNEL);2216	if (blogic_probeinfo_list == NULL) {2217		blogic_err("BusLogic: Unable to allocate Probe Info List\n",2218				NULL);2219		return -ENOMEM;2220	}2221 2222	adapter = kzalloc(sizeof(struct blogic_adapter), GFP_KERNEL);2223	if (adapter == NULL) {2224		kfree(blogic_probeinfo_list);2225		blogic_err("BusLogic: Unable to allocate Prototype Host Adapter\n", NULL);2226		return -ENOMEM;2227	}2228 2229#ifdef MODULE2230	if (BusLogic != NULL)2231		blogic_setup(BusLogic);2232#endif2233	blogic_init_probeinfo_list(adapter);2234	for (probeindex = 0; probeindex < blogic_probeinfo_count; probeindex++) {2235		struct blogic_probeinfo *probeinfo =2236			&blogic_probeinfo_list[probeindex];2237		struct blogic_adapter *myadapter = adapter;2238		struct Scsi_Host *host;2239 2240		if (probeinfo->io_addr == 0)2241			continue;2242		memset(myadapter, 0, sizeof(struct blogic_adapter));2243		myadapter->adapter_type = probeinfo->adapter_type;2244		myadapter->adapter_bus_type = probeinfo->adapter_bus_type;2245		myadapter->io_addr = probeinfo->io_addr;2246		myadapter->pci_addr = probeinfo->pci_addr;2247		myadapter->bus = probeinfo->bus;2248		myadapter->dev = probeinfo->dev;2249		myadapter->pci_device = probeinfo->pci_device;2250		myadapter->irq_ch = probeinfo->irq_ch;2251		myadapter->addr_count =2252			blogic_adapter_addr_count[myadapter->adapter_type];2253 2254		/*2255		   Make sure region is free prior to probing.2256		 */2257		if (!request_region(myadapter->io_addr, myadapter->addr_count,2258					"BusLogic"))2259			continue;2260		/*2261		   Probe the Host Adapter. If unsuccessful, abort further2262		   initialization.2263		 */2264		if (!blogic_probe(myadapter)) {2265			release_region(myadapter->io_addr,2266					myadapter->addr_count);2267			continue;2268		}2269		/*2270		   Hard Reset the Host Adapter.  If unsuccessful, abort further2271		   initialization.2272		 */2273		if (!blogic_hwreset(myadapter, true)) {2274			release_region(myadapter->io_addr,2275					myadapter->addr_count);2276			continue;2277		}2278		/*2279		   Check the Host Adapter.  If unsuccessful, abort further2280		   initialization.2281		 */2282		if (!blogic_checkadapter(myadapter)) {2283			release_region(myadapter->io_addr,2284					myadapter->addr_count);2285			continue;2286		}2287		/*2288		   Initialize the Driver Options field if provided.2289		 */2290		if (drvr_optindex < blogic_drvr_options_count)2291			myadapter->drvr_opts =2292				&blogic_drvr_options[drvr_optindex++];2293		/*2294		   Announce the Driver Version and Date, Author's Name,2295		   Copyright Notice, and Electronic Mail Address.2296		 */2297		blogic_announce_drvr(myadapter);2298		/*2299		   Register the SCSI Host structure.2300		 */2301 2302		host = scsi_host_alloc(&blogic_template,2303				sizeof(struct blogic_adapter));2304		if (host == NULL) {2305			release_region(myadapter->io_addr,2306					myadapter->addr_count);2307			continue;2308		}2309		myadapter = (struct blogic_adapter *) host->hostdata;2310		memcpy(myadapter, adapter, sizeof(struct blogic_adapter));2311		myadapter->scsi_host = host;2312		myadapter->host_no = host->host_no;2313		/*2314		   Add Host Adapter to the end of the list of registered2315		   BusLogic Host Adapters.2316		 */2317		list_add_tail(&myadapter->host_list, &blogic_host_list);2318 2319		/*2320		   Read the Host Adapter Configuration, Configure the Host2321		   Adapter, Acquire the System Resources necessary to use2322		   the Host Adapter, then Create the Initial CCBs, Initialize2323		   the Host Adapter, and finally perform Target Device2324		   Inquiry. From this point onward, any failure will be2325		   assumed to be due to a problem with the Host Adapter,2326		   rather than due to having mistakenly identified this port2327		   as belonging to a BusLogic Host Adapter. The I/O Address2328		   range will not be released, thereby preventing it from2329		   being incorrectly identified as any other type of Host2330		   Adapter.2331		 */2332		if (blogic_rdconfig(myadapter) &&2333		    blogic_reportconfig(myadapter) &&2334		    blogic_getres(myadapter) &&2335		    blogic_create_initccbs(myadapter) &&2336		    blogic_initadapter(myadapter) &&2337		    blogic_inquiry(myadapter)) {2338			/*2339			   Initialization has been completed successfully.2340			   Release and re-register usage of the I/O Address2341			   range so that the Model Name of the Host Adapter2342			   will appear, and initialize the SCSI Host structure.2343			 */2344			release_region(myadapter->io_addr,2345				       myadapter->addr_count);2346			if (!request_region(myadapter->io_addr,2347					    myadapter->addr_count,2348					    myadapter->full_model)) {2349				printk(KERN_WARNING2350					"BusLogic: Release and re-register of "2351					"port 0x%04lx failed \n",2352					(unsigned long)myadapter->io_addr);2353				blogic_destroy_ccbs(myadapter);2354				blogic_relres(myadapter);2355				list_del(&myadapter->host_list);2356				scsi_host_put(host);2357				ret = -ENOMEM;2358			} else {2359				blogic_inithoststruct(myadapter,2360								 host);2361				if (scsi_add_host(host, myadapter->pci_device2362						? &myadapter->pci_device->dev2363						  : NULL)) {2364					printk(KERN_WARNING2365					       "BusLogic: scsi_add_host()"2366					       "failed!\n");2367					blogic_destroy_ccbs(myadapter);2368					blogic_relres(myadapter);2369					list_del(&myadapter->host_list);2370					scsi_host_put(host);2371					ret = -ENODEV;2372				} else2373					scsi_scan_host(host);2374			}2375		} else {2376			/*2377			   An error occurred during Host Adapter Configuration2378			   Querying, Host Adapter Configuration, Resource2379			   Acquisition, CCB Creation, Host Adapter2380			   Initialization, or Target Device Inquiry, so2381			   remove Host Adapter from the list of registered2382			   BusLogic Host Adapters, destroy the CCBs, Release2383			   the System Resources, and Unregister the SCSI2384			   Host.2385			 */2386			blogic_destroy_ccbs(myadapter);2387			blogic_relres(myadapter);2388			list_del(&myadapter->host_list);2389			scsi_host_put(host);2390			ret = -ENODEV;2391		}2392	}2393	kfree(adapter);2394	kfree(blogic_probeinfo_list);2395	blogic_probeinfo_list = NULL;2396	return ret;2397}2398 2399 2400/*2401  blogic_deladapter releases all resources previously acquired to2402  support a specific Host Adapter, including the I/O Address range, and2403  unregisters the BusLogic Host Adapter.2404*/2405 2406static int __exit blogic_deladapter(struct blogic_adapter *adapter)2407{2408	struct Scsi_Host *host = adapter->scsi_host;2409 2410	scsi_remove_host(host);2411 2412	/*2413	   FlashPoint Host Adapters must first be released by the FlashPoint2414	   SCCB Manager.2415	 */2416	if (blogic_flashpoint_type(adapter))2417		FlashPoint_ReleaseHostAdapter(adapter->cardhandle);2418	/*2419	   Destroy the CCBs and release any system resources acquired to2420	   support Host Adapter.2421	 */2422	blogic_destroy_ccbs(adapter);2423	blogic_relres(adapter);2424	/*2425	   Release usage of the I/O Address range.2426	 */2427	release_region(adapter->io_addr, adapter->addr_count);2428	/*2429	   Remove Host Adapter from the list of registered BusLogic2430	   Host Adapters.2431	 */2432	list_del(&adapter->host_list);2433 2434	scsi_host_put(host);2435	return 0;2436}2437 2438 2439/*2440  blogic_qcompleted_ccb queues CCB for completion processing.2441*/2442 2443static void blogic_qcompleted_ccb(struct blogic_ccb *ccb)2444{2445	struct blogic_adapter *adapter = ccb->adapter;2446 2447	ccb->status = BLOGIC_CCB_COMPLETE;2448	ccb->next = NULL;2449	if (adapter->firstccb == NULL) {2450		adapter->firstccb = ccb;2451		adapter->lastccb = ccb;2452	} else {2453		adapter->lastccb->next = ccb;2454		adapter->lastccb = ccb;2455	}2456	adapter->active_cmds[ccb->tgt_id]--;2457}2458 2459 2460/*2461  blogic_resultcode computes a SCSI Subsystem Result Code from2462  the Host Adapter Status and Target Device Status.2463*/2464 2465static int blogic_resultcode(struct blogic_adapter *adapter,2466		enum blogic_adapter_status adapter_status,2467		enum blogic_tgt_status tgt_status)2468{2469	int hoststatus;2470 2471	switch (adapter_status) {2472	case BLOGIC_CMD_CMPLT_NORMAL:2473	case BLOGIC_LINK_CMD_CMPLT:2474	case BLOGIC_LINK_CMD_CMPLT_FLAG:2475		hoststatus = DID_OK;2476		break;2477	case BLOGIC_SELECT_TIMEOUT:2478		hoststatus = DID_TIME_OUT;2479		break;2480	case BLOGIC_INVALID_OUTBOX_CODE:2481	case BLOGIC_INVALID_CMD_CODE:2482	case BLOGIC_BAD_CMD_PARAM:2483		blogic_warn("BusLogic Driver Protocol Error 0x%02X\n",2484				adapter, adapter_status);2485		fallthrough;2486	case BLOGIC_DATA_UNDERRUN:2487	case BLOGIC_DATA_OVERRUN:2488	case BLOGIC_NOEXPECT_BUSFREE:2489	case BLOGIC_LINKCCB_BADLUN:2490	case BLOGIC_AUTOREQSENSE_FAIL:2491	case BLOGIC_TAGQUEUE_REJECT:2492	case BLOGIC_BAD_MSG_RCVD:2493	case BLOGIC_HW_FAIL:2494	case BLOGIC_BAD_RECONNECT:2495	case BLOGIC_ABRT_QUEUE:2496	case BLOGIC_ADAPTER_SW_ERROR:2497	case BLOGIC_HW_TIMEOUT:2498	case BLOGIC_PARITY_ERR:2499		hoststatus = DID_ERROR;2500		break;2501	case BLOGIC_INVALID_BUSPHASE:2502	case BLOGIC_NORESPONSE_TO_ATN:2503	case BLOGIC_HW_RESET:2504	case BLOGIC_RST_FROM_OTHERDEV:2505	case BLOGIC_HW_BDR:2506		hoststatus = DID_RESET;2507		break;2508	default:2509		blogic_warn("Unknown Host Adapter Status 0x%02X\n", adapter,2510				adapter_status);2511		hoststatus = DID_ERROR;2512		break;2513	}2514	return (hoststatus << 16) | tgt_status;2515}2516 2517/*2518 * turn the dma address from an inbox into a ccb pointer2519 * This is rather inefficient.2520 */2521static struct blogic_ccb *2522blogic_inbox_to_ccb(struct blogic_adapter *adapter, struct blogic_inbox *inbox)2523{2524	struct blogic_ccb *ccb;2525 2526	for (ccb = adapter->all_ccbs; ccb; ccb = ccb->next_all)2527		if (inbox->ccb == ccb->dma_handle)2528			break;2529 2530	return ccb;2531}2532 2533/*2534  blogic_scan_inbox scans the Incoming Mailboxes saving any2535  Incoming Mailbox entries for completion processing.2536*/2537static void blogic_scan_inbox(struct blogic_adapter *adapter)2538{2539	/*2540	   Scan through the Incoming Mailboxes in Strict Round Robin2541	   fashion, saving any completed CCBs for further processing. It2542	   is essential that for each CCB and SCSI Command issued, command2543	   completion processing is performed exactly once.  Therefore,2544	   only Incoming Mailboxes with completion code Command Completed2545	   Without Error, Command Completed With Error, or Command Aborted2546	   At Host Request are saved for completion processing. When an2547	   Incoming Mailbox has a completion code of Aborted Command Not2548	   Found, the CCB had already completed or been aborted before the2549	   current Abort request was processed, and so completion processing2550	   has already occurred and no further action should be taken.2551	 */2552	struct blogic_inbox *next_inbox = adapter->next_inbox;2553	enum blogic_cmplt_code comp_code;2554 2555	while ((comp_code = next_inbox->comp_code) != BLOGIC_INBOX_FREE) {2556		struct blogic_ccb *ccb = blogic_inbox_to_ccb(adapter, next_inbox);2557		if (!ccb) {2558			/*2559			 * This should never happen, unless the CCB list is2560			 * corrupted in memory.2561			 */2562			blogic_warn("Could not find CCB for dma address %x\n", adapter, next_inbox->ccb);2563		} else if (comp_code != BLOGIC_CMD_NOTFOUND) {2564			if (ccb->status == BLOGIC_CCB_ACTIVE ||2565					ccb->status == BLOGIC_CCB_RESET) {2566				/*2567				   Save the Completion Code for this CCB and2568				   queue the CCB for completion processing.2569				 */2570				ccb->comp_code = comp_code;2571				blogic_qcompleted_ccb(ccb);2572			} else {2573				/*2574				   If a CCB ever appears in an Incoming Mailbox2575				   and is not marked as status Active or Reset,2576				   then there is most likely a bug in2577				   the Host Adapter firmware.2578				 */2579				blogic_warn("Illegal CCB #%ld status %d in Incoming Mailbox\n", adapter, ccb->serial, ccb->status);2580			}2581		}2582		next_inbox->comp_code = BLOGIC_INBOX_FREE;2583		if (++next_inbox > adapter->last_inbox)2584			next_inbox = adapter->first_inbox;2585	}2586	adapter->next_inbox = next_inbox;2587}2588 2589 2590/*2591  blogic_process_ccbs iterates over the completed CCBs for Host2592  Adapter setting the SCSI Command Result Codes, deallocating the CCBs, and2593  calling the SCSI Subsystem Completion Routines.  The Host Adapter's Lock2594  should already have been acquired by the caller.2595*/2596 2597static void blogic_process_ccbs(struct blogic_adapter *adapter)2598{2599	if (adapter->processing_ccbs)2600		return;2601	adapter->processing_ccbs = true;2602	while (adapter->firstccb != NULL) {2603		struct blogic_ccb *ccb = adapter->firstccb;2604		struct scsi_cmnd *command = ccb->command;2605		adapter->firstccb = ccb->next;2606		if (adapter->firstccb == NULL)2607			adapter->lastccb = NULL;2608		/*2609		   Process the Completed CCB.2610		 */2611		if (ccb->opcode == BLOGIC_BDR) {2612			int tgt_id = ccb->tgt_id;2613 2614			blogic_warn("Bus Device Reset CCB #%ld to Target %d Completed\n", adapter, ccb->serial, tgt_id);2615			blogic_inc_count(&adapter->tgt_stats[tgt_id].bdr_done);2616			adapter->tgt_flags[tgt_id].tagq_active = false;2617			adapter->cmds_since_rst[tgt_id] = 0;2618			adapter->last_resetdone[tgt_id] = jiffies;2619			/*2620			   Place CCB back on the Host Adapter's free list.2621			 */2622			blogic_dealloc_ccb(ccb, 1);2623#if 0			/* this needs to be redone different for new EH */2624			/*2625			   Bus Device Reset CCBs have the command field2626			   non-NULL only when a Bus Device Reset was requested2627			   for a command that did not have a currently active2628			   CCB in the Host Adapter (i.e., a Synchronous Bus2629			   Device Reset), and hence would not have its2630			   Completion Routine called otherwise.2631			 */2632			while (command != NULL) {2633				struct scsi_cmnd *nxt_cmd =2634					command->reset_chain;2635				command->reset_chain = NULL;2636				command->result = DID_RESET << 16;2637				scsi_done(command);2638				command = nxt_cmd;2639			}2640#endif2641			/*2642			   Iterate over the CCBs for this Host Adapter2643			   performing completion processing for any CCBs2644			   marked as Reset for this Target.2645			 */2646			for (ccb = adapter->all_ccbs; ccb != NULL;2647					ccb = ccb->next_all)2648				if (ccb->status == BLOGIC_CCB_RESET &&2649						ccb->tgt_id == tgt_id) {2650					command = ccb->command;2651					blogic_dealloc_ccb(ccb, 1);2652					adapter->active_cmds[tgt_id]--;2653					command->result = DID_RESET << 16;2654					scsi_done(command);2655				}2656			adapter->bdr_pend[tgt_id] = NULL;2657		} else {2658			/*2659			   Translate the Completion Code, Host Adapter Status,2660			   and Target Device Status into a SCSI Subsystem2661			   Result Code.2662			 */2663			switch (ccb->comp_code) {2664			case BLOGIC_INBOX_FREE:2665			case BLOGIC_CMD_NOTFOUND:2666			case BLOGIC_INVALID_CCB:2667				blogic_warn("CCB #%ld to Target %d Impossible State\n", adapter, ccb->serial, ccb->tgt_id);2668				break;2669			case BLOGIC_CMD_COMPLETE_GOOD:2670				adapter->tgt_stats[ccb->tgt_id]2671				    .cmds_complete++;2672				adapter->tgt_flags[ccb->tgt_id]2673				    .cmd_good = true;2674				command->result = DID_OK << 16;2675				break;2676			case BLOGIC_CMD_ABORT_BY_HOST:2677				blogic_warn("CCB #%ld to Target %d Aborted\n",2678					adapter, ccb->serial, ccb->tgt_id);2679				blogic_inc_count(&adapter->tgt_stats[ccb->tgt_id].aborts_done);2680				command->result = DID_ABORT << 16;2681				break;2682			case BLOGIC_CMD_COMPLETE_ERROR:2683				command->result = blogic_resultcode(adapter,2684					ccb->adapter_status, ccb->tgt_status);2685				if (ccb->adapter_status != BLOGIC_SELECT_TIMEOUT) {2686					adapter->tgt_stats[ccb->tgt_id]2687					    .cmds_complete++;2688					if (blogic_global_options.trace_err) {2689						int i;2690						blogic_notice("CCB #%ld Target %d: Result %X Host "2691								"Adapter Status %02X Target Status %02X\n", adapter, ccb->serial, ccb->tgt_id, command->result, ccb->adapter_status, ccb->tgt_status);2692						blogic_notice("CDB   ", adapter);2693						for (i = 0; i < ccb->cdblen; i++)2694							blogic_notice(" %02X", adapter, ccb->cdb[i]);2695						blogic_notice("\n", adapter);2696						blogic_notice("Sense ", adapter);2697						for (i = 0; i < ccb->sense_datalen; i++)2698							blogic_notice(" %02X", adapter, command->sense_buffer[i]);2699						blogic_notice("\n", adapter);2700					}2701				}2702				break;2703			}2704			/*2705			   When an INQUIRY command completes normally, save the2706			   CmdQue (Tagged Queuing Supported) and WBus16 (16 Bit2707			   Wide Data Transfers Supported) bits.2708			 */2709			if (ccb->cdb[0] == INQUIRY && ccb->cdb[1] == 0 &&2710				ccb->adapter_status == BLOGIC_CMD_CMPLT_NORMAL) {2711				struct blogic_tgt_flags *tgt_flags =2712					&adapter->tgt_flags[ccb->tgt_id];2713				struct scsi_inquiry *inquiry =2714					(struct scsi_inquiry *) scsi_sglist(command);2715				tgt_flags->tgt_exists = true;2716				tgt_flags->tagq_ok = inquiry->CmdQue;2717				tgt_flags->wide_ok = inquiry->WBus16;2718			}2719			/*2720			   Place CCB back on the Host Adapter's free list.2721			 */2722			blogic_dealloc_ccb(ccb, 1);2723			/*2724			   Call the SCSI Command Completion Routine.2725			 */2726			scsi_done(command);2727		}2728	}2729	adapter->processing_ccbs = false;2730}2731 2732 2733/*2734  blogic_inthandler handles hardware interrupts from BusLogic Host2735  Adapters.2736*/2737 2738static irqreturn_t blogic_inthandler(int irq_ch, void *devid)2739{2740	struct blogic_adapter *adapter = (struct blogic_adapter *) devid;2741	unsigned long processor_flag;2742	/*2743	   Acquire exclusive access to Host Adapter.2744	 */2745	spin_lock_irqsave(adapter->scsi_host->host_lock, processor_flag);2746	/*2747	   Handle Interrupts appropriately for each Host Adapter type.2748	 */2749	if (blogic_multimaster_type(adapter)) {2750		union blogic_int_reg intreg;2751		/*2752		   Read the Host Adapter Interrupt Register.2753		 */2754		intreg.all = blogic_rdint(adapter);2755		if (intreg.ir.int_valid) {2756			/*2757			   Acknowledge the interrupt and reset the Host Adapter2758			   Interrupt Register.2759			 */2760			blogic_intreset(adapter);2761			/*2762			   Process valid External SCSI Bus Reset and Incoming2763			   Mailbox Loaded Interrupts. Command Complete2764			   Interrupts are noted, and Outgoing Mailbox Available2765			   Interrupts are ignored, as they are never enabled.2766			 */2767			if (intreg.ir.ext_busreset)2768				adapter->adapter_extreset = true;2769			else if (intreg.ir.mailin_loaded)2770				blogic_scan_inbox(adapter);2771			else if (intreg.ir.cmd_complete)2772				adapter->adapter_cmd_complete = true;2773		}2774	} else {2775		/*2776		   Check if there is a pending interrupt for this Host Adapter.2777		 */2778		if (FlashPoint_InterruptPending(adapter->cardhandle))2779			switch (FlashPoint_HandleInterrupt(adapter->cardhandle)) {2780			case FPOINT_NORMAL_INT:2781				break;2782			case FPOINT_EXT_RESET:2783				adapter->adapter_extreset = true;2784				break;2785			case FPOINT_INTERN_ERR:2786				blogic_warn("Internal FlashPoint Error detected - Resetting Host Adapter\n", adapter);2787				adapter->adapter_intern_err = true;2788				break;2789			}2790	}2791	/*2792	   Process any completed CCBs.2793	 */2794	if (adapter->firstccb != NULL)2795		blogic_process_ccbs(adapter);2796	/*2797	   Reset the Host Adapter if requested.2798	 */2799	if (adapter->adapter_extreset) {2800		blogic_warn("Resetting %s due to External SCSI Bus Reset\n", adapter, adapter->full_model);2801		blogic_inc_count(&adapter->ext_resets);2802		blogic_resetadapter(adapter, false);2803		adapter->adapter_extreset = false;2804	} else if (adapter->adapter_intern_err) {2805		blogic_warn("Resetting %s due to Host Adapter Internal Error\n", adapter, adapter->full_model);2806		blogic_inc_count(&adapter->adapter_intern_errors);2807		blogic_resetadapter(adapter, true);2808		adapter->adapter_intern_err = false;2809	}2810	/*2811	   Release exclusive access to Host Adapter.2812	 */2813	spin_unlock_irqrestore(adapter->scsi_host->host_lock, processor_flag);2814	return IRQ_HANDLED;2815}2816 2817 2818/*2819  blogic_write_outbox places CCB and Action Code into an Outgoing2820  Mailbox for execution by Host Adapter.  The Host Adapter's Lock should2821  already have been acquired by the caller.2822*/2823 2824static bool blogic_write_outbox(struct blogic_adapter *adapter,2825		enum blogic_action action, struct blogic_ccb *ccb)2826{2827	struct blogic_outbox *next_outbox;2828 2829	next_outbox = adapter->next_outbox;2830	if (next_outbox->action == BLOGIC_OUTBOX_FREE) {2831		ccb->status = BLOGIC_CCB_ACTIVE;2832		/*2833		   The CCB field must be written before the Action Code field2834		   since the Host Adapter is operating asynchronously and the2835		   locking code does not protect against simultaneous access2836		   by the Host Adapter.2837		 */2838		next_outbox->ccb = ccb->dma_handle;2839		next_outbox->action = action;2840		blogic_execmbox(adapter);2841		if (++next_outbox > adapter->last_outbox)2842			next_outbox = adapter->first_outbox;2843		adapter->next_outbox = next_outbox;2844		if (action == BLOGIC_MBOX_START) {2845			adapter->active_cmds[ccb->tgt_id]++;2846			if (ccb->opcode != BLOGIC_BDR)2847				adapter->tgt_stats[ccb->tgt_id].cmds_tried++;2848		}2849		return true;2850	}2851	return false;2852}2853 2854/* Error Handling (EH) support */2855 2856static int blogic_hostreset(struct scsi_cmnd *SCpnt)2857{2858	struct blogic_adapter *adapter =2859		(struct blogic_adapter *) SCpnt->device->host->hostdata;2860 2861	unsigned int id = SCpnt->device->id;2862	struct blogic_tgt_stats *stats = &adapter->tgt_stats[id];2863	int rc;2864 2865	spin_lock_irq(SCpnt->device->host->host_lock);2866 2867	blogic_inc_count(&stats->adapter_reset_req);2868 2869	rc = blogic_resetadapter(adapter, false);2870	spin_unlock_irq(SCpnt->device->host->host_lock);2871	return rc;2872}2873 2874/*2875  blogic_qcmd creates a CCB for Command and places it into an2876  Outgoing Mailbox for execution by the associated Host Adapter.2877*/2878 2879static int blogic_qcmd_lck(struct scsi_cmnd *command)2880{2881	void (*comp_cb)(struct scsi_cmnd *) = scsi_done;2882	struct blogic_adapter *adapter =2883		(struct blogic_adapter *) command->device->host->hostdata;2884	struct blogic_tgt_flags *tgt_flags =2885		&adapter->tgt_flags[command->device->id];2886	struct blogic_tgt_stats *tgt_stats = adapter->tgt_stats;2887	unsigned char *cdb = command->cmnd;2888	int cdblen = command->cmd_len;2889	int tgt_id = command->device->id;2890	int lun = command->device->lun;2891	int buflen = scsi_bufflen(command);2892	int count;2893	struct blogic_ccb *ccb;2894	dma_addr_t sense_buf;2895 2896	/*2897	   SCSI REQUEST_SENSE commands will be executed automatically by the2898	   Host Adapter for any errors, so they should not be executed2899	   explicitly unless the Sense Data is zero indicating that no error2900	   occurred.2901	 */2902	if (cdb[0] == REQUEST_SENSE && command->sense_buffer[0] != 0) {2903		command->result = DID_OK << 16;2904		comp_cb(command);2905		return 0;2906	}2907	/*2908	   Allocate a CCB from the Host Adapter's free list. In the unlikely2909	   event that there are none available and memory allocation fails,2910	   wait 1 second and try again. If that fails, the Host Adapter is2911	   probably hung so signal an error as a Host Adapter Hard Reset2912	   should be initiated soon.2913	 */2914	ccb = blogic_alloc_ccb(adapter);2915	if (ccb == NULL) {2916		spin_unlock_irq(adapter->scsi_host->host_lock);2917		blogic_delay(1);2918		spin_lock_irq(adapter->scsi_host->host_lock);2919		ccb = blogic_alloc_ccb(adapter);2920		if (ccb == NULL) {2921			command->result = DID_ERROR << 16;2922			comp_cb(command);2923			return 0;2924		}2925	}2926 2927	/*2928	   Initialize the fields in the BusLogic Command Control Block (CCB).2929	 */2930	count = scsi_dma_map(command);2931	BUG_ON(count < 0);2932	if (count) {2933		struct scatterlist *sg;2934		int i;2935 2936		ccb->opcode = BLOGIC_INITIATOR_CCB_SG;2937		ccb->datalen = count * sizeof(struct blogic_sg_seg);2938		if (blogic_multimaster_type(adapter))2939			ccb->data = (unsigned int) ccb->dma_handle +2940					((unsigned long) &ccb->sglist -2941					(unsigned long) ccb);2942		else2943			ccb->data = virt_to_32bit_virt(ccb->sglist);2944 2945		scsi_for_each_sg(command, sg, count, i) {2946			ccb->sglist[i].segbytes = sg_dma_len(sg);2947			ccb->sglist[i].segdata = sg_dma_address(sg);2948		}2949	} else if (!count) {2950		ccb->opcode = BLOGIC_INITIATOR_CCB;2951		ccb->datalen = buflen;2952		ccb->data = 0;2953	}2954 2955	switch (cdb[0]) {2956	case READ_6:2957	case READ_10:2958		ccb->datadir = BLOGIC_DATAIN_CHECKED;2959		tgt_stats[tgt_id].read_cmds++;2960		blogic_addcount(&tgt_stats[tgt_id].bytesread, buflen);2961		blogic_incszbucket(tgt_stats[tgt_id].read_sz_buckets, buflen);2962		break;2963	case WRITE_6:2964	case WRITE_10:2965		ccb->datadir = BLOGIC_DATAOUT_CHECKED;2966		tgt_stats[tgt_id].write_cmds++;2967		blogic_addcount(&tgt_stats[tgt_id].byteswritten, buflen);2968		blogic_incszbucket(tgt_stats[tgt_id].write_sz_buckets, buflen);2969		break;2970	default:2971		ccb->datadir = BLOGIC_UNCHECKED_TX;2972		break;2973	}2974	ccb->cdblen = cdblen;2975	ccb->adapter_status = 0;2976	ccb->tgt_status = 0;2977	ccb->tgt_id = tgt_id;2978	ccb->lun = lun;2979	ccb->tag_enable = false;2980	ccb->legacytag_enable = false;2981	/*2982	   BusLogic recommends that after a Reset the first couple of2983	   commands that are sent to a Target Device be sent in a non2984	   Tagged Queue fashion so that the Host Adapter and Target Device2985	   can establish Synchronous and Wide Transfer before Queue Tag2986	   messages can interfere with the Synchronous and Wide Negotiation2987	   messages.  By waiting to enable Tagged Queuing until after the2988	   first BLOGIC_MAX_TAG_DEPTH commands have been queued, it is2989	   assured that after a Reset any pending commands are requeued2990	   before Tagged Queuing is enabled and that the Tagged Queuing2991	   message will not occur while the partition table is being printed.2992	   In addition, some devices do not properly handle the transition2993	   from non-tagged to tagged commands, so it is necessary to wait2994	   until there are no pending commands for a target device2995	   before queuing tagged commands.2996	 */2997	if (adapter->cmds_since_rst[tgt_id]++ >= BLOGIC_MAX_TAG_DEPTH &&2998			!tgt_flags->tagq_active &&2999			adapter->active_cmds[tgt_id] == 03000			&& tgt_flags->tagq_ok &&3001			(adapter->tagq_ok & (1 << tgt_id))) {3002		tgt_flags->tagq_active = true;3003		blogic_notice("Tagged Queuing now active for Target %d\n",3004					adapter, tgt_id);3005	}3006	if (tgt_flags->tagq_active) {3007		enum blogic_queuetag queuetag = BLOGIC_SIMPLETAG;3008		/*3009		   When using Tagged Queuing with Simple Queue Tags, it3010		   appears that disk drive controllers do not guarantee that3011		   a queued command will not remain in a disconnected state3012		   indefinitely if commands that read or write nearer the3013		   head position continue to arrive without interruption.3014		   Therefore, for each Target Device this driver keeps track3015		   of the last time either the queue was empty or an Ordered3016		   Queue Tag was issued. If more than 4 seconds (one fifth3017		   of the 20 second disk timeout) have elapsed since this3018		   last sequence point, this command will be issued with an3019		   Ordered Queue Tag rather than a Simple Queue Tag, which3020		   forces the Target Device to complete all previously3021		   queued commands before this command may be executed.3022		 */3023		if (adapter->active_cmds[tgt_id] == 0)3024			adapter->last_seqpoint[tgt_id] = jiffies;3025		else if (time_after(jiffies,3026				adapter->last_seqpoint[tgt_id] + 4 * HZ)) {3027			adapter->last_seqpoint[tgt_id] = jiffies;3028			queuetag = BLOGIC_ORDEREDTAG;3029		}3030		if (adapter->ext_lun) {3031			ccb->tag_enable = true;3032			ccb->queuetag = queuetag;3033		} else {3034			ccb->legacytag_enable = true;3035			ccb->legacy_tag = queuetag;3036		}3037	}3038	memcpy(ccb->cdb, cdb, cdblen);3039	ccb->sense_datalen = SCSI_SENSE_BUFFERSIZE;3040	ccb->command = command;3041	sense_buf = dma_map_single(&adapter->pci_device->dev,3042				command->sense_buffer, ccb->sense_datalen,3043				DMA_FROM_DEVICE);3044	if (dma_mapping_error(&adapter->pci_device->dev, sense_buf)) {3045		blogic_err("DMA mapping for sense data buffer failed\n",3046				adapter);3047		blogic_dealloc_ccb(ccb, 0);3048		return SCSI_MLQUEUE_HOST_BUSY;3049	}3050	ccb->sensedata = sense_buf;3051	if (blogic_multimaster_type(adapter)) {3052		/*3053		   Place the CCB in an Outgoing Mailbox. The higher levels3054		   of the SCSI Subsystem should not attempt to queue more3055		   commands than can be placed in Outgoing Mailboxes, so3056		   there should always be one free.  In the unlikely event3057		   that there are none available, wait 1 second and try3058		   again. If that fails, the Host Adapter is probably hung3059		   so signal an error as a Host Adapter Hard Reset should3060		   be initiated soon.3061		 */3062		if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START, ccb)) {3063			spin_unlock_irq(adapter->scsi_host->host_lock);3064			blogic_warn("Unable to write Outgoing Mailbox - Pausing for 1 second\n", adapter);3065			blogic_delay(1);3066			spin_lock_irq(adapter->scsi_host->host_lock);3067			if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START,3068						ccb)) {3069				blogic_warn("Still unable to write Outgoing Mailbox - Host Adapter Dead?\n", adapter);3070				blogic_dealloc_ccb(ccb, 1);3071				command->result = DID_ERROR << 16;3072				scsi_done(command);3073			}3074		}3075	} else {3076		/*3077		   Call the FlashPoint SCCB Manager to start execution of3078		   the CCB.3079		 */3080		ccb->status = BLOGIC_CCB_ACTIVE;3081		adapter->active_cmds[tgt_id]++;3082		tgt_stats[tgt_id].cmds_tried++;3083		FlashPoint_StartCCB(adapter->cardhandle, ccb);3084		/*3085		   The Command may have already completed and3086		   blogic_qcompleted_ccb been called, or it may still be3087		   pending.3088		 */3089		if (ccb->status == BLOGIC_CCB_COMPLETE)3090			blogic_process_ccbs(adapter);3091	}3092	return 0;3093}3094 3095static DEF_SCSI_QCMD(blogic_qcmd)3096 3097#if 03098/*3099  blogic_abort aborts Command if possible.3100*/3101 3102static int blogic_abort(struct scsi_cmnd *command)3103{3104	struct blogic_adapter *adapter =3105		(struct blogic_adapter *) command->device->host->hostdata;3106 3107	int tgt_id = command->device->id;3108	struct blogic_ccb *ccb;3109	blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_request);3110 3111	/*3112	   Attempt to find an Active CCB for this Command. If no Active3113	   CCB for this Command is found, then no Abort is necessary.3114	 */3115	for (ccb = adapter->all_ccbs; ccb != NULL; ccb = ccb->next_all)3116		if (ccb->command == command)3117			break;3118	if (ccb == NULL) {3119		blogic_warn("Unable to Abort Command to Target %d - No CCB Found\n", adapter, tgt_id);3120		return SUCCESS;3121	} else if (ccb->status == BLOGIC_CCB_COMPLETE) {3122		blogic_warn("Unable to Abort Command to Target %d - CCB Completed\n", adapter, tgt_id);3123		return SUCCESS;3124	} else if (ccb->status == BLOGIC_CCB_RESET) {3125		blogic_warn("Unable to Abort Command to Target %d - CCB Reset\n", adapter, tgt_id);3126		return SUCCESS;3127	}3128	if (blogic_multimaster_type(adapter)) {3129		/*3130		   Attempt to Abort this CCB.  MultiMaster Firmware versions3131		   prior to 5.xx do not generate Abort Tag messages, but only3132		   generate the non-tagged Abort message.  Since non-tagged3133		   commands are not sent by the Host Adapter until the queue3134		   of outstanding tagged commands has completed, and the3135		   Abort message is treated as a non-tagged command, it is3136		   effectively impossible to abort commands when Tagged3137		   Queuing is active. Firmware version 5.xx does generate3138		   Abort Tag messages, so it is possible to abort commands3139		   when Tagged Queuing is active.3140		 */3141		if (adapter->tgt_flags[tgt_id].tagq_active &&3142				adapter->fw_ver[0] < '5') {3143			blogic_warn("Unable to Abort CCB #%ld to Target %d - Abort Tag Not Supported\n", adapter, ccb->serial, tgt_id);3144			return FAILURE;3145		} else if (blogic_write_outbox(adapter, BLOGIC_MBOX_ABORT,3146					ccb)) {3147			blogic_warn("Aborting CCB #%ld to Target %d\n",3148					adapter, ccb->serial, tgt_id);3149			blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_tried);3150			return SUCCESS;3151		} else {3152			blogic_warn("Unable to Abort CCB #%ld to Target %d - No Outgoing Mailboxes\n", adapter, ccb->serial, tgt_id);3153			return FAILURE;3154		}3155	} else {3156		/*3157		   Call the FlashPoint SCCB Manager to abort execution of3158		   the CCB.3159		 */3160		blogic_warn("Aborting CCB #%ld to Target %d\n", adapter,3161				ccb->serial, tgt_id);3162		blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_tried);3163		FlashPoint_AbortCCB(adapter->cardhandle, ccb);3164		/*3165		   The Abort may have already been completed and3166		   blogic_qcompleted_ccb been called, or it3167		   may still be pending.3168		 */3169		if (ccb->status == BLOGIC_CCB_COMPLETE)3170			blogic_process_ccbs(adapter);3171		return SUCCESS;3172	}3173	return SUCCESS;3174}3175 3176#endif3177/*3178  blogic_resetadapter resets Host Adapter if possible, marking all3179  currently executing SCSI Commands as having been Reset.3180*/3181 3182static int blogic_resetadapter(struct blogic_adapter *adapter, bool hard_reset)3183{3184	struct blogic_ccb *ccb;3185	int tgt_id;3186 3187	/*3188	 * Attempt to Reset and Reinitialize the Host Adapter.3189	 */3190 3191	if (!(blogic_hwreset(adapter, hard_reset) &&3192				blogic_initadapter(adapter))) {3193		blogic_err("Resetting %s Failed\n", adapter,3194						adapter->full_model);3195		return FAILURE;3196	}3197 3198	/*3199	 * Deallocate all currently executing CCBs.3200	 */3201 3202	for (ccb = adapter->all_ccbs; ccb != NULL; ccb = ccb->next_all)3203		if (ccb->status == BLOGIC_CCB_ACTIVE)3204			blogic_dealloc_ccb(ccb, 1);3205	/*3206	 * Wait a few seconds between the Host Adapter Hard Reset which3207	 * initiates a SCSI Bus Reset and issuing any SCSI Commands.  Some3208	 * SCSI devices get confused if they receive SCSI Commands too soon3209	 * after a SCSI Bus Reset.3210	 */3211 3212	if (hard_reset) {3213		spin_unlock_irq(adapter->scsi_host->host_lock);3214		blogic_delay(adapter->bus_settle_time);3215		spin_lock_irq(adapter->scsi_host->host_lock);3216	}3217 3218	for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) {3219		adapter->last_resettried[tgt_id] = jiffies;3220		adapter->last_resetdone[tgt_id] = jiffies;3221	}3222	return SUCCESS;3223}3224 3225/*3226  blogic_diskparam returns the Heads/Sectors/Cylinders BIOS Disk3227  Parameters for Disk.  The default disk geometry is 64 heads, 32 sectors, and3228  the appropriate number of cylinders so as not to exceed drive capacity.  In3229  order for disks equal to or larger than 1 GB to be addressable by the BIOS3230  without exceeding the BIOS limitation of 1024 cylinders, Extended Translation3231  may be enabled in AutoSCSI on FlashPoint Host Adapters and on "W" and "C"3232  series MultiMaster Host Adapters, or by a dip switch setting on "S" and "A"3233  series MultiMaster Host Adapters.  With Extended Translation enabled, drives3234  between 1 GB inclusive and 2 GB exclusive are given a disk geometry of 1283235  heads and 32 sectors, and drives above 2 GB inclusive are given a disk3236  geometry of 255 heads and 63 sectors.  However, if the BIOS detects that the3237  Extended Translation setting does not match the geometry in the partition3238  table, then the translation inferred from the partition table will be used by3239  the BIOS, and a warning may be displayed.3240*/3241 3242static int blogic_diskparam(struct scsi_device *sdev, struct block_device *dev,3243		sector_t capacity, int *params)3244{3245	struct blogic_adapter *adapter =3246				(struct blogic_adapter *) sdev->host->hostdata;3247	struct bios_diskparam *diskparam = (struct bios_diskparam *) params;3248	unsigned char *buf;3249 3250	if (adapter->ext_trans_enable && capacity >= 2 * 1024 * 1024 /* 1 GB in 512 byte sectors */) {3251		if (capacity >= 4 * 1024 * 1024 /* 2 GB in 512 byte sectors */) {3252			diskparam->heads = 255;3253			diskparam->sectors = 63;3254		} else {3255			diskparam->heads = 128;3256			diskparam->sectors = 32;3257		}3258	} else {3259		diskparam->heads = 64;3260		diskparam->sectors = 32;3261	}3262	diskparam->cylinders = (unsigned long) capacity / (diskparam->heads * diskparam->sectors);3263	buf = scsi_bios_ptable(dev);3264	if (buf == NULL)3265		return 0;3266	/*3267	   If the boot sector partition table flag is valid, search for3268	   a partition table entry whose end_head matches one of the3269	   standard BusLogic geometry translations (64/32, 128/32, or 255/63).3270	 */3271	if (*(unsigned short *) (buf + 64) == MSDOS_LABEL_MAGIC) {3272		struct msdos_partition *part1_entry =3273				(struct msdos_partition *)buf;3274		struct msdos_partition *part_entry = part1_entry;3275		int saved_cyl = diskparam->cylinders, part_no;3276		unsigned char part_end_head = 0, part_end_sector = 0;3277 3278		for (part_no = 0; part_no < 4; part_no++) {3279			part_end_head = part_entry->end_head;3280			part_end_sector = part_entry->end_sector & 0x3F;3281			if (part_end_head == 64 - 1) {3282				diskparam->heads = 64;3283				diskparam->sectors = 32;3284				break;3285			} else if (part_end_head == 128 - 1) {3286				diskparam->heads = 128;3287				diskparam->sectors = 32;3288				break;3289			} else if (part_end_head == 255 - 1) {3290				diskparam->heads = 255;3291				diskparam->sectors = 63;3292				break;3293			}3294			part_entry++;3295		}3296		if (part_no == 4) {3297			part_end_head = part1_entry->end_head;3298			part_end_sector = part1_entry->end_sector & 0x3F;3299		}3300		diskparam->cylinders = (unsigned long) capacity / (diskparam->heads * diskparam->sectors);3301		if (part_no < 4 && part_end_sector == diskparam->sectors) {3302			if (diskparam->cylinders != saved_cyl)3303				blogic_warn("Adopting Geometry %d/%d from Partition Table\n", adapter, diskparam->heads, diskparam->sectors);3304		} else if (part_end_head > 0 || part_end_sector > 0) {3305			blogic_warn("Warning: Partition Table appears to have Geometry %d/%d which is\n", adapter, part_end_head + 1, part_end_sector);3306			blogic_warn("not compatible with current BusLogic Host Adapter Geometry %d/%d\n", adapter, diskparam->heads, diskparam->sectors);3307		}3308	}3309	kfree(buf);3310	return 0;3311}3312 3313 3314/*3315  BugLogic_ProcDirectoryInfo implements /proc/scsi/BusLogic/<N>.3316*/3317 3318static int blogic_write_info(struct Scsi_Host *shost, char *procbuf,3319				int bytes_avail)3320{3321	struct blogic_adapter *adapter =3322				(struct blogic_adapter *) shost->hostdata;3323	struct blogic_tgt_stats *tgt_stats;3324 3325	tgt_stats = adapter->tgt_stats;3326	adapter->ext_resets = 0;3327	adapter->adapter_intern_errors = 0;3328	memset(tgt_stats, 0, BLOGIC_MAXDEV * sizeof(struct blogic_tgt_stats));3329	return 0;3330}3331 3332static int blogic_show_info(struct seq_file *m, struct Scsi_Host *shost)3333{3334	struct blogic_adapter *adapter = (struct blogic_adapter *) shost->hostdata;3335	struct blogic_tgt_stats *tgt_stats;3336	int tgt;3337 3338	tgt_stats = adapter->tgt_stats;3339	seq_write(m, adapter->msgbuf, adapter->msgbuflen);3340	seq_printf(m, "\n\3341Current Driver Queue Depth:	%d\n\3342Currently Allocated CCBs:	%d\n", adapter->drvr_qdepth, adapter->alloc_ccbs);3343	seq_puts(m, "\n\n\3344			   DATA TRANSFER STATISTICS\n\3345\n\3346Target	Tagged Queuing	Queue Depth  Active  Attempted	Completed\n\3347======	==============	===========  ======  =========	=========\n");3348	for (tgt = 0; tgt < adapter->maxdev; tgt++) {3349		struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];3350		if (!tgt_flags->tgt_exists)3351			continue;3352		seq_printf(m, "  %2d	%s", tgt, (tgt_flags->tagq_ok ? (tgt_flags->tagq_active ? "    Active" : (adapter->tagq_ok & (1 << tgt)3353																				    ? "  Permitted" : "   Disabled"))3354									  : "Not Supported"));3355		seq_printf(m,3356				  "	    %3d       %3u    %9u	%9u\n", adapter->qdepth[tgt], adapter->active_cmds[tgt], tgt_stats[tgt].cmds_tried, tgt_stats[tgt].cmds_complete);3357	}3358	seq_puts(m, "\n\3359Target  Read Commands  Write Commands   Total Bytes Read    Total Bytes Written\n\3360======  =============  ==============  ===================  ===================\n");3361	for (tgt = 0; tgt < adapter->maxdev; tgt++) {3362		struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];3363		if (!tgt_flags->tgt_exists)3364			continue;3365		seq_printf(m, "  %2d	  %9u	 %9u", tgt, tgt_stats[tgt].read_cmds, tgt_stats[tgt].write_cmds);3366		if (tgt_stats[tgt].bytesread.billions > 0)3367			seq_printf(m, "     %9u%09u", tgt_stats[tgt].bytesread.billions, tgt_stats[tgt].bytesread.units);3368		else3369			seq_printf(m, "		%9u", tgt_stats[tgt].bytesread.units);3370		if (tgt_stats[tgt].byteswritten.billions > 0)3371			seq_printf(m, "   %9u%09u\n", tgt_stats[tgt].byteswritten.billions, tgt_stats[tgt].byteswritten.units);3372		else3373			seq_printf(m, "	     %9u\n", tgt_stats[tgt].byteswritten.units);3374	}3375	seq_puts(m, "\n\3376Target  Command    0-1KB      1-2KB      2-4KB      4-8KB     8-16KB\n\3377======  =======  =========  =========  =========  =========  =========\n");3378	for (tgt = 0; tgt < adapter->maxdev; tgt++) {3379		struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];3380		if (!tgt_flags->tgt_exists)3381			continue;3382		seq_printf(m,3383			    "  %2d	 Read	 %9u  %9u  %9u  %9u  %9u\n", tgt,3384			    tgt_stats[tgt].read_sz_buckets[0],3385			    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]);3386		seq_printf(m,3387			    "  %2d	 Write	 %9u  %9u  %9u  %9u  %9u\n", tgt,3388			    tgt_stats[tgt].write_sz_buckets[0],3389			    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]);3390	}3391	seq_puts(m, "\n\3392Target  Command   16-32KB    32-64KB   64-128KB   128-256KB   256KB+\n\3393======  =======  =========  =========  =========  =========  =========\n");3394	for (tgt = 0; tgt < adapter->maxdev; tgt++) {3395		struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];3396		if (!tgt_flags->tgt_exists)3397			continue;3398		seq_printf(m,3399			    "  %2d	 Read	 %9u  %9u  %9u  %9u  %9u\n", tgt,3400			    tgt_stats[tgt].read_sz_buckets[5],3401			    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]);3402		seq_printf(m,3403			    "  %2d	 Write	 %9u  %9u  %9u  %9u  %9u\n", tgt,3404			    tgt_stats[tgt].write_sz_buckets[5],3405			    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]);3406	}3407	seq_puts(m, "\n\n\3408			   ERROR RECOVERY STATISTICS\n\3409\n\3410	  Command Aborts      Bus Device Resets	  Host Adapter Resets\n\3411Target	Requested Completed  Requested Completed  Requested Completed\n\3412  ID	\\\\\\\\ Attempted ////  \\\\\\\\ Attempted ////  \\\\\\\\ Attempted ////\n\3413======	 ===== ===== =====    ===== ===== =====	   ===== ===== =====\n");3414	for (tgt = 0; tgt < adapter->maxdev; tgt++) {3415		struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];3416		if (!tgt_flags->tgt_exists)3417			continue;3418		seq_printf(m, "  %2d	 %5d %5d %5d    %5d %5d %5d	   %5d %5d %5d\n",3419			   tgt, tgt_stats[tgt].aborts_request,3420			   tgt_stats[tgt].aborts_tried,3421			   tgt_stats[tgt].aborts_done,3422			   tgt_stats[tgt].bdr_request,3423			   tgt_stats[tgt].bdr_tried,3424			   tgt_stats[tgt].bdr_done,3425			   tgt_stats[tgt].adapter_reset_req,3426			   tgt_stats[tgt].adapter_reset_attempt,3427			   tgt_stats[tgt].adapter_reset_done);3428	}3429	seq_printf(m, "\nExternal Host Adapter Resets: %d\n", adapter->ext_resets);3430	seq_printf(m, "Host Adapter Internal Errors: %d\n", adapter->adapter_intern_errors);3431	return 0;3432}3433 3434 3435/*3436  blogic_msg prints Driver Messages.3437*/3438__printf(2, 4)3439static void blogic_msg(enum blogic_msglevel msglevel, char *fmt,3440			struct blogic_adapter *adapter, ...)3441{3442	static char buf[BLOGIC_LINEBUF_SIZE];3443	static bool begin = true;3444	va_list args;3445	int len = 0;3446 3447	va_start(args, adapter);3448	len = vscnprintf(buf, sizeof(buf), fmt, args);3449	va_end(args);3450	if (msglevel == BLOGIC_ANNOUNCE_LEVEL) {3451		static int msglines = 0;3452		strcpy(&adapter->msgbuf[adapter->msgbuflen], buf);3453		adapter->msgbuflen += len;3454		if (++msglines <= 2)3455			printk("%sscsi: %s", blogic_msglevelmap[msglevel], buf);3456	} else if (msglevel == BLOGIC_INFO_LEVEL) {3457		strcpy(&adapter->msgbuf[adapter->msgbuflen], buf);3458		adapter->msgbuflen += len;3459		if (begin) {3460			if (buf[0] != '\n' || len > 1)3461				printk("%sscsi%d: %s", blogic_msglevelmap[msglevel], adapter->host_no, buf);3462		} else3463			pr_cont("%s", buf);3464	} else {3465		if (begin) {3466			if (adapter != NULL && adapter->adapter_initd)3467				printk("%sscsi%d: %s", blogic_msglevelmap[msglevel], adapter->host_no, buf);3468			else3469				printk("%s%s", blogic_msglevelmap[msglevel], buf);3470		} else3471			pr_cont("%s", buf);3472	}3473	begin = (buf[len - 1] == '\n');3474}3475 3476 3477/*3478  blogic_parse parses an individual option keyword.  It returns true3479  and updates the pointer if the keyword is recognized and false otherwise.3480*/3481 3482static bool __init blogic_parse(char **str, char *keyword)3483{3484	char *pointer = *str;3485	while (*keyword != '\0') {3486		char strch = *pointer++;3487		char keywordch = *keyword++;3488		if (strch >= 'A' && strch <= 'Z')3489			strch += 'a' - 'Z';3490		if (keywordch >= 'A' && keywordch <= 'Z')3491			keywordch += 'a' - 'Z';3492		if (strch != keywordch)3493			return false;3494	}3495	*str = pointer;3496	return true;3497}3498 3499 3500/*3501  blogic_parseopts handles processing of BusLogic Driver Options3502  specifications.3503 3504  BusLogic Driver Options may be specified either via the Linux Kernel Command3505  Line or via the Loadable Kernel Module Installation Facility.  Driver Options3506  for multiple host adapters may be specified either by separating the option3507  strings by a semicolon, or by specifying multiple "BusLogic=" strings on the3508  command line.  Individual option specifications for a single host adapter are3509  separated by commas.  The Probing and Debugging Options apply to all host3510  adapters whereas the remaining options apply individually only to the3511  selected host adapter.3512 3513  The BusLogic Driver Probing Options are described in3514  <file:Documentation/scsi/BusLogic.rst>.3515*/3516 3517static int __init blogic_parseopts(char *options)3518{3519	while (true) {3520		struct blogic_drvr_options *drvr_opts =3521			&blogic_drvr_options[blogic_drvr_options_count++];3522		int tgt_id;3523 3524		memset(drvr_opts, 0, sizeof(struct blogic_drvr_options));3525		while (*options != '\0' && *options != ';') {3526			if (blogic_parse(&options, "NoProbePCI"))3527				blogic_probe_options.noprobe_pci = true;3528			else if (blogic_parse(&options, "NoProbe"))3529				blogic_probe_options.noprobe = true;3530			else if (blogic_parse(&options, "NoSortPCI"))3531				blogic_probe_options.nosort_pci = true;3532			else if (blogic_parse(&options, "MultiMasterFirst"))3533				blogic_probe_options.multimaster_first = true;3534			else if (blogic_parse(&options, "FlashPointFirst"))3535				blogic_probe_options.flashpoint_first = true;3536			/* Tagged Queuing Options. */3537			else if (blogic_parse(&options, "QueueDepth:[") ||3538					blogic_parse(&options, "QD:[")) {3539				for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++) {3540					unsigned short qdepth = simple_strtoul(options, &options, 0);3541					if (qdepth > BLOGIC_MAX_TAG_DEPTH) {3542						blogic_err("BusLogic: Invalid Driver Options (invalid Queue Depth %d)\n", NULL, qdepth);3543						return 0;3544					}3545					drvr_opts->qdepth[tgt_id] = qdepth;3546					if (*options == ',')3547						options++;3548					else if (*options == ']')3549						break;3550					else {3551						blogic_err("BusLogic: Invalid Driver Options (',' or ']' expected at '%s')\n", NULL, options);3552						return 0;3553					}3554				}3555				if (*options != ']') {3556					blogic_err("BusLogic: Invalid Driver Options (']' expected at '%s')\n", NULL, options);3557					return 0;3558				} else3559					options++;3560			} else if (blogic_parse(&options, "QueueDepth:") || blogic_parse(&options, "QD:")) {3561				unsigned short qdepth = simple_strtoul(options, &options, 0);3562				if (qdepth == 0 ||3563						qdepth > BLOGIC_MAX_TAG_DEPTH) {3564					blogic_err("BusLogic: Invalid Driver Options (invalid Queue Depth %d)\n", NULL, qdepth);3565					return 0;3566				}3567				drvr_opts->common_qdepth = qdepth;3568				for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++)3569					drvr_opts->qdepth[tgt_id] = qdepth;3570			} else if (blogic_parse(&options, "TaggedQueuing:") ||3571					blogic_parse(&options, "TQ:")) {3572				if (blogic_parse(&options, "Default")) {3573					drvr_opts->tagq_ok = 0x0000;3574					drvr_opts->tagq_ok_mask = 0x0000;3575				} else if (blogic_parse(&options, "Enable")) {3576					drvr_opts->tagq_ok = 0xFFFF;3577					drvr_opts->tagq_ok_mask = 0xFFFF;3578				} else if (blogic_parse(&options, "Disable")) {3579					drvr_opts->tagq_ok = 0x0000;3580					drvr_opts->tagq_ok_mask = 0xFFFF;3581				} else {3582					unsigned short tgt_bit;3583					for (tgt_id = 0, tgt_bit = 1;3584						tgt_id < BLOGIC_MAXDEV;3585						tgt_id++, tgt_bit <<= 1)3586						switch (*options++) {3587						case 'Y':3588							drvr_opts->tagq_ok |= tgt_bit;3589							drvr_opts->tagq_ok_mask |= tgt_bit;3590							break;3591						case 'N':3592							drvr_opts->tagq_ok &= ~tgt_bit;3593							drvr_opts->tagq_ok_mask |= tgt_bit;3594							break;3595						case 'X':3596							break;3597						default:3598							options--;3599							tgt_id = BLOGIC_MAXDEV;3600							break;3601						}3602				}3603			}3604			/* Miscellaneous Options. */3605			else if (blogic_parse(&options, "BusSettleTime:") ||3606					blogic_parse(&options, "BST:")) {3607				unsigned short bus_settle_time =3608					simple_strtoul(options, &options, 0);3609				if (bus_settle_time > 5 * 60) {3610					blogic_err("BusLogic: Invalid Driver Options (invalid Bus Settle Time %d)\n", NULL, bus_settle_time);3611					return 0;3612				}3613				drvr_opts->bus_settle_time = bus_settle_time;3614			} else if (blogic_parse(&options,3615						"InhibitTargetInquiry"))3616				drvr_opts->stop_tgt_inquiry = true;3617			/* Debugging Options. */3618			else if (blogic_parse(&options, "TraceProbe"))3619				blogic_global_options.trace_probe = true;3620			else if (blogic_parse(&options, "TraceHardwareReset"))3621				blogic_global_options.trace_hw_reset = true;3622			else if (blogic_parse(&options, "TraceConfiguration"))3623				blogic_global_options.trace_config = true;3624			else if (blogic_parse(&options, "TraceErrors"))3625				blogic_global_options.trace_err = true;3626			else if (blogic_parse(&options, "Debug")) {3627				blogic_global_options.trace_probe = true;3628				blogic_global_options.trace_hw_reset = true;3629				blogic_global_options.trace_config = true;3630				blogic_global_options.trace_err = true;3631			}3632			if (*options == ',')3633				options++;3634			else if (*options != ';' && *options != '\0') {3635				blogic_err("BusLogic: Unexpected Driver Option '%s' ignored\n", NULL, options);3636				*options = '\0';3637			}3638		}3639		if (!(blogic_drvr_options_count == 0 ||3640			blogic_probeinfo_count == 0 ||3641			blogic_drvr_options_count == blogic_probeinfo_count)) {3642			blogic_err("BusLogic: Invalid Driver Options (all or no I/O Addresses must be specified)\n", NULL);3643			return 0;3644		}3645		/*3646		   Tagged Queuing is disabled when the Queue Depth is 1 since queuing3647		   multiple commands is not possible.3648		 */3649		for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++)3650			if (drvr_opts->qdepth[tgt_id] == 1) {3651				unsigned short tgt_bit = 1 << tgt_id;3652				drvr_opts->tagq_ok &= ~tgt_bit;3653				drvr_opts->tagq_ok_mask |= tgt_bit;3654			}3655		if (*options == ';')3656			options++;3657		if (*options == '\0')3658			return 0;3659	}3660	return 1;3661}3662 3663/*3664  Get it all started3665*/3666 3667static const struct scsi_host_template blogic_template = {3668	.module = THIS_MODULE,3669	.proc_name = "BusLogic",3670	.write_info = blogic_write_info,3671	.show_info = blogic_show_info,3672	.name = "BusLogic",3673	.info = blogic_drvr_info,3674	.queuecommand = blogic_qcmd,3675	.slave_configure = blogic_slaveconfig,3676	.bios_param = blogic_diskparam,3677	.eh_host_reset_handler = blogic_hostreset,3678#if 03679	.eh_abort_handler = blogic_abort,3680#endif3681	.max_sectors = 128,3682};3683 3684/*3685  blogic_setup handles processing of Kernel Command Line Arguments.3686*/3687 3688static int __init blogic_setup(char *str)3689{3690	int ints[3];3691 3692	(void) get_options(str, ARRAY_SIZE(ints), ints);3693 3694	if (ints[0] != 0) {3695		blogic_err("BusLogic: Obsolete Command Line Entry Format Ignored\n", NULL);3696		return 0;3697	}3698	if (str == NULL || *str == '\0')3699		return 0;3700	return blogic_parseopts(str);3701}3702 3703/*3704 * Exit function.  Deletes all hosts associated with this driver.3705 */3706 3707static void __exit blogic_exit(void)3708{3709	struct blogic_adapter *ha, *next;3710 3711	list_for_each_entry_safe(ha, next, &blogic_host_list, host_list)3712		blogic_deladapter(ha);3713}3714 3715__setup("BusLogic=", blogic_setup);3716 3717#ifdef MODULE3718/*static struct pci_device_id blogic_pci_tbl[] = {3719	{ PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER,3720	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},3721	{ PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC,3722	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},3723	{ PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT,3724	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},3725	{ }3726};*/3727static const struct pci_device_id blogic_pci_tbl[] = {3728	{PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER)},3729	{PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC)},3730	{PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT)},3731	{0, },3732};3733#endif3734MODULE_DEVICE_TABLE(pci, blogic_pci_tbl);3735 3736module_init(blogic_init);3737module_exit(blogic_exit);3738