![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to BusLogic.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to BusLogic.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 root 1: /*
2:
3: Linux Driver for BusLogic MultiMaster SCSI Host Adapters
4:
5: Copyright 1995 by Leonard N. Zubkoff <[email protected]>
6:
7: This program is free software; you may redistribute and/or modify it under
8: the terms of the GNU General Public License Version 2 as published by the
9: Free Software Foundation, provided that none of the source code or runtime
10: copyright notices are removed or modified.
11:
12: This program is distributed in the hope that it will be useful, but
13: WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY
14: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15: for complete details.
16:
17: The author respectfully requests that all modifications to this software be
18: sent directly to him for evaluation and testing.
19:
20: Special thanks to Alex T. Win of BusLogic, whose advice has been invaluable,
21: to David B. Gentzel, for writing the original Linux BusLogic driver, and to
22: Paul Gortmaker, for being such a dedicated test site.
23:
24: */
25:
26:
27: #define BusLogic_DriverVersion "1.3.1"
28: #define BusLogic_DriverDate "31 December 1995"
29:
30:
31: #include <linux/module.h>
32: #include <linux/config.h>
33: #include <linux/types.h>
34: #include <linux/blkdev.h>
35: #include <linux/delay.h>
36: #include <linux/ioport.h>
37: #include <linux/kernel_stat.h>
38: #include <linux/mm.h>
39: #include <linux/sched.h>
40: #include <linux/stat.h>
41: #include <linux/pci.h>
42: #include <linux/bios32.h>
43: #include <asm/dma.h>
44: #include <asm/io.h>
45: #include <asm/system.h>
46: #include "scsi.h"
47: #include "hosts.h"
48: #include "sd.h"
49: #include "BusLogic.h"
50:
51:
52: /*
53: BusLogic_CommandLineEntryCount is a count of the number of "BusLogic="
54: entries provided on the Linux Kernel Command Line.
55: */
56:
57: static int
58: BusLogic_CommandLineEntryCount = 0;
59:
60:
61: /*
62: BusLogic_CommandLineEntries is an array of Command Line Entry structures
63: representing the "BusLogic=" entries provided on the Linux Kernel Command
64: Line.
65: */
66:
67: static BusLogic_CommandLineEntry_T
68: BusLogic_CommandLineEntries[BusLogic_MaxHostAdapters];
69:
70:
71: /*
72: BusLogic_GlobalOptions is a bit mask of Global Options to be applied
73: across all Host Adapters.
74: */
75:
76: static int
77: BusLogic_GlobalOptions = 0;
78:
79:
80: /*
81: BusLogic_RegisteredHostAdapters is a linked list of all the registered
82: BusLogic Host Adapters.
83: */
84:
85: static BusLogic_HostAdapter_T
86: *BusLogic_RegisteredHostAdapters = NULL;
87:
88:
89: /*
90: BusLogic_Standard_IO_Addresses is the list of standard I/O Addresses at which
91: BusLogic Host Adapters may potentially be found.
92: */
93:
94: static unsigned short
95: BusLogic_IO_StandardAddresses[] =
96: { 0x330, 0x334, 0x230, 0x234, 0x130, 0x134, 0 };
97:
98:
99: /*
100: BusLogic_IO_AddressProbeList is the list of I/O Addresses to be probed for
101: potential BusLogic Host Adapters. It is initialized by interrogating the
102: PCI Configuration Space on PCI machines as well as from the list of
103: standard BusLogic I/O Addresses.
104: */
105:
106: static unsigned short
107: BusLogic_IO_AddressProbeList[BusLogic_IO_MaxProbeAddresses+1] = { 0 };
108:
109:
110: /*
111: BusLogic_IRQ_UsageCount stores a count of the number of Host Adapters using
112: a given IRQ Channel, which is necessary to support PCI, EISA, or MCA shared
113: interrupts. Only IRQ Channels 9, 10, 11, 12, 14, and 15 are supported by
114: BusLogic Host Adapters.
115: */
116:
117: static short
118: BusLogic_IRQ_UsageCount[7] = { 0 };
119:
120:
121: /*
122: BusLogic_CommandFailureReason holds a string identifying the reason why a
123: call to BusLogic_Command failed. It is only valid when BusLogic_Command
124: returns a failure code.
125: */
126:
127: static char
128: *BusLogic_CommandFailureReason;
129:
130:
131: /*
132: BusLogic_ProcDirectoryEntry is the BusLogic /proc/scsi directory entry.
133: */
134:
135: static struct proc_dir_entry
136: BusLogic_ProcDirectoryEntry =
137: { PROC_SCSI_BUSLOGIC, 8, "BusLogic", S_IFDIR | S_IRUGO | S_IXUGO, 2 };
138:
139:
140: /*
141: BusLogic_AnnounceDriver announces the Driver Version and Date, Author's
142: Name, Copyright Notice, and Contact Address.
143: */
144:
145: static void BusLogic_AnnounceDriver(void)
146: {
147: static boolean DriverAnnouncementPrinted = false;
148: if (DriverAnnouncementPrinted) return;
149: printk("scsi: ***** BusLogic SCSI Driver Version "
150: BusLogic_DriverVersion " of " BusLogic_DriverDate " *****\n");
151: printk("scsi: Copyright 1995 by Leonard N. Zubkoff <[email protected]>\n");
152: DriverAnnouncementPrinted = true;
153: }
154:
155:
156: /*
157: BusLogic_DriverInfo returns the Board Name to identify this SCSI Driver
158: and Host Adapter.
159: */
160:
161: const char *BusLogic_DriverInfo(SCSI_Host_T *Host)
162: {
163: BusLogic_HostAdapter_T *HostAdapter =
164: (BusLogic_HostAdapter_T *) Host->hostdata;
165: return HostAdapter->BoardName;
166: }
167:
168:
169: /*
170: BusLogic_InitializeAddressProbeList initializes the list of I/O Addresses
171: to be probed for potential BusLogic SCSI Host Adapters by interrogating the
172: PCI Configuration Space on PCI machines as well as from the list of standard
173: BusLogic I/O Addresses.
174: */
175:
176: static void BusLogic_InitializeAddressProbeList(void)
177: {
178: int DestinationIndex = 0, SourceIndex = 0;
179: /*
180: If BusLogic_Setup has been called, do not override the Kernel Command
181: Line specifications.
182: */
183: if (BusLogic_IO_AddressProbeList[0] != 0) return;
184: #ifdef CONFIG_PCI
185: /*
186: Interrogate PCI Configuration Space for any BusLogic SCSI Host Adapters.
187: */
188: if (pcibios_present())
189: {
190: unsigned short Index = 0, VendorID;
191: unsigned char Bus, DeviceAndFunction;
192: unsigned int BaseAddress0;
193: while (pcibios_find_class(PCI_CLASS_STORAGE_SCSI<<8, Index++,
194: &Bus, &DeviceAndFunction) == 0)
195: if (pcibios_read_config_word(Bus, DeviceAndFunction,
196: PCI_VENDOR_ID, &VendorID) == 0 &&
197: VendorID == PCI_VENDOR_ID_BUSLOGIC &&
198: pcibios_read_config_dword(Bus, DeviceAndFunction,
199: PCI_BASE_ADDRESS_0, &BaseAddress0) == 0 &&
200: (BaseAddress0 & PCI_BASE_ADDRESS_SPACE) ==
201: PCI_BASE_ADDRESS_SPACE_IO)
202: {
203: BusLogic_IO_AddressProbeList[DestinationIndex++] =
204: BaseAddress0 & PCI_BASE_ADDRESS_IO_MASK;
205: }
206: }
207: #endif
208: /*
209: Append the list of standard BusLogic I/O Addresses.
210: */
211: while (DestinationIndex < BusLogic_IO_MaxProbeAddresses &&
212: BusLogic_IO_StandardAddresses[SourceIndex] > 0)
213: BusLogic_IO_AddressProbeList[DestinationIndex++] =
214: BusLogic_IO_StandardAddresses[SourceIndex++];
215: BusLogic_IO_AddressProbeList[DestinationIndex] = 0;
216: }
217:
218:
219: /*
220: BusLogic_RegisterHostAdapter adds Host Adapter to the list of registered
221: BusLogic Host Adapters.
222: */
223:
224: static void BusLogic_RegisterHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
225: {
226: HostAdapter->Next = NULL;
227: if (BusLogic_RegisteredHostAdapters != NULL)
228: {
229: BusLogic_HostAdapter_T *LastHostAdapter = BusLogic_RegisteredHostAdapters;
230: BusLogic_HostAdapter_T *NextHostAdapter;
231: while ((NextHostAdapter = LastHostAdapter->Next) != NULL)
232: LastHostAdapter = NextHostAdapter;
233: LastHostAdapter->Next = HostAdapter;
234: }
235: else BusLogic_RegisteredHostAdapters = HostAdapter;
236: }
237:
238:
239: /*
240: BusLogic_UnregisterHostAdapter removes Host Adapter from the list of
241: registered BusLogic Host Adapters.
242: */
243:
244: static void BusLogic_UnregisterHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
245: {
246: if (BusLogic_RegisteredHostAdapters != HostAdapter)
247: {
248: BusLogic_HostAdapter_T *LastHostAdapter = BusLogic_RegisteredHostAdapters;
249: while (LastHostAdapter != NULL && LastHostAdapter->Next != HostAdapter)
250: LastHostAdapter = LastHostAdapter->Next;
251: if (LastHostAdapter != NULL)
252: LastHostAdapter->Next = HostAdapter->Next;
253: }
254: else BusLogic_RegisteredHostAdapters = HostAdapter->Next;
255: HostAdapter->Next = NULL;
256: }
257:
258:
259: /*
260: BusLogic_CreateCCBs allocates the initial Command Control Blocks (CCBs)
261: for Host Adapter.
262: */
263:
264: static boolean BusLogic_CreateCCBs(BusLogic_HostAdapter_T *HostAdapter)
265: {
266: int i;
267: for (i = 0; i < BusLogic_InitialCCBs; i++)
268: {
269: BusLogic_CCB_T *CCB = (BusLogic_CCB_T *)
270: scsi_init_malloc(sizeof(BusLogic_CCB_T), GFP_ATOMIC | GFP_DMA);
271: if (CCB == NULL)
272: {
273: printk("scsi%d: UNABLE TO ALLOCATE CCB %d - DETACHING\n",
274: HostAdapter->HostNumber, i);
275: return false;
276: }
277: memset(CCB, 0, sizeof(BusLogic_CCB_T));
278: CCB->HostAdapter = HostAdapter;
279: CCB->Status = BusLogic_CCB_Free;
280: CCB->Next = HostAdapter->Free_CCBs;
281: CCB->NextAll = HostAdapter->All_CCBs;
282: HostAdapter->Free_CCBs = CCB;
283: HostAdapter->All_CCBs = CCB;
284: }
285: return true;
286: }
287:
288:
289: /*
290: BusLogic_DestroyCCBs deallocates the CCBs for Host Adapter.
291: */
292:
293: static void BusLogic_DestroyCCBs(BusLogic_HostAdapter_T *HostAdapter)
294: {
295: BusLogic_CCB_T *NextCCB = HostAdapter->All_CCBs, *CCB;
296: HostAdapter->All_CCBs = NULL;
297: HostAdapter->Free_CCBs = NULL;
298: while ((CCB = NextCCB) != NULL)
299: {
300: NextCCB = CCB->NextAll;
301: scsi_init_free((char *) CCB, sizeof(BusLogic_CCB_T));
302: }
303: }
304:
305:
306: /*
307: BusLogic_AllocateCCB allocates a CCB from the Host Adapter's free list,
308: allocating more memory from the Kernel if necessary.
309: */
310:
311: static BusLogic_CCB_T *BusLogic_AllocateCCB(BusLogic_HostAdapter_T *HostAdapter)
312: {
313: static unsigned int SerialNumber = 0;
314: BusLogic_CCB_T *CCB;
315: BusLogic_LockHostAdapter(HostAdapter);
316: CCB = HostAdapter->Free_CCBs;
317: if (CCB != NULL)
318: {
319: CCB->SerialNumber = ++SerialNumber;
320: HostAdapter->Free_CCBs = CCB->Next;
321: CCB->Next = NULL;
322: BusLogic_UnlockHostAdapter(HostAdapter);
323: return CCB;
324: }
325: BusLogic_UnlockHostAdapter(HostAdapter);
326: CCB = (BusLogic_CCB_T *) scsi_init_malloc(sizeof(BusLogic_CCB_T),
327: GFP_ATOMIC | GFP_DMA);
328: if (CCB == NULL)
329: {
330: printk("scsi%d: Failed to allocate an additional CCB\n",
331: HostAdapter->HostNumber);
332: return NULL;
333: }
334: printk("scsi%d: Allocated an additional CCB\n", HostAdapter->HostNumber);
335: memset(CCB, 0, sizeof(BusLogic_CCB_T));
336: CCB->HostAdapter = HostAdapter;
337: CCB->Status = BusLogic_CCB_Free;
338: BusLogic_LockHostAdapter(HostAdapter);
339: CCB->SerialNumber = ++SerialNumber;
340: CCB->NextAll = HostAdapter->All_CCBs;
341: HostAdapter->All_CCBs = CCB;
342: BusLogic_UnlockHostAdapter(HostAdapter);
343: return CCB;
344: }
345:
346:
347: /*
348: BusLogic_DeallocateCCB deallocates a CCB, returning it to the Host Adapter's
349: free list.
350: */
351:
352: static void BusLogic_DeallocateCCB(BusLogic_CCB_T *CCB)
353: {
354: BusLogic_HostAdapter_T *HostAdapter = CCB->HostAdapter;
355: BusLogic_LockHostAdapter(HostAdapter);
356: CCB->Command = NULL;
357: CCB->Status = BusLogic_CCB_Free;
358: CCB->Next = HostAdapter->Free_CCBs;
359: HostAdapter->Free_CCBs = CCB;
360: BusLogic_UnlockHostAdapter(HostAdapter);
361: }
362:
363:
364: /*
365: BusLogic_Command sends the command OperationCode to HostAdapter, optionally
366: providing ParameterLength bytes of ParameterData and receiving at most
367: ReplyLength bytes of ReplyData; any excess reply data is received but
368: discarded.
369:
370: On success, this function returns the number of reply bytes read from
371: the Host Adapter (including any discarded data); on failure, it returns
372: -1 if the command was invalid, or -2 if a timeout occurred.
373:
374: This function is only called during board detection and initialization, so
375: performance and latency are not critical, and exclusive access to the Host
376: Adapter hardware is assumed. Once the board and driver are initialized, the
377: only Host Adapter command that is issued is the single byte Start Mailbox
378: Scan command, which does not require waiting for the Host Adapter Ready bit
379: to be set in the Status Register.
380: */
381:
382: static int BusLogic_Command(BusLogic_HostAdapter_T *HostAdapter,
383: BusLogic_OperationCode_T OperationCode,
384: void *ParameterData,
385: int ParameterLength,
386: void *ReplyData,
387: int ReplyLength)
388: {
389: unsigned char *ParameterPointer = (unsigned char *) ParameterData;
390: unsigned char *ReplyPointer = (unsigned char *) ReplyData;
391: unsigned char StatusRegister = 0, InterruptRegister;
392: long TimeoutCounter;
393: int ReplyBytes = 0;
394: /*
395: Clear out the Reply Data if provided.
396: */
397: if (ReplyLength > 0)
398: memset(ReplyData, 0, ReplyLength);
399: /*
400: Wait for the Host Adapter Ready bit to be set and the Command/Parameter
401: Register Busy bit to be reset in the Status Register.
402: */
403: TimeoutCounter = loops_per_sec >> 3;
404: while (--TimeoutCounter >= 0)
405: {
406: StatusRegister = BusLogic_ReadStatusRegister(HostAdapter);
407: if ((StatusRegister & BusLogic_HostAdapterReady) &&
408: !(StatusRegister & BusLogic_CommandParameterRegisterBusy))
409: break;
410: }
411: BusLogic_CommandFailureReason = "Timeout waiting for Host Adapter Ready";
412: if (TimeoutCounter < 0) return -2;
413: /*
414: Write the OperationCode to the Command/Parameter Register.
415: */
416: HostAdapter->HostAdapterCommandCompleted = false;
417: BusLogic_WriteCommandParameterRegister(HostAdapter, OperationCode);
418: /*
419: Write any additional Parameter Bytes.
420: */
421: TimeoutCounter = 10000;
422: while (ParameterLength > 0 && --TimeoutCounter >= 0)
423: {
424: /*
425: Wait 100 microseconds to give the Host Adapter enough time to determine
426: whether the last value written to the Command/Parameter Register was
427: valid or not. If the Command Complete bit is set in the Interrupt
428: Register, then the Command Invalid bit in the Status Register will be
429: reset if the Operation Code or Parameter was valid and the command
430: has completed, or set if the Operation Code or Parameter was invalid.
431: If the Data In Register Ready bit is set in the Status Register, then
432: the Operation Code was valid, and data is waiting to be read back
433: from the Host Adapter. Otherwise, wait for the Command/Parameter
434: Register Busy bit in the Status Register to be reset.
435: */
436: udelay(100);
437: InterruptRegister = BusLogic_ReadInterruptRegister(HostAdapter);
438: StatusRegister = BusLogic_ReadStatusRegister(HostAdapter);
439: if (InterruptRegister & BusLogic_CommandComplete) break;
440: if (HostAdapter->HostAdapterCommandCompleted) break;
441: if (StatusRegister & BusLogic_DataInRegisterReady) break;
442: if (StatusRegister & BusLogic_CommandParameterRegisterBusy) continue;
443: BusLogic_WriteCommandParameterRegister(HostAdapter, *ParameterPointer++);
444: ParameterLength--;
445: }
446: BusLogic_CommandFailureReason = "Timeout waiting for Parameter Acceptance";
447: if (TimeoutCounter < 0) return -2;
448: /*
449: The Modify I/O Address command does not cause a Command Complete Interrupt.
450: */
451: if (OperationCode == BusLogic_ModifyIOAddress)
452: {
453: StatusRegister = BusLogic_ReadStatusRegister(HostAdapter);
454: BusLogic_CommandFailureReason = "Modify I/O Address Invalid";
455: if (StatusRegister & BusLogic_CommandInvalid) return -1;
456: BusLogic_CommandFailureReason = NULL;
457: return 0;
458: }
459: /*
460: Select an appropriate timeout value for awaiting command completion.
461: */
462: switch (OperationCode)
463: {
464: case BusLogic_InquireInstalledDevicesID0to7:
465: case BusLogic_InquireInstalledDevicesID8to15:
466: /* Approximately 60 seconds. */
467: TimeoutCounter = loops_per_sec << 2;
468: break;
469: default:
470: /* Approximately 1 second. */
471: TimeoutCounter = loops_per_sec >> 4;
472: break;
473: }
474: /*
475: Receive any Reply Bytes, waiting for either the Command Complete bit to
476: be set in the Interrupt Register, or for the Interrupt Handler to set the
477: Host Adapter Command Completed bit in the Host Adapter structure.
478: */
479: while (--TimeoutCounter >= 0)
480: {
481: InterruptRegister = BusLogic_ReadInterruptRegister(HostAdapter);
482: StatusRegister = BusLogic_ReadStatusRegister(HostAdapter);
483: if (InterruptRegister & BusLogic_CommandComplete) break;
484: if (HostAdapter->HostAdapterCommandCompleted) break;
485: if (StatusRegister & BusLogic_DataInRegisterReady)
486: if (++ReplyBytes <= ReplyLength)
487: *ReplyPointer++ = BusLogic_ReadDataInRegister(HostAdapter);
488: else BusLogic_ReadDataInRegister(HostAdapter);
489: }
490: BusLogic_CommandFailureReason = "Timeout waiting for Command Complete";
491: if (TimeoutCounter < 0) return -2;
492: /*
493: If testing Command Complete Interrupts, wait a short while in case the
494: loop immediately above terminated due to the Command Complete bit being
495: set in the Interrupt Register, but the interrupt hasn't actually been
496: processed yet. Otherwise, acknowledging the interrupt here could prevent
497: the interrupt test from succeeding.
498: */
499: if (OperationCode == BusLogic_TestCommandCompleteInterrupt)
500: udelay(10000);
501: /*
502: Clear any pending Command Complete Interrupt.
503: */
504: BusLogic_WriteControlRegister(HostAdapter, BusLogic_InterruptReset);
505: if (BusLogic_GlobalOptions & BusLogic_TraceConfiguration)
506: if (OperationCode != BusLogic_TestCommandCompleteInterrupt)
507: {
508: int i;
509: printk("BusLogic_Command(%02X) Status = %02X: %2d ==> %2d:",
510: OperationCode, StatusRegister, ReplyLength, ReplyBytes);
511: if (ReplyLength > ReplyBytes) ReplyLength = ReplyBytes;
512: for (i = 0; i < ReplyLength; i++)
513: printk(" %02X", ((unsigned char *) ReplyData)[i]);
514: printk("\n");
515: }
516: /*
517: Process Command Invalid conditions.
518: */
519: if (StatusRegister & BusLogic_CommandInvalid)
520: {
521: /*
522: Some early BusLogic Host Adapters may not recover properly from
523: a Command Invalid condition, so if this appears to be the case,
524: a Soft Reset is issued to the Host Adapter. Potentially invalid
525: commands are never attempted after Mailbox Initialization is
526: performed, so there should be no Host Adapter state lost by a
527: Soft Reset in response to a Command Invalid condition.
528: */
529: udelay(1000);
530: StatusRegister = BusLogic_ReadStatusRegister(HostAdapter);
531: if (StatusRegister != (BusLogic_HostAdapterReady |
532: BusLogic_InitializationRequired))
533: {
534: BusLogic_WriteControlRegister(HostAdapter, BusLogic_SoftReset);
535: udelay(1000);
536: }
537: BusLogic_CommandFailureReason = "Command Invalid";
538: return -1;
539: }
540: /*
541: Handle Excess Parameters Supplied conditions.
542: */
543: BusLogic_CommandFailureReason = "Excess Parameters Supplied";
544: if (ParameterLength > 0) return -1;
545: /*
546: Indicate the command completed successfully.
547: */
548: BusLogic_CommandFailureReason = NULL;
549: return ReplyBytes;
550: }
551:
552:
553: /*
554: BusLogic_Failure prints a standardized error message, and then returns false.
555: */
556:
557: static boolean BusLogic_Failure(BusLogic_HostAdapter_T *HostAdapter,
558: char *ErrorMessage)
559: {
560: BusLogic_AnnounceDriver();
561: printk("While configuring BusLogic Host Adapter at I/O Address 0x%X:\n",
562: HostAdapter->IO_Address);
563: printk("%s FAILED - DETACHING\n", ErrorMessage);
564: if (BusLogic_CommandFailureReason != NULL)
565: printk("ADDITIONAL FAILURE INFO - %s\n", BusLogic_CommandFailureReason);
566: return false;
567: }
568:
569:
570: /*
571: BusLogic_ProbeHostAdapter probes for a BusLogic Host Adapter.
572: */
573:
574: static boolean BusLogic_ProbeHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
575: {
576: boolean TraceProbe = (BusLogic_GlobalOptions & BusLogic_TraceProbe);
577: unsigned char StatusRegister, GeometryRegister;
578: /*
579: Read the Status Register to test if there is an I/O port that responds. A
580: nonexistent I/O port will return 0xFF, in which case there is definitely no
581: BusLogic Host Adapter at this base I/O Address.
582: */
583: StatusRegister = BusLogic_ReadStatusRegister(HostAdapter);
584: if (TraceProbe)
585: printk("BusLogic_Probe(0x%X): Status 0x%02X\n",
586: HostAdapter->IO_Address, StatusRegister);
587: if (StatusRegister == 0xFF) return false;
588: /*
589: Read the undocumented BusLogic Geometry Register to test if there is an I/O
590: port that responds. Adaptec Host Adapters do not implement the Geometry
591: Register, so this test helps serve to avoid incorrectly recognizing an
592: Adaptec 1542A or 1542B as a BusLogic. Unfortunately, the Adaptec 1542C
593: series does respond to the Geometry Register I/O port, but it will be
594: rejected later when the Inquire Extended Setup Information command is
595: issued in BusLogic_CheckHostAdapter. The AMI FastDisk Host Adapter is a
596: BusLogic clone that implements the same interface as earlier BusLogic
597: boards, including the undocumented commands, and is therefore supported by
598: this driver. However, the AMI FastDisk always returns 0x00 upon reading
599: the Geometry Register, so the extended translation option should always be
600: left disabled on the AMI FastDisk.
601: */
602: GeometryRegister = BusLogic_ReadGeometryRegister(HostAdapter);
603: if (TraceProbe)
604: printk("BusLogic_Probe(0x%X): Geometry 0x%02X\n",
605: HostAdapter->IO_Address, GeometryRegister);
606: if (GeometryRegister == 0xFF) return false;
607: /*
608: Indicate the Host Adapter Probe completed successfully.
609: */
610: return true;
611: }
612:
613:
614: /*
615: BusLogic_HardResetHostAdapter issues a Hard Reset to the Host Adapter,
616: and waits for Host Adapter Diagnostics to complete.
617: */
618:
619: static boolean BusLogic_HardResetHostAdapter(BusLogic_HostAdapter_T
620: *HostAdapter)
621: {
622: boolean TraceHardReset = (BusLogic_GlobalOptions & BusLogic_TraceHardReset);
623: long TimeoutCounter = loops_per_sec >> 2;
624: unsigned char StatusRegister = 0;
625: /*
626: Issue a Hard Reset Command to the Host Adapter. The Host Adapter should
627: respond by setting Diagnostic Active in the Status Register.
628: */
629: BusLogic_WriteControlRegister(HostAdapter, BusLogic_HardReset);
630: /*
631: Wait until Diagnostic Active is set in the Status Register.
632: */
633: while (--TimeoutCounter >= 0)
634: {
635: StatusRegister = BusLogic_ReadStatusRegister(HostAdapter);
636: if ((StatusRegister & BusLogic_DiagnosticActive)) break;
637: }
638: if (TraceHardReset)
639: printk("BusLogic_HardReset(0x%X): Diagnostic Active, Status 0x%02X\n",
640: HostAdapter->IO_Address, StatusRegister);
641: if (TimeoutCounter < 0) return false;
642: /*
643: Wait 100 microseconds to allow completion of any initial diagnostic
644: activity which might leave the contents of the Status Register
645: unpredictable.
646: */
647: udelay(100);
648: /*
649: Wait until Diagnostic Active is reset in the Status Register.
650: */
651: while (--TimeoutCounter >= 0)
652: {
653: StatusRegister = BusLogic_ReadStatusRegister(HostAdapter);
654: if (!(StatusRegister & BusLogic_DiagnosticActive)) break;
655: }
656: if (TraceHardReset)
657: printk("BusLogic_HardReset(0x%X): Diagnostic Completed, Status 0x%02X\n",
658: HostAdapter->IO_Address, StatusRegister);
659: if (TimeoutCounter < 0) return false;
660: /*
661: Wait until at least one of the Diagnostic Failure, Host Adapter Ready,
662: or Data In Register Ready bits is set in the Status Register.
663: */
664: while (--TimeoutCounter >= 0)
665: {
666: StatusRegister = BusLogic_ReadStatusRegister(HostAdapter);
667: if (StatusRegister & (BusLogic_DiagnosticFailure |
668: BusLogic_HostAdapterReady |
669: BusLogic_DataInRegisterReady))
670: break;
671: }
672: if (TraceHardReset)
673: printk("BusLogic_HardReset(0x%X): Host Adapter Ready, Status 0x%02X\n",
674: HostAdapter->IO_Address, StatusRegister);
675: if (TimeoutCounter < 0) return false;
676: /*
677: If Diagnostic Failure is set or Host Adapter Ready is reset, then an
678: error occurred during the Host Adapter diagnostics. If Data In Register
679: Ready is set, then there is an Error Code available.
680: */
681: if ((StatusRegister & BusLogic_DiagnosticFailure) ||
682: !(StatusRegister & BusLogic_HostAdapterReady))
683: {
684: BusLogic_CommandFailureReason = NULL;
685: BusLogic_Failure(HostAdapter, "HARD RESET DIAGNOSTICS");
686: printk("HOST ADAPTER STATUS REGISTER = %02X\n", StatusRegister);
687: if (StatusRegister & BusLogic_DataInRegisterReady)
688: {
689: unsigned char ErrorCode = BusLogic_ReadDataInRegister(HostAdapter);
690: printk("HOST ADAPTER ERROR CODE = %d\n", ErrorCode);
691: }
692: return false;
693: }
694: /*
695: Indicate the Host Adapter Hard Reset completed successfully.
696: */
697: return true;
698: }
699:
700:
701: /*
702: BusLogic_CheckHostAdapter checks to be sure this really is a BusLogic
703: Host Adapter.
704: */
705:
706: static boolean BusLogic_CheckHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
707: {
708: BusLogic_ExtendedSetupInformation_T ExtendedSetupInformation;
709: BusLogic_RequestedReplyLength_T RequestedReplyLength;
710: unsigned long ProcessorFlags;
711: int Result;
712: /*
713: Issue the Inquire Extended Setup Information command. Only genuine
714: BusLogic Host Adapters and true clones support this command. Adaptec 1542C
715: series Host Adapters that respond to the Geometry Register I/O port will
716: fail this command. Interrupts must be disabled around the call to
717: BusLogic_Command since a Command Complete interrupt could occur if the IRQ
718: Channel was previously enabled for another BusLogic Host Adapter sharing
719: the same IRQ Channel.
720: */
721: save_flags(ProcessorFlags);
722: cli();
723: RequestedReplyLength = sizeof(ExtendedSetupInformation);
724: Result = BusLogic_Command(HostAdapter,
725: BusLogic_InquireExtendedSetupInformation,
726: &RequestedReplyLength, sizeof(RequestedReplyLength),
727: &ExtendedSetupInformation,
728: sizeof(ExtendedSetupInformation));
729: restore_flags(ProcessorFlags);
730: if (BusLogic_GlobalOptions & BusLogic_TraceProbe)
731: printk("BusLogic_Check(0x%X): Result %d\n",
732: HostAdapter->IO_Address, Result);
733: return (Result == sizeof(ExtendedSetupInformation));
734: }
735:
736:
737: /*
738: BusLogic_ReadHostAdapterConfiguration reads the Configuration Information
739: from Host Adapter.
740: */
741:
742: static boolean BusLogic_ReadHostAdapterConfiguration(BusLogic_HostAdapter_T
743: *HostAdapter)
744: {
745: BusLogic_BoardID_T BoardID;
746: BusLogic_Configuration_T Configuration;
747: BusLogic_SetupInformation_T SetupInformation;
748: BusLogic_ExtendedSetupInformation_T ExtendedSetupInformation;
749: BusLogic_BoardModelNumber_T BoardModelNumber;
750: BusLogic_FirmwareVersion3rdDigit_T FirmwareVersion3rdDigit;
751: BusLogic_FirmwareVersionLetter_T FirmwareVersionLetter;
752: BusLogic_RequestedReplyLength_T RequestedReplyLength;
753: unsigned char GeometryRegister, *TargetPointer, Character;
754: unsigned short AllTargetsMask, DisconnectPermitted;
755: unsigned short TaggedQueuingPermitted, TaggedQueuingPermittedDefault;
756: boolean CommonErrorRecovery;
757: int TargetID, i;
758: /*
759: Issue the Inquire Board ID command.
760: */
761: if (BusLogic_Command(HostAdapter, BusLogic_InquireBoardID, NULL, 0,
762: &BoardID, sizeof(BoardID)) != sizeof(BoardID))
763: return BusLogic_Failure(HostAdapter, "INQUIRE BOARD ID");
764: /*
765: Issue the Inquire Configuration command.
766: */
767: if (BusLogic_Command(HostAdapter, BusLogic_InquireConfiguration, NULL, 0,
768: &Configuration, sizeof(Configuration))
769: != sizeof(Configuration))
770: return BusLogic_Failure(HostAdapter, "INQUIRE CONFIGURATION");
771: /*
772: Issue the Inquire Setup Information command.
773: */
774: RequestedReplyLength = sizeof(SetupInformation);
775: if (BusLogic_Command(HostAdapter, BusLogic_InquireSetupInformation,
776: &RequestedReplyLength, sizeof(RequestedReplyLength),
777: &SetupInformation, sizeof(SetupInformation))
778: != sizeof(SetupInformation))
779: return BusLogic_Failure(HostAdapter, "INQUIRE SETUP INFORMATION");
780: /*
781: Issue the Inquire Extended Setup Information command.
782: */
783: RequestedReplyLength = sizeof(ExtendedSetupInformation);
784: if (BusLogic_Command(HostAdapter, BusLogic_InquireExtendedSetupInformation,
785: &RequestedReplyLength, sizeof(RequestedReplyLength),
786: &ExtendedSetupInformation,
787: sizeof(ExtendedSetupInformation))
788: != sizeof(ExtendedSetupInformation))
789: return BusLogic_Failure(HostAdapter, "INQUIRE EXTENDED SETUP INFORMATION");
790: /*
791: Issue the Inquire Board Model Number command.
792: */
793: if (!(BoardID.FirmwareVersion1stDigit == '2' &&
794: ExtendedSetupInformation.BusType == 'A'))
795: {
796: RequestedReplyLength = sizeof(BoardModelNumber);
797: if (BusLogic_Command(HostAdapter, BusLogic_InquireBoardModelNumber,
798: &RequestedReplyLength, sizeof(RequestedReplyLength),
799: &BoardModelNumber, sizeof(BoardModelNumber))
800: != sizeof(BoardModelNumber))
801: return BusLogic_Failure(HostAdapter, "INQUIRE BOARD MODEL NUMBER");
802: }
803: else strcpy(BoardModelNumber, "542B");
804: /*
805: Issue the Inquire Firmware Version 3rd Digit command.
806: */
807: if (BusLogic_Command(HostAdapter, BusLogic_InquireFirmwareVersion3rdDigit,
808: NULL, 0, &FirmwareVersion3rdDigit,
809: sizeof(FirmwareVersion3rdDigit))
810: != sizeof(FirmwareVersion3rdDigit))
811: return BusLogic_Failure(HostAdapter, "INQUIRE FIRMWARE 3RD DIGIT");
812: /*
813: Issue the Inquire Firmware Version Letter command.
814: */
815: FirmwareVersionLetter = '\0';
816: if (BoardID.FirmwareVersion1stDigit > '3' ||
817: (BoardID.FirmwareVersion1stDigit == '3' &&
818: BoardID.FirmwareVersion2ndDigit >= '3'))
819: if (BusLogic_Command(HostAdapter, BusLogic_InquireFirmwareVersionLetter,
820: NULL, 0, &FirmwareVersionLetter,
821: sizeof(FirmwareVersionLetter))
822: != sizeof(FirmwareVersionLetter))
823: return BusLogic_Failure(HostAdapter, "INQUIRE FIRMWARE VERSION LETTER");
824: /*
825: BusLogic Host Adapters can be identified by their model number and
826: the major version number of their firmware as follows:
827:
828: 4.xx BusLogic "C" Series Host Adapters:
829: BT-946C/956C/956CD/747C/757C/757CD/445C/545C/540CF
830: 3.xx BusLogic "S" Series Host Adapters:
831: BT-747S/747D/757S/757D/445S/545S/542D
832: BT-542B/742A (revision H)
833: 2.xx BusLogic "A" Series Host Adapters:
834: BT-542B/742A (revision G and below)
835: 0.xx AMI FastDisk VLB/EISA BusLogic Clone Host Adapter
836: */
837: /*
838: Save the Model Name and Board Name in the Host Adapter structure.
839: */
840: TargetPointer = HostAdapter->ModelName;
841: *TargetPointer++ = 'B';
842: *TargetPointer++ = 'T';
843: *TargetPointer++ = '-';
844: for (i = 0; i < sizeof(BoardModelNumber); i++)
845: {
846: Character = BoardModelNumber[i];
847: if (Character == ' ' || Character == '\0') break;
848: *TargetPointer++ = Character;
849: }
850: *TargetPointer++ = '\0';
851: strcpy(HostAdapter->BoardName, "BusLogic ");
852: strcat(HostAdapter->BoardName, HostAdapter->ModelName);
853: strcpy(HostAdapter->InterruptLabel, HostAdapter->BoardName);
854: /*
855: Save the Firmware Version in the Host Adapter structure.
856: */
857: TargetPointer = HostAdapter->FirmwareVersion;
858: *TargetPointer++ = BoardID.FirmwareVersion1stDigit;
859: *TargetPointer++ = '.';
860: *TargetPointer++ = BoardID.FirmwareVersion2ndDigit;
861: if (FirmwareVersion3rdDigit != ' ' && FirmwareVersion3rdDigit != '\0')
862: *TargetPointer++ = FirmwareVersion3rdDigit;
863: if (FirmwareVersionLetter != ' ' && FirmwareVersionLetter != '\0')
864: *TargetPointer++ = FirmwareVersionLetter;
865: *TargetPointer++ = '\0';
866: /*
867: Determine the IRQ Channel and save it in the Host Adapter structure.
868: */
869: if (Configuration.IRQ_Channel9)
870: HostAdapter->IRQ_Channel = 9;
871: else if (Configuration.IRQ_Channel10)
872: HostAdapter->IRQ_Channel = 10;
873: else if (Configuration.IRQ_Channel11)
874: HostAdapter->IRQ_Channel = 11;
875: else if (Configuration.IRQ_Channel12)
876: HostAdapter->IRQ_Channel = 12;
877: else if (Configuration.IRQ_Channel14)
878: HostAdapter->IRQ_Channel = 14;
879: else if (Configuration.IRQ_Channel15)
880: HostAdapter->IRQ_Channel = 15;
881: /*
882: Determine the DMA Channel and save it in the Host Adapter structure.
883: */
884: if (Configuration.DMA_Channel5)
885: HostAdapter->DMA_Channel = 5;
886: else if (Configuration.DMA_Channel6)
887: HostAdapter->DMA_Channel = 6;
888: else if (Configuration.DMA_Channel7)
889: HostAdapter->DMA_Channel = 7;
890: /*
891: Save the Host Adapter SCSI ID in the Host Adapter structure.
892: */
893: HostAdapter->SCSI_ID = Configuration.HostAdapterID;
894: /*
895: Save the Synchronous Initiation flag and SCSI Parity Checking flag
896: in the Host Adapter structure.
897: */
898: HostAdapter->SynchronousInitiation =
899: SetupInformation.SynchronousInitiationEnabled;
900: HostAdapter->ParityChecking = SetupInformation.ParityCheckEnabled;
901: /*
902: Determine the Bus Type and save it in the Host Adapter structure,
903: overriding the DMA Channel if it is inappropriate for the bus type.
904: */
905: if (ExtendedSetupInformation.BusType == 'A')
906: HostAdapter->BusType = BusLogic_ISA_Bus;
907: else
908: switch (HostAdapter->ModelName[3])
909: {
910: case '4':
911: HostAdapter->BusType = BusLogic_VESA_Bus;
912: HostAdapter->DMA_Channel = 0;
913: break;
914: case '5':
915: HostAdapter->BusType = BusLogic_ISA_Bus;
916: break;
917: case '6':
918: HostAdapter->BusType = BusLogic_MCA_Bus;
919: HostAdapter->DMA_Channel = 0;
920: break;
921: case '7':
922: HostAdapter->BusType = BusLogic_EISA_Bus;
923: HostAdapter->DMA_Channel = 0;
924: break;
925: case '9':
926: HostAdapter->BusType = BusLogic_PCI_Bus;
927: HostAdapter->DMA_Channel = 0;
928: break;
929: }
930: /*
931: Determine whether Extended Translation is enabled and save it in
932: the Host Adapter structure.
933: */
934: GeometryRegister = BusLogic_ReadGeometryRegister(HostAdapter);
935: if (GeometryRegister & BusLogic_ExtendedTranslationEnabled)
936: HostAdapter->ExtendedTranslation = true;
937: /*
938: Save the Disconnect/Reconnect Permitted flag bits in the Host Adapter
939: structure. The Disconnect Permitted information is only valid on "C"
940: Series boards, but Disconnect/Reconnect is always permitted on "S" and
941: "A" Series boards.
942: */
943: if (HostAdapter->FirmwareVersion[0] >= '4')
944: HostAdapter->DisconnectPermitted =
945: (SetupInformation.DisconnectPermittedID8to15 << 8)
946: | SetupInformation.DisconnectPermittedID0to7;
947: else HostAdapter->DisconnectPermitted = 0xFF;
948: /*
949: Save the Scatter Gather Limits, Level Sensitive Interrupts flag,
950: Wide SCSI flag, and Differential SCSI flag in the Host Adapter structure.
951: */
952: HostAdapter->HostAdapterScatterGatherLimit =
953: ExtendedSetupInformation.ScatterGatherLimit;
954: HostAdapter->DriverScatterGatherLimit =
955: HostAdapter->HostAdapterScatterGatherLimit;
956: if (HostAdapter->HostAdapterScatterGatherLimit > BusLogic_ScatterGatherLimit)
957: HostAdapter->DriverScatterGatherLimit = BusLogic_ScatterGatherLimit;
958: if (ExtendedSetupInformation.Misc.LevelSensitiveInterrupts)
959: HostAdapter->LevelSensitiveInterrupts = true;
960: if (ExtendedSetupInformation.HostWideSCSI)
961: {
962: HostAdapter->HostWideSCSI = true;
963: HostAdapter->MaxTargetIDs = 16;
964: HostAdapter->MaxLogicalUnits = 64;
965: }
966: else
967: {
968: HostAdapter->HostWideSCSI = false;
969: HostAdapter->MaxTargetIDs = 8;
970: HostAdapter->MaxLogicalUnits = 8;
971: }
972: HostAdapter->HostDifferentialSCSI =
973: ExtendedSetupInformation.HostDifferentialSCSI;
974: /*
975: Determine the Host Adapter BIOS Address if the BIOS is enabled and
976: save it in the Host Adapter structure. The BIOS is disabled if the
977: BIOS_Address is 0.
978: */
979: HostAdapter->BIOS_Address = ExtendedSetupInformation.BIOS_Address << 12;
980: /*
981: BusLogic BT-445S Host Adapters prior to board revision D have a hardware
982: bug whereby when the BIOS is enabled, transfers to/from the same address
983: range the BIOS occupies modulo 16MB are handled incorrectly. Only properly
984: functioning BT-445S boards have firmware version 3.37, so we require that
985: ISA bounce buffers be used for the buggy BT-445S models as well as for all
986: ISA models.
987: */
988: if (HostAdapter->BusType == BusLogic_ISA_Bus ||
989: (HostAdapter->BIOS_Address > 0 &&
990: strcmp(HostAdapter->ModelName, "BT-445S") == 0 &&
991: strcmp(HostAdapter->FirmwareVersion, "3.37") < 0))
992: HostAdapter->BounceBuffersRequired = true;
993: /*
994: Select an appropriate value for Concurrency (Commands per Logical Unit)
995: either from a Command Line Entry, or based on whether this Host Adapter
996: requires that ISA bounce buffers be used.
997: */
998: if (HostAdapter->CommandLineEntry != NULL &&
999: HostAdapter->CommandLineEntry->Concurrency > 0)
1000: HostAdapter->Concurrency = HostAdapter->CommandLineEntry->Concurrency;
1001: else if (HostAdapter->BounceBuffersRequired)
1002: HostAdapter->Concurrency = BusLogic_Concurrency_BB;
1003: else HostAdapter->Concurrency = BusLogic_Concurrency;
1004: /*
1005: Select an appropriate value for Bus Settle Time either from a Command
1006: Line Entry, or from BusLogic_DefaultBusSettleTime.
1007: */
1008: if (HostAdapter->CommandLineEntry != NULL &&
1009: HostAdapter->CommandLineEntry->BusSettleTime > 0)
1010: HostAdapter->BusSettleTime = HostAdapter->CommandLineEntry->BusSettleTime;
1011: else HostAdapter->BusSettleTime = BusLogic_DefaultBusSettleTime;
1012: /*
1013: Select an appropriate value for Local Options from a Command Line Entry.
1014: */
1015: if (HostAdapter->CommandLineEntry != NULL)
1016: HostAdapter->LocalOptions = HostAdapter->CommandLineEntry->LocalOptions;
1017: /*
1018: Select appropriate values for the Error Recovery Option array either from
1019: a Command Line Entry, or using BusLogic_ErrorRecoveryDefault.
1020: */
1021: if (HostAdapter->CommandLineEntry != NULL)
1022: memcpy(HostAdapter->ErrorRecoveryOption,
1023: HostAdapter->CommandLineEntry->ErrorRecoveryOption,
1024: sizeof(HostAdapter->ErrorRecoveryOption));
1025: else memset(HostAdapter->ErrorRecoveryOption,
1026: BusLogic_ErrorRecoveryDefault,
1027: sizeof(HostAdapter->ErrorRecoveryOption));
1028: /*
1029: Tagged Queuing support is available and operates properly only on "C"
1030: Series boards with firmware version 4.22 and above and on "S" Series
1031: boards with firmware version 3.35 and above. Tagged Queuing is disabled
1032: by default when the Concurrency value is 1 since queuing multiple commands
1033: is not possible.
1034: */
1035: TaggedQueuingPermittedDefault = 0;
1036: if (HostAdapter->Concurrency > 1)
1037: switch (HostAdapter->FirmwareVersion[0])
1038: {
1039: case '5':
1040: TaggedQueuingPermittedDefault = 0xFFFF;
1041: break;
1042: case '4':
1043: if (strcmp(HostAdapter->FirmwareVersion, "4.22") >= 0)
1044: TaggedQueuingPermittedDefault = 0xFFFF;
1045: break;
1046: case '3':
1047: if (strcmp(HostAdapter->FirmwareVersion, "3.35") >= 0)
1048: TaggedQueuingPermittedDefault = 0xFFFF;
1049: break;
1050: }
1051: /*
1052: Tagged Queuing is only useful if Disconnect/Reconnect is permitted.
1053: Therefore, mask the Tagged Queuing Permitted Default bits with the
1054: Disconnect/Reconnect Permitted bits.
1055: */
1056: TaggedQueuingPermittedDefault &= HostAdapter->DisconnectPermitted;
1057: /*
1058: Combine the default Tagged Queuing Permitted Default bits with any
1059: Command Line Entry Tagged Queuing specification.
1060: */
1061: if (HostAdapter->CommandLineEntry != NULL)
1062: HostAdapter->TaggedQueuingPermitted =
1063: (HostAdapter->CommandLineEntry->TaggedQueuingPermitted &
1064: HostAdapter->CommandLineEntry->TaggedQueuingPermittedMask) |
1065: (TaggedQueuingPermittedDefault &
1066: ~HostAdapter->CommandLineEntry->TaggedQueuingPermittedMask);
1067: else HostAdapter->TaggedQueuingPermitted = TaggedQueuingPermittedDefault;
1068: /*
1069: Announce the Host Adapter Configuration.
1070: */
1071: printk("scsi%d: Configuring BusLogic Model %s %s%s%s SCSI Host Adapter\n",
1072: HostAdapter->HostNumber, HostAdapter->ModelName,
1073: BusLogic_BusNames[HostAdapter->BusType],
1074: (HostAdapter->HostWideSCSI ? " Wide" : ""),
1075: (HostAdapter->HostDifferentialSCSI ? " Differential" : ""));
1076: printk("scsi%d: Firmware Version: %s, I/O Address: 0x%X, "
1077: "IRQ Channel: %d/%s\n",
1078: HostAdapter->HostNumber, HostAdapter->FirmwareVersion,
1079: HostAdapter->IO_Address, HostAdapter->IRQ_Channel,
1080: (HostAdapter->LevelSensitiveInterrupts ? "Level" : "Edge"));
1081: printk("scsi%d: DMA Channel: ", HostAdapter->HostNumber);
1082: if (HostAdapter->DMA_Channel > 0)
1083: printk("%d, ", HostAdapter->DMA_Channel);
1084: else printk("None, ");
1085: if (HostAdapter->BIOS_Address > 0)
1086: printk("BIOS Address: 0x%lX, ", HostAdapter->BIOS_Address);
1087: else printk("BIOS Address: None, ");
1088: printk("Host Adapter SCSI ID: %d\n", HostAdapter->SCSI_ID);
1089: printk("scsi%d: Scatter/Gather Limit: %d segments, "
1090: "Synchronous Initiation: %s\n", HostAdapter->HostNumber,
1091: HostAdapter->HostAdapterScatterGatherLimit,
1092: (HostAdapter->SynchronousInitiation ? "Enabled" : "Disabled"));
1093: printk("scsi%d: SCSI Parity Checking: %s, "
1094: "Extended Disk Translation: %s\n", HostAdapter->HostNumber,
1095: (HostAdapter->ParityChecking ? "Enabled" : "Disabled"),
1096: (HostAdapter->ExtendedTranslation ? "Enabled" : "Disabled"));
1097: AllTargetsMask = (1 << HostAdapter->MaxTargetIDs) - 1;
1098: DisconnectPermitted = HostAdapter->DisconnectPermitted & AllTargetsMask;
1099: printk("scsi%d: Disconnect/Reconnect: ", HostAdapter->HostNumber);
1100: if (DisconnectPermitted == 0)
1101: printk("Disabled");
1102: else if (DisconnectPermitted == AllTargetsMask)
1103: printk("Enabled");
1104: else
1105: for (TargetID = 0; TargetID < HostAdapter->MaxTargetIDs; TargetID++)
1106: printk("%c", (DisconnectPermitted & (1 << TargetID)) ? 'Y' : 'N');
1107: printk(", Tagged Queuing: ");
1108: TaggedQueuingPermitted =
1109: HostAdapter->TaggedQueuingPermitted & AllTargetsMask;
1110: if (TaggedQueuingPermitted == 0)
1111: printk("Disabled");
1112: else if (TaggedQueuingPermitted == AllTargetsMask)
1113: printk("Enabled");
1114: else
1115: for (TargetID = 0; TargetID < HostAdapter->MaxTargetIDs; TargetID++)
1116: printk("%c", (TaggedQueuingPermitted & (1 << TargetID)) ? 'Y' : 'N');
1117: printk("\n");
1118: CommonErrorRecovery = true;
1119: for (TargetID = 1; TargetID < HostAdapter->MaxTargetIDs; TargetID++)
1120: if (HostAdapter->ErrorRecoveryOption[TargetID] !=
1121: HostAdapter->ErrorRecoveryOption[0])
1122: {
1123: CommonErrorRecovery = false;
1124: break;
1125: }
1126: printk("scsi%d: Error Recovery: ", HostAdapter->HostNumber);
1127: if (CommonErrorRecovery)
1128: printk("%s", BusLogic_ErrorRecoveryOptions[
1129: HostAdapter->ErrorRecoveryOption[0]]);
1130: else
1131: for (TargetID = 0; TargetID < HostAdapter->MaxTargetIDs; TargetID++)
1132: printk("%s", BusLogic_ErrorRecoveryOptions2[
1133: HostAdapter->ErrorRecoveryOption[TargetID]]);
1134: printk(", Mailboxes: %d, Initial CCBs: %d\n",
1135: BusLogic_MailboxCount, BusLogic_InitialCCBs);
1136: printk("scsi%d: Driver Scatter/Gather Limit: %d segments, "
1137: "Concurrency: %d\n", HostAdapter->HostNumber,
1138: HostAdapter->DriverScatterGatherLimit, HostAdapter->Concurrency);
1139: /*
1140: Indicate reading the Host Adapter Configuration completed successfully.
1141: */
1142: return true;
1143: }
1144:
1145:
1146: /*
1147: BusLogic_AcquireResources acquires the system resources necessary to use Host
1148: Adapter, and initializes the fields in the SCSI Host structure. The base,
1149: io_port, n_io_ports, irq, and dma_channel fields in the SCSI Host structure
1150: are intentionally left uninitialized, as this driver handles acquisition and
1151: release of these resources explicitly, as well as ensuring exclusive access
1152: to the Host Adapter hardware and data structures through explicit locking.
1153: */
1154:
1155: static boolean BusLogic_AcquireResources(BusLogic_HostAdapter_T *HostAdapter,
1156: SCSI_Host_T *Host)
1157: {
1158: /*
1159: Acquire exclusive or shared access to the IRQ Channel. A usage count is
1160: maintained so that PCI, EISA, or MCA shared Interrupts can be supported.
1161: */
1162: if (BusLogic_IRQ_UsageCount[HostAdapter->IRQ_Channel - 9]++ == 0)
1163: {
1164: if (request_irq(HostAdapter->IRQ_Channel, BusLogic_InterruptHandler,
1165: SA_INTERRUPT, HostAdapter->InterruptLabel) < 0)
1166: {
1167: BusLogic_IRQ_UsageCount[HostAdapter->IRQ_Channel - 9]--;
1168: printk("scsi%d: UNABLE TO ACQUIRE IRQ CHANNEL %d - DETACHING\n",
1169: HostAdapter->HostNumber, HostAdapter->IRQ_Channel);
1170: return false;
1171: }
1172: }
1173: else
1174: {
1175: BusLogic_HostAdapter_T *FirstHostAdapter =
1176: BusLogic_RegisteredHostAdapters;
1177: while (FirstHostAdapter != NULL)
1178: {
1179: if (FirstHostAdapter->IRQ_Channel == HostAdapter->IRQ_Channel)
1180: {
1181: if (strlen(FirstHostAdapter->InterruptLabel) + 11
1182: < sizeof(FirstHostAdapter->InterruptLabel))
1183: {
1184: strcat(FirstHostAdapter->InterruptLabel, " + ");
1185: strcat(FirstHostAdapter->InterruptLabel,
1186: HostAdapter->ModelName);
1187: }
1188: break;
1189: }
1190: FirstHostAdapter = FirstHostAdapter->Next;
1191: }
1192: }
1193: HostAdapter->IRQ_ChannelAcquired = true;
1194: /*
1195: Acquire exclusive access to the DMA Channel.
1196: */
1197: if (HostAdapter->DMA_Channel > 0)
1198: {
1199: if (request_dma(HostAdapter->DMA_Channel, HostAdapter->BoardName) < 0)
1200: {
1201: printk("scsi%d: UNABLE TO ACQUIRE DMA CHANNEL %d - DETACHING\n",
1202: HostAdapter->HostNumber, HostAdapter->DMA_Channel);
1203: return false;
1204: }
1205: set_dma_mode(HostAdapter->DMA_Channel, DMA_MODE_CASCADE);
1206: enable_dma(HostAdapter->DMA_Channel);
1207: HostAdapter->DMA_ChannelAcquired = true;
1208: }
1209: /*
1210: Initialize necessary fields in the SCSI Host structure.
1211: */
1212: Host->max_id = HostAdapter->MaxTargetIDs;
1213: Host->max_lun = HostAdapter->MaxLogicalUnits;
1214: Host->max_channel = 0;
1215: Host->this_id = HostAdapter->SCSI_ID;
1216: Host->can_queue = BusLogic_MailboxCount;
1217: Host->cmd_per_lun = HostAdapter->Concurrency;
1218: Host->sg_tablesize = HostAdapter->DriverScatterGatherLimit;
1219: Host->unchecked_isa_dma = HostAdapter->BounceBuffersRequired;
1220: /*
1221: Indicate the System Resource Acquisition completed successfully,
1222: */
1223: return true;
1224: }
1225:
1226:
1227: /*
1228: BusLogic_ReleaseResources releases any system resources previously acquired
1229: by BusLogic_AcquireResources.
1230: */
1231:
1232: static void BusLogic_ReleaseResources(BusLogic_HostAdapter_T *HostAdapter)
1233: {
1234: /*
1235: Release exclusive or shared access to the IRQ Channel.
1236: */
1237: if (HostAdapter->IRQ_ChannelAcquired)
1238: if (--BusLogic_IRQ_UsageCount[HostAdapter->IRQ_Channel - 9] == 0)
1239: free_irq(HostAdapter->IRQ_Channel);
1240: /*
1241: Release exclusive access to the DMA Channel.
1242: */
1243: if (HostAdapter->DMA_ChannelAcquired)
1244: free_dma(HostAdapter->DMA_Channel);
1245: }
1246:
1247:
1248: /*
1249: BusLogic_TestInterrupts tests for proper functioning of the Host Adapter
1250: Interrupt Register and that interrupts generated by the Host Adapter are
1251: getting through to the Interrupt Handler. A large proportion of initial
1252: problems with installing PCI Host Adapters are due to configuration problems
1253: where either the Host Adapter or Motherboard is configured incorrectly, and
1254: interrupts do not get through as a result.
1255: */
1256:
1257: static boolean BusLogic_TestInterrupts(BusLogic_HostAdapter_T *HostAdapter)
1258: {
1259: unsigned int InitialInterruptCount, FinalInterruptCount;
1260: int TestCount = 5, i;
1261: InitialInterruptCount = kstat.interrupts[HostAdapter->IRQ_Channel];
1262: /*
1263: Issue the Test Command Complete Interrupt commands.
1264: */
1265: for (i = 0; i < TestCount; i++)
1266: BusLogic_Command(HostAdapter, BusLogic_TestCommandCompleteInterrupt,
1267: NULL, 0, NULL, 0);
1268: /*
1269: Verify that BusLogic_InterruptHandler was called at least TestCount times.
1270: Shared IRQ Channels could cause more than TestCount interrupts to occur,
1271: but there should never be fewer than TestCount.
1272: */
1273: FinalInterruptCount = kstat.interrupts[HostAdapter->IRQ_Channel];
1274: if (FinalInterruptCount < InitialInterruptCount + TestCount)
1275: {
1276: BusLogic_Failure(HostAdapter, "HOST ADAPTER INTERRUPT TEST");
1277: printk("\n\
1278: Interrupts are not getting through from the Host Adapter to the BusLogic\n\
1279: Driver Interrupt Handler. The most likely cause is that either the Host\n\
1280: Adapter or Motherboard is configured incorrectly. Please check the Host\n\
1281: Adapter configuration with AutoSCSI or by examining any dip switch and\n\
1282: jumper settings on the Host Adapter, and verify that no other device is\n\
1283: attempting to use the same IRQ Channel. For PCI Host Adapters, it may also\n\
1284: be necessary to investigate and manually set the PCI interrupt assignments\n\
1285: and edge/level interrupt type selection in the BIOS Setup Program or with\n\
1286: Motherboard jumpers.\n\n");
1287: return false;
1288: }
1289: /*
1290: Indicate the Host Adapter Interrupt Test completed successfully.
1291: */
1292: return true;
1293: }
1294:
1295:
1296: /*
1297: BusLogic_InitializeHostAdapter initializes Host Adapter. This is the only
1298: function called during SCSI Host Adapter detection which modifies the state
1299: of the Host Adapter from its initial power on or hard reset state.
1300: */
1301:
1302: static boolean BusLogic_InitializeHostAdapter(BusLogic_HostAdapter_T
1303: *HostAdapter)
1304: {
1305: BusLogic_ExtendedMailboxRequest_T ExtendedMailboxRequest;
1306: BusLogic_RoundRobinModeRequest_T RoundRobinModeRequest;
1307: BusLogic_WideModeCCBRequest_T WideModeCCBRequest;
1308: BusLogic_ModifyIOAddressRequest_T ModifyIOAddressRequest;
1309: /*
1310: Initialize the Command Successful Flag, Read/Write Operation Count,
1311: and Queued Operation Count for each Target.
1312: */
1313: memset(HostAdapter->CommandSuccessfulFlag, false,
1314: sizeof(HostAdapter->CommandSuccessfulFlag));
1315: memset(HostAdapter->ReadWriteOperationCount, 0,
1316: sizeof(HostAdapter->ReadWriteOperationCount));
1317: memset(HostAdapter->QueuedOperationCount, 0,
1318: sizeof(HostAdapter->QueuedOperationCount));
1319: /*
1320: Initialize the Outgoing and Incoming Mailbox structures.
1321: */
1322: memset(HostAdapter->OutgoingMailboxes, 0,
1323: sizeof(HostAdapter->OutgoingMailboxes));
1324: memset(HostAdapter->IncomingMailboxes, 0,
1325: sizeof(HostAdapter->IncomingMailboxes));
1326: /*
1327: Initialize the pointers to the First, Last, and Next Mailboxes.
1328: */
1329: HostAdapter->FirstOutgoingMailbox = &HostAdapter->OutgoingMailboxes[0];
1330: HostAdapter->LastOutgoingMailbox =
1331: &HostAdapter->OutgoingMailboxes[BusLogic_MailboxCount-1];
1332: HostAdapter->NextOutgoingMailbox = HostAdapter->FirstOutgoingMailbox;
1333: HostAdapter->FirstIncomingMailbox = &HostAdapter->IncomingMailboxes[0];
1334: HostAdapter->LastIncomingMailbox =
1335: &HostAdapter->IncomingMailboxes[BusLogic_MailboxCount-1];
1336: HostAdapter->NextIncomingMailbox = HostAdapter->FirstIncomingMailbox;
1337: /*
1338: Initialize the Host Adapter's Pointer to the Outgoing/Incoming Mailboxes.
1339: */
1340: ExtendedMailboxRequest.MailboxCount = BusLogic_MailboxCount;
1341: ExtendedMailboxRequest.BaseMailboxAddress = HostAdapter->OutgoingMailboxes;
1342: if (BusLogic_Command(HostAdapter, BusLogic_InitializeExtendedMailbox,
1343: &ExtendedMailboxRequest,
1344: sizeof(ExtendedMailboxRequest), NULL, 0) < 0)
1345: return BusLogic_Failure(HostAdapter, "MAILBOX INITIALIZATION");
1346: /*
1347: Enable Strict Round Robin Mode if supported by the Host Adapter. In Strict
1348: Round Robin Mode, the Host Adapter only looks at the next Outgoing Mailbox
1349: for each new command, rather than scanning through all the Outgoing
1350: Mailboxes to find any that have new commands in them. BusLogic indicates
1351: that Strict Round Robin Mode is significantly more efficient.
1352: */
1353: if (strcmp(HostAdapter->FirmwareVersion, "3.31") >= 0)
1354: {
1355: RoundRobinModeRequest = BusLogic_StrictRoundRobinMode;
1356: if (BusLogic_Command(HostAdapter, BusLogic_EnableStrictRoundRobinMode,
1357: &RoundRobinModeRequest,
1358: sizeof(RoundRobinModeRequest), NULL, 0) < 0)
1359: return BusLogic_Failure(HostAdapter, "ENABLE STRICT ROUND ROBIN MODE");
1360: }
1361: /*
1362: For Wide SCSI Host Adapters, issue the Enable Wide Mode CCB command to
1363: allow more than 8 Logical Units per Target to be supported.
1364: */
1365: if (HostAdapter->HostWideSCSI)
1366: {
1367: WideModeCCBRequest = BusLogic_WideModeCCB;
1368: if (BusLogic_Command(HostAdapter, BusLogic_EnableWideModeCCB,
1369: &WideModeCCBRequest,
1370: sizeof(WideModeCCBRequest), NULL, 0) < 0)
1371: return BusLogic_Failure(HostAdapter, "ENABLE WIDE MODE CCB");
1372: }
1373: /*
1374: For PCI Host Adapters being accessed through the PCI compliant I/O
1375: Address, disable the ISA compatible I/O Address to avoid detecting the
1376: same Host Adapter at both I/O Addresses.
1377: */
1378: if (HostAdapter->BusType == BusLogic_PCI_Bus)
1379: {
1380: int Index;
1381: for (Index = 0; BusLogic_IO_StandardAddresses[Index] > 0; Index++)
1382: if (HostAdapter->IO_Address == BusLogic_IO_StandardAddresses[Index])
1383: break;
1384: if (BusLogic_IO_StandardAddresses[Index] == 0)
1385: {
1386: ModifyIOAddressRequest = BusLogic_ModifyIO_Disable;
1387: if (BusLogic_Command(HostAdapter, BusLogic_ModifyIOAddress,
1388: &ModifyIOAddressRequest,
1389: sizeof(ModifyIOAddressRequest), NULL, 0) < 0)
1390: return BusLogic_Failure(HostAdapter, "MODIFY I/O ADDRESS");
1391: }
1392: }
1393: /*
1394: Announce Successful Initialization.
1395: */
1396: printk("scsi%d: *** %s Initialized Successfully ***\n",
1397: HostAdapter->HostNumber, HostAdapter->BoardName);
1398: /*
1399: Indicate the Host Adapter Initialization completed successfully.
1400: */
1401: return true;
1402: }
1403:
1404:
1405: /*
1406: BusLogic_InquireTargetDevices inquires about the Target Devices accessible
1407: through Host Adapter and reports on the results.
1408: */
1409:
1410: static boolean BusLogic_InquireTargetDevices(BusLogic_HostAdapter_T
1411: *HostAdapter)
1412: {
1413: BusLogic_InstalledDevices8_T InstalledDevicesID0to7;
1414: BusLogic_InstalledDevices8_T InstalledDevicesID8to15;
1415: BusLogic_SetupInformation_T SetupInformation;
1416: BusLogic_SynchronousPeriod_T SynchronousPeriod;
1417: BusLogic_RequestedReplyLength_T RequestedReplyLength;
1418: int TargetDevicesFound = 0, TargetID;
1419: /*
1420: Wait a few seconds between the Host Adapter Hard Reset which initiates
1421: a SCSI Bus Reset and issuing any SCSI commands. Some SCSI devices get
1422: confused if they receive SCSI commands too soon after a SCSI Bus Reset.
1423: */
1424: BusLogic_Delay(HostAdapter->BusSettleTime);
1425: /*
1426: Inhibit the Target Devices Inquiry if requested.
1427: */
1428: if (HostAdapter->LocalOptions & BusLogic_InhibitTargetInquiry)
1429: {
1430: printk("scsi%d: Target Device Inquiry Inhibited\n",
1431: HostAdapter->HostNumber);
1432: return true;
1433: }
1434: /*
1435: Issue the Inquire Installed Devices ID 0 to 7 command, and for Wide SCSI
1436: Host Adapters the Inquire Installed Devices ID 8 to 15 command. This is
1437: necessary to force Synchronous Transfer Negotiation so that the Inquire
1438: Setup Information and Inquire Synchronous Period commands will return
1439: valid data.
1440: */
1441: if (BusLogic_Command(HostAdapter, BusLogic_InquireInstalledDevicesID0to7,
1442: NULL, 0, &InstalledDevicesID0to7,
1443: sizeof(InstalledDevicesID0to7))
1444: != sizeof(InstalledDevicesID0to7))
1445: return BusLogic_Failure(HostAdapter, "INQUIRE INSTALLED DEVICES ID 0 TO 7");
1446: if (HostAdapter->HostWideSCSI)
1447: if (BusLogic_Command(HostAdapter, BusLogic_InquireInstalledDevicesID8to15,
1448: NULL, 0, &InstalledDevicesID8to15,
1449: sizeof(InstalledDevicesID8to15))
1450: != sizeof(InstalledDevicesID8to15))
1451: return BusLogic_Failure(HostAdapter,
1452: "INQUIRE INSTALLED DEVICES ID 8 TO 15");
1453: /*
1454: Issue the Inquire Setup Information command.
1455: */
1456: RequestedReplyLength = sizeof(SetupInformation);
1457: if (BusLogic_Command(HostAdapter, BusLogic_InquireSetupInformation,
1458: &RequestedReplyLength, sizeof(RequestedReplyLength),
1459: &SetupInformation, sizeof(SetupInformation))
1460: != sizeof(SetupInformation))
1461: return BusLogic_Failure(HostAdapter, "INQUIRE SETUP INFORMATION");
1462: /*
1463: Issue the Inquire Synchronous Period command.
1464: */
1465: if (HostAdapter->FirmwareVersion[0] >= '3')
1466: {
1467: RequestedReplyLength = sizeof(SynchronousPeriod);
1468: if (BusLogic_Command(HostAdapter, BusLogic_InquireSynchronousPeriod,
1469: &RequestedReplyLength, sizeof(RequestedReplyLength),
1470: &SynchronousPeriod, sizeof(SynchronousPeriod))
1471: != sizeof(SynchronousPeriod))
1472: return BusLogic_Failure(HostAdapter, "INQUIRE SYNCHRONOUS PERIOD");
1473: }
1474: else
1475: for (TargetID = 0; TargetID < HostAdapter->MaxTargetIDs; TargetID++)
1476: if (SetupInformation.SynchronousValuesID0to7[TargetID].Offset > 0)
1477: SynchronousPeriod[TargetID] =
1478: 20 + 5 * SetupInformation.SynchronousValuesID0to7[TargetID]
1479: .TransferPeriod;
1480: else SynchronousPeriod[TargetID] = 0;
1481: /*
1482: Save the Installed Devices, Synchronous Values, and Synchronous Period
1483: information in the Host Adapter structure.
1484: */
1485: memcpy(HostAdapter->InstalledDevices, InstalledDevicesID0to7,
1486: sizeof(BusLogic_InstalledDevices8_T));
1487: memcpy(HostAdapter->SynchronousValues,
1488: SetupInformation.SynchronousValuesID0to7,
1489: sizeof(BusLogic_SynchronousValues8_T));
1490: if (HostAdapter->HostWideSCSI)
1491: {
1492: memcpy(&HostAdapter->InstalledDevices[8], InstalledDevicesID8to15,
1493: sizeof(BusLogic_InstalledDevices8_T));
1494: memcpy(&HostAdapter->SynchronousValues[8],
1495: SetupInformation.SynchronousValuesID8to15,
1496: sizeof(BusLogic_SynchronousValues8_T));
1497: }
1498: memcpy(HostAdapter->SynchronousPeriod, SynchronousPeriod,
1499: sizeof(BusLogic_SynchronousPeriod_T));
1500: for (TargetID = 0; TargetID < HostAdapter->MaxTargetIDs; TargetID++)
1501: if (HostAdapter->InstalledDevices[TargetID] != 0)
1502: {
1503: int SynchronousPeriod = HostAdapter->SynchronousPeriod[TargetID];
1504: if (SynchronousPeriod > 10)
1505: {
1506: int SynchronousTransferRate = 100000000 / SynchronousPeriod;
1507: int RoundedSynchronousTransferRate =
1508: (SynchronousTransferRate + 5000) / 10000;
1509: printk("scsi%d: Target %d: Synchronous at "
1510: "%d.%02d mega-transfers/second, offset %d\n",
1511: HostAdapter->HostNumber, TargetID,
1512: RoundedSynchronousTransferRate / 100,
1513: RoundedSynchronousTransferRate % 100,
1514: HostAdapter->SynchronousValues[TargetID].Offset);
1515: }
1516: else if (SynchronousPeriod > 0)
1517: {
1518: int SynchronousTransferRate = 100000000 / SynchronousPeriod;
1519: int RoundedSynchronousTransferRate =
1520: (SynchronousTransferRate + 50000) / 100000;
1521: printk("scsi%d: Target %d: Synchronous at "
1522: "%d.%01d mega-transfers/second, offset %d\n",
1523: HostAdapter->HostNumber, TargetID,
1524: RoundedSynchronousTransferRate / 10,
1525: RoundedSynchronousTransferRate % 10,
1526: HostAdapter->SynchronousValues[TargetID].Offset);
1527: }
1528: else printk("scsi%d: Target %d: Asynchronous\n",
1529: HostAdapter->HostNumber, TargetID);
1530: TargetDevicesFound++;
1531: }
1532: if (TargetDevicesFound == 0)
1533: printk("scsi%d: No Target Devices Found\n", HostAdapter->HostNumber);
1534: /*
1535: Indicate the Target Device Inquiry completed successfully.
1536: */
1537: return true;
1538: }
1539:
1540:
1541: /*
1542: BusLogic_DetectHostAdapter probes for BusLogic Host Adapters at the standard
1543: I/O Addresses where they may be located, initializing, registering, and
1544: reporting the configuration of each BusLogic Host Adapter it finds. It
1545: returns the number of BusLogic Host Adapters successfully initialized and
1546: registered.
1547: */
1548:
1549: int BusLogic_DetectHostAdapter(SCSI_Host_Template_T *HostTemplate)
1550: {
1551: int BusLogicHostAdapterCount = 0, CommandLineEntryIndex = 0;
1552: int AddressProbeIndex = 0;
1553: BusLogic_InitializeAddressProbeList();
1554: while (BusLogic_IO_AddressProbeList[AddressProbeIndex] > 0)
1555: {
1556: BusLogic_HostAdapter_T HostAdapterPrototype;
1557: BusLogic_HostAdapter_T *HostAdapter = &HostAdapterPrototype;
1558: SCSI_Host_T *Host;
1559: memset(HostAdapter, 0, sizeof(BusLogic_HostAdapter_T));
1560: HostAdapter->IO_Address =
1561: BusLogic_IO_AddressProbeList[AddressProbeIndex++];
1562: /*
1563: Initialize the Command Line Entry field if an explicit I/O Address
1564: was specified.
1565: */
1566: if (CommandLineEntryIndex < BusLogic_CommandLineEntryCount &&
1567: BusLogic_CommandLineEntries[CommandLineEntryIndex].IO_Address ==
1568: HostAdapter->IO_Address)
1569: HostAdapter->CommandLineEntry =
1570: &BusLogic_CommandLineEntries[CommandLineEntryIndex++];
1571: /*
1572: Check whether the I/O Address range is already in use.
1573: */
1574: if (check_region(HostAdapter->IO_Address, BusLogic_IO_PortCount) < 0)
1575: continue;
1576: /*
1577: Probe the Host Adapter. If unsuccessful, abort further initialization.
1578: */
1579: if (!BusLogic_ProbeHostAdapter(HostAdapter)) continue;
1580: /*
1581: Hard Reset the Host Adapter. If unsuccessful, abort further
1582: initialization.
1583: */
1584: if (!BusLogic_HardResetHostAdapter(HostAdapter)) continue;
1585: /*
1586: Check the Host Adapter. If unsuccessful, abort further initialization.
1587: */
1588: if (!BusLogic_CheckHostAdapter(HostAdapter)) continue;
1589: /*
1590: Initialize the Command Line Entry field if an explicit I/O Address
1591: was not specified.
1592: */
1593: if (CommandLineEntryIndex < BusLogic_CommandLineEntryCount &&
1594: BusLogic_CommandLineEntries[CommandLineEntryIndex].IO_Address == 0)
1595: HostAdapter->CommandLineEntry =
1596: &BusLogic_CommandLineEntries[CommandLineEntryIndex++];
1597: /*
1598: Announce the Driver Version and Date, Author's Name, Copyright Notice,
1599: and Contact Address.
1600: */
1601: BusLogic_AnnounceDriver();
1602: /*
1603: Register usage of the I/O Address range. From this point onward, any
1604: failure will be assumed to be due to a problem with the Host Adapter,
1605: rather than due to having mistakenly identified this port as belonging
1606: to a BusLogic Host Adapter. The I/O Address range will not be
1607: released, thereby preventing it from being incorrectly identified as
1608: any other type of Host Adapter.
1609: */
1610: request_region(HostAdapter->IO_Address, BusLogic_IO_PortCount,
1611: "BusLogic");
1612: /*
1613: Register the SCSI Host structure.
1614: */
1615: HostTemplate->proc_dir = &BusLogic_ProcDirectoryEntry;
1616: Host = scsi_register(HostTemplate, sizeof(BusLogic_HostAdapter_T));
1617: HostAdapter = (BusLogic_HostAdapter_T *) Host->hostdata;
1618: memcpy(HostAdapter, &HostAdapterPrototype,
1619: sizeof(BusLogic_HostAdapter_T));
1620: HostAdapter->SCSI_Host = Host;
1621: HostAdapter->HostNumber = Host->host_no;
1622: /*
1623: Add Host Adapter to the end of the list of registered BusLogic
1624: Host Adapters. In order for Command Complete Interrupts to be
1625: properly dismissed by BusLogic_InterruptHandler, the Host Adapter
1626: must be registered. This must be done before the IRQ Channel is
1627: acquired, and in a shared IRQ Channel environment, must be done
1628: before any Command Complete Interrupts occur, since the IRQ Channel
1629: may have already been acquired by a previous BusLogic Host Adapter.
1630: */
1631: BusLogic_RegisterHostAdapter(HostAdapter);
1632: /*
1633: Read the Host Adapter Configuration, Acquire the System Resources
1634: necessary to use Host Adapter and initialize the fields in the SCSI
1635: Host structure, then Test Interrupts, Create the CCBs, Initialize
1636: the Host Adapter, and finally Inquire about the Target Devices.
1637: */
1638: if (BusLogic_ReadHostAdapterConfiguration(HostAdapter) &&
1639: BusLogic_AcquireResources(HostAdapter, Host) &&
1640: BusLogic_TestInterrupts(HostAdapter) &&
1641: BusLogic_CreateCCBs(HostAdapter) &&
1642: BusLogic_InitializeHostAdapter(HostAdapter) &&
1643: BusLogic_InquireTargetDevices(HostAdapter))
1644: {
1645: /*
1646: Initialization has been completed successfully. Release and
1647: re-register usage of the I/O Address range so that the Model
1648: Name of the Host Adapter will appear.
1649: */
1650: release_region(HostAdapter->IO_Address, BusLogic_IO_PortCount);
1651: request_region(HostAdapter->IO_Address, BusLogic_IO_PortCount,
1652: HostAdapter->BoardName);
1653: BusLogicHostAdapterCount++;
1654: }
1655: else
1656: {
1657: /*
1658: An error occurred during Host Adapter Configuration Querying,
1659: Resource Acquisition, Interrupt Testing, CCB Creation, Host
1660: Adapter Initialization, or Target Device Inquiry, so remove
1661: Host Adapter from the list of registered BusLogic Host Adapters,
1662: destroy the CCBs, Release the System Resources, and Unregister
1663: the SCSI Host.
1664: */
1665: BusLogic_DestroyCCBs(HostAdapter);
1666: BusLogic_ReleaseResources(HostAdapter);
1667: BusLogic_UnregisterHostAdapter(HostAdapter);
1668: scsi_unregister(Host);
1669: }
1670: }
1671: return BusLogicHostAdapterCount;
1672: }
1673:
1674:
1675: /*
1676: BusLogic_ReleaseHostAdapter releases all resources previously acquired to
1677: support a specific Host Adapter, including the I/O Address range, and
1678: unregisters the BusLogic Host Adapter.
1679: */
1680:
1681: int BusLogic_ReleaseHostAdapter(SCSI_Host_T *Host)
1682: {
1683: BusLogic_HostAdapter_T *HostAdapter =
1684: (BusLogic_HostAdapter_T *) Host->hostdata;
1685: /*
1686: Destroy the CCBs and release any system resources acquired to use
1687: Host Adapter.
1688: */
1689: BusLogic_DestroyCCBs(HostAdapter);
1690: BusLogic_ReleaseResources(HostAdapter);
1691: /*
1692: Release usage of the I/O Address range.
1693: */
1694: release_region(HostAdapter->IO_Address, BusLogic_IO_PortCount);
1695: /*
1696: Remove Host Adapter from the list of registered BusLogic Host Adapters.
1697: */
1698: BusLogic_UnregisterHostAdapter(HostAdapter);
1699: return 0;
1700: }
1701:
1702:
1703: /*
1704: BusLogic_ComputeResultCode computes a SCSI Subsystem Result Code from
1705: the Host Adapter Status and Target Device Status.
1706: */
1707:
1708: static int BusLogic_ComputeResultCode(BusLogic_HostAdapterStatus_T
1709: HostAdapterStatus,
1710: BusLogic_TargetDeviceStatus_T
1711: TargetDeviceStatus)
1712: {
1713: int HostStatus;
1714: switch (HostAdapterStatus)
1715: {
1716: case BusLogic_CommandCompletedNormally:
1717: case BusLogic_LinkedCommandCompleted:
1718: case BusLogic_LinkedCommandCompletedWithFlag:
1719: HostStatus = DID_OK;
1720: break;
1721: case BusLogic_SCSISelectionTimeout:
1722: HostStatus = DID_TIME_OUT;
1723: break;
1724: case BusLogic_InvalidOutgoingMailboxActionCode:
1725: case BusLogic_InvalidCommandOperationCode:
1726: case BusLogic_InvalidCommandParameter:
1727: printk("BusLogic: BusLogic Driver Protocol Error 0x%02X\n",
1728: HostAdapterStatus);
1729: case BusLogic_DataOverUnderRun:
1730: case BusLogic_UnexpectedBusFree:
1731: case BusLogic_LinkedCCBhasInvalidLUN:
1732: case BusLogic_AutoRequestSenseFailed:
1733: case BusLogic_TaggedQueuingMessageRejected:
1734: case BusLogic_UnsupportedMessageReceived:
1735: case BusLogic_HostAdapterHardwareFailed:
1736: case BusLogic_TargetDeviceReconnectedImproperly:
1737: case BusLogic_AbortQueueGenerated:
1738: case BusLogic_HostAdapterSoftwareError:
1739: case BusLogic_HostAdapterHardwareTimeoutError:
1740: case BusLogic_SCSIParityErrorDetected:
1741: HostStatus = DID_ERROR;
1742: break;
1743: case BusLogic_InvalidBusPhaseRequested:
1744: case BusLogic_TargetFailedResponseToATN:
1745: case BusLogic_HostAdapterAssertedRST:
1746: case BusLogic_OtherDeviceAssertedRST:
1747: case BusLogic_HostAdapterAssertedBusDeviceReset:
1748: HostStatus = DID_RESET;
1749: break;
1750: default:
1751: printk("BusLogic: unknown Host Adapter Status 0x%02X\n",
1752: HostAdapterStatus);
1753: HostStatus = DID_ERROR;
1754: break;
1755: }
1756: return (HostStatus << 16) | TargetDeviceStatus;
1757: }
1758:
1759:
1760: /*
1761: BusLogic_InterruptHandler handles hardware interrupts from BusLogic Host
1762: Adapters. To simplify handling shared IRQ Channels, all installed BusLogic
1763: Host Adapters are scanned whenever any one of them signals a hardware
1764: interrupt.
1765: */
1766:
1767: static void BusLogic_InterruptHandler(int IRQ_Channel,
1768: Registers_T *InterruptRegisters)
1769: {
1770: BusLogic_CCB_T *FirstCompletedCCB = NULL, *LastCompletedCCB = NULL;
1771: BusLogic_HostAdapter_T *HostAdapter;
1772: int HostAdapterResetPendingCount = 0;
1773: /*
1774: Iterate over the installed BusLogic Host Adapters accepting any Incoming
1775: Mailbox entries and saving the completed CCBs for processing. This
1776: interrupt handler is installed with SA_INTERRUPT, so interrupts are
1777: disabled when the interrupt handler is entered.
1778: */
1779: for (HostAdapter = BusLogic_RegisteredHostAdapters;
1780: HostAdapter != NULL;
1781: HostAdapter = HostAdapter->Next)
1782: {
1783: unsigned char InterruptRegister;
1784: /*
1785: Acquire exclusive access to Host Adapter.
1786: */
1787: BusLogic_LockHostAdapterID(HostAdapter);
1788: /*
1789: Read the Host Adapter Interrupt Register.
1790: */
1791: InterruptRegister = BusLogic_ReadInterruptRegister(HostAdapter);
1792: if (InterruptRegister & BusLogic_InterruptValid)
1793: {
1794: /*
1795: Acknowledge the interrupt and reset the Host Adapter
1796: Interrupt Register.
1797: */
1798: BusLogic_WriteControlRegister(HostAdapter, BusLogic_InterruptReset);
1799: /*
1800: Process valid SCSI Reset State and Incoming Mailbox Loaded
1801: interrupts. Command Complete interrupts are noted, and
1802: Outgoing Mailbox Available interrupts are ignored, as they
1803: are never enabled.
1804: */
1805: if (InterruptRegister & BusLogic_SCSIResetState)
1806: {
1807: HostAdapter->HostAdapterResetPending = true;
1808: HostAdapterResetPendingCount++;
1809: }
1810: else if (InterruptRegister & BusLogic_IncomingMailboxLoaded)
1811: {
1812: /*
1813: Scan through the Incoming Mailboxes in Strict Round Robin
1814: fashion, saving any completed CCBs for further processing.
1815: It is essential that for each CCB and SCSI Command issued,
1816: command completion processing is performed exactly once.
1817: Therefore, only Incoming Mailboxes with completion code
1818: Command Completed Without Error, Command Completed With
1819: Error, or Command Aborted At Host Request are saved for
1820: completion processing. When an Incoming Mailbox has a
1821: completion code of Aborted Command Not Found, the CCB had
1822: already completed or been aborted before the current Abort
1823: request was processed, and so completion processing has
1824: already occurred and no further action should be taken.
1825: */
1826: BusLogic_IncomingMailbox_T *NextIncomingMailbox =
1827: HostAdapter->NextIncomingMailbox;
1828: BusLogic_CompletionCode_T MailboxCompletionCode;
1829: while ((MailboxCompletionCode =
1830: NextIncomingMailbox->CompletionCode) !=
1831: BusLogic_IncomingMailboxFree)
1832: {
1833: BusLogic_CCB_T *CCB = NextIncomingMailbox->CCB;
1834: if (MailboxCompletionCode != BusLogic_AbortedCommandNotFound)
1835: if (CCB->Status == BusLogic_CCB_Active)
1836: {
1837: /*
1838: Mark this CCB as completed and add it to the end
1839: of the list of completed CCBs.
1840: */
1841: CCB->Status = BusLogic_CCB_Completed;
1842: CCB->MailboxCompletionCode = MailboxCompletionCode;
1843: CCB->Next = NULL;
1844: if (FirstCompletedCCB == NULL)
1845: {
1846: FirstCompletedCCB = CCB;
1847: LastCompletedCCB = CCB;
1848: }
1849: else
1850: {
1851: LastCompletedCCB->Next = CCB;
1852: LastCompletedCCB = CCB;
1853: }
1854: HostAdapter->QueuedOperationCount[CCB->TargetID]--;
1855: }
1856: else
1857: {
1858: /*
1859: If a CCB ever appears in an Incoming Mailbox and
1860: is not marked as status Active, then there is
1861: most likely a bug in the Host Adapter firmware.
1862: */
1863: printk("scsi%d: Illegal CCB #%d status %d in "
1864: "Incoming Mailbox\n", HostAdapter->HostNumber,
1865: CCB->SerialNumber, CCB->Status);
1866: }
1867: else printk("scsi%d: Aborted CCB #%d to Target %d "
1868: "Not Found\n", HostAdapter->HostNumber,
1869: CCB->SerialNumber, CCB->TargetID);
1870: NextIncomingMailbox->CompletionCode =
1871: BusLogic_IncomingMailboxFree;
1872: if (++NextIncomingMailbox > HostAdapter->LastIncomingMailbox)
1873: NextIncomingMailbox = HostAdapter->FirstIncomingMailbox;
1874: }
1875: HostAdapter->NextIncomingMailbox = NextIncomingMailbox;
1876: }
1877: else if (InterruptRegister & BusLogic_CommandComplete)
1878: HostAdapter->HostAdapterCommandCompleted = true;
1879: }
1880: /*
1881: Release exclusive access to Host Adapter.
1882: */
1883: BusLogic_UnlockHostAdapterID(HostAdapter);
1884: }
1885: /*
1886: Enable interrupts while the completed CCBs are processed.
1887: */
1888: sti();
1889: /*
1890: Iterate over the Host Adapters performing any pending Host Adapter Resets.
1891: */
1892: if (HostAdapterResetPendingCount > 0)
1893: for (HostAdapter = BusLogic_RegisteredHostAdapters;
1894: HostAdapter != NULL;
1895: HostAdapter = HostAdapter->Next)
1896: if (HostAdapter->HostAdapterResetPending)
1897: {
1898: BusLogic_ResetHostAdapter(HostAdapter, NULL);
1899: HostAdapter->HostAdapterResetPending = false;
1900: scsi_mark_host_bus_reset(HostAdapter->SCSI_Host);
1901: }
1902: /*
1903: Iterate over the completed CCBs setting the SCSI Command Result Codes,
1904: deallocating the CCBs, and calling the Completion Routines.
1905: */
1906: while (FirstCompletedCCB != NULL)
1907: {
1908: BusLogic_CCB_T *CCB = FirstCompletedCCB;
1909: SCSI_Command_T *Command = CCB->Command;
1910: FirstCompletedCCB = FirstCompletedCCB->Next;
1911: HostAdapter = CCB->HostAdapter;
1912: /*
1913: Bus Device Reset CCBs have the Command field non-NULL only when a Bus
1914: Device Reset was requested for a command that was not currently active
1915: in the Host Adapter, and hence would not have its Completion Routine
1916: called otherwise.
1917: */
1918: if (CCB->Opcode == BusLogic_SCSIBusDeviceReset)
1919: {
1920: printk("scsi%d: Bus Device Reset CCB #%d to Target %d Completed\n",
1921: HostAdapter->HostNumber, CCB->SerialNumber, CCB->TargetID);
1922: if (Command != NULL) Command->result = DID_RESET << 16;
1923: }
1924: else
1925: /*
1926: Translate the Mailbox Completion Code, Host Adapter Status, and
1927: Target Device Status into a SCSI Subsystem Result Code.
1928: */
1929: switch (CCB->MailboxCompletionCode)
1930: {
1931: case BusLogic_IncomingMailboxFree:
1932: case BusLogic_AbortedCommandNotFound:
1933: printk("scsi%d: CCB #%d to Target %d Impossible State\n",
1934: HostAdapter->HostNumber, CCB->SerialNumber, CCB->TargetID);
1935: break;
1936: case BusLogic_CommandCompletedWithoutError:
1937: HostAdapter->CommandSuccessfulFlag[CCB->TargetID] = true;
1938: Command->result = DID_OK << 16;
1939: break;
1940: case BusLogic_CommandAbortedAtHostRequest:
1941: printk("scsi%d: CCB #%d to Target %d Aborted\n",
1942: HostAdapter->HostNumber, CCB->SerialNumber, CCB->TargetID);
1943: Command->result = DID_ABORT << 16;
1944: break;
1945: case BusLogic_CommandCompletedWithError:
1946: Command->result =
1947: BusLogic_ComputeResultCode(CCB->HostAdapterStatus,
1948: CCB->TargetDeviceStatus);
1949: if (BusLogic_GlobalOptions & BusLogic_TraceErrors)
1950: if (CCB->HostAdapterStatus != BusLogic_SCSISelectionTimeout)
1951: {
1952: int i;
1953: printk("scsi%d: CCB #%d Target %d: Result %X "
1954: "Host Adapter Status %02X Target Status %02X\n",
1955: HostAdapter->HostNumber, CCB->SerialNumber,
1956: CCB->TargetID, Command->result,
1957: CCB->HostAdapterStatus, CCB->TargetDeviceStatus);
1958: printk("scsi%d: CDB ", HostAdapter->HostNumber);
1959: for (i = 0; i < CCB->CDB_Length; i++)
1960: printk(" %02X", CCB->CDB[i]);
1961: printk("\n");
1962: printk("scsi%d: Sense ", HostAdapter->HostNumber);
1963: for (i = 0; i < CCB->SenseDataLength; i++)
1964: printk(" %02X", (*CCB->SenseDataPointer)[i]);
1965: printk("\n");
1966: }
1967: break;
1968: }
1969: /*
1970: Place CCB back on the Host Adapter's free list.
1971: */
1972: BusLogic_DeallocateCCB(CCB);
1973: /*
1974: Call the SCSI Command Completion Routine if appropriate.
1975: */
1976: if (Command != NULL) Command->scsi_done(Command);
1977: }
1978: }
1979:
1980:
1981: /*
1982: BusLogic_WriteOutgoingMailbox places CCB and Action Code into an Outgoing
1983: Mailbox for execution by Host Adapter.
1984: */
1985:
1986: static boolean BusLogic_WriteOutgoingMailbox(BusLogic_HostAdapter_T
1987: *HostAdapter,
1988: BusLogic_ActionCode_T ActionCode,
1989: BusLogic_CCB_T *CCB)
1990: {
1991: BusLogic_OutgoingMailbox_T *NextOutgoingMailbox;
1992: boolean Result = false;
1993: BusLogic_LockHostAdapter(HostAdapter);
1994: NextOutgoingMailbox = HostAdapter->NextOutgoingMailbox;
1995: if (NextOutgoingMailbox->ActionCode == BusLogic_OutgoingMailboxFree)
1996: {
1997: CCB->Status = BusLogic_CCB_Active;
1998: /*
1999: The CCB field must be written before the Action Code field since
2000: the Host Adapter is operating asynchronously and the locking code
2001: does not protect against simultaneous access by the Host Adapter.
2002: */
2003: NextOutgoingMailbox->CCB = CCB;
2004: NextOutgoingMailbox->ActionCode = ActionCode;
2005: BusLogic_StartMailboxScan(HostAdapter);
2006: if (++NextOutgoingMailbox > HostAdapter->LastOutgoingMailbox)
2007: NextOutgoingMailbox = HostAdapter->FirstOutgoingMailbox;
2008: HostAdapter->NextOutgoingMailbox = NextOutgoingMailbox;
2009: if (ActionCode == BusLogic_MailboxStartCommand)
2010: HostAdapter->QueuedOperationCount[CCB->TargetID]++;
2011: Result = true;
2012: }
2013: BusLogic_UnlockHostAdapter(HostAdapter);
2014: return Result;
2015: }
2016:
2017:
2018: /*
2019: BusLogic_QueueCommand creates a CCB for Command and places it into an
2020: Outgoing Mailbox for execution by the associated Host Adapter.
2021: */
2022:
2023: int BusLogic_QueueCommand(SCSI_Command_T *Command,
2024: void (*CompletionRoutine)(SCSI_Command_T *))
2025: {
2026: BusLogic_HostAdapter_T *HostAdapter =
2027: (BusLogic_HostAdapter_T *) Command->host->hostdata;
2028: unsigned char *CDB = Command->cmnd;
2029: unsigned char CDB_Length = Command->cmd_len;
2030: unsigned char TargetID = Command->target;
2031: unsigned char LogicalUnit = Command->lun;
2032: void *BufferPointer = Command->request_buffer;
2033: int BufferLength = Command->request_bufflen;
2034: int SegmentCount = Command->use_sg;
2035: BusLogic_CCB_T *CCB;
2036: long EnableTQ;
2037: /*
2038: SCSI REQUEST_SENSE commands will be executed automatically by the Host
2039: Adapter for any errors, so they should not be executed explicitly unless
2040: the Sense Data is zero indicating that no error occurred.
2041: */
2042: if (CDB[0] == REQUEST_SENSE && Command->sense_buffer[0] != 0)
2043: {
2044: Command->result = DID_OK << 16;
2045: CompletionRoutine(Command);
2046: return 0;
2047: }
2048: /*
2049: Allocate a CCB from the Host Adapter's free list. If there are none
2050: available and memory allocation fails, return a result code of Bus Busy
2051: so that this Command will be retried.
2052: */
2053: CCB = BusLogic_AllocateCCB(HostAdapter);
2054: if (CCB == NULL)
2055: {
2056: Command->result = DID_BUS_BUSY << 16;
2057: CompletionRoutine(Command);
2058: return 0;
2059: }
2060: /*
2061: Initialize the fields in the BusLogic Command Control Block (CCB).
2062: */
2063: if (SegmentCount == 0)
2064: {
2065: CCB->Opcode = BusLogic_InitiatorCCB;
2066: CCB->DataLength = BufferLength;
2067: CCB->DataPointer = BufferPointer;
2068: }
2069: else
2070: {
2071: SCSI_ScatterList_T *ScatterList = (SCSI_ScatterList_T *) BufferPointer;
2072: int Segment;
2073: CCB->Opcode = BusLogic_InitiatorCCB_ScatterGather;
2074: CCB->DataLength = SegmentCount * sizeof(BusLogic_ScatterGatherSegment_T);
2075: CCB->DataPointer = CCB->ScatterGatherList;
2076: for (Segment = 0; Segment < SegmentCount; Segment++)
2077: {
2078: CCB->ScatterGatherList[Segment].SegmentByteCount =
2079: ScatterList[Segment].length;
2080: CCB->ScatterGatherList[Segment].SegmentDataPointer =
2081: ScatterList[Segment].address;
2082: }
2083: }
2084: switch (CDB[0])
2085: {
2086: case READ_6:
2087: case READ_10:
2088: CCB->DataDirection = BusLogic_DataInLengthChecked;
2089: HostAdapter->ReadWriteOperationCount[TargetID]++;
2090: break;
2091: case WRITE_6:
2092: case WRITE_10:
2093: CCB->DataDirection = BusLogic_DataOutLengthChecked;
2094: HostAdapter->ReadWriteOperationCount[TargetID]++;
2095: break;
2096: default:
2097: CCB->DataDirection = BusLogic_UncheckedDataTransfer;
2098: break;
2099: }
2100: CCB->CDB_Length = CDB_Length;
2101: CCB->SenseDataLength = sizeof(Command->sense_buffer);
2102: CCB->HostAdapterStatus = 0;
2103: CCB->TargetDeviceStatus = 0;
2104: CCB->TargetID = TargetID;
2105: CCB->LogicalUnit = LogicalUnit;
2106: /*
2107: For Wide SCSI Host Adapters, Wide Mode CCBs are used to support more than
2108: 8 Logical Units per Target, and this requires setting the overloaded
2109: TagEnable field to Logical Unit bit 5.
2110: */
2111: if (HostAdapter->HostWideSCSI)
2112: {
2113: CCB->TagEnable = LogicalUnit >> 5;
2114: CCB->WideModeTagEnable = false;
2115: }
2116: else CCB->TagEnable = false;
2117: /*
2118: BusLogic recommends that after a Reset the first couple of commands that
2119: are sent to a Target be sent in a non Tagged Queue fashion so that the Host
2120: Adapter and Target can establish Synchronous Transfer before Queue Tag
2121: messages can interfere with the Synchronous Negotiation message. By
2122: waiting to enable tagged Queuing until after the first 16 read/write
2123: commands have been sent, it is assured that the Tagged Queuing message
2124: will not occur while the partition table is printed.
2125: */
2126: if ((HostAdapter->TaggedQueuingPermitted & (1 << TargetID)) &&
2127: Command->device->tagged_supported &&
2128: (EnableTQ = HostAdapter->ReadWriteOperationCount[TargetID] - 16) >= 0)
2129: {
2130: BusLogic_QueueTag_T QueueTag = BusLogic_SimpleQueueTag;
2131: unsigned long CurrentTime = jiffies;
2132: if (EnableTQ == 0)
2133: printk("scsi%d: Tagged Queuing now active for Target %d\n",
2134: HostAdapter->HostNumber, TargetID);
2135: /*
2136: When using Tagged Queuing with Simple Queue Tags, it appears that disk
2137: drive controllers do not guarantee that a queued command will not
2138: remain in a disconnected state indefinitely if commands that read or
2139: write nearer the head position continue to arrive without interruption.
2140: Therefore, for each Target Device this driver keeps track of the last
2141: time either the queue was empty or an Ordered Queue Tag was issued. If
2142: more than 2 seconds have elapsed since this last sequence point, this
2143: command will be issued with an Ordered Queue Tag rather than a Simple
2144: Queue Tag, which forces the Target Device to complete all previously
2145: queued commands before this command may be executed.
2146: */
2147: if (HostAdapter->QueuedOperationCount[TargetID] == 0)
2148: HostAdapter->LastSequencePoint[TargetID] = CurrentTime;
2149: else if (CurrentTime - HostAdapter->LastSequencePoint[TargetID] > 2*HZ)
2150: {
2151: HostAdapter->LastSequencePoint[TargetID] = CurrentTime;
2152: QueueTag = BusLogic_OrderedQueueTag;
2153: }
2154: if (HostAdapter->HostWideSCSI)
2155: {
2156: CCB->WideModeTagEnable = true;
2157: CCB->WideModeQueueTag = QueueTag;
2158: }
2159: else
2160: {
2161: CCB->TagEnable = true;
2162: CCB->QueueTag = QueueTag;
2163: }
2164: }
2165: memcpy(CCB->CDB, CDB, CDB_Length);
2166: CCB->SenseDataPointer = (SCSI_SenseData_T *) &Command->sense_buffer;
2167: CCB->Command = Command;
2168: Command->scsi_done = CompletionRoutine;
2169: /*
2170: Place the CCB in an Outgoing Mailbox. If there are no Outgoing
2171: Mailboxes available, return a result code of Bus Busy so that this
2172: Command will be retried.
2173: */
2174: if (!(BusLogic_WriteOutgoingMailbox(HostAdapter,
2175: BusLogic_MailboxStartCommand, CCB)))
2176: {
2177: printk("scsi%d: cannot write Outgoing Mailbox\n",
2178: HostAdapter->HostNumber);
2179: BusLogic_DeallocateCCB(CCB);
2180: Command->result = DID_BUS_BUSY << 16;
2181: CompletionRoutine(Command);
2182: }
2183: return 0;
2184: }
2185:
2186:
2187: /*
2188: BusLogic_AbortCommand aborts Command if possible.
2189: */
2190:
2191: int BusLogic_AbortCommand(SCSI_Command_T *Command)
2192: {
2193: BusLogic_HostAdapter_T *HostAdapter =
2194: (BusLogic_HostAdapter_T *) Command->host->hostdata;
2195: unsigned long CommandPID = Command->pid;
2196: unsigned char InterruptRegister;
2197: BusLogic_CCB_T *CCB;
2198: int Result;
2199: /*
2200: If the Host Adapter has posted an interrupt but the Interrupt Handler
2201: has not been called for some reason (i.e. the interrupt was lost), try
2202: calling the Interrupt Handler directly to process the commands that
2203: have been completed.
2204: */
2205: InterruptRegister = BusLogic_ReadInterruptRegister(HostAdapter);
2206: if (InterruptRegister & BusLogic_InterruptValid)
2207: {
2208: unsigned long ProcessorFlags;
2209: printk("scsi%d: Recovering Lost/Delayed Interrupt for IRQ Channel %d\n",
2210: HostAdapter->HostNumber, HostAdapter->IRQ_Channel);
2211: save_flags(ProcessorFlags);
2212: cli();
2213: BusLogic_InterruptHandler(HostAdapter->IRQ_Channel, NULL);
2214: restore_flags(ProcessorFlags);
2215: return SCSI_ABORT_SNOOZE;
2216: }
2217: /*
2218: Find the CCB to be aborted if possible.
2219: */
2220: BusLogic_LockHostAdapter(HostAdapter);
2221: for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
2222: if (CCB->Command == Command) break;
2223: BusLogic_UnlockHostAdapter(HostAdapter);
2224: if (CCB == NULL)
2225: {
2226: printk("scsi%d: Unable to Abort Command to Target %d - No CCB Found\n",
2227: HostAdapter->HostNumber, Command->target);
2228: return SCSI_ABORT_NOT_RUNNING;
2229: }
2230: /*
2231: Briefly pause to see if this command will complete.
2232: */
2233: printk("scsi%d: Pausing briefly to see if CCB #%d "
2234: "to Target %d will complete\n",
2235: HostAdapter->HostNumber, CCB->SerialNumber, CCB->TargetID);
2236: BusLogic_Delay(2);
2237: /*
2238: If this CCB is still Active and still refers to the same Command, then
2239: actually aborting this Command is necessary.
2240: */
2241: BusLogic_LockHostAdapter(HostAdapter);
2242: Result = SCSI_ABORT_NOT_RUNNING;
2243: if (CCB->Status == BusLogic_CCB_Active &&
2244: CCB->Command == Command && Command->pid == CommandPID)
2245: {
2246: /*
2247: Attempt to abort this CCB.
2248: */
2249: if (BusLogic_WriteOutgoingMailbox(HostAdapter,
2250: BusLogic_MailboxAbortCommand, CCB))
2251: {
2252: printk("scsi%d: Aborting CCB #%d to Target %d\n",
2253: HostAdapter->HostNumber, CCB->SerialNumber, CCB->TargetID);
2254: Result = SCSI_ABORT_PENDING;
2255: }
2256: else
2257: {
2258: printk("scsi%d: Unable to Abort CCB #%d to Target %d - "
2259: "No Outgoing Mailboxes\n", HostAdapter->HostNumber,
2260: CCB->SerialNumber, CCB->TargetID);
2261: Result = SCSI_ABORT_BUSY;
2262: }
2263: }
2264: else printk("scsi%d: CCB #%d to Target %d completed\n",
2265: HostAdapter->HostNumber, CCB->SerialNumber, CCB->TargetID);
2266: BusLogic_UnlockHostAdapter(HostAdapter);
2267: return Result;
2268: }
2269:
2270:
2271: /*
2272: BusLogic_ResetHostAdapter resets Host Adapter if possible, marking all
2273: currently executing SCSI commands as having been reset, as well as
2274: the specified Command if non-NULL.
2275: */
2276:
2277: static int BusLogic_ResetHostAdapter(BusLogic_HostAdapter_T *HostAdapter,
2278: SCSI_Command_T *Command)
2279: {
2280: BusLogic_CCB_T *CCB;
2281: if (Command == NULL)
2282: printk("scsi%d: Resetting %s due to SCSI Reset State Interrupt\n",
2283: HostAdapter->HostNumber, HostAdapter->BoardName);
2284: else printk("scsi%d: Resetting %s due to Target %d\n",
2285: HostAdapter->HostNumber, HostAdapter->BoardName, Command->target);
2286: /*
2287: Attempt to Reset and Reinitialize the Host Adapter.
2288: */
2289: BusLogic_LockHostAdapter(HostAdapter);
2290: if (!(BusLogic_HardResetHostAdapter(HostAdapter) &&
2291: BusLogic_InitializeHostAdapter(HostAdapter)))
2292: {
2293: printk("scsi%d: Resetting %s Failed\n",
2294: HostAdapter->HostNumber, HostAdapter->BoardName);
2295: BusLogic_UnlockHostAdapter(HostAdapter);
2296: return SCSI_RESET_ERROR;
2297: }
2298: BusLogic_UnlockHostAdapter(HostAdapter);
2299: /*
2300: Wait a few seconds between the Host Adapter Hard Reset which initiates
2301: a SCSI Bus Reset and issuing any SCSI commands. Some SCSI devices get
2302: confused if they receive SCSI commands too soon after a SCSI Bus Reset.
2303: */
2304: BusLogic_Delay(HostAdapter->BusSettleTime);
2305: /*
2306: Mark all currently executing CCBs as having been reset.
2307: */
2308: BusLogic_LockHostAdapter(HostAdapter);
2309: for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
2310: if (CCB->Status == BusLogic_CCB_Active)
2311: {
2312: CCB->Status = BusLogic_CCB_Reset;
2313: if (CCB->Command == Command)
2314: {
2315: CCB->Command = NULL;
2316: /*
2317: Disable Tagged Queuing if it was active for this Target Device.
2318: */
2319: if (((HostAdapter->HostWideSCSI && CCB->WideModeTagEnable) ||
2320: (!HostAdapter->HostWideSCSI && CCB->TagEnable)) &&
2321: (HostAdapter->TaggedQueuingPermitted & (1 << CCB->TargetID)))
2322: {
2323: HostAdapter->TaggedQueuingPermitted &= ~(1 << CCB->TargetID);
2324: printk("scsi%d: Tagged Queuing now disabled for Target %d\n",
2325: HostAdapter->HostNumber, CCB->TargetID);
2326: }
2327: }
2328: }
2329: BusLogic_UnlockHostAdapter(HostAdapter);
2330: /*
2331: Perform completion processing for the Command being Reset.
2332: */
2333: if (Command != NULL)
2334: {
2335: Command->result = DID_RESET << 16;
2336: Command->scsi_done(Command);
2337: }
2338: /*
2339: Perform completion processing for any other active CCBs.
2340: */
2341: for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
2342: if (CCB->Status == BusLogic_CCB_Reset)
2343: {
2344: Command = CCB->Command;
2345: BusLogic_DeallocateCCB(CCB);
2346: if (Command != NULL)
2347: {
2348: Command->result = DID_RESET << 16;
2349: Command->scsi_done(Command);
2350: }
2351: }
2352: return SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET;
2353: }
2354:
2355:
2356: /*
2357: BusLogic_BusDeviceReset sends a Bus Device Reset to the Target
2358: associated with Command.
2359: */
2360:
2361: static int BusLogic_BusDeviceReset(BusLogic_HostAdapter_T *HostAdapter,
2362: SCSI_Command_T *Command)
2363: {
2364: BusLogic_CCB_T *CCB = BusLogic_AllocateCCB(HostAdapter), *XCCB;
2365: unsigned char TargetID = Command->target;
2366: /*
2367: If sending a Bus Device Reset is impossible, attempt a full Host
2368: Adapter Hard Reset and SCSI Bus Reset.
2369: */
2370: if (CCB == NULL)
2371: return BusLogic_ResetHostAdapter(HostAdapter, Command);
2372: printk("scsi%d: Sending Bus Device Reset CCB #%d to Target %d\n",
2373: HostAdapter->HostNumber, CCB->SerialNumber, TargetID);
2374: CCB->Opcode = BusLogic_SCSIBusDeviceReset;
2375: CCB->TargetID = TargetID;
2376: CCB->Command = Command;
2377: /*
2378: If there is a currently executing CCB in the Host Adapter for this Command,
2379: then an Incoming Mailbox entry will be made with a completion code of
2380: BusLogic_HostAdapterAssertedBusDeviceReset. Otherwise, the CCB's Command
2381: field will be left pointing to the Command so that the interrupt for the
2382: completion of the Bus Device Reset can call the Completion Routine for the
2383: Command.
2384: */
2385: BusLogic_LockHostAdapter(HostAdapter);
2386: for (XCCB = HostAdapter->All_CCBs; XCCB != NULL; XCCB = XCCB->NextAll)
2387: if (XCCB->Command == Command && XCCB->Status == BusLogic_CCB_Active)
2388: {
2389: CCB->Command = NULL;
2390: /*
2391: Disable Tagged Queuing if it was active for this Target Device.
2392: */
2393: if (((HostAdapter->HostWideSCSI && XCCB->WideModeTagEnable) ||
2394: (!HostAdapter->HostWideSCSI && XCCB->TagEnable)) &&
2395: (HostAdapter->TaggedQueuingPermitted & (1 << TargetID)))
2396: {
2397: HostAdapter->TaggedQueuingPermitted &= ~(1 << TargetID);
2398: printk("scsi%d: Tagged Queuing now disabled for Target %d\n",
2399: HostAdapter->HostNumber, TargetID);
2400: }
2401: break;
2402: }
2403: BusLogic_UnlockHostAdapter(HostAdapter);
2404: /*
2405: Attempt to write an Outgoing Mailbox with the Bus Device Reset CCB.
2406: If sending a Bus Device Reset is impossible, attempt a full Host
2407: Adapter Hard Reset and SCSI Bus Reset.
2408: */
2409: if (!(BusLogic_WriteOutgoingMailbox(HostAdapter,
2410: BusLogic_MailboxStartCommand, CCB)))
2411: {
2412: printk("scsi%d: cannot write Outgoing Mailbox for Bus Device Reset\n",
2413: HostAdapter->HostNumber);
2414: BusLogic_DeallocateCCB(CCB);
2415: return BusLogic_ResetHostAdapter(HostAdapter, Command);
2416: }
2417: HostAdapter->ReadWriteOperationCount[TargetID] = 0;
2418: HostAdapter->QueuedOperationCount[TargetID] = 0;
2419: return SCSI_RESET_PENDING;
2420: }
2421:
2422:
2423: /*
2424: BusLogic_ResetCommand takes appropriate action to reset Command.
2425: */
2426:
2427: int BusLogic_ResetCommand(SCSI_Command_T *Command)
2428: {
2429: BusLogic_HostAdapter_T *HostAdapter =
2430: (BusLogic_HostAdapter_T *) Command->host->hostdata;
2431: unsigned char TargetID = Command->target;
2432: unsigned char ErrorRecoveryOption =
2433: HostAdapter->ErrorRecoveryOption[TargetID];
2434: if (ErrorRecoveryOption == BusLogic_ErrorRecoveryDefault)
2435: if (Command->host->suggest_bus_reset)
2436: ErrorRecoveryOption = BusLogic_ErrorRecoveryHardReset;
2437: else ErrorRecoveryOption = BusLogic_ErrorRecoveryBusDeviceReset;
2438: switch (ErrorRecoveryOption)
2439: {
2440: case BusLogic_ErrorRecoveryHardReset:
2441: return BusLogic_ResetHostAdapter(HostAdapter, Command);
2442: case BusLogic_ErrorRecoveryBusDeviceReset:
2443: if (HostAdapter->CommandSuccessfulFlag[TargetID])
2444: {
2445: HostAdapter->CommandSuccessfulFlag[TargetID] = false;
2446: return BusLogic_BusDeviceReset(HostAdapter, Command);
2447: }
2448: else return BusLogic_ResetHostAdapter(HostAdapter, Command);
2449: }
2450: printk("scsi%d: Error Recovery for Target %d Suppressed\n",
2451: HostAdapter->HostNumber, TargetID);
2452: return SCSI_RESET_PUNT;
2453: }
2454:
2455:
2456: /*
2457: BusLogic_BIOSDiskParameters returns the Heads/Sectors/Cylinders BIOS Disk
2458: Parameters for Disk. The default disk geometry is 64 heads, 32 sectors, and
2459: the appropriate number of cylinders so as not to exceed drive capacity. In
2460: order for disks equal to or larger than 1 GB to be addressable by the BIOS
2461: without exceeding the BIOS limitation of 1024 cylinders, Extended Translation
2462: may be enabled in AutoSCSI on "C" Series boards or by a dip switch setting
2463: on older boards. With Extended Translation enabled, drives between 1 GB
2464: inclusive and 2 GB exclusive are given a disk geometry of 128 heads and 32
2465: sectors, and drives between 2 GB inclusive and 8 GB exclusive are given a
2466: disk geometry of 255 heads and 63 sectors. On "C" Series boards the firmware
2467: can be queried for the precise translation in effect for each drive
2468: individually, but there is really no need to do so since we know the total
2469: capacity of the drive and whether Extended Translation is enabled, hence we
2470: can deduce the BIOS disk geometry that must be in effect.
2471: */
2472:
2473: int BusLogic_BIOSDiskParameters(SCSI_Disk_T *Disk, KernelDevice_T Device,
2474: int *Parameters)
2475: {
2476: BusLogic_HostAdapter_T *HostAdapter =
2477: (BusLogic_HostAdapter_T *) Disk->device->host->hostdata;
2478: BIOS_DiskParameters_T *DiskParameters = (BIOS_DiskParameters_T *) Parameters;
2479: if (HostAdapter->ExtendedTranslation &&
2480: Disk->capacity >= 2*1024*1024 /* 1 GB in 512 byte sectors */)
2481: if (Disk->capacity >= 4*1024*1024 /* 2 GB in 512 byte sectors */)
2482: {
2483: DiskParameters->Heads = 255;
2484: DiskParameters->Sectors = 63;
2485: }
2486: else
2487: {
2488: DiskParameters->Heads = 128;
2489: DiskParameters->Sectors = 32;
2490: }
2491: else
2492: {
2493: DiskParameters->Heads = 64;
2494: DiskParameters->Sectors = 32;
2495: }
2496: DiskParameters->Cylinders =
2497: Disk->capacity / (DiskParameters->Heads * DiskParameters->Sectors);
2498: return 0;
2499: }
2500:
2501:
2502: /*
2503: BusLogic_Setup handles processing of Kernel Command Line Arguments.
2504:
2505: For the BusLogic driver, a kernel command line entry comprises the driver
2506: identifier "BusLogic=" optionally followed by a comma-separated sequence of
2507: integers and then optionally followed by a comma-separated sequence of
2508: strings. Each command line entry applies to one BusLogic Host Adapter.
2509: Multiple command line entries may be used in systems which contain multiple
2510: BusLogic Host Adapters.
2511:
2512: The first integer specified is the I/O Address at which the Host Adapter is
2513: located. If unspecified, it defaults to 0 which means to apply this entry to
2514: the first BusLogic Host Adapter found during the default probe sequence. If
2515: any I/O Address parameters are provided on the command line, then the default
2516: probe sequence is omitted.
2517:
2518: The second integer specified is the number of Concurrent Commands per Logical
2519: Unit to allow for Target Devices on the Host Adapter. If unspecified, it
2520: defaults to 0 which means to use the value of BusLogic_Concurrency for
2521: non-ISA Host Adapters, or BusLogic_Concurrency_ISA for ISA Host Adapters.
2522:
2523: The third integer specified is the Bus Settle Time in seconds. This is
2524: the amount of time to wait between a Host Adapter Hard Reset which initiates
2525: a SCSI Bus Reset and issuing any SCSI commands. If unspecified, it defaults
2526: to 0 which means to use the value of BusLogic_DefaultBusSettleTime.
2527:
2528: The fourth integer specified is the Local Options. If unspecified, it
2529: defaults to 0. Note that Local Options are only applied to a specific Host
2530: Adapter.
2531:
2532: The fifth integer specified is the Global Options. If unspecified, it
2533: defaults to 0. Note that Global Options are applied across all Host
2534: Adapters.
2535:
2536: The string options are used to provide control over Tagged Queuing and Error
2537: Recovery. If both Tagged Queuing and Error Recovery strings are provided, the
2538: Tagged Queuing specification string must come first.
2539:
2540: The Tagged Queuing specification begins with "TQ:" and allows for explicitly
2541: specifying whether Tagged Queuing is permitted on Target Devices that support
2542: it. The following specification options are available:
2543:
2544: TQ:Default Tagged Queuing will be permitted based on the firmware
2545: version of the BusLogic Host Adapter and based on
2546: whether the Concurrency value allows queuing multiple
2547: commands.
2548:
2549: TQ:Enable Tagged Queuing will be enabled for all Target Devices
2550: on this Host Adapter overriding any limitation that
2551: would otherwise be imposed based on the Host Adapter
2552: firmware version.
2553:
2554: TQ:Disable Tagged Queuing will be disabled for all Target Devices
2555: on this Host Adapter.
2556:
2557: TQ:<Per-Target-Spec> Tagged Queuing will be controlled individually for each
2558: Target Device. <Per-Target-Spec> is a sequence of "Y",
2559: "N", and "X" characters. "Y" enabled Tagged Queuing,
2560: "N" disables Tagged Queuing, and "X" accepts the
2561: default based on the firmware version. The first
2562: character refers to Target 0, the second to Target 1,
2563: and so on; if the sequence of "Y", "N", and "X"
2564: characters does not cover all the Target Devices,
2565: unspecified characters are assumed to be "X".
2566:
2567: Note that explicitly requesting Tagged Queuing may lead to problems; this
2568: facility is provided primarily to allow disabling Tagged Queuing on Target
2569: Devices that do not implement it correctly.
2570:
2571: The Error Recovery specification begins with "ER:" and allows for explicitly
2572: specifying the Error Recovery action to be performed when ResetCommand is
2573: called due to a SCSI Command failing to complete successfully. The following
2574: specification options are available:
2575:
2576: ER:Default Error Recovery will select between the Hard Reset and
2577: Bus Device Reset options based on the recommendation
2578: of the SCSI Subsystem.
2579:
2580: ER:HardReset Error Recovery will initiate a Host Adapter Hard Reset
2581: which also causes a SCSI Bus Reset.
2582:
2583: ER:BusDeviceReset Error Recovery will send a Bus Device Reset message to
2584: the individual Target Device causing the error. If
2585: Error Recovery is again initiated for this Target
2586: Device and no SCSI Command to this Target Device has
2587: completed successfully since the Bus Device Reset
2588: message was sent, then a Hard Reset will be attempted.
2589:
2590: ER:None Error Recovery will be suppressed. This option should
2591: only be selected if a SCSI Bus Reset or Bus Device
2592: Reset will cause the Target Device to fail completely
2593: and unrecoverably.
2594:
2595: ER:<Per-Target-Spec> Error Recovery will be controlled individually for each
2596: Target Device. <Per-Target-Spec> is a sequence of "D",
2597: "H", "B", and "N" characters. "D" selects Default, "H"
2598: selects Hard Reset, "B" selects Bus Device Reset, and
2599: "N" selects None. The first character refers to Target
2600: 0, the second to Target 1, and so on; if the sequence
2601: of "D", "H", "B", and "N" characters does not cover all
2602: the Target Devices, unspecified characters are assumed
2603: to be "D".
2604: */
2605:
2606: void BusLogic_Setup(char *Strings, int *Integers)
2607: {
2608: BusLogic_CommandLineEntry_T *CommandLineEntry =
2609: &BusLogic_CommandLineEntries[BusLogic_CommandLineEntryCount++];
2610: static int ProbeListIndex = 0;
2611: int IntegerCount = Integers[0], TargetID, i;
2612: CommandLineEntry->IO_Address = 0;
2613: CommandLineEntry->Concurrency = 0;
2614: CommandLineEntry->BusSettleTime = 0;
2615: CommandLineEntry->LocalOptions = 0;
2616: CommandLineEntry->TaggedQueuingPermitted = 0;
2617: CommandLineEntry->TaggedQueuingPermittedMask = 0;
2618: memset(CommandLineEntry->ErrorRecoveryOption,
2619: BusLogic_ErrorRecoveryDefault,
2620: sizeof(CommandLineEntry->ErrorRecoveryOption));
2621: if (IntegerCount > 5)
2622: printk("BusLogic: Unexpected Command Line Integers ignored\n");
2623: if (IntegerCount >= 1)
2624: {
2625: unsigned short IO_Address = Integers[1];
2626: if (IO_Address > 0)
2627: {
2628: for (i = 0; ; i++)
2629: if (BusLogic_IO_StandardAddresses[i] == 0)
2630: {
2631: printk("BusLogic: Invalid Command Line Entry "
2632: "(illegal I/O Address 0x%X)\n", IO_Address);
2633: return;
2634: }
2635: else if (i < ProbeListIndex &&
2636: IO_Address == BusLogic_IO_AddressProbeList[i])
2637: {
2638: printk("BusLogic: Invalid Command Line Entry "
2639: "(duplicate I/O Address 0x%X)\n", IO_Address);
2640: return;
2641: }
2642: else if (IO_Address >= 0x1000 ||
2643: IO_Address == BusLogic_IO_StandardAddresses[i]) break;
2644: BusLogic_IO_AddressProbeList[ProbeListIndex++] = IO_Address;
2645: BusLogic_IO_AddressProbeList[ProbeListIndex] = 0;
2646: }
2647: CommandLineEntry->IO_Address = IO_Address;
2648: }
2649: if (IntegerCount >= 2)
2650: {
2651: unsigned short Concurrency = Integers[2];
2652: if (Concurrency > BusLogic_MailboxCount)
2653: {
2654: printk("BusLogic: Invalid Command Line Entry "
2655: "(illegal Concurrency %d)\n", Concurrency);
2656: return;
2657: }
2658: CommandLineEntry->Concurrency = Concurrency;
2659: }
2660: if (IntegerCount >= 3)
2661: CommandLineEntry->BusSettleTime = Integers[3];
2662: if (IntegerCount >= 4)
2663: CommandLineEntry->LocalOptions = Integers[4];
2664: if (IntegerCount >= 5)
2665: BusLogic_GlobalOptions |= Integers[5];
2666: if (!(BusLogic_CommandLineEntryCount == 0 || ProbeListIndex == 0 ||
2667: BusLogic_CommandLineEntryCount == ProbeListIndex))
2668: {
2669: printk("BusLogic: Invalid Command Line Entry "
2670: "(all or no I/O Addresses must be specified)\n");
2671: return;
2672: }
2673: if (Strings == NULL) return;
2674: if (strncmp(Strings, "TQ:", 3) == 0)
2675: {
2676: Strings += 3;
2677: if (strncmp(Strings, "Default", 7) == 0)
2678: Strings += 7;
2679: else if (strncmp(Strings, "Enable", 6) == 0)
2680: {
2681: Strings += 6;
2682: CommandLineEntry->TaggedQueuingPermitted = 0xFFFF;
2683: CommandLineEntry->TaggedQueuingPermittedMask = 0xFFFF;
2684: }
2685: else if (strncmp(Strings, "Disable", 7) == 0)
2686: {
2687: Strings += 7;
2688: CommandLineEntry->TaggedQueuingPermitted = 0x0000;
2689: CommandLineEntry->TaggedQueuingPermittedMask = 0xFFFF;
2690: }
2691: else
2692: for (TargetID = 0; TargetID < BusLogic_MaxTargetIDs; TargetID++)
2693: switch (*Strings++)
2694: {
2695: case 'Y':
2696: CommandLineEntry->TaggedQueuingPermitted |= 1 << TargetID;
2697: CommandLineEntry->TaggedQueuingPermittedMask |= 1 << TargetID;
2698: break;
2699: case 'N':
2700: CommandLineEntry->TaggedQueuingPermittedMask |= 1 << TargetID;
2701: break;
2702: case 'X':
2703: break;
2704: default:
2705: Strings--;
2706: TargetID = BusLogic_MaxTargetIDs;
2707: break;
2708: }
2709: }
2710: if (*Strings == ',') Strings++;
2711: if (strncmp(Strings, "ER:", 3) == 0)
2712: {
2713: Strings += 3;
2714: if (strncmp(Strings, "Default", 7) == 0)
2715: Strings += 7;
2716: else if (strncmp(Strings, "HardReset", 9) == 0)
2717: {
2718: Strings += 9;
2719: memset(CommandLineEntry->ErrorRecoveryOption,
2720: BusLogic_ErrorRecoveryHardReset,
2721: sizeof(CommandLineEntry->ErrorRecoveryOption));
2722: }
2723: else if (strncmp(Strings, "BusDeviceReset", 14) == 0)
2724: {
2725: Strings += 14;
2726: memset(CommandLineEntry->ErrorRecoveryOption,
2727: BusLogic_ErrorRecoveryBusDeviceReset,
2728: sizeof(CommandLineEntry->ErrorRecoveryOption));
2729: }
2730: else if (strncmp(Strings, "None", 4) == 0)
2731: {
2732: Strings += 4;
2733: memset(CommandLineEntry->ErrorRecoveryOption,
2734: BusLogic_ErrorRecoveryNone,
2735: sizeof(CommandLineEntry->ErrorRecoveryOption));
2736: }
2737: else
2738: for (TargetID = 0; TargetID < BusLogic_MaxTargetIDs; TargetID++)
2739: switch (*Strings++)
2740: {
2741: case 'D':
2742: CommandLineEntry->ErrorRecoveryOption[TargetID] =
2743: BusLogic_ErrorRecoveryDefault;
2744: break;
2745: case 'H':
2746: CommandLineEntry->ErrorRecoveryOption[TargetID] =
2747: BusLogic_ErrorRecoveryHardReset;
2748: break;
2749: case 'B':
2750: CommandLineEntry->ErrorRecoveryOption[TargetID] =
2751: BusLogic_ErrorRecoveryBusDeviceReset;
2752: break;
2753: case 'N':
2754: CommandLineEntry->ErrorRecoveryOption[TargetID] =
2755: BusLogic_ErrorRecoveryNone;
2756: break;
2757: default:
2758: Strings--;
2759: TargetID = BusLogic_MaxTargetIDs;
2760: break;
2761: }
2762: }
2763: if (*Strings != '\0')
2764: printk("BusLogic: Unexpected Command Line String '%s' ignored\n", Strings);
2765: }
2766:
2767:
2768: /*
2769: Include Module support if requested.
2770: */
2771:
2772:
2773: #ifdef MODULE
2774:
2775: SCSI_Host_Template_T driver_template = BUSLOGIC;
2776:
2777: #include "scsi_module.c"
2778:
2779: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.