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