![[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 / linux / src / drivers / scsi|
Return to BusLogic.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi |
1.1 root 1: /*
2:
3: Linux Driver for BusLogic MultiMaster and FlashPoint SCSI Host Adapters
4:
5: Copyright 1995-1998 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.
10:
11: This program is distributed in the hope that it will be useful, but
12: WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY
13: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14: for complete details.
15:
16: The author respectfully requests that any modifications to this software be
17: sent directly to him for evaluation and testing.
18:
19: Special thanks to Wayne Yen, Jin-Lon Hon, and Alex Win of BusLogic, whose
20: advice has been invaluable, to David Gentzel, for writing the original Linux
21: BusLogic driver, and to Paul Gortmaker, for being such a dedicated test site.
22:
23: Finally, special thanks to Mylex/BusLogic for making the FlashPoint SCCB
24: Manager available as freely redistributable source code.
25:
26: */
27:
28:
29: #define BusLogic_DriverVersion "2.0.15"
30: #define BusLogic_DriverDate "17 August 1998"
31:
32:
33: #include <linux/version.h>
34: #include <linux/module.h>
35: #include <linux/config.h>
36: #include <linux/types.h>
37: #include <linux/blkdev.h>
38: #include <linux/delay.h>
39: #include <linux/ioport.h>
40: #include <linux/mm.h>
41: #include <linux/sched.h>
42: #include <linux/stat.h>
43: #include <linux/pci.h>
44: #include <linux/bios32.h>
45: #include <asm/dma.h>
46: #include <asm/io.h>
47: #include <asm/irq.h>
48: #include <asm/system.h>
49: #include "scsi.h"
50: #include "hosts.h"
51: #include "sd.h"
52: #include "BusLogic.h"
53: #include "FlashPoint.c"
54:
55:
56: /*
57: BusLogic_DriverOptionsCount is a count of the number of BusLogic Driver
58: Options specifications provided via the Linux Kernel Command Line or via
59: the Loadable Kernel Module Installation Facility.
60: */
61:
62: static int
63: BusLogic_DriverOptionsCount = 0;
64:
65:
66: /*
67: BusLogic_DriverOptions is an array of Driver Options structures representing
68: BusLogic Driver Options specifications provided via the Linux Kernel Command
69: Line or via the Loadable Kernel Module Installation Facility.
70: */
71:
72: static BusLogic_DriverOptions_T
73: BusLogic_DriverOptions[BusLogic_MaxHostAdapters];
74:
75:
76: /*
77: BusLogic_Options can be assigned a string by the Loadable Kernel Module
78: Installation Facility to be parsed for BusLogic Driver Options
79: specifications.
80: */
81:
82: static char
83: *BusLogic_Options = NULL;
84:
85:
86: /*
87: BusLogic_ProbeOptions is a set of Probe Options to be applied across
88: all BusLogic Host Adapters.
89: */
90:
91: static BusLogic_ProbeOptions_T
92: BusLogic_ProbeOptions = { 0 };
93:
94:
95: /*
96: BusLogic_GlobalOptions is a set of Global Options to be applied across
97: all BusLogic Host Adapters.
98: */
99:
100: static BusLogic_GlobalOptions_T
101: BusLogic_GlobalOptions = { 0 };
102:
103:
104: /*
105: BusLogic_FirstRegisteredHostAdapter and BusLogic_LastRegisteredHostAdapter
106: are pointers to the first and last registered BusLogic Host Adapters.
107: */
108:
109: static BusLogic_HostAdapter_T
110: *BusLogic_FirstRegisteredHostAdapter = NULL,
111: *BusLogic_LastRegisteredHostAdapter = NULL;
112:
113:
114: /*
115: BusLogic_ProbeInfoCount is the number of entries in BusLogic_ProbeInfoList.
116: */
117:
118: static int
119: BusLogic_ProbeInfoCount = 0;
120:
121:
122: /*
123: BusLogic_ProbeInfoList is the list of I/O Addresses and Bus Probe Information
124: to be checked for potential BusLogic Host Adapters. It is initialized by
125: interrogating the PCI Configuration Space on PCI machines as well as from the
126: list of standard BusLogic I/O Addresses.
127: */
128:
129: static BusLogic_ProbeInfo_T
130: *BusLogic_ProbeInfoList = NULL;
131:
132:
133: /*
134: BusLogic_CommandFailureReason holds a string identifying the reason why a
135: call to BusLogic_Command failed. It is only non-NULL when BusLogic_Command
136: returns a failure code.
137: */
138:
139: static char
140: *BusLogic_CommandFailureReason;
141:
142:
143: /*
144: BusLogic_ProcDirectoryEntry is the BusLogic /proc/scsi directory entry.
145: */
146:
147: PROC_DirectoryEntry_T
148: BusLogic_ProcDirectoryEntry =
149: { PROC_SCSI_BUSLOGIC, 8, "BusLogic", S_IFDIR | S_IRUGO | S_IXUGO, 2 };
150:
151:
152: /*
153: BusLogic_AnnounceDriver announces the Driver Version and Date, Author's
154: Name, Copyright Notice, and Electronic Mail Address.
155: */
156:
157: static void BusLogic_AnnounceDriver(BusLogic_HostAdapter_T *HostAdapter)
158: {
159: BusLogic_Announce("***** BusLogic SCSI Driver Version "
160: BusLogic_DriverVersion " of "
161: BusLogic_DriverDate " *****\n", HostAdapter);
162: BusLogic_Announce("Copyright 1995-1998 by Leonard N. Zubkoff "
163: "<[email protected]>\n", HostAdapter);
164: }
165:
166:
167: /*
168: BusLogic_DriverInfo returns the Host Adapter Name to identify this SCSI
169: Driver and Host Adapter.
170: */
171:
172: const char *BusLogic_DriverInfo(SCSI_Host_T *Host)
173: {
174: BusLogic_HostAdapter_T *HostAdapter =
175: (BusLogic_HostAdapter_T *) Host->hostdata;
176: return HostAdapter->FullModelName;
177: }
178:
179:
180: /*
181: BusLogic_RegisterHostAdapter adds Host Adapter to the list of registered
182: BusLogic Host Adapters.
183: */
184:
185: static void BusLogic_RegisterHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
186: {
187: HostAdapter->Next = NULL;
188: if (BusLogic_FirstRegisteredHostAdapter == NULL)
189: {
190: BusLogic_FirstRegisteredHostAdapter = HostAdapter;
191: BusLogic_LastRegisteredHostAdapter = HostAdapter;
192: }
193: else
194: {
195: BusLogic_LastRegisteredHostAdapter->Next = HostAdapter;
196: BusLogic_LastRegisteredHostAdapter = HostAdapter;
197: }
198: }
199:
200:
201: /*
202: BusLogic_UnregisterHostAdapter removes Host Adapter from the list of
203: registered BusLogic Host Adapters.
204: */
205:
206: static void BusLogic_UnregisterHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
207: {
208: if (HostAdapter == BusLogic_FirstRegisteredHostAdapter)
209: {
210: BusLogic_FirstRegisteredHostAdapter =
211: BusLogic_FirstRegisteredHostAdapter->Next;
212: if (HostAdapter == BusLogic_LastRegisteredHostAdapter)
213: BusLogic_LastRegisteredHostAdapter = NULL;
214: }
215: else
216: {
217: BusLogic_HostAdapter_T *PreviousHostAdapter =
218: BusLogic_FirstRegisteredHostAdapter;
219: while (PreviousHostAdapter != NULL &&
220: PreviousHostAdapter->Next != HostAdapter)
221: PreviousHostAdapter = PreviousHostAdapter->Next;
222: if (PreviousHostAdapter != NULL)
223: PreviousHostAdapter->Next = HostAdapter->Next;
224: }
225: HostAdapter->Next = NULL;
226: }
227:
228:
229: /*
230: BusLogic_InitializeCCBs initializes a group of Command Control Blocks (CCBs)
231: for Host Adapter from the BlockSize bytes located at BlockPointer. The newly
232: created CCBs are added to Host Adapter's free list.
233: */
234:
235: static void BusLogic_InitializeCCBs(BusLogic_HostAdapter_T *HostAdapter,
236: void *BlockPointer, int BlockSize)
237: {
238: BusLogic_CCB_T *CCB = (BusLogic_CCB_T *) BlockPointer;
239: memset(BlockPointer, 0, BlockSize);
240: CCB->AllocationGroupHead = true;
241: while ((BlockSize -= sizeof(BusLogic_CCB_T)) >= 0)
242: {
243: CCB->Status = BusLogic_CCB_Free;
244: CCB->HostAdapter = HostAdapter;
245: if (BusLogic_FlashPointHostAdapterP(HostAdapter))
246: {
247: CCB->CallbackFunction = BusLogic_QueueCompletedCCB;
248: CCB->BaseAddress = HostAdapter->FlashPointInfo.BaseAddress;
249: }
250: CCB->Next = HostAdapter->Free_CCBs;
251: CCB->NextAll = HostAdapter->All_CCBs;
252: HostAdapter->Free_CCBs = CCB;
253: HostAdapter->All_CCBs = CCB;
254: HostAdapter->AllocatedCCBs++;
255: CCB++;
256: }
257: }
258:
259:
260: /*
261: BusLogic_CreateInitialCCBs allocates the initial CCBs for Host Adapter.
262: */
263:
264: static boolean BusLogic_CreateInitialCCBs(BusLogic_HostAdapter_T *HostAdapter)
265: {
266: int BlockSize = BusLogic_CCB_AllocationGroupSize * sizeof(BusLogic_CCB_T);
267: while (HostAdapter->AllocatedCCBs < HostAdapter->InitialCCBs)
268: {
269: void *BlockPointer = kmalloc(BlockSize,
270: (HostAdapter->BounceBuffersRequired
271: ? GFP_ATOMIC | GFP_DMA
272: : GFP_ATOMIC));
273: if (BlockPointer == NULL)
274: {
275: BusLogic_Error("UNABLE TO ALLOCATE CCB GROUP - DETACHING\n",
276: HostAdapter);
277: return false;
278: }
279: BusLogic_InitializeCCBs(HostAdapter, BlockPointer, BlockSize);
280: }
281: return true;
282: }
283:
284:
285: /*
286: BusLogic_DestroyCCBs deallocates the CCBs for Host Adapter.
287: */
288:
289: static void BusLogic_DestroyCCBs(BusLogic_HostAdapter_T *HostAdapter)
290: {
291: BusLogic_CCB_T *NextCCB = HostAdapter->All_CCBs, *CCB;
292: HostAdapter->All_CCBs = NULL;
293: HostAdapter->Free_CCBs = NULL;
294: while ((CCB = NextCCB) != NULL)
295: {
296: NextCCB = CCB->NextAll;
297: if (CCB->AllocationGroupHead)
298: kfree(CCB);
299: }
300: }
301:
302:
303: /*
304: BusLogic_CreateAdditionalCCBs allocates Additional CCBs for Host Adapter. If
305: allocation fails and there are no remaining CCBs available, the Driver Queue
306: Depth is decreased to a known safe value to avoid potential deadlocks when
307: multiple host adapters share the same IRQ Channel.
308: */
309:
310: static void BusLogic_CreateAdditionalCCBs(BusLogic_HostAdapter_T *HostAdapter,
311: int AdditionalCCBs,
312: boolean SuccessMessageP)
313: {
314: int BlockSize = BusLogic_CCB_AllocationGroupSize * sizeof(BusLogic_CCB_T);
315: int PreviouslyAllocated = HostAdapter->AllocatedCCBs;
316: if (AdditionalCCBs <= 0) return;
317: while (HostAdapter->AllocatedCCBs - PreviouslyAllocated < AdditionalCCBs)
318: {
319: void *BlockPointer = kmalloc(BlockSize,
320: (HostAdapter->BounceBuffersRequired
321: ? GFP_ATOMIC | GFP_DMA
322: : GFP_ATOMIC));
323: if (BlockPointer == NULL) break;
324: BusLogic_InitializeCCBs(HostAdapter, BlockPointer, BlockSize);
325: }
326: if (HostAdapter->AllocatedCCBs > PreviouslyAllocated)
327: {
328: if (SuccessMessageP)
329: BusLogic_Notice("Allocated %d additional CCBs (total now %d)\n",
330: HostAdapter,
331: HostAdapter->AllocatedCCBs - PreviouslyAllocated,
332: HostAdapter->AllocatedCCBs);
333: return;
334: }
335: BusLogic_Notice("Failed to allocate additional CCBs\n", HostAdapter);
336: if (HostAdapter->DriverQueueDepth >
337: HostAdapter->AllocatedCCBs - HostAdapter->TargetDeviceCount)
338: {
339: HostAdapter->DriverQueueDepth =
340: HostAdapter->AllocatedCCBs - HostAdapter->TargetDeviceCount;
341: HostAdapter->SCSI_Host->can_queue = HostAdapter->DriverQueueDepth;
342: }
343: }
344:
345:
346: /*
347: BusLogic_AllocateCCB allocates a CCB from Host Adapter's free list,
348: allocating more memory from the Kernel if necessary. The Host Adapter's
349: Lock should already have been acquired by the caller.
350: */
351:
352: static BusLogic_CCB_T *BusLogic_AllocateCCB(BusLogic_HostAdapter_T
353: *HostAdapter)
354: {
355: static unsigned long SerialNumber = 0;
356: BusLogic_CCB_T *CCB;
357: CCB = HostAdapter->Free_CCBs;
358: if (CCB != NULL)
359: {
360: CCB->SerialNumber = ++SerialNumber;
361: HostAdapter->Free_CCBs = CCB->Next;
362: CCB->Next = NULL;
363: if (HostAdapter->Free_CCBs == NULL)
364: BusLogic_CreateAdditionalCCBs(HostAdapter,
365: HostAdapter->IncrementalCCBs,
366: true);
367: return CCB;
368: }
369: BusLogic_CreateAdditionalCCBs(HostAdapter,
370: HostAdapter->IncrementalCCBs,
371: true);
372: CCB = HostAdapter->Free_CCBs;
373: if (CCB == NULL) return NULL;
374: CCB->SerialNumber = ++SerialNumber;
375: HostAdapter->Free_CCBs = CCB->Next;
376: CCB->Next = NULL;
377: return CCB;
378: }
379:
380:
381: /*
382: BusLogic_DeallocateCCB deallocates a CCB, returning it to the Host Adapter's
383: free list. The Host Adapter's Lock should already have been acquired by the
384: caller.
385: */
386:
387: static void BusLogic_DeallocateCCB(BusLogic_CCB_T *CCB)
388: {
389: BusLogic_HostAdapter_T *HostAdapter = CCB->HostAdapter;
390: CCB->Command = NULL;
391: CCB->Status = BusLogic_CCB_Free;
392: CCB->Next = HostAdapter->Free_CCBs;
393: HostAdapter->Free_CCBs = CCB;
394: }
395:
396:
397: /*
398: BusLogic_Command sends the command OperationCode to HostAdapter, optionally
399: providing ParameterLength bytes of ParameterData and receiving at most
400: ReplyLength bytes of ReplyData; any excess reply data is received but
401: discarded.
402:
403: On success, this function returns the number of reply bytes read from
404: the Host Adapter (including any discarded data); on failure, it returns
405: -1 if the command was invalid, or -2 if a timeout occurred.
406:
407: BusLogic_Command is called exclusively during host adapter detection and
408: initialization, so performance and latency are not critical, and exclusive
409: access to the Host Adapter hardware is assumed. Once the host adapter and
410: driver are initialized, the only Host Adapter command that is issued is the
411: single byte Execute Mailbox Command operation code, which does not require
412: waiting for the Host Adapter Ready bit to be set in the Status Register.
413: */
414:
415: static int BusLogic_Command(BusLogic_HostAdapter_T *HostAdapter,
416: BusLogic_OperationCode_T OperationCode,
417: void *ParameterData,
418: int ParameterLength,
419: void *ReplyData,
420: int ReplyLength)
421: {
422: unsigned char *ParameterPointer = (unsigned char *) ParameterData;
423: unsigned char *ReplyPointer = (unsigned char *) ReplyData;
424: BusLogic_StatusRegister_T StatusRegister;
425: BusLogic_InterruptRegister_T InterruptRegister;
426: ProcessorFlags_T ProcessorFlags = 0;
427: int ReplyBytes = 0, Result;
428: long TimeoutCounter;
429: /*
430: Clear out the Reply Data if provided.
431: */
432: if (ReplyLength > 0)
433: memset(ReplyData, 0, ReplyLength);
434: /*
435: If the IRQ Channel has not yet been acquired, then interrupts must be
436: disabled while issuing host adapter commands since a Command Complete
437: interrupt could occur if the IRQ Channel was previously enabled by another
438: BusLogic Host Adapter or another driver sharing the same IRQ Channel.
439: */
440: if (!HostAdapter->IRQ_ChannelAcquired)
441: {
442: save_flags(ProcessorFlags);
443: cli();
444: }
445: /*
446: Wait for the Host Adapter Ready bit to be set and the Command/Parameter
447: Register Busy bit to be reset in the Status Register.
448: */
449: TimeoutCounter = 10000;
450: while (--TimeoutCounter >= 0)
451: {
452: StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
453: if (StatusRegister.Bits.HostAdapterReady &&
454: !StatusRegister.Bits.CommandParameterRegisterBusy)
455: break;
456: udelay(100);
457: }
458: if (TimeoutCounter < 0)
459: {
460: BusLogic_CommandFailureReason = "Timeout waiting for Host Adapter Ready";
461: Result = -2;
462: goto Done;
463: }
464: /*
465: Write the OperationCode to the Command/Parameter Register.
466: */
467: HostAdapter->HostAdapterCommandCompleted = false;
468: BusLogic_WriteCommandParameterRegister(HostAdapter, OperationCode);
469: /*
470: Write any additional Parameter Bytes.
471: */
472: TimeoutCounter = 10000;
473: while (ParameterLength > 0 && --TimeoutCounter >= 0)
474: {
475: /*
476: Wait 100 microseconds to give the Host Adapter enough time to determine
477: whether the last value written to the Command/Parameter Register was
478: valid or not. If the Command Complete bit is set in the Interrupt
479: Register, then the Command Invalid bit in the Status Register will be
480: reset if the Operation Code or Parameter was valid and the command
481: has completed, or set if the Operation Code or Parameter was invalid.
482: If the Data In Register Ready bit is set in the Status Register, then
483: the Operation Code was valid, and data is waiting to be read back
484: from the Host Adapter. Otherwise, wait for the Command/Parameter
485: Register Busy bit in the Status Register to be reset.
486: */
487: udelay(100);
488: InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
489: StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
490: if (InterruptRegister.Bits.CommandComplete) break;
491: if (HostAdapter->HostAdapterCommandCompleted) break;
492: if (StatusRegister.Bits.DataInRegisterReady) break;
493: if (StatusRegister.Bits.CommandParameterRegisterBusy) continue;
494: BusLogic_WriteCommandParameterRegister(HostAdapter, *ParameterPointer++);
495: ParameterLength--;
496: }
497: if (TimeoutCounter < 0)
498: {
499: BusLogic_CommandFailureReason =
500: "Timeout waiting for Parameter Acceptance";
501: Result = -2;
502: goto Done;
503: }
504: /*
505: The Modify I/O Address command does not cause a Command Complete Interrupt.
506: */
507: if (OperationCode == BusLogic_ModifyIOAddress)
508: {
509: StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
510: if (StatusRegister.Bits.CommandInvalid)
511: {
512: BusLogic_CommandFailureReason = "Modify I/O Address Invalid";
513: Result = -1;
514: goto Done;
515: }
516: if (BusLogic_GlobalOptions.TraceConfiguration)
517: BusLogic_Notice("BusLogic_Command(%02X) Status = %02X: "
518: "(Modify I/O Address)\n", HostAdapter,
519: OperationCode, StatusRegister.All);
520: Result = 0;
521: goto Done;
522: }
523: /*
524: Select an appropriate timeout value for awaiting command completion.
525: */
526: switch (OperationCode)
527: {
528: case BusLogic_InquireInstalledDevicesID0to7:
529: case BusLogic_InquireInstalledDevicesID8to15:
530: case BusLogic_InquireTargetDevices:
531: /* Approximately 60 seconds. */
532: TimeoutCounter = 60*10000;
533: break;
534: default:
535: /* Approximately 1 second. */
536: TimeoutCounter = 10000;
537: break;
538: }
539: /*
540: Receive any Reply Bytes, waiting for either the Command Complete bit to
541: be set in the Interrupt Register, or for the Interrupt Handler to set the
542: Host Adapter Command Completed bit in the Host Adapter structure.
543: */
544: while (--TimeoutCounter >= 0)
545: {
546: InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
547: StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
548: if (InterruptRegister.Bits.CommandComplete) break;
549: if (HostAdapter->HostAdapterCommandCompleted) break;
550: if (StatusRegister.Bits.DataInRegisterReady)
551: {
552: if (++ReplyBytes <= ReplyLength)
553: *ReplyPointer++ = BusLogic_ReadDataInRegister(HostAdapter);
554: else BusLogic_ReadDataInRegister(HostAdapter);
555: }
556: if (OperationCode == BusLogic_FetchHostAdapterLocalRAM &&
557: StatusRegister.Bits.HostAdapterReady) break;
558: udelay(100);
559: }
560: if (TimeoutCounter < 0)
561: {
562: BusLogic_CommandFailureReason = "Timeout waiting for Command Complete";
563: Result = -2;
564: goto Done;
565: }
566: /*
567: Clear any pending Command Complete Interrupt.
568: */
569: BusLogic_InterruptReset(HostAdapter);
570: /*
571: Provide tracing information if requested.
572: */
573: if (BusLogic_GlobalOptions.TraceConfiguration)
574: {
575: int i;
576: BusLogic_Notice("BusLogic_Command(%02X) Status = %02X: %2d ==> %2d:",
577: HostAdapter, OperationCode,
578: StatusRegister.All, ReplyLength, ReplyBytes);
579: if (ReplyLength > ReplyBytes) ReplyLength = ReplyBytes;
580: for (i = 0; i < ReplyLength; i++)
581: BusLogic_Notice(" %02X", HostAdapter,
582: ((unsigned char *) ReplyData)[i]);
583: BusLogic_Notice("\n", HostAdapter);
584: }
585: /*
586: Process Command Invalid conditions.
587: */
588: if (StatusRegister.Bits.CommandInvalid)
589: {
590: /*
591: Some early BusLogic Host Adapters may not recover properly from
592: a Command Invalid condition, so if this appears to be the case,
593: a Soft Reset is issued to the Host Adapter. Potentially invalid
594: commands are never attempted after Mailbox Initialization is
595: performed, so there should be no Host Adapter state lost by a
596: Soft Reset in response to a Command Invalid condition.
597: */
598: udelay(1000);
599: StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
600: if (StatusRegister.Bits.CommandInvalid ||
601: StatusRegister.Bits.Reserved ||
602: StatusRegister.Bits.DataInRegisterReady ||
603: StatusRegister.Bits.CommandParameterRegisterBusy ||
604: !StatusRegister.Bits.HostAdapterReady ||
605: !StatusRegister.Bits.InitializationRequired ||
606: StatusRegister.Bits.DiagnosticActive ||
607: StatusRegister.Bits.DiagnosticFailure)
608: {
609: BusLogic_SoftReset(HostAdapter);
610: udelay(1000);
611: }
612: BusLogic_CommandFailureReason = "Command Invalid";
613: Result = -1;
614: goto Done;
615: }
616: /*
617: Handle Excess Parameters Supplied conditions.
618: */
619: if (ParameterLength > 0)
620: {
621: BusLogic_CommandFailureReason = "Excess Parameters Supplied";
622: Result = -1;
623: goto Done;
624: }
625: /*
626: Indicate the command completed successfully.
627: */
628: BusLogic_CommandFailureReason = NULL;
629: Result = ReplyBytes;
630: /*
631: Restore the interrupt status if necessary and return.
632: */
633: Done:
634: if (!HostAdapter->IRQ_ChannelAcquired)
635: restore_flags(ProcessorFlags);
636: return Result;
637: }
638:
639:
640: /*
641: BusLogic_AppendProbeAddressISA appends a single ISA I/O Address to the list
642: of I/O Address and Bus Probe Information to be checked for potential BusLogic
643: Host Adapters.
644: */
645:
646: static void BusLogic_AppendProbeAddressISA(BusLogic_IO_Address_T IO_Address)
647: {
648: BusLogic_ProbeInfo_T *ProbeInfo;
649: if (BusLogic_ProbeInfoCount >= BusLogic_MaxHostAdapters) return;
650: ProbeInfo = &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++];
651: ProbeInfo->HostAdapterType = BusLogic_MultiMaster;
652: ProbeInfo->HostAdapterBusType = BusLogic_ISA_Bus;
653: ProbeInfo->IO_Address = IO_Address;
654: }
655:
656:
657: /*
658: BusLogic_InitializeProbeInfoListISA initializes the list of I/O Address and
659: Bus Probe Information to be checked for potential BusLogic SCSI Host Adapters
660: only from the list of standard BusLogic MultiMaster ISA I/O Addresses.
661: */
662:
663: static void BusLogic_InitializeProbeInfoListISA(BusLogic_HostAdapter_T
664: *PrototypeHostAdapter)
665: {
666: /*
667: If BusLogic Driver Options specifications requested that ISA Bus Probes
668: be inhibited, do not proceed further.
669: */
670: if (BusLogic_ProbeOptions.NoProbeISA) return;
671: /*
672: Append the list of standard BusLogic MultiMaster ISA I/O Addresses.
673: */
674: if (BusLogic_ProbeOptions.LimitedProbeISA
675: ? BusLogic_ProbeOptions.Probe330
676: : check_region(0x330, BusLogic_MultiMasterAddressCount) == 0)
677: BusLogic_AppendProbeAddressISA(0x330);
678: if (BusLogic_ProbeOptions.LimitedProbeISA
679: ? BusLogic_ProbeOptions.Probe334
680: : check_region(0x334, BusLogic_MultiMasterAddressCount) == 0)
681: BusLogic_AppendProbeAddressISA(0x334);
682: if (BusLogic_ProbeOptions.LimitedProbeISA
683: ? BusLogic_ProbeOptions.Probe230
684: : check_region(0x230, BusLogic_MultiMasterAddressCount) == 0)
685: BusLogic_AppendProbeAddressISA(0x230);
686: if (BusLogic_ProbeOptions.LimitedProbeISA
687: ? BusLogic_ProbeOptions.Probe234
688: : check_region(0x234, BusLogic_MultiMasterAddressCount) == 0)
689: BusLogic_AppendProbeAddressISA(0x234);
690: if (BusLogic_ProbeOptions.LimitedProbeISA
691: ? BusLogic_ProbeOptions.Probe130
692: : check_region(0x130, BusLogic_MultiMasterAddressCount) == 0)
693: BusLogic_AppendProbeAddressISA(0x130);
694: if (BusLogic_ProbeOptions.LimitedProbeISA
695: ? BusLogic_ProbeOptions.Probe134
696: : check_region(0x134, BusLogic_MultiMasterAddressCount) == 0)
697: BusLogic_AppendProbeAddressISA(0x134);
698: }
699:
700:
701: #ifdef CONFIG_PCI
702:
703:
704: /*
705: BusLogic_SortProbeInfo sorts a section of BusLogic_ProbeInfoList in order
706: of increasing PCI Bus and Device Number.
707: */
708:
709: static void BusLogic_SortProbeInfo(BusLogic_ProbeInfo_T *ProbeInfoList,
710: int ProbeInfoCount)
711: {
712: int LastInterchange = ProbeInfoCount-1, Bound, j;
713: while (LastInterchange > 0)
714: {
715: Bound = LastInterchange;
716: LastInterchange = 0;
717: for (j = 0; j < Bound; j++)
718: {
719: BusLogic_ProbeInfo_T *ProbeInfo1 = &ProbeInfoList[j];
720: BusLogic_ProbeInfo_T *ProbeInfo2 = &ProbeInfoList[j+1];
721: if (ProbeInfo1->Bus > ProbeInfo2->Bus ||
722: (ProbeInfo1->Bus == ProbeInfo2->Bus &&
723: (ProbeInfo1->Device > ProbeInfo2->Device)))
724: {
725: BusLogic_ProbeInfo_T TempProbeInfo;
726: memcpy(&TempProbeInfo, ProbeInfo1, sizeof(BusLogic_ProbeInfo_T));
727: memcpy(ProbeInfo1, ProbeInfo2, sizeof(BusLogic_ProbeInfo_T));
728: memcpy(ProbeInfo2, &TempProbeInfo, sizeof(BusLogic_ProbeInfo_T));
729: LastInterchange = j;
730: }
731: }
732: }
733: }
734:
735:
736: /*
737: BusLogic_InitializeMultiMasterProbeInfo initializes the list of I/O Address
738: and Bus Probe Information to be checked for potential BusLogic MultiMaster
739: SCSI Host Adapters by interrogating the PCI Configuration Space on PCI
740: machines as well as from the list of standard BusLogic MultiMaster ISA
741: I/O Addresses. It returns the number of PCI MultiMaster Host Adapters found.
742: */
743:
744: static int BusLogic_InitializeMultiMasterProbeInfo(BusLogic_HostAdapter_T
745: *PrototypeHostAdapter)
746: {
747: BusLogic_ProbeInfo_T *PrimaryProbeInfo =
748: &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount];
749: int NonPrimaryPCIMultiMasterIndex = BusLogic_ProbeInfoCount + 1;
750: int NonPrimaryPCIMultiMasterCount = 0, PCIMultiMasterCount = 0;
751: boolean ForceBusDeviceScanningOrder = false;
752: boolean ForceBusDeviceScanningOrderChecked = false;
753: boolean StandardAddressSeen[6];
754: unsigned char Bus, DeviceFunction;
755: unsigned int BaseAddress0, BaseAddress1;
756: unsigned char IRQ_Channel;
757: BusLogic_IO_Address_T IO_Address;
758: BusLogic_PCI_Address_T PCI_Address;
759: unsigned short Index = 0;
760: int i;
761: if (BusLogic_ProbeInfoCount >= BusLogic_MaxHostAdapters) return 0;
762: BusLogic_ProbeInfoCount++;
763: for (i = 0; i < 6; i++)
764: StandardAddressSeen[i] = false;
765: /*
766: Iterate over the MultiMaster PCI Host Adapters. For each enumerated host
767: adapter, determine whether its ISA Compatible I/O Port is enabled and if
768: so, whether it is assigned the Primary I/O Address. A host adapter that is
769: assigned the Primary I/O Address will always be the preferred boot device.
770: The MultiMaster BIOS will first recognize a host adapter at the Primary I/O
771: Address, then any other PCI host adapters, and finally any host adapters
772: located at the remaining standard ISA I/O Addresses. When a PCI host
773: adapter is found with its ISA Compatible I/O Port enabled, a command is
774: issued to disable the ISA Compatible I/O Port, and it is noted that the
775: particular standard ISA I/O Address need not be probed.
776: */
777: PrimaryProbeInfo->IO_Address = 0;
778: while (pcibios_find_device(PCI_VENDOR_ID_BUSLOGIC,
779: PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER,
780: Index++, &Bus, &DeviceFunction) == 0)
781: if (pcibios_read_config_dword(Bus, DeviceFunction,
782: PCI_BASE_ADDRESS_0, &BaseAddress0) == 0 &&
783: pcibios_read_config_dword(Bus, DeviceFunction,
784: PCI_BASE_ADDRESS_1, &BaseAddress1) == 0 &&
785: pcibios_read_config_byte(Bus, DeviceFunction,
786: PCI_INTERRUPT_LINE, &IRQ_Channel) == 0)
787: {
788: BusLogic_HostAdapter_T *HostAdapter = PrototypeHostAdapter;
789: BusLogic_PCIHostAdapterInformation_T PCIHostAdapterInformation;
790: BusLogic_ModifyIOAddressRequest_T ModifyIOAddressRequest;
791: unsigned char Device = DeviceFunction >> 3;
792: IO_Address = BaseAddress0 & PCI_BASE_ADDRESS_IO_MASK;
793: PCI_Address = BaseAddress1 & PCI_BASE_ADDRESS_MEM_MASK;
794: if ((BaseAddress0 & PCI_BASE_ADDRESS_SPACE)
795: != PCI_BASE_ADDRESS_SPACE_IO)
796: {
797: BusLogic_Error("BusLogic: Base Address0 0x%X not I/O for "
798: "MultiMaster Host Adapter\n", NULL, BaseAddress0);
799: BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n",
800: NULL, Bus, Device, IO_Address);
801: continue;
802: }
803: if ((BaseAddress1 & PCI_BASE_ADDRESS_SPACE)
804: != PCI_BASE_ADDRESS_SPACE_MEMORY)
805: {
806: BusLogic_Error("BusLogic: Base Address1 0x%X not Memory for "
807: "MultiMaster Host Adapter\n", NULL, BaseAddress1);
808: BusLogic_Error("at PCI Bus %d Device %d PCI Address 0x%X\n",
809: NULL, Bus, Device, PCI_Address);
810: continue;
811: }
812: if (IRQ_Channel == 0 || IRQ_Channel >= NR_IRQS)
813: {
814: BusLogic_Error("BusLogic: IRQ Channel %d illegal for "
815: "MultiMaster Host Adapter\n", NULL, IRQ_Channel);
816: BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n",
817: NULL, Bus, Device, IO_Address);
818: continue;
819: }
820: if (BusLogic_GlobalOptions.TraceProbe)
821: {
822: BusLogic_Notice("BusLogic: PCI MultiMaster Host Adapter "
823: "detected at\n", NULL);
824: BusLogic_Notice("BusLogic: PCI Bus %d Device %d I/O Address "
825: "0x%X PCI Address 0x%X\n", NULL,
826: Bus, Device, IO_Address, PCI_Address);
827: }
828: /*
829: Issue the Inquire PCI Host Adapter Information command to determine
830: the ISA Compatible I/O Port. If the ISA Compatible I/O Port is
831: known and enabled, note that the particular Standard ISA I/O
832: Address should not be probed.
833: */
834: HostAdapter->IO_Address = IO_Address;
835: BusLogic_InterruptReset(HostAdapter);
836: if (BusLogic_Command(HostAdapter,
837: BusLogic_InquirePCIHostAdapterInformation,
838: NULL, 0, &PCIHostAdapterInformation,
839: sizeof(PCIHostAdapterInformation))
840: == sizeof(PCIHostAdapterInformation))
841: {
842: if (PCIHostAdapterInformation.ISACompatibleIOPort < 6)
843: StandardAddressSeen[PCIHostAdapterInformation
844: .ISACompatibleIOPort] = true;
845: }
846: else PCIHostAdapterInformation.ISACompatibleIOPort =
847: BusLogic_IO_Disable;
848: /*
849: Issue the Modify I/O Address command to disable the ISA Compatible
850: I/O Port.
851: */
852: ModifyIOAddressRequest = BusLogic_IO_Disable;
853: BusLogic_Command(HostAdapter, BusLogic_ModifyIOAddress,
854: &ModifyIOAddressRequest,
855: sizeof(ModifyIOAddressRequest), NULL, 0);
856: /*
857: For the first MultiMaster Host Adapter enumerated, issue the Fetch
858: Host Adapter Local RAM command to read byte 45 of the AutoSCSI area,
859: for the setting of the "Use Bus And Device # For PCI Scanning Seq."
860: option. Issue the Inquire Board ID command since this option is
861: only valid for the BT-948/958/958D.
862: */
863: if (!ForceBusDeviceScanningOrderChecked)
864: {
865: BusLogic_FetchHostAdapterLocalRAMRequest_T
866: FetchHostAdapterLocalRAMRequest;
867: BusLogic_AutoSCSIByte45_T AutoSCSIByte45;
868: BusLogic_BoardID_T BoardID;
869: FetchHostAdapterLocalRAMRequest.ByteOffset =
870: BusLogic_AutoSCSI_BaseOffset + 45;
871: FetchHostAdapterLocalRAMRequest.ByteCount =
872: sizeof(AutoSCSIByte45);
873: BusLogic_Command(HostAdapter,
874: BusLogic_FetchHostAdapterLocalRAM,
875: &FetchHostAdapterLocalRAMRequest,
876: sizeof(FetchHostAdapterLocalRAMRequest),
877: &AutoSCSIByte45, sizeof(AutoSCSIByte45));
878: BusLogic_Command(HostAdapter, BusLogic_InquireBoardID,
879: NULL, 0, &BoardID, sizeof(BoardID));
880: if (BoardID.FirmwareVersion1stDigit == '5')
881: ForceBusDeviceScanningOrder =
882: AutoSCSIByte45.ForceBusDeviceScanningOrder;
883: ForceBusDeviceScanningOrderChecked = true;
884: }
885: /*
886: Determine whether this MultiMaster Host Adapter has its ISA
887: Compatible I/O Port enabled and is assigned the Primary I/O Address.
888: If it does, then it is the Primary MultiMaster Host Adapter and must
889: be recognized first. If it does not, then it is added to the list
890: for probing after any Primary MultiMaster Host Adapter is probed.
891: */
892: if (PCIHostAdapterInformation.ISACompatibleIOPort == BusLogic_IO_330)
893: {
894: PrimaryProbeInfo->HostAdapterType = BusLogic_MultiMaster;
895: PrimaryProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
896: PrimaryProbeInfo->IO_Address = IO_Address;
897: PrimaryProbeInfo->PCI_Address = PCI_Address;
898: PrimaryProbeInfo->Bus = Bus;
899: PrimaryProbeInfo->Device = Device;
900: PrimaryProbeInfo->IRQ_Channel = IRQ_Channel;
901: PCIMultiMasterCount++;
902: }
903: else if (BusLogic_ProbeInfoCount < BusLogic_MaxHostAdapters)
904: {
905: BusLogic_ProbeInfo_T *ProbeInfo =
906: &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++];
907: ProbeInfo->HostAdapterType = BusLogic_MultiMaster;
908: ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
909: ProbeInfo->IO_Address = IO_Address;
910: ProbeInfo->PCI_Address = PCI_Address;
911: ProbeInfo->Bus = Bus;
912: ProbeInfo->Device = Device;
913: ProbeInfo->IRQ_Channel = IRQ_Channel;
914: NonPrimaryPCIMultiMasterCount++;
915: PCIMultiMasterCount++;
916: }
917: else BusLogic_Warning("BusLogic: Too many Host Adapters "
918: "detected\n", NULL);
919: }
920: /*
921: If the AutoSCSI "Use Bus And Device # For PCI Scanning Seq." option is ON
922: for the first enumerated MultiMaster Host Adapter, and if that host adapter
923: is a BT-948/958/958D, then the MultiMaster BIOS will recognize MultiMaster
924: Host Adapters in the order of increasing PCI Bus and Device Number. In
925: that case, sort the probe information into the same order the BIOS uses.
926: If this option is OFF, then the MultiMaster BIOS will recognize MultiMaster
927: Host Adapters in the order they are enumerated by the PCI BIOS, and hence
928: no sorting is necessary.
929: */
930: if (ForceBusDeviceScanningOrder)
931: BusLogic_SortProbeInfo(&BusLogic_ProbeInfoList[
932: NonPrimaryPCIMultiMasterIndex],
933: NonPrimaryPCIMultiMasterCount);
934: /*
935: If no PCI MultiMaster Host Adapter is assigned the Primary I/O Address,
936: then the Primary I/O Address must be probed explicitly before any PCI
937: host adapters are probed.
938: */
939: if (!BusLogic_ProbeOptions.NoProbeISA)
940: if (PrimaryProbeInfo->IO_Address == 0 &&
941: (BusLogic_ProbeOptions.LimitedProbeISA
942: ? BusLogic_ProbeOptions.Probe330
943: : check_region(0x330, BusLogic_MultiMasterAddressCount) == 0))
944: {
945: PrimaryProbeInfo->HostAdapterType = BusLogic_MultiMaster;
946: PrimaryProbeInfo->HostAdapterBusType = BusLogic_ISA_Bus;
947: PrimaryProbeInfo->IO_Address = 0x330;
948: }
949: /*
950: Append the list of standard BusLogic MultiMaster ISA I/O Addresses,
951: omitting the Primary I/O Address which has already been handled.
952: */
953: if (!BusLogic_ProbeOptions.NoProbeISA)
954: {
955: if (!StandardAddressSeen[1] &&
956: (BusLogic_ProbeOptions.LimitedProbeISA
957: ? BusLogic_ProbeOptions.Probe334
958: : check_region(0x334, BusLogic_MultiMasterAddressCount) == 0))
959: BusLogic_AppendProbeAddressISA(0x334);
960: if (!StandardAddressSeen[2] &&
961: (BusLogic_ProbeOptions.LimitedProbeISA
962: ? BusLogic_ProbeOptions.Probe230
963: : check_region(0x230, BusLogic_MultiMasterAddressCount) == 0))
964: BusLogic_AppendProbeAddressISA(0x230);
965: if (!StandardAddressSeen[3] &&
966: (BusLogic_ProbeOptions.LimitedProbeISA
967: ? BusLogic_ProbeOptions.Probe234
968: : check_region(0x234, BusLogic_MultiMasterAddressCount) == 0))
969: BusLogic_AppendProbeAddressISA(0x234);
970: if (!StandardAddressSeen[4] &&
971: (BusLogic_ProbeOptions.LimitedProbeISA
972: ? BusLogic_ProbeOptions.Probe130
973: : check_region(0x130, BusLogic_MultiMasterAddressCount) == 0))
974: BusLogic_AppendProbeAddressISA(0x130);
975: if (!StandardAddressSeen[5] &&
976: (BusLogic_ProbeOptions.LimitedProbeISA
977: ? BusLogic_ProbeOptions.Probe134
978: : check_region(0x134, BusLogic_MultiMasterAddressCount) == 0))
979: BusLogic_AppendProbeAddressISA(0x134);
980: }
981: /*
982: Iterate over the older non-compliant MultiMaster PCI Host Adapters,
983: noting the PCI bus location and assigned IRQ Channel.
984: */
985: Index = 0;
986: while (pcibios_find_device(PCI_VENDOR_ID_BUSLOGIC,
987: PCI_DEVICE_ID_BUSLOGIC_MULTIMASTER_NC,
988: Index++, &Bus, &DeviceFunction) == 0)
989: if (pcibios_read_config_dword(Bus, DeviceFunction,
990: PCI_BASE_ADDRESS_0, &BaseAddress0) == 0 &&
991: pcibios_read_config_byte(Bus, DeviceFunction,
992: PCI_INTERRUPT_LINE, &IRQ_Channel) == 0)
993: {
994: unsigned char Device = DeviceFunction >> 3;
995: IO_Address = BaseAddress0 & PCI_BASE_ADDRESS_IO_MASK;
996: if (IO_Address == 0 || IRQ_Channel == 0 || IRQ_Channel >= NR_IRQS)
997: continue;
998: for (i = 0; i < BusLogic_ProbeInfoCount; i++)
999: {
1000: BusLogic_ProbeInfo_T *ProbeInfo = &BusLogic_ProbeInfoList[i];
1001: if (ProbeInfo->IO_Address == IO_Address &&
1002: ProbeInfo->HostAdapterType == BusLogic_MultiMaster)
1003: {
1004: ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
1005: ProbeInfo->PCI_Address = 0;
1006: ProbeInfo->Bus = Bus;
1007: ProbeInfo->Device = Device;
1008: ProbeInfo->IRQ_Channel = IRQ_Channel;
1009: break;
1010: }
1011: }
1012: }
1013: return PCIMultiMasterCount;
1014: }
1015:
1016:
1017: /*
1018: BusLogic_InitializeFlashPointProbeInfo initializes the list of I/O Address
1019: and Bus Probe Information to be checked for potential BusLogic FlashPoint
1020: Host Adapters by interrogating the PCI Configuration Space. It returns the
1021: number of FlashPoint Host Adapters found.
1022: */
1023:
1024: static int BusLogic_InitializeFlashPointProbeInfo(BusLogic_HostAdapter_T
1025: *PrototypeHostAdapter)
1026: {
1027: int FlashPointIndex = BusLogic_ProbeInfoCount, FlashPointCount = 0;
1028: unsigned char Bus, DeviceFunction;
1029: unsigned int BaseAddress0, BaseAddress1;
1030: unsigned char IRQ_Channel;
1031: BusLogic_IO_Address_T IO_Address;
1032: BusLogic_PCI_Address_T PCI_Address;
1033: unsigned short Index = 0;
1034: /*
1035: Interrogate PCI Configuration Space for any FlashPoint Host Adapters.
1036: */
1037: while (pcibios_find_device(PCI_VENDOR_ID_BUSLOGIC,
1038: PCI_DEVICE_ID_BUSLOGIC_FLASHPOINT,
1039: Index++, &Bus, &DeviceFunction) == 0)
1040: if (pcibios_read_config_dword(Bus, DeviceFunction,
1041: PCI_BASE_ADDRESS_0, &BaseAddress0) == 0 &&
1042: pcibios_read_config_dword(Bus, DeviceFunction,
1043: PCI_BASE_ADDRESS_1, &BaseAddress1) == 0 &&
1044: pcibios_read_config_byte(Bus, DeviceFunction,
1045: PCI_INTERRUPT_LINE, &IRQ_Channel) == 0)
1046: {
1047: unsigned char Device = DeviceFunction >> 3;
1048: IO_Address = BaseAddress0 & PCI_BASE_ADDRESS_IO_MASK;
1049: PCI_Address = BaseAddress1 & PCI_BASE_ADDRESS_MEM_MASK;
1050: #ifndef CONFIG_SCSI_OMIT_FLASHPOINT
1051: if ((BaseAddress0 & PCI_BASE_ADDRESS_SPACE)
1052: != PCI_BASE_ADDRESS_SPACE_IO)
1053: {
1054: BusLogic_Error("BusLogic: Base Address0 0x%X not I/O for "
1055: "FlashPoint Host Adapter\n", NULL, BaseAddress0);
1056: BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n",
1057: NULL, Bus, Device, IO_Address);
1058: continue;
1059: }
1060: if ((BaseAddress1 & PCI_BASE_ADDRESS_SPACE)
1061: != PCI_BASE_ADDRESS_SPACE_MEMORY)
1062: {
1063: BusLogic_Error("BusLogic: Base Address1 0x%X not Memory for "
1064: "FlashPoint Host Adapter\n", NULL, BaseAddress1);
1065: BusLogic_Error("at PCI Bus %d Device %d PCI Address 0x%X\n",
1066: NULL, Bus, Device, PCI_Address);
1067: continue;
1068: }
1069: if (IRQ_Channel == 0 || IRQ_Channel >= NR_IRQS)
1070: {
1071: BusLogic_Error("BusLogic: IRQ Channel %d illegal for "
1072: "FlashPoint Host Adapter\n", NULL, IRQ_Channel);
1073: BusLogic_Error("at PCI Bus %d Device %d I/O Address 0x%X\n",
1074: NULL, Bus, Device, IO_Address);
1075: continue;
1076: }
1077: if (BusLogic_GlobalOptions.TraceProbe)
1078: {
1079: BusLogic_Notice("BusLogic: FlashPoint Host Adapter "
1080: "detected at\n", NULL);
1081: BusLogic_Notice("BusLogic: PCI Bus %d Device %d I/O Address "
1082: "0x%X PCI Address 0x%X\n", NULL,
1083: Bus, Device, IO_Address, PCI_Address);
1084: }
1085: if (BusLogic_ProbeInfoCount < BusLogic_MaxHostAdapters)
1086: {
1087: BusLogic_ProbeInfo_T *ProbeInfo =
1088: &BusLogic_ProbeInfoList[BusLogic_ProbeInfoCount++];
1089: ProbeInfo->HostAdapterType = BusLogic_FlashPoint;
1090: ProbeInfo->HostAdapterBusType = BusLogic_PCI_Bus;
1091: ProbeInfo->IO_Address = IO_Address;
1092: ProbeInfo->PCI_Address = PCI_Address;
1093: ProbeInfo->Bus = Bus;
1094: ProbeInfo->Device = Device;
1095: ProbeInfo->IRQ_Channel = IRQ_Channel;
1096: FlashPointCount++;
1097: }
1098: else BusLogic_Warning("BusLogic: Too many Host Adapters "
1099: "detected\n", NULL);
1100: #else
1101: BusLogic_Error("BusLogic: FlashPoint Host Adapter detected at "
1102: "PCI Bus %d Device %d\n", NULL, Bus, Device);
1103: BusLogic_Error("BusLogic: I/O Address 0x%X PCI Address 0x%X, "
1104: "but FlashPoint\n", NULL, IO_Address, PCI_Address);
1105: BusLogic_Error("BusLogic: support was omitted in this kernel "
1106: "configuration.\n", NULL);
1107: #endif
1108: }
1109: /*
1110: The FlashPoint BIOS will scan for FlashPoint Host Adapters in the order of
1111: increasing PCI Bus and Device Number, so sort the probe information into
1112: the same order the BIOS uses.
1113: */
1114: BusLogic_SortProbeInfo(&BusLogic_ProbeInfoList[FlashPointIndex],
1115: FlashPointCount);
1116: return FlashPointCount;
1117: }
1118:
1119:
1120: /*
1121: BusLogic_InitializeProbeInfoList initializes the list of I/O Address and Bus
1122: Probe Information to be checked for potential BusLogic SCSI Host Adapters by
1123: interrogating the PCI Configuration Space on PCI machines as well as from the
1124: list of standard BusLogic MultiMaster ISA I/O Addresses. By default, if both
1125: FlashPoint and PCI MultiMaster Host Adapters are present, this driver will
1126: probe for FlashPoint Host Adapters first unless the BIOS primary disk is
1127: controlled by the first PCI MultiMaster Host Adapter, in which case
1128: MultiMaster Host Adapters will be probed first. The BusLogic Driver Options
1129: specifications "MultiMasterFirst" and "FlashPointFirst" can be used to force
1130: a particular probe order.
1131: */
1132:
1133: static void BusLogic_InitializeProbeInfoList(BusLogic_HostAdapter_T
1134: *PrototypeHostAdapter)
1135: {
1136: /*
1137: If a PCI BIOS is present, interrogate it for MultiMaster and FlashPoint
1138: Host Adapters; otherwise, default to the standard ISA MultiMaster probe.
1139: */
1140: if (!BusLogic_ProbeOptions.NoProbePCI && pcibios_present())
1141: {
1142: if (BusLogic_ProbeOptions.MultiMasterFirst)
1143: {
1144: BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter);
1145: BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter);
1146: }
1147: else if (BusLogic_ProbeOptions.FlashPointFirst)
1148: {
1149: BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter);
1150: BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter);
1151: }
1152: else
1153: {
1154: int FlashPointCount =
1155: BusLogic_InitializeFlashPointProbeInfo(PrototypeHostAdapter);
1156: int PCIMultiMasterCount =
1157: BusLogic_InitializeMultiMasterProbeInfo(PrototypeHostAdapter);
1158: if (FlashPointCount > 0 && PCIMultiMasterCount > 0)
1159: {
1160: BusLogic_ProbeInfo_T *ProbeInfo =
1161: &BusLogic_ProbeInfoList[FlashPointCount];
1162: BusLogic_HostAdapter_T *HostAdapter = PrototypeHostAdapter;
1163: BusLogic_FetchHostAdapterLocalRAMRequest_T
1164: FetchHostAdapterLocalRAMRequest;
1165: BusLogic_BIOSDriveMapByte_T Drive0MapByte;
1166: while (ProbeInfo->HostAdapterBusType != BusLogic_PCI_Bus)
1167: ProbeInfo++;
1168: HostAdapter->IO_Address = ProbeInfo->IO_Address;
1169: FetchHostAdapterLocalRAMRequest.ByteOffset =
1170: BusLogic_BIOS_BaseOffset + BusLogic_BIOS_DriveMapOffset + 0;
1171: FetchHostAdapterLocalRAMRequest.ByteCount =
1172: sizeof(Drive0MapByte);
1173: BusLogic_Command(HostAdapter,
1174: BusLogic_FetchHostAdapterLocalRAM,
1175: &FetchHostAdapterLocalRAMRequest,
1176: sizeof(FetchHostAdapterLocalRAMRequest),
1177: &Drive0MapByte, sizeof(Drive0MapByte));
1178: /*
1179: If the Map Byte for BIOS Drive 0 indicates that BIOS Drive 0
1180: is controlled by this PCI MultiMaster Host Adapter, then
1181: reverse the probe order so that MultiMaster Host Adapters are
1182: probed before FlashPoint Host Adapters.
1183: */
1184: if (Drive0MapByte.DiskGeometry !=
1185: BusLogic_BIOS_Disk_Not_Installed)
1186: {
1187: BusLogic_ProbeInfo_T
1188: SavedProbeInfo[BusLogic_MaxHostAdapters];
1189: int MultiMasterCount =
1190: BusLogic_ProbeInfoCount - FlashPointCount;
1191: memcpy(SavedProbeInfo,
1192: BusLogic_ProbeInfoList,
1193: BusLogic_ProbeInfoCount
1194: * sizeof(BusLogic_ProbeInfo_T));
1195: memcpy(&BusLogic_ProbeInfoList[0],
1196: &SavedProbeInfo[FlashPointCount],
1197: MultiMasterCount * sizeof(BusLogic_ProbeInfo_T));
1198: memcpy(&BusLogic_ProbeInfoList[MultiMasterCount],
1199: &SavedProbeInfo[0],
1200: FlashPointCount * sizeof(BusLogic_ProbeInfo_T));
1201: }
1202: }
1203: }
1204: }
1205: else BusLogic_InitializeProbeInfoListISA(PrototypeHostAdapter);
1206: }
1207:
1208:
1209: #endif /* CONFIG_PCI */
1210:
1211:
1212: /*
1213: BusLogic_Failure prints a standardized error message, and then returns false.
1214: */
1215:
1216: static boolean BusLogic_Failure(BusLogic_HostAdapter_T *HostAdapter,
1217: char *ErrorMessage)
1218: {
1219: BusLogic_AnnounceDriver(HostAdapter);
1220: if (HostAdapter->HostAdapterBusType == BusLogic_PCI_Bus)
1221: {
1222: BusLogic_Error("While configuring BusLogic PCI Host Adapter at\n",
1223: HostAdapter);
1224: BusLogic_Error("Bus %d Device %d I/O Address 0x%X PCI Address 0x%X:\n",
1225: HostAdapter, HostAdapter->Bus, HostAdapter->Device,
1226: HostAdapter->IO_Address, HostAdapter->PCI_Address);
1227: }
1228: else BusLogic_Error("While configuring BusLogic Host Adapter at "
1229: "I/O Address 0x%X:\n", HostAdapter,
1230: HostAdapter->IO_Address);
1231: BusLogic_Error("%s FAILED - DETACHING\n", HostAdapter, ErrorMessage);
1232: if (BusLogic_CommandFailureReason != NULL)
1233: BusLogic_Error("ADDITIONAL FAILURE INFO - %s\n", HostAdapter,
1234: BusLogic_CommandFailureReason);
1235: return false;
1236: }
1237:
1238:
1239: /*
1240: BusLogic_ProbeHostAdapter probes for a BusLogic Host Adapter.
1241: */
1242:
1243: static boolean BusLogic_ProbeHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
1244: {
1245: BusLogic_StatusRegister_T StatusRegister;
1246: BusLogic_InterruptRegister_T InterruptRegister;
1247: BusLogic_GeometryRegister_T GeometryRegister;
1248: /*
1249: FlashPoint Host Adapters are Probed by the FlashPoint SCCB Manager.
1250: */
1251: if (BusLogic_FlashPointHostAdapterP(HostAdapter))
1252: {
1253: FlashPoint_Info_T *FlashPointInfo = &HostAdapter->FlashPointInfo;
1254: FlashPointInfo->BaseAddress =
1255: (BusLogic_Base_Address_T) HostAdapter->IO_Address;
1256: FlashPointInfo->IRQ_Channel = HostAdapter->IRQ_Channel;
1257: FlashPointInfo->Present = false;
1258: if (!(FlashPoint_ProbeHostAdapter(FlashPointInfo) == 0 &&
1259: FlashPointInfo->Present))
1260: {
1261: BusLogic_Error("BusLogic: FlashPoint Host Adapter detected at "
1262: "PCI Bus %d Device %d\n", HostAdapter,
1263: HostAdapter->Bus, HostAdapter->Device);
1264: BusLogic_Error("BusLogic: I/O Address 0x%X PCI Address 0x%X, "
1265: "but FlashPoint\n", HostAdapter,
1266: HostAdapter->IO_Address, HostAdapter->PCI_Address);
1267: BusLogic_Error("BusLogic: Probe Function failed to validate it.\n",
1268: HostAdapter);
1269: return false;
1270: }
1271: if (BusLogic_GlobalOptions.TraceProbe)
1272: BusLogic_Notice("BusLogic_Probe(0x%X): FlashPoint Found\n",
1273: HostAdapter, HostAdapter->IO_Address);
1274: /*
1275: Indicate the Host Adapter Probe completed successfully.
1276: */
1277: return true;
1278: }
1279: /*
1280: Read the Status, Interrupt, and Geometry Registers to test if there are I/O
1281: ports that respond, and to check the values to determine if they are from a
1282: BusLogic Host Adapter. A nonexistent I/O port will return 0xFF, in which
1283: case there is definitely no BusLogic Host Adapter at this base I/O Address.
1284: The test here is a subset of that used by the BusLogic Host Adapter BIOS.
1285: */
1286: StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
1287: InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
1288: GeometryRegister.All = BusLogic_ReadGeometryRegister(HostAdapter);
1289: if (BusLogic_GlobalOptions.TraceProbe)
1290: BusLogic_Notice("BusLogic_Probe(0x%X): Status 0x%02X, Interrupt 0x%02X, "
1291: "Geometry 0x%02X\n", HostAdapter,
1292: HostAdapter->IO_Address, StatusRegister.All,
1293: InterruptRegister.All, GeometryRegister.All);
1294: if (StatusRegister.All == 0 ||
1295: StatusRegister.Bits.DiagnosticActive ||
1296: StatusRegister.Bits.CommandParameterRegisterBusy ||
1297: StatusRegister.Bits.Reserved ||
1298: StatusRegister.Bits.CommandInvalid ||
1299: InterruptRegister.Bits.Reserved != 0)
1300: return false;
1301: /*
1302: Check the undocumented Geometry Register to test if there is an I/O port
1303: that responded. Adaptec Host Adapters do not implement the Geometry
1304: Register, so this test helps serve to avoid incorrectly recognizing an
1305: Adaptec 1542A or 1542B as a BusLogic. Unfortunately, the Adaptec 1542C
1306: series does respond to the Geometry Register I/O port, but it will be
1307: rejected later when the Inquire Extended Setup Information command is
1308: issued in BusLogic_CheckHostAdapter. The AMI FastDisk Host Adapter is a
1309: BusLogic clone that implements the same interface as earlier BusLogic
1310: Host Adapters, including the undocumented commands, and is therefore
1311: supported by this driver. However, the AMI FastDisk always returns 0x00
1312: upon reading the Geometry Register, so the extended translation option
1313: should always be left disabled on the AMI FastDisk.
1314: */
1315: if (GeometryRegister.All == 0xFF) return false;
1316: /*
1317: Indicate the Host Adapter Probe completed successfully.
1318: */
1319: return true;
1320: }
1321:
1322:
1323: /*
1324: BusLogic_HardwareResetHostAdapter issues a Hardware Reset to the Host Adapter
1325: and waits for Host Adapter Diagnostics to complete. If HardReset is true, a
1326: Hard Reset is performed which also initiates a SCSI Bus Reset. Otherwise, a
1327: Soft Reset is performed which only resets the Host Adapter without forcing a
1328: SCSI Bus Reset.
1329: */
1330:
1331: static boolean BusLogic_HardwareResetHostAdapter(BusLogic_HostAdapter_T
1332: *HostAdapter,
1333: boolean HardReset)
1334: {
1335: BusLogic_StatusRegister_T StatusRegister;
1336: int TimeoutCounter;
1337: /*
1338: FlashPoint Host Adapters are Hard Reset by the FlashPoint SCCB Manager.
1339: */
1340: if (BusLogic_FlashPointHostAdapterP(HostAdapter))
1341: {
1342: FlashPoint_Info_T *FlashPointInfo = &HostAdapter->FlashPointInfo;
1343: FlashPointInfo->HostSoftReset = !HardReset;
1344: FlashPointInfo->ReportDataUnderrun = true;
1345: HostAdapter->CardHandle =
1346: FlashPoint_HardwareResetHostAdapter(FlashPointInfo);
1347: if (HostAdapter->CardHandle == FlashPoint_BadCardHandle) return false;
1348: /*
1349: Indicate the Host Adapter Hard Reset completed successfully.
1350: */
1351: return true;
1352: }
1353: /*
1354: Issue a Hard Reset or Soft Reset Command to the Host Adapter. The Host
1355: Adapter should respond by setting Diagnostic Active in the Status Register.
1356: */
1357: if (HardReset)
1358: BusLogic_HardReset(HostAdapter);
1359: else BusLogic_SoftReset(HostAdapter);
1360: /*
1361: Wait until Diagnostic Active is set in the Status Register.
1362: */
1363: TimeoutCounter = 5*10000;
1364: while (--TimeoutCounter >= 0)
1365: {
1366: StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
1367: if (StatusRegister.Bits.DiagnosticActive) break;
1368: udelay(100);
1369: }
1370: if (BusLogic_GlobalOptions.TraceHardwareReset)
1371: BusLogic_Notice("BusLogic_HardwareReset(0x%X): Diagnostic Active, "
1372: "Status 0x%02X\n", HostAdapter,
1373: HostAdapter->IO_Address, StatusRegister.All);
1374: if (TimeoutCounter < 0) return false;
1375: /*
1376: Wait 100 microseconds to allow completion of any initial diagnostic
1377: activity which might leave the contents of the Status Register
1378: unpredictable.
1379: */
1380: udelay(100);
1381: /*
1382: Wait until Diagnostic Active is reset in the Status Register.
1383: */
1384: TimeoutCounter = 10*10000;
1385: while (--TimeoutCounter >= 0)
1386: {
1387: StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
1388: if (!StatusRegister.Bits.DiagnosticActive) break;
1389: udelay(100);
1390: }
1391: if (BusLogic_GlobalOptions.TraceHardwareReset)
1392: BusLogic_Notice("BusLogic_HardwareReset(0x%X): Diagnostic Completed, "
1393: "Status 0x%02X\n", HostAdapter,
1394: HostAdapter->IO_Address, StatusRegister.All);
1395: if (TimeoutCounter < 0) return false;
1396: /*
1397: Wait until at least one of the Diagnostic Failure, Host Adapter Ready,
1398: or Data In Register Ready bits is set in the Status Register.
1399: */
1400: TimeoutCounter = 10000;
1401: while (--TimeoutCounter >= 0)
1402: {
1403: StatusRegister.All = BusLogic_ReadStatusRegister(HostAdapter);
1404: if (StatusRegister.Bits.DiagnosticFailure ||
1405: StatusRegister.Bits.HostAdapterReady ||
1406: StatusRegister.Bits.DataInRegisterReady)
1407: break;
1408: udelay(100);
1409: }
1410: if (BusLogic_GlobalOptions.TraceHardwareReset)
1411: BusLogic_Notice("BusLogic_HardwareReset(0x%X): Host Adapter Ready, "
1412: "Status 0x%02X\n", HostAdapter,
1413: HostAdapter->IO_Address, StatusRegister.All);
1414: if (TimeoutCounter < 0) return false;
1415: /*
1416: If Diagnostic Failure is set or Host Adapter Ready is reset, then an
1417: error occurred during the Host Adapter diagnostics. If Data In Register
1418: Ready is set, then there is an Error Code available.
1419: */
1420: if (StatusRegister.Bits.DiagnosticFailure ||
1421: !StatusRegister.Bits.HostAdapterReady)
1422: {
1423: BusLogic_CommandFailureReason = NULL;
1424: BusLogic_Failure(HostAdapter, "HARD RESET DIAGNOSTICS");
1425: BusLogic_Error("HOST ADAPTER STATUS REGISTER = %02X\n",
1426: HostAdapter, StatusRegister.All);
1427: if (StatusRegister.Bits.DataInRegisterReady)
1428: {
1429: unsigned char ErrorCode = BusLogic_ReadDataInRegister(HostAdapter);
1430: BusLogic_Error("HOST ADAPTER ERROR CODE = %d\n",
1431: HostAdapter, ErrorCode);
1432: }
1433: return false;
1434: }
1435: /*
1436: Indicate the Host Adapter Hard Reset completed successfully.
1437: */
1438: return true;
1439: }
1440:
1441:
1442: /*
1443: BusLogic_CheckHostAdapter checks to be sure this really is a BusLogic
1444: Host Adapter.
1445: */
1446:
1447: static boolean BusLogic_CheckHostAdapter(BusLogic_HostAdapter_T *HostAdapter)
1448: {
1449: BusLogic_ExtendedSetupInformation_T ExtendedSetupInformation;
1450: BusLogic_RequestedReplyLength_T RequestedReplyLength;
1451: boolean Result = true;
1452: /*
1453: FlashPoint Host Adapters do not require this protection.
1454: */
1455: if (BusLogic_FlashPointHostAdapterP(HostAdapter)) return true;
1456: /*
1457: Issue the Inquire Extended Setup Information command. Only genuine
1458: BusLogic Host Adapters and true clones support this command. Adaptec 1542C
1459: series Host Adapters that respond to the Geometry Register I/O port will
1460: fail this command.
1461: */
1462: RequestedReplyLength = sizeof(ExtendedSetupInformation);
1463: if (BusLogic_Command(HostAdapter,
1464: BusLogic_InquireExtendedSetupInformation,
1465: &RequestedReplyLength,
1466: sizeof(RequestedReplyLength),
1467: &ExtendedSetupInformation,
1468: sizeof(ExtendedSetupInformation))
1469: != sizeof(ExtendedSetupInformation))
1470: Result = false;
1471: /*
1472: Provide tracing information if requested and return.
1473: */
1474: if (BusLogic_GlobalOptions.TraceProbe)
1475: BusLogic_Notice("BusLogic_Check(0x%X): MultiMaster %s\n", HostAdapter,
1476: HostAdapter->IO_Address, (Result ? "Found" : "Not Found"));
1477: return Result;
1478: }
1479:
1480:
1481: /*
1482: BusLogic_ReadHostAdapterConfiguration reads the Configuration Information
1483: from Host Adapter and initializes the Host Adapter structure.
1484: */
1485:
1486: static boolean BusLogic_ReadHostAdapterConfiguration(BusLogic_HostAdapter_T
1487: *HostAdapter)
1488: {
1489: BusLogic_BoardID_T BoardID;
1490: BusLogic_Configuration_T Configuration;
1491: BusLogic_SetupInformation_T SetupInformation;
1492: BusLogic_ExtendedSetupInformation_T ExtendedSetupInformation;
1493: BusLogic_HostAdapterModelNumber_T HostAdapterModelNumber;
1494: BusLogic_FirmwareVersion3rdDigit_T FirmwareVersion3rdDigit;
1495: BusLogic_FirmwareVersionLetter_T FirmwareVersionLetter;
1496: BusLogic_PCIHostAdapterInformation_T PCIHostAdapterInformation;
1497: BusLogic_FetchHostAdapterLocalRAMRequest_T FetchHostAdapterLocalRAMRequest;
1498: BusLogic_AutoSCSIData_T AutoSCSIData;
1499: BusLogic_GeometryRegister_T GeometryRegister;
1500: BusLogic_RequestedReplyLength_T RequestedReplyLength;
1501: unsigned char *TargetPointer, Character;
1502: int TargetID, i;
1503: /*
1504: Configuration Information for FlashPoint Host Adapters is provided in the
1505: FlashPoint_Info structure by the FlashPoint SCCB Manager's Probe Function.
1506: Initialize fields in the Host Adapter structure from the FlashPoint_Info
1507: structure.
1508: */
1509: if (BusLogic_FlashPointHostAdapterP(HostAdapter))
1510: {
1511: FlashPoint_Info_T *FlashPointInfo = &HostAdapter->FlashPointInfo;
1512: TargetPointer = HostAdapter->ModelName;
1513: *TargetPointer++ = 'B';
1514: *TargetPointer++ = 'T';
1515: *TargetPointer++ = '-';
1516: for (i = 0; i < sizeof(FlashPointInfo->ModelNumber); i++)
1517: *TargetPointer++ = FlashPointInfo->ModelNumber[i];
1518: *TargetPointer++ = '\0';
1519: strcpy(HostAdapter->FirmwareVersion, FlashPoint_FirmwareVersion);
1520: HostAdapter->SCSI_ID = FlashPointInfo->SCSI_ID;
1521: HostAdapter->ExtendedTranslationEnabled =
1522: FlashPointInfo->ExtendedTranslationEnabled;
1523: HostAdapter->ParityCheckingEnabled =
1524: FlashPointInfo->ParityCheckingEnabled;
1525: HostAdapter->BusResetEnabled = !FlashPointInfo->HostSoftReset;
1526: HostAdapter->LevelSensitiveInterrupt = true;
1527: HostAdapter->HostWideSCSI = FlashPointInfo->HostWideSCSI;
1528: HostAdapter->HostDifferentialSCSI = false;
1529: HostAdapter->HostSupportsSCAM = true;
1530: HostAdapter->HostUltraSCSI = true;
1531: HostAdapter->ExtendedLUNSupport = true;
1532: HostAdapter->TerminationInfoValid = true;
1533: HostAdapter->LowByteTerminated = FlashPointInfo->LowByteTerminated;
1534: HostAdapter->HighByteTerminated = FlashPointInfo->HighByteTerminated;
1535: HostAdapter->SCAM_Enabled = FlashPointInfo->SCAM_Enabled;
1536: HostAdapter->SCAM_Level2 = FlashPointInfo->SCAM_Level2;
1537: HostAdapter->DriverScatterGatherLimit = BusLogic_ScatterGatherLimit;
1538: HostAdapter->MaxTargetDevices = (HostAdapter->HostWideSCSI ? 16 : 8);
1539: HostAdapter->MaxLogicalUnits = 32;
1540: HostAdapter->InitialCCBs = 4 * BusLogic_CCB_AllocationGroupSize;
1541: HostAdapter->IncrementalCCBs = BusLogic_CCB_AllocationGroupSize;
1542: HostAdapter->DriverQueueDepth = 255;
1543: HostAdapter->HostAdapterQueueDepth = HostAdapter->DriverQueueDepth;
1544: HostAdapter->SynchronousPermitted = FlashPointInfo->SynchronousPermitted;
1545: HostAdapter->FastPermitted = FlashPointInfo->FastPermitted;
1546: HostAdapter->UltraPermitted = FlashPointInfo->UltraPermitted;
1547: HostAdapter->WidePermitted = FlashPointInfo->WidePermitted;
1548: HostAdapter->DisconnectPermitted = FlashPointInfo->DisconnectPermitted;
1549: HostAdapter->TaggedQueuingPermitted = 0xFFFF;
1550: goto Common;
1551: }
1552: /*
1553: Issue the Inquire Board ID command.
1554: */
1555: if (BusLogic_Command(HostAdapter, BusLogic_InquireBoardID, NULL, 0,
1556: &BoardID, sizeof(BoardID)) != sizeof(BoardID))
1557: return BusLogic_Failure(HostAdapter, "INQUIRE BOARD ID");
1558: /*
1559: Issue the Inquire Configuration command.
1560: */
1561: if (BusLogic_Command(HostAdapter, BusLogic_InquireConfiguration, NULL, 0,
1562: &Configuration, sizeof(Configuration))
1563: != sizeof(Configuration))
1564: return BusLogic_Failure(HostAdapter, "INQUIRE CONFIGURATION");
1565: /*
1566: Issue the Inquire Setup Information command.
1567: */
1568: RequestedReplyLength = sizeof(SetupInformation);
1569: if (BusLogic_Command(HostAdapter, BusLogic_InquireSetupInformation,
1570: &RequestedReplyLength, sizeof(RequestedReplyLength),
1571: &SetupInformation, sizeof(SetupInformation))
1572: != sizeof(SetupInformation))
1573: return BusLogic_Failure(HostAdapter, "INQUIRE SETUP INFORMATION");
1574: /*
1575: Issue the Inquire Extended Setup Information command.
1576: */
1577: RequestedReplyLength = sizeof(ExtendedSetupInformation);
1578: if (BusLogic_Command(HostAdapter, BusLogic_InquireExtendedSetupInformation,
1579: &RequestedReplyLength, sizeof(RequestedReplyLength),
1580: &ExtendedSetupInformation,
1581: sizeof(ExtendedSetupInformation))
1582: != sizeof(ExtendedSetupInformation))
1583: return BusLogic_Failure(HostAdapter, "INQUIRE EXTENDED SETUP INFORMATION");
1584: /*
1585: Issue the Inquire Firmware Version 3rd Digit command.
1586: */
1587: FirmwareVersion3rdDigit = '\0';
1588: if (BoardID.FirmwareVersion1stDigit > '0')
1589: if (BusLogic_Command(HostAdapter, BusLogic_InquireFirmwareVersion3rdDigit,
1590: NULL, 0, &FirmwareVersion3rdDigit,
1591: sizeof(FirmwareVersion3rdDigit))
1592: != sizeof(FirmwareVersion3rdDigit))
1593: return BusLogic_Failure(HostAdapter, "INQUIRE FIRMWARE 3RD DIGIT");
1594: /*
1595: Issue the Inquire Host Adapter Model Number command.
1596: */
1597: if (ExtendedSetupInformation.BusType == 'A' &&
1598: BoardID.FirmwareVersion1stDigit == '2')
1599: /* BusLogic BT-542B ISA 2.xx */
1600: strcpy(HostAdapterModelNumber, "542B");
1601: else if (ExtendedSetupInformation.BusType == 'E' &&
1602: BoardID.FirmwareVersion1stDigit == '2' &&
1603: (BoardID.FirmwareVersion2ndDigit <= '1' ||
1604: (BoardID.FirmwareVersion2ndDigit == '2' &&
1605: FirmwareVersion3rdDigit == '0')))
1606: /* BusLogic BT-742A EISA 2.1x or 2.20 */
1607: strcpy(HostAdapterModelNumber, "742A");
1608: else if (ExtendedSetupInformation.BusType == 'E' &&
1609: BoardID.FirmwareVersion1stDigit == '0')
1610: /* AMI FastDisk EISA Series 441 0.x */
1611: strcpy(HostAdapterModelNumber, "747A");
1612: else
1613: {
1614: RequestedReplyLength = sizeof(HostAdapterModelNumber);
1615: if (BusLogic_Command(HostAdapter, BusLogic_InquireHostAdapterModelNumber,
1616: &RequestedReplyLength, sizeof(RequestedReplyLength),
1617: &HostAdapterModelNumber,
1618: sizeof(HostAdapterModelNumber))
1619: != sizeof(HostAdapterModelNumber))
1620: return BusLogic_Failure(HostAdapter,
1621: "INQUIRE HOST ADAPTER MODEL NUMBER");
1622: }
1623: /*
1624: BusLogic MultiMaster Host Adapters can be identified by their model number
1625: and the major version number of their firmware as follows:
1626:
1627: 5.xx BusLogic "W" Series Host Adapters:
1628: BT-948/958/958D
1629: 4.xx BusLogic "C" Series Host Adapters:
1630: BT-946C/956C/956CD/747C/757C/757CD/445C/545C/540CF
1631: 3.xx BusLogic "S" Series Host Adapters:
1632: BT-747S/747D/757S/757D/445S/545S/542D
1633: BT-542B/742A (revision H)
1634: 2.xx BusLogic "A" Series Host Adapters:
1635: BT-542B/742A (revision G and below)
1636: 0.xx AMI FastDisk VLB/EISA BusLogic Clone Host Adapter
1637: */
1638: /*
1639: Save the Model Name and Host Adapter Name in the Host Adapter structure.
1640: */
1641: TargetPointer = HostAdapter->ModelName;
1642: *TargetPointer++ = 'B';
1643: *TargetPointer++ = 'T';
1644: *TargetPointer++ = '-';
1645: for (i = 0; i < sizeof(HostAdapterModelNumber); i++)
1646: {
1647: Character = HostAdapterModelNumber[i];
1648: if (Character == ' ' || Character == '\0') break;
1649: *TargetPointer++ = Character;
1650: }
1651: *TargetPointer++ = '\0';
1652: /*
1653: Save the Firmware Version in the Host Adapter structure.
1654: */
1655: TargetPointer = HostAdapter->FirmwareVersion;
1656: *TargetPointer++ = BoardID.FirmwareVersion1stDigit;
1657: *TargetPointer++ = '.';
1658: *TargetPointer++ = BoardID.FirmwareVersion2ndDigit;
1659: if (FirmwareVersion3rdDigit != ' ' && FirmwareVersion3rdDigit != '\0')
1660: *TargetPointer++ = FirmwareVersion3rdDigit;
1661: *TargetPointer = '\0';
1662: /*
1663: Issue the Inquire Firmware Version Letter command.
1664: */
1665: if (strcmp(HostAdapter->FirmwareVersion, "3.3") >= 0)
1666: {
1667: if (BusLogic_Command(HostAdapter, BusLogic_InquireFirmwareVersionLetter,
1668: NULL, 0, &FirmwareVersionLetter,
1669: sizeof(FirmwareVersionLetter))
1670: != sizeof(FirmwareVersionLetter))
1671: return BusLogic_Failure(HostAdapter,
1672: "INQUIRE FIRMWARE VERSION LETTER");
1673: if (FirmwareVersionLetter != ' ' && FirmwareVersionLetter != '\0')
1674: *TargetPointer++ = FirmwareVersionLetter;
1675: *TargetPointer = '\0';
1676: }
1677: /*
1678: Save the Host Adapter SCSI ID in the Host Adapter structure.
1679: */
1680: HostAdapter->SCSI_ID = Configuration.HostAdapterID;
1681: /*
1682: Determine the Bus Type and save it in the Host Adapter structure, determine
1683: and save the IRQ Channel if necessary, and determine and save the DMA
1684: Channel for ISA Host Adapters.
1685: */
1686: HostAdapter->HostAdapterBusType =
1687: BusLogic_HostAdapterBusTypes[HostAdapter->ModelName[3] - '4'];
1688: if (HostAdapter->IRQ_Channel == 0)
1689: {
1690: if (Configuration.IRQ_Channel9)
1691: HostAdapter->IRQ_Channel = 9;
1692: else if (Configuration.IRQ_Channel10)
1693: HostAdapter->IRQ_Channel = 10;
1694: else if (Configuration.IRQ_Channel11)
1695: HostAdapter->IRQ_Channel = 11;
1696: else if (Configuration.IRQ_Channel12)
1697: HostAdapter->IRQ_Channel = 12;
1698: else if (Configuration.IRQ_Channel14)
1699: HostAdapter->IRQ_Channel = 14;
1700: else if (Configuration.IRQ_Channel15)
1701: HostAdapter->IRQ_Channel = 15;
1702: }
1703: if (HostAdapter->HostAdapterBusType == BusLogic_ISA_Bus)
1704: {
1705: if (Configuration.DMA_Channel5)
1706: HostAdapter->DMA_Channel = 5;
1707: else if (Configuration.DMA_Channel6)
1708: HostAdapter->DMA_Channel = 6;
1709: else if (Configuration.DMA_Channel7)
1710: HostAdapter->DMA_Channel = 7;
1711: }
1712: /*
1713: Determine whether Extended Translation is enabled and save it in
1714: the Host Adapter structure.
1715: */
1716: GeometryRegister.All = BusLogic_ReadGeometryRegister(HostAdapter);
1717: HostAdapter->ExtendedTranslationEnabled =
1718: GeometryRegister.Bits.ExtendedTranslationEnabled;
1719: /*
1720: Save the Scatter Gather Limits, Level Sensitive Interrupt flag, Wide
1721: SCSI flag, Differential SCSI flag, SCAM Supported flag, and
1722: Ultra SCSI flag in the Host Adapter structure.
1723: */
1724: HostAdapter->HostAdapterScatterGatherLimit =
1725: ExtendedSetupInformation.ScatterGatherLimit;
1726: HostAdapter->DriverScatterGatherLimit =
1727: HostAdapter->HostAdapterScatterGatherLimit;
1728: if (HostAdapter->HostAdapterScatterGatherLimit > BusLogic_ScatterGatherLimit)
1729: HostAdapter->DriverScatterGatherLimit = BusLogic_ScatterGatherLimit;
1730: if (ExtendedSetupInformation.Misc.LevelSensitiveInterrupt)
1731: HostAdapter->LevelSensitiveInterrupt = true;
1732: HostAdapter->HostWideSCSI = ExtendedSetupInformation.HostWideSCSI;
1733: HostAdapter->HostDifferentialSCSI =
1734: ExtendedSetupInformation.HostDifferentialSCSI;
1735: HostAdapter->HostSupportsSCAM = ExtendedSetupInformation.HostSupportsSCAM;
1736: HostAdapter->HostUltraSCSI = ExtendedSetupInformation.HostUltraSCSI;
1737: /*
1738: Determine whether Extended LUN Format CCBs are supported and save the
1739: information in the Host Adapter structure.
1740: */
1741: if (HostAdapter->FirmwareVersion[0] == '5' ||
1742: (HostAdapter->FirmwareVersion[0] == '4' && HostAdapter->HostWideSCSI))
1743: HostAdapter->ExtendedLUNSupport = true;
1744: /*
1745: Issue the Inquire PCI Host Adapter Information command to read the
1746: Termination Information from "W" series MultiMaster Host Adapters.
1747: */
1748: if (HostAdapter->FirmwareVersion[0] == '5')
1749: {
1750: if (BusLogic_Command(HostAdapter,
1751: BusLogic_InquirePCIHostAdapterInformation,
1752: NULL, 0, &PCIHostAdapterInformation,
1753: sizeof(PCIHostAdapterInformation))
1754: != sizeof(PCIHostAdapterInformation))
1755: return BusLogic_Failure(HostAdapter,
1756: "INQUIRE PCI HOST ADAPTER INFORMATION");
1757: /*
1758: Save the Termination Information in the Host Adapter structure.
1759: */
1760: if (PCIHostAdapterInformation.GenericInfoValid)
1761: {
1762: HostAdapter->TerminationInfoValid = true;
1763: HostAdapter->LowByteTerminated =
1764: PCIHostAdapterInformation.LowByteTerminated;
1765: HostAdapter->HighByteTerminated =
1766: PCIHostAdapterInformation.HighByteTerminated;
1767: }
1768: }
1769: /*
1770: Issue the Fetch Host Adapter Local RAM command to read the AutoSCSI data
1771: from "W" and "C" series MultiMaster Host Adapters.
1772: */
1773: if (HostAdapter->FirmwareVersion[0] >= '4')
1774: {
1775: FetchHostAdapterLocalRAMRequest.ByteOffset =
1776: BusLogic_AutoSCSI_BaseOffset;
1777: FetchHostAdapterLocalRAMRequest.ByteCount = sizeof(AutoSCSIData);
1778: if (BusLogic_Command(HostAdapter,
1779: BusLogic_FetchHostAdapterLocalRAM,
1780: &FetchHostAdapterLocalRAMRequest,
1781: sizeof(FetchHostAdapterLocalRAMRequest),
1782: &AutoSCSIData, sizeof(AutoSCSIData))
1783: != sizeof(AutoSCSIData))
1784: return BusLogic_Failure(HostAdapter, "FETCH HOST ADAPTER LOCAL RAM");
1785: /*
1786: Save the Parity Checking Enabled, Bus Reset Enabled, and Termination
1787: Information in the Host Adapter structure.
1788: */
1789: HostAdapter->ParityCheckingEnabled = AutoSCSIData.ParityCheckingEnabled;
1790: HostAdapter->BusResetEnabled = AutoSCSIData.BusResetEnabled;
1791: if (HostAdapter->FirmwareVersion[0] == '4')
1792: {
1793: HostAdapter->TerminationInfoValid = true;
1794: HostAdapter->LowByteTerminated = AutoSCSIData.LowByteTerminated;
1795: HostAdapter->HighByteTerminated = AutoSCSIData.HighByteTerminated;
1796: }
1797: /*
1798: Save the Wide Permitted, Fast Permitted, Synchronous Permitted,
1799: Disconnect Permitted, Ultra Permitted, and SCAM Information in the
1800: Host Adapter structure.
1801: */
1802: HostAdapter->WidePermitted = AutoSCSIData.WidePermitted;
1803: HostAdapter->FastPermitted = AutoSCSIData.FastPermitted;
1804: HostAdapter->SynchronousPermitted =
1805: AutoSCSIData.SynchronousPermitted;
1806: HostAdapter->DisconnectPermitted =
1807: AutoSCSIData.DisconnectPermitted;
1808: if (HostAdapter->HostUltraSCSI)
1809: HostAdapter->UltraPermitted = AutoSCSIData.UltraPermitted;
1810: if (HostAdapter->HostSupportsSCAM)
1811: {
1812: HostAdapter->SCAM_Enabled = AutoSCSIData.SCAM_Enabled;
1813: HostAdapter->SCAM_Level2 = AutoSCSIData.SCAM_Level2;
1814: }
1815: }
1816: /*
1817: Initialize fields in the Host Adapter structure for "S" and "A" series
1818: MultiMaster Host Adapters.
1819: */
1820: if (HostAdapter->FirmwareVersion[0] < '4')
1821: {
1822: if (SetupInformation.SynchronousInitiationEnabled)
1823: {
1824: HostAdapter->SynchronousPermitted = 0xFF;
1825: if (HostAdapter->HostAdapterBusType == BusLogic_EISA_Bus)
1826: {
1827: if (ExtendedSetupInformation.Misc.FastOnEISA)
1828: HostAdapter->FastPermitted = 0xFF;
1829: if (strcmp(HostAdapter->ModelName, "BT-757") == 0)
1830: HostAdapter->WidePermitted = 0xFF;
1831: }
1832: }
1833: HostAdapter->DisconnectPermitted = 0xFF;
1834: HostAdapter->ParityCheckingEnabled =
1835: SetupInformation.ParityCheckingEnabled;
1836: HostAdapter->BusResetEnabled = true;
1837: }
1838: /*
1839: Determine the maximum number of Target IDs and Logical Units supported by
1840: this driver for Wide and Narrow Host Adapters.
1841: */
1842: HostAdapter->MaxTargetDevices = (HostAdapter->HostWideSCSI ? 16 : 8);
1843: HostAdapter->MaxLogicalUnits = (HostAdapter->ExtendedLUNSupport ? 32 : 8);
1844: /*
1845: Select appropriate values for the Mailbox Count, Driver Queue Depth,
1846: Initial CCBs, and Incremental CCBs variables based on whether or not Strict
1847: Round Robin Mode is supported. If Strict Round Robin Mode is supported,
1848: then there is no performance degradation in using the maximum possible
1849: number of Outgoing and Incoming Mailboxes and allowing the Tagged and
1850: Untagged Queue Depths to determine the actual utilization. If Strict Round
1851: Robin Mode is not supported, then the Host Adapter must scan all the
1852: Outgoing Mailboxes whenever an Outgoing Mailbox entry is made, which can
1853: cause a substantial performance penalty. The host adapters actually have
1854: room to store the following number of CCBs internally; that is, they can
1855: internally queue and manage this many active commands on the SCSI bus
1856: simultaneously. Performance measurements demonstrate that the Driver Queue
1857: Depth should be set to the Mailbox Count, rather than the Host Adapter
1858: Queue Depth (internal CCB capacity), as it is more efficient to have the
1859: queued commands waiting in Outgoing Mailboxes if necessary than to block
1860: the process in the higher levels of the SCSI Subsystem.
1861:
1862: 192 BT-948/958/958D
1863: 100 BT-946C/956C/956CD/747C/757C/757CD/445C
1864: 50 BT-545C/540CF
1865: 30 BT-747S/747D/757S/757D/445S/545S/542D/542B/742A
1866: */
1867: if (HostAdapter->FirmwareVersion[0] == '5')
1868: HostAdapter->HostAdapterQueueDepth = 192;
1869: else if (HostAdapter->FirmwareVersion[0] == '4')
1870: HostAdapter->HostAdapterQueueDepth =
1871: (HostAdapter->HostAdapterBusType != BusLogic_ISA_Bus ? 100 : 50);
1872: else HostAdapter->HostAdapterQueueDepth = 30;
1873: if (strcmp(HostAdapter->FirmwareVersion, "3.31") >= 0)
1874: {
1875: HostAdapter->StrictRoundRobinModeSupport = true;
1876: HostAdapter->MailboxCount = BusLogic_MaxMailboxes;
1877: }
1878: else
1879: {
1880: HostAdapter->StrictRoundRobinModeSupport = false;
1881: HostAdapter->MailboxCount = 32;
1882: }
1883: HostAdapter->DriverQueueDepth = HostAdapter->MailboxCount;
1884: HostAdapter->InitialCCBs = 4 * BusLogic_CCB_AllocationGroupSize;
1885: HostAdapter->IncrementalCCBs = BusLogic_CCB_AllocationGroupSize;
1886: /*
1887: Tagged Queuing support is available and operates properly on all "W" series
1888: MultiMaster Host Adapters, on "C" series MultiMaster Host Adapters with
1889: firmware version 4.22 and above, and on "S" series MultiMaster Host
1890: Adapters with firmware version 3.35 and above.
1891: */
1892: HostAdapter->TaggedQueuingPermitted = 0;
1893: switch (HostAdapter->FirmwareVersion[0])
1894: {
1895: case '5':
1896: HostAdapter->TaggedQueuingPermitted = 0xFFFF;
1897: break;
1898: case '4':
1899: if (strcmp(HostAdapter->FirmwareVersion, "4.22") >= 0)
1900: HostAdapter->TaggedQueuingPermitted = 0xFFFF;
1901: break;
1902: case '3':
1903: if (strcmp(HostAdapter->FirmwareVersion, "3.35") >= 0)
1904: HostAdapter->TaggedQueuingPermitted = 0xFFFF;
1905: break;
1906: }
1907: /*
1908: Determine the Host Adapter BIOS Address if the BIOS is enabled and
1909: save it in the Host Adapter structure. The BIOS is disabled if the
1910: BIOS_Address is 0.
1911: */
1912: HostAdapter->BIOS_Address = ExtendedSetupInformation.BIOS_Address << 12;
1913: /*
1914: ISA Host Adapters require Bounce Buffers if there is more than 16MB memory.
1915: */
1916: if (HostAdapter->HostAdapterBusType == BusLogic_ISA_Bus &&
1917: (void *) high_memory > (void *) MAX_DMA_ADDRESS)
1918: HostAdapter->BounceBuffersRequired = true;
1919: /*
1920: BusLogic BT-445S Host Adapters prior to board revision E have a hardware
1921: bug whereby when the BIOS is enabled, transfers to/from the same address
1922: range the BIOS occupies modulo 16MB are handled incorrectly. Only properly
1923: functioning BT-445S Host Adapters have firmware version 3.37, so require
1924: that ISA Bounce Buffers be used for the buggy BT-445S models if there is
1925: more than 16MB memory.
1926: */
1927: if (HostAdapter->BIOS_Address > 0 &&
1928: strcmp(HostAdapter->ModelName, "BT-445S") == 0 &&
1929: strcmp(HostAdapter->FirmwareVersion, "3.37") < 0 &&
1930: (void *) high_memory > (void *) MAX_DMA_ADDRESS)
1931: HostAdapter->BounceBuffersRequired = true;
1932: /*
1933: Initialize parameters common to MultiMaster and FlashPoint Host Adapters.
1934: */
1935: Common:
1936: /*
1937: Initialize the Host Adapter Full Model Name from the Model Name.
1938: */
1939: strcpy(HostAdapter->FullModelName, "BusLogic ");
1940: strcat(HostAdapter->FullModelName, HostAdapter->ModelName);
1941: /*
1942: Select an appropriate value for the Tagged Queue Depth either from a
1943: BusLogic Driver Options specification, or based on whether this Host
1944: Adapter requires that ISA Bounce Buffers be used. The Tagged Queue Depth
1945: is left at 0 for automatic determination in BusLogic_SelectQueueDepths.
1946: Initialize the Untagged Queue Depth.
1947: */
1948: for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++)
1949: {
1950: unsigned char QueueDepth = 0;
1951: if (HostAdapter->DriverOptions != NULL &&
1952: HostAdapter->DriverOptions->QueueDepth[TargetID] > 0)
1953: QueueDepth = HostAdapter->DriverOptions->QueueDepth[TargetID];
1954: else if (HostAdapter->BounceBuffersRequired)
1955: QueueDepth = BusLogic_TaggedQueueDepthBB;
1956: HostAdapter->QueueDepth[TargetID] = QueueDepth;
1957: }
1958: if (HostAdapter->BounceBuffersRequired)
1959: HostAdapter->UntaggedQueueDepth = BusLogic_UntaggedQueueDepthBB;
1960: else HostAdapter->UntaggedQueueDepth = BusLogic_UntaggedQueueDepth;
1961: if (HostAdapter->DriverOptions != NULL)
1962: HostAdapter->CommonQueueDepth =
1963: HostAdapter->DriverOptions->CommonQueueDepth;
1964: if (HostAdapter->CommonQueueDepth > 0 &&
1965: HostAdapter->CommonQueueDepth < HostAdapter->UntaggedQueueDepth)
1966: HostAdapter->UntaggedQueueDepth = HostAdapter->CommonQueueDepth;
1967: /*
1968: Tagged Queuing is only allowed if Disconnect/Reconnect is permitted.
1969: Therefore, mask the Tagged Queuing Permitted Default bits with the
1970: Disconnect/Reconnect Permitted bits.
1971: */
1972: HostAdapter->TaggedQueuingPermitted &= HostAdapter->DisconnectPermitted;
1973: /*
1974: Combine the default Tagged Queuing Permitted bits with any BusLogic Driver
1975: Options Tagged Queuing specification.
1976: */
1977: if (HostAdapter->DriverOptions != NULL)
1978: HostAdapter->TaggedQueuingPermitted =
1979: (HostAdapter->DriverOptions->TaggedQueuingPermitted &
1980: HostAdapter->DriverOptions->TaggedQueuingPermittedMask) |
1981: (HostAdapter->TaggedQueuingPermitted &
1982: ~HostAdapter->DriverOptions->TaggedQueuingPermittedMask);
1983: /*
1984: Select appropriate values for the Error Recovery Strategy array
1985: either from a BusLogic Driver Options specification, or using
1986: BusLogic_ErrorRecovery_Default.
1987: */
1988: for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++)
1989: if (HostAdapter->DriverOptions != NULL)
1990: HostAdapter->ErrorRecoveryStrategy[TargetID] =
1991: HostAdapter->DriverOptions->ErrorRecoveryStrategy[TargetID];
1992: else HostAdapter->ErrorRecoveryStrategy[TargetID] =
1993: BusLogic_ErrorRecovery_Default;
1994: /*
1995: Select an appropriate value for Bus Settle Time either from a BusLogic
1996: Driver Options specification, or from BusLogic_DefaultBusSettleTime.
1997: */
1998: if (HostAdapter->DriverOptions != NULL &&
1999: HostAdapter->DriverOptions->BusSettleTime > 0)
2000: HostAdapter->BusSettleTime = HostAdapter->DriverOptions->BusSettleTime;
2001: else HostAdapter->BusSettleTime = BusLogic_DefaultBusSettleTime;
2002: /*
2003: Indicate reading the Host Adapter Configuration completed successfully.
2004: */
2005: return true;
2006: }
2007:
2008:
2009: /*
2010: BusLogic_ReportHostAdapterConfiguration reports the configuration of
2011: Host Adapter.
2012: */
2013:
2014: static boolean BusLogic_ReportHostAdapterConfiguration(BusLogic_HostAdapter_T
2015: *HostAdapter)
2016: {
2017: unsigned short AllTargetsMask = (1 << HostAdapter->MaxTargetDevices) - 1;
2018: unsigned short SynchronousPermitted, FastPermitted;
2019: unsigned short UltraPermitted, WidePermitted;
2020: unsigned short DisconnectPermitted, TaggedQueuingPermitted;
2021: boolean CommonSynchronousNegotiation, CommonTaggedQueueDepth;
2022: boolean CommonErrorRecovery;
2023: char SynchronousString[BusLogic_MaxTargetDevices+1];
2024: char WideString[BusLogic_MaxTargetDevices+1];
2025: char DisconnectString[BusLogic_MaxTargetDevices+1];
2026: char TaggedQueuingString[BusLogic_MaxTargetDevices+1];
2027: char ErrorRecoveryString[BusLogic_MaxTargetDevices+1];
2028: char *SynchronousMessage = SynchronousString;
2029: char *WideMessage = WideString;
2030: char *DisconnectMessage = DisconnectString;
2031: char *TaggedQueuingMessage = TaggedQueuingString;
2032: char *ErrorRecoveryMessage = ErrorRecoveryString;
2033: int TargetID;
2034: BusLogic_Info("Configuring BusLogic Model %s %s%s%s%s SCSI Host Adapter\n",
2035: HostAdapter, HostAdapter->ModelName,
2036: BusLogic_HostAdapterBusNames[HostAdapter->HostAdapterBusType],
2037: (HostAdapter->HostWideSCSI ? " Wide" : ""),
2038: (HostAdapter->HostDifferentialSCSI ? " Differential" : ""),
2039: (HostAdapter->HostUltraSCSI ? " Ultra" : ""));
2040: BusLogic_Info(" Firmware Version: %s, I/O Address: 0x%X, "
2041: "IRQ Channel: %d/%s\n", HostAdapter,
2042: HostAdapter->FirmwareVersion,
2043: HostAdapter->IO_Address, HostAdapter->IRQ_Channel,
2044: (HostAdapter->LevelSensitiveInterrupt ? "Level" : "Edge"));
2045: if (HostAdapter->HostAdapterBusType != BusLogic_PCI_Bus)
2046: {
2047: BusLogic_Info(" DMA Channel: ", HostAdapter);
2048: if (HostAdapter->DMA_Channel > 0)
2049: BusLogic_Info("%d, ", HostAdapter, HostAdapter->DMA_Channel);
2050: else BusLogic_Info("None, ", HostAdapter);
2051: if (HostAdapter->BIOS_Address > 0)
2052: BusLogic_Info("BIOS Address: 0x%X, ", HostAdapter,
2053: HostAdapter->BIOS_Address);
2054: else BusLogic_Info("BIOS Address: None, ", HostAdapter);
2055: }
2056: else
2057: {
2058: BusLogic_Info(" PCI Bus: %d, Device: %d, Address: ",
2059: HostAdapter, HostAdapter->Bus, HostAdapter->Device);
2060: if (HostAdapter->PCI_Address > 0)
2061: BusLogic_Info("0x%X, ", HostAdapter, HostAdapter->PCI_Address);
2062: else BusLogic_Info("Unassigned, ", HostAdapter);
2063: }
2064: BusLogic_Info("Host Adapter SCSI ID: %d\n", HostAdapter,
2065: HostAdapter->SCSI_ID);
2066: BusLogic_Info(" Parity Checking: %s, Extended Translation: %s\n",
2067: HostAdapter,
2068: (HostAdapter->ParityCheckingEnabled
2069: ? "Enabled" : "Disabled"),
2070: (HostAdapter->ExtendedTranslationEnabled
2071: ? "Enabled" : "Disabled"));
2072: AllTargetsMask &= ~(1 << HostAdapter->SCSI_ID);
2073: SynchronousPermitted = HostAdapter->SynchronousPermitted & AllTargetsMask;
2074: FastPermitted = HostAdapter->FastPermitted & AllTargetsMask;
2075: UltraPermitted = HostAdapter->UltraPermitted & AllTargetsMask;
2076: if ((BusLogic_MultiMasterHostAdapterP(HostAdapter) &&
2077: (HostAdapter->FirmwareVersion[0] >= '4' ||
2078: HostAdapter->HostAdapterBusType == BusLogic_EISA_Bus)) ||
2079: BusLogic_FlashPointHostAdapterP(HostAdapter))
2080: {
2081: CommonSynchronousNegotiation = false;
2082: if (SynchronousPermitted == 0)
2083: {
2084: SynchronousMessage = "Disabled";
2085: CommonSynchronousNegotiation = true;
2086: }
2087: else if (SynchronousPermitted == AllTargetsMask)
2088: {
2089: if (FastPermitted == 0)
2090: {
2091: SynchronousMessage = "Slow";
2092: CommonSynchronousNegotiation = true;
2093: }
2094: else if (FastPermitted == AllTargetsMask)
2095: {
2096: if (UltraPermitted == 0)
2097: {
2098: SynchronousMessage = "Fast";
2099: CommonSynchronousNegotiation = true;
2100: }
2101: else if (UltraPermitted == AllTargetsMask)
2102: {
2103: SynchronousMessage = "Ultra";
2104: CommonSynchronousNegotiation = true;
2105: }
2106: }
2107: }
2108: if (!CommonSynchronousNegotiation)
2109: {
2110: for (TargetID = 0;
2111: TargetID < HostAdapter->MaxTargetDevices;
2112: TargetID++)
2113: SynchronousString[TargetID] =
2114: ((!(SynchronousPermitted & (1 << TargetID))) ? 'N' :
2115: (!(FastPermitted & (1 << TargetID)) ? 'S' :
2116: (!(UltraPermitted & (1 << TargetID)) ? 'F' : 'U')));
2117: SynchronousString[HostAdapter->SCSI_ID] = '#';
2118: SynchronousString[HostAdapter->MaxTargetDevices] = '\0';
2119: }
2120: }
2121: else SynchronousMessage =
2122: (SynchronousPermitted == 0 ? "Disabled" : "Enabled");
2123: WidePermitted = HostAdapter->WidePermitted & AllTargetsMask;
2124: if (WidePermitted == 0)
2125: WideMessage = "Disabled";
2126: else if (WidePermitted == AllTargetsMask)
2127: WideMessage = "Enabled";
2128: else
2129: {
2130: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2131: WideString[TargetID] =
2132: ((WidePermitted & (1 << TargetID)) ? 'Y' : 'N');
2133: WideString[HostAdapter->SCSI_ID] = '#';
2134: WideString[HostAdapter->MaxTargetDevices] = '\0';
2135: }
2136: DisconnectPermitted = HostAdapter->DisconnectPermitted & AllTargetsMask;
2137: if (DisconnectPermitted == 0)
2138: DisconnectMessage = "Disabled";
2139: else if (DisconnectPermitted == AllTargetsMask)
2140: DisconnectMessage = "Enabled";
2141: else
2142: {
2143: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2144: DisconnectString[TargetID] =
2145: ((DisconnectPermitted & (1 << TargetID)) ? 'Y' : 'N');
2146: DisconnectString[HostAdapter->SCSI_ID] = '#';
2147: DisconnectString[HostAdapter->MaxTargetDevices] = '\0';
2148: }
2149: TaggedQueuingPermitted =
2150: HostAdapter->TaggedQueuingPermitted & AllTargetsMask;
2151: if (TaggedQueuingPermitted == 0)
2152: TaggedQueuingMessage = "Disabled";
2153: else if (TaggedQueuingPermitted == AllTargetsMask)
2154: TaggedQueuingMessage = "Enabled";
2155: else
2156: {
2157: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2158: TaggedQueuingString[TargetID] =
2159: ((TaggedQueuingPermitted & (1 << TargetID)) ? 'Y' : 'N');
2160: TaggedQueuingString[HostAdapter->SCSI_ID] = '#';
2161: TaggedQueuingString[HostAdapter->MaxTargetDevices] = '\0';
2162: }
2163: BusLogic_Info(" Synchronous Negotiation: %s, Wide Negotiation: %s\n",
2164: HostAdapter, SynchronousMessage, WideMessage);
2165: BusLogic_Info(" Disconnect/Reconnect: %s, Tagged Queuing: %s\n",
2166: HostAdapter, DisconnectMessage, TaggedQueuingMessage);
2167: if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
2168: {
2169: BusLogic_Info(" Scatter/Gather Limit: %d of %d segments, "
2170: "Mailboxes: %d\n", HostAdapter,
2171: HostAdapter->DriverScatterGatherLimit,
2172: HostAdapter->HostAdapterScatterGatherLimit,
2173: HostAdapter->MailboxCount);
2174: BusLogic_Info(" Driver Queue Depth: %d, "
2175: "Host Adapter Queue Depth: %d\n",
2176: HostAdapter, HostAdapter->DriverQueueDepth,
2177: HostAdapter->HostAdapterQueueDepth);
2178: }
2179: else BusLogic_Info(" Driver Queue Depth: %d, "
2180: "Scatter/Gather Limit: %d segments\n",
2181: HostAdapter, HostAdapter->DriverQueueDepth,
2182: HostAdapter->DriverScatterGatherLimit);
2183: BusLogic_Info(" Tagged Queue Depth: ", HostAdapter);
2184: CommonTaggedQueueDepth = true;
2185: for (TargetID = 1; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2186: if (HostAdapter->QueueDepth[TargetID] != HostAdapter->QueueDepth[0])
2187: {
2188: CommonTaggedQueueDepth = false;
2189: break;
2190: }
2191: if (CommonTaggedQueueDepth)
2192: {
2193: if (HostAdapter->QueueDepth[0] > 0)
2194: BusLogic_Info("%d", HostAdapter, HostAdapter->QueueDepth[0]);
2195: else BusLogic_Info("Automatic", HostAdapter);
2196: }
2197: else BusLogic_Info("Individual", HostAdapter);
2198: BusLogic_Info(", Untagged Queue Depth: %d\n", HostAdapter,
2199: HostAdapter->UntaggedQueueDepth);
2200: CommonErrorRecovery = true;
2201: for (TargetID = 1; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2202: if (HostAdapter->ErrorRecoveryStrategy[TargetID] !=
2203: HostAdapter->ErrorRecoveryStrategy[0])
2204: {
2205: CommonErrorRecovery = false;
2206: break;
2207: }
2208: if (CommonErrorRecovery)
2209: ErrorRecoveryMessage =
2210: BusLogic_ErrorRecoveryStrategyNames[
2211: HostAdapter->ErrorRecoveryStrategy[0]];
2212: else
2213: {
2214: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2215: ErrorRecoveryString[TargetID] =
2216: BusLogic_ErrorRecoveryStrategyLetters[
2217: HostAdapter->ErrorRecoveryStrategy[TargetID]];
2218: ErrorRecoveryString[HostAdapter->SCSI_ID] = '#';
2219: ErrorRecoveryString[HostAdapter->MaxTargetDevices] = '\0';
2220: }
2221: BusLogic_Info(" Error Recovery Strategy: %s, SCSI Bus Reset: %s\n",
2222: HostAdapter, ErrorRecoveryMessage,
2223: (HostAdapter->BusResetEnabled ? "Enabled" : "Disabled"));
2224: if (HostAdapter->TerminationInfoValid)
2225: {
2226: if (HostAdapter->HostWideSCSI)
2227: BusLogic_Info(" SCSI Bus Termination: %s", HostAdapter,
2228: (HostAdapter->LowByteTerminated
2229: ? (HostAdapter->HighByteTerminated
2230: ? "Both Enabled" : "Low Enabled")
2231: : (HostAdapter->HighByteTerminated
2232: ? "High Enabled" : "Both Disabled")));
2233: else BusLogic_Info(" SCSI Bus Termination: %s", HostAdapter,
2234: (HostAdapter->LowByteTerminated ?
2235: "Enabled" : "Disabled"));
2236: if (HostAdapter->HostSupportsSCAM)
2237: BusLogic_Info(", SCAM: %s", HostAdapter,
2238: (HostAdapter->SCAM_Enabled
2239: ? (HostAdapter->SCAM_Level2
2240: ? "Enabled, Level 2" : "Enabled, Level 1")
2241: : "Disabled"));
2242: BusLogic_Info("\n", HostAdapter);
2243: }
2244: /*
2245: Indicate reporting the Host Adapter configuration completed successfully.
2246: */
2247: return true;
2248: }
2249:
2250:
2251: /*
2252: BusLogic_AcquireResources acquires the system resources necessary to use
2253: Host Adapter.
2254: */
2255:
2256: static boolean BusLogic_AcquireResources(BusLogic_HostAdapter_T *HostAdapter)
2257: {
2258: if (HostAdapter->IRQ_Channel == 0)
2259: {
2260: BusLogic_Error("NO LEGAL INTERRUPT CHANNEL ASSIGNED - DETACHING\n",
2261: HostAdapter);
2262: return false;
2263: }
2264: /*
2265: Acquire shared access to the IRQ Channel.
2266: */
2267: if (request_irq(HostAdapter->IRQ_Channel, BusLogic_InterruptHandler,
2268: SA_INTERRUPT | SA_SHIRQ,
2269: HostAdapter->FullModelName, HostAdapter) < 0)
2270: {
2271: BusLogic_Error("UNABLE TO ACQUIRE IRQ CHANNEL %d - DETACHING\n",
2272: HostAdapter, HostAdapter->IRQ_Channel);
2273: return false;
2274: }
2275: HostAdapter->IRQ_ChannelAcquired = true;
2276: /*
2277: Acquire exclusive access to the DMA Channel.
2278: */
2279: if (HostAdapter->DMA_Channel > 0)
2280: {
2281: if (request_dma(HostAdapter->DMA_Channel,
2282: HostAdapter->FullModelName) < 0)
2283: {
2284: BusLogic_Error("UNABLE TO ACQUIRE DMA CHANNEL %d - DETACHING\n",
2285: HostAdapter, HostAdapter->DMA_Channel);
2286: return false;
2287: }
2288: set_dma_mode(HostAdapter->DMA_Channel, DMA_MODE_CASCADE);
2289: enable_dma(HostAdapter->DMA_Channel);
2290: HostAdapter->DMA_ChannelAcquired = true;
2291: }
2292: /*
2293: Indicate the System Resource Acquisition completed successfully,
2294: */
2295: return true;
2296: }
2297:
2298:
2299: /*
2300: BusLogic_ReleaseResources releases any system resources previously acquired
2301: by BusLogic_AcquireResources.
2302: */
2303:
2304: static void BusLogic_ReleaseResources(BusLogic_HostAdapter_T *HostAdapter)
2305: {
2306: /*
2307: Release shared access to the IRQ Channel.
2308: */
2309: if (HostAdapter->IRQ_ChannelAcquired)
2310: free_irq(HostAdapter->IRQ_Channel, HostAdapter);
2311: /*
2312: Release exclusive access to the DMA Channel.
2313: */
2314: if (HostAdapter->DMA_ChannelAcquired)
2315: free_dma(HostAdapter->DMA_Channel);
2316: }
2317:
2318:
2319: /*
2320: BusLogic_InitializeHostAdapter initializes Host Adapter. This is the only
2321: function called during SCSI Host Adapter detection which modifies the state
2322: of the Host Adapter from its initial power on or hard reset state.
2323: */
2324:
2325: static boolean BusLogic_InitializeHostAdapter(BusLogic_HostAdapter_T
2326: *HostAdapter)
2327: {
2328: BusLogic_ExtendedMailboxRequest_T ExtendedMailboxRequest;
2329: BusLogic_RoundRobinModeRequest_T RoundRobinModeRequest;
2330: BusLogic_SetCCBFormatRequest_T SetCCBFormatRequest;
2331: int TargetID;
2332: /*
2333: Initialize the pointers to the first and last CCBs that are queued for
2334: completion processing.
2335: */
2336: HostAdapter->FirstCompletedCCB = NULL;
2337: HostAdapter->LastCompletedCCB = NULL;
2338: /*
2339: Initialize the Bus Device Reset Pending CCB, Tagged Queuing Active,
2340: Command Successful Flag, Active Commands, and Commands Since Reset
2341: for each Target Device.
2342: */
2343: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2344: {
2345: HostAdapter->BusDeviceResetPendingCCB[TargetID] = NULL;
2346: HostAdapter->TargetFlags[TargetID].TaggedQueuingActive = false;
2347: HostAdapter->TargetFlags[TargetID].CommandSuccessfulFlag = false;
2348: HostAdapter->ActiveCommands[TargetID] = 0;
2349: HostAdapter->CommandsSinceReset[TargetID] = 0;
2350: }
2351: /*
2352: FlashPoint Host Adapters do not use Outgoing and Incoming Mailboxes.
2353: */
2354: if (BusLogic_FlashPointHostAdapterP(HostAdapter)) goto Done;
2355: /*
2356: Initialize the Outgoing and Incoming Mailbox pointers.
2357: */
2358: HostAdapter->FirstOutgoingMailbox =
2359: (BusLogic_OutgoingMailbox_T *) HostAdapter->MailboxSpace;
2360: HostAdapter->LastOutgoingMailbox =
2361: HostAdapter->FirstOutgoingMailbox + HostAdapter->MailboxCount - 1;
2362: HostAdapter->NextOutgoingMailbox = HostAdapter->FirstOutgoingMailbox;
2363: HostAdapter->FirstIncomingMailbox =
2364: (BusLogic_IncomingMailbox_T *) (HostAdapter->LastOutgoingMailbox + 1);
2365: HostAdapter->LastIncomingMailbox =
2366: HostAdapter->FirstIncomingMailbox + HostAdapter->MailboxCount - 1;
2367: HostAdapter->NextIncomingMailbox = HostAdapter->FirstIncomingMailbox;
2368: /*
2369: Initialize the Outgoing and Incoming Mailbox structures.
2370: */
2371: memset(HostAdapter->FirstOutgoingMailbox, 0,
2372: HostAdapter->MailboxCount * sizeof(BusLogic_OutgoingMailbox_T));
2373: memset(HostAdapter->FirstIncomingMailbox, 0,
2374: HostAdapter->MailboxCount * sizeof(BusLogic_IncomingMailbox_T));
2375: /*
2376: Initialize the Host Adapter's Pointer to the Outgoing/Incoming Mailboxes.
2377: */
2378: ExtendedMailboxRequest.MailboxCount = HostAdapter->MailboxCount;
2379: ExtendedMailboxRequest.BaseMailboxAddress =
2380: Virtual_to_Bus(HostAdapter->FirstOutgoingMailbox);
2381: if (BusLogic_Command(HostAdapter, BusLogic_InitializeExtendedMailbox,
2382: &ExtendedMailboxRequest,
2383: sizeof(ExtendedMailboxRequest), NULL, 0) < 0)
2384: return BusLogic_Failure(HostAdapter, "MAILBOX INITIALIZATION");
2385: /*
2386: Enable Strict Round Robin Mode if supported by the Host Adapter. In
2387: Strict Round Robin Mode, the Host Adapter only looks at the next Outgoing
2388: Mailbox for each new command, rather than scanning through all the
2389: Outgoing Mailboxes to find any that have new commands in them. Strict
2390: Round Robin Mode is significantly more efficient.
2391: */
2392: if (HostAdapter->StrictRoundRobinModeSupport)
2393: {
2394: RoundRobinModeRequest = BusLogic_StrictRoundRobinMode;
2395: if (BusLogic_Command(HostAdapter, BusLogic_EnableStrictRoundRobinMode,
2396: &RoundRobinModeRequest,
2397: sizeof(RoundRobinModeRequest), NULL, 0) < 0)
2398: return BusLogic_Failure(HostAdapter, "ENABLE STRICT ROUND ROBIN MODE");
2399: }
2400: /*
2401: For Host Adapters that support Extended LUN Format CCBs, issue the Set CCB
2402: Format command to allow 32 Logical Units per Target Device.
2403: */
2404: if (HostAdapter->ExtendedLUNSupport)
2405: {
2406: SetCCBFormatRequest = BusLogic_ExtendedLUNFormatCCB;
2407: if (BusLogic_Command(HostAdapter, BusLogic_SetCCBFormat,
2408: &SetCCBFormatRequest, sizeof(SetCCBFormatRequest),
2409: NULL, 0) < 0)
2410: return BusLogic_Failure(HostAdapter, "SET CCB FORMAT");
2411: }
2412: /*
2413: Announce Successful Initialization.
2414: */
2415: Done:
2416: if (!HostAdapter->HostAdapterInitialized)
2417: {
2418: BusLogic_Info("*** %s Initialized Successfully ***\n",
2419: HostAdapter, HostAdapter->FullModelName);
2420: BusLogic_Info("\n", HostAdapter);
2421: }
2422: else BusLogic_Warning("*** %s Initialized Successfully ***\n",
2423: HostAdapter, HostAdapter->FullModelName);
2424: HostAdapter->HostAdapterInitialized = true;
2425: /*
2426: Indicate the Host Adapter Initialization completed successfully.
2427: */
2428: return true;
2429: }
2430:
2431:
2432: /*
2433: BusLogic_TargetDeviceInquiry inquires about the Target Devices accessible
2434: through Host Adapter.
2435: */
2436:
2437: static boolean BusLogic_TargetDeviceInquiry(BusLogic_HostAdapter_T
2438: *HostAdapter)
2439: {
2440: BusLogic_InstalledDevices_T InstalledDevices;
2441: BusLogic_InstalledDevices8_T InstalledDevicesID0to7;
2442: BusLogic_SetupInformation_T SetupInformation;
2443: BusLogic_SynchronousPeriod_T SynchronousPeriod;
2444: BusLogic_RequestedReplyLength_T RequestedReplyLength;
2445: int TargetID;
2446: /*
2447: Wait a few seconds between the Host Adapter Hard Reset which initiates
2448: a SCSI Bus Reset and issuing any SCSI Commands. Some SCSI devices get
2449: confused if they receive SCSI Commands too soon after a SCSI Bus Reset.
2450: */
2451: BusLogic_Delay(HostAdapter->BusSettleTime);
2452: /*
2453: FlashPoint Host Adapters do not provide for Target Device Inquiry.
2454: */
2455: if (BusLogic_FlashPointHostAdapterP(HostAdapter)) return true;
2456: /*
2457: Inhibit the Target Device Inquiry if requested.
2458: */
2459: if (HostAdapter->DriverOptions != NULL &&
2460: HostAdapter->DriverOptions->LocalOptions.InhibitTargetInquiry)
2461: return true;
2462: /*
2463: Issue the Inquire Target Devices command for host adapters with firmware
2464: version 4.25 or later, or the Inquire Installed Devices ID 0 to 7 command
2465: for older host adapters. This is necessary to force Synchronous Transfer
2466: Negotiation so that the Inquire Setup Information and Inquire Synchronous
2467: Period commands will return valid data. The Inquire Target Devices command
2468: is preferable to Inquire Installed Devices ID 0 to 7 since it only probes
2469: Logical Unit 0 of each Target Device.
2470: */
2471: if (strcmp(HostAdapter->FirmwareVersion, "4.25") >= 0)
2472: {
2473: if (BusLogic_Command(HostAdapter, BusLogic_InquireTargetDevices, NULL, 0,
2474: &InstalledDevices, sizeof(InstalledDevices))
2475: != sizeof(InstalledDevices))
2476: return BusLogic_Failure(HostAdapter, "INQUIRE TARGET DEVICES");
2477: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2478: HostAdapter->TargetFlags[TargetID].TargetExists =
2479: (InstalledDevices & (1 << TargetID) ? true : false);
2480: }
2481: else
2482: {
2483: if (BusLogic_Command(HostAdapter, BusLogic_InquireInstalledDevicesID0to7,
2484: NULL, 0, &InstalledDevicesID0to7,
2485: sizeof(InstalledDevicesID0to7))
2486: != sizeof(InstalledDevicesID0to7))
2487: return BusLogic_Failure(HostAdapter,
2488: "INQUIRE INSTALLED DEVICES ID 0 TO 7");
2489: for (TargetID = 0; TargetID < 8; TargetID++)
2490: HostAdapter->TargetFlags[TargetID].TargetExists =
2491: (InstalledDevicesID0to7[TargetID] != 0 ? true : false);
2492: }
2493: /*
2494: Issue the Inquire Setup Information command.
2495: */
2496: RequestedReplyLength = sizeof(SetupInformation);
2497: if (BusLogic_Command(HostAdapter, BusLogic_InquireSetupInformation,
2498: &RequestedReplyLength, sizeof(RequestedReplyLength),
2499: &SetupInformation, sizeof(SetupInformation))
2500: != sizeof(SetupInformation))
2501: return BusLogic_Failure(HostAdapter, "INQUIRE SETUP INFORMATION");
2502: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2503: HostAdapter->SynchronousOffset[TargetID] =
2504: (TargetID < 8
2505: ? SetupInformation.SynchronousValuesID0to7[TargetID].Offset
2506: : SetupInformation.SynchronousValuesID8to15[TargetID-8].Offset);
2507: if (strcmp(HostAdapter->FirmwareVersion, "5.06L") >= 0)
2508: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2509: HostAdapter->TargetFlags[TargetID].WideTransfersActive =
2510: (TargetID < 8
2511: ? (SetupInformation.WideTransfersActiveID0to7 & (1 << TargetID)
2512: ? true : false)
2513: : (SetupInformation.WideTransfersActiveID8to15 & (1 << (TargetID-8))
2514: ? true : false));
2515: /*
2516: Issue the Inquire Synchronous Period command.
2517: */
2518: if (HostAdapter->FirmwareVersion[0] >= '3')
2519: {
2520: RequestedReplyLength = sizeof(SynchronousPeriod);
2521: if (BusLogic_Command(HostAdapter, BusLogic_InquireSynchronousPeriod,
2522: &RequestedReplyLength, sizeof(RequestedReplyLength),
2523: &SynchronousPeriod, sizeof(SynchronousPeriod))
2524: != sizeof(SynchronousPeriod))
2525: return BusLogic_Failure(HostAdapter, "INQUIRE SYNCHRONOUS PERIOD");
2526: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2527: HostAdapter->SynchronousPeriod[TargetID] = SynchronousPeriod[TargetID];
2528: }
2529: else
2530: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2531: if (SetupInformation.SynchronousValuesID0to7[TargetID].Offset > 0)
2532: HostAdapter->SynchronousPeriod[TargetID] =
2533: 20 + 5 * SetupInformation.SynchronousValuesID0to7[TargetID]
2534: .TransferPeriod;
2535: /*
2536: Indicate the Target Device Inquiry completed successfully.
2537: */
2538: return true;
2539: }
2540:
2541:
2542: /*
2543: BusLogic_ReportTargetDeviceInfo reports about the Target Devices accessible
2544: through Host Adapter.
2545: */
2546:
2547: static void BusLogic_ReportTargetDeviceInfo(BusLogic_HostAdapter_T
2548: *HostAdapter)
2549: {
2550: int TargetID;
2551: /*
2552: Inhibit the Target Device Inquiry and Reporting if requested.
2553: */
2554: if (BusLogic_MultiMasterHostAdapterP(HostAdapter) &&
2555: HostAdapter->DriverOptions != NULL &&
2556: HostAdapter->DriverOptions->LocalOptions.InhibitTargetInquiry)
2557: return;
2558: /*
2559: Report on the Target Devices found.
2560: */
2561: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2562: {
2563: BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
2564: if (TargetFlags->TargetExists && !TargetFlags->TargetInfoReported)
2565: {
2566: int SynchronousTransferRate = 0;
2567: if (BusLogic_FlashPointHostAdapterP(HostAdapter))
2568: {
2569: boolean WideTransfersActive;
2570: FlashPoint_InquireTargetInfo(
2571: HostAdapter->CardHandle, TargetID,
2572: &HostAdapter->SynchronousPeriod[TargetID],
2573: &HostAdapter->SynchronousOffset[TargetID],
2574: &WideTransfersActive);
2575: TargetFlags->WideTransfersActive = WideTransfersActive;
2576: }
2577: else if (TargetFlags->WideTransfersSupported &&
2578: (HostAdapter->WidePermitted & (1 << TargetID)) &&
2579: strcmp(HostAdapter->FirmwareVersion, "5.06L") < 0)
2580: TargetFlags->WideTransfersActive = true;
2581: if (HostAdapter->SynchronousPeriod[TargetID] > 0)
2582: SynchronousTransferRate =
2583: 100000 / HostAdapter->SynchronousPeriod[TargetID];
2584: if (TargetFlags->WideTransfersActive)
2585: SynchronousTransferRate <<= 1;
2586: if (SynchronousTransferRate >= 9950)
2587: {
2588: SynchronousTransferRate = (SynchronousTransferRate + 50) / 100;
2589: BusLogic_Info("Target %d: Queue Depth %d, %sSynchronous at "
2590: "%d.%01d MB/sec, offset %d\n",
2591: HostAdapter, TargetID,
2592: HostAdapter->QueueDepth[TargetID],
2593: (TargetFlags->WideTransfersActive ? "Wide " : ""),
2594: SynchronousTransferRate / 10,
2595: SynchronousTransferRate % 10,
2596: HostAdapter->SynchronousOffset[TargetID]);
2597: }
2598: else if (SynchronousTransferRate > 0)
2599: {
2600: SynchronousTransferRate = (SynchronousTransferRate + 5) / 10;
2601: BusLogic_Info("Target %d: Queue Depth %d, %sSynchronous at "
2602: "%d.%02d MB/sec, offset %d\n",
2603: HostAdapter, TargetID,
2604: HostAdapter->QueueDepth[TargetID],
2605: (TargetFlags->WideTransfersActive ? "Wide " : ""),
2606: SynchronousTransferRate / 100,
2607: SynchronousTransferRate % 100,
2608: HostAdapter->SynchronousOffset[TargetID]);
2609: }
2610: else BusLogic_Info("Target %d: Queue Depth %d, Asynchronous\n",
2611: HostAdapter, TargetID,
2612: HostAdapter->QueueDepth[TargetID]);
2613: TargetFlags->TargetInfoReported = true;
2614: }
2615: }
2616: }
2617:
2618:
2619: /*
2620: BusLogic_InitializeHostStructure initializes the fields in the SCSI Host
2621: structure. The base, io_port, n_io_ports, irq, and dma_channel fields in the
2622: SCSI Host structure are intentionally left uninitialized, as this driver
2623: handles acquisition and release of these resources explicitly, as well as
2624: ensuring exclusive access to the Host Adapter hardware and data structures
2625: through explicit acquisition and release of the Host Adapter's Lock.
2626: */
2627:
2628: static void BusLogic_InitializeHostStructure(BusLogic_HostAdapter_T
2629: *HostAdapter,
2630: SCSI_Host_T *Host)
2631: {
2632: Host->max_id = HostAdapter->MaxTargetDevices;
2633: Host->max_lun = HostAdapter->MaxLogicalUnits;
2634: Host->max_channel = 0;
2635: Host->unique_id = HostAdapter->IO_Address;
2636: Host->this_id = HostAdapter->SCSI_ID;
2637: Host->can_queue = HostAdapter->DriverQueueDepth;
2638: Host->sg_tablesize = HostAdapter->DriverScatterGatherLimit;
2639: Host->unchecked_isa_dma = HostAdapter->BounceBuffersRequired;
2640: Host->cmd_per_lun = HostAdapter->UntaggedQueueDepth;
2641: }
2642:
2643:
2644: /*
2645: BusLogic_SelectQueueDepths selects Queue Depths for each Target Device based
2646: on the Host Adapter's Total Queue Depth and the number, type, speed, and
2647: capabilities of the Target Devices. When called for the last Host Adapter,
2648: it reports on the Target Device Information for all BusLogic Host Adapters
2649: since all the Target Devices have now been probed.
2650: */
2651:
2652: static void BusLogic_SelectQueueDepths(SCSI_Host_T *Host,
2653: SCSI_Device_T *DeviceList)
2654: {
2655: BusLogic_HostAdapter_T *HostAdapter =
2656: (BusLogic_HostAdapter_T *) Host->hostdata;
2657: int TaggedDeviceCount = 0, AutomaticTaggedDeviceCount = 0;
2658: int UntaggedDeviceCount = 0, AutomaticTaggedQueueDepth = 0;
2659: int AllocatedQueueDepth = 0;
2660: SCSI_Device_T *Device;
2661: int TargetID;
2662: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2663: if (HostAdapter->TargetFlags[TargetID].TargetExists)
2664: {
2665: int QueueDepth = HostAdapter->QueueDepth[TargetID];
2666: if (HostAdapter->TargetFlags[TargetID].TaggedQueuingSupported &&
2667: (HostAdapter->TaggedQueuingPermitted & (1 << TargetID)))
2668: {
2669: TaggedDeviceCount++;
2670: if (QueueDepth == 0) AutomaticTaggedDeviceCount++;
2671: }
2672: else
2673: {
2674: UntaggedDeviceCount++;
2675: if (QueueDepth == 0 ||
2676: QueueDepth > HostAdapter->UntaggedQueueDepth)
2677: {
2678: QueueDepth = HostAdapter->UntaggedQueueDepth;
2679: HostAdapter->QueueDepth[TargetID] = QueueDepth;
2680: }
2681: }
2682: AllocatedQueueDepth += QueueDepth;
2683: if (QueueDepth == 1)
2684: HostAdapter->TaggedQueuingPermitted &= ~(1 << TargetID);
2685: }
2686: HostAdapter->TargetDeviceCount = TaggedDeviceCount + UntaggedDeviceCount;
2687: if (AutomaticTaggedDeviceCount > 0)
2688: {
2689: AutomaticTaggedQueueDepth =
2690: (HostAdapter->HostAdapterQueueDepth - AllocatedQueueDepth)
2691: / AutomaticTaggedDeviceCount;
2692: if (AutomaticTaggedQueueDepth > BusLogic_MaxAutomaticTaggedQueueDepth)
2693: AutomaticTaggedQueueDepth = BusLogic_MaxAutomaticTaggedQueueDepth;
2694: if (AutomaticTaggedQueueDepth < BusLogic_MinAutomaticTaggedQueueDepth)
2695: AutomaticTaggedQueueDepth = BusLogic_MinAutomaticTaggedQueueDepth;
2696: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
2697: if (HostAdapter->TargetFlags[TargetID].TargetExists &&
2698: HostAdapter->QueueDepth[TargetID] == 0)
2699: {
2700: AllocatedQueueDepth += AutomaticTaggedQueueDepth;
2701: HostAdapter->QueueDepth[TargetID] = AutomaticTaggedQueueDepth;
2702: }
2703: }
2704: for (Device = DeviceList; Device != NULL; Device = Device->next)
2705: if (Device->host == Host)
2706: Device->queue_depth = HostAdapter->QueueDepth[Device->id];
2707: /* Allocate an extra CCB for each Target Device for a Bus Device Reset. */
2708: AllocatedQueueDepth += HostAdapter->TargetDeviceCount;
2709: if (AllocatedQueueDepth > HostAdapter->DriverQueueDepth)
2710: AllocatedQueueDepth = HostAdapter->DriverQueueDepth;
2711: BusLogic_CreateAdditionalCCBs(HostAdapter,
2712: AllocatedQueueDepth
2713: - HostAdapter->AllocatedCCBs,
2714: false);
2715: if (HostAdapter == BusLogic_LastRegisteredHostAdapter)
2716: for (HostAdapter = BusLogic_FirstRegisteredHostAdapter;
2717: HostAdapter != NULL;
2718: HostAdapter = HostAdapter->Next)
2719: BusLogic_ReportTargetDeviceInfo(HostAdapter);
2720: }
2721:
2722:
2723: /*
2724: BusLogic_DetectHostAdapter probes for BusLogic Host Adapters at the standard
2725: I/O Addresses where they may be located, initializing, registering, and
2726: reporting the configuration of each BusLogic Host Adapter it finds. It
2727: returns the number of BusLogic Host Adapters successfully initialized and
2728: registered.
2729: */
2730:
2731: int BusLogic_DetectHostAdapter(SCSI_Host_Template_T *HostTemplate)
2732: {
2733: int BusLogicHostAdapterCount = 0, DriverOptionsIndex = 0, ProbeIndex;
2734: BusLogic_HostAdapter_T *PrototypeHostAdapter;
2735: if (BusLogic_ProbeOptions.NoProbe) return 0;
2736: BusLogic_ProbeInfoList = (BusLogic_ProbeInfo_T *)
2737: kmalloc(BusLogic_MaxHostAdapters * sizeof(BusLogic_ProbeInfo_T),
2738: GFP_ATOMIC);
2739: if (BusLogic_ProbeInfoList == NULL)
2740: {
2741: BusLogic_Error("BusLogic: Unable to allocate Probe Info List\n", NULL);
2742: return 0;
2743: }
2744: memset(BusLogic_ProbeInfoList, 0,
2745: BusLogic_MaxHostAdapters * sizeof(BusLogic_ProbeInfo_T));
2746: PrototypeHostAdapter = (BusLogic_HostAdapter_T *)
2747: kmalloc(sizeof(BusLogic_HostAdapter_T), GFP_ATOMIC);
2748: if (PrototypeHostAdapter == NULL)
2749: {
2750: kfree(BusLogic_ProbeInfoList);
2751: BusLogic_Error("BusLogic: Unable to allocate Prototype "
2752: "Host Adapter\n", NULL);
2753: return 0;
2754: }
2755: memset(PrototypeHostAdapter, 0, sizeof(BusLogic_HostAdapter_T));
2756: if (BusLogic_Options != NULL)
2757: BusLogic_ParseDriverOptions(BusLogic_Options);
2758: BusLogic_InitializeProbeInfoList(PrototypeHostAdapter);
2759: for (ProbeIndex = 0; ProbeIndex < BusLogic_ProbeInfoCount; ProbeIndex++)
2760: {
2761: BusLogic_ProbeInfo_T *ProbeInfo = &BusLogic_ProbeInfoList[ProbeIndex];
2762: BusLogic_HostAdapter_T *HostAdapter = PrototypeHostAdapter;
2763: SCSI_Host_T *Host;
2764: if (ProbeInfo->IO_Address == 0) continue;
2765: memset(HostAdapter, 0, sizeof(BusLogic_HostAdapter_T));
2766: HostAdapter->HostAdapterType = ProbeInfo->HostAdapterType;
2767: HostAdapter->HostAdapterBusType = ProbeInfo->HostAdapterBusType;
2768: HostAdapter->IO_Address = ProbeInfo->IO_Address;
2769: HostAdapter->PCI_Address = ProbeInfo->PCI_Address;
2770: HostAdapter->Bus = ProbeInfo->Bus;
2771: HostAdapter->Device = ProbeInfo->Device;
2772: HostAdapter->IRQ_Channel = ProbeInfo->IRQ_Channel;
2773: HostAdapter->AddressCount =
2774: BusLogic_HostAdapterAddressCount[HostAdapter->HostAdapterType];
2775: /*
2776: Probe the Host Adapter. If unsuccessful, abort further initialization.
2777: */
2778: if (!BusLogic_ProbeHostAdapter(HostAdapter)) continue;
2779: /*
2780: Hard Reset the Host Adapter. If unsuccessful, abort further
2781: initialization.
2782: */
2783: if (!BusLogic_HardwareResetHostAdapter(HostAdapter, true)) continue;
2784: /*
2785: Check the Host Adapter. If unsuccessful, abort further initialization.
2786: */
2787: if (!BusLogic_CheckHostAdapter(HostAdapter)) continue;
2788: /*
2789: Initialize the Driver Options field if provided.
2790: */
2791: if (DriverOptionsIndex < BusLogic_DriverOptionsCount)
2792: HostAdapter->DriverOptions =
2793: &BusLogic_DriverOptions[DriverOptionsIndex++];
2794: /*
2795: Announce the Driver Version and Date, Author's Name, Copyright Notice,
2796: and Electronic Mail Address.
2797: */
2798: BusLogic_AnnounceDriver(HostAdapter);
2799: /*
2800: Register usage of the I/O Address range. From this point onward, any
2801: failure will be assumed to be due to a problem with the Host Adapter,
2802: rather than due to having mistakenly identified this port as belonging
2803: to a BusLogic Host Adapter. The I/O Address range will not be
2804: released, thereby preventing it from being incorrectly identified as
2805: any other type of Host Adapter.
2806: */
2807: request_region(HostAdapter->IO_Address, HostAdapter->AddressCount,
2808: "BusLogic");
2809: /*
2810: Register the SCSI Host structure.
2811: */
2812: Host = scsi_register(HostTemplate, sizeof(BusLogic_HostAdapter_T));
2813: HostAdapter = (BusLogic_HostAdapter_T *) Host->hostdata;
2814: memcpy(HostAdapter, PrototypeHostAdapter, sizeof(BusLogic_HostAdapter_T));
2815: HostAdapter->SCSI_Host = Host;
2816: HostAdapter->HostNumber = Host->host_no;
2817: Host->select_queue_depths = BusLogic_SelectQueueDepths;
2818: /*
2819: Add Host Adapter to the end of the list of registered BusLogic
2820: Host Adapters.
2821: */
2822: BusLogic_RegisterHostAdapter(HostAdapter);
2823: /*
2824: Read the Host Adapter Configuration, Configure the Host Adapter,
2825: Acquire the System Resources necessary to use the Host Adapter, then
2826: Create the Initial CCBs, Initialize the Host Adapter, and finally
2827: perform Target Device Inquiry.
2828: */
2829: if (BusLogic_ReadHostAdapterConfiguration(HostAdapter) &&
2830: BusLogic_ReportHostAdapterConfiguration(HostAdapter) &&
2831: BusLogic_AcquireResources(HostAdapter) &&
2832: BusLogic_CreateInitialCCBs(HostAdapter) &&
2833: BusLogic_InitializeHostAdapter(HostAdapter) &&
2834: BusLogic_TargetDeviceInquiry(HostAdapter))
2835: {
2836: /*
2837: Initialization has been completed successfully. Release and
2838: re-register usage of the I/O Address range so that the Model
2839: Name of the Host Adapter will appear, and initialize the SCSI
2840: Host structure.
2841: */
2842: release_region(HostAdapter->IO_Address,
2843: HostAdapter->AddressCount);
2844: request_region(HostAdapter->IO_Address,
2845: HostAdapter->AddressCount,
2846: HostAdapter->FullModelName);
2847: BusLogic_InitializeHostStructure(HostAdapter, Host);
2848: BusLogicHostAdapterCount++;
2849: }
2850: else
2851: {
2852: /*
2853: An error occurred during Host Adapter Configuration Querying, Host
2854: Adapter Configuration, Resource Acquisition, CCB Creation, Host
2855: Adapter Initialization, or Target Device Inquiry, so remove Host
2856: Adapter from the list of registered BusLogic Host Adapters, destroy
2857: the CCBs, Release the System Resources, and Unregister the SCSI
2858: Host.
2859: */
2860: BusLogic_DestroyCCBs(HostAdapter);
2861: BusLogic_ReleaseResources(HostAdapter);
2862: BusLogic_UnregisterHostAdapter(HostAdapter);
2863: scsi_unregister(Host);
2864: }
2865: }
2866: kfree(PrototypeHostAdapter);
2867: kfree(BusLogic_ProbeInfoList);
2868: BusLogic_ProbeInfoList = NULL;
2869: return BusLogicHostAdapterCount;
2870: }
2871:
2872:
2873: /*
2874: BusLogic_ReleaseHostAdapter releases all resources previously acquired to
2875: support a specific Host Adapter, including the I/O Address range, and
2876: unregisters the BusLogic Host Adapter.
2877: */
2878:
2879: int BusLogic_ReleaseHostAdapter(SCSI_Host_T *Host)
2880: {
2881: BusLogic_HostAdapter_T *HostAdapter =
2882: (BusLogic_HostAdapter_T *) Host->hostdata;
2883: /*
2884: FlashPoint Host Adapters must first be released by the FlashPoint
2885: SCCB Manager.
2886: */
2887: if (BusLogic_FlashPointHostAdapterP(HostAdapter))
2888: FlashPoint_ReleaseHostAdapter(HostAdapter->CardHandle);
2889: /*
2890: Destroy the CCBs and release any system resources acquired to
2891: support Host Adapter.
2892: */
2893: BusLogic_DestroyCCBs(HostAdapter);
2894: BusLogic_ReleaseResources(HostAdapter);
2895: /*
2896: Release usage of the I/O Address range.
2897: */
2898: release_region(HostAdapter->IO_Address, HostAdapter->AddressCount);
2899: /*
2900: Remove Host Adapter from the list of registered BusLogic Host Adapters.
2901: */
2902: BusLogic_UnregisterHostAdapter(HostAdapter);
2903: return 0;
2904: }
2905:
2906:
2907: /*
2908: BusLogic_QueueCompletedCCB queues CCB for completion processing.
2909: */
2910:
2911: static void BusLogic_QueueCompletedCCB(BusLogic_CCB_T *CCB)
2912: {
2913: BusLogic_HostAdapter_T *HostAdapter = CCB->HostAdapter;
2914: CCB->Status = BusLogic_CCB_Completed;
2915: CCB->Next = NULL;
2916: if (HostAdapter->FirstCompletedCCB == NULL)
2917: {
2918: HostAdapter->FirstCompletedCCB = CCB;
2919: HostAdapter->LastCompletedCCB = CCB;
2920: }
2921: else
2922: {
2923: HostAdapter->LastCompletedCCB->Next = CCB;
2924: HostAdapter->LastCompletedCCB = CCB;
2925: }
2926: HostAdapter->ActiveCommands[CCB->TargetID]--;
2927: }
2928:
2929:
2930: /*
2931: BusLogic_ComputeResultCode computes a SCSI Subsystem Result Code from
2932: the Host Adapter Status and Target Device Status.
2933: */
2934:
2935: static int BusLogic_ComputeResultCode(BusLogic_HostAdapter_T *HostAdapter,
2936: BusLogic_HostAdapterStatus_T
2937: HostAdapterStatus,
2938: BusLogic_TargetDeviceStatus_T
2939: TargetDeviceStatus)
2940: {
2941: int HostStatus;
2942: switch (HostAdapterStatus)
2943: {
2944: case BusLogic_CommandCompletedNormally:
2945: case BusLogic_LinkedCommandCompleted:
2946: case BusLogic_LinkedCommandCompletedWithFlag:
2947: HostStatus = DID_OK;
2948: break;
2949: case BusLogic_SCSISelectionTimeout:
2950: HostStatus = DID_TIME_OUT;
2951: break;
2952: case BusLogic_InvalidOutgoingMailboxActionCode:
2953: case BusLogic_InvalidCommandOperationCode:
2954: case BusLogic_InvalidCommandParameter:
2955: BusLogic_Warning("BusLogic Driver Protocol Error 0x%02X\n",
2956: HostAdapter, HostAdapterStatus);
2957: case BusLogic_DataUnderRun:
2958: case BusLogic_DataOverRun:
2959: case BusLogic_UnexpectedBusFree:
2960: case BusLogic_LinkedCCBhasInvalidLUN:
2961: case BusLogic_AutoRequestSenseFailed:
2962: case BusLogic_TaggedQueuingMessageRejected:
2963: case BusLogic_UnsupportedMessageReceived:
2964: case BusLogic_HostAdapterHardwareFailed:
2965: case BusLogic_TargetDeviceReconnectedImproperly:
2966: case BusLogic_AbortQueueGenerated:
2967: case BusLogic_HostAdapterSoftwareError:
2968: case BusLogic_HostAdapterHardwareTimeoutError:
2969: case BusLogic_SCSIParityErrorDetected:
2970: HostStatus = DID_ERROR;
2971: break;
2972: case BusLogic_InvalidBusPhaseRequested:
2973: case BusLogic_TargetFailedResponseToATN:
2974: case BusLogic_HostAdapterAssertedRST:
2975: case BusLogic_OtherDeviceAssertedRST:
2976: case BusLogic_HostAdapterAssertedBusDeviceReset:
2977: HostStatus = DID_RESET;
2978: break;
2979: default:
2980: BusLogic_Warning("Unknown Host Adapter Status 0x%02X\n",
2981: HostAdapter, HostAdapterStatus);
2982: HostStatus = DID_ERROR;
2983: break;
2984: }
2985: return (HostStatus << 16) | TargetDeviceStatus;
2986: }
2987:
2988:
2989: /*
2990: BusLogic_ScanIncomingMailboxes scans the Incoming Mailboxes saving any
2991: Incoming Mailbox entries for completion processing.
2992: */
2993:
2994: static void BusLogic_ScanIncomingMailboxes(BusLogic_HostAdapter_T *HostAdapter)
2995: {
2996: /*
2997: Scan through the Incoming Mailboxes in Strict Round Robin fashion, saving
2998: any completed CCBs for further processing. It is essential that for each
2999: CCB and SCSI Command issued, command completion processing is performed
3000: exactly once. Therefore, only Incoming Mailboxes with completion code
3001: Command Completed Without Error, Command Completed With Error, or Command
3002: Aborted At Host Request are saved for completion processing. When an
3003: Incoming Mailbox has a completion code of Aborted Command Not Found, the
3004: CCB had already completed or been aborted before the current Abort request
3005: was processed, and so completion processing has already occurred and no
3006: further action should be taken.
3007: */
3008: BusLogic_IncomingMailbox_T *NextIncomingMailbox =
3009: HostAdapter->NextIncomingMailbox;
3010: BusLogic_CompletionCode_T CompletionCode;
3011: while ((CompletionCode = NextIncomingMailbox->CompletionCode) !=
3012: BusLogic_IncomingMailboxFree)
3013: {
3014: BusLogic_CCB_T *CCB = (BusLogic_CCB_T *)
3015: Bus_to_Virtual(NextIncomingMailbox->CCB);
3016: if (CompletionCode != BusLogic_AbortedCommandNotFound)
3017: {
3018: if (CCB->Status == BusLogic_CCB_Active ||
3019: CCB->Status == BusLogic_CCB_Reset)
3020: {
3021: /*
3022: Save the Completion Code for this CCB and queue the CCB
3023: for completion processing.
3024: */
3025: CCB->CompletionCode = CompletionCode;
3026: BusLogic_QueueCompletedCCB(CCB);
3027: }
3028: else
3029: {
3030: /*
3031: If a CCB ever appears in an Incoming Mailbox and is not marked
3032: as status Active or Reset, then there is most likely a bug in
3033: the Host Adapter firmware.
3034: */
3035: BusLogic_Warning("Illegal CCB #%ld status %d in "
3036: "Incoming Mailbox\n", HostAdapter,
3037: CCB->SerialNumber, CCB->Status);
3038: }
3039: }
3040: NextIncomingMailbox->CompletionCode = BusLogic_IncomingMailboxFree;
3041: if (++NextIncomingMailbox > HostAdapter->LastIncomingMailbox)
3042: NextIncomingMailbox = HostAdapter->FirstIncomingMailbox;
3043: }
3044: HostAdapter->NextIncomingMailbox = NextIncomingMailbox;
3045: }
3046:
3047:
3048: /*
3049: BusLogic_ProcessCompletedCCBs iterates over the completed CCBs for Host
3050: Adapter setting the SCSI Command Result Codes, deallocating the CCBs, and
3051: calling the SCSI Subsystem Completion Routines. The Host Adapter's Lock
3052: should already have been acquired by the caller.
3053: */
3054:
3055: static void BusLogic_ProcessCompletedCCBs(BusLogic_HostAdapter_T *HostAdapter)
3056: {
3057: if (HostAdapter->ProcessCompletedCCBsActive) return;
3058: HostAdapter->ProcessCompletedCCBsActive = true;
3059: while (HostAdapter->FirstCompletedCCB != NULL)
3060: {
3061: BusLogic_CCB_T *CCB = HostAdapter->FirstCompletedCCB;
3062: SCSI_Command_T *Command = CCB->Command;
3063: HostAdapter->FirstCompletedCCB = CCB->Next;
3064: if (HostAdapter->FirstCompletedCCB == NULL)
3065: HostAdapter->LastCompletedCCB = NULL;
3066: /*
3067: Process the Completed CCB.
3068: */
3069: if (CCB->Opcode == BusLogic_BusDeviceReset)
3070: {
3071: int TargetID = CCB->TargetID;
3072: BusLogic_Warning("Bus Device Reset CCB #%ld to Target "
3073: "%d Completed\n", HostAdapter,
3074: CCB->SerialNumber, TargetID);
3075: BusLogic_IncrementErrorCounter(
3076: &HostAdapter->TargetStatistics[TargetID].BusDeviceResetsCompleted);
3077: HostAdapter->TargetFlags[TargetID].TaggedQueuingActive = false;
3078: HostAdapter->CommandsSinceReset[TargetID] = 0;
3079: HostAdapter->LastResetCompleted[TargetID] = jiffies;
3080: /*
3081: Place CCB back on the Host Adapter's free list.
3082: */
3083: BusLogic_DeallocateCCB(CCB);
3084: /*
3085: Bus Device Reset CCBs have the Command field non-NULL only when a
3086: Bus Device Reset was requested for a Command that did not have a
3087: currently active CCB in the Host Adapter (i.e., a Synchronous
3088: Bus Device Reset), and hence would not have its Completion Routine
3089: called otherwise.
3090: */
3091: while (Command != NULL)
3092: {
3093: SCSI_Command_T *NextCommand = Command->reset_chain;
3094: Command->reset_chain = NULL;
3095: Command->result = DID_RESET << 16;
3096: Command->scsi_done(Command);
3097: Command = NextCommand;
3098: }
3099: /*
3100: Iterate over the CCBs for this Host Adapter performing completion
3101: processing for any CCBs marked as Reset for this Target.
3102: */
3103: for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
3104: if (CCB->Status == BusLogic_CCB_Reset && CCB->TargetID == TargetID)
3105: {
3106: Command = CCB->Command;
3107: BusLogic_DeallocateCCB(CCB);
3108: HostAdapter->ActiveCommands[TargetID]--;
3109: Command->result = DID_RESET << 16;
3110: Command->scsi_done(Command);
3111: }
3112: HostAdapter->BusDeviceResetPendingCCB[TargetID] = NULL;
3113: }
3114: else
3115: {
3116: /*
3117: Translate the Completion Code, Host Adapter Status, and Target
3118: Device Status into a SCSI Subsystem Result Code.
3119: */
3120: switch (CCB->CompletionCode)
3121: {
3122: case BusLogic_IncomingMailboxFree:
3123: case BusLogic_AbortedCommandNotFound:
3124: case BusLogic_InvalidCCB:
3125: BusLogic_Warning("CCB #%ld to Target %d Impossible State\n",
3126: HostAdapter, CCB->SerialNumber, CCB->TargetID);
3127: break;
3128: case BusLogic_CommandCompletedWithoutError:
3129: HostAdapter->TargetStatistics[CCB->TargetID]
3130: .CommandsCompleted++;
3131: HostAdapter->TargetFlags[CCB->TargetID]
3132: .CommandSuccessfulFlag = true;
3133: Command->result = DID_OK << 16;
3134: break;
3135: case BusLogic_CommandAbortedAtHostRequest:
3136: BusLogic_Warning("CCB #%ld to Target %d Aborted\n",
3137: HostAdapter, CCB->SerialNumber, CCB->TargetID);
3138: BusLogic_IncrementErrorCounter(
3139: &HostAdapter->TargetStatistics[CCB->TargetID]
3140: .CommandAbortsCompleted);
3141: Command->result = DID_ABORT << 16;
3142: break;
3143: case BusLogic_CommandCompletedWithError:
3144: Command->result =
3145: BusLogic_ComputeResultCode(HostAdapter,
3146: CCB->HostAdapterStatus,
3147: CCB->TargetDeviceStatus);
3148: if (CCB->HostAdapterStatus != BusLogic_SCSISelectionTimeout)
3149: {
3150: HostAdapter->TargetStatistics[CCB->TargetID]
3151: .CommandsCompleted++;
3152: if (BusLogic_GlobalOptions.TraceErrors)
3153: {
3154: int i;
3155: BusLogic_Notice("CCB #%ld Target %d: Result %X Host "
3156: "Adapter Status %02X "
3157: "Target Status %02X\n",
3158: HostAdapter, CCB->SerialNumber,
3159: CCB->TargetID, Command->result,
3160: CCB->HostAdapterStatus,
3161: CCB->TargetDeviceStatus);
3162: BusLogic_Notice("CDB ", HostAdapter);
3163: for (i = 0; i < CCB->CDB_Length; i++)
3164: BusLogic_Notice(" %02X", HostAdapter, CCB->CDB[i]);
3165: BusLogic_Notice("\n", HostAdapter);
3166: BusLogic_Notice("Sense ", HostAdapter);
3167: for (i = 0; i < CCB->SenseDataLength; i++)
3168: BusLogic_Notice(" %02X", HostAdapter,
3169: Command->sense_buffer[i]);
3170: BusLogic_Notice("\n", HostAdapter);
3171: }
3172: }
3173: break;
3174: }
3175: /*
3176: When an INQUIRY command completes normally, save the
3177: CmdQue (Tagged Queuing Supported) and WBus16 (16 Bit
3178: Wide Data Transfers Supported) bits.
3179: */
3180: if (CCB->CDB[0] == INQUIRY && CCB->CDB[1] == 0 &&
3181: CCB->HostAdapterStatus == BusLogic_CommandCompletedNormally)
3182: {
3183: BusLogic_TargetFlags_T *TargetFlags =
3184: &HostAdapter->TargetFlags[CCB->TargetID];
3185: SCSI_Inquiry_T *InquiryResult =
3186: (SCSI_Inquiry_T *) Command->request_buffer;
3187: TargetFlags->TargetExists = true;
3188: TargetFlags->TaggedQueuingSupported = InquiryResult->CmdQue;
3189: TargetFlags->WideTransfersSupported = InquiryResult->WBus16;
3190: }
3191: /*
3192: Place CCB back on the Host Adapter's free list.
3193: */
3194: BusLogic_DeallocateCCB(CCB);
3195: /*
3196: Call the SCSI Command Completion Routine.
3197: */
3198: Command->scsi_done(Command);
3199: }
3200: }
3201: HostAdapter->ProcessCompletedCCBsActive = false;
3202: }
3203:
3204:
3205: /*
3206: BusLogic_InterruptHandler handles hardware interrupts from BusLogic Host
3207: Adapters.
3208: */
3209:
3210: static void BusLogic_InterruptHandler(int IRQ_Channel,
3211: void *DeviceIdentifier,
3212: Registers_T *InterruptRegisters)
3213: {
3214: BusLogic_HostAdapter_T *HostAdapter =
3215: (BusLogic_HostAdapter_T *) DeviceIdentifier;
3216: ProcessorFlags_T ProcessorFlags;
3217: /*
3218: Acquire exclusive access to Host Adapter.
3219: */
3220: BusLogic_AcquireHostAdapterLockIH(HostAdapter, &ProcessorFlags);
3221: /*
3222: Handle Interrupts appropriately for each Host Adapter type.
3223: */
3224: if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
3225: {
3226: BusLogic_InterruptRegister_T InterruptRegister;
3227: /*
3228: Read the Host Adapter Interrupt Register.
3229: */
3230: InterruptRegister.All = BusLogic_ReadInterruptRegister(HostAdapter);
3231: if (InterruptRegister.Bits.InterruptValid)
3232: {
3233: /*
3234: Acknowledge the interrupt and reset the Host Adapter
3235: Interrupt Register.
3236: */
3237: BusLogic_InterruptReset(HostAdapter);
3238: /*
3239: Process valid External SCSI Bus Reset and Incoming Mailbox
3240: Loaded Interrupts. Command Complete Interrupts are noted,
3241: and Outgoing Mailbox Available Interrupts are ignored, as
3242: they are never enabled.
3243: */
3244: if (InterruptRegister.Bits.ExternalBusReset)
3245: HostAdapter->HostAdapterExternalReset = true;
3246: else if (InterruptRegister.Bits.IncomingMailboxLoaded)
3247: BusLogic_ScanIncomingMailboxes(HostAdapter);
3248: else if (InterruptRegister.Bits.CommandComplete)
3249: HostAdapter->HostAdapterCommandCompleted = true;
3250: }
3251: }
3252: else
3253: {
3254: /*
3255: Check if there is a pending interrupt for this Host Adapter.
3256: */
3257: if (FlashPoint_InterruptPending(HostAdapter->CardHandle))
3258: switch (FlashPoint_HandleInterrupt(HostAdapter->CardHandle))
3259: {
3260: case FlashPoint_NormalInterrupt:
3261: break;
3262: case FlashPoint_ExternalBusReset:
3263: HostAdapter->HostAdapterExternalReset = true;
3264: break;
3265: case FlashPoint_InternalError:
3266: BusLogic_Warning("Internal FlashPoint Error detected"
3267: " - Resetting Host Adapter\n", HostAdapter);
3268: HostAdapter->HostAdapterInternalError = true;
3269: break;
3270: }
3271: }
3272: /*
3273: Process any completed CCBs.
3274: */
3275: if (HostAdapter->FirstCompletedCCB != NULL)
3276: BusLogic_ProcessCompletedCCBs(HostAdapter);
3277: /*
3278: Reset the Host Adapter if requested.
3279: */
3280: if (HostAdapter->HostAdapterExternalReset ||
3281: HostAdapter->HostAdapterInternalError)
3282: {
3283: BusLogic_ResetHostAdapter(HostAdapter, NULL, 0);
3284: HostAdapter->HostAdapterExternalReset = false;
3285: HostAdapter->HostAdapterInternalError = false;
3286: scsi_mark_host_reset(HostAdapter->SCSI_Host);
3287: }
3288: /*
3289: Release exclusive access to Host Adapter.
3290: */
3291: BusLogic_ReleaseHostAdapterLockIH(HostAdapter, &ProcessorFlags);
3292: }
3293:
3294:
3295: /*
3296: BusLogic_WriteOutgoingMailbox places CCB and Action Code into an Outgoing
3297: Mailbox for execution by Host Adapter. The Host Adapter's Lock should
3298: already have been acquired by the caller.
3299: */
3300:
3301: static boolean BusLogic_WriteOutgoingMailbox(BusLogic_HostAdapter_T
3302: *HostAdapter,
3303: BusLogic_ActionCode_T ActionCode,
3304: BusLogic_CCB_T *CCB)
3305: {
3306: BusLogic_OutgoingMailbox_T *NextOutgoingMailbox;
3307: NextOutgoingMailbox = HostAdapter->NextOutgoingMailbox;
3308: if (NextOutgoingMailbox->ActionCode == BusLogic_OutgoingMailboxFree)
3309: {
3310: CCB->Status = BusLogic_CCB_Active;
3311: /*
3312: The CCB field must be written before the Action Code field since
3313: the Host Adapter is operating asynchronously and the locking code
3314: does not protect against simultaneous access by the Host Adapter.
3315: */
3316: NextOutgoingMailbox->CCB = Virtual_to_Bus(CCB);
3317: NextOutgoingMailbox->ActionCode = ActionCode;
3318: BusLogic_StartMailboxCommand(HostAdapter);
3319: if (++NextOutgoingMailbox > HostAdapter->LastOutgoingMailbox)
3320: NextOutgoingMailbox = HostAdapter->FirstOutgoingMailbox;
3321: HostAdapter->NextOutgoingMailbox = NextOutgoingMailbox;
3322: if (ActionCode == BusLogic_MailboxStartCommand)
3323: {
3324: HostAdapter->ActiveCommands[CCB->TargetID]++;
3325: if (CCB->Opcode != BusLogic_BusDeviceReset)
3326: HostAdapter->TargetStatistics[CCB->TargetID].CommandsAttempted++;
3327: }
3328: return true;
3329: }
3330: return false;
3331: }
3332:
3333:
3334: /*
3335: BusLogic_QueueCommand creates a CCB for Command and places it into an
3336: Outgoing Mailbox for execution by the associated Host Adapter.
3337: */
3338:
3339: int BusLogic_QueueCommand(SCSI_Command_T *Command,
3340: void (*CompletionRoutine)(SCSI_Command_T *))
3341: {
3342: BusLogic_HostAdapter_T *HostAdapter =
3343: (BusLogic_HostAdapter_T *) Command->host->hostdata;
3344: BusLogic_TargetFlags_T *TargetFlags =
3345: &HostAdapter->TargetFlags[Command->target];
3346: BusLogic_TargetStatistics_T *TargetStatistics =
3347: HostAdapter->TargetStatistics;
3348: unsigned char *CDB = Command->cmnd;
3349: int CDB_Length = Command->cmd_len;
3350: int TargetID = Command->target;
3351: int LogicalUnit = Command->lun;
3352: void *BufferPointer = Command->request_buffer;
3353: int BufferLength = Command->request_bufflen;
3354: int SegmentCount = Command->use_sg;
3355: ProcessorFlags_T ProcessorFlags;
3356: BusLogic_CCB_T *CCB;
3357: /*
3358: SCSI REQUEST_SENSE commands will be executed automatically by the Host
3359: Adapter for any errors, so they should not be executed explicitly unless
3360: the Sense Data is zero indicating that no error occurred.
3361: */
3362: if (CDB[0] == REQUEST_SENSE && Command->sense_buffer[0] != 0)
3363: {
3364: Command->result = DID_OK << 16;
3365: CompletionRoutine(Command);
3366: return 0;
3367: }
3368: /*
3369: Acquire exclusive access to Host Adapter.
3370: */
3371: BusLogic_AcquireHostAdapterLock(HostAdapter, &ProcessorFlags);
3372: /*
3373: Allocate a CCB from the Host Adapter's free list. In the unlikely event
3374: that there are none available and memory allocation fails, wait 1 second
3375: and try again. If that fails, the Host Adapter is probably hung so signal
3376: an error as a Host Adapter Hard Reset should be initiated soon.
3377: */
3378: CCB = BusLogic_AllocateCCB(HostAdapter);
3379: if (CCB == NULL)
3380: {
3381: BusLogic_Delay(1);
3382: CCB = BusLogic_AllocateCCB(HostAdapter);
3383: if (CCB == NULL)
3384: {
3385: Command->result = DID_ERROR << 16;
3386: CompletionRoutine(Command);
3387: goto Done;
3388: }
3389: }
3390: /*
3391: Initialize the fields in the BusLogic Command Control Block (CCB).
3392: */
3393: if (SegmentCount == 0)
3394: {
3395: CCB->Opcode = BusLogic_InitiatorCCB;
3396: CCB->DataLength = BufferLength;
3397: CCB->DataPointer = Virtual_to_Bus(BufferPointer);
3398: }
3399: else
3400: {
3401: SCSI_ScatterList_T *ScatterList = (SCSI_ScatterList_T *) BufferPointer;
3402: int Segment;
3403: CCB->Opcode = BusLogic_InitiatorCCB_ScatterGather;
3404: CCB->DataLength = SegmentCount * sizeof(BusLogic_ScatterGatherSegment_T);
3405: if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
3406: CCB->DataPointer = Virtual_to_Bus(CCB->ScatterGatherList);
3407: else CCB->DataPointer = Virtual_to_32Bit_Virtual(CCB->ScatterGatherList);
3408: for (Segment = 0; Segment < SegmentCount; Segment++)
3409: {
3410: CCB->ScatterGatherList[Segment].SegmentByteCount =
3411: ScatterList[Segment].length;
3412: CCB->ScatterGatherList[Segment].SegmentDataPointer =
3413: Virtual_to_Bus(ScatterList[Segment].address);
3414: }
3415: }
3416: switch (CDB[0])
3417: {
3418: case READ_6:
3419: case READ_10:
3420: CCB->DataDirection = BusLogic_DataInLengthChecked;
3421: TargetStatistics[TargetID].ReadCommands++;
3422: BusLogic_IncrementByteCounter(
3423: &TargetStatistics[TargetID].TotalBytesRead, BufferLength);
3424: BusLogic_IncrementSizeBucket(
3425: TargetStatistics[TargetID].ReadCommandSizeBuckets, BufferLength);
3426: break;
3427: case WRITE_6:
3428: case WRITE_10:
3429: CCB->DataDirection = BusLogic_DataOutLengthChecked;
3430: TargetStatistics[TargetID].WriteCommands++;
3431: BusLogic_IncrementByteCounter(
3432: &TargetStatistics[TargetID].TotalBytesWritten, BufferLength);
3433: BusLogic_IncrementSizeBucket(
3434: TargetStatistics[TargetID].WriteCommandSizeBuckets, BufferLength);
3435: break;
3436: default:
3437: CCB->DataDirection = BusLogic_UncheckedDataTransfer;
3438: break;
3439: }
3440: CCB->CDB_Length = CDB_Length;
3441: CCB->SenseDataLength = sizeof(Command->sense_buffer);
3442: CCB->HostAdapterStatus = 0;
3443: CCB->TargetDeviceStatus = 0;
3444: CCB->TargetID = TargetID;
3445: CCB->LogicalUnit = LogicalUnit;
3446: CCB->TagEnable = false;
3447: CCB->LegacyTagEnable = false;
3448: /*
3449: BusLogic recommends that after a Reset the first couple of commands that
3450: are sent to a Target Device be sent in a non Tagged Queue fashion so that
3451: the Host Adapter and Target Device can establish Synchronous and Wide
3452: Transfer before Queue Tag messages can interfere with the Synchronous and
3453: Wide Negotiation messages. By waiting to enable Tagged Queuing until after
3454: the first BusLogic_MaxTaggedQueueDepth commands have been queued, it is
3455: assured that after a Reset any pending commands are requeued before Tagged
3456: Queuing is enabled and that the Tagged Queuing message will not occur while
3457: the partition table is being printed. In addition, some devices do not
3458: properly handle the transition from non-tagged to tagged commands, so it is
3459: necessary to wait until there are no pending commands for a target device
3460: before queuing tagged commands.
3461: */
3462: if (HostAdapter->CommandsSinceReset[TargetID]++ >=
3463: BusLogic_MaxTaggedQueueDepth &&
3464: !TargetFlags->TaggedQueuingActive &&
3465: HostAdapter->ActiveCommands[TargetID] == 0 &&
3466: TargetFlags->TaggedQueuingSupported &&
3467: (HostAdapter->TaggedQueuingPermitted & (1 << TargetID)))
3468: {
3469: TargetFlags->TaggedQueuingActive = true;
3470: BusLogic_Notice("Tagged Queuing now active for Target %d\n",
3471: HostAdapter, TargetID);
3472: }
3473: if (TargetFlags->TaggedQueuingActive)
3474: {
3475: BusLogic_QueueTag_T QueueTag = BusLogic_SimpleQueueTag;
3476: /*
3477: When using Tagged Queuing with Simple Queue Tags, it appears that disk
3478: drive controllers do not guarantee that a queued command will not
3479: remain in a disconnected state indefinitely if commands that read or
3480: write nearer the head position continue to arrive without interruption.
3481: Therefore, for each Target Device this driver keeps track of the last
3482: time either the queue was empty or an Ordered Queue Tag was issued. If
3483: more than 4 seconds (one fifth of the 20 second disk timeout) have
3484: elapsed since this last sequence point, this command will be issued
3485: with an Ordered Queue Tag rather than a Simple Queue Tag, which forces
3486: the Target Device to complete all previously queued commands before
3487: this command may be executed.
3488: */
3489: if (HostAdapter->ActiveCommands[TargetID] == 0)
3490: HostAdapter->LastSequencePoint[TargetID] = jiffies;
3491: else if (jiffies - HostAdapter->LastSequencePoint[TargetID] > 4*HZ)
3492: {
3493: HostAdapter->LastSequencePoint[TargetID] = jiffies;
3494: QueueTag = BusLogic_OrderedQueueTag;
3495: }
3496: if (HostAdapter->ExtendedLUNSupport)
3497: {
3498: CCB->TagEnable = true;
3499: CCB->QueueTag = QueueTag;
3500: }
3501: else
3502: {
3503: CCB->LegacyTagEnable = true;
3504: CCB->LegacyQueueTag = QueueTag;
3505: }
3506: }
3507: memcpy(CCB->CDB, CDB, CDB_Length);
3508: CCB->SenseDataPointer = Virtual_to_Bus(&Command->sense_buffer);
3509: CCB->Command = Command;
3510: Command->scsi_done = CompletionRoutine;
3511: if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
3512: {
3513: /*
3514: Place the CCB in an Outgoing Mailbox. The higher levels of the SCSI
3515: Subsystem should not attempt to queue more commands than can be placed
3516: in Outgoing Mailboxes, so there should always be one free. In the
3517: unlikely event that there are none available, wait 1 second and try
3518: again. If that fails, the Host Adapter is probably hung so signal an
3519: error as a Host Adapter Hard Reset should be initiated soon.
3520: */
3521: if (!BusLogic_WriteOutgoingMailbox(
3522: HostAdapter, BusLogic_MailboxStartCommand, CCB))
3523: {
3524: BusLogic_Warning("Unable to write Outgoing Mailbox - "
3525: "Pausing for 1 second\n", HostAdapter);
3526: BusLogic_Delay(1);
3527: if (!BusLogic_WriteOutgoingMailbox(
3528: HostAdapter, BusLogic_MailboxStartCommand, CCB))
3529: {
3530: BusLogic_Warning("Still unable to write Outgoing Mailbox - "
3531: "Host Adapter Dead?\n", HostAdapter);
3532: BusLogic_DeallocateCCB(CCB);
3533: Command->result = DID_ERROR << 16;
3534: Command->scsi_done(Command);
3535: }
3536: }
3537: }
3538: else
3539: {
3540: /*
3541: Call the FlashPoint SCCB Manager to start execution of the CCB.
3542: */
3543: CCB->Status = BusLogic_CCB_Active;
3544: HostAdapter->ActiveCommands[TargetID]++;
3545: TargetStatistics[TargetID].CommandsAttempted++;
3546: FlashPoint_StartCCB(HostAdapter->CardHandle, CCB);
3547: /*
3548: The Command may have already completed and BusLogic_QueueCompletedCCB
3549: been called, or it may still be pending.
3550: */
3551: if (CCB->Status == BusLogic_CCB_Completed)
3552: BusLogic_ProcessCompletedCCBs(HostAdapter);
3553: }
3554: /*
3555: Release exclusive access to Host Adapter.
3556: */
3557: Done:
3558: BusLogic_ReleaseHostAdapterLock(HostAdapter, &ProcessorFlags);
3559: return 0;
3560: }
3561:
3562:
3563: /*
3564: BusLogic_AbortCommand aborts Command if possible.
3565: */
3566:
3567: int BusLogic_AbortCommand(SCSI_Command_T *Command)
3568: {
3569: BusLogic_HostAdapter_T *HostAdapter =
3570: (BusLogic_HostAdapter_T *) Command->host->hostdata;
3571: int TargetID = Command->target;
3572: ProcessorFlags_T ProcessorFlags;
3573: BusLogic_CCB_T *CCB;
3574: int Result;
3575: BusLogic_IncrementErrorCounter(
3576: &HostAdapter->TargetStatistics[TargetID].CommandAbortsRequested);
3577: /*
3578: Acquire exclusive access to Host Adapter.
3579: */
3580: BusLogic_AcquireHostAdapterLock(HostAdapter, &ProcessorFlags);
3581: /*
3582: If this Command has already completed, then no Abort is necessary.
3583: */
3584: if (Command->serial_number != Command->serial_number_at_timeout)
3585: {
3586: BusLogic_Warning("Unable to Abort Command to Target %d - "
3587: "Already Completed\n", HostAdapter, TargetID);
3588: Result = SCSI_ABORT_NOT_RUNNING;
3589: goto Done;
3590: }
3591: /*
3592: Attempt to find an Active CCB for this Command. If no Active CCB for this
3593: Command is found, then no Abort is necessary.
3594: */
3595: for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
3596: if (CCB->Command == Command) break;
3597: if (CCB == NULL)
3598: {
3599: BusLogic_Warning("Unable to Abort Command to Target %d - "
3600: "No CCB Found\n", HostAdapter, TargetID);
3601: Result = SCSI_ABORT_NOT_RUNNING;
3602: goto Done;
3603: }
3604: else if (CCB->Status == BusLogic_CCB_Completed)
3605: {
3606: BusLogic_Warning("Unable to Abort Command to Target %d - "
3607: "CCB Completed\n", HostAdapter, TargetID);
3608: Result = SCSI_ABORT_NOT_RUNNING;
3609: goto Done;
3610: }
3611: else if (CCB->Status == BusLogic_CCB_Reset)
3612: {
3613: BusLogic_Warning("Unable to Abort Command to Target %d - "
3614: "CCB Reset\n", HostAdapter, TargetID);
3615: Result = SCSI_ABORT_PENDING;
3616: goto Done;
3617: }
3618: if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
3619: {
3620: /*
3621: Attempt to Abort this CCB. MultiMaster Firmware versions prior to 5.xx
3622: do not generate Abort Tag messages, but only generate the non-tagged
3623: Abort message. Since non-tagged commands are not sent by the Host
3624: Adapter until the queue of outstanding tagged commands has completed,
3625: and the Abort message is treated as a non-tagged command, it is
3626: effectively impossible to abort commands when Tagged Queuing is active.
3627: Firmware version 5.xx does generate Abort Tag messages, so it is
3628: possible to abort commands when Tagged Queuing is active.
3629: */
3630: if (HostAdapter->TargetFlags[TargetID].TaggedQueuingActive &&
3631: HostAdapter->FirmwareVersion[0] < '5')
3632: {
3633: BusLogic_Warning("Unable to Abort CCB #%ld to Target %d - "
3634: "Abort Tag Not Supported\n",
3635: HostAdapter, CCB->SerialNumber, TargetID);
3636: Result = SCSI_ABORT_SNOOZE;
3637: }
3638: else if (BusLogic_WriteOutgoingMailbox(
3639: HostAdapter, BusLogic_MailboxAbortCommand, CCB))
3640: {
3641: BusLogic_Warning("Aborting CCB #%ld to Target %d\n",
3642: HostAdapter, CCB->SerialNumber, TargetID);
3643: BusLogic_IncrementErrorCounter(
3644: &HostAdapter->TargetStatistics[TargetID].CommandAbortsAttempted);
3645: Result = SCSI_ABORT_PENDING;
3646: }
3647: else
3648: {
3649: BusLogic_Warning("Unable to Abort CCB #%ld to Target %d - "
3650: "No Outgoing Mailboxes\n",
3651: HostAdapter, CCB->SerialNumber, TargetID);
3652: Result = SCSI_ABORT_BUSY;
3653: }
3654: }
3655: else
3656: {
3657: /*
3658: Call the FlashPoint SCCB Manager to abort execution of the CCB.
3659: */
3660: BusLogic_Warning("Aborting CCB #%ld to Target %d\n",
3661: HostAdapter, CCB->SerialNumber, TargetID);
3662: BusLogic_IncrementErrorCounter(
3663: &HostAdapter->TargetStatistics[TargetID].CommandAbortsAttempted);
3664: FlashPoint_AbortCCB(HostAdapter->CardHandle, CCB);
3665: /*
3666: The Abort may have already been completed and
3667: BusLogic_QueueCompletedCCB been called, or it
3668: may still be pending.
3669: */
3670: Result = SCSI_ABORT_PENDING;
3671: if (CCB->Status == BusLogic_CCB_Completed)
3672: {
3673: BusLogic_ProcessCompletedCCBs(HostAdapter);
3674: Result = SCSI_ABORT_SUCCESS;
3675: }
3676: }
3677: /*
3678: Release exclusive access to Host Adapter.
3679: */
3680: Done:
3681: BusLogic_ReleaseHostAdapterLock(HostAdapter, &ProcessorFlags);
3682: return Result;
3683: }
3684:
3685:
3686: /*
3687: BusLogic_ResetHostAdapter resets Host Adapter if possible, marking all
3688: currently executing SCSI Commands as having been Reset.
3689: */
3690:
3691: static int BusLogic_ResetHostAdapter(BusLogic_HostAdapter_T *HostAdapter,
3692: SCSI_Command_T *Command,
3693: unsigned int ResetFlags)
3694: {
3695: ProcessorFlags_T ProcessorFlags;
3696: BusLogic_CCB_T *CCB;
3697: int TargetID, Result;
3698: boolean HardReset;
3699: if (HostAdapter->HostAdapterExternalReset)
3700: {
3701: BusLogic_IncrementErrorCounter(&HostAdapter->ExternalHostAdapterResets);
3702: HardReset = false;
3703: }
3704: else if (HostAdapter->HostAdapterInternalError)
3705: {
3706: BusLogic_IncrementErrorCounter(&HostAdapter->HostAdapterInternalErrors);
3707: HardReset = true;
3708: }
3709: else
3710: {
3711: BusLogic_IncrementErrorCounter(
3712: &HostAdapter->TargetStatistics[Command->target]
3713: .HostAdapterResetsRequested);
3714: HardReset = true;
3715: }
3716: /*
3717: Acquire exclusive access to Host Adapter.
3718: */
3719: BusLogic_AcquireHostAdapterLock(HostAdapter, &ProcessorFlags);
3720: /*
3721: If this is an Asynchronous Reset and this Command has already completed,
3722: then no Reset is necessary.
3723: */
3724: if (ResetFlags & SCSI_RESET_ASYNCHRONOUS)
3725: {
3726: TargetID = Command->target;
3727: if (Command->serial_number != Command->serial_number_at_timeout)
3728: {
3729: BusLogic_Warning("Unable to Reset Command to Target %d - "
3730: "Already Completed or Reset\n",
3731: HostAdapter, TargetID);
3732: Result = SCSI_RESET_NOT_RUNNING;
3733: goto Done;
3734: }
3735: for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
3736: if (CCB->Command == Command) break;
3737: if (CCB == NULL)
3738: {
3739: BusLogic_Warning("Unable to Reset Command to Target %d - "
3740: "No CCB Found\n", HostAdapter, TargetID);
3741: Result = SCSI_RESET_NOT_RUNNING;
3742: goto Done;
3743: }
3744: else if (CCB->Status == BusLogic_CCB_Completed)
3745: {
3746: BusLogic_Warning("Unable to Reset Command to Target %d - "
3747: "CCB Completed\n", HostAdapter, TargetID);
3748: Result = SCSI_RESET_NOT_RUNNING;
3749: goto Done;
3750: }
3751: else if (CCB->Status == BusLogic_CCB_Reset &&
3752: HostAdapter->BusDeviceResetPendingCCB[TargetID] == NULL)
3753: {
3754: BusLogic_Warning("Unable to Reset Command to Target %d - "
3755: "Reset Pending\n", HostAdapter, TargetID);
3756: Result = SCSI_RESET_PENDING;
3757: goto Done;
3758: }
3759: }
3760: if (Command == NULL)
3761: {
3762: if (HostAdapter->HostAdapterInternalError)
3763: BusLogic_Warning("Resetting %s due to Host Adapter Internal Error\n",
3764: HostAdapter, HostAdapter->FullModelName);
3765: else BusLogic_Warning("Resetting %s due to External SCSI Bus Reset\n",
3766: HostAdapter, HostAdapter->FullModelName);
3767: }
3768: else
3769: {
3770: BusLogic_Warning("Resetting %s due to Target %d\n", HostAdapter,
3771: HostAdapter->FullModelName, Command->target);
3772: BusLogic_IncrementErrorCounter(
3773: &HostAdapter->TargetStatistics[Command->target]
3774: .HostAdapterResetsAttempted);
3775: }
3776: /*
3777: Attempt to Reset and Reinitialize the Host Adapter.
3778: */
3779: if (!(BusLogic_HardwareResetHostAdapter(HostAdapter, HardReset) &&
3780: BusLogic_InitializeHostAdapter(HostAdapter)))
3781: {
3782: BusLogic_Error("Resetting %s Failed\n", HostAdapter,
3783: HostAdapter->FullModelName);
3784: Result = SCSI_RESET_ERROR;
3785: goto Done;
3786: }
3787: if (Command != NULL)
3788: BusLogic_IncrementErrorCounter(
3789: &HostAdapter->TargetStatistics[Command->target]
3790: .HostAdapterResetsCompleted);
3791: /*
3792: Mark all currently executing CCBs as having been Reset.
3793: */
3794: for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
3795: if (CCB->Status == BusLogic_CCB_Active)
3796: CCB->Status = BusLogic_CCB_Reset;
3797: /*
3798: Wait a few seconds between the Host Adapter Hard Reset which initiates
3799: a SCSI Bus Reset and issuing any SCSI Commands. Some SCSI devices get
3800: confused if they receive SCSI Commands too soon after a SCSI Bus Reset.
3801: Note that a timer interrupt may occur here, but all active CCBs have
3802: already been marked Reset and so a reentrant call will return Pending.
3803: */
3804: if (HardReset)
3805: BusLogic_Delay(HostAdapter->BusSettleTime);
3806: /*
3807: If this is a Synchronous Reset, perform completion processing for
3808: the Command being Reset.
3809: */
3810: if (ResetFlags & SCSI_RESET_SYNCHRONOUS)
3811: {
3812: Command->result = DID_RESET << 16;
3813: Command->scsi_done(Command);
3814: }
3815: /*
3816: Perform completion processing for all CCBs marked as Reset.
3817: */
3818: for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
3819: if (CCB->Status == BusLogic_CCB_Reset)
3820: {
3821: Command = CCB->Command;
3822: BusLogic_DeallocateCCB(CCB);
3823: while (Command != NULL)
3824: {
3825: SCSI_Command_T *NextCommand = Command->reset_chain;
3826: Command->reset_chain = NULL;
3827: Command->result = DID_RESET << 16;
3828: Command->scsi_done(Command);
3829: Command = NextCommand;
3830: }
3831: }
3832: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
3833: {
3834: HostAdapter->LastResetAttempted[TargetID] = jiffies;
3835: HostAdapter->LastResetCompleted[TargetID] = jiffies;
3836: }
3837: Result = SCSI_RESET_SUCCESS | SCSI_RESET_HOST_RESET;
3838: /*
3839: Release exclusive access to Host Adapter.
3840: */
3841: Done:
3842: BusLogic_ReleaseHostAdapterLock(HostAdapter, &ProcessorFlags);
3843: return Result;
3844: }
3845:
3846:
3847: /*
3848: BusLogic_SendBusDeviceReset sends a Bus Device Reset to the Target
3849: Device associated with Command.
3850: */
3851:
3852: static int BusLogic_SendBusDeviceReset(BusLogic_HostAdapter_T *HostAdapter,
3853: SCSI_Command_T *Command,
3854: unsigned int ResetFlags)
3855: {
3856: int TargetID = Command->target;
3857: BusLogic_CCB_T *CCB, *XCCB;
3858: ProcessorFlags_T ProcessorFlags;
3859: int Result = -1;
3860: BusLogic_IncrementErrorCounter(
3861: &HostAdapter->TargetStatistics[TargetID].BusDeviceResetsRequested);
3862: /*
3863: Acquire exclusive access to Host Adapter.
3864: */
3865: BusLogic_AcquireHostAdapterLock(HostAdapter, &ProcessorFlags);
3866: /*
3867: If this is an Asynchronous Reset and this Command has already completed,
3868: then no Reset is necessary.
3869: */
3870: if (ResetFlags & SCSI_RESET_ASYNCHRONOUS)
3871: {
3872: if (Command->serial_number != Command->serial_number_at_timeout)
3873: {
3874: BusLogic_Warning("Unable to Reset Command to Target %d - "
3875: "Already Completed\n", HostAdapter, TargetID);
3876: Result = SCSI_RESET_NOT_RUNNING;
3877: goto Done;
3878: }
3879: for (CCB = HostAdapter->All_CCBs; CCB != NULL; CCB = CCB->NextAll)
3880: if (CCB->Command == Command) break;
3881: if (CCB == NULL)
3882: {
3883: BusLogic_Warning("Unable to Reset Command to Target %d - "
3884: "No CCB Found\n", HostAdapter, TargetID);
3885: Result = SCSI_RESET_NOT_RUNNING;
3886: goto Done;
3887: }
3888: else if (CCB->Status == BusLogic_CCB_Completed)
3889: {
3890: BusLogic_Warning("Unable to Reset Command to Target %d - "
3891: "CCB Completed\n", HostAdapter, TargetID);
3892: Result = SCSI_RESET_NOT_RUNNING;
3893: goto Done;
3894: }
3895: else if (CCB->Status == BusLogic_CCB_Reset)
3896: {
3897: BusLogic_Warning("Unable to Reset Command to Target %d - "
3898: "Reset Pending\n", HostAdapter, TargetID);
3899: Result = SCSI_RESET_PENDING;
3900: goto Done;
3901: }
3902: else if (HostAdapter->BusDeviceResetPendingCCB[TargetID] != NULL)
3903: {
3904: BusLogic_Warning("Bus Device Reset already pending to Target %d\n",
3905: HostAdapter, TargetID);
3906: goto Done;
3907: }
3908: }
3909: /*
3910: If this is a Synchronous Reset and a Bus Device Reset is already pending
3911: for this Target Device, do not send a second one. Add this Command to
3912: the list of Commands for which completion processing must be performed
3913: when the Bus Device Reset CCB completes.
3914: */
3915: if (ResetFlags & SCSI_RESET_SYNCHRONOUS)
3916: if ((CCB = HostAdapter->BusDeviceResetPendingCCB[TargetID]) != NULL)
3917: {
3918: Command->reset_chain = CCB->Command;
3919: CCB->Command = Command;
3920: BusLogic_Warning("Unable to Reset Command to Target %d - "
3921: "Reset Pending\n", HostAdapter, TargetID);
3922: Result = SCSI_RESET_PENDING;
3923: goto Done;
3924: }
3925: if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
3926: {
3927: /*
3928: MultiMaster Firmware versions prior to 5.xx treat a Bus Device Reset as
3929: a non-tagged command. Since non-tagged commands are not sent by the
3930: Host Adapter until the queue of outstanding tagged commands has
3931: completed, it is effectively impossible to send a Bus Device Reset
3932: while there are tagged commands outstanding. Therefore, in that case a
3933: full Host Adapter Hard Reset and SCSI Bus Reset must be done.
3934: */
3935: if (HostAdapter->TargetFlags[TargetID].TaggedQueuingActive &&
3936: HostAdapter->ActiveCommands[TargetID] > 0 &&
3937: HostAdapter->FirmwareVersion[0] < '5')
3938: goto Done;
3939: }
3940: /*
3941: Allocate a CCB from the Host Adapter's free list. In the unlikely event
3942: that there are none available and memory allocation fails, attempt a full
3943: Host Adapter Hard Reset and SCSI Bus Reset.
3944: */
3945: CCB = BusLogic_AllocateCCB(HostAdapter);
3946: if (CCB == NULL) goto Done;
3947: BusLogic_Warning("Sending Bus Device Reset CCB #%ld to Target %d\n",
3948: HostAdapter, CCB->SerialNumber, TargetID);
3949: CCB->Opcode = BusLogic_BusDeviceReset;
3950: CCB->TargetID = TargetID;
3951: /*
3952: For Synchronous Resets, arrange for the interrupt handler to perform
3953: completion processing for the Command being Reset.
3954: */
3955: if (ResetFlags & SCSI_RESET_SYNCHRONOUS)
3956: {
3957: Command->reset_chain = NULL;
3958: CCB->Command = Command;
3959: }
3960: if (BusLogic_MultiMasterHostAdapterP(HostAdapter))
3961: {
3962: /*
3963: Attempt to write an Outgoing Mailbox with the Bus Device Reset CCB.
3964: If sending a Bus Device Reset is impossible, attempt a full Host
3965: Adapter Hard Reset and SCSI Bus Reset.
3966: */
3967: if (!(BusLogic_WriteOutgoingMailbox(
3968: HostAdapter, BusLogic_MailboxStartCommand, CCB)))
3969: {
3970: BusLogic_Warning("Unable to write Outgoing Mailbox for "
3971: "Bus Device Reset\n", HostAdapter);
3972: BusLogic_DeallocateCCB(CCB);
3973: goto Done;
3974: }
3975: }
3976: else
3977: {
3978: /*
3979: Call the FlashPoint SCCB Manager to start execution of the CCB.
3980: */
3981: CCB->Status = BusLogic_CCB_Active;
3982: HostAdapter->ActiveCommands[TargetID]++;
3983: FlashPoint_StartCCB(HostAdapter->CardHandle, CCB);
3984: }
3985: /*
3986: If there is a currently executing CCB in the Host Adapter for this Command
3987: (i.e. this is an Asynchronous Reset), then an Incoming Mailbox entry may be
3988: made with a completion code of BusLogic_HostAdapterAssertedBusDeviceReset.
3989: If there is no active CCB for this Command (i.e. this is a Synchronous
3990: Reset), then the Bus Device Reset CCB's Command field will have been set
3991: to the Command so that the interrupt for the completion of the Bus Device
3992: Reset can call the Completion Routine for the Command. On successful
3993: execution of a Bus Device Reset, older firmware versions did return the
3994: pending CCBs with the appropriate completion code, but more recent firmware
3995: versions only return the Bus Device Reset CCB itself. This driver handles
3996: both cases by marking all the currently executing CCBs to this Target
3997: Device as Reset. When the Bus Device Reset CCB is processed by the
3998: interrupt handler, any remaining CCBs marked as Reset will have completion
3999: processing performed.
4000: */
4001: BusLogic_IncrementErrorCounter(
4002: &HostAdapter->TargetStatistics[TargetID].BusDeviceResetsAttempted);
4003: HostAdapter->BusDeviceResetPendingCCB[TargetID] = CCB;
4004: HostAdapter->LastResetAttempted[TargetID] = jiffies;
4005: for (XCCB = HostAdapter->All_CCBs; XCCB != NULL; XCCB = XCCB->NextAll)
4006: if (XCCB->Status == BusLogic_CCB_Active && XCCB->TargetID == TargetID)
4007: XCCB->Status = BusLogic_CCB_Reset;
4008: /*
4009: FlashPoint Host Adapters may have already completed the Bus Device
4010: Reset and BusLogic_QueueCompletedCCB been called, or it may still be
4011: pending.
4012: */
4013: Result = SCSI_RESET_PENDING;
4014: if (BusLogic_FlashPointHostAdapterP(HostAdapter))
4015: if (CCB->Status == BusLogic_CCB_Completed)
4016: {
4017: BusLogic_ProcessCompletedCCBs(HostAdapter);
4018: Result = SCSI_RESET_SUCCESS;
4019: }
4020: /*
4021: If a Bus Device Reset was not possible for some reason, force a full
4022: Host Adapter Hard Reset and SCSI Bus Reset.
4023: */
4024: Done:
4025: if (Result < 0)
4026: Result = BusLogic_ResetHostAdapter(HostAdapter, Command, ResetFlags);
4027: /*
4028: Release exclusive access to Host Adapter.
4029: */
4030: BusLogic_ReleaseHostAdapterLock(HostAdapter, &ProcessorFlags);
4031: return Result;
4032: }
4033:
4034:
4035: /*
4036: BusLogic_ResetCommand takes appropriate action to reset Command.
4037: */
4038:
4039: int BusLogic_ResetCommand(SCSI_Command_T *Command, unsigned int ResetFlags)
4040: {
4041: BusLogic_HostAdapter_T *HostAdapter =
4042: (BusLogic_HostAdapter_T *) Command->host->hostdata;
4043: int TargetID = Command->target;
4044: BusLogic_ErrorRecoveryStrategy_T
4045: ErrorRecoveryStrategy = HostAdapter->ErrorRecoveryStrategy[TargetID];
4046: /*
4047: Disable Tagged Queuing if it is active for this Target Device and if
4048: it has been less than 10 minutes since the last reset occurred, or since
4049: the system was initialized if no prior resets have occurred.
4050: */
4051: if (HostAdapter->TargetFlags[TargetID].TaggedQueuingActive &&
4052: jiffies - HostAdapter->LastResetCompleted[TargetID] < 10*60*HZ)
4053: {
4054: HostAdapter->TaggedQueuingPermitted &= ~(1 << TargetID);
4055: HostAdapter->TargetFlags[TargetID].TaggedQueuingActive = false;
4056: BusLogic_Warning("Tagged Queuing now disabled for Target %d\n",
4057: HostAdapter, TargetID);
4058: }
4059: switch (ErrorRecoveryStrategy)
4060: {
4061: case BusLogic_ErrorRecovery_Default:
4062: if (ResetFlags & SCSI_RESET_SUGGEST_HOST_RESET)
4063: return BusLogic_ResetHostAdapter(HostAdapter, Command, ResetFlags);
4064: else if (ResetFlags & SCSI_RESET_SUGGEST_BUS_RESET)
4065: return BusLogic_ResetHostAdapter(HostAdapter, Command, ResetFlags);
4066: /* Fall through to Bus Device Reset case. */
4067: case BusLogic_ErrorRecovery_BusDeviceReset:
4068: /*
4069: The Bus Device Reset Error Recovery Strategy only graduates to a Hard
4070: Reset when no commands have completed successfully since the last Bus
4071: Device Reset and it has been at least 100 milliseconds. This prevents
4072: a sequence of commands that all timeout together from immediately
4073: forcing a Hard Reset before the Bus Device Reset has had a chance to
4074: clear the error condition.
4075: */
4076: if (HostAdapter->TargetFlags[TargetID].CommandSuccessfulFlag ||
4077: jiffies - HostAdapter->LastResetAttempted[TargetID] < HZ/10)
4078: {
4079: HostAdapter->TargetFlags[TargetID].CommandSuccessfulFlag = false;
4080: return BusLogic_SendBusDeviceReset(HostAdapter, Command, ResetFlags);
4081: }
4082: /* Fall through to Hard Reset case. */
4083: case BusLogic_ErrorRecovery_HardReset:
4084: return BusLogic_ResetHostAdapter(HostAdapter, Command, ResetFlags);
4085: case BusLogic_ErrorRecovery_None:
4086: BusLogic_Warning("Error Recovery for Target %d Suppressed\n",
4087: HostAdapter, TargetID);
4088: break;
4089: }
4090: return SCSI_RESET_PUNT;
4091: }
4092:
4093:
4094: /*
4095: BusLogic_BIOSDiskParameters returns the Heads/Sectors/Cylinders BIOS Disk
4096: Parameters for Disk. The default disk geometry is 64 heads, 32 sectors, and
4097: the appropriate number of cylinders so as not to exceed drive capacity. In
4098: order for disks equal to or larger than 1 GB to be addressable by the BIOS
4099: without exceeding the BIOS limitation of 1024 cylinders, Extended Translation
4100: may be enabled in AutoSCSI on FlashPoint Host Adapters and on "W" and "C"
4101: series MultiMaster Host Adapters, or by a dip switch setting on "S" and "A"
4102: series MultiMaster Host Adapters. With Extended Translation enabled, drives
4103: between 1 GB inclusive and 2 GB exclusive are given a disk geometry of 128
4104: heads and 32 sectors, and drives above 2 GB inclusive are given a disk
4105: geometry of 255 heads and 63 sectors. However, if the BIOS detects that the
4106: Extended Translation setting does not match the geometry in the partition
4107: table, then the translation inferred from the partition table will be used by
4108: the BIOS, and a warning may be displayed.
4109: */
4110:
4111: int BusLogic_BIOSDiskParameters(SCSI_Disk_T *Disk, KernelDevice_T Device,
4112: int *Parameters)
4113: {
4114: BusLogic_HostAdapter_T *HostAdapter =
4115: (BusLogic_HostAdapter_T *) Disk->device->host->hostdata;
4116: BIOS_DiskParameters_T *DiskParameters = (BIOS_DiskParameters_T *) Parameters;
4117: struct buffer_head *BufferHead;
4118: if (HostAdapter->ExtendedTranslationEnabled &&
4119: Disk->capacity >= 2*1024*1024 /* 1 GB in 512 byte sectors */)
4120: {
4121: if (Disk->capacity >= 4*1024*1024 /* 2 GB in 512 byte sectors */)
4122: {
4123: DiskParameters->Heads = 255;
4124: DiskParameters->Sectors = 63;
4125: }
4126: else
4127: {
4128: DiskParameters->Heads = 128;
4129: DiskParameters->Sectors = 32;
4130: }
4131: }
4132: else
4133: {
4134: DiskParameters->Heads = 64;
4135: DiskParameters->Sectors = 32;
4136: }
4137: DiskParameters->Cylinders =
4138: Disk->capacity / (DiskParameters->Heads * DiskParameters->Sectors);
4139: /*
4140: Attempt to read the first 1024 bytes from the disk device.
4141: */
4142: BufferHead = bread(MKDEV(MAJOR(Device), MINOR(Device) & ~0x0F), 0, 1024);
4143: if (BufferHead == NULL) return 0;
4144: /*
4145: If the boot sector partition table flag is valid, search for a partition
4146: table entry whose end_head matches one of the standard BusLogic geometry
4147: translations (64/32, 128/32, or 255/63).
4148: */
4149: if (*(unsigned short *) (BufferHead->b_data + 0x1FE) == 0xAA55)
4150: {
4151: PartitionTable_T *FirstPartitionEntry =
4152: (PartitionTable_T *) (BufferHead->b_data + 0x1BE);
4153: PartitionTable_T *PartitionEntry = FirstPartitionEntry;
4154: int SavedCylinders = DiskParameters->Cylinders, PartitionNumber;
4155: unsigned char PartitionEntryEndHead, PartitionEntryEndSector;
4156: for (PartitionNumber = 0; PartitionNumber < 4; PartitionNumber++)
4157: {
4158: PartitionEntryEndHead = PartitionEntry->end_head;
4159: PartitionEntryEndSector = PartitionEntry->end_sector & 0x3F;
4160: if (PartitionEntryEndHead == 64-1)
4161: {
4162: DiskParameters->Heads = 64;
4163: DiskParameters->Sectors = 32;
4164: break;
4165: }
4166: else if (PartitionEntryEndHead == 128-1)
4167: {
4168: DiskParameters->Heads = 128;
4169: DiskParameters->Sectors = 32;
4170: break;
4171: }
4172: else if (PartitionEntryEndHead == 255-1)
4173: {
4174: DiskParameters->Heads = 255;
4175: DiskParameters->Sectors = 63;
4176: break;
4177: }
4178: PartitionEntry++;
4179: }
4180: if (PartitionNumber == 4)
4181: {
4182: PartitionEntryEndHead = FirstPartitionEntry->end_head;
4183: PartitionEntryEndSector = FirstPartitionEntry->end_sector & 0x3F;
4184: }
4185: DiskParameters->Cylinders =
4186: Disk->capacity / (DiskParameters->Heads * DiskParameters->Sectors);
4187: if (PartitionNumber < 4 &&
4188: PartitionEntryEndSector == DiskParameters->Sectors)
4189: {
4190: if (DiskParameters->Cylinders != SavedCylinders)
4191: BusLogic_Warning("Adopting Geometry %d/%d from Partition Table\n",
4192: HostAdapter,
4193: DiskParameters->Heads, DiskParameters->Sectors);
4194: }
4195: else if (PartitionEntryEndHead > 0 || PartitionEntryEndSector > 0)
4196: {
4197: BusLogic_Warning("Warning: Partition Table appears to "
4198: "have Geometry %d/%d which is\n", HostAdapter,
4199: PartitionEntryEndHead + 1,
4200: PartitionEntryEndSector);
4201: BusLogic_Warning("not compatible with current BusLogic "
4202: "Host Adapter Geometry %d/%d\n", HostAdapter,
4203: DiskParameters->Heads, DiskParameters->Sectors);
4204: }
4205: }
4206: brelse(BufferHead);
4207: return 0;
4208: }
4209:
4210:
4211: /*
4212: BugLogic_ProcDirectoryInfo implements /proc/scsi/BusLogic/<N>.
4213: */
4214:
4215: int BusLogic_ProcDirectoryInfo(char *ProcBuffer, char **StartPointer,
4216: off_t Offset, int BytesAvailable,
4217: int HostNumber, int WriteFlag)
4218: {
4219: BusLogic_HostAdapter_T *HostAdapter;
4220: BusLogic_TargetStatistics_T *TargetStatistics;
4221: int TargetID, Length;
4222: char *Buffer;
4223: for (HostAdapter = BusLogic_FirstRegisteredHostAdapter;
4224: HostAdapter != NULL;
4225: HostAdapter = HostAdapter->Next)
4226: if (HostAdapter->HostNumber == HostNumber) break;
4227: if (HostAdapter == NULL)
4228: {
4229: BusLogic_Error("Cannot find Host Adapter for SCSI Host %d\n",
4230: NULL, HostNumber);
4231: return 0;
4232: }
4233: TargetStatistics = HostAdapter->TargetStatistics;
4234: if (WriteFlag)
4235: {
4236: HostAdapter->ExternalHostAdapterResets = 0;
4237: HostAdapter->HostAdapterInternalErrors = 0;
4238: memset(TargetStatistics, 0,
4239: BusLogic_MaxTargetDevices * sizeof(BusLogic_TargetStatistics_T));
4240: return 0;
4241: }
4242: Buffer = HostAdapter->MessageBuffer;
4243: Length = HostAdapter->MessageBufferLength;
4244: Length += sprintf(&Buffer[Length], "\n\
4245: Current Driver Queue Depth: %d\n\
4246: Currently Allocated CCBs: %d\n",
4247: HostAdapter->DriverQueueDepth,
4248: HostAdapter->AllocatedCCBs);
4249: Length += sprintf(&Buffer[Length], "\n\n\
4250: DATA TRANSFER STATISTICS\n\
4251: \n\
4252: Target Tagged Queuing Queue Depth Active Attempted Completed\n\
4253: ====== ============== =========== ====== ========= =========\n");
4254: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
4255: {
4256: BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
4257: if (!TargetFlags->TargetExists) continue;
4258: Length +=
4259: sprintf(&Buffer[Length], " %2d %s", TargetID,
4260: (TargetFlags->TaggedQueuingSupported
4261: ? (TargetFlags->TaggedQueuingActive
4262: ? " Active"
4263: : (HostAdapter->TaggedQueuingPermitted & (1 << TargetID)
4264: ? " Permitted" : " Disabled"))
4265: : "Not Supported"));
4266: Length += sprintf(&Buffer[Length],
4267: " %3d %3u %9u %9u\n",
4268: HostAdapter->QueueDepth[TargetID],
4269: HostAdapter->ActiveCommands[TargetID],
4270: TargetStatistics[TargetID].CommandsAttempted,
4271: TargetStatistics[TargetID].CommandsCompleted);
4272: }
4273: Length += sprintf(&Buffer[Length], "\n\
4274: Target Read Commands Write Commands Total Bytes Read Total Bytes Written\n\
4275: ====== ============= ============== =================== ===================\n");
4276: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
4277: {
4278: BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
4279: if (!TargetFlags->TargetExists) continue;
4280: Length +=
4281: sprintf(&Buffer[Length], " %2d %9u %9u", TargetID,
4282: TargetStatistics[TargetID].ReadCommands,
4283: TargetStatistics[TargetID].WriteCommands);
4284: if (TargetStatistics[TargetID].TotalBytesRead.Billions > 0)
4285: Length +=
4286: sprintf(&Buffer[Length], " %9u%09u",
4287: TargetStatistics[TargetID].TotalBytesRead.Billions,
4288: TargetStatistics[TargetID].TotalBytesRead.Units);
4289: else
4290: Length +=
4291: sprintf(&Buffer[Length], " %9u",
4292: TargetStatistics[TargetID].TotalBytesRead.Units);
4293: if (TargetStatistics[TargetID].TotalBytesWritten.Billions > 0)
4294: Length +=
4295: sprintf(&Buffer[Length], " %9u%09u\n",
4296: TargetStatistics[TargetID].TotalBytesWritten.Billions,
4297: TargetStatistics[TargetID].TotalBytesWritten.Units);
4298: else
4299: Length +=
4300: sprintf(&Buffer[Length], " %9u\n",
4301: TargetStatistics[TargetID].TotalBytesWritten.Units);
4302: }
4303: Length += sprintf(&Buffer[Length], "\n\
4304: Target Command 0-1KB 1-2KB 2-4KB 4-8KB 8-16KB\n\
4305: ====== ======= ========= ========= ========= ========= =========\n");
4306: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
4307: {
4308: BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
4309: if (!TargetFlags->TargetExists) continue;
4310: Length +=
4311: sprintf(&Buffer[Length],
4312: " %2d Read %9u %9u %9u %9u %9u\n", TargetID,
4313: TargetStatistics[TargetID].ReadCommandSizeBuckets[0],
4314: TargetStatistics[TargetID].ReadCommandSizeBuckets[1],
4315: TargetStatistics[TargetID].ReadCommandSizeBuckets[2],
4316: TargetStatistics[TargetID].ReadCommandSizeBuckets[3],
4317: TargetStatistics[TargetID].ReadCommandSizeBuckets[4]);
4318: Length +=
4319: sprintf(&Buffer[Length],
4320: " %2d Write %9u %9u %9u %9u %9u\n", TargetID,
4321: TargetStatistics[TargetID].WriteCommandSizeBuckets[0],
4322: TargetStatistics[TargetID].WriteCommandSizeBuckets[1],
4323: TargetStatistics[TargetID].WriteCommandSizeBuckets[2],
4324: TargetStatistics[TargetID].WriteCommandSizeBuckets[3],
4325: TargetStatistics[TargetID].WriteCommandSizeBuckets[4]);
4326: }
4327: Length += sprintf(&Buffer[Length], "\n\
4328: Target Command 16-32KB 32-64KB 64-128KB 128-256KB 256KB+\n\
4329: ====== ======= ========= ========= ========= ========= =========\n");
4330: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
4331: {
4332: BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
4333: if (!TargetFlags->TargetExists) continue;
4334: Length +=
4335: sprintf(&Buffer[Length],
4336: " %2d Read %9u %9u %9u %9u %9u\n", TargetID,
4337: TargetStatistics[TargetID].ReadCommandSizeBuckets[5],
4338: TargetStatistics[TargetID].ReadCommandSizeBuckets[6],
4339: TargetStatistics[TargetID].ReadCommandSizeBuckets[7],
4340: TargetStatistics[TargetID].ReadCommandSizeBuckets[8],
4341: TargetStatistics[TargetID].ReadCommandSizeBuckets[9]);
4342: Length +=
4343: sprintf(&Buffer[Length],
4344: " %2d Write %9u %9u %9u %9u %9u\n", TargetID,
4345: TargetStatistics[TargetID].WriteCommandSizeBuckets[5],
4346: TargetStatistics[TargetID].WriteCommandSizeBuckets[6],
4347: TargetStatistics[TargetID].WriteCommandSizeBuckets[7],
4348: TargetStatistics[TargetID].WriteCommandSizeBuckets[8],
4349: TargetStatistics[TargetID].WriteCommandSizeBuckets[9]);
4350: }
4351: Length += sprintf(&Buffer[Length], "\n\n\
4352: ERROR RECOVERY STATISTICS\n\
4353: \n\
4354: Command Aborts Bus Device Resets Host Adapter Resets\n\
4355: Target Requested Completed Requested Completed Requested Completed\n\
4356: ID \\\\\\\\ Attempted //// \\\\\\\\ Attempted //// \\\\\\\\ Attempted ////\n\
4357: ====== ===== ===== ===== ===== ===== ===== ===== ===== =====\n");
4358: for (TargetID = 0; TargetID < HostAdapter->MaxTargetDevices; TargetID++)
4359: {
4360: BusLogic_TargetFlags_T *TargetFlags = &HostAdapter->TargetFlags[TargetID];
4361: if (!TargetFlags->TargetExists) continue;
4362: Length +=
4363: sprintf(&Buffer[Length], "\
4364: %2d %5d %5d %5d %5d %5d %5d %5d %5d %5d\n", TargetID,
4365: TargetStatistics[TargetID].CommandAbortsRequested,
4366: TargetStatistics[TargetID].CommandAbortsAttempted,
4367: TargetStatistics[TargetID].CommandAbortsCompleted,
4368: TargetStatistics[TargetID].BusDeviceResetsRequested,
4369: TargetStatistics[TargetID].BusDeviceResetsAttempted,
4370: TargetStatistics[TargetID].BusDeviceResetsCompleted,
4371: TargetStatistics[TargetID].HostAdapterResetsRequested,
4372: TargetStatistics[TargetID].HostAdapterResetsAttempted,
4373: TargetStatistics[TargetID].HostAdapterResetsCompleted);
4374: }
4375: Length += sprintf(&Buffer[Length], "\nExternal Host Adapter Resets: %d\n",
4376: HostAdapter->ExternalHostAdapterResets);
4377: Length += sprintf(&Buffer[Length], "Host Adapter Internal Errors: %d\n",
4378: HostAdapter->HostAdapterInternalErrors);
4379: if (Length >= BusLogic_MessageBufferSize)
4380: BusLogic_Error("Message Buffer length %d exceeds size %d\n",
4381: HostAdapter, Length, BusLogic_MessageBufferSize);
4382: if ((Length -= Offset) <= 0) return 0;
4383: if (Length >= BytesAvailable) Length = BytesAvailable;
4384: *StartPointer = &HostAdapter->MessageBuffer[Offset];
4385: return Length;
4386: }
4387:
4388:
4389: /*
4390: BusLogic_Message prints Driver Messages.
4391: */
4392:
4393: static void BusLogic_Message(BusLogic_MessageLevel_T MessageLevel,
4394: char *Format,
4395: BusLogic_HostAdapter_T *HostAdapter,
4396: ...)
4397: {
4398: static char Buffer[BusLogic_LineBufferSize];
4399: static boolean BeginningOfLine = true;
4400: va_list Arguments;
4401: int Length = 0;
4402: va_start(Arguments, HostAdapter);
4403: Length = vsprintf(Buffer, Format, Arguments);
4404: va_end(Arguments);
4405: if (MessageLevel == BusLogic_AnnounceLevel)
4406: {
4407: static int AnnouncementLines = 0;
4408: strcpy(&HostAdapter->MessageBuffer[HostAdapter->MessageBufferLength],
4409: Buffer);
4410: HostAdapter->MessageBufferLength += Length;
4411: if (++AnnouncementLines <= 2)
4412: printk("%sscsi: %s", BusLogic_MessageLevelMap[MessageLevel], Buffer);
4413: }
4414: else if (MessageLevel == BusLogic_InfoLevel)
4415: {
4416: strcpy(&HostAdapter->MessageBuffer[HostAdapter->MessageBufferLength],
4417: Buffer);
4418: HostAdapter->MessageBufferLength += Length;
4419: if (BeginningOfLine)
4420: {
4421: if (Buffer[0] != '\n' || Length > 1)
4422: printk("%sscsi%d: %s", BusLogic_MessageLevelMap[MessageLevel],
4423: HostAdapter->HostNumber, Buffer);
4424: }
4425: else printk("%s", Buffer);
4426: }
4427: else
4428: {
4429: if (BeginningOfLine)
4430: {
4431: if (HostAdapter != NULL && HostAdapter->HostAdapterInitialized)
4432: printk("%sscsi%d: %s", BusLogic_MessageLevelMap[MessageLevel],
4433: HostAdapter->HostNumber, Buffer);
4434: else printk("%s%s", BusLogic_MessageLevelMap[MessageLevel], Buffer);
4435: }
4436: else printk("%s", Buffer);
4437: }
4438: BeginningOfLine = (Buffer[Length-1] == '\n');
4439: }
4440:
4441:
4442: /*
4443: BusLogic_ParseKeyword parses an individual option keyword. It returns true
4444: and updates the pointer if the keyword is recognized and false otherwise.
4445: */
4446:
4447: static boolean BusLogic_ParseKeyword(char **StringPointer, char *Keyword)
4448: {
4449: char *Pointer = *StringPointer;
4450: while (*Keyword != '\0')
4451: {
4452: char StringChar = *Pointer++;
4453: char KeywordChar = *Keyword++;
4454: if (StringChar >= 'A' && StringChar <= 'Z')
4455: StringChar += 'a' - 'Z';
4456: if (KeywordChar >= 'A' && KeywordChar <= 'Z')
4457: KeywordChar += 'a' - 'Z';
4458: if (StringChar != KeywordChar) return false;
4459: }
4460: *StringPointer = Pointer;
4461: return true;
4462: }
4463:
4464:
4465: /*
4466: BusLogic_ParseDriverOptions handles processing of BusLogic Driver Options
4467: specifications.
4468:
4469: BusLogic Driver Options may be specified either via the Linux Kernel Command
4470: Line or via the Loadable Kernel Module Installation Facility. Driver Options
4471: for multiple host adapters may be specified either by separating the option
4472: strings by a semicolon, or by specifying multiple "BusLogic=" strings on the
4473: command line. Individual option specifications for a single host adapter are
4474: separated by commas. The Probing and Debugging Options apply to all host
4475: adapters whereas the remaining options apply individually only to the
4476: selected host adapter.
4477:
4478: The BusLogic Driver Probing Options comprise the following:
4479:
4480: IO:<integer>
4481:
4482: The "IO:" option specifies an ISA I/O Address to be probed for a non-PCI
4483: MultiMaster Host Adapter. If neither "IO:" nor "NoProbeISA" options are
4484: specified, then the standard list of BusLogic MultiMaster ISA I/O Addresses
4485: will be probed (0x330, 0x334, 0x230, 0x234, 0x130, and 0x134). Multiple
4486: "IO:" options may be specified to precisely determine the I/O Addresses to
4487: be probed, but the probe order will always follow the standard list.
4488:
4489: NoProbe
4490:
4491: The "NoProbe" option disables all probing and therefore no BusLogic Host
4492: Adapters will be detected.
4493:
4494: NoProbeISA
4495:
4496: The "NoProbeISA" option disables probing of the standard BusLogic ISA I/O
4497: Addresses and therefore only PCI MultiMaster and FlashPoint Host Adapters
4498: will be detected.
4499:
4500: NoProbePCI
4501:
4502: The "NoProbePCI" options disables the interrogation of PCI Configuration
4503: Space and therefore only ISA Multimaster Host Adapters will be detected, as
4504: well as PCI Multimaster Host Adapters that have their ISA Compatible I/O
4505: Port set to "Primary" or "Alternate".
4506:
4507: NoSortPCI
4508:
4509: The "NoSortPCI" option forces PCI MultiMaster Host Adapters to be
4510: enumerated in the order provided by the PCI BIOS, ignoring any setting of
4511: the AutoSCSI "Use Bus And Device # For PCI Scanning Seq." option.
4512:
4513: MultiMasterFirst
4514:
4515: The "MultiMasterFirst" option forces MultiMaster Host Adapters to be probed
4516: before FlashPoint Host Adapters. By default, if both FlashPoint and PCI
4517: MultiMaster Host Adapters are present, this driver will probe for
4518: FlashPoint Host Adapters first unless the BIOS primary disk is controlled
4519: by the first PCI MultiMaster Host Adapter, in which case MultiMaster Host
4520: Adapters will be probed first.
4521:
4522: FlashPointFirst
4523:
4524: The "FlashPointFirst" option forces FlashPoint Host Adapters to be probed
4525: before MultiMaster Host Adapters.
4526:
4527: The BusLogic Driver Tagged Queuing Options allow for explicitly specifying
4528: the Queue Depth and whether Tagged Queuing is permitted for each Target
4529: Device (assuming that the Target Device supports Tagged Queuing). The Queue
4530: Depth is the number of SCSI Commands that are allowed to be concurrently
4531: presented for execution (either to the Host Adapter or Target Device). Note
4532: that explicitly enabling Tagged Queuing may lead to problems; the option to
4533: enable or disable Tagged Queuing is provided primarily to allow disabling
4534: Tagged Queuing on Target Devices that do not implement it correctly. The
4535: following options are available:
4536:
4537: QueueDepth:<integer>
4538:
4539: The "QueueDepth:" or QD:" option specifies the Queue Depth to use for all
4540: Target Devices that support Tagged Queuing, as well as the maximum Queue
4541: Depth for devices that do not support Tagged Queuing. If no Queue Depth
4542: option is provided, the Queue Depth will be determined automatically based
4543: on the Host Adapter's Total Queue Depth and the number, type, speed, and
4544: capabilities of the detected Target Devices. For Host Adapters that
4545: require ISA Bounce Buffers, the Queue Depth is automatically set by default
4546: to BusLogic_TaggedQueueDepthBB or BusLogic_UntaggedQueueDepthBB to avoid
4547: excessive preallocation of DMA Bounce Buffer memory. Target Devices that
4548: do not support Tagged Queuing always have their Queue Depth set to
4549: BusLogic_UntaggedQueueDepth or BusLogic_UntaggedQueueDepthBB, unless a
4550: lower Queue Depth option is provided. A Queue Depth of 1 automatically
4551: disables Tagged Queuing.
4552:
4553: QueueDepth:[<integer>,<integer>...]
4554:
4555: The "QueueDepth:[...]" or "QD:[...]" option specifies the Queue Depth
4556: individually for each Target Device. If an <integer> is omitted, the
4557: associated Target Device will have its Queue Depth selected automatically.
4558:
4559: TaggedQueuing:Default
4560:
4561: The "TaggedQueuing:Default" or "TQ:Default" option permits Tagged Queuing
4562: based on the firmware version of the BusLogic Host Adapter and based on
4563: whether the Queue Depth allows queuing multiple commands.
4564:
4565: TaggedQueuing:Enable
4566:
4567: The "TaggedQueuing:Enable" or "TQ:Enable" option enables Tagged Queuing for
4568: all Target Devices on this Host Adapter, overriding any limitation that
4569: would otherwise be imposed based on the Host Adapter firmware version.
4570:
4571: TaggedQueuing:Disable
4572:
4573: The "TaggedQueuing:Disable" or "TQ:Disable" option disables Tagged Queuing
4574: for all Target Devices on this Host Adapter.
4575:
4576: TaggedQueuing:<Target-Spec>
4577:
4578: The "TaggedQueuing:<Target-Spec>" or "TQ:<Target-Spec>" option controls
4579: Tagged Queuing individually for each Target Device. <Target-Spec> is a
4580: sequence of "Y", "N", and "X" characters. "Y" enables Tagged Queuing, "N"
4581: disables Tagged Queuing, and "X" accepts the default based on the firmware
4582: version. The first character refers to Target Device 0, the second to
4583: Target Device 1, and so on; if the sequence of "Y", "N", and "X" characters
4584: does not cover all the Target Devices, unspecified characters are assumed
4585: to be "X".
4586:
4587: The BusLogic Driver Error Recovery Option allows for explicitly specifying
4588: the Error Recovery action to be performed when BusLogic_ResetCommand is
4589: called due to a SCSI Command failing to complete successfully. The following
4590: options are available:
4591:
4592: ErrorRecovery:Default
4593:
4594: The "ErrorRecovery:Default" or "ER:Default" option selects between the Hard
4595: Reset and Bus Device Reset options based on the recommendation of the SCSI
4596: Subsystem.
4597:
4598: ErrorRecovery:HardReset
4599:
4600: The "ErrorRecovery:HardReset" or "ER:HardReset" option will initiate a Host
4601: Adapter Hard Reset which also causes a SCSI Bus Reset.
4602:
4603: ErrorRecovery:BusDeviceReset
4604:
4605: The "ErrorRecovery:BusDeviceReset" or "ER:BusDeviceReset" option will send
4606: a Bus Device Reset message to the individual Target Device causing the
4607: error. If Error Recovery is again initiated for this Target Device and no
4608: SCSI Command to this Target Device has completed successfully since the Bus
4609: Device Reset message was sent, then a Hard Reset will be attempted.
4610:
4611: ErrorRecovery:None
4612:
4613: The "ErrorRecovery:None" or "ER:None" option suppresses Error Recovery.
4614: This option should only be selected if a SCSI Bus Reset or Bus Device Reset
4615: will cause the Target Device or a critical operation to suffer a complete
4616: and unrecoverable failure.
4617:
4618: ErrorRecovery:<Target-Spec>
4619:
4620: The "ErrorRecovery:<Target-Spec>" or "ER:<Target-Spec>" option controls
4621: Error Recovery individually for each Target Device. <Target-Spec> is a
4622: sequence of "D", "H", "B", and "N" characters. "D" selects Default, "H"
4623: selects Hard Reset, "B" selects Bus Device Reset, and "N" selects None.
4624: The first character refers to Target Device 0, the second to Target Device
4625: 1, and so on; if the sequence of "D", "H", "B", and "N" characters does not
4626: cover all the possible Target Devices, unspecified characters are assumed
4627: to be "D".
4628:
4629: The BusLogic Driver Miscellaneous Options comprise the following:
4630:
4631: BusSettleTime:<seconds>
4632:
4633: The "BusSettleTime:" or "BST:" option specifies the Bus Settle Time in
4634: seconds. The Bus Settle Time is the amount of time to wait between a Host
4635: Adapter Hard Reset which initiates a SCSI Bus Reset and issuing any SCSI
4636: Commands. If unspecified, it defaults to BusLogic_DefaultBusSettleTime.
4637:
4638: InhibitTargetInquiry
4639:
4640: The "InhibitTargetInquiry" option inhibits the execution of an Inquire
4641: Target Devices or Inquire Installed Devices command on MultiMaster Host
4642: Adapters. This may be necessary with some older Target Devices that do not
4643: respond correctly when Logical Units above 0 are addressed.
4644:
4645: The BusLogic Driver Debugging Options comprise the following:
4646:
4647: TraceProbe
4648:
4649: The "TraceProbe" option enables tracing of Host Adapter Probing.
4650:
4651: TraceHardwareReset
4652:
4653: The "TraceHardwareReset" option enables tracing of Host Adapter Hardware
4654: Reset.
4655:
4656: TraceConfiguration
4657:
4658: The "TraceConfiguration" option enables tracing of Host Adapter
4659: Configuration.
4660:
4661: TraceErrors
4662:
4663: The "TraceErrors" option enables tracing of SCSI Commands that return an
4664: error from the Target Device. The CDB and Sense Data will be printed for
4665: each SCSI Command that fails.
4666:
4667: Debug
4668:
4669: The "Debug" option enables all debugging options.
4670:
4671: The following examples demonstrate setting the Queue Depth for Target Devices
4672: 1 and 2 on the first host adapter to 7 and 15, the Queue Depth for all Target
4673: Devices on the second host adapter to 31, and the Bus Settle Time on the
4674: second host adapter to 30 seconds.
4675:
4676: Linux Kernel Command Line:
4677:
4678: linux BusLogic=QueueDepth:[,7,15];QueueDepth:31,BusSettleTime:30
4679:
4680: LILO Linux Boot Loader (in /etc/lilo.conf):
4681:
4682: append = "BusLogic=QueueDepth:[,7,15];QueueDepth:31,BusSettleTime:30"
4683:
4684: INSMOD Loadable Kernel Module Installation Facility:
4685:
4686: insmod BusLogic.o \
4687: 'BusLogic_Options="QueueDepth:[,7,15];QueueDepth:31,BusSettleTime:30"'
4688:
4689: NOTE: Module Utilities 2.1.71 or later is required for correct parsing
4690: of driver options containing commas.
4691:
4692: */
4693:
4694: static void BusLogic_ParseDriverOptions(char *OptionsString)
4695: {
4696: while (true)
4697: {
4698: BusLogic_DriverOptions_T *DriverOptions =
4699: &BusLogic_DriverOptions[BusLogic_DriverOptionsCount++];
4700: int TargetID;
4701: memset(DriverOptions, 0, sizeof(BusLogic_DriverOptions_T));
4702: for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++)
4703: DriverOptions->ErrorRecoveryStrategy[TargetID] =
4704: BusLogic_ErrorRecovery_Default;
4705: while (*OptionsString != '\0' && *OptionsString != ';')
4706: {
4707: /* Probing Options. */
4708: if (BusLogic_ParseKeyword(&OptionsString, "IO:"))
4709: {
4710: BusLogic_IO_Address_T IO_Address =
4711: simple_strtoul(OptionsString, &OptionsString, 0);
4712: BusLogic_ProbeOptions.LimitedProbeISA = true;
4713: switch (IO_Address)
4714: {
4715: case 0x330:
4716: BusLogic_ProbeOptions.Probe330 = true;
4717: break;
4718: case 0x334:
4719: BusLogic_ProbeOptions.Probe334 = true;
4720: break;
4721: case 0x230:
4722: BusLogic_ProbeOptions.Probe230 = true;
4723: break;
4724: case 0x234:
4725: BusLogic_ProbeOptions.Probe234 = true;
4726: break;
4727: case 0x130:
4728: BusLogic_ProbeOptions.Probe130 = true;
4729: break;
4730: case 0x134:
4731: BusLogic_ProbeOptions.Probe134 = true;
4732: break;
4733: default:
4734: BusLogic_Error("BusLogic: Invalid Driver Options "
4735: "(illegal I/O Address 0x%X)\n",
4736: NULL, IO_Address);
4737: return;
4738: }
4739: }
4740: else if (BusLogic_ParseKeyword(&OptionsString, "NoProbeISA"))
4741: BusLogic_ProbeOptions.NoProbeISA = true;
4742: else if (BusLogic_ParseKeyword(&OptionsString, "NoProbePCI"))
4743: BusLogic_ProbeOptions.NoProbePCI = true;
4744: else if (BusLogic_ParseKeyword(&OptionsString, "NoProbe"))
4745: BusLogic_ProbeOptions.NoProbe = true;
4746: else if (BusLogic_ParseKeyword(&OptionsString, "NoSortPCI"))
4747: BusLogic_ProbeOptions.NoSortPCI = true;
4748: else if (BusLogic_ParseKeyword(&OptionsString, "MultiMasterFirst"))
4749: BusLogic_ProbeOptions.MultiMasterFirst = true;
4750: else if (BusLogic_ParseKeyword(&OptionsString, "FlashPointFirst"))
4751: BusLogic_ProbeOptions.FlashPointFirst = true;
4752: /* Tagged Queuing Options. */
4753: else if (BusLogic_ParseKeyword(&OptionsString, "QueueDepth:[") ||
4754: BusLogic_ParseKeyword(&OptionsString, "QD:["))
4755: {
4756: for (TargetID = 0;
4757: TargetID < BusLogic_MaxTargetDevices;
4758: TargetID++)
4759: {
4760: unsigned short QueueDepth =
4761: simple_strtoul(OptionsString, &OptionsString, 0);
4762: if (QueueDepth > BusLogic_MaxTaggedQueueDepth)
4763: {
4764: BusLogic_Error("BusLogic: Invalid Driver Options "
4765: "(illegal Queue Depth %d)\n",
4766: NULL, QueueDepth);
4767: return;
4768: }
4769: DriverOptions->QueueDepth[TargetID] = QueueDepth;
4770: if (*OptionsString == ',')
4771: OptionsString++;
4772: else if (*OptionsString == ']')
4773: break;
4774: else
4775: {
4776: BusLogic_Error("BusLogic: Invalid Driver Options "
4777: "(',' or ']' expected at '%s')\n",
4778: NULL, OptionsString);
4779: return;
4780: }
4781: }
4782: if (*OptionsString != ']')
4783: {
4784: BusLogic_Error("BusLogic: Invalid Driver Options "
4785: "(']' expected at '%s')\n",
4786: NULL, OptionsString);
4787: return;
4788: }
4789: else OptionsString++;
4790: }
4791: else if (BusLogic_ParseKeyword(&OptionsString, "QueueDepth:") ||
4792: BusLogic_ParseKeyword(&OptionsString, "QD:"))
4793: {
4794: unsigned short QueueDepth =
4795: simple_strtoul(OptionsString, &OptionsString, 0);
4796: if (QueueDepth == 0 || QueueDepth > BusLogic_MaxTaggedQueueDepth)
4797: {
4798: BusLogic_Error("BusLogic: Invalid Driver Options "
4799: "(illegal Queue Depth %d)\n",
4800: NULL, QueueDepth);
4801: return;
4802: }
4803: DriverOptions->CommonQueueDepth = QueueDepth;
4804: for (TargetID = 0;
4805: TargetID < BusLogic_MaxTargetDevices;
4806: TargetID++)
4807: DriverOptions->QueueDepth[TargetID] = QueueDepth;
4808: }
4809: else if (BusLogic_ParseKeyword(&OptionsString, "TaggedQueuing:") ||
4810: BusLogic_ParseKeyword(&OptionsString, "TQ:"))
4811: {
4812: if (BusLogic_ParseKeyword(&OptionsString, "Default"))
4813: {
4814: DriverOptions->TaggedQueuingPermitted = 0x0000;
4815: DriverOptions->TaggedQueuingPermittedMask = 0x0000;
4816: }
4817: else if (BusLogic_ParseKeyword(&OptionsString, "Enable"))
4818: {
4819: DriverOptions->TaggedQueuingPermitted = 0xFFFF;
4820: DriverOptions->TaggedQueuingPermittedMask = 0xFFFF;
4821: }
4822: else if (BusLogic_ParseKeyword(&OptionsString, "Disable"))
4823: {
4824: DriverOptions->TaggedQueuingPermitted = 0x0000;
4825: DriverOptions->TaggedQueuingPermittedMask = 0xFFFF;
4826: }
4827: else
4828: {
4829: unsigned short TargetBit;
4830: for (TargetID = 0, TargetBit = 1;
4831: TargetID < BusLogic_MaxTargetDevices;
4832: TargetID++, TargetBit <<= 1)
4833: switch (*OptionsString++)
4834: {
4835: case 'Y':
4836: DriverOptions->TaggedQueuingPermitted |= TargetBit;
4837: DriverOptions->TaggedQueuingPermittedMask |= TargetBit;
4838: break;
4839: case 'N':
4840: DriverOptions->TaggedQueuingPermitted &= ~TargetBit;
4841: DriverOptions->TaggedQueuingPermittedMask |= TargetBit;
4842: break;
4843: case 'X':
4844: break;
4845: default:
4846: OptionsString--;
4847: TargetID = BusLogic_MaxTargetDevices;
4848: break;
4849: }
4850: }
4851: }
4852: /* Error Recovery Option. */
4853: else if (BusLogic_ParseKeyword(&OptionsString, "ErrorRecovery:") ||
4854: BusLogic_ParseKeyword(&OptionsString, "ER:"))
4855: {
4856: if (BusLogic_ParseKeyword(&OptionsString, "Default"))
4857: for (TargetID = 0;
4858: TargetID < BusLogic_MaxTargetDevices;
4859: TargetID++)
4860: DriverOptions->ErrorRecoveryStrategy[TargetID] =
4861: BusLogic_ErrorRecovery_Default;
4862: else if (BusLogic_ParseKeyword(&OptionsString, "HardReset"))
4863: for (TargetID = 0;
4864: TargetID < BusLogic_MaxTargetDevices;
4865: TargetID++)
4866: DriverOptions->ErrorRecoveryStrategy[TargetID] =
4867: BusLogic_ErrorRecovery_HardReset;
4868: else if (BusLogic_ParseKeyword(&OptionsString, "BusDeviceReset"))
4869: for (TargetID = 0;
4870: TargetID < BusLogic_MaxTargetDevices;
4871: TargetID++)
4872: DriverOptions->ErrorRecoveryStrategy[TargetID] =
4873: BusLogic_ErrorRecovery_BusDeviceReset;
4874: else if (BusLogic_ParseKeyword(&OptionsString, "None"))
4875: for (TargetID = 0;
4876: TargetID < BusLogic_MaxTargetDevices;
4877: TargetID++)
4878: DriverOptions->ErrorRecoveryStrategy[TargetID] =
4879: BusLogic_ErrorRecovery_None;
4880: else
4881: for (TargetID = 0;
4882: TargetID < BusLogic_MaxTargetDevices;
4883: TargetID++)
4884: switch (*OptionsString++)
4885: {
4886: case 'D':
4887: DriverOptions->ErrorRecoveryStrategy[TargetID] =
4888: BusLogic_ErrorRecovery_Default;
4889: break;
4890: case 'H':
4891: DriverOptions->ErrorRecoveryStrategy[TargetID] =
4892: BusLogic_ErrorRecovery_HardReset;
4893: break;
4894: case 'B':
4895: DriverOptions->ErrorRecoveryStrategy[TargetID] =
4896: BusLogic_ErrorRecovery_BusDeviceReset;
4897: break;
4898: case 'N':
4899: DriverOptions->ErrorRecoveryStrategy[TargetID] =
4900: BusLogic_ErrorRecovery_None;
4901: break;
4902: default:
4903: OptionsString--;
4904: TargetID = BusLogic_MaxTargetDevices;
4905: break;
4906: }
4907: }
4908: /* Miscellaneous Options. */
4909: else if (BusLogic_ParseKeyword(&OptionsString, "BusSettleTime:") ||
4910: BusLogic_ParseKeyword(&OptionsString, "BST:"))
4911: {
4912: unsigned short BusSettleTime =
4913: simple_strtoul(OptionsString, &OptionsString, 0);
4914: if (BusSettleTime > 5 * 60)
4915: {
4916: BusLogic_Error("BusLogic: Invalid Driver Options "
4917: "(illegal Bus Settle Time %d)\n",
4918: NULL, BusSettleTime);
4919: return;
4920: }
4921: DriverOptions->BusSettleTime = BusSettleTime;
4922: }
4923: else if (BusLogic_ParseKeyword(&OptionsString,
4924: "InhibitTargetInquiry"))
4925: DriverOptions->LocalOptions.InhibitTargetInquiry = true;
4926: /* Debugging Options. */
4927: else if (BusLogic_ParseKeyword(&OptionsString, "TraceProbe"))
4928: BusLogic_GlobalOptions.TraceProbe = true;
4929: else if (BusLogic_ParseKeyword(&OptionsString, "TraceHardwareReset"))
4930: BusLogic_GlobalOptions.TraceHardwareReset = true;
4931: else if (BusLogic_ParseKeyword(&OptionsString, "TraceConfiguration"))
4932: BusLogic_GlobalOptions.TraceConfiguration = true;
4933: else if (BusLogic_ParseKeyword(&OptionsString, "TraceErrors"))
4934: BusLogic_GlobalOptions.TraceErrors = true;
4935: else if (BusLogic_ParseKeyword(&OptionsString, "Debug"))
4936: {
4937: BusLogic_GlobalOptions.TraceProbe = true;
4938: BusLogic_GlobalOptions.TraceHardwareReset = true;
4939: BusLogic_GlobalOptions.TraceConfiguration = true;
4940: BusLogic_GlobalOptions.TraceErrors = true;
4941: }
4942: if (*OptionsString == ',')
4943: OptionsString++;
4944: else if (*OptionsString != ';' && *OptionsString != '\0')
4945: {
4946: BusLogic_Error("BusLogic: Unexpected Driver Option '%s' "
4947: "ignored\n", NULL, OptionsString);
4948: *OptionsString = '\0';
4949: }
4950: }
4951: if (!(BusLogic_DriverOptionsCount == 0 ||
4952: BusLogic_ProbeInfoCount == 0 ||
4953: BusLogic_DriverOptionsCount == BusLogic_ProbeInfoCount))
4954: {
4955: BusLogic_Error("BusLogic: Invalid Driver Options "
4956: "(all or no I/O Addresses must be specified)\n", NULL);
4957: return;
4958: }
4959: /*
4960: Tagged Queuing is disabled when the Queue Depth is 1 since queuing
4961: multiple commands is not possible.
4962: */
4963: for (TargetID = 0; TargetID < BusLogic_MaxTargetDevices; TargetID++)
4964: if (DriverOptions->QueueDepth[TargetID] == 1)
4965: {
4966: unsigned short TargetBit = 1 << TargetID;
4967: DriverOptions->TaggedQueuingPermitted &= ~TargetBit;
4968: DriverOptions->TaggedQueuingPermittedMask |= TargetBit;
4969: }
4970: if (*OptionsString == ';') OptionsString++;
4971: if (*OptionsString == '\0') return;
4972: }
4973: }
4974:
4975:
4976: /*
4977: BusLogic_Setup handles processing of Kernel Command Line Arguments.
4978: */
4979:
4980: void BusLogic_Setup(char *CommandLineString, int *CommandLineIntegers)
4981: {
4982: if (CommandLineIntegers[0] != 0)
4983: {
4984: BusLogic_Error("BusLogic: Obsolete Command Line Entry "
4985: "Format Ignored\n", NULL);
4986: return;
4987: }
4988: if (CommandLineString == NULL || *CommandLineString == '\0') return;
4989: BusLogic_ParseDriverOptions(CommandLineString);
4990: }
4991:
4992:
4993: /*
4994: Include Module support if requested.
4995: */
4996:
4997: #ifdef MODULE
4998:
4999: SCSI_Host_Template_T driver_template = BUSLOGIC;
5000:
5001: #include "scsi_module.c"
5002:
5003: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.