![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ncr53c9x.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / scsi / ncr53c9x|
Return to ncr53c9x.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / ncr53c9x |
1.1 root 1: /*++
2:
3: Copyright (c) 1990 Microsoft Corporation
4:
5: Module Name:
6:
7: ncr53c9x.c
8:
9: Abstract:
10:
11: This module contains the NCR 53c9x specific functions for the NT SCSI port
12: driver.
13:
14: Author:
15:
16: Jeff Havens (jhavens) 28-Feb-1991
17:
18: Environment:
19:
20: Kernel Mode only
21:
22: Revision History:
23:
24: --*/
25:
26: #include "miniport.h"
27: #include "scsi.h"
28:
29: #include "ncr53c9x.h"
30: #include "mcadefs.h"
31: #include "string.h"
32:
33: #include "jazzdef.h"
34: #include "jazzdma.h"
35:
36: #undef ASSERT
37: #if DBG
38: VOID
39: RtlAssert(
40: PVOID FailedAssertion,
41: PVOID FileName,
42: ULONG LineNumber,
43: PCHAR Message
44: );
45:
46: #define ASSERT( exp ) \
47: if (!(exp)) \
48: RtlAssert( #exp, __FILE__, __LINE__, NULL )
49:
50: #define ASSERTMSG( msg, exp ) \
51: if (!(exp)) \
52: RtlAssert( #exp, __FILE__, __LINE__, msg )
53:
54: #else
55: #define ASSERT( exp )
56: #define ASSERTMSG( msg, exp )
57: #endif // DBG
58:
59: #if DBG
60: int NcrDebug;
61: #define NcrPrint(arg) ScsiDebugPrint arg
62: #else
63: #define NcrPrint(arg)
64: #endif
65:
66: //
67: // Define SCSI Protocol Chip configuration parameters.
68: //
69:
70: #define INITIATOR_BUS_ID 0x7
71: #define SELECT_TIMEOUT_FACTOR 33
72: #define SYNCHRONOUS_OFFSET 0x0f
73: #define ASYNCHRONOUS_OFFSET 0
74: #define ASYNCHRONOUS_PERIOD 0x05
75: #define RESET_STALL_TIME 25 // The minimum assertion time for
76: // a SCSI bus reset.
77: #define INTERRUPT_STALL_TIME 5 // Time to wait for the next interrupt.
78:
79:
80: //
81: // NCR 53c9x specific port driver device extension flags.
82: //
83:
84: #define PD_SYNCHRONOUS_RESPONSE_SENT 0x0001
85: #define PD_SYNCHRONOUS_TRANSFER_SENT 0x0002
86: #define PD_PENDING_START_IO 0x0004
87: #define PD_MESSAGE_OUT_VALID 0x0008
88: #define PD_DISCONNECT_EXPECTED 0x0010
89: #define PD_SEND_MESSAGE_REQUEST 0x0020
90: #define PD_POSSIBLE_EXTRA_MESSAGE_OUT 0x0040
91: #define PD_PENDING_DATA_TRANSFER 0x0080
92: #define PD_PARITY_ERROR_LOGGED 0x0100
93: #define PD_EXPECTING_RESET_INTERRUPT 0x0200
94: #define PD_EXPECTING_QUEUE_TAG 0x0400
95: #define PD_TAGGED_SELECT 0x0800
96: #define PD_NCR_ADAPTER 0x1000
97:
98: //
99: // The following defines specify masks which are used to clear flags when
100: // specific events occur, such as reset or disconnect.
101: //
102:
103: #define PD_ADAPTER_RESET_MASK ( PD_SYNCHRONOUS_TRANSFER_SENT | \
104: PD_PENDING_START_IO | \
105: PD_MESSAGE_OUT_VALID | \
106: PD_SEND_MESSAGE_REQUEST | \
107: PD_POSSIBLE_EXTRA_MESSAGE_OUT | \
108: PD_PENDING_DATA_TRANSFER | \
109: PD_PARITY_ERROR_LOGGED | \
110: PD_EXPECTING_QUEUE_TAG | \
111: PD_TAGGED_SELECT | \
112: PD_DISCONNECT_EXPECTED \
113: )
114:
115: #define PD_ADAPTER_DISCONNECT_MASK ( PD_SYNCHRONOUS_TRANSFER_SENT | \
116: PD_MESSAGE_OUT_VALID | \
117: PD_SEND_MESSAGE_REQUEST | \
118: PD_POSSIBLE_EXTRA_MESSAGE_OUT | \
119: PD_PENDING_DATA_TRANSFER | \
120: PD_PARITY_ERROR_LOGGED | \
121: PD_EXPECTING_QUEUE_TAG | \
122: PD_TAGGED_SELECT | \
123: PD_DISCONNECT_EXPECTED \
124: )
125:
126: //
127: // The largest SCSI bus message expected.
128: //
129:
130: #define MESSAGE_BUFFER_SIZE 8
131:
132: //
133: // Retry count limits.
134: //
135:
136: #define RETRY_SELECTION_LIMIT 1
137: #define RETRY_ERROR_LIMIT 2
138: #define MAX_INTERRUPT_COUNT 64
139:
140: //
141: // Bus and chip states.
142: //
143:
144: typedef enum _ADAPTER_STATE {
145: BusFree,
146: AttemptingSelect,
147: CommandComplete,
148: CommandOut,
149: DataTransfer,
150: DisconnectExpected,
151: MessageAccepted,
152: MessageIn,
153: MessageOut,
154: Reselected
155: } ADAPTER_STATE, *PADAPTER_STATE;
156:
157: //
158: // Define the types of chips this driver will support.
159: //
160:
161: typedef enum _CHIP_TYPES {
162: Ncr53c90,
163: Ncr53c94,
164: Fas216,
165: Fas216Fast
166: }CHIP_TYPES, *PCHIP_TYPES;
167:
168: //
169: // NCR 53c9x specific port driver logical unit flags.
170: //
171:
172: #define PD_STATUS_VALID 0x0004
173: #define PD_DO_NOT_CHECK_TRANSFER_LENGTH 0x0008
174: #define PD_INITIATE_RECOVERY 0x0010
175: #define PD_QUEUED_COMMANDS_EXECUTING 0x0020
176:
177: //
178: // The following defines specify masks which are used to clear flags when
179: // specific events occur, such as reset or command complete.
180: //
181:
182: #define PD_LU_COMPLETE_MASK ( PD_STATUS_VALID | \
183: PD_DO_NOT_CHECK_TRANSFER_LENGTH | \
184: PD_INITIATE_RECOVERY \
185: )
186:
187: #define PD_LU_RESET_MASK ( PD_STATUS_VALID | \
188: PD_DO_NOT_CHECK_TRANSFER_LENGTH | \
189: PD_QUEUED_COMMANDS_EXECUTING | \
190: PD_INITIATE_RECOVERY \
191: )
192:
193: //
194: // NCR 53c9x specific port driver SRB extension.
195: //
196:
197: typedef struct _SRB_EXTENSION {
198: ULONG SrbExtensionFlags;
199: ULONG SavedDataPointer;
200: ULONG SavedDataLength;
201: ULONG MaximumTransferLength;
202: }SRB_EXTENSION, *PSRB_EXTENSION;
203:
204: #define SRB_EXT(x) ((PSRB_EXTENSION)(x->SrbExtension))
205:
206: //
207: // NCR 53c9x specific port driver logical unit extension.
208: //
209:
210: typedef struct _SPECIFIC_LOGICAL_UNIT_EXTENSION {
211: USHORT LuFlags;
212: UCHAR RetryCount;
213: ULONG SavedDataPointer;
214: ULONG SavedDataLength;
215: PSCSI_REQUEST_BLOCK ActiveLuRequest;
216: PSCSI_REQUEST_BLOCK ActiveSendRequest;
217: }SPECIFIC_LOGICAL_UNIT_EXTENSION, *PSPECIFIC_LOGICAL_UNIT_EXTENSION;
218:
219: //
220: // NCR 53c9x specific per target controller information.
221: //
222:
223: typedef struct _SPECIFIC_TARGET_EXTENSION {
224: UCHAR TargetFlags;
225: UCHAR SynchronousPeriod;
226: UCHAR SynchronousOffset;
227: SCSI_CONFIGURATION3 Configuration3;
228: }SPECIFIC_TARGET_EXTENSION, *PSPECIFIC_TARGET_EXTENSION;
229:
230: //
231: // Define target controller specific flags.
232: //
233:
234: #define PD_SYNCHRONOUS_NEGOTIATION_DONE 0x0001
235: #define PD_DO_NOT_NEGOTIATE 0x0002
236:
237: //
238: // NCR 53c9x specific port driver device object extension.
239: //
240:
241: typedef struct _SPECIFIC_DEVICE_EXTENSION {
242: ULONG AdapterFlags;
243: ADAPTER_STATE AdapterState; // Current state of the adapter
244: PADAPTER_REGISTERS AdapterBase; // Address of the NCR 53c9x adapter
245: PSCSI_REGISTERS Adapter; // Address of the NCR 53c9x chip
246: PSCSI_REQUEST_BLOCK ActiveLuRequest;
247: PSPECIFIC_LOGICAL_UNIT_EXTENSION ActiveLogicalUnit;
248: // Pointer to the acitive request.
249: PSCSI_REQUEST_BLOCK NextSrbRequest; // Pointer to the next SRB to process.
250: ULONG ActiveDataPointer; // SCSI bus active data pointer
251: ULONG ActiveDataLength; // The amount of data to be transferred.
252: LONG InterruptCount; // Count of interrupts since connection.
253: SPECIFIC_TARGET_EXTENSION TargetState[SCSI_MAXIMUM_TARGETS];
254: CHIP_TYPES ChipType; // Type or version of the chip.
255: SCSI_STATUS AdapterStatus; // Saved status register value
256: SCSI_SEQUENCE_STEP SequenceStep; // Saved sequence step register value
257: SCSI_INTERRUPT AdapterInterrupt; // Saved interrupt status register
258: SCSI_CONFIGURATION3 Configuration3;
259: UCHAR AdapterBusId; // This adapter's SCSI bus ID
260: UCHAR AdapterBusIdMask; // This adapter's SCSI bus ID bit mask
261: UCHAR ClockSpeed; // Chip clock speed in megahetrz.
262: BOOLEAN InterruptPending; // Interrupt pending indicator
263: UCHAR MessageBuffer[MESSAGE_BUFFER_SIZE]; // SCSI bus message buffer
264: UCHAR MessageCount; // Count of bytes in message buffer
265: UCHAR MessageSent; // Count of bytes sent to target
266: UCHAR TargetId; // Saved target id.
267: UCHAR Lun; // Saved lun id.
268: UCHAR ErrorCount;
269: } SPECIFIC_DEVICE_EXTENSION, *PSPECIFIC_DEVICE_EXTENSION;
270:
271:
272: //
273: // Define the synchrouns data transfer parameters structure.
274: //
275:
276: typedef struct _SYNCHRONOUS_TYPE_PARAMETERS {
277: UCHAR MaximumPeriodCyles;
278: UCHAR SynchronousPeriodCyles;
279: UCHAR InitialRegisterValue;
280: }SYNCHRONOUS_TYPE_PARAMETERS, *PSYNCHRONOUS_TYPE_PARAMETERS;
281:
282: //
283: // Define the table of synchronous transfer types.
284: //
285:
286: const SYNCHRONOUS_TYPE_PARAMETERS SynchronousTransferTypes[] = {
287: { 0, 0, 5},
288: { 32, 5, 5},
289: { 32, 8, 7},
290: { 12, 4, 4}
291: };
292:
293: //
294: // SCSI Protocol Chip Control read and write macros.
295: //
296:
297: #ifdef SCSI_READ
298: #undef SCSI_READ
299: #undef SCSI_WRITE
300: #endif
301:
302: #if defined(DECSTATION)
303:
304: #define SCSI_READ(ChipAddr, Register) ScsiPortReadRegisterUchar(&((ChipAddr)->ReadRegisters.Register.Byte))
305:
306: #define SCSI_WRITE(ChipAddr, Register, Value) ScsiPortWriteRegisterUchar(&((ChipAddr)->WriteRegisters.Register.Byte), (Value))
307:
308: #else
309:
310: #define SCSI_READ(ChipAddr, Register) ScsiPortReadPortUchar(&((ChipAddr)->ReadRegisters.Register))
311: #define SCSI_WRITE(ChipAddr, Register, Value) (ScsiPortWritePortUchar(&((ChipAddr)->WriteRegisters.Register), (Value)))
312:
313: #endif
314:
315:
316: //
317: // Functions passed to the OS-specific port driver.
318: //
319:
320: ULONG
321: NcrEisaFindAdapter(
322: IN PVOID ServiceContext,
323: IN PVOID Context,
324: IN PVOID BusInformation,
325: IN PCHAR ArgumentString,
326: IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
327: OUT PBOOLEAN Again
328: );
329:
330: ULONG
331: NcrMcaFindAdapter(
332: IN PVOID ServiceContext,
333: IN PVOID Context,
334: IN PVOID BusInformation,
335: IN PCHAR ArgumentString,
336: IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
337: OUT PBOOLEAN Again
338: );
339:
340: ULONG
341: NcrMipsFindAdapter(
342: IN PVOID ServiceContext,
343: IN PVOID Context,
344: IN PVOID BusInformation,
345: IN PCHAR ArgumentString,
346: IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
347: OUT PBOOLEAN Again
348: );
349:
350: BOOLEAN
351: NcrInitializeAdapter(
352: IN PVOID ServiceContext
353: );
354:
355: BOOLEAN
356: NcrInterruptServiceRoutine(
357: IN PVOID ServiceContext
358: );
359:
360: BOOLEAN
361: NcrResetScsiBus(
362: IN PVOID ServiceContext,
363: IN ULONG PathId
364: );
365:
366: BOOLEAN
367: NcrStartIo(
368: IN PVOID ServiceContext,
369: IN PSCSI_REQUEST_BLOCK Srb
370: );
371:
372: VOID
373: NcrStartDataTransfer(
374: IN PVOID ServiceContext
375: );
376:
377: //
378: // NCR 53c9x internal mini-port driver functions.
379: //
380:
381: VOID
382: NcrAcceptMessage(
383: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
384: IN BOOLEAN SetAttention,
385: IN BOOLEAN SetSynchronousParameters
386: );
387:
388: VOID
389: NcrCleanupAfterReset(
390: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
391: IN BOOLEAN ExternalReset
392: );
393:
394: VOID
395: NcrCompleteSendMessage(
396: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
397: IN UCHAR SrbStatus
398: );
399:
400: BOOLEAN
401: NcrDecodeSynchronousRequest(
402: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
403: IN PSPECIFIC_TARGET_EXTENSION TargetState,
404: IN BOOLEAN ResponseExpected
405: );
406:
407: VOID
408: NcrDumpState(
409: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
410: );
411:
412: BOOLEAN
413: NcrMessageDecode(
414: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
415: );
416:
417: VOID
418: NcrLogError(
419: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
420: IN ULONG ErrorCode,
421: IN ULONG UniqueCode
422: );
423:
424: VOID
425: NcrProcessRequestCompletion(
426: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
427: );
428:
429: VOID
430: NcrResetScsiBusInternal(
431: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
432: IN ULONG PathId
433: );
434:
435: VOID
436: NcrSelectTarget(
437: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
438: IN PSPECIFIC_LOGICAL_UNIT_EXTENSION LuExtension
439: );
440:
441: VOID
442: NcrSendMessage(
443: IN PSCSI_REQUEST_BLOCK Srb,
444: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
445: IN PSPECIFIC_LOGICAL_UNIT_EXTENSION LuExtension
446: );
447:
448: VOID
449: NcrStartExecution(
450: PSCSI_REQUEST_BLOCK Srb,
451: PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
452: PSPECIFIC_LOGICAL_UNIT_EXTENSION LuExtension
453: );
454:
455:
456: VOID
457: NcrAcceptMessage(
458: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
459: IN BOOLEAN SetAttention,
460: IN BOOLEAN SetSynchronousParameters
461: )
462: /*++
463:
464: Routine Description:
465:
466: This procedure tells the adapter to accept a pending message on the SCSI
467: bus. Optionally, it will set the synchronous transfer parameters and the
468: attention signal.
469:
470: Arguments:
471:
472: DeviceExtension - Supplies a pointer to the device extension.
473:
474: SetAttention - Indicates the attention line on the SCSI bus should be set.
475:
476: SetSynchronousParameters - Indicates the synchronous data transfer
477: parameters should be set.
478:
479: Return Value:
480:
481: None.
482:
483: --*/
484:
485: {
486:
487: PSPECIFIC_TARGET_EXTENSION targetState;
488:
489: //
490: // Check to see if the synchonous data transfer parameters need to be set.
491: //
492:
493: if (SetSynchronousParameters) {
494:
495: //
496: // These must be set before a data transfer is started.
497: //
498:
499: targetState = &DeviceExtension->TargetState[DeviceExtension->TargetId];
500:
501: SCSI_WRITE( DeviceExtension->Adapter,
502: SynchronousPeriod,
503: targetState->SynchronousPeriod
504: );
505: SCSI_WRITE( DeviceExtension->Adapter,
506: SynchronousOffset,
507: targetState->SynchronousOffset
508: );
509: SCSI_WRITE( DeviceExtension->Adapter,
510: Configuration3,
511: *((PUCHAR) &targetState->Configuration3)
512: );
513: }
514:
515: //
516: // Check to see if the attention signal needs to be set.
517: //
518:
519: if (SetAttention) {
520:
521: //
522: // This requests that the target enter the message-out phase.
523: //
524:
525: SCSI_WRITE( DeviceExtension->Adapter, Command, SET_ATTENTION );
526: }
527:
528: //
529: // Indicate to the adapter that the message-in phase may now be completed.
530: //
531:
532: SCSI_WRITE(DeviceExtension->Adapter, Command, MESSAGE_ACCEPTED);
533: }
534:
535:
536: VOID
537: NcrCleanupAfterReset(
538: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
539: IN BOOLEAN ExternalReset
540: )
541:
542: /*++
543:
544: Routine Description:
545:
546: This routine cleans up the adapter-specific
547: and logical-unit-specific data structures. Any active requests are
548: completed and the synchronous negotiation flags are cleared.
549:
550: Arguments:
551:
552: DeviceExtension - Supplies a pointer to device extension for the bus that
553: was reset.
554:
555: ExternalReset - When set, indicates that the reset was generated by a
556: SCSI device other than this host adapter.
557:
558: Return Value:
559:
560: None.
561:
562: --*/
563:
564: {
565: UCHAR pathId = 0;
566: UCHAR targetId;
567: UCHAR luId;
568: PSPECIFIC_LOGICAL_UNIT_EXTENSION luExtension;
569: PSPECIFIC_TARGET_EXTENSION targetState;
570:
571: //
572: // Check to see if a data transfer was in progress, if so, flush the DMA.
573: //
574:
575: if (DeviceExtension->AdapterState == DataTransfer) {
576:
577: SCSI_WRITE(DeviceExtension->Adapter, Command, FLUSH_FIFO);
578: ScsiPortFlushDma(DeviceExtension);
579:
580: }
581:
582: //
583: // if the current state is AttemptingSelect then SCSI port driver needs
584: // to be notified that new requests can be sent.
585: //
586:
587: if (DeviceExtension->AdapterFlags & PD_PENDING_START_IO) {
588:
589: //
590: // Ask for another request and clear the pending one. The pending
591: // request will be processed when the request of the active requests
592: // are returned.
593:
594: DeviceExtension->NextSrbRequest = NULL;
595: DeviceExtension->AdapterFlags &= ~PD_PENDING_START_IO;
596:
597: ScsiPortNotification( NextRequest, DeviceExtension, NULL );
598:
599: }
600:
601: //
602: // If there was an active request, then complete it with
603: // SRB_STATUS_PHASE_SEQUENCE_FAILURE so the class driver will know not
604: // to retry it too many times.
605: //
606:
607: if (DeviceExtension->ActiveLuRequest != NULL) {
608:
609: //
610: // Set the SrbStatus in the SRB, complete the request and
611: // clear the active pointers
612: //
613:
614: luExtension = DeviceExtension->ActiveLogicalUnit;
615:
616: DeviceExtension->ActiveLuRequest->SrbStatus =
617: SRB_STATUS_PHASE_SEQUENCE_FAILURE;
618:
619: targetState = &DeviceExtension->TargetState[DeviceExtension->TargetId];
620:
621: ScsiPortNotification(
622: RequestComplete,
623: DeviceExtension,
624: DeviceExtension->ActiveLuRequest
625: );
626:
627: //
628: // Check to see if there was a synchronous negotiation in progress. If
629: // there was then do not try to negotiate with this target again.
630: //
631:
632: if (DeviceExtension->AdapterFlags & (PD_SYNCHRONOUS_RESPONSE_SENT |
633: PD_SYNCHRONOUS_TRANSFER_SENT)) {
634:
635: //
636: // This target cannot negotiate properly. Set a flag to prevent
637: // further attempts and set the synchronous parameters to use
638: // asynchronous data transfer.
639: //
640:
641: targetState->TargetFlags |= PD_DO_NOT_NEGOTIATE;
642: targetState->SynchronousOffset = ASYNCHRONOUS_OFFSET;
643: targetState->SynchronousPeriod = ASYNCHRONOUS_PERIOD;
644: targetState->Configuration3.FastScsi = 0;
645:
646: }
647:
648: luExtension->ActiveLuRequest = NULL;
649: luExtension->RetryCount = 0;
650: DeviceExtension->ActiveLogicalUnit = NULL;
651: DeviceExtension->ActiveLuRequest = NULL;
652: }
653:
654: //
655: // Clear the appropriate state flags as well as the next request.
656: // The request will actually be cleared when the logical units are processed.
657: // Note that it is not necessary to fail the request waiting to be started
658: // since it will be processed properly by the target controller, but it
659: // is cleared anyway.
660: //
661:
662: for (targetId = 0; targetId < SCSI_MAXIMUM_TARGETS; targetId++) {
663:
664: //
665: // Loop through each of the possible logical units for this target.
666: //
667:
668: //
669: // Clear the synchronous negotiation flage for the target controller.
670: //
671:
672: DeviceExtension->TargetState[targetId].TargetFlags &=
673: ~PD_SYNCHRONOUS_NEGOTIATION_DONE;
674:
675: for (luId = 0; luId < SCSI_MAXIMUM_LOGICAL_UNITS; luId++) {
676:
677: luExtension = ScsiPortGetLogicalUnit( DeviceExtension,
678: pathId,
679: targetId,
680: luId
681: );
682:
683: if (luExtension == NULL) {
684: continue;
685: }
686:
687: ScsiPortCompleteRequest(
688: DeviceExtension,
689: pathId,
690: targetId,
691: luId,
692: SRB_STATUS_BUS_RESET
693: );
694:
695: luExtension->ActiveLuRequest = NULL;
696:
697: if (luExtension->ActiveSendRequest != NULL) {
698:
699: //
700: // Set the SrbStatus in the SRB, complete the request and
701: // clear the active pointers
702: //
703:
704: luExtension->ActiveSendRequest->SrbStatus =
705: SRB_STATUS_BUS_RESET;
706:
707: //
708: // Complete the request.
709: //
710:
711: ScsiPortNotification(
712: RequestComplete,
713: DeviceExtension,
714: luExtension->ActiveSendRequest
715: );
716:
717: luExtension->ActiveSendRequest = NULL;
718:
719: }
720:
721: //
722: // Clear the necessary logical unit flags.
723: //
724:
725: luExtension->LuFlags &= ~PD_LU_RESET_MASK;
726:
727: } /* for luId */
728: } /* for targetId */
729:
730: //
731: // Clear the adapter flags and set the bus state to free.
732: //
733:
734: DeviceExtension->AdapterState = BusFree;
735: DeviceExtension->AdapterFlags &= ~PD_ADAPTER_RESET_MASK;
736:
737: }
738:
739: VOID
740: NcrCompleteSendMessage(
741: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
742: IN UCHAR SrbStatus
743: )
744: /*++
745:
746: Routine Description:
747:
748: This function does the cleanup necessary to complete a send-message request.
749: This includes completing any affected execute-I/O requests and cleaning
750: up the device extension state.
751:
752: Arguments:
753:
754: DeviceExtension - Supplies a pointer to the device extension of the SCSI bus
755: adapter. The active logical unit is stored in ActiveLogicalUnit.
756:
757: SrbStatus - Indicates the status that the request should be completeted with
758: if the request did not complete normally, then any active execute
759: requests are not considered to have been affected.
760:
761: Return Value:
762:
763: None.
764:
765: --*/
766:
767: {
768: PSPECIFIC_LOGICAL_UNIT_EXTENSION luExtension;
769: PSCSI_REQUEST_BLOCK srb;
770: PSCSI_REQUEST_BLOCK srbAbort;
771: UCHAR pathId = 0;
772: UCHAR targetId;
773: UCHAR luId;
774:
775: luExtension = DeviceExtension->ActiveLogicalUnit;
776: srb = luExtension->ActiveSendRequest;
777:
778: //
779: // Clean up any EXECUTE requests which may have been affected by this
780: // message.
781: //
782:
783: if (SrbStatus == SRB_STATUS_SUCCESS) {
784: switch (srb->Function) {
785: case SRB_FUNCTION_ABORT_COMMAND:
786:
787: //
788: // Make sure there is still a request to complete. If so complete
789: // it with an SRB_STATUS_ABORTED status.
790: //
791:
792: srbAbort = ScsiPortGetSrb(
793: DeviceExtension,
794: srb->PathId,
795: srb->TargetId,
796: srb->Lun,
797: srb->QueueTag
798: );
799:
800: if (srbAbort != srb->NextSrb) {
801:
802: //
803: // If there is no request, then fail the abort.
804: //
805:
806: SrbStatus = SRB_STATUS_ABORT_FAILED;
807: break;
808: }
809:
810: srbAbort->SrbStatus = SRB_STATUS_ABORTED;
811:
812: ScsiPortNotification(
813: RequestComplete,
814: DeviceExtension,
815: srbAbort
816: );
817:
818: if (DeviceExtension->ActiveLuRequest == srbAbort) {
819:
820: DeviceExtension->ActiveLuRequest = NULL;
821: }
822:
823: luExtension->ActiveLuRequest = NULL;
824: luExtension->LuFlags &= ~PD_LU_COMPLETE_MASK;
825: luExtension->RetryCount = 0;
826:
827: break;
828:
829: case SRB_FUNCTION_RESET_DEVICE:
830:
831: //
832: // Cycle through each of the possible logical units looking
833: // for requests which have been cleared by the target reset.
834: //
835:
836: targetId = srb->TargetId;
837: DeviceExtension->TargetState[targetId].TargetFlags &=
838: ~PD_SYNCHRONOUS_NEGOTIATION_DONE;
839:
840: for (luId = 0; luId < SCSI_MAXIMUM_LOGICAL_UNITS; luId) {
841:
842: luExtension = ScsiPortGetLogicalUnit( DeviceExtension,
843: pathId,
844: targetId,
845: luId
846: );
847:
848: if (luExtension == NULL) {
849: continue;
850: }
851:
852: ScsiPortCompleteRequest(
853: DeviceExtension,
854: pathId,
855: targetId,
856: luId,
857: SRB_STATUS_BUS_RESET
858: );
859:
860: luExtension->ActiveLuRequest = NULL;
861: luExtension->RetryCount = 0;
862:
863: //
864: // Clear the necessary logical unit flags.
865: //
866:
867: luExtension->LuFlags &= ~PD_LU_RESET_MASK;
868:
869: } /* for luId */
870:
871: /* TODO: Handle CLEAR QUEUE */
872: }
873: } else {
874:
875: //
876: // If an abort request fails then complete target of the abort;
877: // otherwise the target of the ABORT may never be compileted.
878: //
879:
880: if (srb->Function == SRB_FUNCTION_ABORT_COMMAND) {
881:
882: //
883: // Make sure there is still a request to complete. If so
884: // it with an SRB_STATUS_ABORTED status.
885: //
886:
887: srbAbort = ScsiPortGetSrb(
888: DeviceExtension,
889: srb->PathId,
890: srb->TargetId,
891: srb->Lun,
892: srb->QueueTag
893: );
894:
895: if (srbAbort == srb->NextSrb) {
896:
897: srbAbort->SrbStatus = SRB_STATUS_ABORTED;
898:
899: ScsiPortNotification(
900: RequestComplete,
901: DeviceExtension,
902: srbAbort
903: );
904:
905: luExtension->ActiveLuRequest = NULL;
906: luExtension->LuFlags &= ~PD_LU_COMPLETE_MASK;
907: luExtension->RetryCount = 0;
908:
909: }
910: }
911:
912: }
913:
914: //
915: // Complete the actual send-message request.
916: //
917:
918: srb->SrbStatus = SrbStatus;
919: ScsiPortNotification(
920: RequestComplete,
921: DeviceExtension,
922: srb
923: );
924:
925: //
926: // Clear the active send request and PD_SEND_MESSAGE_REQUEST flag.
927: //
928:
929: luExtension->RetryCount = 0;
930: luExtension->ActiveSendRequest = NULL;
931: DeviceExtension->AdapterFlags &= ~PD_SEND_MESSAGE_REQUEST;
932: }
933:
934: BOOLEAN
935: NcrMessageDecode(
936: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
937: )
938: /*++
939:
940: Routine Description:
941:
942: This function decodes the SCSI bus message-in the device extension message
943: buffer. After the message is decoded it decides what action to take in
944: response to the message. If an outgoing message needs to be sent, then
945: it is placed in the message buffer and TRUE is returned. If the message
946: is acceptable, then the device state is set either to DisconnectExpected or
947: MessageAccepted and the MessageCount is reset to 0.
948:
949: Some messages are made up of several bytes. This funtion will simply
950: return false when an incomplete message is detected, allowing the target
951: to send the rest of the message. The message count is left unchanged.
952:
953: Arguments:
954:
955: DeviceExtension - Supplies a pointer to the specific device extension.
956:
957: Return Value:
958:
959: TRUE - Returns true if there is a reponse message to be sent.
960:
961: FALSE - If there is no response message.
962:
963: --*/
964:
965: {
966: PSCSI_REQUEST_BLOCK srb;
967: PSPECIFIC_LOGICAL_UNIT_EXTENSION luExtension;
968: LONG offset;
969: PSPECIFIC_TARGET_EXTENSION targetState;
970: LONG i;
971: ULONG savedAdapterFlags;
972: PSCSI_EXTENDED_MESSAGE extendedMessage;
973:
974: //
975: // NOTE: The ActivelogicalUnit field could be invalid if the
976: // PD_DISCONNECT_EXPECTED flag is set, so luExtension cannot
977: // be used until this flag has been checked.
978: //
979:
980: luExtension = DeviceExtension->ActiveLogicalUnit;
981: savedAdapterFlags = DeviceExtension->AdapterFlags;
982: srb = DeviceExtension->ActiveLuRequest;
983: targetState = &DeviceExtension->TargetState[DeviceExtension->TargetId];
984:
985: //
986: // If a queue message is expected then it must be the first message byte.
987: //
988:
989: if (DeviceExtension->AdapterFlags & PD_EXPECTING_QUEUE_TAG &&
990: DeviceExtension->MessageBuffer[0] != SRB_SIMPLE_TAG_REQUEST) {
991:
992: NcrPrint((1, "NcrMessageDecode: Unexpected message recieved when que tag expected.\n"));
993:
994: //
995: // The target did not reselect correctly Send a
996: // message reject of this message.
997: //
998:
999: DeviceExtension->MessageCount = 1;
1000: DeviceExtension->MessageSent = 0;
1001: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1002: DeviceExtension->AdapterState = MessageOut;
1003:
1004: return(TRUE);
1005: }
1006:
1007: //
1008: // A number of special cases must be handled if a special message has
1009: // just been sent. These special messages are synchronous negotiations
1010: // or a messages which implie a disconnect. The special cases are:
1011: //
1012: // If a disconnect is expected because of a send-message request,
1013: // then the only valid message-in is a MESSAGE REJECT; other messages
1014: // are a protocol error and are rejected.
1015: //
1016: // If a synchronous negotiation response was just sent and the message
1017: // in was not a MESSAGE REJECT, then the negotiation has been accepted.
1018: //
1019: // If a synchronous negotiation request was just sent, then valid responses
1020: // are a MESSAGE REJECT or an extended synchronous message back.
1021: //
1022:
1023: if (DeviceExtension->AdapterFlags & (PD_SYNCHRONOUS_RESPONSE_SENT |
1024: PD_DISCONNECT_EXPECTED | PD_SYNCHRONOUS_TRANSFER_SENT)) {
1025:
1026: if (DeviceExtension->AdapterFlags & PD_DISCONNECT_EXPECTED &&
1027: DeviceExtension->MessageBuffer[0] != SCSIMESS_MESSAGE_REJECT) {
1028:
1029: //
1030: // The target is not responding correctly to the message. Send a
1031: // message reject of this message.
1032: //
1033:
1034: DeviceExtension->MessageCount = 1;
1035: DeviceExtension->MessageSent = 0;
1036: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1037: DeviceExtension->AdapterState = MessageOut;
1038:
1039: return(TRUE);
1040: }
1041:
1042: if (DeviceExtension->AdapterFlags & PD_SYNCHRONOUS_RESPONSE_SENT &&
1043: DeviceExtension->MessageBuffer[0] != SCSIMESS_MESSAGE_REJECT) {
1044:
1045: //
1046: // The target did not reject our response so the synchronous
1047: // transfer negotiation is done. Clear the adapter flags and
1048: // set the logical unit flags indicating this. Continue processing
1049: // the message which is unrelated to negotiation.
1050: //
1051:
1052: DeviceExtension->AdapterFlags &= ~PD_SYNCHRONOUS_RESPONSE_SENT;
1053: targetState->TargetFlags |= PD_SYNCHRONOUS_NEGOTIATION_DONE;
1054: }
1055:
1056: //
1057: // Save the adapter flags for later use.
1058: //
1059:
1060: savedAdapterFlags = DeviceExtension->AdapterFlags;
1061:
1062: if (DeviceExtension->AdapterFlags & PD_SYNCHRONOUS_TRANSFER_SENT ) {
1063:
1064: //
1065: // The target is sending a message after a synchronous transfer
1066: // request was sent. Valid responses are a MESSAGE REJECT or an
1067: // extended synchronous message; any other message negates the
1068: // fact that a negotiation was started. However, since extended
1069: // messages are multi-byte, it is difficult to determine what the
1070: // incoming message is. So at this point, the fact that a
1071: // sychronous transfer was sent will be saved and cleared from the
1072: // AdapterFlags. If the message looks like a synchronous transfer
1073: // request, then restore this fact back into the AdapterFlags. If
1074: // the complete message is not the one expected, then opening
1075: // negotiation will be forgotten. This is an error by the target,
1076: // but minor so nothing will be done about it. Finally, to prevent
1077: // this cycle from reoccurring on the next request indicate that
1078: // the negotiation is done.
1079: //
1080:
1081: DeviceExtension->AdapterFlags &= ~PD_SYNCHRONOUS_TRANSFER_SENT;
1082: targetState->TargetFlags |= PD_SYNCHRONOUS_NEGOTIATION_DONE;
1083: }
1084:
1085: }
1086:
1087: switch (DeviceExtension->MessageBuffer[0]) {
1088: case SCSIMESS_COMMAND_COMPLETE:
1089:
1090: //
1091: // For better or worse the command is complete. Process request which
1092: // set the SrbStatus and clean up the device and logical unit states.
1093: //
1094:
1095: NcrProcessRequestCompletion(DeviceExtension);
1096:
1097: //
1098: // Complete the request.
1099: //
1100:
1101: ScsiPortNotification(
1102: RequestComplete,
1103: DeviceExtension,
1104: srb
1105: );
1106:
1107: //
1108: // Everything is ok with the message so do not send one and set the
1109: // state to DisconnectExpected.
1110: //
1111:
1112: DeviceExtension->AdapterState = DisconnectExpected;
1113: DeviceExtension->MessageCount = 0;
1114: return(FALSE);
1115:
1116: case SCSIMESS_DISCONNECT:
1117:
1118: //
1119: // The target wants to disconnect. Set the state to DisconnectExpected,
1120: // and do not request a message-out.
1121: //
1122:
1123: DeviceExtension->AdapterState = DisconnectExpected;
1124: DeviceExtension->MessageCount = 0;
1125: return(FALSE);
1126:
1127: case SCSIMESS_EXTENDED_MESSAGE:
1128:
1129: //
1130: // The format of an extended message is:
1131: // Extended Message Code
1132: // Length of Message
1133: // Extended Message Type
1134: // .
1135: // .
1136: //
1137: // Until the entire message has been read in, just keep getting bytes
1138: // from the target, making sure that the message buffer is not
1139: // overrun.
1140: //
1141:
1142: extendedMessage = (PSCSI_EXTENDED_MESSAGE)
1143: DeviceExtension->MessageBuffer;
1144:
1145: if (DeviceExtension->MessageCount < 2 ||
1146: (DeviceExtension->MessageCount < MESSAGE_BUFFER_SIZE &&
1147: DeviceExtension->MessageCount < extendedMessage->MessageLength + 2)
1148: ) {
1149:
1150: //
1151: // Update the state and return; also restore the AdapterFlags.
1152: //
1153:
1154: DeviceExtension->AdapterFlags = savedAdapterFlags;
1155: DeviceExtension->AdapterState = MessageAccepted;
1156: return(FALSE);
1157:
1158: }
1159:
1160: //
1161: // Make sure the length includes an extended op-code.
1162: //
1163:
1164: if (DeviceExtension->MessageCount < 3) {
1165:
1166: //
1167: // This is an illegal extended message. Send a MESSAGE_REJECT.
1168: //
1169:
1170: DeviceExtension->MessageCount = 1;
1171: DeviceExtension->MessageSent = 0;
1172: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1173: DeviceExtension->AdapterState = MessageOut;
1174:
1175: return(TRUE);
1176: }
1177:
1178: //
1179: // Determine the extended message type.
1180: //
1181:
1182: switch (extendedMessage->MessageType) {
1183: case SCSIMESS_MODIFY_DATA_POINTER:
1184:
1185: //
1186: // Verify the message length.
1187: //
1188:
1189: if (extendedMessage->MessageLength != SCSIMESS_MODIFY_DATA_LENGTH) {
1190:
1191: //
1192: // Reject the message.
1193: //
1194:
1195: DeviceExtension->MessageCount = 1;
1196: DeviceExtension->MessageSent = 0;
1197: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1198: DeviceExtension->AdapterState = MessageOut;
1199:
1200: return(TRUE);
1201: }
1202:
1203: //
1204: // Calculate the modification to be added to the data pointer.
1205: //
1206:
1207: offset = 0;
1208: for (i = 0; i < 4; i++) {
1209: offset << 8;
1210: offset += extendedMessage->ExtendedArguments.Modify.Modifier[i];
1211: }
1212:
1213: //
1214: // Verify that the new data pointer is still within the range
1215: // of the buffer.
1216: //
1217:
1218: if (DeviceExtension->ActiveDataLength - offset >
1219: srb->DataTransferLength ||
1220: ((LONG) DeviceExtension->ActiveDataLength - offset) < 0 ) {
1221:
1222: //
1223: // The new pointer is not valid, so reject the message.
1224: //
1225:
1226: DeviceExtension->MessageCount = 1;
1227: DeviceExtension->MessageSent = 0;
1228: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1229: DeviceExtension->AdapterState = MessageOut;
1230:
1231: return(TRUE);
1232: }
1233:
1234: //
1235: // Everything has checked out, so update the pointer.
1236: //
1237:
1238: DeviceExtension->ActiveDataPointer += offset;
1239: DeviceExtension->ActiveDataLength -= offset;
1240:
1241: //
1242: // Everything is ok, so accept the message as is.
1243: //
1244:
1245: DeviceExtension->MessageCount = 0;
1246: DeviceExtension->AdapterState = MessageAccepted;
1247: return(FALSE);
1248:
1249: case SCSIMESS_SYNCHRONOUS_DATA_REQ:
1250:
1251: //
1252: // A SYNCHRONOUS DATA TRANSFER REQUEST message was received.
1253: // Make sure the length is correct.
1254: //
1255:
1256: if ( extendedMessage->MessageLength !=
1257: SCSIMESS_SYNCH_DATA_LENGTH) {
1258:
1259: //
1260: // The length is invalid, so reject the message.
1261: //
1262:
1263: DeviceExtension->MessageCount = 1;
1264: DeviceExtension->MessageSent = 0;
1265: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1266: DeviceExtension->AdapterState = MessageOut;
1267: return(TRUE);
1268: }
1269:
1270: //
1271: // If synchrouns negotiation has been disabled for this request,
1272: // then reject any synchronous messages; however, when synchronous
1273: // transfers are allowed then a new attempt can be made.
1274: //
1275:
1276: if (srb != NULL &&
1277: !(savedAdapterFlags & PD_SYNCHRONOUS_TRANSFER_SENT) &&
1278: srb->SrbFlags & SRB_FLAGS_DISABLE_SYNCH_TRANSFER) {
1279:
1280: //
1281: // Reject the synchronous transfer message since synchonrous
1282: // transfers are not desired at this time.
1283: //
1284:
1285: DeviceExtension->MessageCount = 1;
1286: DeviceExtension->MessageSent = 0;
1287: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1288: DeviceExtension->AdapterState = MessageOut;
1289: return(TRUE);
1290:
1291: }
1292:
1293: //
1294: // Call NcrDecodeSynchronousMessage to decode the message and
1295: // formulate a response if necessary.
1296: // NcrDecodeSynchronousRequest will return FALSE if the
1297: // message is not accepable and should be rejected.
1298: //
1299:
1300: if (!NcrDecodeSynchronousRequest(
1301: DeviceExtension,
1302: targetState,
1303: !(savedAdapterFlags & PD_SYNCHRONOUS_TRANSFER_SENT)
1304: )) {
1305:
1306: //
1307: // Indicate that a negotiation has been done in the logical
1308: // unit and clear the negotiation flags.
1309: //
1310:
1311: targetState->TargetFlags |= PD_SYNCHRONOUS_NEGOTIATION_DONE;
1312:
1313: DeviceExtension->AdapterFlags &=
1314: ~(PD_SYNCHRONOUS_RESPONSE_SENT|
1315: PD_SYNCHRONOUS_TRANSFER_SENT);
1316:
1317: //
1318: // The message was not acceptable so send a MESSAGE_REJECT.
1319: //
1320:
1321: DeviceExtension->MessageCount = 1;
1322: DeviceExtension->MessageSent = 0;
1323: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1324: DeviceExtension->AdapterState = MessageOut;
1325: return(TRUE);
1326: }
1327:
1328: //
1329: // If a reponse was expected, then set the state for a message-out.
1330: // Otherwise, NcrDecodeSynchronousRequest has put a reponse
1331: // in the message buffer to be returned to the target.
1332: //
1333:
1334: if (savedAdapterFlags & PD_SYNCHRONOUS_TRANSFER_SENT){
1335:
1336: //
1337: // We initiated the negotiation, so no response is necessary.
1338: //
1339:
1340: DeviceExtension->AdapterState = MessageAccepted;
1341: DeviceExtension->AdapterFlags &= ~PD_SYNCHRONOUS_TRANSFER_SENT;
1342: targetState->TargetFlags |= PD_SYNCHRONOUS_NEGOTIATION_DONE;
1343: DeviceExtension->MessageCount = 0;
1344: return(FALSE);
1345: }
1346:
1347: //
1348: // Set up the state to send the reponse. The message count is
1349: // still correct.
1350: //
1351:
1352: DeviceExtension->MessageSent = 0;
1353: DeviceExtension->AdapterState = MessageOut;
1354: DeviceExtension->AdapterFlags &= ~PD_SYNCHRONOUS_TRANSFER_SENT;
1355: DeviceExtension->AdapterFlags |= PD_SYNCHRONOUS_RESPONSE_SENT;
1356: return(TRUE);
1357:
1358: case SCSIMESS_WIDE_DATA_REQUEST:
1359:
1360: //
1361: // A WIDE DATA TRANSFER REQUEST message was received.
1362: // Make sure the length is correct.
1363: //
1364:
1365: if ( extendedMessage->MessageLength !=
1366: SCSIMESS_WIDE_DATA_LENGTH) {
1367:
1368: //
1369: // The length is invalid reject the message.
1370: //
1371:
1372: DeviceExtension->MessageCount = 1;
1373: DeviceExtension->MessageSent = 0;
1374: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1375: DeviceExtension->AdapterState = MessageOut;
1376: return(TRUE);
1377: }
1378:
1379: //
1380: // Since this SCSI protocol chip only supports 8-bits return
1381: // a width of 0 which indicates an 8-bit-wide transfers. The
1382: // MessageCount is still correct for the message.
1383: //
1384:
1385: extendedMessage->ExtendedArguments.Wide.Width = 0;
1386: DeviceExtension->MessageSent = 0;
1387: DeviceExtension->AdapterState = MessageOut;
1388: return(TRUE);
1389:
1390: default:
1391:
1392: //
1393: // This is an unknown or illegal message, so send-message REJECT.
1394: //
1395:
1396: DeviceExtension->MessageCount = 1;
1397: DeviceExtension->MessageSent = 0;
1398: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1399: DeviceExtension->AdapterState = MessageOut;
1400: return(TRUE);
1401: }
1402:
1403: case SCSIMESS_INITIATE_RECOVERY:
1404:
1405: //
1406: // Save the fact that a INITIATE RECOVERY message was received.
1407: //
1408:
1409: SRB_EXT(srb)->SrbExtensionFlags |= PD_INITIATE_RECOVERY;
1410: DeviceExtension->MessageCount = 0;
1411: return(FALSE);
1412:
1413: case SCSIMESS_LINK_CMD_COMP:
1414:
1415: //
1416: // A link command completed. Process the completion. Since the link
1417: // FLAG was not set, do not call ScsiPortNotification. Get the next
1418: // segment of the request and accept the message.
1419: //
1420:
1421: //
1422: // Make sure that this is a linked command.
1423: // Linked commands are not supported.
1424: //
1425:
1426: if (TRUE) {
1427:
1428: //
1429: // Something is messed up. Reject the message.
1430: //
1431:
1432: DeviceExtension->MessageCount = 1;
1433: DeviceExtension->MessageSent = 0;
1434: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1435: DeviceExtension->AdapterState = MessageOut;
1436: return(TRUE);
1437: }
1438:
1439: NcrProcessRequestCompletion(DeviceExtension);
1440:
1441: DeviceExtension->ActiveLuRequest = srb->NextSrb;
1442:
1443: //
1444: // Everything is ok with the message, so do not send one and set the
1445: // state to MessageAccepted.
1446: //
1447:
1448: DeviceExtension->AdapterState = MessageAccepted;
1449: DeviceExtension->MessageCount = 0;
1450: return(FALSE);
1451:
1452: case SCSIMESS_LINK_CMD_COMP_W_FLAG:
1453:
1454: //
1455: // A link command completed. Process the completion and get the next
1456: // segment of the request. Since the link FLAG was set, call
1457: // ScsiPortNotification to notify the class driver.
1458: //
1459:
1460: //
1461: // Make sure that this is a linked command.
1462: // Linked commands are not supported.
1463: //
1464:
1465: if (TRUE) {
1466:
1467: //
1468: // Something is messed up. Reject the message.
1469: //
1470:
1471: DeviceExtension->MessageCount = 1;
1472: DeviceExtension->MessageSent = 0;
1473: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1474: DeviceExtension->AdapterState = MessageOut;
1475: return(TRUE);
1476: }
1477:
1478: NcrProcessRequestCompletion(DeviceExtension);
1479:
1480: DeviceExtension->ActiveLuRequest = srb->NextSrb;
1481:
1482: //
1483: // Complete the request.
1484: //
1485:
1486: ScsiPortNotification(
1487: RequestComplete,
1488: DeviceExtension,
1489: srb
1490: );
1491:
1492: //
1493: // Everything is ok with the message, so do not send one and set the
1494: // state to MessageAccepted.
1495: //
1496:
1497: DeviceExtension->AdapterState = MessageAccepted;
1498: DeviceExtension->MessageCount = 0;
1499: return(FALSE);
1500:
1501: case SCSIMESS_MESSAGE_REJECT:
1502:
1503: //
1504: // The last message we sent was rejected. If this was a send
1505: // message request, then set the proper status and complete the
1506: // request. Set the state to message accepted.
1507: //
1508:
1509: /* TODO: Handle message reject correctly. */
1510: if (DeviceExtension->AdapterFlags & PD_SEND_MESSAGE_REQUEST) {
1511:
1512: //
1513: // Complete the request with message rejected status.
1514: //
1515:
1516: NcrCompleteSendMessage(
1517: DeviceExtension,
1518: SRB_STATUS_MESSAGE_REJECTED
1519: );
1520: }
1521:
1522: //
1523: // Check to see if a synchronous negotiation is in progress.
1524: //
1525:
1526: if (savedAdapterFlags & (PD_SYNCHRONOUS_RESPONSE_SENT|
1527: PD_SYNCHRONOUS_TRANSFER_SENT)) {
1528:
1529: //
1530: // The negotiation failed so use asynchronous data transfers.
1531: // Indicate that the negotiation has been attempted and set
1532: // the transfer for asynchronous. Clear the negotiation flags.
1533: //
1534:
1535: targetState->TargetFlags |= PD_SYNCHRONOUS_NEGOTIATION_DONE;
1536: targetState->SynchronousOffset = ASYNCHRONOUS_OFFSET;
1537: targetState->SynchronousPeriod = ASYNCHRONOUS_PERIOD;
1538: targetState->Configuration3.FastScsi = 0;
1539: DeviceExtension->AdapterFlags &= ~(PD_SYNCHRONOUS_RESPONSE_SENT|
1540: PD_SYNCHRONOUS_TRANSFER_SENT);
1541:
1542: //
1543: // Even though the negotiation appeared to go ok, there is no reason
1544: // to try again, and some targets get messed up later, so do not try
1545: // synchronous negotiation again.
1546: //
1547:
1548: targetState->TargetFlags |= PD_DO_NOT_NEGOTIATE;
1549:
1550: }
1551:
1552: DeviceExtension->AdapterState = MessageAccepted;
1553: DeviceExtension->MessageCount = 0;
1554: return(FALSE);
1555:
1556: case SCSIMESS_SIMPLE_QUEUE_TAG:
1557: case SCSIMESS_ORDERED_QUEUE_TAG:
1558: case SCSIMESS_HEAD_OF_QUEUE_TAG:
1559:
1560: //
1561: // A queue tag message was recieve. If this is the first byte just
1562: // accept the message and wait for the next one.
1563: //
1564:
1565: if (DeviceExtension->MessageCount < 2) {
1566:
1567: DeviceExtension->AdapterState = MessageAccepted;
1568: return(FALSE);
1569:
1570: }
1571:
1572: //
1573: // Make sure that a queue tag message is expected.
1574: //
1575:
1576: if (!(DeviceExtension->AdapterFlags & PD_EXPECTING_QUEUE_TAG) ||
1577: luExtension == NULL) {
1578:
1579: NcrPrint((1, "NcrMessageDecode: Unexpected queue tag message recieved\n"));
1580:
1581: //
1582: // Something is messed up. Reject the message.
1583: //
1584:
1585: DeviceExtension->MessageCount = 1;
1586: DeviceExtension->MessageSent = 0;
1587: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1588: DeviceExtension->AdapterFlags |= PD_DISCONNECT_EXPECTED;
1589: DeviceExtension->AdapterState = MessageOut;
1590: NcrLogError( DeviceExtension, SP_PROTOCOL_ERROR, 17);
1591: return(TRUE);
1592:
1593: }
1594:
1595: //
1596: // The second byte contains the tag used to locate the srb.
1597: //
1598:
1599: srb = ScsiPortGetSrb(
1600: DeviceExtension,
1601: 0,
1602: DeviceExtension->TargetId,
1603: DeviceExtension->Lun,
1604: DeviceExtension->MessageBuffer[1]
1605: );
1606:
1607: if (srb == NULL) {
1608:
1609: NcrPrint((1, "NcrMessageDecode: Invalid queue tag recieved\n"));
1610:
1611: //
1612: // Something is messed up. Reject the message.
1613: //
1614:
1615: DeviceExtension->AdapterFlags &= ~PD_EXPECTING_QUEUE_TAG;
1616: DeviceExtension->AdapterFlags |= PD_DISCONNECT_EXPECTED;
1617: DeviceExtension->MessageCount = 1;
1618: DeviceExtension->MessageSent = 0;
1619: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1620: DeviceExtension->AdapterState = MessageOut;
1621:
1622: NcrLogError( DeviceExtension, SP_PROTOCOL_ERROR, 16);
1623:
1624: return(TRUE);
1625:
1626: }
1627:
1628: //
1629: // Everthing is ok. Set up the device extension and accept the message.
1630: // Restore the data pointers.
1631: //
1632:
1633: DeviceExtension->ActiveLuRequest = srb;
1634: DeviceExtension->ActiveDataPointer = SRB_EXT(srb)->SavedDataPointer;
1635: DeviceExtension->ActiveDataLength = SRB_EXT(srb)->SavedDataLength;
1636: DeviceExtension->AdapterFlags &= ~PD_EXPECTING_QUEUE_TAG;
1637: DeviceExtension->AdapterState = MessageAccepted;
1638: DeviceExtension->MessageCount = 0;
1639: return(FALSE);
1640:
1641: case SCSIMESS_RESTORE_POINTERS:
1642:
1643: //
1644: // Restore data pointer message. Just copy the saved data pointer
1645: // and the length to the active data pointers.
1646: //
1647:
1648: DeviceExtension->ActiveDataPointer = SRB_EXT(srb)->SavedDataPointer;
1649: DeviceExtension->ActiveDataLength = SRB_EXT(srb)->SavedDataLength;
1650: DeviceExtension->AdapterState = MessageAccepted;
1651: DeviceExtension->MessageCount = 0;
1652: return(FALSE);
1653:
1654: case SCSIMESS_SAVE_DATA_POINTER:
1655:
1656: //
1657: // SAVE DATA POINTER message request that the active data pointer and
1658: // length be copied to the saved location.
1659: //
1660:
1661: SRB_EXT(srb)->SavedDataPointer = DeviceExtension->ActiveDataPointer;
1662: SRB_EXT(srb)->SavedDataLength = DeviceExtension->ActiveDataLength;
1663: DeviceExtension->AdapterState = MessageAccepted;
1664: DeviceExtension->MessageCount = 0;
1665: return(FALSE);
1666:
1667: default:
1668:
1669: //
1670: // An unrecognized or unsupported message. send-message reject.
1671: //
1672:
1673: DeviceExtension->MessageCount = 1;
1674: DeviceExtension->MessageSent = 0;
1675: DeviceExtension->MessageBuffer[0] = SCSIMESS_MESSAGE_REJECT;
1676: DeviceExtension->AdapterState = MessageOut;
1677: return(TRUE);
1678: }
1679: }
1680:
1681: BOOLEAN
1682: NcrDecodeSynchronousRequest(
1683: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
1684: PSPECIFIC_TARGET_EXTENSION TargetState,
1685: IN BOOLEAN ResponseExpected
1686: )
1687: /*++
1688:
1689: Routine Description:
1690:
1691: This function decodes the synchronous data transfer request message from
1692: the target. It will update the synchronous message-in the buffer and the
1693: synchronous transfer parameters in the logical unit extension. These
1694: parameters are specific for the NCR 53C9X protocol chip. The updated
1695: message-in the device extension message buffer might be returned to the
1696: target.
1697:
1698: This function should be called before the final byte of the message is
1699: accepted from the SCSI bus.
1700:
1701: Arguments:
1702:
1703: DeviceExtension - Supplies a pointer to the adapter specific device
1704: extension.
1705:
1706: TargetState - Supplies a pointer to the target controller's state.
1707: The synchronous transfer fields are updated in this structure to
1708: reflect the new parameter in the message.
1709:
1710: ResponseExpected - When set, indicates that the target initiated the
1711: negotiation and that it expects a response.
1712:
1713: Return Value:
1714:
1715: TRUE - Returned if the request is acceptable.
1716:
1717: FALSE - Returned if the request should be rejected and asynchronous
1718: transfer should be used.
1719:
1720: --*/
1721:
1722: {
1723: PSCSI_EXTENDED_MESSAGE extendedMessage;
1724: CHIP_TYPES chipType;
1725: LONG period;
1726: ULONG localPeriod;
1727: ULONG step;
1728: LONG i;
1729:
1730: extendedMessage = (PSCSI_EXTENDED_MESSAGE) DeviceExtension->MessageBuffer;
1731:
1732: //
1733: // Determine the transfer offset. It is the minimum of the SCSI protocol
1734: // chip's maximum offset and the requested offset.
1735: //
1736:
1737: if (extendedMessage->ExtendedArguments.Synchronous.ReqAckOffset >
1738: SYNCHRONOUS_OFFSET) {
1739:
1740: if (!ResponseExpected) {
1741:
1742: //
1743: // The negotiation failed for some reason; fall back to
1744: // asynchronous data transfer.
1745: //
1746:
1747: TargetState->SynchronousOffset = ASYNCHRONOUS_OFFSET;
1748: TargetState->SynchronousPeriod = ASYNCHRONOUS_PERIOD;
1749: TargetState->Configuration3.FastScsi = 0;
1750: return(FALSE);
1751: }
1752:
1753: extendedMessage->ExtendedArguments.Synchronous.ReqAckOffset = SYNCHRONOUS_OFFSET;
1754: TargetState->SynchronousOffset = SYNCHRONOUS_OFFSET;
1755:
1756: } else {
1757:
1758: TargetState->SynchronousOffset =
1759: extendedMessage->ExtendedArguments.Synchronous.ReqAckOffset;
1760:
1761: }
1762:
1763: //
1764: // If the offset requests asynchronous transfers then set the default
1765: // period and return.
1766: //
1767:
1768: if (extendedMessage->ExtendedArguments.Synchronous.ReqAckOffset ==
1769: ASYNCHRONOUS_OFFSET) {
1770: TargetState->SynchronousPeriod = ASYNCHRONOUS_PERIOD;
1771: TargetState->Configuration3.FastScsi = 0;
1772: return(TRUE);
1773: }
1774:
1775: //
1776: // Calculate the period in nanoseconds from the message.
1777: //
1778:
1779: period = extendedMessage->ExtendedArguments.Synchronous.TransferPeriod;
1780:
1781: NcrPrint((1, "NcrDecodeSynchronousRequest: Requested period %d, ", period));
1782:
1783: //
1784: // If the chip supports fast SCSI and the requested period is faster than
1785: // 200 ns then assume fast SCSI.
1786: //
1787:
1788: if (DeviceExtension->ChipType == Fas216 && period < 200 / 4) {
1789:
1790: chipType = Fas216Fast;
1791:
1792: //
1793: // Set the fast SCSI bit in the configuration register.
1794: //
1795:
1796: TargetState->Configuration3.FastScsi = 1;
1797:
1798: } else {
1799: chipType = DeviceExtension->ChipType;
1800: }
1801:
1802: //
1803: // The initial sychronous transfer period is:
1804: //
1805: // SynchronousPeriodCyles * 1000
1806: // -----------------------------
1807: // ClockSpeed * 4
1808: //
1809: // Note the result of the divide by four must be rounded up.
1810: //
1811:
1812: localPeriod = ((SynchronousTransferTypes[chipType].SynchronousPeriodCyles
1813: * 1000) / DeviceExtension->ClockSpeed + 3) / 4;
1814:
1815: //
1816: // Check to see if the period is less than the SCSI protocol chip can
1817: // use. If it is then update the message with our minimum and return.
1818: //
1819:
1820: if ((ULONG) period < localPeriod ) {
1821:
1822: if (!ResponseExpected) {
1823:
1824: //
1825: // The negotiation failed for some reason; fall back to
1826: // asynchronous data transfer.
1827: //
1828:
1829: TargetState->SynchronousOffset = ASYNCHRONOUS_OFFSET;
1830: TargetState->SynchronousPeriod = ASYNCHRONOUS_PERIOD;
1831: TargetState->Configuration3.FastScsi = 0;
1832: NcrPrint((1, "Too fast. Local period %d\n", localPeriod));
1833: return(FALSE);
1834: }
1835:
1836: extendedMessage->ExtendedArguments.Synchronous.TransferPeriod =
1837: (UCHAR) localPeriod;
1838: period = localPeriod;
1839: }
1840:
1841: //
1842: // The synchronous transfer cycle count is calculated by:
1843: //
1844: // (RequestedPeriod - BasePeriod) * 1000
1845: // ------------------------------------- + InitialRegisterValue
1846: // ClockSpeed * 4
1847: //
1848: // Note the divide must be rounded up.
1849: //
1850:
1851: step = (1000 / 4) / DeviceExtension->ClockSpeed;
1852: period -= localPeriod;
1853: for (i = SynchronousTransferTypes[chipType].InitialRegisterValue;
1854: i < SynchronousTransferTypes[chipType].MaximumPeriodCyles;
1855: i++) {
1856:
1857: if (period <= 0) {
1858: break;
1859: }
1860:
1861: period -= step;
1862: localPeriod += step;
1863: }
1864:
1865: NcrPrint((1, "Local period: %d, Register value: %d\n", localPeriod, i));
1866:
1867: if (i >= SynchronousTransferTypes[chipType].MaximumPeriodCyles) {
1868:
1869: //
1870: // The requested transfer period is too long for the SCSI protocol
1871: // chip. Fall back to synchronous and reject the request.
1872: //
1873:
1874: TargetState->SynchronousOffset = ASYNCHRONOUS_OFFSET;
1875: TargetState->SynchronousPeriod = ASYNCHRONOUS_PERIOD;
1876: TargetState->Configuration3.FastScsi = 0;
1877:
1878: return(FALSE);
1879: }
1880:
1881: TargetState->SynchronousPeriod = (UCHAR) i;
1882:
1883: //
1884: // If no response was expected then the negotation has completed
1885: // successfully. Set the synchronous data transfer parameter registers
1886: // to the new values. These must be set before a data transfer
1887: // is started.
1888: //
1889:
1890: SCSI_WRITE( DeviceExtension->Adapter,
1891: SynchronousPeriod,
1892: TargetState->SynchronousPeriod
1893: );
1894: SCSI_WRITE( DeviceExtension->Adapter,
1895: SynchronousOffset,
1896: TargetState->SynchronousOffset
1897: );
1898: SCSI_WRITE( DeviceExtension->Adapter,
1899: Configuration3,
1900: *((PUCHAR) &TargetState->Configuration3)
1901: );
1902:
1903: return(TRUE);
1904:
1905: }
1906:
1907: VOID
1908: NcrDumpState(
1909: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
1910: )
1911:
1912: /*++
1913:
1914: Routine Description:
1915:
1916: This function prints the interesting state information about the requested
1917: SCSI bus adapter.
1918:
1919: Arguments:
1920:
1921: DeviceExtension - Supplies a pointer to device extension for the SCSI
1922: bus adapter that should be displayed.
1923:
1924: Return Value:
1925:
1926: None.
1927:
1928: --*/
1929:
1930: {
1931: NcrPrint((0, "NcrDumpState: Specific device extension: %8x; Active Logical Unit: %8x;\n",
1932: DeviceExtension,
1933: DeviceExtension->ActiveLogicalUnit
1934: ));
1935: NcrPrint((0, "NcrDumpState: Adapter Status: %2x; Adapter Interrupt: %2x; Adapter Step: %2x;\n",
1936: *((PUCHAR) &DeviceExtension->AdapterStatus),
1937: *((PUCHAR) &DeviceExtension->AdapterInterrupt),
1938: *((PUCHAR) &DeviceExtension->SequenceStep)
1939: ));
1940: NcrPrint((0, "NcrDumpState: Adapter flags: %4x; Adapter state: %d;\n",
1941: DeviceExtension->AdapterFlags,
1942: DeviceExtension->AdapterState
1943: ));
1944:
1945: }
1946:
1947:
1948: BOOLEAN
1949: NcrInitializeAdapter(
1950: IN PVOID ServiceContext
1951: )
1952: /*++
1953:
1954: Routine Description:
1955:
1956: This function initializes the NCR 53c9x SCSI host adpater and protocol
1957: chip. This function must be called before any other operations are
1958: performed. It should also be called after a power failure. This
1959: function does not cause any interrupts; however, after it completes
1960: interrupts can occur.
1961:
1962: Arguments:
1963:
1964: ServiceContext - Pointer to the specific device extension for this SCSI
1965: bus.
1966:
1967: Return Value:
1968:
1969: TRUE - Returns true indicating that the initialization of the chip is
1970: complete.
1971:
1972: --*/
1973:
1974: {
1975: PSPECIFIC_DEVICE_EXTENSION deviceExtension = ServiceContext;
1976: UCHAR dataByte;
1977:
1978: //
1979: // Clear the adapter flags, but preserve the NCR adapter flag.
1980: //
1981:
1982: deviceExtension->AdapterFlags =
1983: deviceExtension->AdapterFlags & PD_NCR_ADAPTER;
1984:
1985: //
1986: // Initialize the NCR 53c9x SCSI protocol chip.
1987: //
1988:
1989: SCSI_WRITE( deviceExtension->Adapter, Command, RESET_SCSI_CHIP );
1990: SCSI_WRITE( deviceExtension->Adapter, Command, NO_OPERATION_DMA );
1991:
1992: //
1993: // Set the configuration register for slow cable mode, parity enable,
1994: // and allow reset interrupts, also set the host adapter SCSI bus id.
1995: // Configuration registers 2 and 3 are cleared by the chip reset and
1996: // do not need to be changed.
1997: //
1998:
1999: dataByte = deviceExtension->AdapterBusId;
2000: ((PSCSI_CONFIGURATION1)(&dataByte))->ParityEnable = 1;
2001:
2002: SCSI_WRITE(deviceExtension->Adapter, Configuration1, dataByte);
2003:
2004: //
2005: // Configuration registers 2 and 3 are cleared by a chip reset and do
2006: // need to be initialized. Note these registers do not exist on the
2007: // Ncr53c90, but the writes will do no harm. Set configuration register 3
2008: // with the value determined by the find adapter routine.
2009: //
2010:
2011: SCSI_WRITE(
2012: deviceExtension->Adapter,
2013: Configuration3,
2014: *((PUCHAR)&deviceExtension->Configuration3)
2015: );
2016:
2017: //
2018: // Enable the SCSI-2 features.
2019: //
2020:
2021: dataByte = 0;
2022: ((PSCSI_CONFIGURATION2)(&dataByte))->Scsi2 = 1;
2023: ((PSCSI_CONFIGURATION2)(&dataByte))->EnablePhaseLatch = 1;
2024:
2025: SCSI_WRITE(deviceExtension->Adapter, Configuration2, dataByte);
2026:
2027: //
2028: // Set the clock conversion register. The clock convertion factor is the
2029: // clock speed divided by 5 rounded up. Only the low three bits are used.
2030: //
2031:
2032: dataByte = (deviceExtension->ClockSpeed + 4) / 5;
2033: SCSI_WRITE(
2034: deviceExtension->Adapter,
2035: ClockConversionFactor,
2036: (dataByte & 0x07)
2037: );
2038:
2039: //
2040: // Set the SelectTimeOut Register to 250ms. This value is based on the
2041: // clock conversion factor and the clock speed.
2042: //
2043:
2044: dataByte = SELECT_TIMEOUT_FACTOR * deviceExtension->ClockSpeed / dataByte;
2045:
2046: SCSI_WRITE( deviceExtension->Adapter, SelectTimeOut, dataByte);
2047:
2048: //
2049: // NOTE: Reselection does not need to be enabled until a request is sent
2050: // to a target. The process of sending a target a request will cause a
2051: // disconnect interrupt so that an ENABLE_SELECTION_RESELECTION request
2052: // will be performed.
2053: //
2054:
2055: if (deviceExtension->AdapterFlags & PD_NCR_ADAPTER) {
2056:
2057: //
2058: // Enable Adapter Interrupts
2059: //
2060:
2061: dataByte = SCSI_READ(deviceExtension->AdapterBase, OptionSelect1);
2062: ((PPOS_DATA_1)(&dataByte))->InterruptEnable = 1;
2063: SCSI_WRITE(deviceExtension->AdapterBase, OptionSelect1, dataByte);
2064:
2065: }
2066:
2067: return( TRUE );
2068: }
2069:
2070: BOOLEAN
2071: NcrInterruptServiceRoutine(
2072: PVOID ServiceContext
2073: )
2074: /*++
2075:
2076: Routine Description:
2077:
2078: This routine is the interrupt service routine for the NCR 53c9x SCSI
2079: host adapter. It is the main SCSI protocol engine of the driver and
2080: is driven by service requests from targets on the SCSI bus. This routine
2081: also detects errors and performs error recovery. Generally, this routine
2082: handles one interrupt per invokation.
2083:
2084: The general flow of this routine is as follows:
2085:
2086: Check for an interrupt.
2087:
2088: Determine if there are any pending errors.
2089:
2090: Check to see if the bus disconnected.
2091:
2092: Check that the previous function completed normally.
2093:
2094: Determine what the target wants to do next and program the chip
2095: appropriately.
2096:
2097: Check for the next interrupt.
2098:
2099: Arguments:
2100:
2101: ServiceContext - Supplies a pointer to the device extension for the
2102: interrupting adapter.
2103:
2104: Return Value:
2105:
2106: TRUE - Indicates that an interrupt was found.
2107:
2108: FALSE - Indicates the device was not interrupting.
2109:
2110: --*/
2111:
2112: {
2113: PSPECIFIC_DEVICE_EXTENSION deviceExtension = ServiceContext;
2114: PSPECIFIC_LOGICAL_UNIT_EXTENSION luExtension;
2115: PSCSI_REQUEST_BLOCK srb;
2116: LONG i;
2117: SCSI_DMA_STATUS DmaStatus;
2118: BOOLEAN setAttention;
2119:
2120: /* POWERFAIL */
2121:
2122: //
2123: // Make sure there is really an interrupt before reading the other
2124: // registers, particularly, the interrupt register.
2125: //
2126:
2127: if (deviceExtension->AdapterFlags & PD_NCR_ADAPTER) {
2128:
2129: *((PUCHAR) &DmaStatus) = SCSI_READ( deviceExtension->AdapterBase, DmaStatus );
2130: if (DmaStatus.Interrupt != deviceExtension->InterruptPending ) {
2131: return(FALSE);
2132: }
2133:
2134: *((PUCHAR) &deviceExtension->AdapterStatus) = SCSI_READ ( deviceExtension->Adapter, ScsiStatus );
2135:
2136: } else {
2137:
2138: *((PUCHAR) &deviceExtension->AdapterStatus) = SCSI_READ ( deviceExtension->Adapter, ScsiStatus );
2139: if (!deviceExtension->AdapterStatus.Interrupt) {
2140: return(FALSE);
2141: }
2142: }
2143:
2144: NextInterrupt:
2145:
2146: //
2147: // Get the current chip state which includes the status register, the
2148: // sequence step register and the interrupt register. These registers are
2149: // frozen until the interrupt register is read.
2150: //
2151:
2152: *((PUCHAR) &deviceExtension->SequenceStep) = SCSI_READ(
2153: deviceExtension->Adapter,
2154: SequenceStep
2155: );
2156: //
2157: // This read will dismiss the interrupt.
2158: //
2159:
2160: *((PUCHAR) &deviceExtension->AdapterInterrupt) = SCSI_READ(
2161: deviceExtension->Adapter,
2162: ScsiInterrupt
2163: );
2164:
2165: #if DBG
2166: if (!deviceExtension->AdapterInterrupt.Disconnect && NcrDebug) {
2167: NcrPrint((0, "NcrInterrupt: Adapter Status: %2x; Adapter Interrupt: %2x; Adapter Step: %2x;\n",
2168: *((PUCHAR) &deviceExtension->AdapterStatus),
2169: *((PUCHAR) &deviceExtension->AdapterInterrupt),
2170: *((PUCHAR) &deviceExtension->SequenceStep)
2171: ));
2172: }
2173: #endif
2174:
2175: deviceExtension->InterruptCount++;
2176:
2177: if (deviceExtension->AdapterInterrupt.IllegalCommand) {
2178: NcrPrint((1, "NcrInterrupt: IllegalCommand\n" ));
2179:
2180: #if DBG
2181: if ( NcrDebug != 0) {
2182: NcrDumpState(deviceExtension);
2183: }
2184: #endif
2185:
2186: if (deviceExtension->AdapterState == AttemptingSelect ||
2187: deviceExtension->AdapterState == Reselected) {
2188:
2189: //
2190: // If an IllegalCommand interrupt has occurred and a select
2191: // is being attempted, flush the FIFO and exit. This occurs
2192: // when the fifo is being filled for a new command at the
2193: // same time time a reselection occurs.
2194: //
2195:
2196: SCSI_WRITE(deviceExtension->Adapter, Command, FLUSH_FIFO);
2197:
2198: } else {
2199:
2200: //
2201: // An illegal command occured at an unexpected time. Reset the
2202: // bus and log an error.
2203: //
2204:
2205: NcrResetScsiBusInternal(deviceExtension, 0);
2206: NcrInitializeAdapter(deviceExtension);
2207:
2208: #ifdef MIPS
2209: //
2210: // There is a chip bug with the Emulex 216 part which causes
2211: // illegal commands interrupts to be generated. This problem
2212: // can be prevented on the mips systems by setting a bit in the
2213: // DMA controller to provide better DMA service to the adapter.
2214: //
2215:
2216: if (deviceExtension->ErrorCount++ == 1) {
2217:
2218: //
2219: // Clear on board DMA
2220: //
2221:
2222: i = ScsiPortReadRegisterUlong(
2223: (PULONG) &DMA_CONTROL->Channel[SCSI_CHANNEL].Enable.Long
2224: );
2225:
2226: ((PDMA_CHANNEL_ENABLE) &i)->ChannelEnable = 0;
2227: ScsiPortWriteRegisterUlong(
2228: (PULONG) &DMA_CONTROL->Channel[SCSI_CHANNEL].Enable.Long,
2229: i
2230: );
2231:
2232:
2233: //
2234: // Enable brust mode in the DMA controller.
2235: //
2236:
2237: i = ScsiPortReadRegisterUlong(
2238: (PULONG) &DMA_CONTROL->Channel[SCSI_CHANNEL].Mode.Long
2239: );
2240:
2241:
2242: ((PDMA_CHANNEL_MODE) &i)->BurstMode = 1;
2243:
2244: ScsiPortWriteRegisterUlong(
2245: (PULONG) &DMA_CONTROL->Channel[SCSI_CHANNEL].Mode.Long,
2246: i
2247: );
2248:
2249: NcrLogError(deviceExtension, SP_BAD_FW_WARNING, 15);
2250:
2251: }
2252: #endif
2253: NcrLogError(deviceExtension, SP_INTERNAL_ADAPTER_ERROR, 14);
2254:
2255: }
2256:
2257: return(TRUE);
2258: }
2259:
2260: //
2261: // Check for major errors these should never occur.
2262: //
2263:
2264: if ( deviceExtension->AdapterInterrupt.Selected ||
2265: deviceExtension->AdapterInterrupt.SelectedWithAttention ||
2266: deviceExtension->AdapterStatus.GrossError ||
2267: deviceExtension->InterruptCount > MAX_INTERRUPT_COUNT) {
2268:
2269: //
2270: // Things are really messed up. Reset the bus, the chip and
2271: // bail out.
2272: //
2273:
2274: NcrPrint((0,
2275: "NcrInterruptServiceRoutine: Unexpected error. Interrupt Count=%d\n",
2276: deviceExtension->InterruptCount
2277: ));
2278:
2279: NcrDumpState(deviceExtension);
2280:
2281: NcrResetScsiBusInternal(deviceExtension, 0);
2282: NcrInitializeAdapter(deviceExtension);
2283:
2284: NcrLogError(deviceExtension, SP_INTERNAL_ADAPTER_ERROR, 1);
2285: return(TRUE);
2286: }
2287:
2288: //
2289: // Check for a bus reset.
2290: //
2291:
2292: if (deviceExtension->AdapterInterrupt.ScsiReset) {
2293:
2294: //
2295: // Check if this was an expected reset.
2296: //
2297:
2298: if (!(deviceExtension->AdapterFlags & PD_EXPECTING_RESET_INTERRUPT)) {
2299:
2300: NcrPrint((0, "NcrInterruptServiceRoutine: SCSI bus reset detected\n"));
2301:
2302: //
2303: // Cleanup the logical units and notify the port driver,
2304: // then return.
2305: //
2306:
2307: NcrCleanupAfterReset(deviceExtension, TRUE);
2308: ScsiPortNotification(
2309: ResetDetected,
2310: deviceExtension,
2311: NULL
2312: );
2313:
2314: } else {
2315: deviceExtension->AdapterFlags &= ~PD_EXPECTING_RESET_INTERRUPT;
2316: }
2317:
2318: //
2319: // Stall for a short time. This allows interrupt to clear.
2320: //
2321:
2322: ScsiPortStallExecution(INTERRUPT_STALL_TIME);
2323:
2324: SCSI_WRITE(deviceExtension->Adapter, Command, FLUSH_FIFO);
2325:
2326: //
2327: // Note that this should only happen in firmware where the interrupts
2328: // are polled.
2329: //
2330:
2331: if (deviceExtension->AdapterFlags & PD_PENDING_START_IO) {
2332:
2333: //
2334: // Call NcrStartIo to start the pending request.
2335: // Note that NcrStartIo is idempotent when called with
2336: // the same arguments.
2337: //
2338:
2339: NcrStartIo(
2340: deviceExtension,
2341: deviceExtension->NextSrbRequest
2342: );
2343:
2344: }
2345:
2346: return(TRUE);
2347: }
2348:
2349: //
2350: // Check for parity errors.
2351: //
2352:
2353: if (deviceExtension->AdapterStatus.ParityError) {
2354:
2355: //
2356: // The SCSI protocol chip has set ATN: we expect the target to
2357: // go into message-out so that a error message can be sent and the
2358: // operation retried. After the error has been noted, continue
2359: // processing the interrupt. The message sent depends on whether a
2360: // message was being received or something else. If the status
2361: // is currently message-in then send-message PARITY ERROR;
2362: // otherwise, send INITIATOR DETECTED ERROR.
2363: //
2364:
2365: NcrPrint((0, "NcrInterruptServiceRoutine: Parity error detected.\n"));
2366: NcrDumpState(deviceExtension);
2367:
2368: //
2369: // If the current phase is MESSAGE_IN then special handling is requred.
2370: //
2371:
2372: if (deviceExtension->AdapterStatus.Phase == MESSAGE_IN) {
2373:
2374: //
2375: // If the current state is CommandComplete, then the fifo contains
2376: // a good status byte. Save the status byte before handling the
2377: // message parity error.
2378: //
2379:
2380: if (deviceExtension->AdapterState == CommandComplete) {
2381:
2382: srb = deviceExtension->ActiveLuRequest;
2383:
2384: srb->ScsiStatus = SCSI_READ(
2385: deviceExtension->Adapter,
2386: Fifo
2387: );
2388:
2389: SRB_EXT(srb)->SrbExtensionFlags |= PD_STATUS_VALID;
2390:
2391: }
2392:
2393: //
2394: // Set the message to indicate a message parity error, flush the
2395: // fifo and accept the message.
2396: //
2397:
2398: deviceExtension->MessageBuffer[0] = SCSIMESS_MESS_PARITY_ERROR;
2399: SCSI_WRITE(deviceExtension->Adapter, Command, FLUSH_FIFO);
2400: NcrAcceptMessage(deviceExtension, TRUE, TRUE);
2401:
2402: //
2403: // Since the message which was in the fifo is no good. Clear the
2404: // function complete interrupt which indicates that a message byte
2405: // has been recieved. If this is a reselection, then this will
2406: // a bus reset to occur. This cause is not handled well in this
2407: // code, because it is not setup to deal with a target id and no
2408: // logical unit.
2409: //
2410:
2411: deviceExtension->AdapterInterrupt.FunctionComplete = FALSE;
2412:
2413: } else {
2414:
2415: deviceExtension->MessageBuffer[0] = SCSIMESS_INIT_DETECTED_ERROR;
2416:
2417: }
2418:
2419: deviceExtension->MessageCount = 1;
2420: deviceExtension->MessageSent = 0;
2421: deviceExtension->AdapterState = MessageOut;
2422: deviceExtension->AdapterFlags |= PD_MESSAGE_OUT_VALID;
2423:
2424: if (!(deviceExtension->AdapterFlags & PD_PARITY_ERROR_LOGGED)) {
2425: NcrLogError(deviceExtension, SP_BUS_PARITY_ERROR, 2);
2426: deviceExtension->AdapterFlags |= PD_PARITY_ERROR_LOGGED;
2427: }
2428:
2429: }
2430:
2431:
2432: //
2433: // Check for bus disconnection. If this was expected, then the next request
2434: // can be processed. If a selection was being attempted, then perhaps the
2435: // logical unit is not there or has gone away. Otherwise, this is an
2436: // unexpected disconnect and should be reported as an error.
2437: //
2438:
2439: if (deviceExtension->AdapterInterrupt.Disconnect) {
2440:
2441: srb = deviceExtension->NextSrbRequest;
2442:
2443: //
2444: // Check for an unexpected disconnect. This occurs if the state is
2445: // not ExpectingDisconnect and a selection did not fail. A selection
2446: // failure is indicated by state of AttemptingSelect and a sequence
2447: // step of 0.
2448: //
2449:
2450: if (deviceExtension->AdapterState == AttemptingSelect &&
2451: deviceExtension->SequenceStep.Step == 0) {
2452:
2453: //
2454: // The target selection failed. Log the error. If the retry
2455: // count is not exceeded then retry the selection; otherwise
2456: // fail the request.
2457: //
2458:
2459: luExtension = ScsiPortGetLogicalUnit(
2460: deviceExtension,
2461: srb->PathId,
2462: srb->TargetId,
2463: srb->Lun
2464: );
2465:
2466: if (luExtension->RetryCount++ >= RETRY_SELECTION_LIMIT) {
2467:
2468: //
2469: // Clear the Active request in the logical unit.
2470: //
2471:
2472: luExtension->RetryCount = 0;
2473:
2474: if (deviceExtension->AdapterFlags & PD_SEND_MESSAGE_REQUEST) {
2475:
2476: //
2477: // Process the completion of the send message request.
2478: // Set the ActiveLogicalUnit for NcrCompleteSendMessage.
2479: // ActiveLogicalUnit is cleared after it returns.
2480: //
2481:
2482: deviceExtension->ActiveLogicalUnit = luExtension;
2483:
2484: NcrCompleteSendMessage(
2485: deviceExtension,
2486: SRB_STATUS_SELECTION_TIMEOUT
2487: );
2488:
2489: deviceExtension->ActiveLogicalUnit = NULL;
2490:
2491: } else {
2492:
2493: srb->SrbStatus = SRB_STATUS_SELECTION_TIMEOUT;
2494:
2495: ScsiPortNotification(
2496: RequestComplete,
2497: deviceExtension,
2498: srb
2499: );
2500:
2501: luExtension->ActiveLuRequest = NULL;
2502: }
2503:
2504: deviceExtension->NextSrbRequest = NULL;
2505: deviceExtension->AdapterFlags &= ~PD_PENDING_START_IO;
2506:
2507: ScsiPortNotification(
2508: NextRequest,
2509: deviceExtension,
2510: NULL
2511: );
2512:
2513: }
2514:
2515: //
2516: // If the request needs to be retried, it will be automatically
2517: // because the PD_PENDING_START_IO flag is still set, and the
2518: // following code will cause it to be restarted.
2519: //
2520:
2521: //
2522: // The chip leaves some of the command in the FIFO, so clear the
2523: // FIFO so there is no garbage left in it.
2524: //
2525:
2526: SCSI_WRITE(deviceExtension->Adapter, Command, FLUSH_FIFO);
2527:
2528: } else if ( deviceExtension->AdapterState == DisconnectExpected ||
2529: deviceExtension->AdapterFlags & PD_DISCONNECT_EXPECTED) {
2530:
2531: //
2532: // Check to see if this was a send-message request which is
2533: // completed when the disconnect occurs.
2534: //
2535:
2536: if (deviceExtension->AdapterFlags & PD_SEND_MESSAGE_REQUEST) {
2537:
2538: //
2539: // Complete the request.
2540: //
2541:
2542: NcrCompleteSendMessage( deviceExtension,
2543: SRB_STATUS_SUCCESS
2544: );
2545: }
2546:
2547: } else {
2548:
2549: //
2550: // The disconnect was unexpected treat it as an error.
2551: // Check to see if a data transfer was in progress, if so flush
2552: // the DMA.
2553: //
2554:
2555: if (deviceExtension->AdapterState == DataTransfer) {
2556: ScsiPortFlushDma(deviceExtension);
2557: }
2558:
2559: //
2560: // NOTE: If the state is AttemptingSelect, then ActiveLogicalUnit
2561: // is NULL!
2562: //
2563:
2564: //
2565: // The chip leaves some of the command in the FIFO, so clear the
2566: // FIFO so there is not garbage left in it.
2567: //
2568:
2569: SCSI_WRITE(deviceExtension->Adapter, Command, FLUSH_FIFO);
2570:
2571: //
2572: // An unexpected disconnect has occurred. Log the error. It is
2573: // not clear if the device will respond again, so let the time-out
2574: // code clean up the request if necessary.
2575: //
2576:
2577: NcrPrint((0, "NcrInterruptServiceRoutine: Unexpected bus disconnect\n"));
2578:
2579: NcrLogError(deviceExtension, SP_UNEXPECTED_DISCONNECT, 3);
2580: }
2581:
2582: //
2583: // Clean up the adapter state to indicate the bus is now free, enable
2584: // reselection, and start any pending request.
2585: //
2586:
2587: deviceExtension->AdapterState = BusFree;
2588: deviceExtension->AdapterFlags &= ~PD_ADAPTER_DISCONNECT_MASK;
2589: deviceExtension->ActiveLuRequest = NULL;
2590: SCSI_WRITE(deviceExtension->Adapter, Command, ENABLE_SELECTION_RESELECTION);
2591:
2592: #if DBG
2593: if (NcrDebug) {
2594: NcrPrint((0, "NcrInterruptServiceRoutine: DisconnectComplete.\n"));
2595: }
2596: #endif
2597:
2598: if (deviceExtension->AdapterFlags & PD_PENDING_START_IO) {
2599:
2600: ASSERT(deviceExtension->NextSrbRequest->SrbExtension != NULL);
2601:
2602: //
2603: // Check that the next request is still active. This should not
2604: // be necessary, but it appears there is a hole somewhere.
2605: //
2606:
2607: srb = deviceExtension->NextSrbRequest;
2608: srb = ScsiPortGetSrb(
2609: deviceExtension,
2610: srb->PathId,
2611: srb->TargetId,
2612: srb->Lun,
2613: srb->QueueTag
2614: );
2615:
2616: ASSERT(srb == deviceExtension->NextSrbRequest ||
2617: deviceExtension->NextSrbRequest->Function != SRB_FUNCTION_EXECUTE_SCSI);
2618:
2619: if (srb != deviceExtension->NextSrbRequest &&
2620: deviceExtension->NextSrbRequest->Function == SRB_FUNCTION_EXECUTE_SCSI) {
2621:
2622: NcrPrint((1, "NcrInterruptServiceRoutine: Found in active SRB in next request field.\n"));
2623: NcrDumpState(deviceExtension);
2624:
2625: //
2626: // Dump it on the floor.
2627: //
2628:
2629: deviceExtension->NextSrbRequest = NULL;
2630: deviceExtension->AdapterFlags &= ~PD_PENDING_START_IO;
2631:
2632: NcrLogError(deviceExtension, SP_INTERNAL_ADAPTER_ERROR, 18);
2633:
2634: ScsiPortNotification(
2635: NextRequest,
2636: deviceExtension,
2637: NULL
2638: );
2639:
2640: } else {
2641:
2642: //
2643: // Call NcrStartIo to start the pending request.
2644: // Note that NcrStartIo is idempotent when called with
2645: // the same arguments.
2646: //
2647:
2648: NcrStartIo(
2649: deviceExtension,
2650: deviceExtension->NextSrbRequest
2651: );
2652:
2653: }
2654: }
2655: }
2656:
2657:
2658: //
2659: // Check for a reselection interrupt.
2660: //
2661:
2662: if (deviceExtension->AdapterInterrupt.Reselected) {
2663: UCHAR targetId;
2664: UCHAR luId;
2665:
2666: //
2667: // The usual case is not to set attention so initialize the
2668: // varible to FALSE.
2669: //
2670:
2671: setAttention = FALSE;
2672:
2673: //
2674: // If the FunctionComplete interrupt is not set then the target did
2675: // not send an IDENTFY message. This is a fatal protocol violation.
2676: // Reset the bus to get rid of this target.
2677: //
2678:
2679: if (!deviceExtension->AdapterInterrupt.FunctionComplete) {
2680:
2681: NcrPrint((0, "NcrInterruptServiceRoutine: Reselection Failed.\n"));
2682: NcrDumpState(deviceExtension);
2683:
2684: NcrResetScsiBusInternal(deviceExtension, 0);
2685: NcrInitializeAdapter(deviceExtension);
2686:
2687: NcrLogError(deviceExtension, SP_PROTOCOL_ERROR, 4);
2688:
2689: return(TRUE);
2690: }
2691:
2692: //
2693: // The target Id and the logical unit id are in the FIFO. Use them to
2694: // get the connected active logical unit.
2695: //
2696:
2697: luId = SCSI_READ(deviceExtension->Adapter, Fifo);
2698:
2699: //
2700: // The select id has two bits set. One is the SCSI bus id of the
2701: // initiator and the other is the reselecting target id. The initiator
2702: // id must be stripped and the remaining bit converted to a bit number
2703: // to get the target id.
2704: //
2705:
2706: luId &= ~deviceExtension->AdapterBusIdMask;
2707: WHICH_BIT(luId, targetId);
2708:
2709: luId = SCSI_READ(deviceExtension->Adapter, Fifo);
2710:
2711: //
2712: // The logical unit id is stored in the low-order 3 bits of the
2713: // IDENTIFY message, so the upper bits must be stripped off the
2714: // byte read from the FIFO to get the logical unit number.
2715: //
2716:
2717: luId &= SCSI_MAXIMUM_LOGICAL_UNITS - 1;
2718:
2719: luExtension = ScsiPortGetLogicalUnit( deviceExtension,
2720: 0,
2721: targetId,
2722: luId
2723: );
2724:
2725: //
2726: // Check to that this is a valid logical unit.
2727: //
2728:
2729: if (luExtension == NULL) {
2730:
2731: NcrPrint((0, "NcrInterruptServiceRoutine: Reselection Failed.\n"));
2732: NcrDumpState(deviceExtension);
2733:
2734:
2735: ScsiPortLogError(
2736: deviceExtension, // HwDeviceExtension,
2737: NULL, // Srb
2738: 0, // PathId,
2739: targetId, // TargetId,
2740: luId, // Lun,
2741: SP_INVALID_RESELECTION, // ErrorCode,
2742: 4 // UniqueId
2743: );
2744:
2745: //
2746: // Send an abort message. Put the message in the buffer, set the
2747: // state, indicate that a disconnect is expected after this, and
2748: // set the attention signal.
2749: //
2750:
2751: deviceExtension->MessageBuffer[0] = SCSIMESS_ABORT;
2752: deviceExtension->MessageCount = 1;
2753: deviceExtension->MessageSent = 0;
2754: deviceExtension->AdapterState = MessageOut;
2755: deviceExtension->AdapterFlags &= ~PD_ADAPTER_DISCONNECT_MASK;
2756: deviceExtension->AdapterFlags |= PD_MESSAGE_OUT_VALID |
2757: PD_DISCONNECT_EXPECTED;
2758:
2759: setAttention = TRUE;
2760:
2761: } else {
2762:
2763: //
2764: // Everything looks ok.
2765: //
2766:
2767: //
2768: // A reselection has been completed. Set the active logical
2769: // unit, restore the active data pointer, and set the state.
2770: // In addition, any adpater flags set by a pending select
2771: // must be cleared using the disconnect mask.
2772: //
2773:
2774: deviceExtension->AdapterFlags &= ~PD_ADAPTER_DISCONNECT_MASK;
2775: deviceExtension->ActiveLogicalUnit = luExtension;
2776: deviceExtension->AdapterState = Reselected;
2777: deviceExtension->MessageCount = 0;
2778:
2779: srb = luExtension->ActiveLuRequest;
2780: deviceExtension->ActiveLuRequest = srb;
2781:
2782: if (srb == NULL) {
2783:
2784: //
2785: // This must be a reconnect for a tagged request.
2786: // Indicate a queue tag message is expected next and save
2787: // the target and logical unit ids.
2788: //
2789:
2790: deviceExtension->AdapterFlags |= PD_EXPECTING_QUEUE_TAG;
2791: deviceExtension->Lun = luId;
2792: } else {
2793:
2794: deviceExtension->ActiveDataPointer = SRB_EXT(srb)->SavedDataPointer;
2795: deviceExtension->ActiveDataLength = SRB_EXT(srb)->SavedDataLength;
2796:
2797: }
2798: }
2799:
2800: //
2801: // The bus is waiting for the message to be accepted. The attention
2802: // signal will be set if this is not a valid reselection. Finally,
2803: // the synchronous data tranfer parameters need to be set in case a
2804: // data transfer is done.
2805: //
2806:
2807: deviceExtension->TargetId = targetId;
2808: NcrAcceptMessage(deviceExtension, setAttention, TRUE);
2809: deviceExtension->InterruptCount = 0;
2810:
2811: } else if (deviceExtension->AdapterInterrupt.FunctionComplete) {
2812:
2813: //
2814: // Check for function complete interrupt if there was not a reselected
2815: // interrupt. The function complete interrupt has already been checked
2816: // in the previous case.
2817: //
2818: // The function complete interrupt occurs after the following cases:
2819: // A select succeeded
2820: // A message byte has been read
2821: // A status byte and message byte have been read when in the
2822: // command complete state.
2823: // A reselection (handled above)
2824: //
2825: // Switch on the state current state of the bus to determine what
2826: // action should be taken now the function has completed.
2827: //
2828:
2829: switch (deviceExtension->AdapterState) {
2830: case AttemptingSelect:
2831:
2832: //
2833: // The target was successfully selected. Set the active
2834: // logical unit field, clear the next logical unit, and
2835: // notify the OS-dependent driver that a new request can
2836: // be accepted. The state is set to MessageOut since is
2837: // the next thing done after a selection.
2838: //
2839:
2840: deviceExtension->ActiveLogicalUnit = ScsiPortGetLogicalUnit(
2841: deviceExtension,
2842: deviceExtension->NextSrbRequest->PathId,
2843: deviceExtension->NextSrbRequest->TargetId,
2844: deviceExtension->NextSrbRequest->Lun
2845: );
2846:
2847: srb = deviceExtension->NextSrbRequest;
2848: deviceExtension->ActiveLuRequest = srb;
2849:
2850: //
2851: // Restore the data pointers.
2852: //
2853:
2854: deviceExtension->ActiveDataPointer = SRB_EXT(srb)->SavedDataPointer;
2855: deviceExtension->ActiveDataLength = SRB_EXT(srb)->SavedDataLength;
2856:
2857: //
2858: // The next request has now become the active request.
2859: // Clear the state associated with the next request and ask for
2860: // another one to start.
2861: //
2862:
2863: deviceExtension->AdapterFlags &= ~PD_PENDING_START_IO;
2864: deviceExtension->NextSrbRequest = NULL;
2865: deviceExtension->AdapterState = MessageOut;
2866:
2867: //
2868: // If this was a tagged request then indicate that the next
2869: // request for this lu may be sent.
2870: //
2871:
2872: if (deviceExtension->AdapterFlags & PD_TAGGED_SELECT) {
2873:
2874: ScsiPortNotification(
2875: NextLuRequest,
2876: deviceExtension,
2877: srb->PathId,
2878: srb->TargetId,
2879: srb->Lun
2880: );
2881:
2882: } else {
2883:
2884: ScsiPortNotification(
2885: NextRequest,
2886: deviceExtension,
2887: NULL
2888: );
2889:
2890: }
2891:
2892: break;
2893:
2894: case CommandComplete:
2895:
2896: //
2897: // The FIFO contains the status byte and a message byte. Save the
2898: // status byte and set the state to look like MessageIn, then fall
2899: // through to the message-in state.
2900: //
2901:
2902: srb = deviceExtension->ActiveLuRequest;
2903:
2904: ASSERT(deviceExtension->NextSrbRequest != srb);
2905:
2906: srb->ScsiStatus = SCSI_READ(
2907: deviceExtension->Adapter,
2908: Fifo
2909: );
2910:
2911: SRB_EXT(srb)->SrbExtensionFlags |= PD_STATUS_VALID;
2912:
2913: deviceExtension->AdapterState = MessageIn;
2914: deviceExtension->MessageCount = 0;
2915: deviceExtension->AdapterFlags &= ~PD_MESSAGE_OUT_VALID;
2916:
2917: //
2918: // Fall through and process the message byte in the FIFO.
2919: //
2920:
2921: case MessageIn:
2922:
2923: //
2924: // A message byte has been received. Store it in the message buffer
2925: // and call message decode to determine what to do. The message
2926: // byte will either be accepted, or cause a message to be sent.
2927: // A message-out is indicated to the target by setting the ATN
2928: // line before sending the SCSI protocol chip the MESSAGE_ACCEPTED
2929: // command.
2930: //
2931:
2932: deviceExtension->MessageBuffer[deviceExtension->MessageCount++] =
2933: SCSI_READ( deviceExtension->Adapter, Fifo );
2934:
2935: if (NcrMessageDecode( deviceExtension )) {
2936:
2937: //
2938: // NcrMessageDecode returns TRUE if there is a message to be
2939: // sent out. This message will normally be a MESSAGE REJECT
2940: // or a SYNCHRONOUS DATA TRANSFER REQUEST. In any case, the
2941: // message has been set by NcrMessageDecode. All that needs
2942: // to be done here is set the ATN signal and set
2943: // PD_MESSAGE_OUT_VALID in the adapter flags.
2944: //
2945:
2946: deviceExtension->AdapterFlags |= PD_MESSAGE_OUT_VALID;
2947: setAttention = TRUE;
2948: } else {
2949: setAttention = FALSE;
2950: }
2951:
2952: //
2953: // In either case, tell the SCSI protocol chip to acknowlege or
2954: // accept the message. The synchronous data transfer parameters
2955: // do not need to be set.
2956: //
2957:
2958: NcrAcceptMessage( deviceExtension, setAttention, FALSE);
2959: break;
2960:
2961: default:
2962:
2963: //
2964: // A function complete should not occur while in any other states.
2965: //
2966:
2967: NcrPrint((0, "NcrInterruptServiceRoutine: Unexpected function complete interrupt.\n"));
2968: NcrDumpState(deviceExtension);
2969:
2970: }
2971: }
2972:
2973:
2974: //
2975: // Check for a bus service interrupt. This interrupt indicates the target
2976: // is requesting some form of bus transfer. The bus transfer type is
2977: // determined by the bus phase.
2978: //
2979:
2980: if (deviceExtension->AdapterInterrupt.BusService) {
2981:
2982: luExtension = deviceExtension->ActiveLogicalUnit;
2983:
2984: if (luExtension == NULL) {
2985:
2986: //
2987: // There should never be an bus service interrupt without an
2988: // active locgial unit. The bus or the chip is really messed up.
2989: // Reset the bus and return.
2990: //
2991:
2992: NcrPrint((0, "NcrInterruptServiceRoutine: Unexpected Bus service interrupt.\n"));
2993: NcrDumpState(deviceExtension);
2994:
2995: NcrResetScsiBusInternal(deviceExtension, 0);
2996: NcrInitializeAdapter(deviceExtension);
2997:
2998: NcrLogError(deviceExtension, SP_PROTOCOL_ERROR, 6);
2999:
3000: return(TRUE);
3001: }
3002:
3003: srb = deviceExtension->ActiveLuRequest;
3004:
3005: //
3006: // If there is no current srb request then the bus service interrupt
3007: // must be a message in with a tag.
3008: //
3009:
3010: if (deviceExtension->AdapterFlags & PD_EXPECTING_QUEUE_TAG &&
3011: deviceExtension->AdapterStatus.Phase != MESSAGE_IN ) {
3012:
3013: //
3014: // A bus service interrupt occured when a queue tag message
3015: // was exepected. Is a protocol error by the target reset the
3016: // bus.
3017: //
3018:
3019: NcrPrint((0, "NcrInterruptServiceRoutine: Unexpected Bus service interrupt when queue tag expected.\n"));
3020: NcrDumpState(deviceExtension);
3021:
3022: NcrResetScsiBusInternal(deviceExtension, 0);
3023: NcrInitializeAdapter(deviceExtension);
3024:
3025: NcrLogError(deviceExtension, SP_PROTOCOL_ERROR, 13);
3026:
3027: return(TRUE);
3028:
3029: }
3030:
3031: //
3032: // The bus is changing phases or needs more data. Generally, the target
3033: // can change bus phase at any time: in particular, in the middle of
3034: // a data transfer. The initiator must be able to restart a transfer
3035: // where it left off. To do this it must know how much data was
3036: // transferred. If the previous state was a data transfer, then the
3037: // amount of data transferred needs to be determined, saved and
3038: // the DMA flushed.
3039: //
3040:
3041: if (deviceExtension->AdapterState == DataTransfer) {
3042: SCSI_FIFO_FLAGS fifoFlags;
3043:
3044: //
3045: // Figure out how many bytes have been transferred based on the
3046: // original transfer count stored in the ActiveLengthField,
3047: // SCSI protocol chip transfer counters, and
3048: // the number of bytes in the FIFO. The normal case is when all
3049: // the bytes have been transferred so check for that using the
3050: // TerminalCount bit in the status field.
3051: //
3052:
3053: i = 0;
3054:
3055: if (!deviceExtension->AdapterStatus.TerminalCount) {
3056:
3057: //
3058: // Read bits 23-16 if this chip has that register.
3059: //
3060:
3061: if (deviceExtension->ChipType == Fas216) {
3062:
3063: i = (SCSI_READ(deviceExtension->Adapter,
3064: TransferCountPage
3065: )) << 16;
3066:
3067: }
3068:
3069: //
3070: // Read the current value of the tranfer count registers;
3071: //
3072:
3073: i |= (SCSI_READ(deviceExtension->Adapter, TransferCountHigh)) << 8;
3074: i |= SCSI_READ(deviceExtension->Adapter, TransferCountLow );
3075:
3076: //
3077: // A value of zero in i and TerminalCount clear indicates
3078: // that the transfer length was 64K and that no bytes were
3079: // transferred. Set i to 64K.
3080: //
3081:
3082: if (i == 0) {
3083: i = 0x10000;
3084: }
3085:
3086: }
3087:
3088: //
3089: // If this is a write then there may still be some bytes in the
3090: // FIFO which have yet to be transferred to the target.
3091: //
3092:
3093: if (srb->SrbFlags & SRB_FLAGS_DATA_OUT) {
3094: *((PUCHAR) &fifoFlags) = SCSI_READ(deviceExtension->Adapter,
3095: FifoFlags
3096: );
3097: i += fifoFlags.ByteCount;
3098:
3099:
3100: if (i == 1 && deviceExtension->ChipType == Fas216) {
3101:
3102: //
3103: // This is a chip bug. If the bus state is still data
3104: // out then tell the chip to transfer one more byte.
3105: //
3106:
3107: NcrPrint((1, "NcrInterruptServiceRoutine: One byte left!\n"));
3108:
3109: //
3110: // Set the transfer count.
3111: //
3112:
3113: SCSI_WRITE( deviceExtension->Adapter,
3114: TransferCountLow,
3115: 1
3116: );
3117: SCSI_WRITE( deviceExtension->Adapter,
3118: TransferCountHigh,
3119: 0
3120: );
3121:
3122: SCSI_WRITE(deviceExtension->Adapter,
3123: TransferCountPage,
3124: 0
3125: );
3126:
3127: SCSI_WRITE(deviceExtension->Adapter, Command, TRANSFER_INFORMATION);
3128:
3129: return(TRUE);
3130: }
3131:
3132: //
3133: // The chip leaves some data in the FIFO, so clear the
3134: // FIFO so there is not garbage left in it.
3135: //
3136:
3137: SCSI_WRITE(deviceExtension->Adapter, Command, FLUSH_FIFO);
3138: }
3139:
3140: //
3141: // i now contains the number of bytes to be transferred.
3142: // Check to see if this the maximum that has be transferred so far,
3143: // and update the active data pointer and the active length.
3144: //
3145:
3146: if (srb->DataTransferLength - i >
3147: SRB_EXT(srb)->MaximumTransferLength) {
3148: SRB_EXT(srb)->MaximumTransferLength = srb->DataTransferLength -
3149: i;
3150: }
3151:
3152: deviceExtension->ActiveDataPointer +=
3153: deviceExtension->ActiveDataLength - i;
3154: deviceExtension->ActiveDataLength = i;
3155:
3156: //
3157: // Flush the DMA to ensure all the bytes are transferred.
3158: //
3159:
3160: deviceExtension->AdapterFlags &= ~PD_PENDING_DATA_TRANSFER;
3161: ScsiPortFlushDma(deviceExtension);
3162:
3163: } else if (deviceExtension->AdapterState == DisconnectExpected) {
3164:
3165: //
3166: // This is an error; however, some contollers attempt to read more
3167: // message bytes even after a message indicating a disconnect.
3168: // If the request is for a message transfer and extra bytes
3169: // are expected, then allow the transfer; otherwise, reset the bus.
3170: //
3171:
3172: if (!(deviceExtension->AdapterFlags & PD_POSSIBLE_EXTRA_MESSAGE_OUT)
3173: || (deviceExtension->AdapterStatus.Phase != MESSAGE_OUT &&
3174: deviceExtension->AdapterStatus.Phase != MESSAGE_IN)) {
3175:
3176: //
3177: // If a disconnect was expected and a bus service interrupt was
3178: // detected, then a SCSI protocol error has been detected and the
3179: // SCSI bus should be reset to clear the condition.
3180: //
3181:
3182: NcrPrint((0, "NcrInterruptServiceRoutine: Bus request while disconnect expected.\n"));
3183: NcrDumpState(deviceExtension);
3184:
3185: NcrResetScsiBusInternal(deviceExtension, 0);
3186: NcrInitializeAdapter(deviceExtension);
3187:
3188: NcrLogError(deviceExtension, SP_PROTOCOL_ERROR, 7);
3189:
3190: return(TRUE);
3191: } else {
3192:
3193: //
3194: // Make sure the disconnect-expected flag is set.
3195: //
3196:
3197: deviceExtension->AdapterFlags |= PD_DISCONNECT_EXPECTED;
3198: }
3199: } else if (deviceExtension->AdapterState == MessageOut) {
3200:
3201: //
3202: // The SCSI protocol chip indicates that the message has been sent;
3203: // however, the target may need to reread the message or there
3204: // may be more messages to send. This condition is indicated by a
3205: // message-out bus phase; otherwise, the message has been accepted
3206: // by the target. If message has been accepted then check to see
3207: // if any special processing is necessary. Note that the driver
3208: // state is set to MessageOut after the PD_DISCONNECT_EXPECTED is
3209: // set, or after a selection. So it is only necessary to check for
3210: // PD_DISCONNECT_EXPECTED when the driver state is currently in
3211: // MessageOut.
3212: //
3213:
3214: if (deviceExtension->AdapterFlags & (PD_DISCONNECT_EXPECTED |
3215: PD_SYNCHRONOUS_TRANSFER_SENT | PD_SYNCHRONOUS_RESPONSE_SENT) &&
3216: deviceExtension->AdapterStatus.Phase != MESSAGE_OUT &&
3217: deviceExtension->AdapterStatus.Phase != MESSAGE_IN) {
3218:
3219: if (deviceExtension->AdapterFlags & PD_DISCONNECT_EXPECTED) {
3220:
3221: //
3222: // If a disconnect was expected and a bus service interrupt was
3223: // detected, then a SCSI protocol error has been detected and the
3224: // SCSI bus should be reset to clear the condition.
3225: //
3226:
3227: NcrPrint((0, "NcrInterruptServiceRoutine: Bus request while disconnect expected after message-out.\n"));
3228: NcrDumpState(deviceExtension);
3229:
3230: NcrResetScsiBusInternal(deviceExtension, 0);
3231: NcrInitializeAdapter(deviceExtension);
3232:
3233: NcrLogError(deviceExtension, SP_PROTOCOL_ERROR, 8);
3234:
3235: return(TRUE);
3236:
3237: } else if (deviceExtension->AdapterFlags &
3238: PD_SYNCHRONOUS_TRANSFER_SENT) {
3239:
3240: //
3241: // The controller ignored the synchronous transfer message.
3242: // Treat it as a rejection and clear the necessary state.
3243: //
3244:
3245: deviceExtension->TargetState[deviceExtension->TargetId]
3246: .TargetFlags |=
3247: PD_SYNCHRONOUS_NEGOTIATION_DONE | PD_DO_NOT_NEGOTIATE;
3248: deviceExtension->AdapterFlags &=
3249: ~(PD_SYNCHRONOUS_RESPONSE_SENT |
3250: PD_SYNCHRONOUS_TRANSFER_SENT);
3251: } else if (deviceExtension->AdapterFlags &
3252: PD_SYNCHRONOUS_RESPONSE_SENT) {
3253:
3254: //
3255: // The target controller accepted the negotiation. Set
3256: // the done flag in the logical unit and clear the
3257: // negotiation flags in the adapter.
3258: //
3259:
3260: deviceExtension->TargetState[deviceExtension->TargetId].TargetFlags |=
3261: PD_SYNCHRONOUS_NEGOTIATION_DONE | PD_DO_NOT_NEGOTIATE;
3262: deviceExtension->AdapterFlags &=
3263: ~(PD_SYNCHRONOUS_RESPONSE_SENT |
3264: PD_SYNCHRONOUS_TRANSFER_SENT);
3265:
3266: }
3267: }
3268: }
3269:
3270: //
3271: // If the bus phase is not DATA_IN then the FIFO may need to be
3272: // flushed. The FIFO cannot be flushed while the bus is in the
3273: // DATA_IN phase because the FIFO already has data bytes in it.
3274: // The only case where a target can legally switch phases while
3275: // there are message bytes in the FIFO to the MESSAGE_OUT bus
3276: // phase. If the target leaves message bytes and attempts to
3277: // goto a DATA_IN phase, then the transfer will appear to overrun
3278: // and be detected as an error.
3279: //
3280:
3281: if (deviceExtension->AdapterStatus.Phase != DATA_IN) {
3282: SCSI_WRITE(deviceExtension->Adapter, Command, FLUSH_FIFO);
3283: }
3284:
3285: //
3286: // Decode the current bus phase.
3287: //
3288:
3289: switch (deviceExtension->AdapterStatus.Phase) {
3290:
3291: case COMMAND_OUT:
3292:
3293: //
3294: // Fill the FIFO with the commnad and tell the SCSI protocol chip
3295: // to go.
3296: //
3297:
3298: for (i = 0; i < srb->CdbLength; i++) {
3299: SCSI_WRITE( deviceExtension->Adapter,
3300: Fifo,
3301: srb->Cdb[i]
3302: );
3303: }
3304:
3305: SCSI_WRITE( deviceExtension->Adapter,
3306: Command,
3307: TRANSFER_INFORMATION
3308: );
3309:
3310: deviceExtension->AdapterState = CommandOut;
3311:
3312: break;
3313:
3314: case STATUS_IN:
3315:
3316: //
3317: // Setup of the SCSI protocol chip to read in the status and the
3318: // following message byte, and set the adapter state.
3319: //
3320:
3321: SCSI_WRITE( deviceExtension->Adapter, Command, COMMAND_COMPLETE );
3322: deviceExtension->AdapterState = CommandComplete;
3323:
3324: break;
3325:
3326: case MESSAGE_OUT:
3327:
3328: //
3329: // The target is requesting a message-out. There are three
3330: // possible cases. First, the target is improperly requesting
3331: // a message. Second, a message has been sent, but the target
3332: // could not read it properly. Third, a message has been
3333: // partially sent and the target is requesting the remainder
3334: // of the message.
3335: //
3336: // The first case is indicated when the MessageCount is zero or
3337: // the message-out flag is not set.
3338: //
3339:
3340: if ( deviceExtension->MessageCount == 0 ||
3341: !(deviceExtension->AdapterFlags & PD_MESSAGE_OUT_VALID)) {
3342:
3343: //
3344: // If extra message-outs are possible then just send a NOP
3345: // message.
3346:
3347: if (deviceExtension->AdapterFlags &
3348: PD_POSSIBLE_EXTRA_MESSAGE_OUT) {
3349:
3350: //
3351: // Set the message to NOP and clear the extra message
3352: // flag. This is a hack for controllers that do not
3353: // properly read the entire message.
3354: //
3355:
3356: deviceExtension->MessageBuffer[0] = SCSIMESS_NO_OPERATION;
3357: deviceExtension->AdapterFlags &=
3358: ~PD_POSSIBLE_EXTRA_MESSAGE_OUT;
3359: } else {
3360:
3361: //
3362: // Send an INITIATOR DETECTED ERROR message.
3363: //
3364:
3365: deviceExtension->MessageBuffer[0] =
3366: SCSIMESS_INIT_DETECTED_ERROR;
3367: NcrLogError(deviceExtension, SP_PROTOCOL_ERROR, 9);
3368: NcrPrint((0, "NcrInterruptServiceRoutine: Unexpected message-out request\n"));
3369: NcrDumpState(deviceExtension);
3370:
3371: }
3372:
3373: deviceExtension->MessageCount = 1;
3374: deviceExtension->MessageSent = 0;
3375: deviceExtension->AdapterState = MessageOut;
3376:
3377: }
3378:
3379: //
3380: // The second case is indicated when MessageCount and MessageSent
3381: // are equal and nonzero.
3382: //
3383:
3384: if (deviceExtension->MessageCount == deviceExtension->MessageSent){
3385:
3386: //
3387: // The message needs to be resent, so set ATN, clear MessageSent
3388: // and fall through to the next case.
3389: //
3390:
3391: SCSI_WRITE(deviceExtension->Adapter, Command, SET_ATTENTION);
3392: deviceExtension->MessageSent = 0;
3393: }
3394:
3395: if (deviceExtension->MessageCount != deviceExtension->MessageSent){
3396:
3397: //
3398: // The ATTENTION signal needs to be set if the current state
3399: // is not MessageOut.
3400: //
3401:
3402: if (deviceExtension->AdapterState != MessageOut) {
3403:
3404: SCSI_WRITE(
3405: deviceExtension->Adapter,
3406: Command,
3407: SET_ATTENTION
3408: );
3409: }
3410:
3411: //
3412: // There is more message to send. Fill the FIFO with the
3413: // message and tell the SCSI protocol chip to transfer the
3414: // message.
3415: //
3416:
3417: for (;
3418: deviceExtension->MessageSent <
3419: deviceExtension->MessageCount;
3420: deviceExtension->MessageSent++ ) {
3421:
3422: SCSI_WRITE(deviceExtension->Adapter,
3423: Fifo,
3424: deviceExtension->
3425: MessageBuffer[deviceExtension->MessageSent]
3426: );
3427:
3428: }
3429:
3430: SCSI_WRITE(deviceExtension->Adapter,
3431: Command,
3432: TRANSFER_INFORMATION
3433: );
3434:
3435: }
3436:
3437: break;
3438:
3439: case MESSAGE_IN:
3440:
3441: //
3442: // If this is the first byte of the message then initialize
3443: // MessageCount and the adapter state. The message buffer
3444: // cannot overflow because the message decode function will
3445: // take care of the message before the buffer is full.
3446: // The SCSI protocol chip will interrupt for each message
3447: // byte.
3448: //
3449:
3450: if ( deviceExtension->AdapterState != MessageIn &&
3451: deviceExtension->AdapterState != MessageAccepted ) {
3452:
3453: deviceExtension->AdapterFlags &= ~PD_MESSAGE_OUT_VALID;
3454: deviceExtension->MessageCount = 0;
3455: }
3456:
3457: deviceExtension->AdapterState = MessageIn;
3458:
3459: SCSI_WRITE( deviceExtension->Adapter,
3460: Command,
3461: TRANSFER_INFORMATION
3462: );
3463:
3464: break;
3465:
3466: case DATA_OUT:
3467: case DATA_IN:
3468:
3469: //
3470: // Check that the transfer direction is ok, setup the DMA, set
3471: // the synchronous transfer parameter, and tell the chip to go.
3472: // Also check that there is still data to be transferred.
3473: //
3474:
3475: if ((!(srb->SrbFlags & SRB_FLAGS_DATA_IN) &&
3476: deviceExtension->AdapterStatus.Phase == DATA_IN) ||
3477:
3478: (!(srb->SrbFlags & SRB_FLAGS_DATA_OUT) &&
3479: deviceExtension->AdapterStatus.Phase == DATA_OUT) ||
3480:
3481: deviceExtension->ActiveDataLength == 0 ) {
3482:
3483: //
3484: // The data direction is incorrect. Reset the bus to clear
3485: // things up.
3486: //
3487:
3488: NcrPrint((0, "NcrInterruptServiceRoutine: Illegal transfer direction.\n"));
3489: NcrDumpState(deviceExtension);
3490:
3491: NcrResetScsiBusInternal(deviceExtension, 0);
3492: NcrInitializeAdapter(deviceExtension);
3493:
3494: NcrLogError(deviceExtension, SP_PROTOCOL_ERROR, 10);
3495:
3496: return(TRUE);
3497: }
3498:
3499: //
3500: // Set the transfer count.
3501: //
3502:
3503: SCSI_WRITE( deviceExtension->Adapter,
3504: TransferCountLow,
3505: (UCHAR) deviceExtension->ActiveDataLength
3506: );
3507: SCSI_WRITE( deviceExtension->Adapter,
3508: TransferCountHigh,
3509: (UCHAR) (deviceExtension->ActiveDataLength >> 8)
3510: );
3511:
3512: //
3513: // Write bits 23-16 if this chip has that register.
3514: //
3515:
3516: if (deviceExtension->ChipType == Fas216) {
3517:
3518: SCSI_WRITE(deviceExtension->Adapter,
3519: TransferCountPage,
3520: (UCHAR) (deviceExtension->ActiveDataLength >> 16)
3521: );
3522:
3523: }
3524:
3525: //
3526: // Clear the extra data transfer flags correctly.
3527: //
3528:
3529: if (deviceExtension->AdapterStatus.Phase == DATA_IN) {
3530: srb->SrbFlags &= ~SRB_FLAGS_DATA_OUT;
3531: } else {
3532: srb->SrbFlags &= ~SRB_FLAGS_DATA_IN;
3533: }
3534:
3535: //
3536: // Set up the DMA controller.
3537: //
3538:
3539: deviceExtension->AdapterState = DataTransfer;
3540: deviceExtension->AdapterFlags |= PD_PENDING_DATA_TRANSFER;
3541:
3542: ScsiPortIoMapTransfer( deviceExtension,
3543: srb,
3544: (PVOID) deviceExtension->ActiveDataPointer,
3545: deviceExtension->ActiveDataLength
3546: );
3547:
3548: break;
3549:
3550: default:
3551:
3552: //
3553: // This phase is illegal and indicates a serious error. Reset the
3554: // bus to clear the problem.
3555: //
3556:
3557: NcrPrint((0, "NcrInterruptServiceRoutine: Illegal bus state detected.\n"));
3558: NcrDumpState(deviceExtension);
3559:
3560: NcrResetScsiBusInternal(deviceExtension, 0);
3561: NcrInitializeAdapter(deviceExtension);
3562:
3563: NcrLogError(deviceExtension, SP_PROTOCOL_ERROR, 11);
3564:
3565: return(TRUE);
3566: }
3567: }
3568:
3569: //
3570: // Stall for a short time. This allows interrupt to clear and gives new
3571: // interrupts a chance to fire.
3572: //
3573:
3574: ScsiPortStallExecution(INTERRUPT_STALL_TIME);
3575:
3576: //
3577: // Make sure there is really an interrupt before reading the other
3578: // registers, particularly, the interrupt register.
3579: //
3580:
3581: if (deviceExtension->AdapterFlags & PD_NCR_ADAPTER) {
3582:
3583: *((PUCHAR) &DmaStatus) = SCSI_READ( deviceExtension->AdapterBase, DmaStatus );
3584:
3585: if (DmaStatus.Interrupt == deviceExtension->InterruptPending) {
3586: *((PUCHAR) &deviceExtension->AdapterStatus) = SCSI_READ( deviceExtension->Adapter, ScsiStatus );
3587: deviceExtension->InterruptCount++;
3588: goto NextInterrupt;
3589:
3590: }
3591: } else {
3592:
3593: *((PUCHAR) &deviceExtension->AdapterStatus) = SCSI_READ ( deviceExtension->Adapter, ScsiStatus );
3594:
3595: if (deviceExtension->AdapterStatus.Interrupt) {
3596: deviceExtension->InterruptCount++;
3597: goto NextInterrupt;
3598:
3599: }
3600: }
3601:
3602: return(TRUE);
3603: }
3604:
3605: VOID
3606: NcrLogError(
3607: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
3608: IN ULONG ErrorCode,
3609: IN ULONG UniqueId
3610: )
3611: /*++
3612:
3613: Routine Description:
3614:
3615: This routine logs an error.
3616:
3617: Arguments:
3618:
3619: DeviceExtension - Supplies a pointer to the device extension for the
3620: port adapter to which the completing target controller is connected.
3621:
3622: ErrorCode - Supplies the error code to log with the error.
3623:
3624: UniqueId - Supplies the unique error identifier.
3625:
3626: Return Value:
3627:
3628: None.
3629:
3630: --*/
3631: {
3632:
3633: PSCSI_REQUEST_BLOCK srb;
3634:
3635: //
3636: // Look for a current request in the device extension.
3637: //
3638:
3639: if (DeviceExtension->ActiveLogicalUnit != NULL) {
3640:
3641: if (DeviceExtension->ActiveLuRequest != NULL) {
3642:
3643: srb = DeviceExtension->ActiveLuRequest;
3644:
3645: } else {
3646:
3647: srb = DeviceExtension->ActiveLogicalUnit->ActiveSendRequest;
3648:
3649: }
3650:
3651: } else {
3652:
3653: srb = DeviceExtension->NextSrbRequest;
3654:
3655: }
3656:
3657: //
3658: // If the srb is NULL, then log the error against the host adapter address.
3659: //
3660:
3661: if (srb == NULL) {
3662:
3663: ScsiPortLogError(
3664: DeviceExtension, // HwDeviceExtension,
3665: NULL, // Srb
3666: 0, // PathId,
3667: DeviceExtension->AdapterBusId, // TargetId,
3668: 0, // Lun,
3669: ErrorCode, // ErrorCode,
3670: UniqueId // UniqueId
3671: );
3672:
3673: } else {
3674:
3675: ScsiPortLogError(
3676: DeviceExtension, // HwDeviceExtension,
3677: srb, // Srb
3678: srb->PathId, // PathId,
3679: srb->TargetId, // TargetId,
3680: srb->Lun, // Lun,
3681: ErrorCode, // ErrorCode,
3682: UniqueId // UniqueId
3683: );
3684:
3685: }
3686:
3687: }
3688:
3689:
3690: VOID
3691: NcrProcessRequestCompletion(
3692: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension
3693: )
3694: /*++
3695:
3696: Routine Description:
3697:
3698: This routine does all of checking and state updating necessary when a
3699: request terminates normally. It determines what the SrbStatus
3700: should be and updates the state in the DeviceExtension, the
3701: logicalUnitExtension and the srb.
3702:
3703: Arguments:
3704:
3705: DeviceExtension - Supplies a pointer to the device extension for the
3706: port adapter on to which the completing target controller is connected.
3707:
3708: Return Value:
3709:
3710: None.
3711:
3712: --*/
3713:
3714: {
3715: PSPECIFIC_LOGICAL_UNIT_EXTENSION luExtension;
3716: PSCSI_REQUEST_BLOCK srb;
3717:
3718: luExtension = DeviceExtension->ActiveLogicalUnit;
3719: srb = DeviceExtension->ActiveLuRequest;
3720:
3721: ASSERT(DeviceExtension->NextSrbRequest != srb);
3722:
3723: if ( srb->ScsiStatus != SCSISTAT_GOOD &&
3724: srb->ScsiStatus != SCSISTAT_CONDITION_MET &&
3725: srb->ScsiStatus != SCSISTAT_INTERMEDIATE &&
3726: srb->ScsiStatus != SCSISTAT_INTERMEDIATE_COND_MET ) {
3727:
3728: //
3729: // Indicate an abnormal status code.
3730: //
3731:
3732: srb->SrbStatus = SRB_STATUS_ERROR;
3733:
3734: //
3735: // Indicate that a INITIATE RECOVERY message was received. This
3736: // indicates to the class driver that it must send a TERMINATE
3737: // RECOVERY message before the logical unit will resume normal
3738: // operation.
3739: //
3740:
3741: if (SRB_EXT(srb)->SrbExtensionFlags & PD_INITIATE_RECOVERY) {
3742:
3743: //
3744: // Modify the SrbStatus.
3745: //
3746:
3747: srb->SrbStatus = SRB_STATUS_ERROR_RECOVERY;
3748: }
3749:
3750: //
3751: // If this is a check condition, then clear the synchronous negotiation
3752: // done flag. This is done in case the controller was power cycled.
3753: //
3754:
3755: if (srb->ScsiStatus == SCSISTAT_CHECK_CONDITION) {
3756:
3757: DeviceExtension->TargetState[srb->TargetId].TargetFlags
3758: &= ~PD_SYNCHRONOUS_NEGOTIATION_DONE;
3759:
3760: }
3761:
3762: //
3763: // If there is a pending request for this logical unit then return
3764: // that request with a busy status. This situation only occurs when
3765: // command queuing is enabled an a command pending for a logical unit
3766: // at the same time that an error has occured. This may be a BUSY,
3767: // QUEUE FULL or CHECK CONDITION. The important case is CHECK CONDITION
3768: // because a contingatent aligance condition has be established and the
3769: // port driver needs a chance to send a Reqeust Sense before the
3770: // pending command is started.
3771: //
3772:
3773: if (DeviceExtension->AdapterFlags & PD_PENDING_START_IO &&
3774: DeviceExtension->NextSrbRequest->PathId == srb->PathId &&
3775: DeviceExtension->NextSrbRequest->TargetId == srb->TargetId &&
3776: DeviceExtension->NextSrbRequest->Lun == srb->Lun) {
3777:
3778: NcrPrint((1, "NcrProcessRequestCompletion: Failing request with busy status due to check condition\n"));
3779: DeviceExtension->NextSrbRequest->SrbStatus =
3780: SCSISTAT_CHECK_CONDITION;
3781:
3782: DeviceExtension->NextSrbRequest->ScsiStatus = SCSISTAT_BUSY;
3783:
3784: ScsiPortNotification(
3785: RequestComplete,
3786: DeviceExtension,
3787: DeviceExtension->NextSrbRequest
3788: );
3789:
3790: //
3791: // Make sure the request is not sitting in the logical unit.
3792: //
3793:
3794: if (DeviceExtension->NextSrbRequest == luExtension->ActiveLuRequest) {
3795:
3796: luExtension->ActiveLuRequest = NULL;
3797:
3798: } else if (DeviceExtension->NextSrbRequest ==
3799: luExtension->ActiveSendRequest) {
3800:
3801: luExtension->ActiveSendRequest = NULL;
3802: }
3803:
3804: DeviceExtension->NextSrbRequest = NULL;
3805: DeviceExtension->AdapterFlags &= ~PD_PENDING_START_IO;
3806:
3807: ScsiPortNotification(
3808: NextRequest,
3809: DeviceExtension,
3810: NULL
3811: );
3812:
3813: }
3814:
3815: } else {
3816:
3817: //
3818: // Everything looks correct so far.
3819: //
3820:
3821: srb->SrbStatus = SRB_STATUS_SUCCESS;
3822:
3823: //
3824: // Make sure that status is valid.
3825: //
3826:
3827: if (!(SRB_EXT(srb)->SrbExtensionFlags & PD_STATUS_VALID)) {
3828:
3829: //
3830: // The status byte is not valid.
3831: //
3832:
3833: srb->SrbStatus = SRB_STATUS_PHASE_SEQUENCE_FAILURE;
3834:
3835: //
3836: // Log the error.
3837: //
3838:
3839: NcrLogError(DeviceExtension, SP_PROTOCOL_ERROR, 12);
3840:
3841: }
3842:
3843:
3844: }
3845:
3846: //
3847: // Check that data was transferred to the end of the buffer.
3848: //
3849:
3850: if ( SRB_EXT(srb)->MaximumTransferLength != srb->DataTransferLength ){
3851:
3852: //
3853: // The entire buffer was not transferred. Update the length
3854: // and update the status code.
3855: //
3856:
3857: if (srb->SrbStatus == SRB_STATUS_SUCCESS) {
3858:
3859: NcrPrint((1, "NcrProcessRequestCompletion: Short transfer, Actual: %x; Expected: %x;\n",
3860: SRB_EXT(srb)->MaximumTransferLength,
3861: srb->DataTransferLength
3862: ));
3863:
3864: //
3865: // If no data was transferred then indicated this was a
3866: // protocol error rather than a data under/over run.
3867: //
3868:
3869: if (srb->DataTransferLength == 0) {
3870: srb->SrbStatus = SRB_STATUS_PHASE_SEQUENCE_FAILURE;
3871: } else {
3872: srb->SrbStatus = SRB_STATUS_DATA_OVERRUN;
3873: }
3874:
3875: srb->DataTransferLength = SRB_EXT(srb)->MaximumTransferLength;
3876: } else {
3877:
3878: //
3879: // Update the length if a check condition was returned.
3880: //
3881:
3882: if (srb->ScsiStatus == SCSISTAT_CHECK_CONDITION) {
3883: srb->DataTransferLength = SRB_EXT(srb)->MaximumTransferLength;
3884: }
3885: }
3886: }
3887:
3888: if (srb->SrbStatus != SRB_STATUS_SUCCESS) {
3889: NcrPrint((1, "NcrProcessRequestCompletion: Request failed. ScsiStatus: %x, SrbStatus: %x\n",
3890: srb->ScsiStatus,
3891: srb->SrbStatus
3892: ));
3893: }
3894:
3895: //
3896: // Clear the request but not the ActiveLogicalUnit since the target has
3897: // not disconnected from the SCSI bus yet.
3898: //
3899:
3900: DeviceExtension->ActiveLuRequest = NULL;
3901: luExtension->ActiveLuRequest = NULL;
3902: luExtension->RetryCount = 0;
3903: luExtension->LuFlags &= ~PD_LU_COMPLETE_MASK;
3904: }
3905:
3906: BOOLEAN
3907: NcrResetScsiBus(
3908: IN PVOID ServiceContext,
3909: IN ULONG PathId
3910: )
3911:
3912: /*++
3913:
3914: Routine Description:
3915:
3916: This function resets the SCSI bus and calls the reset cleanup function.
3917:
3918: Arguments:
3919:
3920: ServiceContext - Supplies a pointer to the specific device extension.
3921:
3922: PathId - Supplies the path id of the bus.
3923:
3924: Return Value:
3925:
3926: TRUE - Indicating the reset is complete.
3927:
3928: --*/
3929:
3930: {
3931: PSPECIFIC_DEVICE_EXTENSION deviceExtension = ServiceContext;
3932:
3933: NcrPrint((1, "NcrResetScsiBus: Resetting the SCSI bus.\n"));
3934:
3935: //
3936: // The bus should be reset regardless of what is occurring on the bus or in
3937: // the chip. The reset SCSI bus command executes immediately.
3938: //
3939:
3940: SCSI_WRITE(deviceExtension->Adapter, Command, RESET_SCSI_BUS);
3941:
3942: //
3943: // Delay the minimum assertion time for a SCSI bus reset to make sure a
3944: // valid reset signal is sent.
3945: //
3946:
3947: ScsiPortStallExecution( RESET_STALL_TIME );
3948:
3949: NcrCleanupAfterReset(deviceExtension, FALSE);
3950: deviceExtension->AdapterFlags |= PD_EXPECTING_RESET_INTERRUPT;
3951:
3952: return(TRUE);
3953: }
3954:
3955: VOID
3956: NcrResetScsiBusInternal(
3957: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
3958: IN ULONG PathId
3959: )
3960: /*++
3961:
3962: Routine Description:
3963:
3964: This function resets the SCSI bus and notifies the port driver.
3965:
3966: Arguments:
3967:
3968: DeviceExtension - Supplies a pointer to the specific device extension.
3969:
3970: PathId - Supplies the path id of the bus.
3971:
3972: Return Value:
3973:
3974: None
3975:
3976: --*/
3977: {
3978:
3979: ScsiPortNotification(
3980: ResetDetected,
3981: DeviceExtension,
3982: NULL
3983: );
3984:
3985: NcrResetScsiBus(DeviceExtension, 0);
3986: }
3987:
3988: VOID
3989: NcrSelectTarget(
3990: IN PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
3991: IN PSPECIFIC_LOGICAL_UNIT_EXTENSION LuExtension
3992: )
3993: /*++
3994:
3995: Routine Description:
3996:
3997: This routine sets up the hardware to select a target. If a valid message
3998: is in the message buffer, it will be sent to the target. If the request
3999: includes a SCSI command descriptor block, it will also be passed to the
4000: target.
4001:
4002: Arguments:
4003:
4004: DeviceExtension - Supplies the device extension for this HBA adapter.
4005:
4006: LuExtension - Supplies the logical unit extension for the target being
4007: selected.
4008:
4009: Return Value:
4010:
4011: None
4012:
4013: --*/
4014:
4015: {
4016: PSCSI_REQUEST_BLOCK srb;
4017: PSPECIFIC_TARGET_EXTENSION targetState;
4018: SCSI_DMA_STATUS DmaStatus;
4019: LONG i;
4020:
4021: srb = DeviceExtension->NextSrbRequest;
4022:
4023: targetState = &DeviceExtension->TargetState[srb->TargetId];
4024:
4025: #if DBG
4026: if (NcrDebug) {
4027: NcrPrint((0, "NcrSelectTarget: Attempting target select.\n"));
4028: }
4029: #endif
4030: /* Powerfail Start */
4031:
4032: //
4033: // Set up the SCSI protocol chip to select the target, transfer the
4034: // IDENTIFY message and the CDB. This can be done by following steps:
4035: //
4036: // setting the destination register,
4037: // filling the FIFO with the IDENTIFY message and the CDB
4038: // setting the command register
4039: //
4040: // If the chip is not interrupting, then set up for selection. If the
4041: // chip is interrupting then return. The interrupt will process the
4042: // request. Note that if we get reselected after this point the chip
4043: // will ignore the bytes written until the interrupt register is read.
4044: // The commands that handle a message and a CDB can only be used if the
4045: // message is one byte or 3 bytes long; otherwise only a one-byte message
4046: // is transferred on the select and the remaining bytes are handled in the
4047: // interrupt routine.
4048: //
4049:
4050: if (DeviceExtension->AdapterFlags & PD_NCR_ADAPTER) {
4051:
4052: *((PUCHAR) &DmaStatus) = SCSI_READ( DeviceExtension->AdapterBase, DmaStatus );
4053: if (DmaStatus.Interrupt == DeviceExtension->InterruptPending) {
4054: return;
4055: }
4056:
4057: } else {
4058:
4059: *((PUCHAR) &DeviceExtension->AdapterStatus) = SCSI_READ( DeviceExtension->Adapter, ScsiStatus );
4060: if (DeviceExtension->AdapterStatus.Interrupt) {
4061: return;
4062: }
4063:
4064: }
4065:
4066: //
4067: // Set the destination ID. Put the first byte of the message-in
4068: // the fifo and set the command to select with ATN. This command
4069: // selects the target, sends one message byte and interrupts. The
4070: // ATN line remains set. The succeeding bytes are loaded into the
4071: // FIFO and sent to the target by the interrupt service routine.
4072: //
4073:
4074: SCSI_WRITE(DeviceExtension->Adapter, DestinationId, srb->TargetId);
4075: SCSI_WRITE( DeviceExtension->Adapter,
4076: Fifo,
4077: DeviceExtension->MessageBuffer[DeviceExtension->MessageSent++]
4078: );
4079:
4080: //
4081: // Set the synchronous data transfer parameter registers in case a
4082: // data transfer is done. These must be set before a data transfer
4083: // is started.
4084: //
4085:
4086: SCSI_WRITE( DeviceExtension->Adapter,
4087: SynchronousPeriod,
4088: targetState->SynchronousPeriod
4089: );
4090: SCSI_WRITE( DeviceExtension->Adapter,
4091: SynchronousOffset,
4092: targetState->SynchronousOffset
4093: );
4094:
4095: SCSI_WRITE( DeviceExtension->Adapter,
4096: Configuration3,
4097: *((PCHAR) &targetState->Configuration3)
4098: );
4099:
4100:
4101: //
4102: // Determine if this srb has a Cdb with it and whether the message is such that
4103: // the message and the Cdb can be loaded into the fifo; otherwise, just
4104: // load the first byte of the message.
4105: //
4106:
4107: if (srb->Function == SRB_FUNCTION_EXECUTE_SCSI &&
4108: (DeviceExtension->MessageCount == 1 ||
4109: DeviceExtension->MessageCount == 3)) {
4110:
4111: //
4112: // Copy the entire message and Cdb into the fifo.
4113: //
4114:
4115: for (;
4116: DeviceExtension->MessageSent <
4117: DeviceExtension->MessageCount;
4118: DeviceExtension->MessageSent++ ) {
4119:
4120: SCSI_WRITE( DeviceExtension->Adapter,
4121: Fifo,
4122: DeviceExtension->
4123: MessageBuffer[DeviceExtension->MessageSent]
4124: );
4125:
4126: }
4127:
4128: for (i = 0; i < srb->CdbLength; i++) {
4129: SCSI_WRITE(DeviceExtension->Adapter,
4130: Fifo,
4131: srb->Cdb[i]
4132: );
4133: }
4134:
4135: if (DeviceExtension->MessageCount == 1) {
4136:
4137: //
4138: // One message byte so use select with attention which uses one
4139: // message byte.
4140: //
4141:
4142: SCSI_WRITE(
4143: DeviceExtension->Adapter,
4144: Command,
4145: SELECT_WITH_ATTENTION
4146: );
4147:
4148: } else {
4149:
4150: //
4151: // Three byte message, so use the select with attention which uses
4152: // three byte messages.
4153: //
4154:
4155: SCSI_WRITE(
4156: DeviceExtension->Adapter,
4157: Command,
4158: SELECT_WITH_ATTENTION3
4159: );
4160:
4161: }
4162:
4163: } else {
4164:
4165: //
4166: // Only the first byte of the message can be sent so select with
4167: // ATTENTION and the target will request the rest.
4168: //
4169:
4170: SCSI_WRITE(
4171: DeviceExtension->Adapter,
4172: Command,
4173: SELECT_WITH_ATTENTION_STOP
4174: );
4175:
4176: }
4177:
4178: /* Powerfail release */
4179:
4180: //
4181: // Set the device state to message-out and indicate that a message
4182: // is being sent.
4183: //
4184:
4185: DeviceExtension->AdapterFlags |= PD_MESSAGE_OUT_VALID;
4186: DeviceExtension->AdapterState = AttemptingSelect;
4187: DeviceExtension->InterruptCount = 0;
4188:
4189: }
4190:
4191:
4192: VOID
4193: NcrSendMessage(
4194: PSCSI_REQUEST_BLOCK Srb,
4195: PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
4196: PSPECIFIC_LOGICAL_UNIT_EXTENSION LuExtension
4197: )
4198:
4199: /*++
4200:
4201: Routine Description:
4202:
4203: This routine attempts to send the indicated message to the target
4204: controller. There are three classes of messages:
4205: Those which terminate a specific request and end in bus free.
4206: Those which apply to a specific request and then proceed.
4207: Those which end in bus free.
4208:
4209: For those messages that apply to a specific request, check to see that
4210: the request is currently being processed and an INDENTIFY message prefixed
4211: to the message.
4212:
4213: It is possible that the destination logical unit is the active logical unit;
4214: however, it would difficult to jump in and send the requested message, so
4215: just wait for the bus to become free.
4216:
4217: In the case where the target is not currently active, then set up the SCSI
4218: protocol chip to select the target controller and send the message.
4219:
4220: Arguments:
4221:
4222: Srb - Supplies the request to be started.
4223:
4224: DeviceExtension - Supplies the extended device extension for this SCSI bus.
4225:
4226: LuExtension - Supplies the logical unit extension for this request.
4227:
4228: Notes:
4229:
4230: This routine must be synchronized with the interrupt routine.
4231:
4232: Return Value:
4233:
4234: None
4235:
4236: --*/
4237: {
4238: PSCSI_REQUEST_BLOCK linkedSrb;
4239: BOOLEAN impliesDisconnect;
4240: BOOLEAN useTag;
4241: UCHAR message;
4242:
4243: impliesDisconnect = FALSE;
4244: useTag = FALSE;
4245:
4246: //
4247: // Decode the type of message.
4248: //
4249:
4250: switch (Srb->Function) {
4251:
4252: case SRB_FUNCTION_TERMINATE_IO:
4253: case SRB_FUNCTION_ABORT_COMMAND:
4254:
4255: //
4256: // Verify that the request is being processed by the logical unit.
4257: //
4258:
4259: linkedSrb = ScsiPortGetSrb(
4260: DeviceExtension,
4261: Srb->PathId,
4262: Srb->TargetId,
4263: Srb->Lun,
4264: Srb->QueueTag
4265: );
4266:
4267: if (linkedSrb != Srb->NextSrb) {
4268:
4269: //
4270: // The specified request is not here. Complete the request
4271: // without error.
4272: //
4273:
4274: Srb->SrbStatus = SRB_STATUS_ABORT_FAILED;
4275: ScsiPortNotification(
4276: RequestComplete,
4277: DeviceExtension,
4278: Srb
4279: );
4280:
4281: ScsiPortNotification(
4282: NextRequest,
4283: DeviceExtension,
4284: NULL
4285: );
4286:
4287: return;
4288: }
4289:
4290: if (Srb->Function == SRB_FUNCTION_ABORT_COMMAND) {
4291: impliesDisconnect = TRUE;
4292: message = SCSIMESS_ABORT;
4293: } else {
4294: message = SCSIMESS_TERMINATE_IO_PROCESS;
4295: impliesDisconnect = FALSE;
4296: }
4297:
4298: //
4299: // Use a tagged message if the original request was tagged.
4300: //
4301:
4302: useTag = linkedSrb->SrbFlags & SRB_FLAGS_QUEUE_ACTION_ENABLE ?
4303: TRUE : FALSE;
4304:
4305: break;
4306:
4307: case SRB_FUNCTION_RESET_DEVICE:
4308:
4309: //
4310: // Because of the way the chip works it is easiest to send an IDENTIFY
4311: // message along with the BUS DEVICE RESET message. That is because
4312: // there is no way to select a target with ATN and send one message
4313: // byte. This IDENTIFY message is not necessary for the SCSI protocol,
4314: // but it is legal and should not cause any problem.
4315: //
4316:
4317: message = SCSIMESS_BUS_DEVICE_RESET;
4318: impliesDisconnect = TRUE;
4319: break;
4320:
4321: case SRB_FUNCTION_RELEASE_RECOVERY:
4322:
4323: //
4324: // These messages require an IDENTIFY message and imply a disconnect.
4325: //
4326:
4327: impliesDisconnect = TRUE;
4328: message = SCSIMESS_RELEASE_RECOVERY;
4329: break;
4330:
4331: case SCSIMESS_CLEAR_QUEUE:
4332:
4333: //
4334: // These messages require an IDENTIFY message and imply a disconnect.
4335: //
4336:
4337: message = SCSIMESS_CLEAR_QUEUE;
4338: impliesDisconnect = TRUE;
4339: break;
4340:
4341: default:
4342:
4343: //
4344: // This is an unsupported message request. Fail the request.
4345: //
4346:
4347: Srb->SrbStatus = SRB_STATUS_INVALID_REQUEST;
4348: ScsiPortNotification(
4349: RequestComplete,
4350: DeviceExtension,
4351: Srb
4352: );
4353:
4354: ScsiPortNotification(
4355: NextRequest,
4356: DeviceExtension,
4357: NULL
4358: );
4359:
4360: return;
4361: }
4362:
4363: //
4364: // Save away the parameters in case nothing can be done now.
4365: //
4366:
4367: DeviceExtension->NextSrbRequest = Srb;
4368: DeviceExtension->AdapterFlags |= PD_PENDING_START_IO;
4369: LuExtension->ActiveSendRequest = Srb;
4370:
4371: //
4372: // Check to see if the bus is free. If it is not, then return. Since
4373: // the request parameters have been saved, indicate that the request has
4374: // been accepted. The request will be processed when the bus becomes free.
4375: //
4376:
4377: if (DeviceExtension->AdapterState != BusFree) {
4378: return;
4379: }
4380:
4381: //
4382: // Create the identify command and copy the message to the buffer.
4383: //
4384:
4385: DeviceExtension->MessageBuffer[0] = SCSIMESS_IDENTIFY_WITH_DISCON |
4386: Srb->Lun;
4387: DeviceExtension->MessageCount = 1;
4388: DeviceExtension->MessageSent = 0;
4389:
4390: if (useTag && Srb->QueueTag != SP_UNTAGGED) {
4391: DeviceExtension->MessageBuffer[DeviceExtension->MessageCount++] = SCSIMESS_SIMPLE_QUEUE_TAG;
4392: DeviceExtension->MessageBuffer[DeviceExtension->MessageCount++] = Srb->QueueTag;
4393:
4394: if (message == SCSIMESS_ABORT) {
4395: message = SCSIMESS_ABORT_WITH_TAG;
4396: }
4397: }
4398:
4399: DeviceExtension->MessageBuffer[DeviceExtension->MessageCount++] = message;
4400:
4401: //
4402: // Attempt to select the target and update the adapter flags.
4403: //
4404:
4405: NcrSelectTarget( DeviceExtension, LuExtension );
4406:
4407: DeviceExtension->AdapterFlags |= impliesDisconnect ?
4408: PD_DISCONNECT_EXPECTED | PD_SEND_MESSAGE_REQUEST
4409: : PD_SEND_MESSAGE_REQUEST;
4410:
4411: }
4412:
4413: VOID
4414: NcrStartExecution(
4415: PSCSI_REQUEST_BLOCK Srb,
4416: PSPECIFIC_DEVICE_EXTENSION DeviceExtension,
4417: PSPECIFIC_LOGICAL_UNIT_EXTENSION LuExtension
4418: )
4419:
4420: /*++
4421:
4422: Routine Description:
4423:
4424: This procedure sets up the chip to select the target and notify it that
4425: a request is available. For the NCR chip, the chip is set up to select,
4426: send the IDENTIFY message and send the command data block. A check is
4427: made to determine if synchronous negotiation is necessary.
4428:
4429: Arguments:
4430:
4431: Srb - Supplies the request to be started.
4432:
4433: DeviceExtension - Supplies the extended device extension for this SCSI bus.
4434:
4435: LuExtension - Supplies the logical unit extension for this requst.
4436:
4437: Notes:
4438:
4439: This routine must be synchronized with the interrupt routine.
4440:
4441: Return Value:
4442:
4443: None
4444:
4445: --*/
4446:
4447: {
4448:
4449: PSCSI_EXTENDED_MESSAGE extendedMessage;
4450: CHIP_TYPES chipType;
4451: PSPECIFIC_TARGET_EXTENSION targetState;
4452:
4453: //
4454: // Save away the parameters in case nothing can be done now.
4455: //
4456:
4457: SRB_EXT(Srb)->SavedDataPointer = (ULONG) Srb->DataBuffer;
4458: SRB_EXT(Srb)->SavedDataLength = Srb->DataTransferLength;
4459: SRB_EXT(Srb)->SrbExtensionFlags = 0;
4460: SRB_EXT(Srb)->MaximumTransferLength = 0;
4461: DeviceExtension->NextSrbRequest = Srb;
4462: DeviceExtension->AdapterFlags |= PD_PENDING_START_IO;
4463:
4464: //
4465: // Check to see if the bus is free. If it is not, then return. Since
4466: // the request parameters have been saved, indicate that the request has
4467: // been accepted. The request will be processed when the bus becomes free.
4468: //
4469:
4470: if (DeviceExtension->AdapterState != BusFree) {
4471: return;
4472: }
4473:
4474: //
4475: // Create the identify command.
4476: //
4477:
4478: DeviceExtension->MessageCount = 1;
4479: DeviceExtension->MessageSent = 0;
4480: DeviceExtension->AdapterFlags |= PD_MESSAGE_OUT_VALID;
4481:
4482: DeviceExtension->MessageBuffer[0] = SCSIMESS_IDENTIFY | Srb->Lun;
4483:
4484: DeviceExtension->TargetId = Srb->TargetId;
4485: targetState = &DeviceExtension->TargetState[Srb->TargetId];
4486:
4487: //
4488: // Check to see if disconnect is allowed. If not then don't do tagged
4489: // queuing either.
4490: //
4491:
4492: if (!(Srb->SrbFlags & SRB_FLAGS_DISABLE_DISCONNECT)) {
4493:
4494: //
4495: // Enable disconnects in the message.
4496: //
4497:
4498: DeviceExtension->MessageBuffer[0] |= SCSIMESS_IDENTIFY_WITH_DISCON;
4499:
4500: //
4501: // If this is a tagged command then create a tagged message.
4502: //
4503:
4504: if (Srb->SrbFlags & SRB_FLAGS_QUEUE_ACTION_ENABLE) {
4505:
4506: //
4507: // The queue tag message is two bytes the first is the queue action
4508: // and the second is the queue tag.
4509: //
4510:
4511: DeviceExtension->MessageBuffer[1] = Srb->QueueAction;
4512: DeviceExtension->MessageBuffer[2] = Srb->QueueTag;
4513: DeviceExtension->MessageCount += 2;
4514: DeviceExtension->AdapterFlags |= PD_TAGGED_SELECT;
4515:
4516: } else {
4517: LuExtension->ActiveLuRequest = Srb;
4518: }
4519:
4520: } else {
4521: LuExtension->ActiveLuRequest = Srb;
4522: }
4523:
4524: //
4525: // Check to see if synchronous negotiation is necessary.
4526: //
4527:
4528: if (!(targetState->TargetFlags &
4529: (PD_SYNCHRONOUS_NEGOTIATION_DONE | PD_DO_NOT_NEGOTIATE))) {
4530:
4531: //
4532: // Initialize the synchronous transfer register values to an
4533: // asynchronous transfer, which is what will be used if anything
4534: // goes wrong with the negotiation.
4535: //
4536:
4537: targetState->SynchronousOffset = ASYNCHRONOUS_OFFSET;
4538: targetState->SynchronousPeriod = ASYNCHRONOUS_PERIOD;
4539: targetState->Configuration3 = DeviceExtension->Configuration3;
4540:
4541: if (Srb->SrbFlags & SRB_FLAGS_DISABLE_SYNCH_TRANSFER) {
4542:
4543: //
4544: // Synchronous transfers are disabled by the SRB.
4545: //
4546:
4547: NcrSelectTarget( DeviceExtension, LuExtension );
4548: return;
4549: }
4550:
4551: if (DeviceExtension->ChipType == Fas216) {
4552:
4553: //
4554: // The Fas216 supports fast synchronous transfers.
4555: //
4556:
4557: chipType = Fas216Fast;
4558:
4559: } else if (DeviceExtension->ChipType == Ncr53c90) {
4560:
4561: //
4562: // The 53c90 does not support synchronous transfers.
4563: // Set the do not negotate flag in the logical unit structure.
4564: //
4565:
4566: targetState->TargetFlags |= PD_DO_NOT_NEGOTIATE;
4567: NcrSelectTarget( DeviceExtension, LuExtension );
4568: return;
4569:
4570: } else {
4571:
4572: chipType = DeviceExtension->ChipType;
4573:
4574: }
4575:
4576: //
4577: // Create the synchronous data transfer request message.
4578: // The format of the message is:
4579: //
4580: // EXTENDED_MESSAGE op-code
4581: // Length of message
4582: // Synchronous transfer data request op-code
4583: // Our Transfer period
4584: // Our REQ/ACK offset
4585: //
4586: // The message is placed after the IDENTIFY message.
4587: //
4588:
4589: extendedMessage = (PSCSI_EXTENDED_MESSAGE)
4590: &DeviceExtension->MessageBuffer[DeviceExtension->MessageCount];
4591: DeviceExtension->MessageCount += 2 + SCSIMESS_SYNCH_DATA_LENGTH;
4592:
4593: extendedMessage->InitialMessageCode = SCSIMESS_EXTENDED_MESSAGE;
4594: extendedMessage->MessageLength = SCSIMESS_SYNCH_DATA_LENGTH;
4595: extendedMessage->MessageType = SCSIMESS_SYNCHRONOUS_DATA_REQ;
4596:
4597: //
4598: // If this chips does not suport fast SCSI, just calculate the normal
4599: // minimum transfer period; otherwise use the fast value.
4600: //
4601:
4602: //
4603: // The initial sychronous transfer period is:
4604: //
4605: // SynchronousPeriodCyles * 1000
4606: // -----------------------------
4607: // ClockSpeed * 4
4608: //
4609: // Note the result of the divide by four must be rounded up.
4610: //
4611:
4612: extendedMessage->ExtendedArguments.Synchronous.TransferPeriod =
4613: ((SynchronousTransferTypes[chipType].SynchronousPeriodCyles * 1000) /
4614: DeviceExtension->ClockSpeed + 3) / 4;
4615: extendedMessage->ExtendedArguments.Synchronous.ReqAckOffset = SYNCHRONOUS_OFFSET;
4616:
4617: //
4618: // Attempt to select the target and update the adapter flags.
4619: //
4620:
4621: NcrSelectTarget( DeviceExtension, LuExtension );
4622:
4623: //
4624: // Many controllers reject the first byte of a synchronous
4625: // negotiation message. Since this is a multibyte message the
4626: // ATN signal remains set after the first byte is sent. Some
4627: // controllers remember this attempt to do a message-out
4628: // later. Setting the PD_POSSIBLE_EXTRA_MESSAGE_OUT flag allows
4629: // this extra message transfer to occur without error.
4630: //
4631:
4632: DeviceExtension->AdapterFlags |= PD_POSSIBLE_EXTRA_MESSAGE_OUT |
4633: PD_SYNCHRONOUS_TRANSFER_SENT;
4634:
4635: return;
4636: }
4637:
4638: NcrSelectTarget( DeviceExtension, LuExtension );
4639:
4640: }
4641:
4642: BOOLEAN
4643: NcrStartIo(
4644: IN PVOID ServiceContext,
4645: IN PSCSI_REQUEST_BLOCK Srb
4646: )
4647: /*++
4648:
4649: Routine Description:
4650:
4651: This function is used by the OS dependent port driver to pass requests to
4652: the dependent driver. This function begins the execution of the request.
4653: Requests to reset the SCSI bus are handled immediately. Requests to send
4654: a message or start a SCSI command are handled when the bus is free.
4655:
4656: Arguments:
4657:
4658: ServiceContext - Supplies the device Extension for the SCSI bus adapter.
4659:
4660: Srb - Supplies the SCSI request block to be started.
4661:
4662: Return Value:
4663:
4664: TRUE - If the request can be accepted at this time.
4665:
4666: FALSE - If the request must be submitted later.
4667:
4668: --*/
4669:
4670: {
4671: PSPECIFIC_DEVICE_EXTENSION deviceExtension = ServiceContext;
4672: PSPECIFIC_LOGICAL_UNIT_EXTENSION luExtension;
4673:
4674: switch (Srb->Function) {
4675: case SRB_FUNCTION_EXECUTE_SCSI:
4676:
4677: //
4678: // Determine the logical unit that this request is for.
4679: //
4680:
4681: luExtension = ScsiPortGetLogicalUnit(
4682: deviceExtension,
4683: Srb->PathId,
4684: Srb->TargetId,
4685: Srb->Lun
4686: );
4687:
4688: NcrStartExecution(
4689: Srb,
4690: deviceExtension,
4691: luExtension
4692: );
4693:
4694: return(TRUE);
4695:
4696: case SRB_FUNCTION_ABORT_COMMAND:
4697: case SRB_FUNCTION_RESET_DEVICE:
4698: case SRB_FUNCTION_TERMINATE_IO:
4699:
4700: //
4701: // Determine the logical unit that this request is for.
4702: //
4703:
4704: luExtension = ScsiPortGetLogicalUnit(
4705: deviceExtension,
4706: Srb->PathId,
4707: Srb->TargetId,
4708: Srb->Lun
4709: );
4710:
4711: NcrSendMessage(
4712: Srb,
4713: deviceExtension,
4714: luExtension
4715: );
4716:
4717: return(TRUE);
4718:
4719: case SRB_FUNCTION_RESET_BUS:
4720:
4721: //
4722: // There is no logical unit so just reset the bus.
4723: //
4724:
4725: NcrResetScsiBusInternal( deviceExtension, 0 );
4726: return(TRUE);
4727:
4728: default:
4729:
4730: //
4731: // Unknown function code in the request. Complete the request with
4732: // an error and ask for the next request.
4733: //
4734:
4735: Srb->SrbStatus = SRB_STATUS_BAD_FUNCTION;
4736: ScsiPortNotification(
4737: RequestComplete,
4738: deviceExtension,
4739: Srb
4740: );
4741:
4742: ScsiPortNotification(
4743: NextRequest,
4744: deviceExtension,
4745: NULL
4746: );
4747:
4748: return(TRUE);
4749: }
4750:
4751: }
4752:
4753: VOID
4754: NcrStartDataTransfer(
4755: IN PVOID ServiceContext
4756: )
4757: /*++
4758:
4759: Routine Description:
4760:
4761: This routine sets up the scsi bus protocol chip to perform a data transfer.
4762: It is called after the DMA has been initialized.
4763:
4764: Arguments:
4765:
4766: ServiceContext - Supplies a pointer to the specific device extension.
4767:
4768: Return Value:
4769:
4770: None.
4771:
4772: --*/
4773:
4774: {
4775: PSPECIFIC_DEVICE_EXTENSION deviceExtension = ServiceContext;
4776:
4777: //
4778: // If the data tranfer is no longer expected then ignore the notification.
4779: //
4780:
4781: if (!(deviceExtension->AdapterFlags & PD_PENDING_DATA_TRANSFER)) {
4782:
4783: return;
4784:
4785: }
4786:
4787: //
4788: // Set up the SCSI protocol chip for the data transfer with the
4789: // command to start.
4790: //
4791:
4792: SCSI_WRITE( deviceExtension->Adapter,
4793: Command,
4794: TRANSFER_INFORMATION_DMA
4795: );
4796:
4797: deviceExtension->AdapterFlags &= ~PD_PENDING_DATA_TRANSFER;
4798:
4799: }
4800:
4801: ULONG
4802: DriverEntry(
4803: IN PVOID DriverObject,
4804: IN PVOID Argument2
4805: )
4806:
4807: /*++
4808:
4809: Routine Description:
4810:
4811: Arguments:
4812:
4813: Driver Object is passed to ScsiPortInitialize()
4814:
4815: Return Value:
4816:
4817: Status from ScsiPortInitialize()
4818:
4819: --*/
4820:
4821: {
4822: HW_INITIALIZATION_DATA hwInitializationData;
4823: ULONG i;
4824: ULONG Status1;
4825: ULONG Status2;
4826: INIT_DATA InitData;
4827:
4828: ScsiDebugPrint(1,"\n\nNCR 53c9x SCSI MiniPort Driver\n");
4829:
4830: //
4831: // Zero out hardware initialization data structure.
4832: //
4833:
4834: for (i=0; i<sizeof(HW_INITIALIZATION_DATA); i++) {
4835: ((PUCHAR)&hwInitializationData)[i] = 0;
4836: }
4837:
4838: //
4839: // Fill in the hardware initialization data structure.
4840: //
4841:
4842: hwInitializationData.HwInitializationDataSize = sizeof(HW_INITIALIZATION_DATA);
4843: hwInitializationData.HwInitialize = NcrInitializeAdapter;
4844: hwInitializationData.HwStartIo = NcrStartIo;
4845: hwInitializationData.HwInterrupt = NcrInterruptServiceRoutine;
4846: hwInitializationData.HwFindAdapter = NcrMcaFindAdapter;
4847: hwInitializationData.HwResetBus = NcrResetScsiBus;
4848: hwInitializationData.HwDmaStarted = NcrStartDataTransfer;
4849: hwInitializationData.NumberOfAccessRanges = 1;
4850: hwInitializationData.AdapterInterfaceType = MicroChannel;
4851: hwInitializationData.DeviceExtensionSize = sizeof(SPECIFIC_DEVICE_EXTENSION);
4852: hwInitializationData.SpecificLuExtensionSize =
4853: sizeof(SPECIFIC_LOGICAL_UNIT_EXTENSION);
4854: hwInitializationData.SrbExtensionSize = sizeof(SRB_EXTENSION);
4855:
4856: //
4857: // Initialize configuration information.
4858: //
4859: // The following adapter search order should be observed:
4860: // 1. Onboard 53c94 scsi host adapter
4861: // 2. Onboard 53c90 scsi host adapter
4862: // 3. Plug-in 53c90 scsi host adapter
4863: //
4864:
4865: InitData.AdapterId = 0;
4866: InitData.CardSlot = 7;
4867:
4868: Status1 = ScsiPortInitialize(DriverObject, Argument2, &hwInitializationData, &InitData);
4869:
4870: //
4871: // Look for internal mips adapter.
4872: //
4873:
4874: hwInitializationData.AdapterInterfaceType = Internal;
4875: hwInitializationData.HwFindAdapter = NcrMipsFindAdapter;
4876:
4877: Status2 = ScsiPortInitialize(DriverObject, Argument2, &hwInitializationData, &InitData);
4878:
4879: Status1 = Status2 < Status1 ? Status2 : Status1;
4880:
4881: //
4882: // Look for an Eisa adapter.
4883: //
4884:
4885: InitData.AdapterId = 0;
4886: hwInitializationData.AdapterInterfaceType = Eisa;
4887: hwInitializationData.HwFindAdapter = NcrEisaFindAdapter;
4888:
4889: Status2 = ScsiPortInitialize(DriverObject, Argument2, &hwInitializationData, &InitData);
4890:
4891: return(Status2 < Status1 ? Status2 : Status1);
4892:
4893: } // end PortInitialize()
4894:
4895: ULONG
4896: NcrMcaFindAdapter(
4897: IN PVOID ServiceContext,
4898: IN PVOID Context,
4899: IN PVOID BusInformation,
4900: IN PCHAR ArgumentString,
4901: IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
4902: OUT PBOOLEAN Again
4903: )
4904: /*++
4905:
4906: Routine Description:
4907:
4908: This function fills in the configuration information structure. This
4909: routine is temporary until the configuration manager supplies similar
4910: informtion. It also fills in the capabilities structure.
4911:
4912: Arguments:
4913:
4914: ServiceContext - Supplies a pointer to the device extension.
4915:
4916: Context - Unused.
4917:
4918: BusInformation - Unused.
4919:
4920: ArgumentString - Unused.
4921:
4922: ConfigInfo - Pointer to the configuration information structure to be
4923: filled in.
4924:
4925: Again - Returns back a request to call this function again.
4926:
4927: Return Value:
4928:
4929: Returns a status value for the initialazitaition.
4930:
4931: --*/
4932:
4933: {
4934:
4935: PSPECIFIC_DEVICE_EXTENSION deviceExtension = ServiceContext;
4936: PINIT_DATA InitData = Context;
4937: LONG Slot;
4938: LONG i;
4939: ULONG Status = SP_RETURN_NOT_FOUND;
4940:
4941: //
4942: // Determine if bus information array needs to be filled in.
4943: //
4944:
4945: if ( InitData->AdapterId == 0 ) {
4946:
4947: //
4948: // Fill in the POS data structure.
4949: //
4950:
4951: for ( Slot = 0; Slot < 8; Slot++ ) {
4952:
4953: i = ScsiPortGetBusData ( deviceExtension,
4954: Pos,
4955: 0,
4956: Slot,
4957: &InitData->PosData[Slot],
4958: sizeof( POS_DATA )
4959: );
4960:
4961: //
4962: // If less that the requested amount of data is returned, then
4963: // insure that this adapter is ignored.
4964: //
4965:
4966: if ( i < (sizeof( POS_DATA ))) {
4967: InitData->PosData[Slot].AdapterId = 0xffff;
4968: }
4969:
4970: }
4971:
4972: }
4973:
4974: for ( Slot = InitData->CardSlot; Slot >= 0; Slot-- ) {
4975: if (( InitData->PosData[Slot].AdapterId == ONBOARD_C94_ADAPTER_ID ||
4976: InitData->PosData[Slot].AdapterId == ONBOARD_C90_ADAPTER_ID ||
4977: InitData->PosData[Slot].AdapterId == PLUGIN_C90_ADAPTER_ID ) &&
4978: (*(PPOS_DATA_1)&InitData->PosData[Slot].OptionData1).AdapterEnable) {
4979: InitData->CardSlot = Slot - 1;
4980: Status = SP_RETURN_FOUND;
4981: break;
4982: }
4983: }
4984:
4985: if ( Status == SP_RETURN_FOUND ) {
4986:
4987: *Again = TRUE;
4988:
4989: deviceExtension->AdapterBase = (PVOID) AdapterBaseAddress[
4990: (*(PPOS_DATA_1) &InitData->PosData[Slot].OptionData1).IoAddressSelects];
4991: deviceExtension->Adapter = (PSCSI_REGISTERS)
4992: ((PCHAR) deviceExtension->AdapterBase + sizeof(ADAPTER_REGISTERS));
4993: if ( InitData->PosData[Slot].AdapterId == ONBOARD_C94_ADAPTER_ID ) {
4994: deviceExtension->ChipType = Ncr53c94;
4995: deviceExtension->AdapterBusId = AdapterScsiIdC94[
4996: (*(PPOS_DATA_3) &InitData->PosData[Slot].OptionData3).HostIdSelects];
4997: deviceExtension->InterruptPending = FALSE;
4998: } else {
4999: deviceExtension->ChipType = Ncr53c90;
5000: deviceExtension->AdapterBusId = AdapterScsiIdC90[
5001: (*(PPOS_DATA_4) &InitData->PosData[Slot].OptionData4).HostIdSelects];
5002: deviceExtension->InterruptPending = TRUE;
5003: }
5004:
5005: deviceExtension->AdapterBusIdMask = 1 << deviceExtension->AdapterBusId;
5006:
5007: //
5008: // Set configuration information
5009: //
5010:
5011: ConfigInfo->NumberOfPhysicalBreaks = 16;
5012: ConfigInfo->BusInterruptLevel = AdapterInterruptLevel[
5013: (*(PPOS_DATA_1) &InitData->PosData[Slot].OptionData1).InterruptSelects];
5014: ConfigInfo->InitiatorBusId[0] = deviceExtension->AdapterBusId;
5015: ConfigInfo->DmaChannel = AdapterDmaLevel[
5016: (*(PPOS_DATA_2) &InitData->PosData[Slot].OptionData2).DmaSelects];
5017: ConfigInfo->DmaPort = (ULONG) deviceExtension->AdapterBase + (ULONG)
5018: &((PADAPTER_WRITE_REGISTERS) 0)->DmaDecode;
5019: if ( InitData->PosData[Slot].AdapterId == ONBOARD_C94_ADAPTER_ID ) {
5020: ConfigInfo->DmaWidth = Width16Bits;
5021: ConfigInfo->AlignmentMask = 1;
5022: ConfigInfo->AdapterScansDown = TRUE;
5023: ConfigInfo->TaggedQueuing = 1;
5024: } else {
5025: ConfigInfo->DmaWidth = Width8Bits;
5026: }
5027:
5028: ConfigInfo->DmaSpeed = Compatible;
5029: ConfigInfo->MaximumTransferLength = 0xf000;
5030: ConfigInfo->NumberOfBuses = 1;
5031:
5032: //
5033: // Fill in the access array information.
5034: //
5035:
5036: (*ConfigInfo->AccessRanges)[0].RangeStart =
5037: ScsiPortConvertUlongToPhysicalAddress((ULONG) deviceExtension->AdapterBase);
5038: (*ConfigInfo->AccessRanges)[0].RangeLength = sizeof(ADAPTER_REGISTERS) +
5039: sizeof(SCSI_REGISTERS);
5040: (*ConfigInfo->AccessRanges)[0].RangeInMemory = FALSE;
5041:
5042: //
5043: // Initialize hardware.
5044: //
5045:
5046: SCSI_WRITE(deviceExtension->Adapter, Command, RESET_SCSI_CHIP);
5047: SCSI_WRITE(deviceExtension->Adapter, Command, NO_OPERATION_DMA);
5048:
5049: deviceExtension->ClockSpeed = 14; // set clock speed at 14 Mhz.
5050: deviceExtension->AdapterFlags |= PD_NCR_ADAPTER;
5051:
5052: ScsiDebugPrint(1, " ScsiId = %x\n", ConfigInfo->InitiatorBusId[0]);
5053: ScsiDebugPrint(1, " IoBase = %2x\n", deviceExtension->Adapter);
5054: ScsiDebugPrint(1, " Irq = %x\n", ConfigInfo->BusInterruptLevel);
5055: ScsiDebugPrint(1, " Dma = %x\n", ConfigInfo->DmaChannel);
5056:
5057: } else {
5058:
5059: *Again = FALSE;
5060:
5061: }
5062:
5063: return(Status);
5064:
5065: }
5066:
5067: ULONG
5068: NcrEisaFindAdapter(
5069: IN PVOID ServiceContext,
5070: IN PVOID Context,
5071: IN PVOID BusInformation,
5072: IN PCHAR ArgumentString,
5073: IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
5074: OUT PBOOLEAN Again
5075: )
5076: /*++
5077:
5078: Routine Description:
5079:
5080: This function fills in the configuration information structure. This
5081: routine is temporary until the configuration manager supplies similar
5082: informtion. It also fills in the capabilities structure.
5083:
5084: Arguments:
5085:
5086: ServiceContext - Supplies a pointer to the device extension.
5087:
5088: Context - Unused.
5089:
5090: BusInformation - Unused.
5091:
5092: ArgumentString - Unused.
5093:
5094: ConfigInfo - Pointer to the configuration information structure to be
5095: filled in.
5096:
5097: Again - Returns back a request to call this function again.
5098:
5099: Return Value:
5100:
5101: Returns a status value for the initialazitaition.
5102:
5103: --*/
5104:
5105: {
5106:
5107: PSPECIFIC_DEVICE_EXTENSION deviceExtension = ServiceContext;
5108: PCM_EISA_FUNCTION_INFORMATION functionInformation;
5109: PCM_EISA_SLOT_INFORMATION slotInformation;
5110: UCHAR dataByte;
5111: PUCHAR configurationRegister;
5112: ULONG boardId;
5113: ULONG numberOfFunctions;
5114: ULONG slotNumber;
5115:
5116: *Again = FALSE;
5117:
5118: for (slotNumber = 0; slotNumber < 16; slotNumber++) {
5119:
5120: boardId = ScsiPortGetBusData( deviceExtension,
5121: EisaConfiguration,
5122: ConfigInfo->SystemIoBusNumber,
5123: slotNumber,
5124: &slotInformation,
5125: 0);
5126:
5127: if (boardId == 0 || slotInformation == NULL) {
5128: continue;
5129: }
5130:
5131: //
5132: // Calculate the actual number of functions returned.
5133: //
5134:
5135: numberOfFunctions = (boardId - sizeof(CM_EISA_SLOT_INFORMATION)) /
5136: sizeof(CM_EISA_FUNCTION_INFORMATION);
5137:
5138: if (numberOfFunctions > (ULONG) slotInformation->NumberFunctions) {
5139: numberOfFunctions = slotInformation->NumberFunctions;
5140: }
5141:
5142: functionInformation = (PCM_EISA_FUNCTION_INFORMATION) (slotInformation + 1);
5143: for (; 0 < numberOfFunctions; numberOfFunctions--, functionInformation++) {
5144:
5145: if (!(functionInformation->FunctionFlags & EISA_FUNCTION_ENABLED) &&
5146: !strcmp(functionInformation->TypeString, "MSD,CDROM1")) {
5147:
5148: DebugPrint((1, "NcrEisaFindAdapter: Found type string. Function information: %lx\n", functionInformation));
5149: ConfigInfo->DmaWidth = Width8Bits;
5150: ConfigInfo->DmaSpeed = Compatible;
5151: deviceExtension->ChipType = Ncr53c90;
5152: goto found;
5153:
5154: } else if (!(functionInformation->FunctionFlags & EISA_FUNCTION_ENABLED) &&
5155: !strcmp(functionInformation->TypeString, "MSD,SCSI,C94")) {
5156:
5157: DebugPrint((1, "NcrEisaFindAdapter: Found type string. Function information: %lx\n", functionInformation));
5158: ConfigInfo->DmaWidth = Width16Bits;
5159: ConfigInfo->AlignmentMask = 1;
5160: ConfigInfo->DmaSpeed = TypeB;
5161: ConfigInfo->MaximumTransferLength = 0x10000;
5162: deviceExtension->ChipType = Ncr53c94;
5163: goto found;
5164: }
5165: }
5166: }
5167:
5168: //
5169: // Determine if this is the correct Eisa board.
5170: //
5171:
5172: if (slotNumber >= 16) {
5173:
5174: //
5175: // The device was not found.
5176: //
5177:
5178: return(SP_RETURN_NOT_FOUND);
5179: }
5180:
5181: found:
5182:
5183: ConfigInfo->BusInterruptVector = 0;
5184: ConfigInfo->NumberOfBuses = 1;
5185:
5186: //
5187: // Get the SCSI bus Id from the configuration information if there
5188: // is any.
5189: //
5190:
5191: if (ConfigInfo->InitiatorBusId[0] == (CCHAR) SP_UNINITIALIZED_VALUE) {
5192: deviceExtension->AdapterBusId = INITIATOR_BUS_ID;
5193: deviceExtension->AdapterBusIdMask = 1 << INITIATOR_BUS_ID;
5194: ConfigInfo->InitiatorBusId[0] = INITIATOR_BUS_ID;
5195: } else {
5196: deviceExtension->AdapterBusId = ConfigInfo->InitiatorBusId[0];
5197: deviceExtension->AdapterBusIdMask = 1 << ConfigInfo->InitiatorBusId[0];
5198: }
5199:
5200: configurationRegister = ScsiPortGetDeviceBase(
5201: deviceExtension, // HwDeviceExtension
5202: ConfigInfo->AdapterInterfaceType, // AdapterInterfaceType
5203: ConfigInfo->SystemIoBusNumber, // SystemIoBusNumber
5204: ScsiPortConvertUlongToPhysicalAddress(functionInformation->EisaPort->PortAddress),
5205: functionInformation->EisaPort->Configuration.NumberPorts, // NumberOfBytes
5206: TRUE // InIoSpace
5207: );
5208:
5209: if (configurationRegister == (PUCHAR) SP_UNINITIALIZED_VALUE) {
5210: return(SP_RETURN_ERROR);
5211: }
5212:
5213: deviceExtension->ClockSpeed = 25; // Assume a 25 Mhz clock speed.
5214: deviceExtension->Adapter = (PSCSI_REGISTERS) configurationRegister;
5215:
5216: //
5217: // The Emulex chip loads the TransferCountPage register with the chip id,
5218: // if the EnablePhaseLatch is set and a NOP DMA command has been loaded.
5219: //
5220:
5221: if (deviceExtension->ChipType == Ncr53c94) {
5222:
5223: //
5224: // Now write to the command register with a reset.
5225: //
5226:
5227: SCSI_WRITE( deviceExtension->Adapter, Command, RESET_SCSI_CHIP );
5228:
5229: //
5230: // A NOP command is required by the FAS218 to
5231: // load the TransferCountPage register with the chip Id.
5232: //
5233:
5234: SCSI_WRITE( deviceExtension->Adapter, Command, NO_OPERATION_DMA );
5235:
5236: dataByte = SCSI_READ( deviceExtension->Adapter, TransferCountPage);
5237:
5238: if (((PNCR_PART_CODE) &dataByte)->ChipFamily == EMULEX_FAS_216) {
5239:
5240: deviceExtension->ChipType = Fas216;
5241: } else if (((PNCR_PART_CODE) &dataByte)->ChipFamily == NCR_53c96) {
5242:
5243: NcrPrint((1, "NcrFindAdapter: NCR 53c96 chip detected.\n"));
5244: deviceExtension->ChipType = Fas216;
5245: }
5246: }
5247:
5248: //
5249: // Set the parameters according to the chip type.
5250: //
5251:
5252: switch (deviceExtension->ChipType) {
5253: case Ncr53c94:
5254:
5255: NcrPrint((1, "NcrFindAdapter: Ncr 53C94 chip detected.\n"));
5256: ConfigInfo->TaggedQueuing = 1;
5257: ConfigInfo->MaximumTransferLength = 0x10000;
5258: break;
5259:
5260: case Fas216:
5261: NcrPrint((1, "NcrFindAdapter: Emulex FAS 216 chip detected.\n"));
5262: deviceExtension->ClockSpeed = EMULEX_SCSI_CLOCK_SPEED;
5263: ConfigInfo->TaggedQueuing = 1;
5264: ConfigInfo->MaximumTransferLength = 0x1000000-0x1000;
5265: deviceExtension->Configuration3.CheckIdMessage = 1;
5266: break;
5267:
5268: case Ncr53c90:
5269:
5270: NcrPrint((1, "NcrFindAdapter: Ncr 53C90 chip detected.\n"));
5271: ConfigInfo->MaximumTransferLength = 0x10000 - 0x1000;
5272: break;
5273:
5274: default:
5275: *Again = FALSE;
5276: return(SP_RETURN_BAD_CONFIG);
5277: }
5278:
5279: //
5280: // If the clock speed is greater than 25 Mhz then set the fast clock
5281: // bit in configuration register.
5282: //
5283:
5284: if (deviceExtension->ClockSpeed > 25) {
5285: deviceExtension->Configuration3.FastClock = 1;
5286: }
5287:
5288: ConfigInfo->DmaChannel =
5289: functionInformation->EisaDma->ConfigurationByte0.Channel;
5290: ConfigInfo->BusInterruptLevel =
5291: functionInformation->EisaIrq->ConfigurationByte.Interrupt;
5292: ConfigInfo->InterruptMode =
5293: functionInformation->EisaIrq->ConfigurationByte.LevelTriggered ?
5294: LevelSensitive : Latched;
5295:
5296: //
5297: // Fill in the access array information.
5298: //
5299:
5300: (*ConfigInfo->AccessRanges)[0].RangeStart =
5301: ScsiPortConvertUlongToPhysicalAddress(
5302: functionInformation->EisaPort->PortAddress);
5303: (*ConfigInfo->AccessRanges)[0].RangeLength =
5304: functionInformation->EisaPort->Configuration.NumberPorts;
5305: (*ConfigInfo->AccessRanges)[0].RangeInMemory = FALSE;
5306:
5307: //
5308: // Make sure the interrupt and DMA channel are properly configured.
5309: //
5310:
5311: if (ConfigInfo->DmaChannel == (UCHAR) ~0 ||
5312: ConfigInfo->BusInterruptLevel == (UCHAR) ~0) {
5313:
5314: return(SP_RETURN_BAD_CONFIG);
5315: }
5316:
5317: //
5318: // Test for the interrupt bit in the status register. Some chips do not
5319: // implement this bit; however, this driver assumes that it exists.
5320: // The itnerrupt bit is tested for by reseting the chip, giving an
5321: // illegal command, and checking for an gross error interrupt.
5322: //
5323:
5324: SCSI_WRITE( deviceExtension->Adapter, Command, RESET_SCSI_CHIP );
5325: SCSI_WRITE( deviceExtension->Adapter, Command, NO_OPERATION_DMA );
5326:
5327: SCSI_WRITE( deviceExtension->Adapter, Command, COMMAND_COMPLETE );
5328:
5329: *((PUCHAR) &deviceExtension->AdapterStatus) = SCSI_READ(
5330: deviceExtension->Adapter,
5331: ScsiStatus
5332: );
5333:
5334: dataByte = SCSI_READ( deviceExtension->Adapter, ScsiInterrupt );
5335:
5336: //
5337: // Test for the interrupt.
5338: //
5339:
5340: if (!deviceExtension->AdapterStatus.Interrupt) {
5341:
5342: NcrPrint((0, "\nNcrEisaFindAdapter: Ncr53c90 chip without status register interrupt detected.\n"));
5343: NcrPrint((0, "NcrInterrupt: Adapter Status: %2x; Adapter Interrupt: %2x\n",
5344: *((PUCHAR) &deviceExtension->AdapterStatus),
5345: dataByte
5346: ));
5347:
5348: ScsiPortFreeDeviceBase(deviceExtension, deviceExtension->Adapter);
5349: return(SP_RETURN_BAD_CONFIG);
5350: }
5351:
5352: //
5353: // Now write to the command register with a reset and a DMA nop.
5354: //
5355:
5356: SCSI_WRITE( deviceExtension->Adapter, Command, RESET_SCSI_CHIP );
5357: SCSI_WRITE( deviceExtension->Adapter, Command, NO_OPERATION_DMA );
5358:
5359: return(SP_RETURN_FOUND);
5360:
5361: }
5362:
5363: ULONG
5364: NcrMipsFindAdapter(
5365: IN PVOID ServiceContext,
5366: IN PVOID Context,
5367: IN PVOID BusInformation,
5368: IN PCHAR ArgumentString,
5369: IN OUT PPORT_CONFIGURATION_INFORMATION ConfigInfo,
5370: OUT PBOOLEAN Again
5371: )
5372: /*++
5373:
5374: Routine Description:
5375:
5376: This function fills in the configuration information structure and mapes
5377: the SCSI protocol chip for access. This routine is temporary until
5378: the configuration manager supplies similar informtion.
5379:
5380: Arguments:
5381:
5382: ServiceContext - Supplies a pointer to the device extension.
5383:
5384: Context - Unused.
5385:
5386: BusInformation - Unused.
5387:
5388: ArgumentString - Unused.
5389:
5390: ConfigInfo - Pointer to the configuration information structure to be
5391: filled in.
5392:
5393: Again - Returns back a request to call this function again.
5394:
5395: Return Value:
5396:
5397: Returns a status value for the initialazitaition.
5398:
5399: --*/
5400:
5401: {
5402: PSPECIFIC_DEVICE_EXTENSION deviceExtension = ServiceContext;
5403: UCHAR dataByte;
5404: UCHAR commandSave;
5405:
5406: if (ConfigInfo->DmaChannel == SP_UNINITIALIZED_VALUE
5407: || ConfigInfo->BusInterruptLevel == 0 ||
5408: (*ConfigInfo->AccessRanges)[0].RangeLength == 0) {
5409: return(SP_RETURN_NOT_FOUND);
5410: }
5411:
5412: ConfigInfo->NumberOfBuses = 1;
5413:
5414: //
5415: // Get the SCSI bus Id from the configuration information if there
5416: // is any.
5417: //
5418:
5419: if (ConfigInfo->InitiatorBusId[0] == (CCHAR) SP_UNINITIALIZED_VALUE) {
5420: deviceExtension->AdapterBusId = INITIATOR_BUS_ID;
5421: deviceExtension->AdapterBusIdMask = 1 << INITIATOR_BUS_ID;
5422: ConfigInfo->InitiatorBusId[0] = INITIATOR_BUS_ID;
5423: } else {
5424: deviceExtension->AdapterBusId = ConfigInfo->InitiatorBusId[0];
5425: deviceExtension->AdapterBusIdMask = 1 << ConfigInfo->InitiatorBusId[0];
5426: }
5427:
5428: //
5429: // Map the SCSI protocol chip into the virtual address space.
5430: //
5431:
5432: deviceExtension->Adapter = ScsiPortGetDeviceBase(
5433: deviceExtension, // HwDeviceExtension
5434: ConfigInfo->AdapterInterfaceType, // AdapterInterfaceType
5435: ConfigInfo->SystemIoBusNumber, // SystemIoBusNumber
5436: (*ConfigInfo->AccessRanges)[0].RangeStart,
5437: (*ConfigInfo->AccessRanges)[0].RangeLength, // NumberOfBytes
5438: FALSE // InIoSpace
5439: );
5440:
5441: if (deviceExtension->Adapter == NULL) {
5442: NcrPrint((0, "\nScsiPortInitialize: Failed to map SCSI device registers into system space.\n"));
5443: return(SP_RETURN_ERROR);
5444: }
5445:
5446: //
5447: // Check the iterrupt register. If it is not equal zero then read it
5448: // agian it should now be zero.
5449: //
5450:
5451: dataByte = SCSI_READ( deviceExtension->Adapter, ScsiInterrupt );
5452:
5453: if (dataByte != 0) {
5454:
5455: ScsiPortStallExecution(INTERRUPT_STALL_TIME);
5456: dataByte = SCSI_READ( deviceExtension->Adapter, ScsiInterrupt );
5457:
5458: if (dataByte != 0 ) {
5459: NcrPrint((1, "NcrMipsFindAdapter: No Ncr53c9x chip found! Interrupt will not clear.\n"));
5460: ScsiPortFreeDeviceBase(deviceExtension, deviceExtension->Adapter);
5461: return(SP_RETURN_NOT_FOUND);
5462: }
5463: }
5464:
5465: //
5466: // Test for the interrupt bit in the status register. Some chips do not
5467: // implement this bit; however, this driver assumes that it exists.
5468: // The itnerrupt bit is tested for by reseting the chip, giving an
5469: // illegal command, and checking for an gross error interrupt.
5470: //
5471:
5472: commandSave = SCSI_READ(deviceExtension->Adapter, Command);
5473:
5474: SCSI_WRITE( deviceExtension->Adapter, Command, RESET_SCSI_CHIP );
5475: ScsiPortStallExecution(1);
5476: SCSI_WRITE( deviceExtension->Adapter, Command, NO_OPERATION_DMA );
5477: ScsiPortStallExecution(1);
5478:
5479: SCSI_WRITE( deviceExtension->Adapter, Command, COMMAND_COMPLETE );
5480: ScsiPortStallExecution(1);
5481:
5482: *((PUCHAR) &deviceExtension->AdapterStatus) = SCSI_READ(
5483: deviceExtension->Adapter,
5484: ScsiStatus
5485: );
5486:
5487: dataByte = SCSI_READ( deviceExtension->Adapter, ScsiInterrupt );
5488:
5489: //
5490: // Test for the interrupt.
5491: //
5492:
5493: if (!deviceExtension->AdapterStatus.Interrupt) {
5494:
5495: NcrPrint((0, "\nNcrMipsFindAdapter: Ncr53c90 chip without status register interrupt detected.\n"));
5496: NcrPrint((0, "NcrMipsFindAdapter: Adapter Status: %2x; Adapter Interrupt: %2x\n",
5497: *((PUCHAR) &deviceExtension->AdapterStatus),
5498: dataByte
5499: ));
5500:
5501: //
5502: // Restore the command register.
5503: //
5504:
5505: SCSI_WRITE( deviceExtension->Adapter, Command, commandSave );
5506:
5507: ScsiPortFreeDeviceBase(deviceExtension, deviceExtension->Adapter);
5508: return(SP_RETURN_NOT_FOUND);
5509: }
5510:
5511: //
5512: // Initialize the NCR SCSI Chip.
5513: //
5514:
5515: SCSI_WRITE( deviceExtension->Adapter, Command, RESET_SCSI_CHIP );
5516:
5517: //
5518: // A NOP command is required to clear the chip reset command.
5519: //
5520:
5521: SCSI_WRITE( deviceExtension->Adapter, Command, NO_OPERATION_DMA );
5522:
5523: //
5524: // Determine the chip type.
5525: //
5526:
5527: //
5528: // The Ncr53c90 is detected by the absense of configuration register 3.
5529: // On the other to chips this register is zero after a reset and is read
5530: // writable.
5531: //
5532:
5533: dataByte = SCSI_READ( deviceExtension->Adapter, Configuration2);
5534:
5535: if (dataByte != 0) {
5536:
5537: deviceExtension->ChipType = Ncr53c90;
5538:
5539: } else {
5540:
5541: //
5542: // Set the Scsi2 and EnablePhaseLatch of the configuration regisiter.
5543: //
5544:
5545: ((PSCSI_CONFIGURATION2)(&dataByte))->Scsi2 = 1;
5546: ((PSCSI_CONFIGURATION2)(&dataByte))->EnablePhaseLatch = 1;
5547:
5548: SCSI_WRITE( deviceExtension->Adapter, Configuration2, dataByte);
5549:
5550: //
5551: // Read the register back if the value is not the same as was written,
5552: // then this an Ncr53c90.
5553: //
5554:
5555: if (dataByte != SCSI_READ( deviceExtension->Adapter, Configuration2)) {
5556:
5557: deviceExtension->ChipType = Ncr53c90;
5558:
5559: } else {
5560:
5561: deviceExtension->ChipType = Ncr53c94;
5562:
5563: }
5564: }
5565:
5566: //
5567: // The Emulex chip loads the TransferCountPage register with the chip id,
5568: // if the EnablePhaseLatch is set and a NOP DMA command has been loaded.
5569: //
5570:
5571: if (deviceExtension->ChipType == Ncr53c94) {
5572:
5573: //
5574: // A NOP command is required by the FAS218 to
5575: // load the TransferCountPage register with the chip Id.
5576: //
5577:
5578: SCSI_WRITE( deviceExtension->Adapter, Command, NO_OPERATION_DMA );
5579:
5580: dataByte = SCSI_READ( deviceExtension->Adapter, TransferCountPage);
5581:
5582: if (((PNCR_PART_CODE) &dataByte)->ChipFamily == EMULEX_FAS_216) {
5583:
5584: deviceExtension->ChipType = Fas216;
5585:
5586: } else if (((PNCR_PART_CODE) &dataByte)->ChipFamily == NCR_53c96) {
5587:
5588: NcrPrint((1, "NcrFindAdapter: NCR 53c96 chip detected.\n"));
5589: deviceExtension->ChipType = Fas216;
5590: }
5591: }
5592:
5593: //
5594: // Set the parameters according to the chip type.
5595: //
5596:
5597: switch (deviceExtension->ChipType) {
5598: case Ncr53c94:
5599:
5600: NcrPrint((1, "NcrFindAdapter: Ncr 53C94 chip detected.\n"));
5601: deviceExtension->ClockSpeed = NCR_SCSI_CLOCK_SPEED;
5602: ConfigInfo->TaggedQueuing = 1;
5603: ConfigInfo->MaximumTransferLength = 0x10000;
5604: break;
5605:
5606: case Fas216:
5607: NcrPrint((1, "NcrFindAdapter: Emulex FAS 216 chip detected.\n"));
5608: deviceExtension->ClockSpeed = EMULEX_SCSI_CLOCK_SPEED;
5609: ConfigInfo->TaggedQueuing = 1;
5610: ConfigInfo->MaximumTransferLength = 0x1000000-0x1000;
5611: deviceExtension->Configuration3.CheckIdMessage = 1;
5612: break;
5613:
5614: case Ncr53c90:
5615:
5616: NcrPrint((1, "NcrFindAdapter: Ncr 53C90 chip detected.\n"));
5617:
5618: default:
5619: *Again = FALSE;
5620: return(SP_RETURN_BAD_CONFIG);
5621: }
5622:
5623: //
5624: // If the clock speed is greater than 25 Mhz then set the fast clock
5625: // bit in configuration register.
5626: //
5627:
5628: if (deviceExtension->ClockSpeed > 25) {
5629: deviceExtension->Configuration3.FastClock = 1;
5630: }
5631:
5632: *Again = FALSE;
5633: return(SP_RETURN_FOUND);
5634:
5635: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.