![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fd8xx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / scsi / fd8xx|
Return to fd8xx.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / fd8xx |
1.1 root 1: /*++
2:
3: Copyright (c) 1991, 1992 Microsoft Corporation
4: Copyright (c) 1992 Future Domain Corporation
5:
6: Module Name:
7:
8: fd8xx.c
9:
10: Abstract:
11:
12: This is the miniport driver for the Future Domain TMC-8XX SCSI Adapters.
13:
14: Environment:
15:
16: kernel mode only
17:
18: Notes:
19:
20: --*/
21:
22: #include "miniport.h"
23: #include "stdarg.h"
24: #include <string.h>
25: #include <math.h>
26: #include <stdlib.h>
27: #include "fd8xx.h" // includes scsi.h
28:
29: //
30: // Logical Unit states.
31: //
32: typedef enum _LU_STATE {
33:
34: LS_UNDETERMINED,
35: LS_ARBITRATE,
36: LS_SELECT,
37: LS_IDENTIFY,
38: LS_MSG_SPECIAL,
39: LS_COMMAND,
40: LS_DATA,
41: LS_DISCONNECTED,
42: LS_ABORT,
43: LS_STATUS,
44: LS_MSG_IN,
45: LS_COMPLETE
46:
47: } LU_STATE, *PLU_STATE;
48:
49: //
50: // Logical Unit extension. The BOOLEANS in this structure will be initialized
51: // to FALSE by the port driver. It will zero the structure when allocated.
52: // Therefore there is no explicit initialization of these fields.
53: //
54: typedef struct _SPECIFIC_LU_EXTENSION {
55:
56: LU_STATE LuState; // State information.
57: ULONG SavedDataPointer; // Current data pointer.
58: ULONG SavedDataLength; // Current data lenght.
59: PSCSI_REQUEST_BLOCK ActiveLuRequest; // Active Srb for this LUN.
60: USHORT OverRunCount; // Initialized to zero, counts up
61: UCHAR AbortBeingAttempted;// Abort active on this LU.
62: BOOLEAN NoDisconnectActive; // No disconnect flag on SRB.
63: BOOLEAN HandShakeAllData; // Dribbling drive fix.
64: BOOLEAN SixByteCDBActive; // Potential tape access.
65:
66: } SPECIFIC_LU_EXTENSION, *PSPECIFIC_LU_EXTENSION;
67:
68: //
69: // Device extension
70: //
71: typedef struct _SPECIFIC_DEVICE_EXTENSION {
72:
73: PUCHAR BaseAddress; // Memory map address of adapter.
74: ULONG CurDataPointer; // Current pointer for active LUN.
75: ULONG CurDataLength; // Bytes left to xfer to this LUN.
76: PSPECIFIC_LU_EXTENSION SavedLu; // Saved LUN during interrupts.
77: PSPECIFIC_LU_EXTENSION ActiveLu; // Currently active LUN.
78: UCHAR PathId; // Relates to SCSI bus.
79: UCHAR ControlRegister; // Current val of fd8xx control reg.
80: BOOLEAN ExpectingInterrupt; // Bookkeeping for IRQ configuration.
81: BOOLEAN NotifiedConfigurationError; // Event is logged.
82: USHORT ContinueTimer; // Indicator to continue polling
83: USHORT TimerCaughtInterrupt; // Number times timer caught IRQ
84: UCHAR InitiatorId; // target id for host adapter
85: BOOLEAN ConfiguredWithoutInterrupts; // Intentially configured w/o IRQ
86:
87: } SPECIFIC_DEVICE_EXTENSION, *PSPECIFIC_DEVICE_EXTENSION;
88:
89:
90: //
91: // Function declarations
92: //
93:
94: ULONG
95: DriverEntry(
96: IN PVOID DriverObject,
97: IN PVOID Argument2
98: );
99:
100: ULONG
101: Fd8xxFindAdapter(
102: IN PVOID Context,
103: IN PVOID AdaptersFound,
104: IN PVOID BusInformation,
105: IN PCHAR ArgumentString,
106: IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
107: OUT PBOOLEAN Again
108: );
109:
110: BOOLEAN
111: Fd8xxInitialize(
112: IN PVOID Context
113: );
114:
115: BOOLEAN
116: Fd8xxStartIo(
117: IN PVOID Context,
118: IN PSCSI_REQUEST_BLOCK Srb
119: );
120:
121: VOID
122: Fd8xxDoReconnect(
123: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
124: );
125:
126: VOID
127: Fd8xxDpcRunPhase(
128: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
129: );
130:
131: VOID
132: Fd8xxTimer(
133: IN PVOID Context
134: );
135:
136: BOOLEAN
137: Fd8xxInterrupt(
138: IN PVOID Context
139: );
140:
141: BOOLEAN
142: Fd8xxResetBus(
143: IN PVOID Context,
144: IN ULONG PathId
145: );
146:
147: VOID
148: Fd8xxMoveMemoryUchar(
149: PUCHAR Source,
150: PUCHAR Dest,
151: ULONG Length
152: );
153:
154:
155: #if DBG
156:
157: //
158: // Globals and externals used for debugging.
159: //
160:
161: //
162: // Fd8xxDebug affects which debug prints are enabled:
163: //
164: // 0x001 Arbitration and selection
165: // 0x002 Command, message out, and status
166: // 0x004 Data transfer
167: // 0x008 Message in and status
168: // 0x010 Miniport entry points and completion
169: // 0x020 Initialization and interrupt
170: // 0x040 StatusCheck and WaitForRequest
171: // 0x080 Control register manipulation
172: // 0x100 Completion
173: // 0x200 Handshake all bytes set.
174: //
175: ULONG Fd8xxDebug = 0x0000;
176:
177: #define FdDebugPrint(MASK, ARGS) \
178: if (MASK & Fd8xxDebug) { \
179: ScsiDebugPrint ARGS; \
180: }
181:
182: #else
183:
184: #define FdDebugPrint(MASK, ARGS)
185:
186: #endif
187:
188:
189: VOID
190: Fd8xxWriteControl(
191: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
192: IN UCHAR Value
193: )
194:
195: /*++
196:
197: Routine Description:
198:
199: This routine sets the control register on the adapter and remembers
200: the value set in the device extension.
201:
202: Arguments:
203:
204: DeviceExtension - Device adapter context pointer.
205: Value - New value for the control register.
206:
207: Return Value:
208:
209: None
210:
211: --*/
212:
213: {
214: FdDebugPrint(0x80,
215: (0, "WriteControl: Device = %x, NewVal = %x\n",
216: DeviceExtension,
217: Value));
218:
219: DeviceExtension->ControlRegister = Value;
220:
221: FD8XX_SET_CONTROL(DeviceExtension->BaseAddress,
222: Value);
223: } // end Fd8xxWriteControl()
224:
225:
226: VOID
227: Fd8xxSetControl(
228: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
229: IN UCHAR Value
230: )
231:
232: /*++
233:
234: Routine Description:
235:
236: This routine adds the control lines indicated to the current value
237: for the adapter control register.
238:
239: Arguments:
240:
241: DeviceExtension - Device adapter context pointer.
242: Value - The bits that are to be added (or'd in) to the
243: control register.
244:
245: Return Value:
246:
247: None
248:
249: --*/
250:
251: {
252: FdDebugPrint(0x80,
253: (0, "SetControl: Device = %x, Value = %x, NewVal = %x\n",
254: DeviceExtension,
255: Value,
256: DeviceExtension->ControlRegister | Value));
257:
258: DeviceExtension->ControlRegister |= Value;
259:
260: FD8XX_SET_CONTROL(DeviceExtension->BaseAddress,
261: DeviceExtension->ControlRegister);
262: } // end Fd8xxSetControl()
263:
264:
265: VOID
266: Fd8xxClearControl(
267: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
268: IN UCHAR Mask
269: )
270:
271: /*++
272:
273: Routine Description:
274:
275: This routine masks out the bits for the control register that are
276: passed in Mask and sets the adapter control register to the new value.
277:
278: Arguments:
279:
280: DeviceExtension - Device adapter context pointer.
281: Mask - The bits that are to be reset to zero in the control
282: register.
283:
284: Return Value:
285:
286: None
287:
288: --*/
289:
290: {
291: FdDebugPrint(0x80,
292: (0, "ClearControl: Device = %x, Mask = %x, NewVal = %x\n",
293: DeviceExtension,
294: Mask,
295: DeviceExtension->ControlRegister & (~(Mask))));
296:
297: //
298: // Negate Value to get a zero based mask.
299: //
300: Mask = ~(Mask);
301:
302: //
303: // AND against the current contents of the control register.
304: //
305: DeviceExtension->ControlRegister &= Mask;
306:
307: FD8XX_SET_CONTROL(DeviceExtension->BaseAddress,
308: DeviceExtension->ControlRegister);
309: } // end Fd8xxClearControl()
310:
311:
312: BOOLEAN
313: Fd8xxWaitForRequestLine(
314: PSPECIFIC_DEVICE_EXTENSION DeviceExtension
315: )
316:
317: /*++
318:
319: Routine Description:
320:
321: Spin checking the status of the FD8XX adapter until it indicates that
322: the SCSI REQUEST line is high.
323:
324: Arguments:
325:
326: DeviceExtension - Device adapter context pointer.
327:
328: Return Value:
329:
330: TRUE - indicates that the SCSI REQUEST line was asserted in time.
331: FALSE - indicates timeout occurred while waiting for the SCSI REQUEST
332: line.
333:
334: --*/
335:
336: {
337: PUCHAR baseAddress = DeviceExtension->BaseAddress;
338: ULONG spinCount = REQUEST_SPIN_WAIT;
339:
340: FdDebugPrint(0x40, (0, "FdWaitForReq: "));
341:
342: do {
343:
344: //
345: // Check if TWO of the status register reads are identical. This is
346: // to validate that there was no "glitch" that caused some line to
347: // temporarily go high.
348: //
349: while (FD8XX_READ_STATUS(baseAddress) !=
350: FD8XX_READ_ALTERNATE_STATUS(baseAddress, 1)) {
351:
352: ScsiPortStallExecution(1);
353: }
354:
355: if (FD8XX_READ_STATUS(baseAddress) & S_REQUEST) {
356:
357: FdDebugPrint(0x40, (0, "Got REQUEST\n"));
358: return TRUE;
359: }
360:
361: ScsiPortStallExecution(1);
362:
363: } while (spinCount--);
364:
365: FdDebugPrint(0x40, (0, "TIMEOUT\n"));
366:
367: if (DeviceExtension->ActiveLu) {
368:
369: ScsiPortLogError(DeviceExtension,
370: DeviceExtension->ActiveLu->ActiveLuRequest,
371: DeviceExtension->ActiveLu->ActiveLuRequest->PathId,
372: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId,
373: DeviceExtension->ActiveLu->ActiveLuRequest->Lun,
374: SP_REQUEST_TIMEOUT,
375: 1);
376: }
377:
378: return FALSE;
379: } // end Fd8xxWaitForRequestLine()
380:
381:
382: BOOLEAN
383: Fd8xxStatusCheck(
384: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
385: IN UCHAR Mask,
386: IN UCHAR Compare,
387: IN ULONG SpinMax
388: )
389:
390: /*++
391:
392: Routine Description:
393:
394: Spin checking the status of the FD8XX adapter until it matches
395: the desired value.
396:
397: Arguments:
398:
399: DeviceExtension - Device adapter context pointer.
400: Mask - Bits to mask out of the value returned by adapter
401: status register.
402: Compare - Desired result of status register after is is "Mask"ed.
403: SpinMax - Number of times to test adapter's status register.
404:
405: Return Value:
406:
407: TRUE indicates desired value was returned by the adapter status register.
408: FALSE indicates timeout occurred and desired value was not returned.
409:
410: --*/
411:
412: {
413: PUCHAR baseAddress = DeviceExtension->BaseAddress;
414:
415: FdDebugPrint(0x40, (0, "FdStatusCheck: "));
416:
417: FdDebugPrint(0x40,
418: (0, "Dev=%x Status=%x Mask=%x Compare=%x ",
419: DeviceExtension,
420: FD8XX_READ_STATUS(baseAddress),
421: Mask,
422: Compare));
423:
424: do {
425:
426: //
427: // Check if TWO of the status register reads are identical. This is
428: // to validate that there was no "glitch" that caused some line to
429: // temporarily go high.
430: //
431: while (FD8XX_READ_STATUS(baseAddress) !=
432: FD8XX_READ_ALTERNATE_STATUS(baseAddress, 1)) {
433:
434: ScsiPortStallExecution(1);
435: }
436:
437: if ((UCHAR)(FD8XX_READ_STATUS(baseAddress) & Mask) == Compare) {
438:
439: FdDebugPrint(0x40, (0, "Got Compare\n"));
440: return TRUE;
441: }
442:
443: ScsiPortStallExecution(1);
444:
445: } while (SpinMax--);
446:
447: FdDebugPrint(0x40,
448: (0, "TIMEOUT Status=%x\n",
449: FD8XX_READ_STATUS(baseAddress)));
450:
451: return FALSE;
452: } // end Fd8xxStatusCheck()
453:
454:
455: VOID
456: Fd8xxDetermineNextState(
457: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
458: )
459:
460: /*++
461:
462: Routine Description:
463:
464: This routine determines the next logical state of this state machine
465: based on the current SCSI bus phase. It is typically called because
466: from the current state, the next state can be one of a number of other
467: states. For example, after issuing the last command byte of COMMAND
468: phase, the device may want to drive us into DATA_IN, DATA_OUT, STATUS,
469: or MSG_IN (i.e., transfer data, report an error, or disconnect).
470:
471: Arguments:
472:
473: DeviceExtension - Device adapter context pointer.
474:
475: Return Value:
476:
477: None
478:
479: --*/
480:
481: {
482: FdDebugPrint(0x01,
483: (0, "FdNextPhase: phase = %x ",
484: FD8XX_READ_PHASE(DeviceExtension->BaseAddress)));
485:
486: switch (FD8XX_READ_PHASE(DeviceExtension->BaseAddress)) {
487:
488: case BP_COMMAND:
489:
490: FdDebugPrint(0x01, (0, "LS_COMMAND\n"));
491: DeviceExtension->ActiveLu->LuState = LS_COMMAND;
492: break;
493:
494: case BP_DATA_IN:
495: case BP_DATA_OUT:
496:
497: FdDebugPrint(0x01, (0, "LS_DATA\n"));
498: DeviceExtension->ActiveLu->LuState = LS_DATA;
499: break;
500:
501: case BP_MESSAGE_IN:
502:
503: FdDebugPrint(0x01, (0, "LS_MSG_IN\n"));
504: DeviceExtension->ActiveLu->LuState = LS_MSG_IN;
505: break;
506:
507: case BP_STATUS:
508:
509: FdDebugPrint(0x01, (0, "LS_STATUS\n"));
510: DeviceExtension->ActiveLu->LuState = LS_STATUS;
511: break;
512:
513: case BP_BUS_FREE:
514:
515: FdDebugPrint(0x01, (0, "LS_BUS_FREE\n"));
516:
517: if (DeviceExtension->ActiveLu->AbortBeingAttempted) {
518:
519: DeviceExtension->ActiveLu->ActiveLuRequest->SrbStatus =
520: SRB_STATUS_SUCCESS;
521: } else {
522:
523: DeviceExtension->ActiveLu->ActiveLuRequest->SrbStatus =
524: SRB_STATUS_UNEXPECTED_BUS_FREE;
525: }
526:
527: DeviceExtension->ActiveLu->LuState = LS_COMPLETE;
528: break;
529:
530: case BP_MESSAGE_OUT:
531: case BP_RESELECT:
532: default:
533:
534: //
535: // This will get handled in RunPhase.
536: //
537: FdDebugPrint(0x01, (0, "N/A\n"));
538: break;
539: }
540: } // end Fd8xxDetermineNextState()
541:
542:
543: VOID
544: Fd8xxArbitrate(
545: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
546: )
547:
548: /*++
549:
550: Routine Description:
551:
552: Attempt to arbitrate for the SCSI bus.
553:
554: Arguments:
555:
556: DeviceExtension - Device adapter context pointer.
557:
558: Return Value:
559:
560: None
561:
562: --*/
563:
564: {
565: PUCHAR baseAddress = DeviceExtension->BaseAddress;
566: ULONG attemptsRemaining = MAX_ARB_ATTEMPTS;
567:
568: FdDebugPrint(0x01, (0, "FdArbitrate: baseaddr = %x ", baseAddress));
569:
570: while (DeviceExtension->ActiveLu->LuState == LS_ARBITRATE) {
571:
572: if (FD8XX_READ_PHASE(baseAddress) == BP_BUS_FREE) {
573:
574: //
575: // Tell the adapter to initiate arbitration for the SCSI bus
576: // since it ia available.
577: //
578: Fd8xxClearControl(DeviceExtension,
579: C_BUS_ENABLE);
580: Fd8xxSetControl(DeviceExtension,
581: C_PARITY_ENABLE);
582: FD8XX_WRITE_DATA(baseAddress,
583: (1 << DeviceExtension->InitiatorId));
584: Fd8xxSetControl(DeviceExtension,
585: C_ARBITRATION);
586: }
587:
588: if (Fd8xxStatusCheck(DeviceExtension,
589: S_ARB_COMPLETE,
590: S_ARB_COMPLETE,
591: ARBITRATION_DELAY)) {
592:
593: FdDebugPrint(0x01,
594: (0, "SUCCESS on attempt #%x!\n",
595: (MAX_ARB_ATTEMPTS - attemptsRemaining)));
596:
597: //
598: // Disable adapter interrupts so selection doesn't cause an
599: // interrupt. Then go to selection phase.
600: //
601: Fd8xxClearControl(DeviceExtension,
602: C_INT_ENABLE);
603: DeviceExtension->ActiveLu->LuState = LS_SELECT;
604:
605: } else {
606:
607: FdDebugPrint(0x01,
608: (0, "FAILED! Status=%x ",
609: FD8XX_READ_STATUS(baseAddress)));
610:
611: Fd8xxClearControl(DeviceExtension,
612: C_ARBITRATION);
613:
614: if (FD8XX_READ_PHASE(baseAddress) & S_SELECT) {
615:
616: FdDebugPrint(0x01, (0, "Being re-selected!\n"));
617:
618: //
619: // This will cause the interrupt routine to be called TWICE
620: // for the same reason. The first call will be from here.
621: // The second call will be from the NT OS since it will
622: // remember to call the interrupt routine due to the
623: // adapter IRQ line (which is tied to the SCSI SELECT line)
624: // going high. The second call will be seen by the interrupt
625: // routine as SPURRIOUS!
626: //
627: DeviceExtension->SavedLu = DeviceExtension->ActiveLu;
628: DeviceExtension->ActiveLu = NULL;
629:
630: Fd8xxDoReconnect(DeviceExtension);
631:
632: if (DeviceExtension->SavedLu == NULL) {
633:
634: //
635: // The bus was reset during the reconnect.
636: //
637: return;
638: }
639:
640: DeviceExtension->ActiveLu = DeviceExtension->SavedLu;
641: DeviceExtension->SavedLu = NULL;
642:
643: FdDebugPrint(0x01, (0, "Back to Arbitration "));
644:
645: } else if (!(attemptsRemaining--)) {
646:
647: FdDebugPrint(0x01, (0, "aborted.\n"));
648:
649: DeviceExtension->ActiveLu->LuState = LS_COMPLETE;
650: DeviceExtension->ActiveLu->ActiveLuRequest->SrbStatus =
651: SRB_STATUS_TIMEOUT;
652: }
653: }
654: }
655: } // end Fd8xxArbitrate()
656:
657:
658: VOID
659: Fd8xxSelect(
660: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
661: )
662:
663: /*++
664:
665: Routine Description:
666:
667: Perform selection process on SCSI bus.
668:
669: Arguments:
670:
671: DeviceExtension - Device adapter context pointer.
672:
673: Return Value:
674:
675: None
676:
677: --*/
678:
679: {
680: FdDebugPrint(0x01,
681: (0, "FdSelect: Device = %x, Target = %x ",
682: DeviceExtension,
683: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId));
684:
685: //
686: // Raise Select line, keeping the BUSY line high. Also, enable parity
687: // and tell the adapter to drive the SCSI data lines to prepare for
688: // outgoing ID bits. Keep in mind that this also clears the
689: // C_ARBITRATION bit.
690: //
691: Fd8xxWriteControl(DeviceExtension,
692: (C_SELECT | C_BUSY | C_BUS_ENABLE));
693: Fd8xxSetControl(DeviceExtension,
694: C_PARITY_ENABLE);
695:
696: ScsiPortStallExecution(2); // Delay 1200 nanoseconds (Bus-Settle + Bus-Clear).
697:
698: FD8XX_WRITE_DATA(DeviceExtension->BaseAddress,
699: (1 << DeviceExtension->InitiatorId) |
700: (1 << (DeviceExtension->ActiveLu->ActiveLuRequest->TargetId)));
701:
702: //
703: // Raise attention to get to message out phase.
704: //
705: Fd8xxSetControl(DeviceExtension,
706: C_ATTENTION);
707:
708: ScsiPortStallExecution(1); // Delay 90 nanoseconds (2 * Bus-Deskew).
709:
710: //
711: // Clear BUSY
712: //
713: Fd8xxClearControl(DeviceExtension,
714: C_BUSY);
715:
716: ScsiPortStallExecution(1); // Delay 400 nanoseconds (Bus-Settle).
717:
718: if (Fd8xxStatusCheck(DeviceExtension,
719: S_BUSY,
720: S_BUSY,
721: SELECTION_DELAY)) {
722:
723: ScsiPortStallExecution(1); // Delay 90 nanoseconds (2 * Bus-Deskew).
724:
725: //
726: // Selection is Ok. Clear SELECT line.
727: //
728: Fd8xxClearControl(DeviceExtension,
729: C_SELECT);
730:
731: DeviceExtension->ActiveLu->LuState = LS_IDENTIFY;
732: FdDebugPrint(0x01,
733: (0, "SELECT OK %x\n",
734: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId));
735: return;
736: }
737:
738: //
739: // Selection failed. Force SCSI bus back to Bus-Free.
740: //
741: Fd8xxWriteControl(DeviceExtension,
742: C_PARITY_ENABLE);
743:
744: FdDebugPrint(0x01,
745: (0, "SELECT FAILED %x\n",
746: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId));
747:
748: DeviceExtension->ActiveLu->LuState = LS_COMPLETE;
749: DeviceExtension->ActiveLu->ActiveLuRequest->SrbStatus =
750: SRB_STATUS_SELECTION_TIMEOUT;
751: } // end Fd8xxSelect()
752:
753:
754: VOID
755: Fd8xxSendIdentify(
756: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
757: )
758:
759: /*++
760:
761: Routine Description:
762:
763: Send an identify message on the SCSI bus if the target will accept it.
764:
765: Arguments:
766:
767: DeviceExtension - Device adapter context pointer.
768:
769: Return Value:
770:
771: None
772:
773: --*/
774:
775: {
776: PUCHAR baseAddress = DeviceExtension->BaseAddress;
777: PSCSI_REQUEST_BLOCK srb = DeviceExtension->ActiveLu->ActiveLuRequest;
778:
779: FdDebugPrint(0x02,
780: (0, "FdSendIdentify: Device = %x, Lun = %x ",
781: DeviceExtension,
782: srb->Lun));
783:
784: if (Fd8xxWaitForRequestLine(DeviceExtension) == FALSE) {
785:
786: ScsiPortLogError(DeviceExtension,
787: DeviceExtension->ActiveLu->ActiveLuRequest,
788: DeviceExtension->ActiveLu->ActiveLuRequest->PathId,
789: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId,
790: DeviceExtension->ActiveLu->ActiveLuRequest->Lun,
791: SP_REQUEST_TIMEOUT,
792: 12);
793: DeviceExtension->ActiveLu->LuState = LS_UNDETERMINED;
794: return;
795: }
796:
797: if (srb->Function == SRB_FUNCTION_EXECUTE_SCSI) {
798:
799: Fd8xxWriteControl(DeviceExtension,
800: (C_PARITY_ENABLE | C_BUS_ENABLE));
801:
802: ScsiPortStallExecution(1); // Delay 90 nanoseconds (2 * Bus-Deskew).
803:
804: //
805: // The target may wish to negotiate synchronous with us, in which
806: // case we will reject the message and go on to COMMAND phase.
807: //
808: DeviceExtension->ActiveLu->LuState = LS_UNDETERMINED;
809:
810: } else {
811:
812: //
813: // We still have an ABORT or RESET message to send, so keep the
814: // ATTENTION line high.
815: //
816: Fd8xxWriteControl(DeviceExtension,
817: (C_PARITY_ENABLE | C_BUS_ENABLE | C_ATTENTION));
818:
819: DeviceExtension->ActiveLu->LuState = LS_MSG_SPECIAL;
820: }
821:
822: //
823: // Some old SCSI-I devices want to skip MESSAGE OUT phase and go
824: // directly to COMMAND phase. We'll just let them do what they want.
825: // If the drive is really stupid, the error should get picked up in
826: // the phase to which it transitions, so just return and get on with
827: // life.
828: //
829: if (FD8XX_READ_PHASE(baseAddress) == BP_MESSAGE_OUT) {
830:
831: FdDebugPrint(0x02, (0, "IDENTIFY sent.\n"));
832:
833: if (srb->SrbFlags & SRB_FLAGS_DISABLE_DISCONNECT) {
834:
835: DeviceExtension->ActiveLu->NoDisconnectActive = TRUE;
836: FD8XX_WRITE_DATA(DeviceExtension->BaseAddress,
837: (SCSIMESS_IDENTIFY |
838: srb->Lun));
839: } else {
840:
841: FD8XX_WRITE_DATA(DeviceExtension->BaseAddress,
842: (SCSIMESS_IDENTIFY_WITH_DISCON |
843: srb->Lun));
844: }
845:
846: } else {
847:
848: FdDebugPrint(0x02,
849: (0, "IDENTIFY not sent %x\n",
850: FD8XX_READ_STATUS(DeviceExtension->BaseAddress)));
851:
852: Fd8xxClearControl(DeviceExtension, C_ATTENTION);
853: ScsiPortStallExecution(1); // Delay 90 nanoseconds (2 * Bus-Deskew).
854:
855: DeviceExtension->ActiveLu->LuState = LS_UNDETERMINED;
856: }
857: } // end Fd8xxSendIdentify()
858:
859:
860: VOID
861: Fd8xxSendSpecialMessage(
862: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
863: )
864:
865: /*++
866:
867: Routine Description:
868:
869: Send an ABORT or RESET message on the SCSI bus if the target will accept
870: it.
871:
872: Arguments:
873:
874: DeviceExtension - Device adapter context pointer.
875:
876: Return Value:
877:
878: None
879:
880: --*/
881:
882: {
883: PUCHAR baseAddress = DeviceExtension->BaseAddress;
884: PSCSI_REQUEST_BLOCK srb = DeviceExtension->ActiveLu->ActiveLuRequest;
885:
886: FdDebugPrint(0x02,
887: (0, "FdSendSpecialMessage: Device = %x, Lun = %x ",
888: DeviceExtension,
889: srb->Lun));
890:
891: if (Fd8xxWaitForRequestLine(DeviceExtension) == FALSE) {
892:
893: ScsiPortLogError(DeviceExtension,
894: DeviceExtension->ActiveLu->ActiveLuRequest,
895: DeviceExtension->ActiveLu->ActiveLuRequest->PathId,
896: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId,
897: DeviceExtension->ActiveLu->ActiveLuRequest->Lun,
898: SP_REQUEST_TIMEOUT,
899: 13);
900: DeviceExtension->ActiveLu->LuState = LS_UNDETERMINED;
901: return;
902: }
903:
904: Fd8xxClearControl(DeviceExtension,
905: C_ATTENTION);
906: ScsiPortStallExecution(1); // Delay 90 nanoseconds (2 * Bus-Deskew).
907:
908: if (srb->Function == SRB_FUNCTION_ABORT_COMMAND) {
909:
910: FdDebugPrint(0x02, (0, "ABORT\n"));
911: FD8XX_WRITE_DATA(DeviceExtension->BaseAddress,
912: SCSIMESS_ABORT);
913: } else if (srb->Function == SRB_FUNCTION_RESET_DEVICE) {
914:
915: FdDebugPrint(0x02, (0, "BDR\n"));
916: FD8XX_WRITE_DATA(DeviceExtension->BaseAddress,
917: SCSIMESS_BUS_DEVICE_RESET);
918: } else {
919:
920: ScsiPortLogError(DeviceExtension,
921: srb,
922: srb->PathId,
923: srb->TargetId,
924: srb->Lun,
925: SP_PROTOCOL_ERROR,
926: 2);
927:
928: FdDebugPrint(0x02, (0, "NO-OP\n"));
929: FD8XX_WRITE_DATA(DeviceExtension->BaseAddress,
930: SCSIMESS_NO_OPERATION);
931: }
932:
933: DeviceExtension->ActiveLu->LuState = LS_UNDETERMINED;
934: } // end Fd8xxSendSpecialMessage()
935:
936:
937: VOID
938: Fd8xxSendCDB(
939: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
940: )
941:
942: /*++
943:
944: Routine Description:
945:
946: Send the SCSI Command Descriptor Block (CDB) to the indicated target/lun.
947:
948: Arguments:
949:
950: DeviceExtension - Device adapter context pointer.
951:
952: Return Value:
953:
954: None
955:
956: --*/
957:
958: {
959: UCHAR cdbLength = DeviceExtension->ActiveLu->ActiveLuRequest->CdbLength;
960: PUCHAR cdb = DeviceExtension->ActiveLu->ActiveLuRequest->Cdb;
961: PUCHAR baseAddress = DeviceExtension->BaseAddress;
962:
963: FdDebugPrint(0x02, (0, "SendCommand: "));
964:
965: Fd8xxSetControl(DeviceExtension, C_BUS_ENABLE);
966:
967: while ((cdbLength-- != 0) &&
968: Fd8xxWaitForRequestLine(DeviceExtension) &&
969: (FD8XX_READ_PHASE(baseAddress) == BP_COMMAND)) {
970:
971: FdDebugPrint(0x02, (0, "%x ", *cdb));
972:
973: FD8XX_WRITE_DATA(baseAddress,
974: *cdb++);
975: }
976:
977: DeviceExtension->ActiveLu->LuState = LS_UNDETERMINED;
978:
979: //
980: // Set up the running data pointer info for a possible data transfer.
981: //
982: DeviceExtension->CurDataPointer = DeviceExtension->ActiveLu->SavedDataPointer;
983: DeviceExtension->CurDataLength = DeviceExtension->ActiveLu->SavedDataLength;
984:
985: FdDebugPrint(0x02, (0, "New phase=%x\n", FD8XX_READ_PHASE(baseAddress)));
986: } // end Fd8xxSendCDB()
987:
988:
989: VOID
990: Fd8xxCopyData(
991: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
992: )
993:
994: /*++
995:
996: Routine Description:
997:
998: Copy data byte-for-byte to and from adapter. This is used to copy data
999: from the FD8XX controller to system memory and vice-versa. Each
1000: iteration of the outer-most "while" loop will transfer MAX_BUFFER_LENGTH
1001: bytes (i.e., 512 bytes - this is the size of the TMC-950 memory-mapped
1002: SCSI data register), or any fraction thereof.
1003:
1004: In theory, one should be able to use the x86 REP MOVB instruction (or
1005: other equivalent) to "blast" 512 bytes of data to this register. The
1006: REQ/ACK handshaking is done by the TMC-950 chip. In practice, there is
1007: one problem. The SCSI data register is "locked in" with the host bus
1008: (ISA). This host bus cannot be tied up for longer than a memory refresh
1009: cycle (15 useconds, I think). After completing a REQ/ACK cycle, the
1010: 950 chip frees the bus, then locks it again waiting for the assertion
1011: SCSI REQ line by the target. If REQ is not asserted within a memory
1012: refresh cycle, the 950 chip times out and frees the host bus so that a
1013: memory refresh can take place. This puts the 950 chip one byte "ahead"
1014: of the target, thus screwing up the rest of the block transfer.
1015:
1016: Future Domain refers to this problem as the "dribbling drive" because
1017: the target delays the assertion of the SCSI REQ line for longer than
1018: usual (probably because the firmware did some maintenance task between
1019: bytes like filling or draining its internal FIFO). SCSI places no
1020: limit on how long a target has to re-assert the SCSI REQ line, so we must
1021: provide a work-around.
1022:
1023: After a fair amount of research and experimentation, we have learned that
1024: "manually" handshaking the first x number of bytes, the last x number of
1025: bytes, or a combination of the two, solves the problem. The determination
1026: of x in either case is purely trial-and-error and is based on device
1027: characteristics.
1028:
1029: Arguments:
1030:
1031: DeviceExtension - Device adapter context pointer.
1032:
1033: Return Value:
1034:
1035: None
1036:
1037: --*/
1038:
1039: {
1040: PUCHAR baseAddress = DeviceExtension->BaseAddress;
1041: UCHAR byteBucket = 0;
1042: UCHAR wantedState;
1043:
1044: register ULONG moveCount;
1045: register ULONG headCount;
1046: register ULONG tailCount;
1047:
1048: if (Fd8xxWaitForRequestLine(DeviceExtension) == FALSE) {
1049:
1050: ScsiPortLogError(DeviceExtension,
1051: DeviceExtension->ActiveLu->ActiveLuRequest,
1052: DeviceExtension->ActiveLu->ActiveLuRequest->PathId,
1053: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId,
1054: DeviceExtension->ActiveLu->ActiveLuRequest->Lun,
1055: SP_REQUEST_TIMEOUT,
1056: 14);
1057: DeviceExtension->ActiveLu->LuState = LS_UNDETERMINED;
1058: return;
1059: }
1060:
1061: wantedState = FD8XX_READ_PHASE(baseAddress);
1062:
1063: FdDebugPrint(0x04,
1064: (0, "CopyData: from %s for %x ",
1065: (wantedState == BP_DATA_IN) ? "Target" : "Memory",
1066: DeviceExtension->CurDataLength));
1067:
1068: if (wantedState == BP_DATA_IN) {
1069:
1070: //
1071: // The target will drive the SCSI data lines in DATA_IN phase.
1072: //
1073: Fd8xxClearControl(DeviceExtension, C_BUS_ENABLE);
1074: } else {
1075:
1076: //
1077: // We will drive the SCSI data lines in DATA_OUT phase.
1078: //
1079: Fd8xxSetControl(DeviceExtension, C_BUS_ENABLE);
1080: }
1081:
1082: while (FD8XX_READ_PHASE(baseAddress) == wantedState) {
1083:
1084: if (DeviceExtension->CurDataLength == 0) {
1085:
1086: //
1087: // Overrun condition. Read (or write) bytes until
1088: // out of DATA phase.
1089: //
1090: FdDebugPrint(0x04, (0, "overrun "));
1091:
1092: while ((FD8XX_READ_PHASE(baseAddress) == wantedState) &&
1093: Fd8xxWaitForRequestLine(DeviceExtension)) {
1094:
1095: FdDebugPrint(0x04, (0, "."));
1096:
1097: if (wantedState == BP_DATA_IN) {
1098:
1099: //
1100: // Throw the byte away since there's nowhere to put it.
1101: //
1102: byteBucket = FD8XX_READ_DATA(baseAddress);
1103: } else {
1104:
1105: //
1106: // Write a zero to the device.
1107: //
1108: FD8XX_WRITE_DATA(baseAddress, byteBucket);
1109: }
1110: }
1111:
1112: DeviceExtension->ActiveLu->ActiveLuRequest->SrbStatus =
1113: SRB_STATUS_DATA_OVERRUN;
1114: DeviceExtension->ActiveLu->OverRunCount++;
1115: if (DeviceExtension->ActiveLu->OverRunCount >= 5) {
1116: FdDebugPrint(0x200, (0, "Fd8xx: Turned on handshake\n"));
1117: DeviceExtension->ActiveLu->HandShakeAllData = TRUE;
1118: }
1119: continue;
1120: }
1121:
1122: //
1123: // First, copy the first bytes (if any) with REQ/ACK handshaking...
1124: //
1125: // NOTE: Some devices are REALLY slow when transferring inquiry
1126: // data. So, we'll treat any transfer less than a block
1127: // as a SLOW transfer. Also, all transfers performed when
1128: // the DISABLE_DISCONNECT bit was on in the SRB are done in
1129: // the slower, handshake per byte way. Finally some devices
1130: // tend to "dribble" bytes and need to have a handshake all
1131: // the time. These are found by a threshold of overruns being
1132: // encountered above. The single OR on the HandShake and SixByte
1133: // booleans is on purpose. This generates an or and conditional
1134: // jump where a double OR generates more code.
1135: //
1136: if (((DeviceExtension->ActiveLu->NoDisconnectActive) &&
1137: (DeviceExtension->ActiveLu->OverRunCount != 0)) ||
1138: (DeviceExtension->ActiveLu->HandShakeAllData |
1139: DeviceExtension->ActiveLu->SixByteCDBActive)) {
1140:
1141: headCount = DeviceExtension->CurDataLength;
1142: } else {
1143: if (MAX_BUFFER_LENGTH > DeviceExtension->CurDataLength) {
1144:
1145: headCount = DeviceExtension->CurDataLength;
1146: } else {
1147:
1148: if (DeviceExtension->CurDataLength & (MAX_BUFFER_LENGTH - 1)) {
1149:
1150: //
1151: // If the expected transfer is not a block multiple, do it
1152: // all the slow way. This will correct problems with NEC
1153: // CD drives when doing NEC CD audio commands.
1154: //
1155: headCount = DeviceExtension->CurDataLength;
1156: } else {
1157: headCount = min(MAX_HEAD_LENGTH,
1158: DeviceExtension->CurDataLength);
1159: }
1160: }
1161: }
1162:
1163: moveCount = 0;
1164:
1165: while (moveCount != headCount) {
1166:
1167: if (Fd8xxWaitForRequestLine(DeviceExtension) == FALSE) {
1168: ScsiPortLogError(DeviceExtension,
1169: DeviceExtension->ActiveLu->ActiveLuRequest,
1170: DeviceExtension->ActiveLu->ActiveLuRequest->PathId,
1171: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId,
1172: DeviceExtension->ActiveLu->ActiveLuRequest->Lun,
1173: SP_REQUEST_TIMEOUT,
1174: 11);
1175: break;
1176: }
1177:
1178: if (FD8XX_READ_PHASE(baseAddress) == BP_DATA_IN) {
1179:
1180: *((PUCHAR) DeviceExtension->CurDataPointer++) =
1181: FD8XX_READ_DATA(baseAddress);
1182: } else if (FD8XX_READ_PHASE(baseAddress) == BP_DATA_OUT) {
1183:
1184: FD8XX_WRITE_DATA(baseAddress,
1185: *((PUCHAR) DeviceExtension->CurDataPointer++));
1186: } else {
1187:
1188: //
1189: // Account for the number of bytes moved.
1190: //
1191: DeviceExtension->CurDataLength -= moveCount;
1192: goto Fd8xxCopyData_CheckNextPhase;
1193: }
1194: moveCount++;
1195: }
1196:
1197: DeviceExtension->CurDataLength -= moveCount;
1198:
1199: if (DeviceExtension->CurDataLength == 0) {
1200: goto Fd8xxCopyData_CheckNextPhase;
1201: }
1202:
1203: //
1204: // Now, calculate the the middle chunk for transfer without hanshaking...
1205: //
1206: moveCount = min(
1207: (DeviceExtension->CurDataLength & (MAX_BUFFER_LENGTH - 1)),
1208: MAX_BUFFER_LENGTH);
1209:
1210: if (moveCount >= MAX_TAIL_LENGTH) {
1211:
1212: moveCount -= MAX_TAIL_LENGTH;
1213: }
1214:
1215: if (wantedState == BP_DATA_IN) {
1216:
1217: ScsiPortReadRegisterBufferUchar((baseAddress + READ_SCSI),
1218: ((PUCHAR) DeviceExtension->CurDataPointer),
1219: moveCount);
1220: } else {
1221:
1222: ScsiPortWriteRegisterBufferUchar((baseAddress + WRITE_SCSI),
1223: ((PUCHAR) DeviceExtension->CurDataPointer),
1224: moveCount);
1225: }
1226:
1227: DeviceExtension->CurDataPointer += moveCount;
1228: DeviceExtension->CurDataLength -= moveCount;
1229:
1230: //
1231: // Finally, copy the last bytes (if any) with REQ/ACK handshaking...
1232: //
1233: tailCount = min(MAX_TAIL_LENGTH, DeviceExtension->CurDataLength);
1234: moveCount = 0;
1235:
1236: while ((moveCount != tailCount) &&
1237: (FD8XX_READ_PHASE(baseAddress) != BP_BUS_FREE) &&
1238: Fd8xxWaitForRequestLine(DeviceExtension)) {
1239:
1240: if (FD8XX_READ_PHASE(baseAddress) == BP_DATA_IN) {
1241:
1242: *((PUCHAR) DeviceExtension->CurDataPointer++) =
1243: FD8XX_READ_DATA(baseAddress);
1244: } else if (FD8XX_READ_PHASE(baseAddress) == BP_DATA_OUT) {
1245:
1246: FD8XX_WRITE_DATA(baseAddress,
1247: *((PUCHAR) DeviceExtension->CurDataPointer++));
1248: } else {
1249:
1250: DeviceExtension->CurDataLength -= moveCount;
1251: goto Fd8xxCopyData_CheckNextPhase;
1252: }
1253: moveCount++;
1254: }
1255:
1256: DeviceExtension->CurDataLength -= moveCount;
1257:
1258: if ((FD8XX_READ_PHASE(baseAddress) == BP_BUS_FREE) ||
1259: (Fd8xxWaitForRequestLine(DeviceExtension) == FALSE)) {
1260:
1261: DeviceExtension->ActiveLu->LuState = LS_UNDETERMINED;
1262: FdDebugPrint(0x04, (0, "NO REQUEST\n"));
1263: return;
1264: }
1265: }
1266:
1267: Fd8xxCopyData_CheckNextPhase:
1268:
1269: if (FD8XX_READ_PHASE(baseAddress) == BP_MESSAGE_IN) {
1270:
1271: //
1272: // The device most likely wants to disconnect.
1273: //
1274: DeviceExtension->ActiveLu->LuState = LS_MSG_IN;
1275:
1276: } else if (FD8XX_READ_PHASE(baseAddress) == BP_STATUS) {
1277:
1278: if (DeviceExtension->CurDataLength != 0) {
1279:
1280: //
1281: // We have an underrun condition. Update the count of bytes transferred.
1282: //
1283: FdDebugPrint(0x04, (0, "underrun "));
1284: DeviceExtension->ActiveLu->ActiveLuRequest->SrbStatus =
1285: SRB_STATUS_DATA_OVERRUN;
1286: DeviceExtension->ActiveLu->ActiveLuRequest->DataTransferLength -=
1287: DeviceExtension->CurDataLength;
1288: } else if (FD8XX_READ_STATUS(baseAddress) & S_PARITY) {
1289:
1290: //
1291: // We have a parity error.
1292: //
1293: FdDebugPrint(0x04, (0, "Parity Error! "));
1294: DeviceExtension->ActiveLu->ActiveLuRequest->SrbStatus =
1295: SRB_STATUS_PARITY_ERROR;
1296: ScsiPortLogError(DeviceExtension,
1297: DeviceExtension->ActiveLu->ActiveLuRequest,
1298: DeviceExtension->ActiveLu->ActiveLuRequest->PathId,
1299: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId,
1300: DeviceExtension->ActiveLu->ActiveLuRequest->Lun,
1301: SP_BUS_PARITY_ERROR,
1302: 3);
1303: }
1304:
1305: DeviceExtension->ActiveLu->LuState = LS_STATUS;
1306:
1307: } else {
1308:
1309: DeviceExtension->ActiveLu->LuState = LS_UNDETERMINED;
1310: FdDebugPrint(0x04, (0, "OTHER\n"));
1311: return;
1312: }
1313:
1314: FdDebugPrint(0x04, (0, "Done\n"));
1315: } // end Fd8xxCopyData()
1316:
1317:
1318: VOID
1319: Fd8xxStatus(
1320: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
1321: )
1322:
1323: /*++
1324:
1325: Routine Description:
1326:
1327: This routine will obtain the status from the target.
1328:
1329: Arguments:
1330:
1331: DeviceExtension - Device adapter context pointer.
1332:
1333: Return Value:
1334:
1335: None
1336:
1337: --*/
1338:
1339: {
1340: UCHAR status;
1341: UCHAR srbStatus;
1342: PSCSI_REQUEST_BLOCK srb = DeviceExtension->ActiveLu->ActiveLuRequest;
1343:
1344: Fd8xxClearControl(DeviceExtension, C_BUS_ENABLE);
1345:
1346: if (Fd8xxWaitForRequestLine(DeviceExtension) == FALSE) {
1347:
1348: DeviceExtension->ActiveLu->LuState = LS_UNDETERMINED;
1349: ScsiPortLogError(DeviceExtension,
1350: DeviceExtension->ActiveLu->ActiveLuRequest,
1351: DeviceExtension->ActiveLu->ActiveLuRequest->PathId,
1352: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId,
1353: DeviceExtension->ActiveLu->ActiveLuRequest->Lun,
1354: SP_REQUEST_TIMEOUT,
1355: 17);
1356: return;
1357: }
1358:
1359: status = FD8XX_READ_DATA(DeviceExtension->BaseAddress);
1360:
1361: //
1362: // Save this away for the driver above.
1363: //
1364: srb->ScsiStatus = status;
1365:
1366: FdDebugPrint(0x02, (0, "FdStatus: Returned status byte=%x\n", status));
1367:
1368: switch (status) {
1369:
1370: case SCSISTAT_GOOD:
1371: case SCSISTAT_CONDITION_MET:
1372: case SCSISTAT_INTERMEDIATE:
1373: case SCSISTAT_INTERMEDIATE_COND_MET:
1374:
1375: srbStatus = SRB_STATUS_SUCCESS;
1376: break;
1377:
1378: case SCSISTAT_CHECK_CONDITION:
1379: case SCSISTAT_COMMAND_TERMINATED:
1380:
1381: srbStatus = SRB_STATUS_ERROR;
1382: break;
1383:
1384: case SCSISTAT_BUSY:
1385: case SCSISTAT_RESERVATION_CONFLICT:
1386: case SCSISTAT_QUEUE_FULL:
1387: default:
1388:
1389: srbStatus = SRB_STATUS_BUSY;
1390: break;
1391: }
1392:
1393: //
1394: // If some error condition already occurred (e.g., parity error), we'll
1395: // let that one take priority.
1396: //
1397: if (srb->SrbStatus == SRB_STATUS_PENDING)
1398: srb->SrbStatus = srbStatus;
1399:
1400: DeviceExtension->ActiveLu->LuState = LS_MSG_IN;
1401: } // end Fd8xxStatus()
1402:
1403:
1404: VOID
1405: Fd8xxMessageIn(
1406: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
1407: )
1408:
1409: /*++
1410:
1411: Routine Description:
1412:
1413: This routine will receive the message from the target.
1414:
1415: Arguments:
1416:
1417: DeviceExtension - Device adapter context pointer.
1418:
1419: Return Value:
1420:
1421: None
1422:
1423: --*/
1424:
1425: {
1426: PSPECIFIC_LU_EXTENSION luExtension = DeviceExtension->ActiveLu;
1427: PSCSI_REQUEST_BLOCK srb = luExtension->ActiveLuRequest;
1428: PUCHAR baseAddress = DeviceExtension->BaseAddress;
1429: UCHAR msg;
1430:
1431: Fd8xxClearControl(DeviceExtension,
1432: C_BUS_ENABLE);
1433:
1434: luExtension->LuState = LS_UNDETERMINED;
1435:
1436: if (Fd8xxWaitForRequestLine(DeviceExtension) == FALSE) {
1437:
1438: ScsiPortLogError(DeviceExtension,
1439: DeviceExtension->ActiveLu->ActiveLuRequest,
1440: DeviceExtension->ActiveLu->ActiveLuRequest->PathId,
1441: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId,
1442: DeviceExtension->ActiveLu->ActiveLuRequest->Lun,
1443: SP_REQUEST_TIMEOUT,
1444: 15);
1445: return;
1446: }
1447:
1448: msg = FD8XX_READ_DATA(baseAddress);
1449:
1450: FdDebugPrint(0x08, (0, "FdMessageIn: message=%x -- ", msg));
1451:
1452: if (msg == SCSIMESS_DISCONNECT) {
1453:
1454: FdDebugPrint(0x08, (0, "DISCONNECT\n"));
1455:
1456: luExtension->LuState = LS_DISCONNECTED;
1457: luExtension->SavedDataPointer = DeviceExtension->CurDataPointer;
1458: luExtension->SavedDataLength = DeviceExtension->CurDataLength;
1459:
1460: DeviceExtension->ActiveLu = NULL;
1461:
1462: if (DeviceExtension->ContinueTimer) {
1463:
1464: //
1465: // Still need the timer to insure interrupts.
1466: //
1467: DeviceExtension->ExpectingInterrupt = TRUE;
1468: ScsiPortNotification(RequestTimerCall,
1469: DeviceExtension,
1470: Fd8xxTimer,
1471: FD8xx_TIMER_VALUE);
1472: }
1473:
1474: } else if (msg == SCSIMESS_SAVE_DATA_POINTER) {
1475:
1476: FdDebugPrint(0x08, (0, "SAVE POINTERS\n"));
1477:
1478: luExtension->SavedDataPointer = DeviceExtension->CurDataPointer;
1479: luExtension->SavedDataLength = DeviceExtension->CurDataLength;
1480:
1481: } else if ((msg == SCSIMESS_COMMAND_COMPLETE) ||
1482: (msg == SCSIMESS_LINK_CMD_COMP) ||
1483: (msg == SCSIMESS_LINK_CMD_COMP_W_FLAG)) {
1484:
1485: FdDebugPrint(0x08, (0, "COMPLETION\n"));
1486:
1487: luExtension->LuState = LS_COMPLETE;
1488:
1489: } else if (msg == SCSIMESS_RESTORE_POINTERS) {
1490:
1491: FdDebugPrint(0x08, (0, "RESTORE POINTERS\n"));
1492:
1493: //
1494: // The Srb is already correct; just restore the adapter context
1495: // pointers.
1496: //
1497: DeviceExtension->CurDataPointer = luExtension->SavedDataPointer;
1498: DeviceExtension->CurDataLength = luExtension->SavedDataLength;
1499:
1500: } else if ((msg == SCSIMESS_NO_OPERATION) ||
1501: (msg == SCSIMESS_MESSAGE_REJECT)) {
1502:
1503: if (srb->Function == SRB_FUNCTION_EXECUTE_SCSI) {
1504:
1505: //
1506: // We may be talking to a stupid device that cannot handle an
1507: // identify message. If this is the case, there's no telling
1508: // what it'll do next. Just let it take us where it wants and
1509: // hope we can recover.
1510: //
1511: FdDebugPrint(0x08, (0, "Identify "));
1512:
1513: } else {
1514:
1515: //
1516: // We were trying to tell the device to abort or reset and it
1517: // puked on the message. It's probably some old device that
1518: // cannot support these messages. So, just let the device take
1519: // us where it wants. If it's to cammand phase, we'll error this
1520: // out since there are no command bytes are associated w/ these
1521: // messages. Hopefully, it'll at least take us back to bus free.
1522: //
1523: srb->SrbStatus = SRB_STATUS_MESSAGE_REJECTED;
1524: FdDebugPrint(0x08, (0, "Abort/Reset "));
1525: }
1526:
1527: FdDebugPrint(0x08, (0, "REJECT\n"));
1528:
1529: } else if (msg == SCSIMESS_EXTENDED_MESSAGE) {
1530:
1531: UCHAR xMsgType;
1532: UCHAR xMsgLength;
1533:
1534: FdDebugPrint(0x08, (0, "EXTENDED "));
1535:
1536: if (Fd8xxStatusCheck(DeviceExtension,
1537: BP_MESSAGE_IN,
1538: BP_MESSAGE_IN,
1539: REQUEST_SPIN_WAIT)) {
1540:
1541: xMsgLength = FD8XX_READ_DATA(baseAddress);
1542: FdDebugPrint(0x08, (0, "length=%x ", xMsgLength));
1543:
1544: } else {
1545:
1546: //
1547: // This better NEVER happen! If it does, this device is
1548: // BRAINDEAD!!
1549: //
1550: goto Fd8xxMessageIn_PhaseSequenceFailure;
1551: }
1552:
1553: if (Fd8xxStatusCheck(DeviceExtension,
1554: BP_MESSAGE_IN,
1555: BP_MESSAGE_IN,
1556: REQUEST_SPIN_WAIT)) {
1557:
1558: xMsgType = FD8XX_READ_DATA(baseAddress);
1559: } else {
1560:
1561: goto Fd8xxMessageIn_PhaseSequenceFailure;
1562: }
1563:
1564: xMsgLength--; // Received one of the bytes.
1565:
1566: if (xMsgType == SCSIMESS_MODIFY_DATA_POINTER) {
1567:
1568: LONG offset = 0;
1569:
1570: FdDebugPrint(0x08, (0, "MODIFY "));
1571: while (xMsgLength-- != 0) {
1572:
1573: if (Fd8xxStatusCheck(DeviceExtension,
1574: BP_MESSAGE_IN,
1575: BP_MESSAGE_IN,
1576: REQUEST_SPIN_WAIT)) {
1577:
1578: *(((PUCHAR) &(offset)) + (3 - xMsgLength)) =
1579: FD8XX_READ_DATA(baseAddress);
1580: } else {
1581:
1582: goto Fd8xxMessageIn_PhaseSequenceFailure;
1583: }
1584: }
1585:
1586: //
1587: // All message bytes for this message were read. We can now
1588: // go and update our pointers as indicated by the juse-read
1589: // message. Keep in mind that the value of offset is a twos-
1590: // compliment value (i.e., negative).
1591: //
1592: FdDebugPrint(0x08, (0, "offset=%x\n", offset));
1593: DeviceExtension->CurDataPointer += offset;
1594: DeviceExtension->CurDataLength -= offset;
1595:
1596: } else {
1597:
1598: goto Fd8xxMessageIn_NotImplemented;
1599: }
1600:
1601: } else {
1602:
1603: Fd8xxMessageIn_NotImplemented:
1604:
1605: FdDebugPrint(0x08, (0, "NOT IMPLEMENTED\n"));
1606:
1607: Fd8xxSetControl(DeviceExtension, C_ATTENTION);
1608: ScsiPortStallExecution(1); // Delay 90 nanoseconds (2 * Bus-Deskew).
1609:
1610: while (Fd8xxWaitForRequestLine(DeviceExtension) &&
1611: (FD8XX_READ_PHASE(baseAddress) == BP_MESSAGE_IN)) {
1612:
1613: //
1614: // Ignore the rest of this message.
1615: //
1616: msg = FD8XX_READ_DATA(baseAddress);
1617: }
1618:
1619: if (FD8XX_READ_PHASE(baseAddress) == BP_MESSAGE_OUT) {
1620:
1621: Fd8xxSetControl(DeviceExtension, C_BUS_ENABLE);
1622: Fd8xxClearControl(DeviceExtension, C_ATTENTION);
1623: ScsiPortStallExecution(1); // Delay 90 nanoseconds.
1624: FD8XX_WRITE_DATA(baseAddress, SCSIMESS_MESSAGE_REJECT);
1625: }
1626:
1627: Fd8xxClearControl(DeviceExtension, C_ATTENTION);
1628: }
1629:
1630: return;
1631:
1632: Fd8xxMessageIn_PhaseSequenceFailure:
1633:
1634: srb->SrbStatus = SRB_STATUS_PHASE_SEQUENCE_FAILURE;
1635: ScsiPortLogError(DeviceExtension,
1636: srb,
1637: srb->PathId,
1638: srb->TargetId,
1639: srb->Lun,
1640: SP_PROTOCOL_ERROR,
1641: 4);
1642:
1643: FdDebugPrint(0x08,
1644: (0,
1645: "PHS SEQ ERROR=%x\n",
1646: FD8XX_READ_DATA(baseAddress)));
1647: return;
1648:
1649: } // end Fd8xxMessageIn()
1650:
1651:
1652: VOID
1653: Fd8xxNotifyCompletion(
1654: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
1655: )
1656:
1657: /*++
1658:
1659: Routine Description:
1660:
1661: This routine will perform any clean up operations for the Srb
1662: and notify the ScsiPort driver of completion.
1663:
1664: Arguments:
1665:
1666: DeviceExtension - Device adapter context pointer.
1667:
1668: Return Value:
1669:
1670: None
1671:
1672: --*/
1673:
1674: {
1675: PSPECIFIC_LU_EXTENSION luExtension = DeviceExtension->ActiveLu;
1676: PSCSI_REQUEST_BLOCK srb = luExtension->ActiveLuRequest;
1677:
1678: FdDebugPrint(0x110,
1679: (0, "FdComplete Dev = %x, Srb = %x, Srbstat = %x, Scsistat = %x\n",
1680: DeviceExtension,
1681: srb,
1682: srb->SrbStatus,
1683: srb->ScsiStatus));
1684:
1685: if (srb != NULL) {
1686: if (srb->SrbStatus == SRB_STATUS_PENDING) {
1687:
1688: srb->SrbStatus = SRB_STATUS_ERROR;
1689: ScsiPortLogError(DeviceExtension,
1690: luExtension->ActiveLuRequest,
1691: luExtension->ActiveLuRequest->PathId,
1692: luExtension->ActiveLuRequest->TargetId,
1693: luExtension->ActiveLuRequest->Lun,
1694: SP_INTERNAL_ADAPTER_ERROR,
1695: 5);
1696: }
1697: }
1698:
1699: luExtension->ActiveLuRequest = NULL;
1700: luExtension->NoDisconnectActive = FALSE;
1701: DeviceExtension->ActiveLu = NULL;
1702:
1703: //
1704: // Call notification routine.
1705: //
1706: if (srb != NULL) {
1707: ScsiPortNotification(RequestComplete,
1708: (PVOID) DeviceExtension,
1709: srb);
1710: }
1711:
1712: if (!(luExtension->AbortBeingAttempted)) {
1713:
1714: //
1715: // Adapter ready for next request.
1716: //
1717: ScsiPortNotification(NextRequest,
1718: DeviceExtension,
1719: NULL);
1720: }
1721:
1722: } // end Fd8xxNotifyCompletion()
1723:
1724:
1725: VOID
1726: Fd8xxRunPhase(
1727: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
1728: )
1729:
1730: /*++
1731:
1732: Routine Description:
1733:
1734: This routine runs through the bus phases until some type of completion
1735: indication is received. This can be when a message informing the host
1736: that the target will be disconnecting is received or when the SCSI bus
1737: goes to a free state.
1738:
1739: Arguments:
1740:
1741: DeviceExtension - Device adapter context pointer.
1742:
1743: Return Value:
1744:
1745: None.
1746:
1747: --*/
1748:
1749: {
1750: PUCHAR baseAddress = DeviceExtension->BaseAddress;
1751: ULONG undetermined = 0;
1752:
1753: while (DeviceExtension->ActiveLu != NULL) {
1754:
1755: switch (DeviceExtension->ActiveLu->LuState) {
1756:
1757: case LS_UNDETERMINED:
1758: Fd8xxDetermineNextState(DeviceExtension);
1759:
1760: if (undetermined++ == REQUEST_SPIN_WAIT) {
1761:
1762: //
1763: // Some CD-ROM drives like to be SCSI bus hogs
1764: // and hold the SCSI bus in COMMAND phase while feching
1765: // data (they also conveniently skip message out phase
1766: // so you can't tell it that you allow disconnect)!! So,
1767: // we better not time out if this happens.
1768: //
1769: if ((FD8XX_READ_PHASE(baseAddress) | S_REQUEST) !=
1770: BP_COMMAND) {
1771: FdDebugPrint(0x01, (0, "NO REQUEST\n"));
1772:
1773: DeviceExtension->ActiveLu->LuState = LS_COMPLETE;
1774: DeviceExtension->ActiveLu->ActiveLuRequest->SrbStatus =
1775: SRB_STATUS_PHASE_SEQUENCE_FAILURE;
1776:
1777: ScsiPortLogError(DeviceExtension,
1778: DeviceExtension->ActiveLu->ActiveLuRequest,
1779: DeviceExtension->ActiveLu->ActiveLuRequest->PathId,
1780: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId,
1781: DeviceExtension->ActiveLu->ActiveLuRequest->Lun,
1782: SP_PROTOCOL_ERROR,
1783: 16);
1784: }
1785: }
1786: break;
1787:
1788: case LS_ARBITRATE:
1789: Fd8xxArbitrate(DeviceExtension);
1790: break;
1791:
1792: case LS_SELECT:
1793: Fd8xxSelect(DeviceExtension);
1794: break;
1795:
1796: case LS_IDENTIFY:
1797: Fd8xxSendIdentify(DeviceExtension);
1798: break;
1799:
1800: case LS_MSG_SPECIAL:
1801: Fd8xxSendSpecialMessage(DeviceExtension);
1802: break;
1803:
1804: case LS_COMMAND:
1805: Fd8xxSendCDB(DeviceExtension);
1806: break;
1807:
1808: case LS_DATA:
1809: Fd8xxCopyData(DeviceExtension);
1810: break;
1811:
1812: case LS_STATUS:
1813: Fd8xxStatus(DeviceExtension);
1814: break;
1815:
1816: case LS_MSG_IN:
1817: Fd8xxMessageIn(DeviceExtension);
1818: break;
1819:
1820: case LS_COMPLETE:
1821: Fd8xxNotifyCompletion(DeviceExtension);
1822: break;
1823:
1824: default:
1825:
1826: DeviceExtension->ActiveLu->LuState = LS_COMPLETE;
1827: DeviceExtension->ActiveLu->ActiveLuRequest->SrbStatus =
1828: SRB_STATUS_PHASE_SEQUENCE_FAILURE;
1829:
1830: ScsiPortLogError(DeviceExtension,
1831: DeviceExtension->ActiveLu->ActiveLuRequest,
1832: DeviceExtension->ActiveLu->ActiveLuRequest->PathId,
1833: DeviceExtension->ActiveLu->ActiveLuRequest->TargetId,
1834: DeviceExtension->ActiveLu->ActiveLuRequest->Lun,
1835: SP_PROTOCOL_ERROR,
1836: 6);
1837: break;
1838: }
1839: }
1840: } // end Fd8xxRunPhase()
1841:
1842:
1843: VOID
1844: Fd8xxReenableAdapterInterrupts(
1845: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
1846: )
1847: /*++
1848:
1849: Routine Description:
1850:
1851: This routine doesn't really do anything. It is here to keep the
1852: SCSI port driver happy about what it can do with interrupts.
1853: The only time we should enable interrupts on selection is when we
1854: get a disconnect from a target.
1855:
1856: Arguments:
1857:
1858: DeviceExtension - Device adapter context pointer.
1859:
1860: Return Value:
1861:
1862: None.
1863:
1864: --*/
1865:
1866: {
1867: //
1868: // Re-enable interrupts on selection.
1869: //
1870: Fd8xxSetControl(DeviceExtension, C_INT_ENABLE);
1871:
1872: } // end Fd8xxReenableAdapterInterrupts()
1873:
1874:
1875: VOID
1876: Fd8xxDoReconnect(
1877: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
1878: )
1879:
1880: /*++
1881:
1882: Routine Description:
1883:
1884: This routine handles reconnecting devices. It basically plucks the
1885: target ID out of reselection phase, followed by the LUN out of
1886: message in phase (from the IDENTIFY message). Then, after validating
1887: the target/lun combination, starts up the state machine again for
1888: the reconnecting device.
1889:
1890: This routine should be called with interrupts enabled.
1891:
1892: Arguments:
1893:
1894: DeviceExtension - Device adapter context pointer.
1895:
1896: Return Value:
1897:
1898: None.
1899:
1900: --*/
1901:
1902: {
1903: PUCHAR baseAddress = DeviceExtension->BaseAddress;
1904: PSPECIFIC_LU_EXTENSION luExtension;
1905: USHORT busFreeTimeout;
1906: UCHAR target; // bit value returned from target
1907: UCHAR targetID; // numeric value of target ID.
1908: UCHAR lunID; // numeric value of LUN ID.
1909:
1910: //
1911: // Wait for the target to drop busy, which is the TRUE beginning of
1912: // reselection phase. If BUSY is not dropped within the indicated time,
1913: // abort the interrupt (and the reselect).
1914: //
1915: if (Fd8xxStatusCheck(DeviceExtension,
1916: BP_RESELECT,
1917: BP_RESELECT,
1918: RESELECTION_WAIT) == FALSE) {
1919:
1920: FdDebugPrint(0x20,
1921: (0, "BUSY not dropped: Status=%x\n",
1922: FD8XX_READ_STATUS(baseAddress)));
1923:
1924: goto Fd8xxDoReconnect_InvalidReselection;
1925: }
1926:
1927: //
1928: // Delay a bit to allow for something close to a bus settle time
1929: // before reading the target id bits.
1930: //
1931: ScsiPortStallExecution(1);
1932:
1933: //
1934: // Try to figure out who is reselecting.
1935: //
1936: target = (FD8XX_READ_DATA(baseAddress) & ~(1 << DeviceExtension->InitiatorId));
1937:
1938: FdDebugPrint(0x20, (0, "Target data=%x ", target));
1939:
1940: //
1941: // Convert the bit oriented target into a number.
1942: //
1943: for (targetID = ((UCHAR) -1); target != 0; target >>= 1) {
1944:
1945: targetID++;
1946: }
1947: FdDebugPrint(0x20, (0, "Target Id=%x ", targetID));
1948:
1949: //
1950: // Answer the reselection by raising busy. This should cause the target
1951: // to transition to MESSAGE IN phase so that we cen figure out which LUN
1952: // is associated with the reselecting target.
1953: //
1954: ScsiPortStallExecution(1); // Delay 400 nanoseconds (Bus-Settle).
1955: Fd8xxSetControl(DeviceExtension, C_BUSY);
1956:
1957: if (Fd8xxStatusCheck(DeviceExtension,
1958: BP_MESSAGE_IN,
1959: BP_MESSAGE_IN,
1960: REQUEST_SPIN_WAIT) == FALSE) {
1961:
1962: FdDebugPrint(0x20,
1963: (0, "REQ not raised: Status=%x\n",
1964: FD8XX_READ_STATUS(baseAddress)));
1965:
1966: goto Fd8xxDoReconnect_InvalidReselection;
1967: }
1968:
1969: //
1970: // The target should be driving BUSY now, so we should de-assert it in
1971: // control register (keep in mind that BUSY is or-tied).
1972: //
1973: Fd8xxClearControl(DeviceExtension, C_BUSY);
1974:
1975: lunID = FD8XX_READ_DATA(baseAddress) & (SCSI_MAXIMUM_LOGICAL_UNITS - 1);
1976: FdDebugPrint(0x20, (0, "Lun Id=%x ", lunID));
1977:
1978: if ((targetID >= SCSI_MAXIMUM_TARGETS) ||
1979: (lunID >= SCSI_MAXIMUM_LOGICAL_UNITS)) {
1980:
1981: FdDebugPrint(0x20,
1982: (0, "BAD Target/Lun: %x/%x\n",
1983: targetID, lunID));
1984:
1985: goto Fd8xxDoReconnect_InvalidReselection;
1986: }
1987:
1988: //
1989: // Re-enable adapter interrupts. Don't do this if we're being called
1990: // by the arbitration routine, because they will never have been turned
1991: // off in the first place, and we'll only confuse the port driver.
1992: //
1993: if (DeviceExtension->SavedLu == NULL) {
1994:
1995: ScsiPortNotification(CallDisableInterrupts,
1996: DeviceExtension,
1997: Fd8xxReenableAdapterInterrupts);
1998: }
1999:
2000: luExtension = ScsiPortGetLogicalUnit(DeviceExtension,
2001: DeviceExtension->PathId,
2002: targetID,
2003: lunID);
2004:
2005: if (luExtension == NULL) {
2006:
2007: //
2008: // This is the pathological case. This would indicate that when
2009: // the target ID bits were read there was a parity error or some
2010: // other problem that made it look like a reselection from a phantom
2011: // device.
2012: //
2013:
2014: ScsiPortLogError(DeviceExtension,
2015: NULL,
2016: 0,
2017: 0,
2018: 0,
2019: SP_INVALID_RESELECTION,
2020: (0x07 << 16) | (targetID << 8) | lunID);
2021: Fd8xxResetBus(DeviceExtension, DeviceExtension->PathId);
2022: ScsiPortNotification(ResetDetected, DeviceExtension, NULL);
2023: return;
2024: }
2025:
2026: if (luExtension->ActiveLuRequest == NULL) {
2027:
2028: //
2029: // This reconnect is not expected. There is no request for the
2030: // device.
2031: //
2032: ScsiPortLogError(DeviceExtension,
2033: NULL,
2034: 0,
2035: 0,
2036: 0,
2037: SP_INVALID_RESELECTION,
2038: (0x17 << 16) | (targetID << 8) | lunID);
2039: Fd8xxResetBus(DeviceExtension, DeviceExtension->PathId);
2040: ScsiPortNotification(ResetDetected, DeviceExtension, NULL);
2041: return;
2042: }
2043:
2044: if ((luExtension->AbortBeingAttempted) &&
2045: (DeviceExtension->SavedLu != NULL)) {
2046:
2047: //
2048: // We're being called while trying to arbitrate for an abort.
2049: // The LUN we're trying to abort is reconnecting, so complete the
2050: // abort from here, and force the arbitration routine to exit.
2051: //
2052: DeviceExtension->SavedLu->LuState = LS_COMPLETE;
2053: DeviceExtension->SavedLu->ActiveLuRequest->SrbStatus = SRB_STATUS_SUCCESS;
2054: goto Fd8xxDoReconnect_AbortReconnect;
2055: }
2056:
2057: DeviceExtension->CurDataPointer = luExtension->SavedDataPointer;
2058: DeviceExtension->CurDataLength = luExtension->SavedDataLength;
2059: DeviceExtension->ActiveLu = luExtension;
2060:
2061: luExtension->LuState = LS_UNDETERMINED;
2062:
2063: Fd8xxRunPhase(DeviceExtension);
2064:
2065: return;
2066:
2067: Fd8xxDoReconnect_InvalidReselection:
2068:
2069: ScsiPortLogError(DeviceExtension,
2070: NULL,
2071: 0,
2072: 0,
2073: 0,
2074: SP_INVALID_RESELECTION,
2075: (0x27 << 16) | (targetID << 8) | lunID);
2076:
2077: if (DeviceExtension->SavedLu == NULL) {
2078:
2079: ScsiPortNotification(CallDisableInterrupts,
2080: DeviceExtension,
2081: Fd8xxReenableAdapterInterrupts);
2082: }
2083:
2084: Fd8xxDoReconnect_AbortReconnect:
2085:
2086: //
2087: // Attempt to send an abort message to the target.
2088: //
2089: Fd8xxSetControl(DeviceExtension, C_ATTENTION);
2090: ScsiPortStallExecution(1); // Delay 90 nanoseconds (2 * Bus-Deskew).
2091:
2092: while (Fd8xxWaitForRequestLine(DeviceExtension) &&
2093: (FD8XX_READ_PHASE(baseAddress) != BP_MESSAGE_OUT)) {
2094:
2095: FD8XX_READ_DATA(baseAddress);
2096: }
2097:
2098: Fd8xxSetControl(DeviceExtension, C_BUS_ENABLE);
2099: Fd8xxClearControl(DeviceExtension, C_ATTENTION);
2100: ScsiPortStallExecution(1); // Delay 90 nanoseconds.
2101:
2102: if (FD8XX_READ_PHASE(baseAddress) == BP_MESSAGE_OUT) {
2103:
2104: FD8XX_WRITE_DATA(baseAddress, SCSIMESS_ABORT);
2105: }
2106:
2107: Fd8xxClearControl(DeviceExtension, C_BUS_ENABLE);
2108:
2109: busFreeTimeout = 2048;
2110: while ((FD8XX_READ_PHASE(baseAddress) & S_BUSY) && (busFreeTimeout--)) {
2111:
2112: if (FD8XX_READ_PHASE(baseAddress) & S_REQUEST) {
2113:
2114: FD8XX_READ_DATA(baseAddress);
2115: } else {
2116:
2117: ScsiPortStallExecution(100);
2118: }
2119: }
2120:
2121: if (FD8XX_READ_PHASE(baseAddress) != BP_BUS_FREE) {
2122:
2123: //
2124: // Reset SCSI bus. Drastic measures for drastic times...
2125: //
2126: Fd8xxResetBus(DeviceExtension, DeviceExtension->PathId);
2127: ScsiPortNotification(ResetDetected, DeviceExtension, NULL);
2128: }
2129: } // end Fd8xxDoReconnect()
2130:
2131:
2132: VOID
2133: Fd8xxTimer(
2134: IN PVOID Context
2135: )
2136:
2137: /*++
2138:
2139: Routine Description:
2140:
2141: This routine is used to monitor interrupts from the Fd8xx adapter.
2142: The ScsiPort support for a timer is used when a disconnect message is
2143: received to schedule this routine as a timer for later execution. If
2144: this routine is invoked before the interrupt and the adapter is attempting
2145: to select, then it is assumed that the adapter is on a different IRQ then
2146: expected and operation will continue in a "polling" mode. If the actual
2147: interrupt occurs before this routine is called, then everything is ok
2148: and this routine need not reschedule itself.
2149:
2150: Operation when called is to see if the actual interrupt routine serviced
2151: the interrupt. If so, then mark the device extension such that this
2152: routine is not rescheduled and return. If the actual interrupt routine
2153: has not serviced the interrupt and the adapter is indicating that a
2154: reselection is being attempted, then call the interrupt routine to service
2155: the interrupt and continue scheduling this routine. Lastly, if the
2156: interrupt routine has not serviced the interrupt and the adapter is not
2157: indicating a reselection, schedule another timer.
2158:
2159: Arguments:
2160:
2161: Context - Device adapter context pointer.
2162:
2163: Return Value
2164:
2165: TRUE indicates that the interrupt was from this Fd8xx adapter,
2166: FALSE indicates that this interrupt was NOT from us.
2167:
2168: --*/
2169:
2170: {
2171: PSPECIFIC_DEVICE_EXTENSION deviceExtension = Context;
2172: BOOLEAN restartTimer = TRUE;
2173:
2174: if (deviceExtension->ExpectingInterrupt == FALSE) {
2175:
2176: //
2177: // The interrupt routine got the interrupt. Decrement the number
2178: // of times to continue scheduling a timer routine.
2179: //
2180: deviceExtension->ContinueTimer--;
2181: return;
2182: }
2183:
2184: if (Fd8xxStatusCheck(deviceExtension, S_SELECT, S_SELECT, 1)) {
2185:
2186: //
2187: // If the interrupt routine does not claim this interrupt for some
2188: // reason, restart the timer. If it does claim the interrupt, shut
2189: // off the timer.
2190: //
2191: restartTimer = Fd8xxInterrupt(Context) == FALSE ? TRUE : FALSE;
2192:
2193: //
2194: // Now determine if an event log entry should be made to inform
2195: // the system administrator that there is a possible configuration
2196: // error on this driver.
2197: //
2198: if ((restartTimer == FALSE) &&
2199: (deviceExtension->NotifiedConfigurationError == FALSE)) {
2200: deviceExtension->TimerCaughtInterrupt--;
2201: if ((deviceExtension->TimerCaughtInterrupt == 0) &&
2202: (deviceExtension->ConfiguredWithoutInterrupts == FALSE)) {
2203: ScsiPortLogError(deviceExtension,
2204: NULL,
2205: 0,
2206: 0,
2207: 0,
2208: SP_IRQ_NOT_RESPONDING,
2209: 8);
2210: deviceExtension->NotifiedConfigurationError = TRUE;
2211: }
2212: }
2213: }
2214:
2215: if (restartTimer) {
2216:
2217: //
2218: // Not selected. Set timer for another call.
2219: //
2220: ScsiPortNotification(RequestTimerCall,
2221: deviceExtension,
2222: Fd8xxTimer,
2223: FD8xx_TIMER_VALUE);
2224: }
2225: }
2226:
2227:
2228: BOOLEAN
2229: Fd8xxInterrupt(
2230: IN PVOID Context
2231: )
2232:
2233: /*++
2234:
2235: Routine Description:
2236:
2237: This routine handles the interrupts for the FD8XX. The intention is to
2238: quickly determine the cause of the interrupt, clear the interrupt, and
2239: setup to process any SCSI command that may have been affected by the
2240: interrupt.
2241:
2242: Arguments:
2243:
2244: Context - Device adapter context pointer.
2245:
2246: Return Value:
2247:
2248: TRUE indicates that the interrupt was from this Fd8xx< adapter,
2249: FALSE indicates that this interrupt was NOT from us.
2250:
2251: --*/
2252:
2253: {
2254: PSPECIFIC_DEVICE_EXTENSION deviceExtension = Context;
2255:
2256: FdDebugPrint(0x20,
2257: (0, "\nFdInterrupt: Device = %x ",
2258: deviceExtension));
2259:
2260: if (Fd8xxStatusCheck(deviceExtension,
2261: S_SELECT,
2262: S_SELECT,
2263: 1) == FALSE) {
2264:
2265: //
2266: // Spurious interrupt or for some other device.
2267: //
2268: FdDebugPrint(0x20,
2269: (0, "NOT Selected: Status = %x, Last CtrlReg = %x\n",
2270: FD8XX_READ_STATUS(deviceExtension->BaseAddress),
2271: deviceExtension->ControlRegister));
2272: return FALSE;
2273:
2274: } else {
2275:
2276: //
2277: // We are being reselected by a target.
2278: //
2279: FdDebugPrint(0x20,
2280: (0, "Selected: Status = %x, Last CtrlReg = %x",
2281: FD8XX_READ_STATUS(deviceExtension->BaseAddress),
2282: deviceExtension->ControlRegister));
2283:
2284: deviceExtension->ExpectingInterrupt = FALSE;
2285: Fd8xxClearControl(deviceExtension, C_INT_ENABLE);
2286:
2287: //
2288: // Here's where the fun starts. We tell the OS to call DoReconnect
2289: // with system interrupts enabled. This way we're not transferring
2290: // gobs of data with the rest of the world blocked out. We can be
2291: // friendly neighbors and do that sort of CPU hungry stuff while
2292: // letting others grab it when necessary.
2293: //
2294: ScsiPortNotification(CallEnableInterrupts,
2295: deviceExtension,
2296: Fd8xxDoReconnect);
2297:
2298: return TRUE;
2299: }
2300: } // end Fd8xxInterrupt()
2301:
2302:
2303: VOID
2304: Fd8xxDpcRunPhase(
2305: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
2306: )
2307:
2308: /*++
2309:
2310: Routine Description:
2311:
2312: This routine is called by the port driver with interrupts enabled.
2313: It calls the normal run phase routine of the 8xx driver to process
2314: the request.
2315:
2316: Arguments:
2317:
2318: DeviceExtension - context pointer for the start or run phase.
2319:
2320: Return Value:
2321:
2322: None.
2323:
2324: --*/
2325:
2326: {
2327:
2328: Fd8xxRunPhase(DeviceExtension);
2329:
2330: ScsiPortNotification(CallDisableInterrupts,
2331: DeviceExtension,
2332: Fd8xxReenableAdapterInterrupts);
2333:
2334: //
2335: // Adapter ready for next request.
2336: //
2337: ScsiPortNotification(NextRequest,
2338: DeviceExtension,
2339: NULL);
2340: }
2341:
2342:
2343: VOID
2344: Fd8xxStartExecution(
2345: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
2346: IN PSPECIFIC_LU_EXTENSION LuExtension,
2347: IN PSCSI_REQUEST_BLOCK Srb
2348: )
2349:
2350: /*++
2351:
2352: Routine Description:
2353:
2354: This routine will start (and possibley complete) the execution of
2355: a SCSI request.
2356:
2357: Arguments:
2358:
2359: DeviceExtension - Device adapter context pointer.
2360: LuExtension - The logical unit specific information.
2361: Srb - The Srb command to execute.
2362:
2363: Return Value:
2364:
2365: None.
2366:
2367: --*/
2368:
2369: {
2370: FdDebugPrint(0x10,
2371: (0, "FdStartExecution Device = %x, LuExt = %x, Srb = %x ",
2372: DeviceExtension,
2373: LuExtension,
2374: Srb));
2375: FdDebugPrint(0x10,
2376: (0, "Target = %x, Lun = %x.\n",
2377: Srb->TargetId,
2378: Srb->Lun));
2379:
2380: //
2381: // Setup the context for this adapter.
2382: //
2383: DeviceExtension->ActiveLu = LuExtension;
2384:
2385: //
2386: // Turn off selection interrupt.
2387: //
2388: Fd8xxClearControl(DeviceExtension, C_INT_ENABLE);
2389:
2390: //
2391: // Check for potential tape access to insure handshake data transfer.
2392: // This is done here instead of in the deferred routine to save
2393: // two pointer loads (Srb and LuExtension).
2394: //
2395: if (Srb->CdbLength == 6) {
2396: LuExtension->SixByteCDBActive = TRUE;
2397: } else {
2398: LuExtension->SixByteCDBActive = FALSE;
2399: }
2400:
2401: //
2402: // Run the bus phase with other interrupts in the system enabled.
2403: //
2404: ScsiPortNotification(CallEnableInterrupts,
2405: DeviceExtension,
2406: Fd8xxDpcRunPhase);
2407: } // end Fd8xxStartExecution()
2408:
2409:
2410: VOID
2411: Fd8xxAbort(
2412: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
2413: IN PSPECIFIC_LU_EXTENSION LuExtension,
2414: IN PSCSI_REQUEST_BLOCK Srb
2415: )
2416:
2417: /*++
2418:
2419: Routine Description:
2420:
2421: Attempt to abort a command on a SCSI target.
2422:
2423: Arguments:
2424:
2425: DeviceExtension - The adapter specific information.
2426: LuExtension - The specific target/logical unit information.
2427: Srb - The Srb command to execute.
2428:
2429: Return Value:
2430:
2431: None.
2432:
2433: --*/
2434:
2435: {
2436: PUCHAR baseAddress = DeviceExtension->BaseAddress;
2437: PSCSI_REQUEST_BLOCK srbBeingAborted = LuExtension->ActiveLuRequest;
2438:
2439: FdDebugPrint(0x10, (0, "FdAbort: "));
2440:
2441: //
2442: // Make sure there is still a request to complete. If so complete
2443: // it with an SRB_STATUS_ABORTED status.
2444: //
2445: if (srbBeingAborted == NULL) {
2446:
2447: //
2448: // If there is no request, then fail the abort.
2449: //
2450: Srb->SrbStatus = SRB_STATUS_ABORT_FAILED;
2451:
2452: FdDebugPrint(0x10, (0, "failed.\n"));
2453:
2454: } else {
2455:
2456: if (LuExtension->LuState == LS_DISCONNECTED) {
2457:
2458: FdDebugPrint(0x10, (0, "sending...\n"));
2459:
2460: //
2461: // Attempt to send an abort message SRB into the state machine.
2462: //
2463: LuExtension->LuState = LS_ARBITRATE;
2464: LuExtension->AbortBeingAttempted = TRUE;
2465: DeviceExtension->ActiveLu = LuExtension;
2466: Fd8xxArbitrate(DeviceExtension);
2467:
2468: if ((LuExtension->LuState == LS_SELECT) ||
2469: (LuExtension->LuState == LS_COMPLETE)) {
2470:
2471: //
2472: // Finish off the abort.
2473: //
2474: Fd8xxRunPhase(DeviceExtension);
2475: LuExtension->AbortBeingAttempted = FALSE;
2476:
2477: //
2478: // Now force a completion on the SRB that is being aborted.
2479: //
2480: LuExtension->LuState = LS_COMPLETE;
2481: srbBeingAborted->SrbStatus = SRB_STATUS_ABORTED;
2482:
2483: LuExtension->ActiveLuRequest = srbBeingAborted;
2484: DeviceExtension->ActiveLu = LuExtension;
2485: Fd8xxNotifyCompletion(DeviceExtension);
2486:
2487: } else {
2488:
2489: LuExtension->AbortBeingAttempted = FALSE;
2490: Srb->SrbStatus = SRB_STATUS_ABORT_FAILED;
2491:
2492: FdDebugPrint(0x10, (0, "FdAbort failed.\n"));
2493: }
2494:
2495: } else if (LuExtension->LuState != LS_COMPLETE) {
2496:
2497: //
2498: // The SCSI bus is most likely hung by this LUN, so reset it.
2499: //
2500: FdDebugPrint(0x10, (0, "still connected to SCSI bus.\n"));
2501: Fd8xxResetBus(DeviceExtension, Srb->PathId);
2502: ScsiPortNotification(ResetDetected, DeviceExtension, NULL);
2503: }
2504: }
2505: } // end Fd8xxAbort()
2506:
2507:
2508: BOOLEAN
2509: Fd8xxResetBus(
2510: IN PVOID Context,
2511: IN ULONG PathId
2512: )
2513:
2514: /*++
2515:
2516: Routine Description:
2517:
2518: Reset Future Domain 8XX SCSI adapter (there is no action for this)
2519: and SCSI bus.
2520:
2521: Arguments:
2522:
2523: Context - pointer to the device extension for the reset.
2524: PathId - The bus for telling the port driver where the reset occurred.
2525:
2526: Return Value:
2527:
2528: Nothing.
2529:
2530: --*/
2531:
2532: {
2533: PSPECIFIC_DEVICE_EXTENSION deviceExtension = Context;
2534:
2535: FdDebugPrint(0x10, (0, "FdResetBus: Reset Fd8xx and SCSI bus\n"));
2536:
2537: //
2538: // RESET SCSI bus.
2539: //
2540: Fd8xxSetControl(deviceExtension,
2541: C_RESET);
2542: ScsiPortStallExecution(RESET_HOLD_TIME);
2543: Fd8xxClearControl(deviceExtension,
2544: C_RESET);
2545:
2546: //
2547: // Complete all outstanding requests with SRB_STATUS_BUS_RESET.
2548: //
2549: ScsiPortCompleteRequest(deviceExtension,
2550: (UCHAR) PathId,
2551: (UCHAR) -1,
2552: (UCHAR) -1,
2553: SRB_STATUS_BUS_RESET);
2554:
2555: //
2556: // Find all luExtensions and zero them out.
2557: //
2558: if (deviceExtension->ActiveLu != NULL) {
2559: deviceExtension->ActiveLu->LuState = LS_COMPLETE;
2560: deviceExtension->ActiveLu->ActiveLuRequest = NULL;
2561: deviceExtension->ActiveLu->NoDisconnectActive = FALSE;
2562: deviceExtension->ActiveLu->AbortBeingAttempted = FALSE;
2563: deviceExtension->ActiveLu = NULL;
2564: }
2565:
2566: if (deviceExtension->SavedLu != NULL) {
2567: deviceExtension->SavedLu->LuState = LS_COMPLETE;
2568: deviceExtension->SavedLu->ActiveLuRequest = NULL;
2569: deviceExtension->SavedLu->NoDisconnectActive = FALSE;
2570: deviceExtension->SavedLu->AbortBeingAttempted = FALSE;
2571: deviceExtension->SavedLu = NULL;
2572: }
2573:
2574: return TRUE;
2575: } // end Fd8xxResetBus()
2576:
2577:
2578: BOOLEAN
2579: Fd8xxStartIo(
2580: IN PVOID Context,
2581: IN PSCSI_REQUEST_BLOCK Srb
2582: )
2583:
2584: /*++
2585:
2586: Routine Description:
2587:
2588: This routine is called from the SCSI port driver synchronized
2589: with the kernel with a request to be executed.
2590:
2591: Arguments:
2592: Context - The adapter specific information.
2593: Srb - The Srb command to execute.
2594:
2595: Return Value:
2596:
2597: TRUE
2598:
2599: --*/
2600:
2601: {
2602: PSPECIFIC_DEVICE_EXTENSION deviceExtension = Context;
2603: PSPECIFIC_LU_EXTENSION luExtension;
2604:
2605: FdDebugPrint(0x10,
2606: (0, "\nFdStartIo: Device = %x, Srb = %x\n",
2607: deviceExtension,
2608: Srb));
2609:
2610: //
2611: // Determine the logical unit that this request is for.
2612: //
2613: deviceExtension->PathId = Srb->PathId;
2614: luExtension = ScsiPortGetLogicalUnit(deviceExtension,
2615: deviceExtension->PathId,
2616: Srb->TargetId,
2617: Srb->Lun);
2618: Srb->SrbStatus = SRB_STATUS_PENDING;
2619:
2620: switch (Srb->Function) {
2621:
2622: case SRB_FUNCTION_ABORT_COMMAND:
2623:
2624: FdDebugPrint(0x10, (0, "ABORT COMMAND.\n"));
2625:
2626: //
2627: // Abort request in progress.
2628: //
2629: // Fd8xxResetBus(deviceExtension, Srb->PathId);
2630: Fd8xxAbort(deviceExtension, luExtension, Srb);
2631: break;
2632:
2633: case SRB_FUNCTION_RESET_BUS:
2634:
2635: FdDebugPrint(0x10, (0, "RESET BUS.\n"));
2636:
2637: //
2638: // Reset Fd8xx and SCSI bus.
2639: //
2640: Fd8xxResetBus(deviceExtension, Srb->PathId);
2641: Srb->SrbStatus = SRB_STATUS_SUCCESS;
2642: break;
2643:
2644: case SRB_FUNCTION_EXECUTE_SCSI:
2645:
2646: FdDebugPrint(0x10, (0, "EXECUTE SCSI.\n"));
2647:
2648: //
2649: // Setup the context for this target/lun.
2650: //
2651: luExtension->ActiveLuRequest = Srb;
2652: luExtension->LuState = LS_ARBITRATE;
2653: luExtension->SavedDataPointer = (ULONG) Srb->DataBuffer;
2654: luExtension->SavedDataLength = Srb->DataTransferLength;
2655:
2656: //
2657: // Initiate a SCSI request.
2658: //
2659: Fd8xxStartExecution(deviceExtension, luExtension, Srb);
2660: return TRUE;
2661:
2662: default:
2663:
2664: Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
2665: ScsiPortNotification(RequestComplete,
2666: (PVOID) deviceExtension,
2667: Srb);
2668: break;
2669:
2670: }
2671:
2672: //
2673: // Adapter ready for next request.
2674: //
2675: ScsiPortNotification(NextRequest,
2676: deviceExtension,
2677: NULL);
2678: return TRUE;
2679: } // end Fd8xxStartIo()
2680:
2681:
2682: BOOLEAN
2683: Fd8xxInitialize(
2684: IN PVOID Context
2685: )
2686:
2687: /*++
2688:
2689: Routine Description:
2690:
2691: Inititialize Fd8xx adapter.
2692:
2693: Arguments:
2694:
2695: Context - Adapter object device extension.
2696:
2697: Return Value:
2698:
2699: Status.
2700:
2701: --*/
2702:
2703: {
2704: PSPECIFIC_DEVICE_EXTENSION deviceExtension = Context;
2705:
2706: //
2707: // Reset Fd8xx and SCSI bus.
2708: //
2709: Fd8xxWriteControl(deviceExtension, C_RESET);
2710: ScsiPortStallExecution(RESET_HOLD_TIME);
2711: Fd8xxClearControl(deviceExtension, C_RESET);
2712:
2713: ScsiPortNotification(ResetDetected,
2714: (PVOID) deviceExtension);
2715:
2716: Fd8xxClearControl(deviceExtension, C_INT_ENABLE);
2717: deviceExtension->ExpectingInterrupt = FALSE;
2718: deviceExtension->NotifiedConfigurationError = FALSE;
2719: deviceExtension->ContinueTimer = 5;
2720: deviceExtension->TimerCaughtInterrupt = 10;
2721: deviceExtension->ConfiguredWithoutInterrupts = FALSE;
2722:
2723: return TRUE;
2724: } // end Fd8xx<Initialize()
2725:
2726:
2727: BOOLEAN
2728: Fd8xxCheckBaseAddress(
2729: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
2730: IN PUCHAR BaseAddress
2731: )
2732:
2733: /*++
2734:
2735: Routine Description:
2736:
2737: This routine will check to see if there is an adapter at the
2738: provided base address. It does this by first reading and comparing
2739: all of the data area bytes on the adapter. If these are all equal
2740: it then changes the first value and performs the compare again.
2741: All other data area values should change to be equal to the first
2742: value when the change is made. If they are not equal any changes
2743: are restored.
2744:
2745: Arguments:
2746:
2747: DeviceExtension - Necessary to attempt the reads.
2748: BaseAddress - The address to attempt to use for the base of the
2749: memory area
2750:
2751: Return Value:
2752:
2753: TRUE - There is an adapter present at the base address provided.
2754: FALSE - There is no adapter present at the base address provided.
2755:
2756: --*/
2757:
2758: {
2759: UCHAR testValue;
2760: UCHAR oldValue;
2761: USHORT offset;
2762:
2763: oldValue = FD8XX_READ_DATA(BaseAddress);
2764:
2765: //
2766: // Perform a read test of the memory area of the adapter.
2767: //
2768: for (offset = 254; offset > 0; offset--) {
2769:
2770: testValue = FD8XX_READ_ALTERNATE_DATA(BaseAddress, offset);
2771: if (oldValue != testValue) {
2772:
2773: FdDebugPrint(0x20, (0, "Read test failed. "));
2774: return FALSE;
2775: }
2776: }
2777:
2778: FdDebugPrint(0x20, (0, "Read test passed. "));
2779:
2780: //
2781: // Card may be present in the system. Perform a write test.
2782: // The write value is insured to be different than the previous
2783: // value by adding 1
2784: //
2785: oldValue++;
2786: Fd8xxWriteControl(DeviceExtension,
2787: (C_BUS_ENABLE | C_PARITY_ENABLE));
2788:
2789: FD8XX_WRITE_DATA(BaseAddress, oldValue);
2790:
2791: for (offset = 254; offset > 0; offset--) {
2792:
2793: testValue = FD8XX_READ_ALTERNATE_DATA(BaseAddress, offset);
2794:
2795: if (oldValue != testValue) {
2796:
2797: oldValue--; // Get the original value and restore it.
2798: FD8XX_WRITE_DATA(BaseAddress, oldValue);
2799: FdDebugPrint(0x20, (0, "Write test failed. "));
2800: return FALSE;
2801: }
2802: }
2803:
2804: FdDebugPrint(0x20, (0, "Write test passed. "));
2805:
2806: return TRUE;
2807: } // end Fd8xxCheckBaseAddress()
2808:
2809:
2810: ULONG
2811: Fd8xxParseArgumentString(
2812: IN PCHAR String,
2813: IN PCHAR KeyWord
2814: )
2815:
2816: /*++
2817:
2818: Routine Description:
2819:
2820: This routine will parse the string for a match on the keyword, then
2821: calculate the value for the keyword and return it to the caller.
2822:
2823: Arguments:
2824:
2825: String - The ASCII string to parse.
2826: KeyWord - The keyword for the value desired.
2827:
2828: Return Values:
2829:
2830: Zero if value not found
2831: Value converted from ASCII to binary.
2832:
2833: --*/
2834:
2835: {
2836: PCHAR cptr;
2837: PCHAR kptr;
2838: ULONG value;
2839: ULONG stringLength = 0;
2840: ULONG keyWordLength = 0;
2841: ULONG index;
2842:
2843: //
2844: // Calculate the string length and lower case all characters.
2845: //
2846: cptr = String;
2847: while (*cptr) {
2848:
2849: if (*cptr >= 'A' && *cptr <= 'Z') {
2850: *cptr = *cptr + ('a' - 'A');
2851: }
2852: cptr++;
2853: stringLength++;
2854: }
2855:
2856: //
2857: // Calculate the keyword length and lower case all characters.
2858: //
2859: cptr = KeyWord;
2860: while (*cptr) {
2861:
2862: if (*cptr >= 'A' && *cptr <= 'Z') {
2863: *cptr = *cptr + ('a' - 'A');
2864: }
2865: cptr++;
2866: keyWordLength++;
2867: }
2868:
2869: if (keyWordLength > stringLength) {
2870:
2871: //
2872: // Can't possibly have a match.
2873: //
2874: return 0;
2875: }
2876:
2877: //
2878: // Now setup and start the compare.
2879: //
2880: cptr = String;
2881:
2882: ContinueSearch:
2883: //
2884: // The input string may start with white space. Skip it.
2885: //
2886: while (*cptr == ' ' || *cptr == '\t') {
2887: cptr++;
2888: }
2889:
2890: if (*cptr == '\0') {
2891:
2892: //
2893: // end of string.
2894: //
2895: return 0;
2896: }
2897:
2898: kptr = KeyWord;
2899: while (*cptr++ == *kptr++) {
2900:
2901: if (*(cptr - 1) == '\0') {
2902:
2903: //
2904: // end of string
2905: //
2906: return 0;
2907: }
2908: }
2909:
2910: if (*(kptr - 1) == '\0') {
2911:
2912: //
2913: // May have a match backup and check for blank or equals.
2914: //
2915:
2916: cptr--;
2917: while (*cptr == ' ' || *cptr == '\t') {
2918: cptr++;
2919: }
2920:
2921: //
2922: // Found a match. Make sure there is an equals.
2923: //
2924: if (*cptr != '=') {
2925:
2926: //
2927: // Not a match so move to the next semicolon.
2928: //
2929: while (*cptr) {
2930: if (*cptr++ == ';') {
2931: goto ContinueSearch;
2932: }
2933: }
2934: return 0;
2935: }
2936:
2937: //
2938: // Skip the equals sign.
2939: //
2940: cptr++;
2941:
2942: //
2943: // Skip white space.
2944: //
2945: while ((*cptr == ' ') || (*cptr == '\t')) {
2946: cptr++;
2947: }
2948:
2949: if (*cptr == '\0') {
2950:
2951: //
2952: // Early end of string, return not found
2953: //
2954: return 0;
2955: }
2956:
2957: if (*cptr == ';') {
2958:
2959: //
2960: // This isn't it either.
2961: //
2962: cptr++;
2963: goto ContinueSearch;
2964: }
2965:
2966: value = 0;
2967: if ((*cptr == '0') && (*(cptr + 1) == 'x')) {
2968:
2969: //
2970: // Value is in Hex. Skip the "0x"
2971: //
2972: cptr += 2;
2973: for (index = 0; *(cptr + index); index++) {
2974:
2975: if (*(cptr + index) == ' ' ||
2976: *(cptr + index) == '\t' ||
2977: *(cptr + index) == ';') {
2978: break;
2979: }
2980:
2981: if ((*(cptr + index) >= '0') && (*(cptr + index) <= '9')) {
2982: value = (16 * value) + (*(cptr + index) - '0');
2983: } else {
2984: if ((*(cptr + index) >= 'a') && (*(cptr + index) <= 'f')) {
2985: value = (16 * value) + (*(cptr + index) - 'a' + 10);
2986: } else {
2987:
2988: //
2989: // Syntax error, return not found.
2990: //
2991: return 0;
2992: }
2993: }
2994: }
2995: } else {
2996:
2997: //
2998: // Value is in Decimal.
2999: //
3000: for (index = 0; *(cptr + index); index++) {
3001:
3002: if (*(cptr + index) == ' ' ||
3003: *(cptr + index) == '\t' ||
3004: *(cptr + index) == ';') {
3005: break;
3006: }
3007:
3008: if ((*(cptr + index) >= '0') && (*(cptr + index) <= '9')) {
3009: value = (10 * value) + (*(cptr + index) - '0');
3010: } else {
3011:
3012: //
3013: // Syntax error return not found.
3014: //
3015: return 0;
3016: }
3017: }
3018: }
3019:
3020: return value;
3021: } else {
3022:
3023: //
3024: // Not a match check for ';' to continue search.
3025: //
3026: while (*cptr) {
3027: if (*cptr++ == ';') {
3028: goto ContinueSearch;
3029: }
3030: }
3031:
3032: return 0;
3033: }
3034: }
3035:
3036:
3037: BOOLEAN
3038: Fd8xxFindSignature(
3039: PUCHAR romAddress,
3040: PUCHAR p1RomBiosId)
3041:
3042: /*++
3043:
3044: Routine Description:
3045:
3046: This routine searches for a P2 ROM BIOS signature within the rom address
3047: provided.
3048:
3049: Arguments:
3050:
3051: romAddress - Location to search
3052: p1RomBiosId - BIOS string to match
3053:
3054: Return Values:
3055:
3056: TRUE if found
3057: FALSE otherwise
3058:
3059: --*/
3060:
3061: {
3062: USHORT count = 64; // Check first 64 bytes of ROM space.
3063: PUCHAR ptr1 = romAddress;
3064:
3065: while (count--) {
3066:
3067: PUCHAR ptr2 = ptr1++;
3068: PUCHAR ptr3 = p1RomBiosId;
3069: UCHAR c = ScsiPortReadRegisterUchar(ptr2);
3070:
3071: while (c == *ptr3++) {
3072:
3073: ptr2++;
3074: c = ScsiPortReadRegisterUchar(ptr2);
3075:
3076: if (*ptr3 == '\0')
3077: return TRUE;
3078:
3079: if (c == '\0')
3080: return FALSE;
3081: }
3082: }
3083:
3084: return FALSE;
3085: }
3086:
3087:
3088: BOOLEAN
3089: Fd8xxVerifyPatriot1(
3090: PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
3091: PPORT_CONFIGURATION_INFORMATION ConfigInfo
3092: )
3093:
3094: /*++
3095:
3096: Routine Descriptions:
3097:
3098: This routine verifies the presence of a P2 ROM based adapter.
3099:
3100: Arguments:
3101:
3102: DeviceExtension - call context.
3103: ConfigInfo - system provided configuration information.
3104:
3105: Return Value:
3106:
3107: TRUE if found
3108: FALSE otherwise
3109:
3110: --*/
3111:
3112: {
3113: UCHAR p1RomBiosId[] = "IBM F1 BIOS";
3114: BOOLEAN retval;
3115:
3116: if (Fd8xxFindSignature(DeviceExtension->BaseAddress, p1RomBiosId)) {
3117:
3118: //
3119: // We have a patriot-1 adapter installed.
3120: //
3121: retval = TRUE;
3122:
3123: } else {
3124:
3125: retval = FALSE;
3126: }
3127:
3128: return retval;
3129: }
3130:
3131:
3132: ULONG
3133: Fd8xxFindAdapter(
3134: IN PVOID Context,
3135: IN PVOID AdaptersFound,
3136: IN PVOID BusInformation,
3137: IN PCHAR ArgumentString,
3138: IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
3139: OUT PBOOLEAN Again
3140: )
3141:
3142: /*++
3143:
3144: Routine Description:
3145:
3146: This routine maps the memory area for the FD8XX adapter into
3147: the virtual address space for the system. It then attempts to
3148: find the adapter and set the configuration information. If
3149: the adapter is not present in the system (or cannot be found)
3150: this routine returnes an indication as such (i.e. FALSE).
3151:
3152: Arguments:
3153:
3154: Context - The device specific context for the call.
3155: AdaptersFound - Passed through from the driver entry as additional
3156: context for the call.
3157: BusInformation - Unused.
3158: ArgumentString - Points to the potential IRQ for this adapter.
3159: ConfigInfo - Pointer to the configuration information structure to
3160: be filled in.
3161: Again - Returns back a request to call this function again.
3162:
3163: Return Value:
3164:
3165: SP_RETURN_FOUND - if an adapter is found.
3166: SP_RETURN_NOT_FOUND - if no adapter is found.
3167:
3168: --*/
3169:
3170: {
3171: USHORT curBaseAddress;
3172: USHORT adaptersFound;
3173: ULONG returnStatus = SP_RETURN_NOT_FOUND;
3174: PSPECIFIC_DEVICE_EXTENSION deviceExtension = Context;
3175: ULONG baseAddresses[] =
3176: {
3177: 0x000c8000,
3178: 0x000ca000,
3179: 0x000ce000,
3180: 0x000de000,
3181: 0x000e8000,
3182: 0x000ea000,
3183: 0
3184: };
3185:
3186: //
3187: // This must never be set to TRUE for this controller. If we return
3188: // TRUE for this parameter, the SCSI port driver will not move to the
3189: // next entry in the registry for the next controller of this type.
3190: // Instead, it will call this routine again with the SAME registry
3191: // information (i.e., IRQ vector) causing the next adapter with a
3192: // DIFFERENT IRQ to fail to install.
3193: //
3194: *Again = FALSE;
3195:
3196: curBaseAddress = (USHORT) (*((PULONG) AdaptersFound) >> 16);
3197: adaptersFound = (USHORT) (*((PULONG) AdaptersFound));
3198:
3199: if ((baseAddresses[curBaseAddress] == 0) ||
3200: (adaptersFound == MAX_ADAPTERS)) {
3201:
3202: return SP_RETURN_NOT_FOUND;
3203: }
3204:
3205: while ((baseAddresses[curBaseAddress] != 0) &&
3206: (adaptersFound != MAX_ADAPTERS) &&
3207: (returnStatus == SP_RETURN_NOT_FOUND)) {
3208:
3209: PUCHAR baseAddress;
3210:
3211: FdDebugPrint(0x20,
3212: (0, "Fd8xxFindAdapter: baseAddresses[%x] = %x, ",
3213: curBaseAddress,
3214: baseAddresses[curBaseAddress]));
3215: FdDebugPrint(0x20,
3216: (0, "%x adapters found so far.\n",
3217: adaptersFound));
3218:
3219: //
3220: // Map the TMC-950 chip into the virtual memory address space.
3221: // If ConfigInfo already has default information about this
3222: // controller, use it. If not, then we derive our own. This
3223: // is for Chicago compatibility.
3224: //
3225: if (ScsiPortConvertPhysicalAddressToUlong(
3226: (*ConfigInfo->AccessRanges)[0].RangeStart) != 0) {
3227:
3228: deviceExtension->BaseAddress = baseAddress =
3229: ScsiPortGetDeviceBase(
3230: deviceExtension,
3231: ConfigInfo->AdapterInterfaceType,
3232: ConfigInfo->SystemIoBusNumber,
3233: (*ConfigInfo->AccessRanges)[0].RangeStart,
3234: (*ConfigInfo->AccessRanges)[0].RangeLength,
3235: (BOOLEAN) !((*ConfigInfo->AccessRanges)[0].RangeInMemory));
3236: } else {
3237:
3238: deviceExtension->BaseAddress = baseAddress =
3239: ScsiPortGetDeviceBase(
3240: deviceExtension,
3241: ConfigInfo->AdapterInterfaceType,
3242: ConfigInfo->SystemIoBusNumber,
3243: ScsiPortConvertUlongToPhysicalAddress(baseAddresses[curBaseAddress]),
3244: (FD8XX_ADDRESS_SIZE), // NumberOfBytes
3245: (BOOLEAN) FALSE); // InIoSpace
3246: }
3247: FdDebugPrint(0x20,
3248: (0, "MmMapIoSpace address = %x ",
3249: baseAddress));
3250:
3251: //
3252: // Determine if the card is really installed in the system.
3253: //
3254: if (Fd8xxCheckBaseAddress(deviceExtension, baseAddress) == FALSE) {
3255:
3256: //
3257: // We did not find an adapter at this baseAddress. Free the
3258: // mapped memory space and continue with the next address if
3259: // there is one.
3260: //
3261: returnStatus = SP_RETURN_NOT_FOUND;
3262: ScsiPortFreeDeviceBase(deviceExtension,
3263: (PVOID) baseAddress);
3264:
3265: } else {
3266:
3267: returnStatus = SP_RETURN_FOUND;
3268:
3269: //
3270: // If there was no previously configured value for the IRQ,
3271: // look at the other way to configure the value or use a default.
3272: //
3273: if (ConfigInfo->BusInterruptLevel == 0) {
3274:
3275: ConfigInfo->BusInterruptLevel = FD8XX_IDT_VECTOR;
3276:
3277: if (ArgumentString != NULL) {
3278: ULONG irq = Fd8xxParseArgumentString(ArgumentString, "irq");
3279:
3280: if (irq == 0) {
3281:
3282: //
3283: // Check for the old way.
3284: //
3285: irq = *((PULONG)ArgumentString);
3286: if (irq > 15) {
3287:
3288: //
3289: // really was intended to be zero.
3290: //
3291: irq = 0;
3292: deviceExtension->ConfiguredWithoutInterrupts = TRUE;
3293: } else {
3294: irq = FD8XX_IDT_VECTOR;
3295: }
3296: }
3297:
3298: FdDebugPrint(0x20,
3299: (0,
3300: "IRQ %d passed in. ",
3301: irq));
3302: ConfigInfo->BusInterruptLevel = irq;
3303: } else {
3304:
3305: FdDebugPrint(0x20, (0, "default IRQ. "));
3306: }
3307: } else {
3308:
3309: FdDebugPrint(0x20,
3310: (0,
3311: "IRQ previously set to %d. ",
3312: ConfigInfo->BusInterruptLevel));
3313: }
3314:
3315: //
3316: // If the user has not specified a target ID, fill in a default.
3317: //
3318: if (ConfigInfo->InitiatorBusId[0] == (UCHAR)SP_UNINITIALIZED_VALUE) {
3319:
3320: deviceExtension->InitiatorId = SCSI_INITIATOR_ID;
3321: ConfigInfo->InitiatorBusId[0] = SCSI_INITIATOR_ID;
3322: } else {
3323:
3324: deviceExtension->InitiatorId = ConfigInfo->InitiatorBusId[0];
3325: FdDebugPrint(0x20,
3326: (0,
3327: "Initiator ID set to %d ",
3328: ConfigInfo->InitiatorBusId[0]));
3329: }
3330:
3331: //
3332: // Fill in the access array information only if there are no
3333: // default parameters already there.
3334: //
3335: if (ScsiPortConvertPhysicalAddressToUlong(
3336: (*ConfigInfo->AccessRanges)[0].RangeStart) == 0) {
3337:
3338: //
3339: // There is no pre-assigned information in the ConfigInfo
3340: // structure derived by Chicago. Thus, we can fill
3341: // our own derived information into the ConfigInfo structure.
3342: // Otherwise WE MUST NOT change the ConfigInfo structure, as
3343: // this will overwrite the Chicago-prestored information.
3344: //
3345: (*ConfigInfo->AccessRanges)[0].RangeStart =
3346: ScsiPortConvertUlongToPhysicalAddress(baseAddresses[curBaseAddress]);
3347: (*ConfigInfo->AccessRanges)[0].RangeLength = FD8XX_ADDRESS_SIZE;
3348: (*ConfigInfo->AccessRanges)[0].RangeInMemory = TRUE;
3349:
3350: ConfigInfo->ScatterGather = FALSE;
3351: ConfigInfo->Master = FALSE;
3352: ConfigInfo->MaximumTransferLength = MAX_TRANSFER_LENGTH;
3353: ConfigInfo->NumberOfBuses = 1;
3354:
3355: if (Fd8xxVerifyPatriot1(deviceExtension, ConfigInfo)) {
3356:
3357: //
3358: // We have a Patriot-I adapter installed in the system
3359: // which scans from Target ID 7 to Target ID 0.
3360: //
3361: ConfigInfo->AdapterScansDown = TRUE;
3362: }
3363: }
3364:
3365: adaptersFound++;
3366: }
3367:
3368: curBaseAddress++;
3369:
3370: FdDebugPrint(0x20, (0, "\n"));
3371: }
3372:
3373: *((PULONG) AdaptersFound) = ((ULONG) curBaseAddress) << 16;
3374: *((PULONG) AdaptersFound) += (ULONG) adaptersFound;
3375:
3376: return returnStatus;
3377: } // end Fd8xxFindAdapter()
3378:
3379:
3380: BOOLEAN
3381: Fd8xxAdapterState(
3382: IN PVOID DeviceExtension,
3383: IN PVOID AdaptersFound,
3384: IN BOOLEAN SaveState
3385: )
3386:
3387: /*++
3388:
3389: Routine Description:
3390:
3391: Saves/restores adapter's real-mode configuration state.
3392:
3393: Arguments:
3394:
3395: DeviceExtension - Adapter object device extension.
3396: AdaptersFound - Passed through from DriverEntry as additional
3397: context for the call.
3398: SaveState - TRUE = Save adapter state, FALSE = restore state.
3399:
3400: Return Value:
3401:
3402: The spec did not intend for this routine to have a return value.
3403: Whoever did the header file just forgot to change the BOOLEAN to
3404: a VOID. We will just return FALSE to shot the compiler up.
3405:
3406: --*/
3407:
3408: {
3409: return FALSE;
3410: }
3411:
3412:
3413: ULONG
3414: DriverEntry(
3415: IN PVOID DriverObject,
3416: IN PVOID Argument2
3417: )
3418:
3419: /*++
3420:
3421: Routine Description:
3422:
3423: Driver initialization entry point for system.
3424:
3425: Arguments:
3426:
3427: DriverObject - The driver specific object pointer
3428: Argument2 - not used.
3429:
3430: Return Value:
3431:
3432: Status from ScsiPortInitialize()
3433:
3434: --*/
3435:
3436: {
3437: HW_INITIALIZATION_DATA hwInitializationData;
3438: ULONG i;
3439:
3440: FdDebugPrint(0x20, (0, "\nSCSI Future Domain 8XX Miniport Driver\n"));
3441:
3442: //
3443: // Zero out the hwInitializationData structure.
3444: //
3445: for (i = 0; i < sizeof(HW_INITIALIZATION_DATA); i++) {
3446:
3447: *(((PUCHAR)&hwInitializationData + i)) = 0;
3448: }
3449:
3450: hwInitializationData.HwInitializationDataSize = sizeof(HW_INITIALIZATION_DATA);
3451:
3452: //
3453: // Set entry points.
3454: //
3455: hwInitializationData.HwInitialize = Fd8xxInitialize;
3456: hwInitializationData.HwStartIo = Fd8xxStartIo;
3457: hwInitializationData.HwInterrupt = Fd8xxInterrupt;
3458: hwInitializationData.HwFindAdapter = Fd8xxFindAdapter;
3459: hwInitializationData.HwResetBus = Fd8xxResetBus;
3460: hwInitializationData.HwAdapterState = Fd8xxAdapterState;
3461:
3462: //
3463: // Indicate need buffer mapping but not physical addresses.
3464: //
3465: hwInitializationData.MapBuffers = TRUE;
3466: hwInitializationData.NeedPhysicalAddresses = FALSE;
3467: hwInitializationData.NumberOfAccessRanges = 1;
3468:
3469: //
3470: // Specify size of device extension.
3471: //
3472: hwInitializationData.DeviceExtensionSize = sizeof(SPECIFIC_DEVICE_EXTENSION);
3473:
3474: //
3475: // Specify size of logical unit extension.
3476: //
3477: hwInitializationData.SpecificLuExtensionSize = sizeof(SPECIFIC_LU_EXTENSION);
3478:
3479: //
3480: // The fourth parameter below (i.e., "i") will show up as the
3481: // "AdaptersFound" parameter when FindAdapter() is called.
3482: //
3483:
3484: FdDebugPrint(0x20, (0, "Trying ISA...\n"));
3485: hwInitializationData.AdapterInterfaceType = Isa;
3486:
3487: i = 0;
3488: return ScsiPortInitialize(DriverObject,
3489: Argument2,
3490: &hwInitializationData,
3491: &(i));
3492:
3493: } // end DriverEntry()
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.