xref: /openbmc/linux/drivers/scsi/BusLogic.c (revision 83e479e1)
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 
blogic_announce_drvr(struct blogic_adapter * adapter)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 
blogic_drvr_info(struct Scsi_Host * host)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 
blogic_init_ccbs(struct blogic_adapter * adapter,void * blk_pointer,int blk_size,dma_addr_t blkp)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 
blogic_create_initccbs(struct blogic_adapter * adapter)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(&adapter->pci_device->dev,
199 				blk_size, &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 
blogic_destroy_ccbs(struct blogic_adapter * adapter)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(&adapter->pci_device->dev,
225 						lastccb->allocgrp_size, lastccb,
226 						lastccb->allocgrp_head);
227 			lastccb = ccb;
228 		}
229 	}
230 	if (lastccb)
231 		dma_free_coherent(&adapter->pci_device->dev,
232 				lastccb->allocgrp_size, lastccb,
233 				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 
blogic_create_addlccbs(struct blogic_adapter * adapter,int addl_ccbs,bool print_success)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(&adapter->pci_device->dev,
255 				blk_size, &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 
blogic_alloc_ccb(struct blogic_adapter * adapter)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, adapter->inc_ccbs,
289 						true);
290 		return ccb;
291 	}
292 	blogic_create_addlccbs(adapter, adapter->inc_ccbs, 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 
blogic_dealloc_ccb(struct blogic_ccb * ccb,int dma_unmap)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(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 
blogic_cmd(struct blogic_adapter * adapter,enum blogic_opcode opcode,void * param,int paramlen,void * reply,int replylen)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, 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, *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 
blogic_sort_probeinfo(struct blogic_probeinfo * probeinfo_list,int probeinfo_cnt)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 
blogic_init_mm_probeinfo(struct blogic_adapter * adapter)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 					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(pci_device))
651 			continue;
652 
653 		if (dma_set_mask(&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(host_adapter);
689 		if (blogic_cmd(host_adapter, BLOGIC_INQ_PCI_INFO, NULL, 0,
690 				&adapter_info, 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(host_adapter, BLOGIC_MOD_IOADDR, &mod_ioaddr_req,
703 				sizeof(mod_ioaddr_req), NULL, 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(host_adapter, BLOGIC_FETCH_LOCALRAM,
720 					&fetch_localram, sizeof(fetch_localram),
721 					&autoscsi_byte45,
722 					sizeof(autoscsi_byte45));
723 			blogic_cmd(host_adapter, BLOGIC_GET_BOARD_ID, NULL, 0,
724 					&id, 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(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(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(&blogic_probeinfo_list[nonpr_mmindex],
777 					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 					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(pci_device))
792 			continue;
793 
794 		if (dma_set_mask(&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(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 
blogic_init_fp_probeinfo(struct blogic_adapter * adapter)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 					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(pci_device))
849 			continue;
850 
851 		if (dma_set_mask(&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(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(&blogic_probeinfo_list[fpindex], 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 
blogic_init_probeinfo_list(struct blogic_adapter * adapter)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(myadapter, BLOGIC_FETCH_LOCALRAM,
954 						&fetch_localram,
955 						sizeof(fetch_localram),
956 						&d0_mapbyte,
957 						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 
blogic_failure(struct blogic_adapter * adapter,char * msg)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 
blogic_probe(struct blogic_adapter * adapter)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(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 
blogic_hwreset(struct blogic_adapter * adapter,bool hard_reset)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(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, "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 
blogic_checkadapter(struct blogic_adapter * adapter)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, BLOGIC_INQ_EXTSETUP, &req_replylen,
1213 				sizeof(req_replylen), &ext_setupinfo,
1214 				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 
blogic_rdconfig(struct blogic_adapter * adapter)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(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, BLOGIC_GET_BOARD_ID, NULL, 0, &id,
1298 				sizeof(id)) != sizeof(id))
1299 		return blogic_failure(adapter, "INQUIRE BOARD ID");
1300 	/*
1301 	   Issue the Inquire Configuration command.
1302 	 */
1303 	if (blogic_cmd(adapter, BLOGIC_INQ_CONFIG, NULL, 0, &config,
1304 				sizeof(config))
1305 	    != sizeof(config))
1306 		return blogic_failure(adapter, "INQUIRE CONFIGURATION");
1307 	/*
1308 	   Issue the Inquire Setup Information command.
1309 	 */
1310 	req_replylen = sizeof(setupinfo);
1311 	if (blogic_cmd(adapter, BLOGIC_INQ_SETUPINFO, &req_replylen,
1312 				sizeof(req_replylen), &setupinfo,
1313 				sizeof(setupinfo)) != sizeof(setupinfo))
1314 		return blogic_failure(adapter, "INQUIRE SETUP INFORMATION");
1315 	/*
1316 	   Issue the Inquire Extended Setup Information command.
1317 	 */
1318 	req_replylen = sizeof(ext_setupinfo);
1319 	if (blogic_cmd(adapter, BLOGIC_INQ_EXTSETUP, &req_replylen,
1320 				sizeof(req_replylen), &ext_setupinfo,
1321 				sizeof(ext_setupinfo)) != sizeof(ext_setupinfo))
1322 		return blogic_failure(adapter,
1323 					"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, BLOGIC_INQ_FWVER_D3, NULL, 0,
1330 				&fw_ver_digit3,
1331 				sizeof(fw_ver_digit3)) != sizeof(fw_ver_digit3))
1332 			return blogic_failure(adapter,
1333 						"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(model, "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(model, "742A");
1345 	else if (ext_setupinfo.bus_type == 'E' && id.fw_ver_digit1 == '0')
1346 		/* AMI FastDisk EISA Series 441 0.x */
1347 		strcpy(model, "747A");
1348 	else {
1349 		req_replylen = sizeof(model);
1350 		if (blogic_cmd(adapter, BLOGIC_INQ_MODELNO, &req_replylen,
1351 					sizeof(req_replylen), &model,
1352 					sizeof(model)) != sizeof(model))
1353 			return blogic_failure(adapter,
1354 					"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, BLOGIC_INQ_FWVER_LETTER, NULL, 0,
1402 				&fw_ver_letter,
1403 				sizeof(fw_ver_letter)) != sizeof(fw_ver_letter))
1404 			return blogic_failure(adapter,
1405 					"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, BLOGIC_INQ_PCI_INFO, NULL, 0,
1469 				&adapter_info,
1470 				sizeof(adapter_info)) != sizeof(adapter_info))
1471 			return blogic_failure(adapter,
1472 					"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, BLOGIC_FETCH_LOCALRAM, &fetch_localram,
1491 					sizeof(fetch_localram), &autoscsi,
1492 					sizeof(autoscsi)) != sizeof(autoscsi))
1493 			return blogic_failure(adapter,
1494 						"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, "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(adapter->full_model, "BusLogic ");
1634 	strcat(adapter->full_model, 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 
blogic_reportconfig(struct blogic_adapter * adapter)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 
blogic_getres(struct blogic_adapter * adapter)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(adapter->irq_ch, blogic_inthandler, IRQF_SHARED,
1858 				adapter->full_model, 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 
blogic_relres(struct blogic_adapter * adapter)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(&adapter->pci_device->dev, adapter->mbox_sz,
1888 			adapter->mbox_space, adapter->mbox_space_handle);
1889 	pci_dev_put(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 
blogic_initadapter(struct blogic_adapter * adapter)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(&adapter->pci_device->dev,
1940 				adapter->mbox_sz, &adapter->mbox_space_handle,
1941 				GFP_KERNEL);
1942 	if (adapter->mbox_space == NULL)
1943 		return blogic_failure(adapter, "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, BLOGIC_INIT_EXT_MBOX, &extmbox_req,
1966 				sizeof(extmbox_req), NULL, 0) < 0)
1967 		return blogic_failure(adapter, "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, BLOGIC_STRICT_RR, &rr_req,
1979 					sizeof(rr_req), NULL, 0) < 0)
1980 			return blogic_failure(adapter,
1981 					"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, BLOGIC_SETCCB_FMT, &setccb_fmt,
1991 					sizeof(setccb_fmt), NULL, 0) < 0)
1992 			return blogic_failure(adapter, "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 
blogic_inquiry(struct blogic_adapter * adapter)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(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, BLOGIC_INQ_DEV, NULL, 0,
2067 					&installed_devs, sizeof(installed_devs))
2068 		    != sizeof(installed_devs))
2069 			return blogic_failure(adapter, "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, BLOGIC_INQ_DEV0TO7, NULL, 0,
2083 				&installed_devs0to7, sizeof(installed_devs0to7))
2084 		    != sizeof(installed_devs0to7))
2085 			return blogic_failure(adapter,
2086 					"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, BLOGIC_INQ_SETUPINFO, &req_replylen,
2096 			sizeof(req_replylen), &setupinfo, sizeof(setupinfo))
2097 	    != sizeof(setupinfo))
2098 		return blogic_failure(adapter, "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, BLOGIC_INQ_SYNC_PERIOD, &req_replylen,
2116 				sizeof(req_replylen), &sync_period,
2117 				sizeof(sync_period)) != sizeof(sync_period))
2118 			return blogic_failure(adapter,
2119 					"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 
blogic_inithoststruct(struct blogic_adapter * adapter,struct Scsi_Host * host)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 */
blogic_slaveconfig(struct scsi_device * dev)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, qdepth - adapter->alloc_ccbs,
2187 				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 
blogic_init(void)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, 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(sizeof(struct blogic_adapter), GFP_KERNEL);
2222 	if (adapter == NULL) {
2223 		kfree(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(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(myadapter, 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(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(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(&myadapter->host_list, &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(myadapter) &&
2332 		    blogic_reportconfig(myadapter) &&
2333 		    blogic_getres(myadapter) &&
2334 		    blogic_create_initccbs(myadapter) &&
2335 		    blogic_initadapter(myadapter) &&
2336 		    blogic_inquiry(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(myadapter);
2353 				blogic_relres(myadapter);
2354 				list_del(&myadapter->host_list);
2355 				scsi_host_put(host);
2356 				ret = -ENOMEM;
2357 			} else {
2358 				blogic_inithoststruct(myadapter,
2359 								 host);
2360 				if (scsi_add_host(host, 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(myadapter);
2367 					blogic_relres(myadapter);
2368 					list_del(&myadapter->host_list);
2369 					scsi_host_put(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(myadapter);
2386 			blogic_relres(myadapter);
2387 			list_del(&myadapter->host_list);
2388 			scsi_host_put(host);
2389 			ret = -ENODEV;
2390 		}
2391 	}
2392 	kfree(adapter);
2393 	kfree(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 
blogic_deladapter(struct blogic_adapter * adapter)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(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(&adapter->host_list);
2432 
2433 	scsi_host_put(host);
2434 	return 0;
2435 }
2436 
2437 
2438 /*
2439   blogic_qcompleted_ccb queues CCB for completion processing.
2440 */
2441 
blogic_qcompleted_ccb(struct blogic_ccb * ccb)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 
blogic_resultcode(struct blogic_adapter * adapter,enum blogic_adapter_status adapter_status,enum blogic_tgt_status tgt_status)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 *
blogic_inbox_to_ccb(struct blogic_adapter * adapter,struct blogic_inbox * inbox)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 */
blogic_scan_inbox(struct blogic_adapter * adapter)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, 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 
blogic_process_ccbs(struct blogic_adapter * adapter)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(&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, 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, 1);
2651 					adapter->active_cmds[tgt_id]--;
2652 					command->result = DID_RESET << 16;
2653 					scsi_done(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(&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 					ccb->adapter_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(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, 1);
2722 			/*
2723 			   Call the SCSI Command Completion Routine.
2724 			 */
2725 			scsi_done(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 
blogic_inthandler(int irq_ch,void * devid)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(adapter->cardhandle))
2778 			switch (FlashPoint_HandleInterrupt(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(&adapter->ext_resets);
2801 		blogic_resetadapter(adapter, 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(&adapter->adapter_intern_errors);
2806 		blogic_resetadapter(adapter, true);
2807 		adapter->adapter_intern_err = false;
2808 	}
2809 	/*
2810 	   Release exclusive access to Host Adapter.
2811 	 */
2812 	spin_unlock_irqrestore(adapter->scsi_host->host_lock, 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 
blogic_write_outbox(struct blogic_adapter * adapter,enum blogic_action action,struct blogic_ccb * ccb)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 
blogic_hostreset(struct scsi_cmnd * SCpnt)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(SCpnt->device->host->host_lock);
2865 
2866 	blogic_inc_count(&stats->adapter_reset_req);
2867 
2868 	rc = blogic_resetadapter(adapter, false);
2869 	spin_unlock_irq(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 
blogic_qcmd_lck(struct scsi_cmnd * command)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(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(adapter->scsi_host->host_lock);
2916 		blogic_delay(1);
2917 		spin_lock_irq(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(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(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(&tgt_stats[tgt_id].bytesread, buflen);
2960 		blogic_incszbucket(tgt_stats[tgt_id].read_sz_buckets, 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(&tgt_stats[tgt_id].byteswritten, buflen);
2967 		blogic_incszbucket(tgt_stats[tgt_id].write_sz_buckets, 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(&adapter->pci_device->dev, sense_buf)) {
3044 		blogic_err("DMA mapping for sense data buffer failed\n",
3045 				adapter);
3046 		blogic_dealloc_ccb(ccb, 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, BLOGIC_MBOX_START, ccb)) {
3062 			spin_unlock_irq(adapter->scsi_host->host_lock);
3063 			blogic_warn("Unable to write Outgoing Mailbox - Pausing for 1 second\n", adapter);
3064 			blogic_delay(1);
3065 			spin_lock_irq(adapter->scsi_host->host_lock);
3066 			if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START,
3067 						ccb)) {
3068 				blogic_warn("Still unable to write Outgoing Mailbox - Host Adapter Dead?\n", adapter);
3069 				blogic_dealloc_ccb(ccb, 1);
3070 				command->result = DID_ERROR << 16;
3071 				scsi_done(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(adapter->cardhandle, 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 
DEF_SCSI_QCMD(blogic_qcmd)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, 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(adapter->scsi_host->host_lock);
3213 		blogic_delay(adapter->bus_settle_time);
3214 		spin_lock_irq(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 
blogic_diskparam(struct scsi_device * sdev,struct block_device * dev,sector_t capacity,int * params)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(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(buf);
3309 	return 0;
3310 }
3311 
3312 
3313 /*
3314   BugLogic_ProcDirectoryInfo implements /proc/scsi/BusLogic/<N>.
3315 */
3316 
blogic_write_info(struct Scsi_Host * shost,char * procbuf,int bytes_avail)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 
blogic_show_info(struct seq_file * m,struct Scsi_Host * shost)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(m, adapter->msgbuf, adapter->msgbuflen);
3339 	seq_printf(m, "\n\
3340 Current Driver Queue Depth:	%d\n\
3341 Currently Allocated CCBs:	%d\n", adapter->drvr_qdepth, adapter->alloc_ccbs);
3342 	seq_puts(m, "\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, "  %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 				  "	    %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, "\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, "  %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, "     %9u%09u", tgt_stats[tgt].bytesread.billions, tgt_stats[tgt].bytesread.units);
3367 		else
3368 			seq_printf(m, "		%9u", tgt_stats[tgt].bytesread.units);
3369 		if (tgt_stats[tgt].byteswritten.billions > 0)
3370 			seq_printf(m, "   %9u%09u\n", tgt_stats[tgt].byteswritten.billions, tgt_stats[tgt].byteswritten.units);
3371 		else
3372 			seq_printf(m, "	     %9u\n", tgt_stats[tgt].byteswritten.units);
3373 	}
3374 	seq_puts(m, "\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 			    "  %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 			    "  %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, "\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 			    "  %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 			    "  %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, "\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, "  %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, "\nExternal Host Adapter Resets: %d\n", adapter->ext_resets);
3429 	seq_printf(m, "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)
blogic_msg(enum blogic_msglevel msglevel,char * fmt,struct blogic_adapter * adapter,...)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, sizeof(buf), fmt, args);
3448 	va_end(args);
3449 	if (msglevel == BLOGIC_ANNOUNCE_LEVEL) {
3450 		static int msglines = 0;
3451 		strcpy(&adapter->msgbuf[adapter->msgbuflen], 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(&adapter->msgbuf[adapter->msgbuflen], 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 
blogic_parse(char ** str,char * keyword)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 
blogic_parseopts(char * options)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(&options, "NoProbePCI"))
3526 				blogic_probe_options.noprobe_pci = true;
3527 			else if (blogic_parse(&options, "NoProbe"))
3528 				blogic_probe_options.noprobe = true;
3529 			else if (blogic_parse(&options, "NoSortPCI"))
3530 				blogic_probe_options.nosort_pci = true;
3531 			else if (blogic_parse(&options, "MultiMasterFirst"))
3532 				blogic_probe_options.multimaster_first = true;
3533 			else if (blogic_parse(&options, "FlashPointFirst"))
3534 				blogic_probe_options.flashpoint_first = true;
3535 			/* Tagged Queuing Options. */
3536 			else if (blogic_parse(&options, "QueueDepth:[") ||
3537 					blogic_parse(&options, "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(&options, "QueueDepth:") || blogic_parse(&options, "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(&options, "TaggedQueuing:") ||
3570 					blogic_parse(&options, "TQ:")) {
3571 				if (blogic_parse(&options, "Default")) {
3572 					drvr_opts->tagq_ok = 0x0000;
3573 					drvr_opts->tagq_ok_mask = 0x0000;
3574 				} else if (blogic_parse(&options, "Enable")) {
3575 					drvr_opts->tagq_ok = 0xFFFF;
3576 					drvr_opts->tagq_ok_mask = 0xFFFF;
3577 				} else if (blogic_parse(&options, "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(&options, "BusSettleTime:") ||
3605 					blogic_parse(&options, "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(&options,
3614 						"InhibitTargetInquiry"))
3615 				drvr_opts->stop_tgt_inquiry = true;
3616 			/* Debugging Options. */
3617 			else if (blogic_parse(&options, "TraceProbe"))
3618 				blogic_global_options.trace_probe = true;
3619 			else if (blogic_parse(&options, "TraceHardwareReset"))
3620 				blogic_global_options.trace_hw_reset = true;
3621 			else if (blogic_parse(&options, "TraceConfiguration"))
3622 				blogic_global_options.trace_config = true;
3623 			else if (blogic_parse(&options, "TraceErrors"))
3624 				blogic_global_options.trace_err = true;
3625 			else if (blogic_parse(&options, "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 
blogic_setup(char * str)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(str);
3700 }
3701 
3702 /*
3703  * Exit function.  Deletes all hosts associated with this driver.
3704  */
3705 
blogic_exit(void)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(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