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 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 adapter_count = 0, 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 					adapter_count++;
2374 				}
2375 			}
2376 		} else {
2377 			/*
2378 			   An error occurred during Host Adapter Configuration
2379 			   Querying, Host Adapter Configuration, Resource
2380 			   Acquisition, CCB Creation, Host Adapter
2381 			   Initialization, or Target Device Inquiry, so
2382 			   remove Host Adapter from the list of registered
2383 			   BusLogic Host Adapters, destroy the CCBs, Release
2384 			   the System Resources, and Unregister the SCSI
2385 			   Host.
2386 			 */
2387 			blogic_destroy_ccbs(myadapter);
2388 			blogic_relres(myadapter);
2389 			list_del(&myadapter->host_list);
2390 			scsi_host_put(host);
2391 			ret = -ENODEV;
2392 		}
2393 	}
2394 	kfree(adapter);
2395 	kfree(blogic_probeinfo_list);
2396 	blogic_probeinfo_list = NULL;
2397 	return ret;
2398 }
2399 
2400 
2401 /*
2402   blogic_deladapter releases all resources previously acquired to
2403   support a specific Host Adapter, including the I/O Address range, and
2404   unregisters the BusLogic Host Adapter.
2405 */
2406 
blogic_deladapter(struct blogic_adapter * adapter)2407 static int __exit blogic_deladapter(struct blogic_adapter *adapter)
2408 {
2409 	struct Scsi_Host *host = adapter->scsi_host;
2410 
2411 	scsi_remove_host(host);
2412 
2413 	/*
2414 	   FlashPoint Host Adapters must first be released by the FlashPoint
2415 	   SCCB Manager.
2416 	 */
2417 	if (blogic_flashpoint_type(adapter))
2418 		FlashPoint_ReleaseHostAdapter(adapter->cardhandle);
2419 	/*
2420 	   Destroy the CCBs and release any system resources acquired to
2421 	   support Host Adapter.
2422 	 */
2423 	blogic_destroy_ccbs(adapter);
2424 	blogic_relres(adapter);
2425 	/*
2426 	   Release usage of the I/O Address range.
2427 	 */
2428 	release_region(adapter->io_addr, adapter->addr_count);
2429 	/*
2430 	   Remove Host Adapter from the list of registered BusLogic
2431 	   Host Adapters.
2432 	 */
2433 	list_del(&adapter->host_list);
2434 
2435 	scsi_host_put(host);
2436 	return 0;
2437 }
2438 
2439 
2440 /*
2441   blogic_qcompleted_ccb queues CCB for completion processing.
2442 */
2443 
blogic_qcompleted_ccb(struct blogic_ccb * ccb)2444 static void blogic_qcompleted_ccb(struct blogic_ccb *ccb)
2445 {
2446 	struct blogic_adapter *adapter = ccb->adapter;
2447 
2448 	ccb->status = BLOGIC_CCB_COMPLETE;
2449 	ccb->next = NULL;
2450 	if (adapter->firstccb == NULL) {
2451 		adapter->firstccb = ccb;
2452 		adapter->lastccb = ccb;
2453 	} else {
2454 		adapter->lastccb->next = ccb;
2455 		adapter->lastccb = ccb;
2456 	}
2457 	adapter->active_cmds[ccb->tgt_id]--;
2458 }
2459 
2460 
2461 /*
2462   blogic_resultcode computes a SCSI Subsystem Result Code from
2463   the Host Adapter Status and Target Device Status.
2464 */
2465 
blogic_resultcode(struct blogic_adapter * adapter,enum blogic_adapter_status adapter_status,enum blogic_tgt_status tgt_status)2466 static int blogic_resultcode(struct blogic_adapter *adapter,
2467 		enum blogic_adapter_status adapter_status,
2468 		enum blogic_tgt_status tgt_status)
2469 {
2470 	int hoststatus;
2471 
2472 	switch (adapter_status) {
2473 	case BLOGIC_CMD_CMPLT_NORMAL:
2474 	case BLOGIC_LINK_CMD_CMPLT:
2475 	case BLOGIC_LINK_CMD_CMPLT_FLAG:
2476 		hoststatus = DID_OK;
2477 		break;
2478 	case BLOGIC_SELECT_TIMEOUT:
2479 		hoststatus = DID_TIME_OUT;
2480 		break;
2481 	case BLOGIC_INVALID_OUTBOX_CODE:
2482 	case BLOGIC_INVALID_CMD_CODE:
2483 	case BLOGIC_BAD_CMD_PARAM:
2484 		blogic_warn("BusLogic Driver Protocol Error 0x%02X\n",
2485 				adapter, adapter_status);
2486 		fallthrough;
2487 	case BLOGIC_DATA_UNDERRUN:
2488 	case BLOGIC_DATA_OVERRUN:
2489 	case BLOGIC_NOEXPECT_BUSFREE:
2490 	case BLOGIC_LINKCCB_BADLUN:
2491 	case BLOGIC_AUTOREQSENSE_FAIL:
2492 	case BLOGIC_TAGQUEUE_REJECT:
2493 	case BLOGIC_BAD_MSG_RCVD:
2494 	case BLOGIC_HW_FAIL:
2495 	case BLOGIC_BAD_RECONNECT:
2496 	case BLOGIC_ABRT_QUEUE:
2497 	case BLOGIC_ADAPTER_SW_ERROR:
2498 	case BLOGIC_HW_TIMEOUT:
2499 	case BLOGIC_PARITY_ERR:
2500 		hoststatus = DID_ERROR;
2501 		break;
2502 	case BLOGIC_INVALID_BUSPHASE:
2503 	case BLOGIC_NORESPONSE_TO_ATN:
2504 	case BLOGIC_HW_RESET:
2505 	case BLOGIC_RST_FROM_OTHERDEV:
2506 	case BLOGIC_HW_BDR:
2507 		hoststatus = DID_RESET;
2508 		break;
2509 	default:
2510 		blogic_warn("Unknown Host Adapter Status 0x%02X\n", adapter,
2511 				adapter_status);
2512 		hoststatus = DID_ERROR;
2513 		break;
2514 	}
2515 	return (hoststatus << 16) | tgt_status;
2516 }
2517 
2518 
2519 /*
2520   blogic_scan_inbox scans the Incoming Mailboxes saving any
2521   Incoming Mailbox entries for completion processing.
2522 */
2523 
blogic_scan_inbox(struct blogic_adapter * adapter)2524 static void blogic_scan_inbox(struct blogic_adapter *adapter)
2525 {
2526 	/*
2527 	   Scan through the Incoming Mailboxes in Strict Round Robin
2528 	   fashion, saving any completed CCBs for further processing. It
2529 	   is essential that for each CCB and SCSI Command issued, command
2530 	   completion processing is performed exactly once.  Therefore,
2531 	   only Incoming Mailboxes with completion code Command Completed
2532 	   Without Error, Command Completed With Error, or Command Aborted
2533 	   At Host Request are saved for completion processing. When an
2534 	   Incoming Mailbox has a completion code of Aborted Command Not
2535 	   Found, the CCB had already completed or been aborted before the
2536 	   current Abort request was processed, and so completion processing
2537 	   has already occurred and no further action should be taken.
2538 	 */
2539 	struct blogic_inbox *next_inbox = adapter->next_inbox;
2540 	enum blogic_cmplt_code comp_code;
2541 
2542 	while ((comp_code = next_inbox->comp_code) != BLOGIC_INBOX_FREE) {
2543 		/*
2544 		   We are only allowed to do this because we limit our
2545 		   architectures we run on to machines where bus_to_virt(
2546 		   actually works.  There *needs* to be a dma_addr_to_virt()
2547 		   in the new PCI DMA mapping interface to replace
2548 		   bus_to_virt() or else this code is going to become very
2549 		   innefficient.
2550 		 */
2551 		struct blogic_ccb *ccb =
2552 			(struct blogic_ccb *) bus_to_virt(next_inbox->ccb);
2553 		if (comp_code != BLOGIC_CMD_NOTFOUND) {
2554 			if (ccb->status == BLOGIC_CCB_ACTIVE ||
2555 					ccb->status == BLOGIC_CCB_RESET) {
2556 				/*
2557 				   Save the Completion Code for this CCB and
2558 				   queue the CCB for completion processing.
2559 				 */
2560 				ccb->comp_code = comp_code;
2561 				blogic_qcompleted_ccb(ccb);
2562 			} else {
2563 				/*
2564 				   If a CCB ever appears in an Incoming Mailbox
2565 				   and is not marked as status Active or Reset,
2566 				   then there is most likely a bug in
2567 				   the Host Adapter firmware.
2568 				 */
2569 				blogic_warn("Illegal CCB #%ld status %d in Incoming Mailbox\n", adapter, ccb->serial, ccb->status);
2570 			}
2571 		}
2572 		next_inbox->comp_code = BLOGIC_INBOX_FREE;
2573 		if (++next_inbox > adapter->last_inbox)
2574 			next_inbox = adapter->first_inbox;
2575 	}
2576 	adapter->next_inbox = next_inbox;
2577 }
2578 
2579 
2580 /*
2581   blogic_process_ccbs iterates over the completed CCBs for Host
2582   Adapter setting the SCSI Command Result Codes, deallocating the CCBs, and
2583   calling the SCSI Subsystem Completion Routines.  The Host Adapter's Lock
2584   should already have been acquired by the caller.
2585 */
2586 
blogic_process_ccbs(struct blogic_adapter * adapter)2587 static void blogic_process_ccbs(struct blogic_adapter *adapter)
2588 {
2589 	if (adapter->processing_ccbs)
2590 		return;
2591 	adapter->processing_ccbs = true;
2592 	while (adapter->firstccb != NULL) {
2593 		struct blogic_ccb *ccb = adapter->firstccb;
2594 		struct scsi_cmnd *command = ccb->command;
2595 		adapter->firstccb = ccb->next;
2596 		if (adapter->firstccb == NULL)
2597 			adapter->lastccb = NULL;
2598 		/*
2599 		   Process the Completed CCB.
2600 		 */
2601 		if (ccb->opcode == BLOGIC_BDR) {
2602 			int tgt_id = ccb->tgt_id;
2603 
2604 			blogic_warn("Bus Device Reset CCB #%ld to Target %d Completed\n", adapter, ccb->serial, tgt_id);
2605 			blogic_inc_count(&adapter->tgt_stats[tgt_id].bdr_done);
2606 			adapter->tgt_flags[tgt_id].tagq_active = false;
2607 			adapter->cmds_since_rst[tgt_id] = 0;
2608 			adapter->last_resetdone[tgt_id] = jiffies;
2609 			/*
2610 			   Place CCB back on the Host Adapter's free list.
2611 			 */
2612 			blogic_dealloc_ccb(ccb, 1);
2613 #if 0			/* this needs to be redone different for new EH */
2614 			/*
2615 			   Bus Device Reset CCBs have the command field
2616 			   non-NULL only when a Bus Device Reset was requested
2617 			   for a command that did not have a currently active
2618 			   CCB in the Host Adapter (i.e., a Synchronous Bus
2619 			   Device Reset), and hence would not have its
2620 			   Completion Routine called otherwise.
2621 			 */
2622 			while (command != NULL) {
2623 				struct scsi_cmnd *nxt_cmd =
2624 					command->reset_chain;
2625 				command->reset_chain = NULL;
2626 				command->result = DID_RESET << 16;
2627 				scsi_done(command);
2628 				command = nxt_cmd;
2629 			}
2630 #endif
2631 			/*
2632 			   Iterate over the CCBs for this Host Adapter
2633 			   performing completion processing for any CCBs
2634 			   marked as Reset for this Target.
2635 			 */
2636 			for (ccb = adapter->all_ccbs; ccb != NULL;
2637 					ccb = ccb->next_all)
2638 				if (ccb->status == BLOGIC_CCB_RESET &&
2639 						ccb->tgt_id == tgt_id) {
2640 					command = ccb->command;
2641 					blogic_dealloc_ccb(ccb, 1);
2642 					adapter->active_cmds[tgt_id]--;
2643 					command->result = DID_RESET << 16;
2644 					scsi_done(command);
2645 				}
2646 			adapter->bdr_pend[tgt_id] = NULL;
2647 		} else {
2648 			/*
2649 			   Translate the Completion Code, Host Adapter Status,
2650 			   and Target Device Status into a SCSI Subsystem
2651 			   Result Code.
2652 			 */
2653 			switch (ccb->comp_code) {
2654 			case BLOGIC_INBOX_FREE:
2655 			case BLOGIC_CMD_NOTFOUND:
2656 			case BLOGIC_INVALID_CCB:
2657 				blogic_warn("CCB #%ld to Target %d Impossible State\n", adapter, ccb->serial, ccb->tgt_id);
2658 				break;
2659 			case BLOGIC_CMD_COMPLETE_GOOD:
2660 				adapter->tgt_stats[ccb->tgt_id]
2661 				    .cmds_complete++;
2662 				adapter->tgt_flags[ccb->tgt_id]
2663 				    .cmd_good = true;
2664 				command->result = DID_OK << 16;
2665 				break;
2666 			case BLOGIC_CMD_ABORT_BY_HOST:
2667 				blogic_warn("CCB #%ld to Target %d Aborted\n",
2668 					adapter, ccb->serial, ccb->tgt_id);
2669 				blogic_inc_count(&adapter->tgt_stats[ccb->tgt_id].aborts_done);
2670 				command->result = DID_ABORT << 16;
2671 				break;
2672 			case BLOGIC_CMD_COMPLETE_ERROR:
2673 				command->result = blogic_resultcode(adapter,
2674 					ccb->adapter_status, ccb->tgt_status);
2675 				if (ccb->adapter_status != BLOGIC_SELECT_TIMEOUT) {
2676 					adapter->tgt_stats[ccb->tgt_id]
2677 					    .cmds_complete++;
2678 					if (blogic_global_options.trace_err) {
2679 						int i;
2680 						blogic_notice("CCB #%ld Target %d: Result %X Host "
2681 								"Adapter Status %02X Target Status %02X\n", adapter, ccb->serial, ccb->tgt_id, command->result, ccb->adapter_status, ccb->tgt_status);
2682 						blogic_notice("CDB   ", adapter);
2683 						for (i = 0; i < ccb->cdblen; i++)
2684 							blogic_notice(" %02X", adapter, ccb->cdb[i]);
2685 						blogic_notice("\n", adapter);
2686 						blogic_notice("Sense ", adapter);
2687 						for (i = 0; i < ccb->sense_datalen; i++)
2688 							blogic_notice(" %02X", adapter, command->sense_buffer[i]);
2689 						blogic_notice("\n", adapter);
2690 					}
2691 				}
2692 				break;
2693 			}
2694 			/*
2695 			   When an INQUIRY command completes normally, save the
2696 			   CmdQue (Tagged Queuing Supported) and WBus16 (16 Bit
2697 			   Wide Data Transfers Supported) bits.
2698 			 */
2699 			if (ccb->cdb[0] == INQUIRY && ccb->cdb[1] == 0 &&
2700 				ccb->adapter_status == BLOGIC_CMD_CMPLT_NORMAL) {
2701 				struct blogic_tgt_flags *tgt_flags =
2702 					&adapter->tgt_flags[ccb->tgt_id];
2703 				struct scsi_inquiry *inquiry =
2704 					(struct scsi_inquiry *) scsi_sglist(command);
2705 				tgt_flags->tgt_exists = true;
2706 				tgt_flags->tagq_ok = inquiry->CmdQue;
2707 				tgt_flags->wide_ok = inquiry->WBus16;
2708 			}
2709 			/*
2710 			   Place CCB back on the Host Adapter's free list.
2711 			 */
2712 			blogic_dealloc_ccb(ccb, 1);
2713 			/*
2714 			   Call the SCSI Command Completion Routine.
2715 			 */
2716 			scsi_done(command);
2717 		}
2718 	}
2719 	adapter->processing_ccbs = false;
2720 }
2721 
2722 
2723 /*
2724   blogic_inthandler handles hardware interrupts from BusLogic Host
2725   Adapters.
2726 */
2727 
blogic_inthandler(int irq_ch,void * devid)2728 static irqreturn_t blogic_inthandler(int irq_ch, void *devid)
2729 {
2730 	struct blogic_adapter *adapter = (struct blogic_adapter *) devid;
2731 	unsigned long processor_flag;
2732 	/*
2733 	   Acquire exclusive access to Host Adapter.
2734 	 */
2735 	spin_lock_irqsave(adapter->scsi_host->host_lock, processor_flag);
2736 	/*
2737 	   Handle Interrupts appropriately for each Host Adapter type.
2738 	 */
2739 	if (blogic_multimaster_type(adapter)) {
2740 		union blogic_int_reg intreg;
2741 		/*
2742 		   Read the Host Adapter Interrupt Register.
2743 		 */
2744 		intreg.all = blogic_rdint(adapter);
2745 		if (intreg.ir.int_valid) {
2746 			/*
2747 			   Acknowledge the interrupt and reset the Host Adapter
2748 			   Interrupt Register.
2749 			 */
2750 			blogic_intreset(adapter);
2751 			/*
2752 			   Process valid External SCSI Bus Reset and Incoming
2753 			   Mailbox Loaded Interrupts. Command Complete
2754 			   Interrupts are noted, and Outgoing Mailbox Available
2755 			   Interrupts are ignored, as they are never enabled.
2756 			 */
2757 			if (intreg.ir.ext_busreset)
2758 				adapter->adapter_extreset = true;
2759 			else if (intreg.ir.mailin_loaded)
2760 				blogic_scan_inbox(adapter);
2761 			else if (intreg.ir.cmd_complete)
2762 				adapter->adapter_cmd_complete = true;
2763 		}
2764 	} else {
2765 		/*
2766 		   Check if there is a pending interrupt for this Host Adapter.
2767 		 */
2768 		if (FlashPoint_InterruptPending(adapter->cardhandle))
2769 			switch (FlashPoint_HandleInterrupt(adapter->cardhandle)) {
2770 			case FPOINT_NORMAL_INT:
2771 				break;
2772 			case FPOINT_EXT_RESET:
2773 				adapter->adapter_extreset = true;
2774 				break;
2775 			case FPOINT_INTERN_ERR:
2776 				blogic_warn("Internal FlashPoint Error detected - Resetting Host Adapter\n", adapter);
2777 				adapter->adapter_intern_err = true;
2778 				break;
2779 			}
2780 	}
2781 	/*
2782 	   Process any completed CCBs.
2783 	 */
2784 	if (adapter->firstccb != NULL)
2785 		blogic_process_ccbs(adapter);
2786 	/*
2787 	   Reset the Host Adapter if requested.
2788 	 */
2789 	if (adapter->adapter_extreset) {
2790 		blogic_warn("Resetting %s due to External SCSI Bus Reset\n", adapter, adapter->full_model);
2791 		blogic_inc_count(&adapter->ext_resets);
2792 		blogic_resetadapter(adapter, false);
2793 		adapter->adapter_extreset = false;
2794 	} else if (adapter->adapter_intern_err) {
2795 		blogic_warn("Resetting %s due to Host Adapter Internal Error\n", adapter, adapter->full_model);
2796 		blogic_inc_count(&adapter->adapter_intern_errors);
2797 		blogic_resetadapter(adapter, true);
2798 		adapter->adapter_intern_err = false;
2799 	}
2800 	/*
2801 	   Release exclusive access to Host Adapter.
2802 	 */
2803 	spin_unlock_irqrestore(adapter->scsi_host->host_lock, processor_flag);
2804 	return IRQ_HANDLED;
2805 }
2806 
2807 
2808 /*
2809   blogic_write_outbox places CCB and Action Code into an Outgoing
2810   Mailbox for execution by Host Adapter.  The Host Adapter's Lock should
2811   already have been acquired by the caller.
2812 */
2813 
blogic_write_outbox(struct blogic_adapter * adapter,enum blogic_action action,struct blogic_ccb * ccb)2814 static bool blogic_write_outbox(struct blogic_adapter *adapter,
2815 		enum blogic_action action, struct blogic_ccb *ccb)
2816 {
2817 	struct blogic_outbox *next_outbox;
2818 
2819 	next_outbox = adapter->next_outbox;
2820 	if (next_outbox->action == BLOGIC_OUTBOX_FREE) {
2821 		ccb->status = BLOGIC_CCB_ACTIVE;
2822 		/*
2823 		   The CCB field must be written before the Action Code field
2824 		   since the Host Adapter is operating asynchronously and the
2825 		   locking code does not protect against simultaneous access
2826 		   by the Host Adapter.
2827 		 */
2828 		next_outbox->ccb = ccb->dma_handle;
2829 		next_outbox->action = action;
2830 		blogic_execmbox(adapter);
2831 		if (++next_outbox > adapter->last_outbox)
2832 			next_outbox = adapter->first_outbox;
2833 		adapter->next_outbox = next_outbox;
2834 		if (action == BLOGIC_MBOX_START) {
2835 			adapter->active_cmds[ccb->tgt_id]++;
2836 			if (ccb->opcode != BLOGIC_BDR)
2837 				adapter->tgt_stats[ccb->tgt_id].cmds_tried++;
2838 		}
2839 		return true;
2840 	}
2841 	return false;
2842 }
2843 
2844 /* Error Handling (EH) support */
2845 
blogic_hostreset(struct scsi_cmnd * SCpnt)2846 static int blogic_hostreset(struct scsi_cmnd *SCpnt)
2847 {
2848 	struct blogic_adapter *adapter =
2849 		(struct blogic_adapter *) SCpnt->device->host->hostdata;
2850 
2851 	unsigned int id = SCpnt->device->id;
2852 	struct blogic_tgt_stats *stats = &adapter->tgt_stats[id];
2853 	int rc;
2854 
2855 	spin_lock_irq(SCpnt->device->host->host_lock);
2856 
2857 	blogic_inc_count(&stats->adapter_reset_req);
2858 
2859 	rc = blogic_resetadapter(adapter, false);
2860 	spin_unlock_irq(SCpnt->device->host->host_lock);
2861 	return rc;
2862 }
2863 
2864 /*
2865   blogic_qcmd creates a CCB for Command and places it into an
2866   Outgoing Mailbox for execution by the associated Host Adapter.
2867 */
2868 
blogic_qcmd_lck(struct scsi_cmnd * command)2869 static int blogic_qcmd_lck(struct scsi_cmnd *command)
2870 {
2871 	void (*comp_cb)(struct scsi_cmnd *) = scsi_done;
2872 	struct blogic_adapter *adapter =
2873 		(struct blogic_adapter *) command->device->host->hostdata;
2874 	struct blogic_tgt_flags *tgt_flags =
2875 		&adapter->tgt_flags[command->device->id];
2876 	struct blogic_tgt_stats *tgt_stats = adapter->tgt_stats;
2877 	unsigned char *cdb = command->cmnd;
2878 	int cdblen = command->cmd_len;
2879 	int tgt_id = command->device->id;
2880 	int lun = command->device->lun;
2881 	int buflen = scsi_bufflen(command);
2882 	int count;
2883 	struct blogic_ccb *ccb;
2884 	dma_addr_t sense_buf;
2885 
2886 	/*
2887 	   SCSI REQUEST_SENSE commands will be executed automatically by the
2888 	   Host Adapter for any errors, so they should not be executed
2889 	   explicitly unless the Sense Data is zero indicating that no error
2890 	   occurred.
2891 	 */
2892 	if (cdb[0] == REQUEST_SENSE && command->sense_buffer[0] != 0) {
2893 		command->result = DID_OK << 16;
2894 		comp_cb(command);
2895 		return 0;
2896 	}
2897 	/*
2898 	   Allocate a CCB from the Host Adapter's free list. In the unlikely
2899 	   event that there are none available and memory allocation fails,
2900 	   wait 1 second and try again. If that fails, the Host Adapter is
2901 	   probably hung so signal an error as a Host Adapter Hard Reset
2902 	   should be initiated soon.
2903 	 */
2904 	ccb = blogic_alloc_ccb(adapter);
2905 	if (ccb == NULL) {
2906 		spin_unlock_irq(adapter->scsi_host->host_lock);
2907 		blogic_delay(1);
2908 		spin_lock_irq(adapter->scsi_host->host_lock);
2909 		ccb = blogic_alloc_ccb(adapter);
2910 		if (ccb == NULL) {
2911 			command->result = DID_ERROR << 16;
2912 			comp_cb(command);
2913 			return 0;
2914 		}
2915 	}
2916 
2917 	/*
2918 	   Initialize the fields in the BusLogic Command Control Block (CCB).
2919 	 */
2920 	count = scsi_dma_map(command);
2921 	BUG_ON(count < 0);
2922 	if (count) {
2923 		struct scatterlist *sg;
2924 		int i;
2925 
2926 		ccb->opcode = BLOGIC_INITIATOR_CCB_SG;
2927 		ccb->datalen = count * sizeof(struct blogic_sg_seg);
2928 		if (blogic_multimaster_type(adapter))
2929 			ccb->data = (unsigned int) ccb->dma_handle +
2930 					((unsigned long) &ccb->sglist -
2931 					(unsigned long) ccb);
2932 		else
2933 			ccb->data = virt_to_32bit_virt(ccb->sglist);
2934 
2935 		scsi_for_each_sg(command, sg, count, i) {
2936 			ccb->sglist[i].segbytes = sg_dma_len(sg);
2937 			ccb->sglist[i].segdata = sg_dma_address(sg);
2938 		}
2939 	} else if (!count) {
2940 		ccb->opcode = BLOGIC_INITIATOR_CCB;
2941 		ccb->datalen = buflen;
2942 		ccb->data = 0;
2943 	}
2944 
2945 	switch (cdb[0]) {
2946 	case READ_6:
2947 	case READ_10:
2948 		ccb->datadir = BLOGIC_DATAIN_CHECKED;
2949 		tgt_stats[tgt_id].read_cmds++;
2950 		blogic_addcount(&tgt_stats[tgt_id].bytesread, buflen);
2951 		blogic_incszbucket(tgt_stats[tgt_id].read_sz_buckets, buflen);
2952 		break;
2953 	case WRITE_6:
2954 	case WRITE_10:
2955 		ccb->datadir = BLOGIC_DATAOUT_CHECKED;
2956 		tgt_stats[tgt_id].write_cmds++;
2957 		blogic_addcount(&tgt_stats[tgt_id].byteswritten, buflen);
2958 		blogic_incszbucket(tgt_stats[tgt_id].write_sz_buckets, buflen);
2959 		break;
2960 	default:
2961 		ccb->datadir = BLOGIC_UNCHECKED_TX;
2962 		break;
2963 	}
2964 	ccb->cdblen = cdblen;
2965 	ccb->adapter_status = 0;
2966 	ccb->tgt_status = 0;
2967 	ccb->tgt_id = tgt_id;
2968 	ccb->lun = lun;
2969 	ccb->tag_enable = false;
2970 	ccb->legacytag_enable = false;
2971 	/*
2972 	   BusLogic recommends that after a Reset the first couple of
2973 	   commands that are sent to a Target Device be sent in a non
2974 	   Tagged Queue fashion so that the Host Adapter and Target Device
2975 	   can establish Synchronous and Wide Transfer before Queue Tag
2976 	   messages can interfere with the Synchronous and Wide Negotiation
2977 	   messages.  By waiting to enable Tagged Queuing until after the
2978 	   first BLOGIC_MAX_TAG_DEPTH commands have been queued, it is
2979 	   assured that after a Reset any pending commands are requeued
2980 	   before Tagged Queuing is enabled and that the Tagged Queuing
2981 	   message will not occur while the partition table is being printed.
2982 	   In addition, some devices do not properly handle the transition
2983 	   from non-tagged to tagged commands, so it is necessary to wait
2984 	   until there are no pending commands for a target device
2985 	   before queuing tagged commands.
2986 	 */
2987 	if (adapter->cmds_since_rst[tgt_id]++ >= BLOGIC_MAX_TAG_DEPTH &&
2988 			!tgt_flags->tagq_active &&
2989 			adapter->active_cmds[tgt_id] == 0
2990 			&& tgt_flags->tagq_ok &&
2991 			(adapter->tagq_ok & (1 << tgt_id))) {
2992 		tgt_flags->tagq_active = true;
2993 		blogic_notice("Tagged Queuing now active for Target %d\n",
2994 					adapter, tgt_id);
2995 	}
2996 	if (tgt_flags->tagq_active) {
2997 		enum blogic_queuetag queuetag = BLOGIC_SIMPLETAG;
2998 		/*
2999 		   When using Tagged Queuing with Simple Queue Tags, it
3000 		   appears that disk drive controllers do not guarantee that
3001 		   a queued command will not remain in a disconnected state
3002 		   indefinitely if commands that read or write nearer the
3003 		   head position continue to arrive without interruption.
3004 		   Therefore, for each Target Device this driver keeps track
3005 		   of the last time either the queue was empty or an Ordered
3006 		   Queue Tag was issued. If more than 4 seconds (one fifth
3007 		   of the 20 second disk timeout) have elapsed since this
3008 		   last sequence point, this command will be issued with an
3009 		   Ordered Queue Tag rather than a Simple Queue Tag, which
3010 		   forces the Target Device to complete all previously
3011 		   queued commands before this command may be executed.
3012 		 */
3013 		if (adapter->active_cmds[tgt_id] == 0)
3014 			adapter->last_seqpoint[tgt_id] = jiffies;
3015 		else if (time_after(jiffies,
3016 				adapter->last_seqpoint[tgt_id] + 4 * HZ)) {
3017 			adapter->last_seqpoint[tgt_id] = jiffies;
3018 			queuetag = BLOGIC_ORDEREDTAG;
3019 		}
3020 		if (adapter->ext_lun) {
3021 			ccb->tag_enable = true;
3022 			ccb->queuetag = queuetag;
3023 		} else {
3024 			ccb->legacytag_enable = true;
3025 			ccb->legacy_tag = queuetag;
3026 		}
3027 	}
3028 	memcpy(ccb->cdb, cdb, cdblen);
3029 	ccb->sense_datalen = SCSI_SENSE_BUFFERSIZE;
3030 	ccb->command = command;
3031 	sense_buf = dma_map_single(&adapter->pci_device->dev,
3032 				command->sense_buffer, ccb->sense_datalen,
3033 				DMA_FROM_DEVICE);
3034 	if (dma_mapping_error(&adapter->pci_device->dev, sense_buf)) {
3035 		blogic_err("DMA mapping for sense data buffer failed\n",
3036 				adapter);
3037 		blogic_dealloc_ccb(ccb, 0);
3038 		return SCSI_MLQUEUE_HOST_BUSY;
3039 	}
3040 	ccb->sensedata = sense_buf;
3041 	if (blogic_multimaster_type(adapter)) {
3042 		/*
3043 		   Place the CCB in an Outgoing Mailbox. The higher levels
3044 		   of the SCSI Subsystem should not attempt to queue more
3045 		   commands than can be placed in Outgoing Mailboxes, so
3046 		   there should always be one free.  In the unlikely event
3047 		   that there are none available, wait 1 second and try
3048 		   again. If that fails, the Host Adapter is probably hung
3049 		   so signal an error as a Host Adapter Hard Reset should
3050 		   be initiated soon.
3051 		 */
3052 		if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START, ccb)) {
3053 			spin_unlock_irq(adapter->scsi_host->host_lock);
3054 			blogic_warn("Unable to write Outgoing Mailbox - Pausing for 1 second\n", adapter);
3055 			blogic_delay(1);
3056 			spin_lock_irq(adapter->scsi_host->host_lock);
3057 			if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START,
3058 						ccb)) {
3059 				blogic_warn("Still unable to write Outgoing Mailbox - Host Adapter Dead?\n", adapter);
3060 				blogic_dealloc_ccb(ccb, 1);
3061 				command->result = DID_ERROR << 16;
3062 				scsi_done(command);
3063 			}
3064 		}
3065 	} else {
3066 		/*
3067 		   Call the FlashPoint SCCB Manager to start execution of
3068 		   the CCB.
3069 		 */
3070 		ccb->status = BLOGIC_CCB_ACTIVE;
3071 		adapter->active_cmds[tgt_id]++;
3072 		tgt_stats[tgt_id].cmds_tried++;
3073 		FlashPoint_StartCCB(adapter->cardhandle, ccb);
3074 		/*
3075 		   The Command may have already completed and
3076 		   blogic_qcompleted_ccb been called, or it may still be
3077 		   pending.
3078 		 */
3079 		if (ccb->status == BLOGIC_CCB_COMPLETE)
3080 			blogic_process_ccbs(adapter);
3081 	}
3082 	return 0;
3083 }
3084 
DEF_SCSI_QCMD(blogic_qcmd)3085 static DEF_SCSI_QCMD(blogic_qcmd)
3086 
3087 #if 0
3088 /*
3089   blogic_abort aborts Command if possible.
3090 */
3091 
3092 static int blogic_abort(struct scsi_cmnd *command)
3093 {
3094 	struct blogic_adapter *adapter =
3095 		(struct blogic_adapter *) command->device->host->hostdata;
3096 
3097 	int tgt_id = command->device->id;
3098 	struct blogic_ccb *ccb;
3099 	blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_request);
3100 
3101 	/*
3102 	   Attempt to find an Active CCB for this Command. If no Active
3103 	   CCB for this Command is found, then no Abort is necessary.
3104 	 */
3105 	for (ccb = adapter->all_ccbs; ccb != NULL; ccb = ccb->next_all)
3106 		if (ccb->command == command)
3107 			break;
3108 	if (ccb == NULL) {
3109 		blogic_warn("Unable to Abort Command to Target %d - No CCB Found\n", adapter, tgt_id);
3110 		return SUCCESS;
3111 	} else if (ccb->status == BLOGIC_CCB_COMPLETE) {
3112 		blogic_warn("Unable to Abort Command to Target %d - CCB Completed\n", adapter, tgt_id);
3113 		return SUCCESS;
3114 	} else if (ccb->status == BLOGIC_CCB_RESET) {
3115 		blogic_warn("Unable to Abort Command to Target %d - CCB Reset\n", adapter, tgt_id);
3116 		return SUCCESS;
3117 	}
3118 	if (blogic_multimaster_type(adapter)) {
3119 		/*
3120 		   Attempt to Abort this CCB.  MultiMaster Firmware versions
3121 		   prior to 5.xx do not generate Abort Tag messages, but only
3122 		   generate the non-tagged Abort message.  Since non-tagged
3123 		   commands are not sent by the Host Adapter until the queue
3124 		   of outstanding tagged commands has completed, and the
3125 		   Abort message is treated as a non-tagged command, it is
3126 		   effectively impossible to abort commands when Tagged
3127 		   Queuing is active. Firmware version 5.xx does generate
3128 		   Abort Tag messages, so it is possible to abort commands
3129 		   when Tagged Queuing is active.
3130 		 */
3131 		if (adapter->tgt_flags[tgt_id].tagq_active &&
3132 				adapter->fw_ver[0] < '5') {
3133 			blogic_warn("Unable to Abort CCB #%ld to Target %d - Abort Tag Not Supported\n", adapter, ccb->serial, tgt_id);
3134 			return FAILURE;
3135 		} else if (blogic_write_outbox(adapter, BLOGIC_MBOX_ABORT,
3136 					ccb)) {
3137 			blogic_warn("Aborting CCB #%ld to Target %d\n",
3138 					adapter, ccb->serial, tgt_id);
3139 			blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_tried);
3140 			return SUCCESS;
3141 		} else {
3142 			blogic_warn("Unable to Abort CCB #%ld to Target %d - No Outgoing Mailboxes\n", adapter, ccb->serial, tgt_id);
3143 			return FAILURE;
3144 		}
3145 	} else {
3146 		/*
3147 		   Call the FlashPoint SCCB Manager to abort execution of
3148 		   the CCB.
3149 		 */
3150 		blogic_warn("Aborting CCB #%ld to Target %d\n", adapter,
3151 				ccb->serial, tgt_id);
3152 		blogic_inc_count(&adapter->tgt_stats[tgt_id].aborts_tried);
3153 		FlashPoint_AbortCCB(adapter->cardhandle, ccb);
3154 		/*
3155 		   The Abort may have already been completed and
3156 		   blogic_qcompleted_ccb been called, or it
3157 		   may still be pending.
3158 		 */
3159 		if (ccb->status == BLOGIC_CCB_COMPLETE)
3160 			blogic_process_ccbs(adapter);
3161 		return SUCCESS;
3162 	}
3163 	return SUCCESS;
3164 }
3165 
3166 #endif
3167 /*
3168   blogic_resetadapter resets Host Adapter if possible, marking all
3169   currently executing SCSI Commands as having been Reset.
3170 */
3171 
3172 static int blogic_resetadapter(struct blogic_adapter *adapter, bool hard_reset)
3173 {
3174 	struct blogic_ccb *ccb;
3175 	int tgt_id;
3176 
3177 	/*
3178 	 * Attempt to Reset and Reinitialize the Host Adapter.
3179 	 */
3180 
3181 	if (!(blogic_hwreset(adapter, hard_reset) &&
3182 				blogic_initadapter(adapter))) {
3183 		blogic_err("Resetting %s Failed\n", adapter,
3184 						adapter->full_model);
3185 		return FAILURE;
3186 	}
3187 
3188 	/*
3189 	 * Deallocate all currently executing CCBs.
3190 	 */
3191 
3192 	for (ccb = adapter->all_ccbs; ccb != NULL; ccb = ccb->next_all)
3193 		if (ccb->status == BLOGIC_CCB_ACTIVE)
3194 			blogic_dealloc_ccb(ccb, 1);
3195 	/*
3196 	 * Wait a few seconds between the Host Adapter Hard Reset which
3197 	 * initiates a SCSI Bus Reset and issuing any SCSI Commands.  Some
3198 	 * SCSI devices get confused if they receive SCSI Commands too soon
3199 	 * after a SCSI Bus Reset.
3200 	 */
3201 
3202 	if (hard_reset) {
3203 		spin_unlock_irq(adapter->scsi_host->host_lock);
3204 		blogic_delay(adapter->bus_settle_time);
3205 		spin_lock_irq(adapter->scsi_host->host_lock);
3206 	}
3207 
3208 	for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) {
3209 		adapter->last_resettried[tgt_id] = jiffies;
3210 		adapter->last_resetdone[tgt_id] = jiffies;
3211 	}
3212 	return SUCCESS;
3213 }
3214 
3215 /*
3216   blogic_diskparam returns the Heads/Sectors/Cylinders BIOS Disk
3217   Parameters for Disk.  The default disk geometry is 64 heads, 32 sectors, and
3218   the appropriate number of cylinders so as not to exceed drive capacity.  In
3219   order for disks equal to or larger than 1 GB to be addressable by the BIOS
3220   without exceeding the BIOS limitation of 1024 cylinders, Extended Translation
3221   may be enabled in AutoSCSI on FlashPoint Host Adapters and on "W" and "C"
3222   series MultiMaster Host Adapters, or by a dip switch setting on "S" and "A"
3223   series MultiMaster Host Adapters.  With Extended Translation enabled, drives
3224   between 1 GB inclusive and 2 GB exclusive are given a disk geometry of 128
3225   heads and 32 sectors, and drives above 2 GB inclusive are given a disk
3226   geometry of 255 heads and 63 sectors.  However, if the BIOS detects that the
3227   Extended Translation setting does not match the geometry in the partition
3228   table, then the translation inferred from the partition table will be used by
3229   the BIOS, and a warning may be displayed.
3230 */
3231 
blogic_diskparam(struct scsi_device * sdev,struct block_device * dev,sector_t capacity,int * params)3232 static int blogic_diskparam(struct scsi_device *sdev, struct block_device *dev,
3233 		sector_t capacity, int *params)
3234 {
3235 	struct blogic_adapter *adapter =
3236 				(struct blogic_adapter *) sdev->host->hostdata;
3237 	struct bios_diskparam *diskparam = (struct bios_diskparam *) params;
3238 	unsigned char *buf;
3239 
3240 	if (adapter->ext_trans_enable && capacity >= 2 * 1024 * 1024 /* 1 GB in 512 byte sectors */) {
3241 		if (capacity >= 4 * 1024 * 1024 /* 2 GB in 512 byte sectors */) {
3242 			diskparam->heads = 255;
3243 			diskparam->sectors = 63;
3244 		} else {
3245 			diskparam->heads = 128;
3246 			diskparam->sectors = 32;
3247 		}
3248 	} else {
3249 		diskparam->heads = 64;
3250 		diskparam->sectors = 32;
3251 	}
3252 	diskparam->cylinders = (unsigned long) capacity / (diskparam->heads * diskparam->sectors);
3253 	buf = scsi_bios_ptable(dev);
3254 	if (buf == NULL)
3255 		return 0;
3256 	/*
3257 	   If the boot sector partition table flag is valid, search for
3258 	   a partition table entry whose end_head matches one of the
3259 	   standard BusLogic geometry translations (64/32, 128/32, or 255/63).
3260 	 */
3261 	if (*(unsigned short *) (buf + 64) == MSDOS_LABEL_MAGIC) {
3262 		struct msdos_partition *part1_entry =
3263 				(struct msdos_partition *)buf;
3264 		struct msdos_partition *part_entry = part1_entry;
3265 		int saved_cyl = diskparam->cylinders, part_no;
3266 		unsigned char part_end_head = 0, part_end_sector = 0;
3267 
3268 		for (part_no = 0; part_no < 4; part_no++) {
3269 			part_end_head = part_entry->end_head;
3270 			part_end_sector = part_entry->end_sector & 0x3F;
3271 			if (part_end_head == 64 - 1) {
3272 				diskparam->heads = 64;
3273 				diskparam->sectors = 32;
3274 				break;
3275 			} else if (part_end_head == 128 - 1) {
3276 				diskparam->heads = 128;
3277 				diskparam->sectors = 32;
3278 				break;
3279 			} else if (part_end_head == 255 - 1) {
3280 				diskparam->heads = 255;
3281 				diskparam->sectors = 63;
3282 				break;
3283 			}
3284 			part_entry++;
3285 		}
3286 		if (part_no == 4) {
3287 			part_end_head = part1_entry->end_head;
3288 			part_end_sector = part1_entry->end_sector & 0x3F;
3289 		}
3290 		diskparam->cylinders = (unsigned long) capacity / (diskparam->heads * diskparam->sectors);
3291 		if (part_no < 4 && part_end_sector == diskparam->sectors) {
3292 			if (diskparam->cylinders != saved_cyl)
3293 				blogic_warn("Adopting Geometry %d/%d from Partition Table\n", adapter, diskparam->heads, diskparam->sectors);
3294 		} else if (part_end_head > 0 || part_end_sector > 0) {
3295 			blogic_warn("Warning: Partition Table appears to have Geometry %d/%d which is\n", adapter, part_end_head + 1, part_end_sector);
3296 			blogic_warn("not compatible with current BusLogic Host Adapter Geometry %d/%d\n", adapter, diskparam->heads, diskparam->sectors);
3297 		}
3298 	}
3299 	kfree(buf);
3300 	return 0;
3301 }
3302 
3303 
3304 /*
3305   BugLogic_ProcDirectoryInfo implements /proc/scsi/BusLogic/<N>.
3306 */
3307 
blogic_write_info(struct Scsi_Host * shost,char * procbuf,int bytes_avail)3308 static int blogic_write_info(struct Scsi_Host *shost, char *procbuf,
3309 				int bytes_avail)
3310 {
3311 	struct blogic_adapter *adapter =
3312 				(struct blogic_adapter *) shost->hostdata;
3313 	struct blogic_tgt_stats *tgt_stats;
3314 
3315 	tgt_stats = adapter->tgt_stats;
3316 	adapter->ext_resets = 0;
3317 	adapter->adapter_intern_errors = 0;
3318 	memset(tgt_stats, 0, BLOGIC_MAXDEV * sizeof(struct blogic_tgt_stats));
3319 	return 0;
3320 }
3321 
blogic_show_info(struct seq_file * m,struct Scsi_Host * shost)3322 static int blogic_show_info(struct seq_file *m, struct Scsi_Host *shost)
3323 {
3324 	struct blogic_adapter *adapter = (struct blogic_adapter *) shost->hostdata;
3325 	struct blogic_tgt_stats *tgt_stats;
3326 	int tgt;
3327 
3328 	tgt_stats = adapter->tgt_stats;
3329 	seq_write(m, adapter->msgbuf, adapter->msgbuflen);
3330 	seq_printf(m, "\n\
3331 Current Driver Queue Depth:	%d\n\
3332 Currently Allocated CCBs:	%d\n", adapter->drvr_qdepth, adapter->alloc_ccbs);
3333 	seq_puts(m, "\n\n\
3334 			   DATA TRANSFER STATISTICS\n\
3335 \n\
3336 Target	Tagged Queuing	Queue Depth  Active  Attempted	Completed\n\
3337 ======	==============	===========  ======  =========	=========\n");
3338 	for (tgt = 0; tgt < adapter->maxdev; tgt++) {
3339 		struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
3340 		if (!tgt_flags->tgt_exists)
3341 			continue;
3342 		seq_printf(m, "  %2d	%s", tgt, (tgt_flags->tagq_ok ? (tgt_flags->tagq_active ? "    Active" : (adapter->tagq_ok & (1 << tgt)
3343 																				    ? "  Permitted" : "   Disabled"))
3344 									  : "Not Supported"));
3345 		seq_printf(m,
3346 				  "	    %3d       %3u    %9u	%9u\n", adapter->qdepth[tgt], adapter->active_cmds[tgt], tgt_stats[tgt].cmds_tried, tgt_stats[tgt].cmds_complete);
3347 	}
3348 	seq_puts(m, "\n\
3349 Target  Read Commands  Write Commands   Total Bytes Read    Total Bytes Written\n\
3350 ======  =============  ==============  ===================  ===================\n");
3351 	for (tgt = 0; tgt < adapter->maxdev; tgt++) {
3352 		struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
3353 		if (!tgt_flags->tgt_exists)
3354 			continue;
3355 		seq_printf(m, "  %2d	  %9u	 %9u", tgt, tgt_stats[tgt].read_cmds, tgt_stats[tgt].write_cmds);
3356 		if (tgt_stats[tgt].bytesread.billions > 0)
3357 			seq_printf(m, "     %9u%09u", tgt_stats[tgt].bytesread.billions, tgt_stats[tgt].bytesread.units);
3358 		else
3359 			seq_printf(m, "		%9u", tgt_stats[tgt].bytesread.units);
3360 		if (tgt_stats[tgt].byteswritten.billions > 0)
3361 			seq_printf(m, "   %9u%09u\n", tgt_stats[tgt].byteswritten.billions, tgt_stats[tgt].byteswritten.units);
3362 		else
3363 			seq_printf(m, "	     %9u\n", tgt_stats[tgt].byteswritten.units);
3364 	}
3365 	seq_puts(m, "\n\
3366 Target  Command    0-1KB      1-2KB      2-4KB      4-8KB     8-16KB\n\
3367 ======  =======  =========  =========  =========  =========  =========\n");
3368 	for (tgt = 0; tgt < adapter->maxdev; tgt++) {
3369 		struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
3370 		if (!tgt_flags->tgt_exists)
3371 			continue;
3372 		seq_printf(m,
3373 			    "  %2d	 Read	 %9u  %9u  %9u  %9u  %9u\n", tgt,
3374 			    tgt_stats[tgt].read_sz_buckets[0],
3375 			    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]);
3376 		seq_printf(m,
3377 			    "  %2d	 Write	 %9u  %9u  %9u  %9u  %9u\n", tgt,
3378 			    tgt_stats[tgt].write_sz_buckets[0],
3379 			    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]);
3380 	}
3381 	seq_puts(m, "\n\
3382 Target  Command   16-32KB    32-64KB   64-128KB   128-256KB   256KB+\n\
3383 ======  =======  =========  =========  =========  =========  =========\n");
3384 	for (tgt = 0; tgt < adapter->maxdev; tgt++) {
3385 		struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
3386 		if (!tgt_flags->tgt_exists)
3387 			continue;
3388 		seq_printf(m,
3389 			    "  %2d	 Read	 %9u  %9u  %9u  %9u  %9u\n", tgt,
3390 			    tgt_stats[tgt].read_sz_buckets[5],
3391 			    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]);
3392 		seq_printf(m,
3393 			    "  %2d	 Write	 %9u  %9u  %9u  %9u  %9u\n", tgt,
3394 			    tgt_stats[tgt].write_sz_buckets[5],
3395 			    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]);
3396 	}
3397 	seq_puts(m, "\n\n\
3398 			   ERROR RECOVERY STATISTICS\n\
3399 \n\
3400 	  Command Aborts      Bus Device Resets	  Host Adapter Resets\n\
3401 Target	Requested Completed  Requested Completed  Requested Completed\n\
3402   ID	\\\\\\\\ Attempted ////  \\\\\\\\ Attempted ////  \\\\\\\\ Attempted ////\n\
3403 ======	 ===== ===== =====    ===== ===== =====	   ===== ===== =====\n");
3404 	for (tgt = 0; tgt < adapter->maxdev; tgt++) {
3405 		struct blogic_tgt_flags *tgt_flags = &adapter->tgt_flags[tgt];
3406 		if (!tgt_flags->tgt_exists)
3407 			continue;
3408 		seq_printf(m, "  %2d	 %5d %5d %5d    %5d %5d %5d	   %5d %5d %5d\n",
3409 			   tgt, tgt_stats[tgt].aborts_request,
3410 			   tgt_stats[tgt].aborts_tried,
3411 			   tgt_stats[tgt].aborts_done,
3412 			   tgt_stats[tgt].bdr_request,
3413 			   tgt_stats[tgt].bdr_tried,
3414 			   tgt_stats[tgt].bdr_done,
3415 			   tgt_stats[tgt].adapter_reset_req,
3416 			   tgt_stats[tgt].adapter_reset_attempt,
3417 			   tgt_stats[tgt].adapter_reset_done);
3418 	}
3419 	seq_printf(m, "\nExternal Host Adapter Resets: %d\n", adapter->ext_resets);
3420 	seq_printf(m, "Host Adapter Internal Errors: %d\n", adapter->adapter_intern_errors);
3421 	return 0;
3422 }
3423 
3424 
3425 /*
3426   blogic_msg prints Driver Messages.
3427 */
3428 __printf(2, 4)
blogic_msg(enum blogic_msglevel msglevel,char * fmt,struct blogic_adapter * adapter,...)3429 static void blogic_msg(enum blogic_msglevel msglevel, char *fmt,
3430 			struct blogic_adapter *adapter, ...)
3431 {
3432 	static char buf[BLOGIC_LINEBUF_SIZE];
3433 	static bool begin = true;
3434 	va_list args;
3435 	int len = 0;
3436 
3437 	va_start(args, adapter);
3438 	len = vscnprintf(buf, sizeof(buf), fmt, args);
3439 	va_end(args);
3440 	if (msglevel == BLOGIC_ANNOUNCE_LEVEL) {
3441 		static int msglines = 0;
3442 		strcpy(&adapter->msgbuf[adapter->msgbuflen], buf);
3443 		adapter->msgbuflen += len;
3444 		if (++msglines <= 2)
3445 			printk("%sscsi: %s", blogic_msglevelmap[msglevel], buf);
3446 	} else if (msglevel == BLOGIC_INFO_LEVEL) {
3447 		strcpy(&adapter->msgbuf[adapter->msgbuflen], buf);
3448 		adapter->msgbuflen += len;
3449 		if (begin) {
3450 			if (buf[0] != '\n' || len > 1)
3451 				printk("%sscsi%d: %s", blogic_msglevelmap[msglevel], adapter->host_no, buf);
3452 		} else
3453 			pr_cont("%s", buf);
3454 	} else {
3455 		if (begin) {
3456 			if (adapter != NULL && adapter->adapter_initd)
3457 				printk("%sscsi%d: %s", blogic_msglevelmap[msglevel], adapter->host_no, buf);
3458 			else
3459 				printk("%s%s", blogic_msglevelmap[msglevel], buf);
3460 		} else
3461 			pr_cont("%s", buf);
3462 	}
3463 	begin = (buf[len - 1] == '\n');
3464 }
3465 
3466 
3467 /*
3468   blogic_parse parses an individual option keyword.  It returns true
3469   and updates the pointer if the keyword is recognized and false otherwise.
3470 */
3471 
blogic_parse(char ** str,char * keyword)3472 static bool __init blogic_parse(char **str, char *keyword)
3473 {
3474 	char *pointer = *str;
3475 	while (*keyword != '\0') {
3476 		char strch = *pointer++;
3477 		char keywordch = *keyword++;
3478 		if (strch >= 'A' && strch <= 'Z')
3479 			strch += 'a' - 'Z';
3480 		if (keywordch >= 'A' && keywordch <= 'Z')
3481 			keywordch += 'a' - 'Z';
3482 		if (strch != keywordch)
3483 			return false;
3484 	}
3485 	*str = pointer;
3486 	return true;
3487 }
3488 
3489 
3490 /*
3491   blogic_parseopts handles processing of BusLogic Driver Options
3492   specifications.
3493 
3494   BusLogic Driver Options may be specified either via the Linux Kernel Command
3495   Line or via the Loadable Kernel Module Installation Facility.  Driver Options
3496   for multiple host adapters may be specified either by separating the option
3497   strings by a semicolon, or by specifying multiple "BusLogic=" strings on the
3498   command line.  Individual option specifications for a single host adapter are
3499   separated by commas.  The Probing and Debugging Options apply to all host
3500   adapters whereas the remaining options apply individually only to the
3501   selected host adapter.
3502 
3503   The BusLogic Driver Probing Options are described in
3504   <file:Documentation/scsi/BusLogic.rst>.
3505 */
3506 
blogic_parseopts(char * options)3507 static int __init blogic_parseopts(char *options)
3508 {
3509 	while (true) {
3510 		struct blogic_drvr_options *drvr_opts =
3511 			&blogic_drvr_options[blogic_drvr_options_count++];
3512 		int tgt_id;
3513 
3514 		memset(drvr_opts, 0, sizeof(struct blogic_drvr_options));
3515 		while (*options != '\0' && *options != ';') {
3516 			if (blogic_parse(&options, "NoProbePCI"))
3517 				blogic_probe_options.noprobe_pci = true;
3518 			else if (blogic_parse(&options, "NoProbe"))
3519 				blogic_probe_options.noprobe = true;
3520 			else if (blogic_parse(&options, "NoSortPCI"))
3521 				blogic_probe_options.nosort_pci = true;
3522 			else if (blogic_parse(&options, "MultiMasterFirst"))
3523 				blogic_probe_options.multimaster_first = true;
3524 			else if (blogic_parse(&options, "FlashPointFirst"))
3525 				blogic_probe_options.flashpoint_first = true;
3526 			/* Tagged Queuing Options. */
3527 			else if (blogic_parse(&options, "QueueDepth:[") ||
3528 					blogic_parse(&options, "QD:[")) {
3529 				for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++) {
3530 					unsigned short qdepth = simple_strtoul(options, &options, 0);
3531 					if (qdepth > BLOGIC_MAX_TAG_DEPTH) {
3532 						blogic_err("BusLogic: Invalid Driver Options (invalid Queue Depth %d)\n", NULL, qdepth);
3533 						return 0;
3534 					}
3535 					drvr_opts->qdepth[tgt_id] = qdepth;
3536 					if (*options == ',')
3537 						options++;
3538 					else if (*options == ']')
3539 						break;
3540 					else {
3541 						blogic_err("BusLogic: Invalid Driver Options (',' or ']' expected at '%s')\n", NULL, options);
3542 						return 0;
3543 					}
3544 				}
3545 				if (*options != ']') {
3546 					blogic_err("BusLogic: Invalid Driver Options (']' expected at '%s')\n", NULL, options);
3547 					return 0;
3548 				} else
3549 					options++;
3550 			} else if (blogic_parse(&options, "QueueDepth:") || blogic_parse(&options, "QD:")) {
3551 				unsigned short qdepth = simple_strtoul(options, &options, 0);
3552 				if (qdepth == 0 ||
3553 						qdepth > BLOGIC_MAX_TAG_DEPTH) {
3554 					blogic_err("BusLogic: Invalid Driver Options (invalid Queue Depth %d)\n", NULL, qdepth);
3555 					return 0;
3556 				}
3557 				drvr_opts->common_qdepth = qdepth;
3558 				for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++)
3559 					drvr_opts->qdepth[tgt_id] = qdepth;
3560 			} else if (blogic_parse(&options, "TaggedQueuing:") ||
3561 					blogic_parse(&options, "TQ:")) {
3562 				if (blogic_parse(&options, "Default")) {
3563 					drvr_opts->tagq_ok = 0x0000;
3564 					drvr_opts->tagq_ok_mask = 0x0000;
3565 				} else if (blogic_parse(&options, "Enable")) {
3566 					drvr_opts->tagq_ok = 0xFFFF;
3567 					drvr_opts->tagq_ok_mask = 0xFFFF;
3568 				} else if (blogic_parse(&options, "Disable")) {
3569 					drvr_opts->tagq_ok = 0x0000;
3570 					drvr_opts->tagq_ok_mask = 0xFFFF;
3571 				} else {
3572 					unsigned short tgt_bit;
3573 					for (tgt_id = 0, tgt_bit = 1;
3574 						tgt_id < BLOGIC_MAXDEV;
3575 						tgt_id++, tgt_bit <<= 1)
3576 						switch (*options++) {
3577 						case 'Y':
3578 							drvr_opts->tagq_ok |= tgt_bit;
3579 							drvr_opts->tagq_ok_mask |= tgt_bit;
3580 							break;
3581 						case 'N':
3582 							drvr_opts->tagq_ok &= ~tgt_bit;
3583 							drvr_opts->tagq_ok_mask |= tgt_bit;
3584 							break;
3585 						case 'X':
3586 							break;
3587 						default:
3588 							options--;
3589 							tgt_id = BLOGIC_MAXDEV;
3590 							break;
3591 						}
3592 				}
3593 			}
3594 			/* Miscellaneous Options. */
3595 			else if (blogic_parse(&options, "BusSettleTime:") ||
3596 					blogic_parse(&options, "BST:")) {
3597 				unsigned short bus_settle_time =
3598 					simple_strtoul(options, &options, 0);
3599 				if (bus_settle_time > 5 * 60) {
3600 					blogic_err("BusLogic: Invalid Driver Options (invalid Bus Settle Time %d)\n", NULL, bus_settle_time);
3601 					return 0;
3602 				}
3603 				drvr_opts->bus_settle_time = bus_settle_time;
3604 			} else if (blogic_parse(&options,
3605 						"InhibitTargetInquiry"))
3606 				drvr_opts->stop_tgt_inquiry = true;
3607 			/* Debugging Options. */
3608 			else if (blogic_parse(&options, "TraceProbe"))
3609 				blogic_global_options.trace_probe = true;
3610 			else if (blogic_parse(&options, "TraceHardwareReset"))
3611 				blogic_global_options.trace_hw_reset = true;
3612 			else if (blogic_parse(&options, "TraceConfiguration"))
3613 				blogic_global_options.trace_config = true;
3614 			else if (blogic_parse(&options, "TraceErrors"))
3615 				blogic_global_options.trace_err = true;
3616 			else if (blogic_parse(&options, "Debug")) {
3617 				blogic_global_options.trace_probe = true;
3618 				blogic_global_options.trace_hw_reset = true;
3619 				blogic_global_options.trace_config = true;
3620 				blogic_global_options.trace_err = true;
3621 			}
3622 			if (*options == ',')
3623 				options++;
3624 			else if (*options != ';' && *options != '\0') {
3625 				blogic_err("BusLogic: Unexpected Driver Option '%s' ignored\n", NULL, options);
3626 				*options = '\0';
3627 			}
3628 		}
3629 		if (!(blogic_drvr_options_count == 0 ||
3630 			blogic_probeinfo_count == 0 ||
3631 			blogic_drvr_options_count == blogic_probeinfo_count)) {
3632 			blogic_err("BusLogic: Invalid Driver Options (all or no I/O Addresses must be specified)\n", NULL);
3633 			return 0;
3634 		}
3635 		/*
3636 		   Tagged Queuing is disabled when the Queue Depth is 1 since queuing
3637 		   multiple commands is not possible.
3638 		 */
3639 		for (tgt_id = 0; tgt_id < BLOGIC_MAXDEV; tgt_id++)
3640 			if (drvr_opts->qdepth[tgt_id] == 1) {
3641 				unsigned short tgt_bit = 1 << tgt_id;
3642 				drvr_opts->tagq_ok &= ~tgt_bit;
3643 				drvr_opts->tagq_ok_mask |= tgt_bit;
3644 			}
3645 		if (*options == ';')
3646 			options++;
3647 		if (*options == '\0')
3648 			return 0;
3649 	}
3650 	return 1;
3651 }
3652 
3653 /*
3654   Get it all started
3655 */
3656 
3657 static struct scsi_host_template blogic_template = {
3658 	.module = THIS_MODULE,
3659 	.proc_name = "BusLogic",
3660 	.write_info = blogic_write_info,
3661 	.show_info = blogic_show_info,
3662 	.name = "BusLogic",
3663 	.info = blogic_drvr_info,
3664 	.queuecommand = blogic_qcmd,
3665 	.slave_configure = blogic_slaveconfig,
3666 	.bios_param = blogic_diskparam,
3667 	.eh_host_reset_handler = blogic_hostreset,
3668 #if 0
3669 	.eh_abort_handler = blogic_abort,
3670 #endif
3671 	.max_sectors = 128,
3672 };
3673 
3674 /*
3675   blogic_setup handles processing of Kernel Command Line Arguments.
3676 */
3677 
blogic_setup(char * str)3678 static int __init blogic_setup(char *str)
3679 {
3680 	int ints[3];
3681 
3682 	(void) get_options(str, ARRAY_SIZE(ints), ints);
3683 
3684 	if (ints[0] != 0) {
3685 		blogic_err("BusLogic: Obsolete Command Line Entry Format Ignored\n", NULL);
3686 		return 0;
3687 	}
3688 	if (str == NULL || *str == '\0')
3689 		return 0;
3690 	return blogic_parseopts(str);
3691 }
3692 
3693 /*
3694  * Exit function.  Deletes all hosts associated with this driver.
3695  */
3696 
blogic_exit(void)3697 static void __exit blogic_exit(void)
3698 {
3699 	struct blogic_adapter *ha, *next;
3700 
3701 	list_for_each_entry_safe(ha, next, &blogic_host_list, host_list)
3702 		blogic_deladapter(ha);
3703 }
3704 
3705 __setup("BusLogic=", blogic_setup);
3706 
3707 #ifdef MODULE
3708 /*static struct pci_device_id blogic_pci_tbl[] = {
3709 	{ PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER,
3710 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
3711 	{ PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC,
3712 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
3713 	{ PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT,
3714 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
3715 	{ }
3716 };*/
3717 static const struct pci_device_id blogic_pci_tbl[] = {
3718 	{PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER)},
3719 	{PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC)},
3720 	{PCI_DEVICE(PCI_VENDOR_ID_BUSLOGIC, PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT)},
3721 	{0, },
3722 };
3723 #endif
3724 MODULE_DEVICE_TABLE(pci, blogic_pci_tbl);
3725 
3726 module_init(blogic_init);
3727 module_exit(blogic_exit);
3728