![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interrup.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / ibmtok|
Return to interrup.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / ibmtok |
1.1 root 1: /*++
2:
3: Copyright (c) 1990 Microsoft Corporation
4:
5: Module Name:
6:
7: interrup.c
8:
9: Abstract:
10:
11: This is a part of the driver for the National Semiconductor IBMTOK
12: Ethernet controller. It contains the interrupt-handling routines.
13: This driver conforms to the NDIS 3.0 interface.
14:
15: The overall structure and much of the code is taken from
16: the Lance NDIS driver by Tony Ercolano.
17:
18: Author:
19:
20: Adam Barr (adamba) 16-Jan-1991
21:
22: Environment:
23:
24: Kernel Mode - Or whatever is the equivalent.
25:
26: Revision History:
27:
28: Sean Selitrennikoff - 10/91
29: Fixed synchronization bugs.
30:
31: Sean Selitrennikoff - 10/15/91
32: Converted to Ndis 3.0
33:
34: Sean Selitrennikoff - 1/8/92
35: Added error logging
36:
37: --*/
38:
39: #pragma optimize("",off)
40:
41: #include <ndis.h>
42:
43:
44: #include <tfilter.h>
45: #include <tokhrd.h>
46: #include <toksft.h>
47:
48:
49: #if DEVL
50: #define STATIC
51: #else
52: #define STATIC static
53: #endif
54:
55: #if DBG
56: extern INT IbmtokDbg;
57: #endif
58:
59: //
60: // This section contains all the functions and definitions for
61: // doing logging of input and output to/from the card.
62: //
63:
64: #if LOG
65:
66: //
67: // Place in the circular buffer.
68: //
69: UCHAR IbmtokLogPlace;
70:
71: //
72: // Circular buffer for storing log information.
73: //
74: UCHAR IbmtokLog[256];
75:
76: #define IF_LOG(A) {IbmtokLog[IbmtokLogPlace++ % 256] = (A); IbmtokLog[IbmtokLogPlace+2 % 256] = '.';}
77:
78: #else
79:
80: #define IF_LOG(A)
81:
82: #endif
83:
84: VOID
85: SetResetVariables(
86: IN PIBMTOK_ADAPTER Adapter
87: );
88:
89: STATIC
90: VOID
91: IbmtokHandleSrbSsb(
92: IN PIBMTOK_ADAPTER Adapter
93: );
94:
95: STATIC
96: VOID
97: IbmtokHandleArbAsb(
98: IN PIBMTOK_ADAPTER Adapter
99: );
100:
101:
102: STATIC
103: VOID
104: HandleResetStaging(
105: IN PIBMTOK_ADAPTER Adapter
106: );
107:
108: STATIC
109: BOOLEAN
110: IbmtokSynchGetSrbSsbBits(
111: IN PVOID Context
112: );
113:
114: STATIC
115: BOOLEAN
116: IbmtokSynchGetArbAsbBits(
117: IN PVOID Context
118: );
119:
120: STATIC
121: VOID
122: PutPacketOnWaitingForAsb(
123: IN PIBMTOK_ADAPTER Adapter,
124: IN PNDIS_PACKET Packet
125: );
126:
127: STATIC
128: PNDIS_PACKET
129: RemoveTransmitFromSrb(
130: IN PIBMTOK_ADAPTER Adapter,
131: OUT PBOOLEAN PacketRemoved
132: );
133:
134: STATIC
135: VOID
136: SetupTransmitFrameSrb(
137: IN PIBMTOK_ADAPTER Adapter,
138: IN PNDIS_PACKET Packet
139: );
140:
141: STATIC
142: VOID
143: SetupTransmitStatusAsb(
144: IN PIBMTOK_ADAPTER Adapter,
145: IN PNDIS_PACKET Packet
146: );
147:
148: STATIC
149: VOID
150: GetAdapterStatisticsFromSrb(
151: PIBMTOK_ADAPTER Adapter
152: );
153:
154: STATIC
155: VOID
156: GetAdapterErrorsFromSrb(
157: PIBMTOK_ADAPTER Adapter
158: );
159:
160:
161: STATIC
162: NDIS_STATUS
163: StartPendQueueOp(
164: IN PIBMTOK_ADAPTER Adapter
165: );
166:
167: STATIC
168: NDIS_STATUS
169: FinishSetOperation(
170: IN PIBMTOK_ADAPTER Adapter,
171: IN PIBMTOK_PEND_DATA PendOp
172: );
173:
174:
175: STATIC
176: BOOLEAN
177: FinishPendQueueOp(
178: IN PIBMTOK_ADAPTER Adapter,
179: IN BOOLEAN Successful
180: );
181:
182: STATIC
183: NDIS_STATUS
184: SetAdapterFunctionalAddress(
185: IN PIBMTOK_ADAPTER Adapter
186: );
187:
188: STATIC
189: VOID
190: SetupFunctionalSrb(
191: IN PIBMTOK_ADAPTER Adapter,
192: IN TR_FUNCTIONAL_ADDRESS FunctionalAddress
193: );
194:
195: STATIC
196: NDIS_STATUS
197: SetAdapterGroupAddress(
198: IN PIBMTOK_ADAPTER Adapter
199: );
200:
201: STATIC
202: VOID
203: SetupGroupSrb(
204: IN PIBMTOK_ADAPTER Adapter,
205: IN TR_FUNCTIONAL_ADDRESS FunctionalAddress
206: );
207:
208: STATIC
209: VOID
210: SetupReceivedDataAsb(
211: IN PIBMTOK_ADAPTER Adapter,
212: IN SRAM_PTR ReceiveBuffer
213: );
214:
215:
216: //
217: // These macros are used to set the SRPR correctly.
218: //
219: #define SET_SRB_SRPR(Adapter) \
220: if (Adapter->SharedRamPaging) { \
221: WRITE_ADAPTER_REGISTER(Adapter, SRPR_LOW, Adapter->SrbSrprLow) \
222: }
223:
224: #define SET_SSB_SRPR(Adapter) \
225: if (Adapter->SharedRamPaging) { \
226: WRITE_ADAPTER_REGISTER(Adapter, SRPR_LOW, Adapter->SsbSrprLow) \
227: }
228:
229: #define SET_ARB_SRPR(Adapter) \
230: if (Adapter->SharedRamPaging) { \
231: WRITE_ADAPTER_REGISTER(Adapter, SRPR_LOW, Adapter->ArbSrprLow) \
232: }
233:
234: #define SET_ASB_SRPR(Adapter) \
235: if (Adapter->SharedRamPaging) { \
236: WRITE_ADAPTER_REGISTER(Adapter, SRPR_LOW, Adapter->AsbSrprLow) \
237: }
238:
239:
240:
241: typedef struct _IBMTOK_SYNCH_CONTEXT {
242:
243: //
244: // Pointer to the ibmtok adapter for which interrupts are
245: // being synchronized.
246: //
247: PIBMTOK_ADAPTER Adapter;
248:
249: //
250: // Points to the variable on to which the relevant
251: // interrupt bits should be ORed.
252: //
253: PVOID Local;
254:
255: } IBMTOK_SYNCH_CONTEXT, * PIBMTOK_SYNCH_CONTEXT;
256:
257: //
258: // This macro is to synchronize execution with interrupts. It
259: // gets the stored value of the SRB/SSB bits and clears the
260: // old value.
261: //
262: #define GET_SRB_SSB_BITS(A,L) \
263: { \
264: PIBMTOK_ADAPTER _A = A; \
265: IBMTOK_SYNCH_CONTEXT _C; \
266: _C.Adapter = _A; \
267: _C.Local = (PVOID)(L); \
268: NdisSynchronizeWithInterrupt( \
269: &(_A->Interrupt), \
270: (PVOID) IbmtokSynchGetSrbSsbBits, \
271: &_C \
272: ); \
273: }
274:
275: //
276: // This macro is to synchronize execution with interrupts. It
277: // gets the stored value of the ARB/ASB bits and clears the
278: // old value.
279: //
280: #define GET_ARB_ASB_BITS(A,L) \
281: { \
282: PIBMTOK_ADAPTER _A = A; \
283: IBMTOK_SYNCH_CONTEXT _C; \
284: _C.Adapter = _A; \
285: _C.Local = (PVOID)(L); \
286: NdisSynchronizeWithInterrupt( \
287: &(_A->Interrupt), \
288: (PVOID) IbmtokSynchGetArbAsbBits, \
289: &_C \
290: ); \
291: }
292:
293:
294: //++
295: //
296: // PNDIS_PACKET
297: // FindPacketGivenCorrelator(
298: // IN PIBMTOK_ADAPTER Adapter,
299: // IN UCHAR CommandCorrelator
300: // )
301: //
302: //
303: // Routine Description:
304: //
305: // This looks a packet up on the command correlator array.
306: //
307: // This routine should be called with the spinlock held.
308: //
309: // Arguments:
310: //
311: // Adapter - The adapter that this packet is coming through.
312: //
313: // CommandCorrelator - The command correlator to search based on.
314: //
315: // Return Value:
316: //
317: // The packet if found, NULL otherwise.
318: //
319: //--
320:
321: #define FindPacketGivenCorrelator(_Adapter, _CommandCorrelator) \
322: ((_Adapter)->CorrelatorArray[_CommandCorrelator])
323:
324:
325: STATIC
326: BOOLEAN
327: IbmtokSynchGetSrbSsbBits(
328: IN PVOID Context
329: )
330:
331: /*++
332:
333: Routine Description:
334:
335: This routine is used by the normal interrupt processing routine
336: to synchronize with interrupts from the card. It will or
337: the value of the stored SRB/SSB bits into the other passed address
338: in the context and clear the stored value.
339:
340: Arguments:
341:
342: Context - This is really a pointer to a record type peculiar
343: to this routine. The record contains a pointer to the adapter
344: and a pointer to an address in which to place the contents
345: of the ISRP.
346:
347: Return Value:
348:
349: Always returns true.
350:
351: --*/
352:
353: {
354:
355: PIBMTOK_SYNCH_CONTEXT C = (PIBMTOK_SYNCH_CONTEXT)Context;
356:
357: *((PUCHAR)C->Local) = (C->Adapter->IsrpBits) &
358: (ISRP_HIGH_SRB_RESPONSE | ISRP_HIGH_SSB_RESPONSE);
359:
360: C->Adapter->IsrpBits = (C->Adapter->IsrpBits) &
361: (~(ISRP_HIGH_SRB_RESPONSE | ISRP_HIGH_SSB_RESPONSE));
362:
363: return TRUE;
364:
365: }
366:
367: STATIC
368: BOOLEAN
369: IbmtokSynchGetArbAsbBits(
370: IN PVOID Context
371: )
372:
373: /*++
374:
375: Routine Description:
376:
377: This routine is used by the normal interrupt processing routine
378: to synchronize with interrupts from the card. It will or
379: the value of the stored ARB/ASB bits into the other passed address
380: in the context and clear the stored value.
381:
382: Arguments:
383:
384: Context - This is really a pointer to a record type peculiar
385: to this routine. The record contains a pointer to the adapter
386: and a pointer to an address in which to place the contents
387: of the ISRP.
388: Return Value:
389:
390: Always returns true.
391:
392: --*/
393:
394: {
395:
396: PIBMTOK_SYNCH_CONTEXT C = (PIBMTOK_SYNCH_CONTEXT)Context;
397:
398: *((PUCHAR)C->Local) = (C->Adapter->IsrpBits) &
399: (ISRP_HIGH_ARB_COMMAND | ISRP_HIGH_ASB_FREE);
400:
401: C->Adapter->IsrpBits = (C->Adapter->IsrpBits) &
402: (~(ISRP_HIGH_ARB_COMMAND | ISRP_HIGH_ASB_FREE));
403:
404: return TRUE;
405:
406: }
407:
408: extern
409: BOOLEAN
410: IbmtokSynchSetReset(
411: IN PVOID Context
412: )
413:
414: /*++
415:
416: Routine Description:
417:
418: This routine is called by the SET_INTERRUPT_RESET_FLAG macro.
419: It sets the ResetInterruptAllowed flag to TRUE.
420:
421: Arguments:
422:
423: Context - A pointer to the Adapter structure.
424:
425: Return Value:
426:
427: Always returns true.
428:
429: --*/
430:
431: {
432:
433: PIBMTOK_ADAPTER Adapter = (PIBMTOK_ADAPTER)Context;
434:
435: Adapter->ResetInterruptAllowed = TRUE;
436:
437: return TRUE;
438:
439: }
440:
441: extern
442: BOOLEAN
443: IbmtokSynchClearIsrpBits(
444: IN PVOID Context
445: )
446:
447: /*++
448:
449: Routine Description:
450:
451: This routine is called by the CLEAR_ISRP_BITS macro.
452: It clears the SRB/SSB and ARB/ASB bits. This is used
453: when a reset has started to prevent a previously
454: queued interrupt handler to come in and start
455: playing with an adapter that is being reset.
456:
457: Arguments:
458:
459: Context - A pointer to the Adapter structure.
460:
461: Return Value:
462:
463: Always returns true.
464:
465: --*/
466:
467: {
468:
469: PIBMTOK_ADAPTER Adapter = (PIBMTOK_ADAPTER)Context;
470:
471: Adapter->IsrpBits = 0;
472:
473: return TRUE;
474:
475: }
476:
477: extern
478: BOOLEAN
479: IbmtokISR(
480: IN PVOID Context
481: )
482:
483: /*++
484:
485: Routine Description:
486:
487: Interrupt service routine for the sonic. It's main job is
488: to get the value of ISR and record the changes in the
489: adapters own list of interrupt reasons.
490:
491: Arguments:
492:
493: Context - Really a pointer to the adapter.
494:
495: Return Value:
496:
497: Returns true if the card ISR is non-zero.
498:
499: --*/
500:
501: {
502:
503: //
504: // Holds the pointer to the adapter.
505: //
506: PIBMTOK_ADAPTER Adapter = Context;
507:
508: //
509: // Holds the value of the ISRP High
510: //
511: UCHAR IsrpHigh;
512:
513: READ_ADAPTER_REGISTER(Adapter, ISRP_HIGH, &IsrpHigh);
514:
515:
516: if (!Adapter->BringUp) {
517:
518: Adapter->ContinuousIsrs++;
519:
520: if (Adapter->ContinuousIsrs == 0xFF) {
521:
522: //
523: // We seemed to be confused since the DPCs aren't getting in.
524: // Shutdown and exit.
525: //
526:
527: #if DBG
528: if (IbmtokDbg) DbgPrint("IBMTOK: Continuous ISRs received\n");
529: #endif
530:
531: WRITE_ADAPTER_PORT(Adapter, RESET_LATCH, 0);
532:
533: return(FALSE);
534:
535: }
536:
537: }
538:
539:
540: #if DBG
541: if (IbmtokDbg) DbgPrint("ISRP High: %x\n", IsrpHigh);
542: #endif
543:
544: IF_LOG('i');
545:
546: //
547: // Acknowledge all the interrupts we got in IsrpHigh.
548: //
549:
550: WRITE_ADAPTER_REGISTER(Adapter, ISRP_HIGH_RESET, (UCHAR)(~IsrpHigh));
551:
552: //
553: // If the adapter is not accepting requests, ignore everything
554: // but SRB_RESPONSE interrupts, saving any others until
555: // NotAcceptingRequests goes to FALSE (note that we have
556: // already turned off ALL bits in ISRP_HIGH).
557: //
558: if (Adapter->NotAcceptingRequests) {
559:
560: Adapter->IsrpDeferredBits |= (IsrpHigh & (~ISRP_HIGH_SRB_RESPONSE));
561:
562: IsrpHigh &= ISRP_HIGH_SRB_RESPONSE;
563:
564: } else {
565:
566: //
567: // Put the deferred bits back on (after the first time
568: // through they will be 0).
569: //
570:
571: IsrpHigh |= Adapter->IsrpDeferredBits;
572:
573: Adapter->IsrpDeferredBits = 0;
574:
575: }
576:
577:
578: //
579: // Now store the bits for the DPC.
580: //
581:
582: Adapter->IsrpBits |= IsrpHigh;
583:
584: //
585: // If this is the reset interrupt, set the flag.
586: //
587:
588: if (Adapter->ResetInterruptAllowed){
589: Adapter->ResetInterruptHasArrived = TRUE;
590: }
591:
592: if (Adapter->FirstInitialization) {
593:
594: USHORT WrbOffset;
595: PSRB_BRING_UP_RESULT BringUpSrb;
596: UCHAR Value1, Value2;
597: USHORT RegValue;
598:
599: READ_ADAPTER_REGISTER(Adapter, WRBR_LOW, &Value1);
600: READ_ADAPTER_REGISTER(Adapter, WRBR_HIGH, &Value2);
601:
602: WrbOffset = (((USHORT)Value1) << 8) + (USHORT)Value2;
603:
604: Adapter->InitialWrbOffset = WrbOffset;
605:
606: BringUpSrb = (PSRB_BRING_UP_RESULT)(Adapter->SharedRam + WrbOffset);
607:
608: NdisReadRegisterUshort(&(BringUpSrb->ReturnCode), &RegValue);
609:
610: if (RegValue == 0x0000) {
611:
612: Adapter->BringUp = TRUE;
613:
614: }
615:
616: //
617: // If we are using the PC I/O Bus then we have to re-enable
618: // interrupts because the card is blocking all other interrupts
619: //
620:
621: if (Adapter->UsingPcIoBus) {
622: WRITE_ADAPTER_PORT(Adapter, INTERRUPT_RELEASE_ISA_ONLY, 0);
623: }
624:
625: IF_LOG('I');
626:
627: //
628: // no DPC for the first init.
629: //
630:
631: return(FALSE);
632: }
633:
634: //
635: // If we are using the PC I/O Bus then we have to re-enable
636: // interrupts because the card is blocking all other interrupts
637: //
638:
639: if (Adapter->UsingPcIoBus) {
640: WRITE_ADAPTER_PORT(Adapter, INTERRUPT_RELEASE_ISA_ONLY, 0);
641: }
642:
643: if (IsrpHigh == 0x0) {
644:
645: //
646: // This means that the interrupt was generated from the IsrpLow
647: // and needs to be cleared.
648: //
649:
650: READ_ADAPTER_REGISTER(Adapter, ISRP_LOW, &IsrpHigh);
651:
652: //
653: // Mask off the bits we need.
654: //
655:
656: IsrpHigh &= 0x1C;
657:
658: Adapter->IsrpLowBits = IsrpHigh;
659:
660: //
661: // Acknowledge all the interrupts we got in IsrpLow.
662: //
663:
664: WRITE_ADAPTER_REGISTER(Adapter, ISRP_LOW_RESET, (UCHAR)(~IsrpHigh));
665:
666: }
667:
668: IF_LOG('I');
669:
670: if (Adapter->IsrpBits != 0) {
671:
672: return TRUE;
673:
674: } else {
675:
676: return FALSE;
677:
678: }
679:
680: }
681:
682: extern
683: VOID
684: IbmtokDPC(
685: IN PVOID SystemSpecific1,
686: IN PVOID Context,
687: IN PVOID SystemArgument1,
688: IN PVOID SystemArgument2
689: )
690:
691: /*++
692:
693: Routine Description:
694:
695: This DPC routine is queued by Ndis after interrupt service routine
696: has run. It's main job is to call the interrupt processing code.
697:
698: Arguments:
699:
700: SystemSpecific1 - Not used.
701:
702: Context - Really a pointer to the adapter.
703:
704: SystemArgument1(2) - Neither of these arguments used.
705:
706: Return Value:
707:
708: None.
709:
710: --*/
711:
712: {
713: PIBMTOK_ADAPTER Adapter = (PIBMTOK_ADAPTER)Context;
714:
715: NdisDprAcquireSpinLock(&Adapter->Lock);
716:
717: Adapter->ContinuousIsrs = 0;
718:
719: IF_LOG('d');
720:
721: Adapter->WakeUpTimeout = FALSE;
722:
723: if (Adapter->IsrpLowBits) {
724:
725: NdisWriteErrorLogEntry(
726: Adapter->NdisAdapterHandle,
727: NDIS_ERROR_CODE_HARDWARE_FAILURE,
728: 3,
729: ibmtokDpc,
730: IBMTOK_ERRMSG_ISRP_LOW_ERROR,
731: (ULONG)(Adapter->IsrpLowBits)
732: );
733:
734: Adapter->IsrpLowBits = 0;
735:
736: }
737:
738: if ((Adapter->IsrpBits & (ISRP_HIGH_SRB_RESPONSE | ISRP_HIGH_SSB_RESPONSE)) &&
739: (!Adapter->HandleSrbRunning)) {
740:
741: IbmtokHandleSrbSsb(Adapter);
742:
743: NdisDprAcquireSpinLock(&(Adapter->Lock));
744:
745: }
746:
747: if ((Adapter->IsrpBits & (ISRP_HIGH_ARB_COMMAND | ISRP_HIGH_ASB_FREE)) &&
748: (!Adapter->HandleArbRunning)) {
749:
750: IbmtokHandleArbAsb(Adapter);
751:
752: } else {
753:
754: NdisDprReleaseSpinLock(&Adapter->Lock);
755: }
756:
757: #if DBG
758: NdisDprAcquireSpinLock(&Adapter->Lock);
759: IF_LOG('D');
760: NdisDprReleaseSpinLock(&Adapter->Lock);
761: #endif
762:
763: }
764:
765: extern
766: VOID
767: IbmtokHandleSrbSsb(
768: IN PIBMTOK_ADAPTER Adapter
769: )
770:
771: /*++
772:
773: Routine Description:
774:
775: This routine is called by the DPC routine
776: and other routines within the driver that notice that
777: some deferred processing needs to be done. It's main
778: job is to call the interrupt processing code.
779:
780: NOTE: THIS ROUTINE IS CALLED WITH THE LOCK HELD!! AND RETURNS
781: WITH IT RELEASED!!
782:
783: Arguments:
784:
785: Adapter - A pointer to the adapter.
786:
787: Return Value:
788:
789: None.
790:
791: --*/
792:
793: {
794: UCHAR IsrpHigh;
795: UCHAR TmpUchar;
796: USHORT TmpUshort;
797:
798: IF_LOG('h');
799:
800: Adapter->References++;
801:
802: if (Adapter->ResetInProgress) {
803:
804: if (Adapter->ResetInterruptHasArrived) {
805:
806: //
807: // This is the interrupt after a reset,
808: // continue things along.
809: //
810:
811: HandleResetStaging(Adapter);
812:
813: IBMTOK_DO_DEFERRED(Adapter);
814:
815: return;
816:
817: }
818:
819: }
820:
821: //
822: // If ResetInProgress is TRUE but this is an old
823: // interrupt, proceed as usual (once the reset
824: // actually starts, GET_SRB_SSB_BITS will return
825: // nothing so no work will get done).
826: //
827:
828: Adapter->HandleSrbRunning = TRUE;
829:
830: GET_SRB_SSB_BITS(Adapter, &IsrpHigh);
831:
832: while (IsrpHigh & (ISRP_HIGH_SRB_RESPONSE | ISRP_HIGH_SSB_RESPONSE)) {
833:
834: IF_LOG((UCHAR)(Adapter->OpenInProgress));
835:
836: if (Adapter->Unplugged && !Adapter->UnpluggedResetInProgress) {
837:
838: //
839: // Do, nothing. This is most likely a stale interrupt. We
840: // wait until we get a ring status interrupt telling us that
841: // the cable is plugged in.
842: //
843:
844: break;
845:
846: }
847:
848: if (IsrpHigh & ISRP_HIGH_SRB_RESPONSE) {
849:
850: if (Adapter->OpenInProgress) {
851:
852: //
853: // Handle the result of the DIR.OPEN.ADAPTER command.
854: //
855:
856: PSRB_OPEN_RESPONSE OpenResponseSrb;
857: PIBMTOK_OPEN Open;
858: PLIST_ENTRY CurrentLink;
859: UCHAR ReturnCode;
860:
861: OpenResponseSrb = (PSRB_OPEN_RESPONSE)
862: (Adapter->SharedRam + Adapter->InitialWrbOffset);
863:
864: NdisReadRegisterUchar(&(OpenResponseSrb->ReturnCode), &ReturnCode);
865:
866: #if DBG
867: if (IbmtokDbg)
868: DbgPrint("IBMTOK: OPEN, Return code = %x, at %lx\n",
869: ReturnCode,
870: OpenResponseSrb);
871: #endif
872:
873: if (ReturnCode == 0x0) {
874:
875: NdisDprReleaseSpinLock(&(Adapter->Lock));
876:
877: if (Adapter->SharedRamPaging) {
878:
879: NdisReadRegisterUshort(&(OpenResponseSrb->SrbPointer), &TmpUshort);
880:
881: TmpUshort = IBMSHORT_TO_USHORT(TmpUshort);
882:
883: Adapter->SrbAddress = SHARED_RAM_ADDRESS(Adapter,
884: SHARED_RAM_LOW_BITS(TmpUshort));
885: Adapter->SrbSrprLow = (UCHAR)(TmpUshort >> 14);
886:
887:
888: NdisReadRegisterUshort(&(OpenResponseSrb->SsbPointer), &TmpUshort);
889:
890: TmpUshort = IBMSHORT_TO_USHORT(TmpUshort);
891:
892: Adapter->SsbAddress = SHARED_RAM_ADDRESS(Adapter,
893: SHARED_RAM_LOW_BITS(TmpUshort));
894: Adapter->SsbSrprLow = (UCHAR)(TmpUshort >> 14);
895:
896:
897: NdisReadRegisterUshort(&(OpenResponseSrb->ArbPointer), &TmpUshort);
898:
899: TmpUshort = IBMSHORT_TO_USHORT(TmpUshort);
900:
901: Adapter->ArbAddress = SHARED_RAM_ADDRESS(Adapter,
902: SHARED_RAM_LOW_BITS(TmpUshort));
903: Adapter->ArbSrprLow = (UCHAR)(TmpUshort >> 14);
904:
905:
906: NdisReadRegisterUshort(&(OpenResponseSrb->AsbPointer), &TmpUshort);
907:
908: TmpUshort = IBMSHORT_TO_USHORT(TmpUshort);
909:
910: Adapter->AsbAddress = SHARED_RAM_ADDRESS(Adapter,
911: SHARED_RAM_LOW_BITS(TmpUshort));
912: Adapter->AsbSrprLow = (UCHAR)(TmpUshort >> 14);
913:
914: } else {
915:
916: NdisReadRegisterUshort(&(OpenResponseSrb->SrbPointer), &TmpUshort);
917: Adapter->SrbAddress = SRAM_PTR_TO_PVOID(Adapter, TmpUshort);
918:
919: NdisReadRegisterUshort(&(OpenResponseSrb->SsbPointer), &TmpUshort);
920: Adapter->SsbAddress = SRAM_PTR_TO_PVOID(Adapter, TmpUshort);
921:
922: NdisReadRegisterUshort(&(OpenResponseSrb->ArbPointer), &TmpUshort);
923: Adapter->ArbAddress = SRAM_PTR_TO_PVOID(Adapter, TmpUshort);
924:
925: NdisReadRegisterUshort(&(OpenResponseSrb->AsbPointer), &TmpUshort);
926: Adapter->AsbAddress = SRAM_PTR_TO_PVOID(Adapter, TmpUshort);
927:
928: }
929:
930: #if DBG
931: if (IbmtokDbg) {
932: USHORT TmpUshort1;
933: USHORT TmpUshort2;
934: USHORT TmpUshort3;
935: USHORT TmpUshort4;
936: NdisReadRegisterUshort(&(OpenResponseSrb->SrbPointer), &TmpUshort1);
937: NdisReadRegisterUshort(&(OpenResponseSrb->SsbPointer), &TmpUshort2);
938: NdisReadRegisterUshort(&(OpenResponseSrb->ArbPointer), &TmpUshort3);
939: NdisReadRegisterUshort(&(OpenResponseSrb->AsbPointer), &TmpUshort4);
940: DbgPrint("IBMTOK: Offsets: SRB %x SSB %x ARB %x ASB %x\n",
941: IBMSHORT_TO_USHORT(TmpUshort1),
942: IBMSHORT_TO_USHORT(TmpUshort2),
943: IBMSHORT_TO_USHORT(TmpUshort3),
944: IBMSHORT_TO_USHORT(TmpUshort4));
945: }
946: #endif
947:
948: //
949: // Now we have to start worrying about synchronization.
950: //
951:
952: NdisDprAcquireSpinLock(&(Adapter->Lock));
953:
954: Adapter->CurrentRingState = NdisRingStateOpened;
955: Adapter->OpenInProgress = FALSE;
956: Adapter->OpenErrorCode = 0;
957: Adapter->AdapterNotOpen = FALSE;
958: Adapter->NotAcceptingRequests = FALSE;
959:
960: //
961: // Complete all opens that pended during this operation.
962: //
963:
964: CurrentLink = Adapter->OpenBindings.Flink;
965:
966: while (CurrentLink != &(Adapter->OpenBindings)){
967:
968: Open = CONTAINING_RECORD(
969: CurrentLink,
970: IBMTOK_OPEN,
971: OpenList
972: );
973:
974: if (Open->OpenPending) {
975:
976: Open->OpenPending = FALSE;
977: NdisDprReleaseSpinLock(&(Adapter->Lock));
978:
979: NdisCompleteOpenAdapter(
980: Open->NdisBindingContext,
981: NDIS_STATUS_SUCCESS,
982: 0
983: );
984:
985: NdisDprAcquireSpinLock(&(Adapter->Lock));
986:
987: }
988:
989: CurrentLink = CurrentLink->Flink;
990:
991: }
992:
993: //
994: // Get any interrupts that have been deferred
995: // while NotAcceptingRequests was TRUE.
996: //
997: IbmtokForceAdapterInterrupt(Adapter);
998:
999: } else {
1000:
1001: //
1002: // Open Failed!
1003: //
1004:
1005: //
1006: // Now we have to start worrying about synchronization.
1007: //
1008:
1009: Adapter->CurrentRingState = NdisRingStateOpenFailure;
1010: Adapter->OpenInProgress = FALSE;
1011: NdisReadRegisterUshort(&(OpenResponseSrb->ErrorCode),
1012: &(Adapter->OpenErrorCode)
1013: );
1014: Adapter->OpenErrorCode = IBMSHORT_TO_USHORT(Adapter->OpenErrorCode);
1015: Adapter->AdapterNotOpen = TRUE;
1016: Adapter->NotAcceptingRequests = TRUE;
1017:
1018: //
1019: // Fail all opens that pended during this operation.
1020: //
1021:
1022: CurrentLink = Adapter->OpenBindings.Flink;
1023:
1024: while (CurrentLink != &(Adapter->OpenBindings)){
1025:
1026: Open = CONTAINING_RECORD(
1027: CurrentLink,
1028: IBMTOK_OPEN,
1029: OpenList
1030: );
1031:
1032:
1033: if (Open->OpenPending) {
1034:
1035: Open->OpenPending = FALSE;
1036:
1037: NdisDprReleaseSpinLock(&(Adapter->Lock));
1038:
1039: NdisCompleteOpenAdapter(
1040: Open->NdisBindingContext,
1041: NDIS_STATUS_OPEN_FAILED,
1042: NDIS_STATUS_TOKEN_RING_OPEN_ERROR |
1043: (NDIS_STATUS)(Adapter->OpenErrorCode)
1044: );
1045:
1046: NdisDprAcquireSpinLock(&(Adapter->Lock));
1047:
1048: CurrentLink = CurrentLink->Flink;
1049:
1050: RemoveEntryList(&(Open->OpenList));
1051:
1052: IBMTOK_FREE_PHYS(Open, sizeof(IBMTOK_OPEN));
1053:
1054: Adapter->References--;
1055:
1056: } else {
1057:
1058: //
1059: // Note: All opens are pending, otherwise the
1060: // adapter would have already been open.
1061: //
1062:
1063: }
1064:
1065: }
1066:
1067: }
1068:
1069: } else {
1070:
1071: #if DBG
1072: if (IbmtokDbg) DbgPrint("IBMTOK: SRB Response\n");
1073: #endif
1074:
1075: IF_LOG('>');
1076:
1077: if (Adapter->TransmittingPacket != (PNDIS_PACKET)NULL) {
1078:
1079: BOOLEAN PacketRemoved;
1080:
1081: //
1082: // Happens if the transmit failed.
1083: //
1084:
1085: (PVOID)RemoveTransmitFromSrb(Adapter, &PacketRemoved);
1086:
1087: //
1088: // If the packet was successfully removed, then
1089: // start the next command.
1090: //
1091: // This will release the spin lock.
1092: //
1093:
1094: if (PacketRemoved) {
1095:
1096: //
1097: // SrbAvailable will still be FALSE here,
1098: // as required.
1099: //
1100:
1101: SetupSrbCommand(Adapter);
1102:
1103: }
1104:
1105: } else if (!Adapter->SrbAvailable) {
1106:
1107: PSRB_GENERIC GenericSrb = (PSRB_GENERIC)Adapter->SrbAddress;
1108: UCHAR ReturnCode;
1109:
1110: //
1111: // Another command in progress, complete it unless
1112: // it was an INTERRUPT command.
1113: //
1114:
1115: NdisReadRegisterUchar(&(GenericSrb->ReturnCode), &ReturnCode);
1116:
1117: IF_LOG('N');
1118:
1119: NdisReadRegisterUchar(&(GenericSrb->Command), &TmpUchar);
1120:
1121: if (TmpUchar != SRB_CMD_INTERRUPT) {
1122:
1123: if ((TmpUchar != SRB_CMD_READ_LOG) &&
1124: (TmpUchar != SRB_CMD_SET_FUNCTIONAL_ADDRESS) &&
1125: (TmpUchar != SRB_CMD_SET_GROUP_ADDRESS) &&
1126: (TmpUchar != SRB_CMD_DLC_STATISTICS)) {
1127:
1128: //
1129: // We have an invalid response. Log an error an exit.
1130: //
1131:
1132: NdisWriteErrorLogEntry(
1133: Adapter->NdisAdapterHandle,
1134: NDIS_ERROR_CODE_INVALID_VALUE_FROM_ADAPTER,
1135: 3,
1136: handleSrbSsb,
1137: IBMTOK_ERRMSG_INVALID_CMD,
1138: (ULONG)TmpUchar
1139: );
1140:
1141: } else {
1142:
1143: //
1144: // This interrupt had to come from a pended op.
1145: //
1146:
1147: ASSERT(Adapter->PendData != NULL);
1148:
1149: if (Adapter->PendData->RequestType == NdisRequestGeneric1){
1150:
1151: //
1152: // If no request, it came as a result of the
1153: // card overflowing a counter and then we
1154: // submitted the correcting operation.
1155: //
1156:
1157: if (ReturnCode == 0x00) {
1158:
1159: if (Adapter->PendData->COMMAND.MAC.ReadLogPending){
1160:
1161: //
1162: // We are getting an SRB_CMD_READ_LOG from
1163: // we sent as a result to a RING_STATUS_CHANGE.
1164: //
1165:
1166: GetAdapterErrorsFromSrb(Adapter);
1167:
1168: } else {
1169:
1170: //
1171: // We are getting an SRB_CMD_DLC_STATISTICS from
1172: // we sent as a result to a DLC_STATUS.
1173: //
1174:
1175: GetAdapterStatisticsFromSrb(Adapter);
1176:
1177: }
1178:
1179: }
1180:
1181: //
1182: // Free up pend operation.
1183: //
1184:
1185: IBMTOK_FREE_PHYS(Adapter->PendData, sizeof(IBMTOK_PEND_DATA));
1186:
1187: Adapter->PendData = NULL;
1188:
1189: //
1190: // Fire off next command.
1191: //
1192:
1193: SetupSrbCommand(Adapter);
1194:
1195: } else {
1196:
1197: //
1198: // This is the result of a pending op from Ndis.
1199: //
1200:
1201: if (FinishPendQueueOp(
1202: Adapter,
1203: (BOOLEAN)(ReturnCode == 0x00 ? TRUE : FALSE)
1204: )){
1205:
1206: //
1207: // Fire off next command.
1208: //
1209:
1210: SetupSrbCommand(Adapter);
1211:
1212: }
1213:
1214: }
1215:
1216: }
1217: } else {
1218:
1219: SetupSrbCommand(Adapter);
1220:
1221: }
1222:
1223: } else {
1224:
1225: //
1226: // Nothing to do -- we get here when an SRB_FREE_REQUEST
1227: // comes through after the ARB to transfer the data has
1228: // already come through.
1229: //
1230:
1231: }
1232:
1233: }
1234:
1235: }
1236:
1237: if (IsrpHigh & ISRP_HIGH_SSB_RESPONSE) {
1238:
1239: //
1240: // This has to be a transmit completing since
1241: // that is the only operation we do that pends.
1242: //
1243: PSSB_TRANSMIT_COMPLETE ResponseSsb =
1244: (PSSB_TRANSMIT_COMPLETE)Adapter->SsbAddress;
1245:
1246: NdisReadRegisterUchar(&(ResponseSsb->Command), &TmpUchar);
1247:
1248: if (TmpUchar == SRB_CMD_TRANSMIT_DIR_FRAME) {
1249:
1250: UCHAR CorrelatorInSrb;
1251: NDIS_STATUS SendStatus;
1252: UCHAR SrbReturnCode;
1253:
1254: //
1255: // Initialize this to one less since the loop starts by
1256: // incrementing it.
1257: //
1258:
1259: UCHAR CurrentCorrelator = (UCHAR)
1260: ((Adapter->NextCorrelatorToComplete +
1261: (MAX_COMMAND_CORRELATOR-1)) %
1262: MAX_COMMAND_CORRELATOR);
1263:
1264: NdisReadRegisterUchar(&(ResponseSsb->CommandCorrelator), &CorrelatorInSrb);
1265:
1266: //
1267: // Have to loop to complete since supposedly one
1268: // of these can indicate multiple completing sends.
1269: //
1270:
1271: //
1272: // Figure out what the return code should be.
1273: //
1274:
1275: NdisReadRegisterUchar(&(ResponseSsb->ReturnCode), &SrbReturnCode);
1276:
1277: if (SrbReturnCode == 0x00) {
1278:
1279: SendStatus = NDIS_STATUS_SUCCESS;
1280:
1281: } else if (SrbReturnCode == 0x22) {
1282:
1283: //
1284: // Check the frame status.
1285: //
1286: UCHAR FrameStatus;
1287: UCHAR HighAc;
1288: UCHAR LowAc;
1289:
1290: NdisReadRegisterUchar(&(ResponseSsb->ErrorFrameStatus), &FrameStatus);
1291: HighAc = GET_FRAME_STATUS_HIGH_AC(FrameStatus);
1292: LowAc = GET_FRAME_STATUS_LOW_AC(FrameStatus);
1293:
1294: if (HighAc != LowAc ||
1295: (HighAc != AC_NOT_RECOGNIZED)) {
1296:
1297: SendStatus = NDIS_STATUS_NOT_RECOGNIZED;
1298:
1299: } else {
1300:
1301: SendStatus = NDIS_STATUS_SUCCESS;
1302:
1303: }
1304:
1305: #if DBG
1306: if (IbmtokDbg) DbgPrint("IBMTOK: Send failed, code %x err %x\n",
1307: SrbReturnCode,
1308: FrameStatus);
1309: #endif
1310:
1311: } else {
1312:
1313: SendStatus = NDIS_STATUS_FAILURE;
1314:
1315: #if DBG
1316: if (IbmtokDbg) DbgPrint("IBMTOK: Send failed, code %x\n",
1317: SrbReturnCode);
1318: #endif
1319:
1320: }
1321:
1322: NdisDprReleaseSpinLock(&(Adapter->Lock));
1323:
1324: do {
1325:
1326: PNDIS_PACKET TransmitPacket;
1327: PIBMTOK_RESERVED Reserved;
1328: PIBMTOK_OPEN Open;
1329:
1330: CurrentCorrelator = (UCHAR)((CurrentCorrelator + 1) %
1331: MAX_COMMAND_CORRELATOR);
1332:
1333: //
1334: // Complete the transmit.
1335: //
1336:
1337: TransmitPacket =
1338: FindPacketGivenCorrelator(Adapter, CurrentCorrelator);
1339:
1340: if (TransmitPacket == (PNDIS_PACKET)NULL) {
1341:
1342: #if DBG
1343: if (IbmtokDbg) DbgPrint("IBMTOK: Missing %d to complete, %d to %d\n",
1344: CurrentCorrelator,
1345: Adapter->NextCorrelatorToComplete,
1346: CorrelatorInSrb);
1347: #endif
1348:
1349: continue;
1350:
1351: }
1352:
1353: RemovePacketFromCorrelatorArray(Adapter, TransmitPacket);
1354:
1355: Reserved = PIBMTOK_RESERVED_FROM_PACKET(TransmitPacket);
1356:
1357: Open =
1358: PIBMTOK_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle);
1359:
1360: //
1361: // If doing LOOPBACK, this should really be a check
1362: // of ReadyToComplete etc.
1363: //
1364:
1365: #ifdef CHECK_DUP_SENDS
1366: {
1367: VOID IbmtokRemovePacketFromList(PIBMTOK_ADAPTER, PNDIS_PACKET);
1368: IbmtokRemovePacketFromList(Adapter, TransmitPacket);
1369: }
1370: #endif
1371:
1372: if (SendStatus == NDIS_STATUS_SUCCESS) {
1373: Adapter->FramesTransmitted++;
1374: } else {
1375: Adapter->FrameTransmitErrors++;
1376: }
1377:
1378: NdisCompleteSend(
1379: Open->NdisBindingContext,
1380: Reserved->Packet,
1381: SendStatus
1382: );
1383:
1384:
1385: //
1386: // Decrement the reference count for the open.
1387: //
1388:
1389: #if DBG
1390: NdisDprAcquireSpinLock(&(Adapter->Lock));
1391: IF_LOG('C');
1392: NdisDprReleaseSpinLock(&(Adapter->Lock));
1393: #endif
1394:
1395: NdisInterlockedAddUlong((PULONG)&Open->References, (UINT)-1, &Adapter->Lock);
1396:
1397:
1398:
1399: } while (CurrentCorrelator != CorrelatorInSrb);
1400:
1401: NdisDprAcquireSpinLock(&(Adapter->Lock));
1402:
1403: Adapter->NextCorrelatorToComplete =
1404: (UCHAR)((CurrentCorrelator + 1) % MAX_COMMAND_CORRELATOR);
1405:
1406:
1407: //
1408: // We know that SrbAvailable is FALSE...
1409: //
1410:
1411: IF_LOG('<');
1412:
1413: SetupSrbCommand(Adapter);
1414:
1415: } else {
1416:
1417: //
1418: // Nothing else should pend!!
1419: //
1420:
1421: NdisWriteErrorLogEntry(
1422: Adapter->NdisAdapterHandle,
1423: NDIS_ERROR_CODE_INVALID_VALUE_FROM_ADAPTER,
1424: 3,
1425: handleSrbSsb,
1426: IBMTOK_ERRMSG_INVALID_CMD,
1427: (ULONG)TmpUchar
1428: );
1429:
1430: #if DBG
1431: if (IbmtokDbg) DbgPrint("IBMTOK: Error! Got Cmd %x\n",TmpUchar);
1432: #endif
1433:
1434: }
1435:
1436: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
1437: ISRA_HIGH_SSB_FREE);
1438:
1439: }
1440:
1441: GET_SRB_SSB_BITS(Adapter, &IsrpHigh);
1442:
1443: }
1444:
1445: Adapter->HandleSrbRunning = FALSE;
1446:
1447: IF_LOG('H');
1448:
1449: //
1450: // This macro assumes it is called with the lock held,
1451: // and releases it.
1452: //
1453: IBMTOK_DO_DEFERRED(Adapter);
1454:
1455: }
1456:
1457: extern
1458: VOID
1459: IbmtokHandleArbAsb(
1460: IN PIBMTOK_ADAPTER Adapter
1461: )
1462:
1463: /*++
1464:
1465: Routine Description:
1466:
1467: This routine is called by the DPC
1468: and other routines within the driver that notice that
1469: some deferred processing needs to be done. It's main
1470: job is to call the interrupt processing code.
1471:
1472: NOTE: THIS ROUTINE IS CALLED WITH THE LOCK HELD!! AND RETURNS WITH
1473: THE LOCK REALEASED!!
1474:
1475: Arguments:
1476:
1477: Adapter - A pointer to the adapter.
1478:
1479: Return Value:
1480:
1481: None.
1482:
1483: --*/
1484:
1485: {
1486: UCHAR IsrpHigh;
1487:
1488: PARB_TRANSMIT_DATA_REQUEST TransmitDataArb;
1489:
1490: PARB_RECEIVED_DATA ReceivedDataArb;
1491:
1492: PNDIS_PACKET TransmitPacket;
1493:
1494: SRAM_PTR ReceiveBufferPointer;
1495:
1496: PRECEIVE_BUFFER ReceiveBuffer;
1497:
1498: UINT PacketLength, DummyBytesCopied;
1499:
1500: BOOLEAN FreedSrb;
1501:
1502: PIBMTOK_RESERVED Reserved;
1503:
1504: PUCHAR DhbAddress;
1505:
1506: UINT PacketSize, LookaheadSize;
1507:
1508: PUCHAR FrameData;
1509:
1510: ULONG HeaderLength;
1511:
1512: UCHAR TmpUchar;
1513:
1514: USHORT TmpUshort;
1515:
1516: PUCHAR LookaheadBuffer;
1517:
1518: Adapter->References++;
1519:
1520: Adapter->HandleArbRunning = TRUE;
1521:
1522: IF_LOG('j');
1523:
1524: GET_ARB_ASB_BITS(Adapter, &IsrpHigh);
1525:
1526: while (IsrpHigh & (ISRP_HIGH_ARB_COMMAND | ISRP_HIGH_ASB_FREE)) {
1527:
1528: if (IsrpHigh & ISRP_HIGH_ARB_COMMAND) {
1529:
1530: NdisReadRegisterUchar(&((PARB_GENERIC)Adapter->ArbAddress)->Command, &TmpUchar);
1531:
1532: switch (TmpUchar) {
1533:
1534: case ARB_CMD_DLC_STATUS:
1535:
1536: #if DBG
1537: if (IbmtokDbg) {
1538: NdisReadRegisterUshort(&
1539: ((PARB_DLC_STATUS)Adapter->ArbAddress)->Status, &TmpUshort);
1540: DbgPrint("IBMTOK: DLC Status %x\n",
1541: IBMSHORT_TO_USHORT(TmpUshort));
1542: }
1543: #endif
1544:
1545:
1546:
1547: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
1548: ISRA_HIGH_ARB_FREE);
1549:
1550: IF_LOG('#');
1551:
1552: //
1553: // If it is a counter overflow, we need to queue a
1554: // DLC.STATISTICS command.
1555: //
1556:
1557: NdisReadRegisterUshort(&
1558: ((PARB_RING_STATUS_CHANGE)Adapter->ArbAddress)->
1559: NetworkStatus, &TmpUshort);
1560:
1561: if (IBMSHORT_TO_USHORT(TmpUshort) & 0x0040 ) {
1562: //
1563: // Build a pending operation. It will get run ASAP
1564: // by ProcessSrbCommand.
1565: //
1566:
1567: PIBMTOK_PEND_DATA PendOp;
1568:
1569: if (IBMTOK_ALLOC_PHYS(&PendOp,sizeof(IBMTOK_PEND_DATA)) !=
1570: NDIS_STATUS_SUCCESS){
1571:
1572: NdisWriteErrorLogEntry(
1573: Adapter->NdisAdapterHandle,
1574: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
1575: 2,
1576: handleSrbSsb,
1577: IBMTOK_ERRMSG_ALLOC_MEM
1578: );
1579:
1580: break;
1581:
1582: }
1583:
1584: PendOp->Next = NULL;
1585: PendOp->RequestType = NdisRequestGeneric1;
1586: PendOp->COMMAND.MAC.ReadLogPending = FALSE;
1587:
1588: if (Adapter->PendQueue == NULL){
1589:
1590: Adapter->PendQueue = Adapter->EndOfPendQueue = PendOp;
1591:
1592: } else {
1593:
1594: //
1595: // Put this operation on the front, so it can
1596: // correct the error quickly.
1597: //
1598:
1599: PendOp->Next = Adapter->PendQueue;
1600: Adapter->PendQueue = PendOp;
1601:
1602: }
1603:
1604: //
1605: // It is now in the pend
1606: // queue so we should start that up.
1607: //
1608:
1609: IbmtokProcessSrbRequests(Adapter);
1610:
1611: }
1612:
1613: break;
1614:
1615: case ARB_CMD_RECEIVED_DATA:
1616:
1617: #if DBG
1618: if (IbmtokDbg) DbgPrint("IBMTOK: Received data\n");
1619: #endif
1620: IF_LOG('r');
1621:
1622: if (Adapter->Unplugged && !Adapter->UnpluggedResetInProgress) {
1623:
1624: //
1625: // Do, nothing. This is most likely a stale interrupt. We
1626: // wait until we get a ring status interrupt telling us that
1627: // the cable is plugged in.
1628: //
1629:
1630: break;
1631:
1632: }
1633:
1634: ReceivedDataArb =
1635: (PARB_RECEIVED_DATA)Adapter->ArbAddress;
1636:
1637: NdisReadRegisterUshort(&(ReceivedDataArb->ReceiveBuffer), &ReceiveBufferPointer);
1638:
1639: //
1640: // Prepare for indication.
1641: //
1642:
1643: Adapter->IndicatedReceiveBuffer = ReceiveBufferPointer;
1644:
1645: ReceiveBuffer = (PRECEIVE_BUFFER)
1646: ((PUCHAR)SRAM_PTR_TO_PVOID(Adapter, ReceiveBufferPointer) + 2);
1647:
1648: NdisReadRegisterUshort(&(ReceivedDataArb->FrameLength), &PacketSize);
1649:
1650: PacketSize = IBMSHORT_TO_USHORT(PacketSize);
1651:
1652:
1653: NdisReadRegisterUshort(&(ReceiveBuffer->BufferLength), &LookaheadSize);
1654:
1655: LookaheadSize = IBMSHORT_TO_USHORT(LookaheadSize);
1656:
1657:
1658: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
1659: ISRA_HIGH_ARB_FREE);
1660:
1661: #if DBG
1662: if (IbmtokDbg) DbgPrint("IBMTOK: indicate len %d, lookahead %d\n",
1663: PacketSize, LookaheadSize);
1664: #endif
1665:
1666: //
1667: // Calculate how big the header is for this
1668: // packet.
1669: //
1670:
1671: FrameData = ReceiveBuffer->FrameData;
1672:
1673: NdisReadRegisterUchar(&FrameData[8], &TmpUchar);
1674:
1675: if (TmpUchar & 0x80) {
1676:
1677: //
1678: // Source routing bit is on in source address.
1679: //
1680:
1681: NdisReadRegisterUchar(&FrameData[14], &TmpUchar);
1682: HeaderLength = (TmpUchar & 0x1f) + 14;
1683:
1684: } else {
1685:
1686: HeaderLength = 14;
1687:
1688: }
1689:
1690: Adapter->IndicatedHeaderLength = (USHORT)HeaderLength;
1691:
1692: Adapter->FramesReceived++;
1693:
1694: NdisDprReleaseSpinLock(&Adapter->Lock);
1695:
1696: //
1697: // Call into the filter package to do the
1698: // indication.
1699: //
1700:
1701: if (LookaheadSize < HeaderLength) {
1702:
1703: //
1704: // Must at least have an address
1705: //
1706:
1707: if (LookaheadSize >= TR_LENGTH_OF_ADDRESS) {
1708:
1709: NdisCreateLookaheadBufferFromSharedMemory(
1710: (PVOID)FrameData,
1711: LookaheadSize,
1712: &LookaheadBuffer
1713: );
1714:
1715: if (LookaheadBuffer != NULL) {
1716:
1717: //
1718: // Runt Packet
1719: //
1720:
1721: TrFilterIndicateReceive(
1722: Adapter->FilterDB,
1723: (NDIS_HANDLE)ReceiveBuffer, // context
1724: LookaheadBuffer, // header
1725: LookaheadSize, // header length
1726: NULL, // lookahead
1727: 0, // lookahead length
1728: 0
1729: );
1730:
1731: NdisDestroyLookaheadBufferFromSharedMemory(
1732: LookaheadBuffer
1733: );
1734:
1735: }
1736:
1737: }
1738:
1739: } else {
1740:
1741: NdisCreateLookaheadBufferFromSharedMemory(
1742: (PVOID)FrameData,
1743: LookaheadSize,
1744: &LookaheadBuffer
1745: );
1746:
1747: if (LookaheadBuffer != NULL) {
1748:
1749: TrFilterIndicateReceive(
1750: Adapter->FilterDB,
1751: (NDIS_HANDLE)ReceiveBuffer, // context
1752: LookaheadBuffer, // header
1753: HeaderLength, // header length
1754: LookaheadBuffer + HeaderLength, // lookahead
1755: LookaheadSize - HeaderLength, // lookahead length
1756: PacketSize - HeaderLength
1757: );
1758:
1759: NdisDestroyLookaheadBufferFromSharedMemory(
1760: LookaheadBuffer
1761: );
1762:
1763: }
1764:
1765: }
1766:
1767: TrFilterIndicateReceiveComplete( Adapter->FilterDB );
1768:
1769: //
1770: // Now worry about the ASB.
1771: //
1772:
1773: NdisDprAcquireSpinLock(&(Adapter->Lock));
1774:
1775: //
1776: // Set response in ASB, if possible, else queue the response
1777: //
1778:
1779: if (Adapter->AsbAvailable){
1780:
1781: Adapter->AsbAvailable = FALSE;
1782:
1783: Adapter->UseNextAsbForReceive = FALSE;
1784:
1785: SetupReceivedDataAsb(Adapter, ReceiveBufferPointer);
1786: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
1787: ISRA_HIGH_RESPONSE_IN_ASB);
1788:
1789: //
1790: // LOOPBACK HERE!!
1791: //
1792:
1793: } else {
1794:
1795: #if DBG
1796: if (IbmtokDbg) DbgPrint("W_ASB R\n");
1797: #endif
1798:
1799: if (Adapter->ReceiveWaitingForAsbEnd == (USHORT)(-1)){
1800:
1801: Adapter->ReceiveWaitingForAsbList = ReceiveBufferPointer;
1802:
1803: } else {
1804:
1805: PVOID PEnd;
1806:
1807: PEnd = SRAM_PTR_TO_PVOID(
1808: Adapter,
1809: Adapter->ReceiveWaitingForAsbEnd
1810: );
1811:
1812: NdisWriteRegisterUshort(PEnd, ReceiveBufferPointer);
1813:
1814: }
1815:
1816: Adapter->ReceiveWaitingForAsbEnd = ReceiveBufferPointer;
1817:
1818: if (!(Adapter->OutstandingAsbFreeRequest)){
1819:
1820: Adapter->OutstandingAsbFreeRequest = TRUE;
1821:
1822: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
1823: ISRA_HIGH_ASB_FREE_REQUEST);
1824:
1825: IF_LOG('a');
1826:
1827: }
1828:
1829: }
1830:
1831: break;
1832:
1833: case ARB_CMD_RING_STATUS_CHANGE:
1834:
1835: {
1836: USHORT RingStatus;
1837: NDIS_STATUS NotifyStatus = 0;
1838:
1839: NdisReadRegisterUshort(&
1840: ((PARB_RING_STATUS_CHANGE)Adapter->ArbAddress)->NetworkStatus,
1841: &RingStatus);
1842:
1843: RingStatus = IBMSHORT_TO_USHORT(RingStatus);
1844:
1845: #if DBG
1846: if (IbmtokDbg)
1847: DbgPrint("IBMTOK: Ring Status %x\n", RingStatus);
1848: #endif
1849:
1850:
1851: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
1852: ISRA_HIGH_ARB_FREE);
1853:
1854: //
1855: // If it is a counter overflow, we need to queue a
1856: // DIR.READ.LOG command.
1857: //
1858:
1859: if (RingStatus & 0x0080) {
1860:
1861: //
1862: // Build a pending operation. It will get run ASAP
1863: // by ProcessSrbCommand.
1864: //
1865:
1866: PIBMTOK_PEND_DATA PendOp;
1867:
1868: if (IBMTOK_ALLOC_PHYS(&PendOp,sizeof(IBMTOK_PEND_DATA)) !=
1869: NDIS_STATUS_SUCCESS){
1870:
1871: NdisWriteErrorLogEntry(
1872: Adapter->NdisAdapterHandle,
1873: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
1874: 2,
1875: handleSrbSsb,
1876: IBMTOK_ERRMSG_ALLOC_MEM
1877: );
1878:
1879: break;
1880:
1881: }
1882:
1883: PendOp->Next = NULL;
1884: PendOp->RequestType = NdisRequestGeneric1;
1885: PendOp->COMMAND.MAC.ReadLogPending = TRUE;
1886:
1887: if (Adapter->PendQueue == NULL){
1888:
1889: Adapter->PendQueue = Adapter->EndOfPendQueue = PendOp;
1890:
1891: } else {
1892:
1893: //
1894: // Put this operation on the front, so it can
1895: // correct the error quickly.
1896: //
1897:
1898: PendOp->Next = Adapter->PendQueue;
1899: Adapter->PendQueue = PendOp;
1900:
1901: }
1902:
1903: //
1904: // It is now in the pend
1905: // queue so we should start that up.
1906: // Returns with lock released
1907: //
1908:
1909: IbmtokProcessSrbRequests(Adapter);
1910:
1911: }
1912:
1913: if (RingStatus & 0x0020) { // Ring Recovery
1914: NotifyStatus |= NDIS_RING_RING_RECOVERY;
1915: }
1916:
1917: if (RingStatus & 0x0040) { // Single Station
1918: NotifyStatus |= NDIS_RING_SINGLE_STATION;
1919: }
1920:
1921: if (RingStatus & 0x0080) { // Counter Overflow
1922: NotifyStatus |= NDIS_RING_COUNTER_OVERFLOW;
1923: }
1924:
1925: if (RingStatus & 0x0100) { // Remove received
1926: NotifyStatus |= NDIS_RING_REMOVE_RECEIVED;
1927: }
1928:
1929: if (RingStatus & 0x0400) { // Auto-removal
1930: NotifyStatus |= NDIS_RING_AUTO_REMOVAL_ERROR;
1931: }
1932:
1933: if (RingStatus & 0x0800) { // Lobe wire fault
1934: NotifyStatus |= NDIS_RING_LOBE_WIRE_FAULT;
1935: }
1936:
1937: if (RingStatus & 0x1000) { // Transmit Beacon
1938: NotifyStatus |= NDIS_RING_TRANSMIT_BEACON;
1939: }
1940:
1941: if (RingStatus & 0x2000) { // Soft error
1942: NotifyStatus |= NDIS_RING_SOFT_ERROR;
1943: }
1944:
1945: if (RingStatus & 0x4000) { // Hard error
1946: NotifyStatus |= NDIS_RING_HARD_ERROR;
1947: }
1948:
1949: if (RingStatus & 0x8000) { // Signal loss
1950: NotifyStatus |= NDIS_RING_SIGNAL_LOSS;
1951: }
1952:
1953: if (NotifyStatus != 0) {
1954:
1955: PLIST_ENTRY CurrentLink;
1956: PIBMTOK_OPEN TempOpen;
1957:
1958: //
1959: // Indicate Status to all opens
1960: //
1961:
1962: CurrentLink = Adapter->OpenBindings.Flink;
1963:
1964: while (CurrentLink != &(Adapter->OpenBindings)){
1965:
1966: TempOpen = CONTAINING_RECORD(
1967: CurrentLink,
1968: IBMTOK_OPEN,
1969: OpenList
1970: );
1971:
1972: TempOpen->References++;
1973:
1974: NdisDprReleaseSpinLock(&Adapter->Lock);
1975:
1976: NdisIndicateStatus(TempOpen->NdisBindingContext,
1977: NDIS_STATUS_RING_STATUS,
1978: (PVOID)&NotifyStatus,
1979: sizeof(NotifyStatus)
1980: );
1981:
1982: NdisIndicateStatusComplete(TempOpen->NdisBindingContext);
1983:
1984: NdisDprAcquireSpinLock(&Adapter->Lock);
1985:
1986: CurrentLink = CurrentLink->Flink;
1987:
1988: TempOpen->References--;
1989:
1990: }
1991:
1992: Adapter->LastNotifyStatus = NotifyStatus;
1993:
1994: }
1995:
1996: //
1997: // Handle a cable being unplugged
1998: //
1999:
2000: if ((RingStatus & 0x5000) == 0x5000) { // receive and transmit beacon
2001:
2002: //
2003: // Ok, the cable has been unplugged. We now abort all
2004: // outstanding sends, etc.
2005: //
2006:
2007: Adapter->Unplugged = TRUE;
2008:
2009: IbmtokAbortPending(Adapter, NDIS_STATUS_DEVICE_FAILED);
2010:
2011: if ((RingStatus & 0x800) == 0x800) {
2012: Adapter->LobeWireFaultIndicated = TRUE;
2013: }
2014:
2015: } else if ((RingStatus & 0x0020) &&
2016: !(RingStatus & 0x4000) &&
2017: (Adapter->Unplugged) &&
2018: (!Adapter->UnpluggedResetInProgress)) {
2019:
2020: //
2021: // Reset the adapter to remove all stale information
2022: //
2023:
2024: Adapter->UnpluggedResetInProgress = TRUE;
2025:
2026: IbmtokSetupForReset(Adapter, NULL);
2027:
2028: IbmtokHandleDeferred(Adapter);
2029:
2030: }
2031:
2032: }
2033:
2034: break;
2035:
2036: case ARB_CMD_TRANSMIT_DATA_REQUEST:
2037:
2038: #if DBG
2039: if (IbmtokDbg) DbgPrint("IBMTOK: Transmit data\n");
2040: #endif
2041:
2042: if (Adapter->Unplugged && !Adapter->UnpluggedResetInProgress) {
2043:
2044: //
2045: // Do, nothing. This is most likely a stale interrupt. We
2046: // wait until we get a ring status interrupt telling us that
2047: // the cable is plugged in.
2048: //
2049:
2050: break;
2051:
2052: }
2053:
2054: TransmitDataArb =
2055: (PARB_TRANSMIT_DATA_REQUEST)Adapter->ArbAddress;
2056:
2057: //
2058: // First see if we have to assign the command correlator.
2059: //
2060:
2061: NdisReadRegisterUchar(&(TransmitDataArb->CommandCorrelator), &TmpUchar);
2062:
2063: TransmitPacket = FindPacketGivenCorrelator(Adapter, TmpUchar);
2064:
2065: if (TransmitPacket == NULL) {
2066:
2067: BOOLEAN PacketRemoved;
2068:
2069: //
2070: // Have to take the correlator out of the SRB
2071: // ourselves. This means that the SRB must still
2072: // be occupied by the request for this transmit.
2073: //
2074:
2075: ASSERT((!Adapter->SrbAvailable) &&
2076: (Adapter->TransmittingPacket != (PNDIS_PACKET)NULL));
2077:
2078: FreedSrb = FALSE;
2079:
2080: //
2081: // This call will remove the packet from the SRB.
2082: //
2083:
2084: TransmitPacket =
2085: RemoveTransmitFromSrb(Adapter, &PacketRemoved);
2086:
2087: //
2088: // This will be NULL if there was an error in
2089: // the transmit command, but in that case why
2090: // are we getting this ARB request?? Just exit.
2091: // The WakeUpDpc will reset the card if it is hosed.
2092: //
2093:
2094: if ((TransmitPacket == (PNDIS_PACKET)NULL) || !PacketRemoved) {
2095:
2096: break;
2097:
2098: }
2099:
2100: } else {
2101:
2102: FreedSrb = FALSE;
2103:
2104: Reserved =
2105: PIBMTOK_RESERVED_FROM_PACKET(TransmitPacket);
2106:
2107: }
2108:
2109: NdisDprReleaseSpinLock(&(Adapter->Lock));
2110:
2111: //
2112: // Fill in the AC and FC bytes.
2113: //
2114:
2115: NdisReadRegisterUshort(&(TransmitDataArb->DhbPointer), &TmpUshort);
2116:
2117: DhbAddress = (PUCHAR)SRAM_PTR_TO_PVOID(Adapter,TmpUshort);
2118:
2119: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2120: ISRA_HIGH_ARB_FREE);
2121:
2122:
2123: //
2124: // Now copy the data down from TransmitPacket.
2125: //
2126:
2127: NdisQueryPacket(
2128: TransmitPacket,
2129: NULL,
2130: NULL,
2131: NULL,
2132: &PacketLength
2133: );
2134:
2135: IbmtokCopyFromPacketToBuffer(
2136: TransmitPacket,
2137: 0,
2138: PacketLength,
2139: (PCHAR)DhbAddress,
2140: &DummyBytesCopied
2141: );
2142:
2143:
2144: //
2145: // Now worry about the ASB.
2146: //
2147:
2148: NdisDprAcquireSpinLock(&(Adapter->Lock));
2149:
2150: IF_LOG('c');
2151:
2152: //
2153: // Set response in ASB, if available, else queue response
2154: //
2155:
2156: if (Adapter->AsbAvailable){
2157:
2158: Adapter->AsbAvailable = FALSE;
2159:
2160: Adapter->UseNextAsbForReceive = TRUE;
2161:
2162: SetupTransmitStatusAsb(Adapter, TransmitPacket);
2163: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2164: ISRA_HIGH_RESPONSE_IN_ASB);
2165:
2166: //
2167: // LOOPBACK HERE!!
2168: //
2169:
2170: } else {
2171:
2172: #if DBG
2173: if (IbmtokDbg) DbgPrint("W_ASB T\n");
2174: #endif
2175:
2176: PutPacketOnWaitingForAsb(Adapter, TransmitPacket);
2177:
2178: if (!(Adapter->OutstandingAsbFreeRequest)){
2179:
2180: Adapter->OutstandingAsbFreeRequest = TRUE;
2181:
2182: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2183: ISRA_HIGH_ASB_FREE_REQUEST);
2184:
2185: IF_LOG('a');
2186: }
2187:
2188: //
2189: // FINAL RETURNCODE CHECK HERE!
2190: //
2191:
2192: }
2193:
2194:
2195: //
2196: // If we freed up the SRB, queue the next command
2197: // if there is one.
2198: // Returns with lock released
2199: //
2200:
2201: if (FreedSrb) {
2202:
2203: IbmtokProcessSrbRequests(Adapter);
2204:
2205: }
2206:
2207: break;
2208:
2209: default:
2210:
2211: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2212: ISRA_HIGH_ARB_FREE);
2213: break;
2214:
2215: }
2216:
2217: }
2218:
2219: if (IsrpHigh & ISRP_HIGH_ASB_FREE) {
2220: BOOLEAN ReceiveNeedsAsb = FALSE;
2221: BOOLEAN TransmitNeedsAsb = FALSE;
2222:
2223: //
2224: // Check whether we have stuff to do.
2225: //
2226:
2227: IF_LOG('A');
2228:
2229: if (Adapter->Unplugged && !Adapter->UnpluggedResetInProgress) {
2230:
2231: //
2232: // Do, nothing. This is most likely a stale interrupt. We
2233: // wait until we get a ring status interrupt telling us that
2234: // the cable is plugged in.
2235: //
2236:
2237: break;
2238:
2239: }
2240:
2241: ASSERT(Adapter->AsbAvailable == FALSE);
2242:
2243: ASSERT(Adapter->OutstandingAsbFreeRequest == TRUE);
2244:
2245: if (Adapter->ReceiveWaitingForAsbList != (USHORT)-1) {
2246:
2247: ReceiveNeedsAsb = TRUE;
2248:
2249: }
2250:
2251: if (Adapter->FirstWaitingForAsb != NULL) {
2252:
2253: TransmitNeedsAsb = TRUE;
2254:
2255: }
2256:
2257: if (ReceiveNeedsAsb &&
2258: (!TransmitNeedsAsb || Adapter->UseNextAsbForReceive)) {
2259:
2260: SRAM_PTR ReceiveBufferPointer;
2261: PVOID PFront;
2262:
2263: #if DBG
2264: if (IbmtokDbg) DbgPrint("ASB R\n");
2265: #endif
2266: IF_LOG('R');
2267:
2268: //
2269: // Save ReceiveWaitingForAsb so we can release
2270: // the spinlock.
2271: //
2272:
2273: ReceiveBufferPointer = Adapter->ReceiveWaitingForAsbList;
2274:
2275:
2276: if (Adapter->ReceiveWaitingForAsbList == Adapter->ReceiveWaitingForAsbEnd){
2277:
2278: Adapter->ReceiveWaitingForAsbList = (USHORT)-1;
2279:
2280: Adapter->ReceiveWaitingForAsbEnd = (USHORT)-1;
2281:
2282: } else {
2283:
2284: PFront = SRAM_PTR_TO_PVOID(Adapter,ReceiveBufferPointer);
2285:
2286: NdisReadRegisterUshort(((PUSHORT)PFront),
2287: &(Adapter->ReceiveWaitingForAsbList)
2288: );
2289:
2290: }
2291:
2292: Adapter->AsbAvailable = FALSE;
2293:
2294: Adapter->UseNextAsbForReceive = FALSE;
2295:
2296: //
2297: // Fill in the ASB and submit it.
2298: //
2299:
2300: SetupReceivedDataAsb(Adapter, ReceiveBufferPointer);
2301:
2302: if (TransmitNeedsAsb){
2303: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2304: ISRA_HIGH_RESPONSE_IN_ASB | ISRA_HIGH_ASB_FREE_REQUEST);
2305: } else {
2306: Adapter->OutstandingAsbFreeRequest = FALSE;
2307: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2308: ISRA_HIGH_RESPONSE_IN_ASB);
2309: }
2310:
2311: } else if (TransmitNeedsAsb) {
2312:
2313: PNDIS_PACKET AsbPacket = Adapter->FirstWaitingForAsb;
2314: PIBMTOK_RESERVED Reserved = PIBMTOK_RESERVED_FROM_PACKET(AsbPacket);
2315:
2316: #if DBG
2317: if (IbmtokDbg) DbgPrint("ASB T\n");
2318: #endif
2319: IF_LOG('T');
2320:
2321: //
2322: // Take the packet off of WaitingForAsb;
2323: //
2324:
2325: Adapter->FirstWaitingForAsb = Reserved->Next;
2326:
2327: Adapter->AsbAvailable = FALSE;
2328:
2329: Adapter->UseNextAsbForReceive = TRUE;
2330:
2331: //
2332: // Now fill in the ASB and fire it off.
2333: //
2334:
2335:
2336: SetupTransmitStatusAsb(Adapter, AsbPacket);
2337:
2338: if (ReceiveNeedsAsb || (Adapter->FirstWaitingForAsb != NULL)){
2339: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2340: ISRA_HIGH_RESPONSE_IN_ASB | ISRA_HIGH_ASB_FREE_REQUEST);
2341: } else {
2342: Adapter->OutstandingAsbFreeRequest = FALSE;
2343: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2344: ISRA_HIGH_RESPONSE_IN_ASB);
2345: }
2346:
2347: //
2348: // LOOPBACK HERE!!
2349: //
2350:
2351: } else {
2352:
2353: #if DBG
2354: if (IbmtokDbg) DbgPrint("ASB -\n");
2355: #endif
2356:
2357: Adapter->AsbAvailable = TRUE;
2358:
2359: }
2360:
2361: }
2362:
2363: GET_ARB_ASB_BITS(Adapter, &IsrpHigh);
2364:
2365: }
2366:
2367: Adapter->HandleArbRunning = FALSE;
2368:
2369: IF_LOG('J');
2370:
2371: //
2372: // This macro assumes it is called with the lock held,
2373: // and releases it.
2374: //
2375: IBMTOK_DO_DEFERRED(Adapter);
2376:
2377: }
2378:
2379: STATIC
2380: VOID
2381: CleanupResetFailure(
2382: IN PIBMTOK_ADAPTER Adapter,
2383: PNDIS_STATUS IndicateStatus,
2384: IN ULONG FailureCode,
2385: IN ULONG ResetStage
2386: )
2387:
2388: /*++
2389:
2390: Routine Description:
2391:
2392: Clean up if a reset fails partway through. Called
2393: from HandleResetStaging.
2394:
2395: Called with the lock held and returns with it held.
2396:
2397: Arguments:
2398:
2399: Adapter - The adapter that the reset is for.
2400:
2401: IndicateStatus - Status to indicate to the protocols, or NULL.
2402:
2403: FailureCode - A code to include in the error log.
2404:
2405: ResetStage - The stage of the reset where the failure occured.
2406:
2407: Return Value:
2408:
2409: None.
2410:
2411: --*/
2412:
2413: {
2414:
2415: PLIST_ENTRY CurrentLink;
2416: PIBMTOK_OPEN TempOpen;
2417:
2418: if (!Adapter->UnpluggedResetInProgress) {
2419:
2420: //
2421: // signal failure....
2422: //
2423: Adapter->CurrentRingState = NdisRingStateRingFailure;
2424:
2425: //
2426: // Indicate Status to all opens
2427: //
2428:
2429: CurrentLink = Adapter->OpenBindings.Flink;
2430:
2431: while (CurrentLink != &(Adapter->OpenBindings)){
2432:
2433: TempOpen = CONTAINING_RECORD(
2434: CurrentLink,
2435: IBMTOK_OPEN,
2436: OpenList
2437: );
2438:
2439: TempOpen->References++;
2440:
2441: NdisReleaseSpinLock(&Adapter->Lock);
2442:
2443: if (IndicateStatus) {
2444: NdisIndicateStatus(TempOpen->NdisBindingContext,
2445: NDIS_STATUS_CLOSED,
2446: IndicateStatus,
2447: sizeof(NDIS_STATUS)
2448: );
2449: } else {
2450: NdisIndicateStatus(TempOpen->NdisBindingContext,
2451: NDIS_STATUS_CLOSED,
2452: NULL,
2453: 0
2454: );
2455: }
2456:
2457: NdisIndicateStatusComplete(TempOpen->NdisBindingContext);
2458:
2459: NdisAcquireSpinLock(&Adapter->Lock);
2460:
2461: CurrentLink = CurrentLink->Flink;
2462:
2463: TempOpen->References--;
2464:
2465: }
2466:
2467: NdisWriteErrorLogEntry(
2468: Adapter->NdisAdapterHandle,
2469: NDIS_ERROR_CODE_HARDWARE_FAILURE,
2470: 4,
2471: handleResetStaging,
2472: IBMTOK_ERRMSG_BRINGUP_FAILURE,
2473: FailureCode,
2474: ResetStage
2475: );
2476:
2477: } else {
2478:
2479: //
2480: // Set this to false, we will try again later.
2481: //
2482:
2483: Adapter->LobeWireFaultIndicated = TRUE;
2484: Adapter->UnpluggedResetInProgress = FALSE;
2485:
2486: }
2487:
2488: //
2489: // Set Abort
2490: //
2491:
2492: Adapter->CurrentResetStage = 4;
2493:
2494: SetResetVariables(Adapter);
2495:
2496: Adapter->OpenInProgress = FALSE;
2497: Adapter->NotAcceptingRequests = TRUE;
2498:
2499: Adapter->ResetInProgress = FALSE;
2500: Adapter->ResetInterruptAllowed = FALSE;
2501: Adapter->ResetInterruptHasArrived = FALSE;
2502:
2503: if (Adapter->ResettingOpen != NULL) {
2504:
2505: PIBMTOK_OPEN Open = Adapter->ResettingOpen;
2506:
2507: //
2508: // Decrement the reference count that was incremented
2509: // in SetupForReset.
2510: //
2511:
2512: Open->References--;
2513:
2514: NdisReleaseSpinLock(&Adapter->Lock);
2515:
2516: NdisCompleteReset(
2517: Open->NdisBindingContext,
2518: NDIS_STATUS_FAILURE
2519: );
2520:
2521: NdisAcquireSpinLock(&Adapter->Lock);
2522:
2523: }
2524:
2525: }
2526:
2527: STATIC
2528: VOID
2529: HandleResetStaging(
2530: IN PIBMTOK_ADAPTER Adapter
2531: )
2532:
2533: /*++
2534:
2535: Routine Description:
2536:
2537: Handles the next stage of the transmit interrupt,
2538: knowing that an SRB interrupt just came through.
2539:
2540: Called with the lock held and returns with it held.
2541:
2542: Arguments:
2543:
2544: Adapter - The adapter that the reset is for.
2545:
2546: Return Value:
2547:
2548: None.
2549:
2550: --*/
2551:
2552: {
2553: USHORT TmpUshort;
2554: #if DBG
2555: UCHAR TmpUchar;
2556: #endif
2557:
2558: switch (Adapter->CurrentResetStage) {
2559:
2560: case 1: {
2561:
2562: //
2563: // The adapter just finished being reset.
2564: //
2565:
2566: USHORT WrbOffset;
2567: PSRB_BRING_UP_RESULT BringUpSrb;
2568: PSRB_OPEN_ADAPTER OpenSrb;
2569: UCHAR Value1, Value2;
2570:
2571: #if DBG
2572: if (IbmtokDbg) DbgPrint("IBMTOK: RESET done\n");
2573: #endif
2574:
2575: READ_ADAPTER_REGISTER(Adapter, WRBR_LOW, &Value1);
2576: READ_ADAPTER_REGISTER(Adapter, WRBR_HIGH, &Value2);
2577:
2578: WrbOffset = (USHORT)
2579: (((USHORT)Value1) << 8) +
2580: (USHORT)Value2;
2581:
2582: Adapter->InitialWrbOffset = WrbOffset;
2583:
2584: BringUpSrb = (PSRB_BRING_UP_RESULT)
2585: (Adapter->SharedRam + WrbOffset);
2586:
2587: NdisReadRegisterUshort(&(BringUpSrb->ReturnCode), &TmpUshort);
2588:
2589: if (TmpUshort != 0x0000) {
2590:
2591: CleanupResetFailure (Adapter, NULL, TmpUshort, 1);
2592: break;
2593:
2594: }
2595:
2596: //
2597: // Now set up the open SRB request.
2598: //
2599:
2600: OpenSrb = (PSRB_OPEN_ADAPTER)
2601: (Adapter->SharedRam + Adapter->InitialWrbOffset);
2602:
2603: IBMTOK_ZERO_MAPPED_MEMORY(OpenSrb, sizeof(SRB_OPEN_ADAPTER));
2604:
2605: NdisWriteRegisterUchar(&(OpenSrb->Command), SRB_CMD_OPEN_ADAPTER);
2606: NdisWriteRegisterUshort(&(OpenSrb->OpenOptions), OPEN_CONTENDER);
2607:
2608: NdisMoveToMappedMemory((PCHAR)OpenSrb->NodeAddress,
2609: Adapter->NetworkAddress,
2610: TR_LENGTH_OF_ADDRESS
2611: );
2612:
2613: WRITE_IBMSHORT(OpenSrb->ReceiveBufferNum,
2614: Adapter->NumberOfReceiveBuffers);
2615: WRITE_IBMSHORT(OpenSrb->ReceiveBufferLen,
2616: Adapter->ReceiveBufferLength);
2617:
2618: WRITE_IBMSHORT(OpenSrb->TransmitBufferLen,
2619: Adapter->TransmitBufferLength);
2620:
2621: NdisWriteRegisterUchar(&(OpenSrb->TransmitBufferNum),
2622: (UCHAR)Adapter->NumberOfTransmitBuffers
2623: );
2624:
2625: Adapter->CurrentResetStage = 2;
2626:
2627: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2628: ISRA_HIGH_COMMAND_IN_SRB | ISRA_HIGH_SRB_FREE_REQUEST);
2629:
2630: IF_LOG('1');
2631:
2632: break;
2633:
2634: }
2635:
2636: case 2: {
2637:
2638: //
2639: // Handle the result of the DIR.OPEN.ADAPTER command.
2640: //
2641:
2642: PSRB_OPEN_RESPONSE OpenResponseSrb;
2643: UCHAR TmpUchar;
2644:
2645: #if DBG
2646: if (IbmtokDbg) DbgPrint("IBMTOK: OPEN done\n");
2647: #endif
2648:
2649: OpenResponseSrb = (PSRB_OPEN_RESPONSE)
2650: (Adapter->SharedRam + Adapter->InitialWrbOffset);
2651:
2652: NdisReadRegisterUchar(&(OpenResponseSrb->ReturnCode), &TmpUchar);
2653:
2654: if (TmpUchar != 0) {
2655:
2656: NDIS_STATUS IndicateStatus;
2657:
2658: NdisReadRegisterUshort(&(OpenResponseSrb->ErrorCode),
2659: &(Adapter->OpenErrorCode));
2660: Adapter->OpenErrorCode = IBMSHORT_TO_USHORT(Adapter->OpenErrorCode);
2661: IndicateStatus =
2662: NDIS_STATUS_TOKEN_RING_OPEN_ERROR |
2663: (NDIS_STATUS)(Adapter->OpenErrorCode);
2664:
2665: CleanupResetFailure (Adapter, &IndicateStatus, Adapter->OpenErrorCode, 2);
2666: break;
2667:
2668: }
2669:
2670: IF_LOG('2');
2671:
2672: #if DBG
2673: NdisReadRegisterUchar(&(OpenResponseSrb->ReturnCode),&TmpUchar);
2674: if (IbmtokDbg) DbgPrint("IBMTOK: RESET OPEN, Return code = %x, at %lx\n",
2675: TmpUchar,
2676: OpenResponseSrb);
2677: #endif
2678:
2679: NdisReadRegisterUshort(&(OpenResponseSrb->SrbPointer), &TmpUshort);
2680: Adapter->SrbAddress = SRAM_PTR_TO_PVOID(Adapter,TmpUshort);
2681:
2682: NdisReadRegisterUshort(&(OpenResponseSrb->SsbPointer), &TmpUshort);
2683: Adapter->SsbAddress = SRAM_PTR_TO_PVOID(Adapter,TmpUshort);
2684:
2685: NdisReadRegisterUshort(&(OpenResponseSrb->ArbPointer), &TmpUshort);
2686: Adapter->ArbAddress = SRAM_PTR_TO_PVOID(Adapter,TmpUshort);
2687:
2688: NdisReadRegisterUshort(&(OpenResponseSrb->AsbPointer), &TmpUshort);
2689: Adapter->AsbAddress = SRAM_PTR_TO_PVOID(Adapter,TmpUshort);
2690:
2691: #if DBG
2692: if (IbmtokDbg) {
2693: USHORT TmpUshort1;
2694: USHORT TmpUshort2;
2695: USHORT TmpUshort3;
2696: USHORT TmpUshort4;
2697: NdisReadRegisterUshort(&(OpenResponseSrb->SrbPointer), &TmpUshort1);
2698: NdisReadRegisterUshort(&(OpenResponseSrb->SsbPointer), &TmpUshort2);
2699: NdisReadRegisterUshort(&(OpenResponseSrb->ArbPointer), &TmpUshort3);
2700: NdisReadRegisterUshort(&(OpenResponseSrb->AsbPointer), &TmpUshort4);
2701: DbgPrint("IBMTOK: Offsets: SRB %x SSB %x ARB %x ASB %x\n",
2702: IBMSHORT_TO_USHORT(TmpUshort1),
2703: IBMSHORT_TO_USHORT(TmpUshort2),
2704: IBMSHORT_TO_USHORT(TmpUshort3),
2705: IBMSHORT_TO_USHORT(TmpUshort4));
2706: }
2707: #endif
2708:
2709: //
2710: // Now queue a SET.FUNCT.ADDRESS command if needed.
2711: //
2712:
2713: Adapter->CurrentCardFunctional = (TR_FUNCTIONAL_ADDRESS)0;
2714:
2715: if (SetAdapterFunctionalAddress(Adapter) == NDIS_STATUS_SUCCESS) {
2716:
2717: //
2718: // This means that the command did not have to be
2719: // queued, so we are done with this step.
2720: //
2721:
2722: if (SetAdapterGroupAddress(Adapter) == NDIS_STATUS_SUCCESS) {
2723:
2724: //
2725: // This one did not pend either, we are done.
2726: //
2727:
2728: IbmtokFinishAdapterReset(Adapter);
2729:
2730: } else {
2731:
2732: Adapter->CurrentResetStage = 4;
2733:
2734: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2735: ISRA_HIGH_COMMAND_IN_SRB | ISRA_HIGH_SRB_FREE_REQUEST);
2736:
2737: }
2738:
2739: } else {
2740:
2741: Adapter->CurrentResetStage = 3;
2742:
2743: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2744: ISRA_HIGH_COMMAND_IN_SRB | ISRA_HIGH_SRB_FREE_REQUEST);
2745:
2746: }
2747:
2748: break;
2749:
2750: }
2751:
2752: case 3: {
2753:
2754: //
2755: // The SET.FUNCT.ADDRESS command finished.
2756: //
2757:
2758: PSRB_GENERIC GenericSrb = (PSRB_GENERIC)Adapter->SrbAddress;
2759: UCHAR ReturnCode;
2760:
2761: NdisReadRegisterUchar(&(GenericSrb->ReturnCode), &ReturnCode);
2762:
2763: IF_LOG('3');
2764:
2765: #if DBG
2766: if (IbmtokDbg) DbgPrint("IBMTOK: SET FUNCT done\n");
2767: #endif
2768: if (ReturnCode == 0x00) {
2769:
2770: if (SetAdapterGroupAddress(Adapter) == NDIS_STATUS_SUCCESS) {
2771:
2772: //
2773: // This one did not pend, the dishes are done.
2774: //
2775:
2776: IbmtokFinishAdapterReset(Adapter);
2777:
2778: } else {
2779:
2780: Adapter->CurrentResetStage = 4;
2781:
2782: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
2783: ISRA_HIGH_COMMAND_IN_SRB | ISRA_HIGH_SRB_FREE_REQUEST);
2784:
2785: }
2786:
2787: } else if (ReturnCode != 0xfe) {
2788:
2789: CleanupResetFailure (Adapter, NULL, (ULONG)ReturnCode, 3);
2790:
2791: }
2792:
2793: break;
2794:
2795: }
2796:
2797: case 4: {
2798:
2799: //
2800: // The SET.GROUP.ADDRESS command finished.
2801: //
2802:
2803: PSRB_GENERIC GenericSrb = (PSRB_GENERIC)Adapter->SrbAddress;
2804: UCHAR ReturnCode;
2805:
2806: NdisReadRegisterUchar(&(GenericSrb->ReturnCode), &ReturnCode);
2807:
2808: IF_LOG('4');
2809:
2810: #if DBG
2811: if (IbmtokDbg) DbgPrint("IBMTOK: SET GROUP done\n");
2812: #endif
2813: if (ReturnCode == 0x00) {
2814:
2815: IbmtokFinishAdapterReset(Adapter);
2816:
2817: } else if (ReturnCode != 0xfe) {
2818:
2819: CleanupResetFailure (Adapter, NULL, (ULONG)ReturnCode, 4);
2820:
2821: }
2822:
2823: break;
2824:
2825: }
2826:
2827: }
2828:
2829: }
2830:
2831: STATIC
2832: PNDIS_PACKET
2833: RemoveTransmitFromSrb(
2834: IN PIBMTOK_ADAPTER Adapter,
2835: OUT PBOOLEAN PacketRemoved
2836: )
2837:
2838: /*++
2839:
2840: Routine Description:
2841:
2842: Cleans a transmit out of the SRB if one was there.
2843:
2844: NOTE : Should be called with the spinlock held!!!
2845:
2846: Arguments:
2847:
2848: Adapter - The adapter that this packet is coming through.
2849:
2850: PacketRemoved - TRUE if the packet was removed from the SRB.
2851:
2852: Return Value:
2853:
2854: The packet removed.
2855:
2856: --*/
2857:
2858: {
2859: PNDIS_PACKET TransmitPacket;
2860: PIBMTOK_RESERVED Reserved;
2861: UCHAR TmpUchar;
2862: PSRB_TRANSMIT_DIR_FRAME TransmitSrb =
2863: (PSRB_TRANSMIT_DIR_FRAME)Adapter->SrbAddress;
2864:
2865:
2866: NdisReadRegisterUchar(&(TransmitSrb->ReturnCode), &TmpUchar);
2867:
2868: if (TmpUchar == 0xfe) {
2869:
2870: //
2871: // The TRANSMIT command was just put in the SRB, and
2872: // the adapter has not yet had time to process it.
2873: // We return now before setting SrbAvailable to TRUE,
2874: // so the command is left to be processed.
2875: //
2876: // NOTE: If this happens on a call from inside the
2877: // ARB_TRANSMIT_DATA interrupt handler, we will fail
2878: // on an assertion when we return NULL.
2879: //
2880: *PacketRemoved = FALSE;
2881:
2882: return (PNDIS_PACKET)NULL;
2883:
2884: }
2885:
2886:
2887: //
2888: // if there was a packet in there, put it in
2889: // the correlator array.
2890: //
2891:
2892: TransmitPacket = Adapter->TransmittingPacket;
2893:
2894: Adapter->TransmittingPacket = (PNDIS_PACKET)NULL;
2895:
2896: //
2897: // This will be TRUE whatever happens next.
2898: //
2899: *PacketRemoved = TRUE;
2900:
2901: Reserved =
2902: PIBMTOK_RESERVED_FROM_PACKET(TransmitPacket);
2903:
2904: //
2905: // Check that the return code is OK.
2906: //
2907:
2908: if (TmpUchar != 0xff) {
2909:
2910: PIBMTOK_OPEN Open =
2911: PIBMTOK_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle);
2912: //
2913: // Fail the transmit.
2914: //
2915:
2916: //
2917: // If doing LOOPBACK, this should really be a check
2918: // of ReadyToComplete etc.
2919: //
2920:
2921: #if DBG
2922: if (IbmtokDbg) {
2923: UCHAR TmpUchar1, TmpUchar2;
2924: NdisReadRegisterUchar(&TransmitSrb->ReturnCode, &TmpUchar1);
2925: NdisReadRegisterUchar(&TransmitSrb->Command, &TmpUchar2);
2926: DbgPrint("IBMTOK: Transmit failed in SRB: %x for %x\n", TmpUchar1, TmpUchar2);
2927: }
2928: #endif
2929:
2930: #ifdef CHECK_DUP_SENDS
2931: {
2932: VOID IbmtokRemovePacketFromList(PIBMTOK_ADAPTER, PNDIS_PACKET);
2933: IbmtokRemovePacketFromList(Adapter, TransmitPacket);
2934: }
2935: #endif
2936:
2937: Adapter->FrameTransmitErrors++;
2938:
2939: NdisReleaseSpinLock(&(Adapter->Lock));
2940:
2941: NdisCompleteSend(
2942: Open->NdisBindingContext,
2943: Reserved->Packet,
2944: NDIS_STATUS_FAILURE
2945: );
2946:
2947: NdisAcquireSpinLock(&(Adapter->Lock));
2948:
2949: //
2950: // Decrement the reference count for the open.
2951: //
2952: Open->References--;
2953:
2954: //
2955: // This will cause an assertion failure if we were
2956: // called from the ARB_TRANSMIT_DATA handler.
2957: //
2958: return (PNDIS_PACKET)NULL;
2959:
2960: }
2961:
2962: //
2963: // Put the packet in the correlator array.
2964: //
2965:
2966: Reserved->CorrelatorAssigned = TRUE;
2967: NdisReadRegisterUchar(&(TransmitSrb->CommandCorrelator), &(Reserved->CommandCorrelator));
2968:
2969: PutPacketInCorrelatorArray(Adapter, TransmitPacket);
2970:
2971: return TransmitPacket;
2972: }
2973:
2974: VOID
2975: SetupSrbCommand(
2976: IN PIBMTOK_ADAPTER Adapter
2977: )
2978:
2979: /*++
2980:
2981: Routine Description:
2982:
2983: Fills in the SRB with the next request. It first checks
2984: if there is a pended request outstanding, then
2985: handles any queued transmits.
2986:
2987: Called with the spinlock held.
2988:
2989: NOTE: Should be called with Adapter->SrbAvailable == FALSE.
2990:
2991: Arguments:
2992:
2993: Adapter - The Adapter to process interrupts for.
2994:
2995: Return Value:
2996:
2997: None.
2998:
2999: --*/
3000:
3001: {
3002:
3003: if (Adapter->PendQueue != NULL) {
3004:
3005: //
3006: // This will copy the appropriate info out of the
3007: // pend queue.
3008: //
3009:
3010: if (StartPendQueueOp(Adapter) == NDIS_STATUS_PENDING) {
3011:
3012: //
3013: // Indicate the SRB command.
3014: //
3015:
3016: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
3017: ISRA_HIGH_COMMAND_IN_SRB);
3018:
3019: return;
3020:
3021: }
3022:
3023: }
3024:
3025: //
3026: // If we reach here, the pend queue was empty or
3027: // else StartPendQueueOp drained the entire queue
3028: // without an operation needing the SRB.
3029: //
3030:
3031: if (Adapter->FirstTransmit != NULL) {
3032:
3033: //
3034: // Remove the packet from the queue.
3035: //
3036:
3037: PNDIS_PACKET TransmitPacket = Adapter->FirstTransmit;
3038:
3039: PIBMTOK_RESERVED Reserved =
3040: PIBMTOK_RESERVED_FROM_PACKET(TransmitPacket);
3041:
3042: Adapter->FirstTransmit = Reserved->Next;
3043:
3044: Adapter->TransmittingPacket = TransmitPacket;
3045:
3046: //
3047: // set up the send - this sets the packet equal
3048: // to Adapter->TransmittingPacket;
3049: //
3050: SetupTransmitFrameSrb(Adapter, TransmitPacket);
3051:
3052: //
3053: // Indicate the SRB command.
3054: //
3055:
3056: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
3057: ISRA_HIGH_COMMAND_IN_SRB);
3058:
3059: } else {
3060:
3061: Adapter->SrbAvailable = TRUE;
3062:
3063: }
3064: }
3065:
3066: extern
3067: VOID
3068: IbmtokForceAdapterInterrupt(
3069: IN PIBMTOK_ADAPTER Adapter
3070: )
3071:
3072: /*++
3073:
3074: Routine Description:
3075:
3076: This forces an adapter interrupt by queueing an
3077: INTERRUPT SRB.
3078:
3079: This is called with the spinlock held, and also
3080: Adapter->SrbAvailable must be TRUE.
3081:
3082: Arguments:
3083:
3084: Adapter - The Adapter to force the interrupt on.
3085:
3086: Return Value:
3087:
3088: None.
3089:
3090: --*/
3091:
3092: {
3093:
3094: PSRB_INTERRUPT InterruptSrb =
3095: (PSRB_INTERRUPT)Adapter->SrbAddress;
3096:
3097: ASSERT(Adapter->SrbAvailable);
3098:
3099: Adapter->SrbAvailable = FALSE;
3100:
3101: NdisWriteRegisterUchar(&(InterruptSrb->Command), SRB_CMD_INTERRUPT);
3102: NdisWriteRegisterUchar(&(InterruptSrb->ReturnCode), 0xfe);
3103:
3104: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
3105: ISRA_HIGH_COMMAND_IN_SRB);
3106:
3107: IF_LOG('O');
3108:
3109: }
3110:
3111: STATIC
3112: VOID
3113: SetupTransmitFrameSrb(
3114: IN PIBMTOK_ADAPTER Adapter,
3115: IN PNDIS_PACKET Packet
3116: )
3117:
3118: /*++
3119:
3120: Routine Description:
3121:
3122: This routine sets up the SRB for a TRANSMIT.DIR.FRAME.
3123:
3124: Arguments:
3125:
3126: Adapter - The adapter that this packet is coming through.
3127:
3128: Packet - The packet that is being sent.
3129:
3130: Return Value:
3131:
3132: None.
3133:
3134: --*/
3135:
3136: {
3137: PSRB_TRANSMIT_DIR_FRAME TransmitSrb =
3138: (PSRB_TRANSMIT_DIR_FRAME)Adapter->SrbAddress;
3139:
3140: UNREFERENCED_PARAMETER(Packet);
3141:
3142: NdisWriteRegisterUchar(&(TransmitSrb->Command), SRB_CMD_TRANSMIT_DIR_FRAME);
3143: NdisWriteRegisterUchar(&(TransmitSrb->CommandCorrelator), 0x00);
3144: NdisWriteRegisterUchar(&(TransmitSrb->ReturnCode), 0xfe); // will change to 0xff or error
3145: NdisWriteRegisterUshort(&(TransmitSrb->StationId), USHORT_TO_IBMSHORT(0x00));
3146:
3147: IF_LOG('x');
3148: }
3149:
3150: STATIC
3151: VOID
3152: SetupTransmitStatusAsb(
3153: IN PIBMTOK_ADAPTER Adapter,
3154: IN PNDIS_PACKET Packet
3155: )
3156:
3157: /*++
3158:
3159: Routine Description:
3160:
3161: This routine sets up the ASB for a response from
3162: a TRANSMIT.DATA.REQUEST.
3163:
3164: Arguments:
3165:
3166: Adapter - The adapter that this packet is coming through.
3167:
3168: Packet - The packet that has been copied down.
3169:
3170: Return Value:
3171:
3172: None.
3173:
3174: --*/
3175:
3176: {
3177:
3178: PASB_TRANSMIT_DATA_STATUS TransmitDataAsb;
3179: UINT PacketLength;
3180: PIBMTOK_RESERVED Reserved = PIBMTOK_RESERVED_FROM_PACKET(Packet);
3181:
3182: NdisQueryPacket(
3183: Packet,
3184: NULL,
3185: NULL,
3186: NULL,
3187: &PacketLength
3188: );
3189:
3190: TransmitDataAsb = (PASB_TRANSMIT_DATA_STATUS)
3191: Adapter->AsbAddress;
3192:
3193: NdisWriteRegisterUchar(&(TransmitDataAsb->Command), SRB_CMD_TRANSMIT_DIR_FRAME);
3194: NdisWriteRegisterUchar(&(TransmitDataAsb->CommandCorrelator),
3195: Reserved->CommandCorrelator);
3196: NdisWriteRegisterUchar(&(TransmitDataAsb->ReturnCode), 0x00);
3197: NdisWriteRegisterUshort(&(TransmitDataAsb->FrameLength),
3198: USHORT_TO_IBMSHORT(PacketLength));
3199:
3200: IF_LOG('X');
3201:
3202: }
3203:
3204: STATIC
3205: VOID
3206: SetupAdapterStatisticsSrb(
3207: IN PIBMTOK_ADAPTER Adapter
3208: )
3209:
3210: /*++
3211:
3212: Routine Description:
3213:
3214: This routine sets up the SRB for a DLC.STATISTICS.
3215:
3216: Arguments:
3217:
3218: Adapter - A pointer to the adapter.
3219:
3220: Return Value:
3221:
3222: None.
3223:
3224: --*/
3225: {
3226: PSRB_DLC_STATS StatsSrb = (PSRB_DLC_STATS)(Adapter->SrbAddress);
3227:
3228: NdisWriteRegisterUchar(&(StatsSrb->Command), SRB_CMD_DLC_STATISTICS);
3229: NdisWriteRegisterUchar(&(StatsSrb->StationId), USHORT_TO_IBMSHORT(0x00));
3230: NdisWriteRegisterUchar(&(StatsSrb->ReturnCode), 0x80); // Resets counters
3231:
3232: }
3233:
3234: STATIC
3235: VOID
3236: GetAdapterStatisticsFromSrb(
3237: PIBMTOK_ADAPTER Adapter
3238: )
3239:
3240: /*++
3241:
3242: Routine Description:
3243:
3244: This routine reads the statistics after a DLC.STATISTICS has completed
3245: and stores the results in the adapter structure.
3246:
3247: Arguments:
3248:
3249: Adapter - A pointer to the adapter.
3250:
3251: Return Value:
3252:
3253: None.
3254:
3255: --*/
3256:
3257: {
3258: PSRB_DLC_STATS StatsSrb = (PSRB_DLC_STATS)(Adapter->SrbAddress);
3259: PDLC_COUNTERS Counters;
3260: USHORT TmpUshort;
3261: UCHAR TmpUchar;
3262:
3263: NdisReadRegisterUshort(&StatsSrb->CountersOffset, &TmpUshort);
3264: Counters = (PDLC_COUNTERS) (((PUCHAR)(Adapter->SrbAddress)) +
3265: IBMSHORT_TO_USHORT(TmpUshort));
3266:
3267: NdisReadRegisterUshort(&Counters->TransmitCount, &TmpUshort);
3268: Adapter->FramesTransmitted += IBMSHORT_TO_USHORT(TmpUshort);
3269: NdisReadRegisterUshort(&Counters->ReceiveCount, &TmpUshort);
3270: Adapter->FramesReceived += IBMSHORT_TO_USHORT(TmpUshort);
3271: NdisReadRegisterUchar(&Counters->TransmitErrors, &TmpUchar);
3272: Adapter->FrameTransmitErrors += TmpUchar;
3273: NdisReadRegisterUchar(&Counters->ReceiveErrors, &TmpUchar);
3274: Adapter->FrameReceiveErrors += TmpUchar;
3275:
3276: }
3277:
3278: STATIC
3279: VOID
3280: GetAdapterErrorsFromSrb(
3281: PIBMTOK_ADAPTER Adapter
3282: )
3283:
3284: /*++
3285:
3286: Routine Description:
3287:
3288: This routine reads the statistics after a DIR.READ.LOG has completed
3289: and stores the results in the adapter structure.
3290:
3291: Arguments:
3292:
3293: Adapter - A pointer to the adapter.
3294:
3295: Return Value:
3296:
3297: None.
3298:
3299: --*/
3300:
3301: {
3302: PSRB_READ_LOG ReadLogSrb = (PSRB_READ_LOG)(Adapter->SrbAddress);
3303: ULONG TmpUchar;
3304:
3305: NdisReadRegisterUchar(&ReadLogSrb->LineErrors, &TmpUchar);
3306: Adapter->LineErrors += TmpUchar;
3307: NdisReadRegisterUchar(&ReadLogSrb->InternalErrors, &TmpUchar);
3308: Adapter->InternalErrors += TmpUchar;
3309: NdisReadRegisterUchar(&ReadLogSrb->BurstErrors, &TmpUchar);
3310: Adapter->BurstErrors += TmpUchar;
3311: NdisReadRegisterUchar(&ReadLogSrb->AcErrors, &TmpUchar);
3312: Adapter->AcErrors += TmpUchar;
3313: NdisReadRegisterUchar(&ReadLogSrb->AbortDelimeters, &TmpUchar);
3314: Adapter->AbortDelimeters += TmpUchar;
3315: NdisReadRegisterUchar(&ReadLogSrb->LostFrames, &TmpUchar);
3316: Adapter->LostFrames += TmpUchar;
3317: NdisReadRegisterUchar(&ReadLogSrb->ReceiveCongestionCount, &TmpUchar);
3318: Adapter->ReceiveCongestionCount += TmpUchar;
3319: NdisReadRegisterUchar(&ReadLogSrb->FrameCopiedErrors, &TmpUchar);
3320: Adapter->FrameCopiedErrors += TmpUchar;
3321: NdisReadRegisterUchar(&ReadLogSrb->FrequencyErrors, &TmpUchar);
3322: Adapter->FrequencyErrors += TmpUchar;
3323: NdisReadRegisterUchar(&ReadLogSrb->TokenErrors, &TmpUchar);
3324: Adapter->TokenErrors += TmpUchar;
3325: }
3326:
3327: STATIC
3328: VOID
3329: SetupAdapterErrorsSrb(
3330: PIBMTOK_ADAPTER Adapter
3331: )
3332:
3333: /*++
3334:
3335: Routine Description:
3336:
3337: This routine sets up the SRB for a DIR.READ.LOG command.
3338:
3339: Arguments:
3340:
3341: Adapter - A pointer to the adapter.
3342:
3343: Return Value:
3344:
3345: None.
3346:
3347: --*/
3348: {
3349: PSRB_READ_LOG ReadLogSrb = (PSRB_READ_LOG)(Adapter->SrbAddress);
3350:
3351: NdisWriteRegisterUchar(&(ReadLogSrb->Command), SRB_CMD_READ_LOG);
3352: }
3353:
3354: STATIC
3355: NDIS_STATUS
3356: StartPendQueueOp(
3357: IN PIBMTOK_ADAPTER Adapter
3358: )
3359:
3360: /*++
3361:
3362: Routine Description:
3363:
3364: This routine goes through the pending queue until it
3365: is empty or it finds a request that requires an SRB
3366: command and hence pends.
3367:
3368: NOTE: This routine is called with the lock held and
3369: returns with it held.
3370:
3371: Arguments:
3372:
3373: Adapter - The adapter that the queue should be checked for.
3374:
3375: Return Value:
3376:
3377: NDIS_STATUS_SUCCESS - If the queue was drained completely.
3378: NDIS_STATUS_PENDING - If a request required the SRB.
3379:
3380: --*/
3381:
3382: {
3383: //
3384: // Holds the operation on the head of the queue
3385: // (we know it is not empty).
3386: //
3387: PIBMTOK_PEND_DATA PendOp;
3388:
3389: //
3390: // Holds status temporarily.
3391: //
3392: NDIS_STATUS RequestStatus;
3393:
3394:
3395: while (Adapter->PendQueue != NULL) {
3396:
3397: //
3398: // First take the head operation off the queue.
3399: //
3400:
3401: PendOp = Adapter->PendQueue;
3402:
3403: Adapter->PendQueue = Adapter->PendQueue->Next;
3404:
3405: if (Adapter->PendQueue == NULL){
3406:
3407: //
3408: // We have just emptied the list.
3409: //
3410:
3411: Adapter->EndOfPendQueue = NULL;
3412:
3413: }
3414:
3415:
3416: if (PendOp->RequestType == NdisRequestGeneric1){
3417:
3418: //
3419: // The pended operation is a result of the card having
3420: // a counter overflow, and now we need to send the command.
3421: //
3422:
3423: if (PendOp->COMMAND.MAC.ReadLogPending){
3424:
3425: //
3426: // A DIR.READ.LOG command is needed.
3427: //
3428:
3429: SetupAdapterErrorsSrb(Adapter);
3430:
3431: } else {
3432:
3433: //
3434: // A DLC.STATISTICS command is needed.
3435: //
3436:
3437: SetupAdapterStatisticsSrb(Adapter);
3438:
3439: }
3440:
3441: //
3442: // Issue adapter command.
3443: //
3444:
3445: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
3446: ISRA_HIGH_COMMAND_IN_SRB);
3447:
3448: RequestStatus = NDIS_STATUS_PENDING;
3449:
3450: } else {
3451:
3452: switch (PendOp->RequestType) {
3453:
3454:
3455: case NdisRequestSetInformation:
3456:
3457: //
3458: // It's a set filter or set address command.
3459: //
3460:
3461: if ((PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp))->DATA.SET_INFORMATION.Oid ==
3462: OID_GEN_CURRENT_PACKET_FILTER){
3463:
3464: //
3465: // It's a set filter command.
3466: //
3467:
3468:
3469: Adapter->OldPacketFilter = Adapter->CurrentPacketFilter;
3470:
3471: Adapter->CurrentPacketFilter =
3472: PendOp->COMMAND.NDIS.SET_FILTER.NewFilterValue;
3473:
3474: RequestStatus = SetAdapterFunctionalAddress(Adapter);
3475:
3476: } else {
3477:
3478: //
3479: // It's a set address command.
3480: //
3481: #if DBG
3482: if (IbmtokDbg) {
3483: DbgPrint("IBMTOK: Starting Command\n");
3484: }
3485: #endif
3486:
3487: if ((PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp))->DATA.SET_INFORMATION.Oid ==
3488: OID_802_5_CURRENT_FUNCTIONAL) {
3489:
3490: Adapter->CurrentFunctionalAddress =
3491: PendOp->COMMAND.NDIS.SET_ADDRESS.NewAddressValue;
3492:
3493: RequestStatus = SetAdapterFunctionalAddress(Adapter);
3494:
3495: } else {
3496:
3497: Adapter->CurrentGroupAddress =
3498: PendOp->COMMAND.NDIS.SET_ADDRESS.NewAddressValue;
3499:
3500: RequestStatus = SetAdapterGroupAddress(Adapter);
3501:
3502: }
3503:
3504: }
3505:
3506:
3507: break;
3508:
3509: case NdisRequestClose:
3510:
3511: //
3512: // It's a set filter command.
3513: //
3514:
3515: Adapter->OldPacketFilter = Adapter->CurrentPacketFilter;
3516:
3517: Adapter->CurrentPacketFilter =
3518: PendOp->COMMAND.NDIS.CLOSE.NewFilterValue;
3519:
3520: RequestStatus = SetAdapterFunctionalAddress(Adapter);
3521:
3522: break;
3523:
3524: case NdisRequestGeneric2:
3525:
3526: //
3527: // It's a set address command.
3528: //
3529:
3530: Adapter->CurrentFunctionalAddress =
3531: PendOp->COMMAND.NDIS.SET_ADDRESS.NewAddressValue;
3532:
3533:
3534: RequestStatus = SetAdapterFunctionalAddress(Adapter);
3535:
3536: break;
3537:
3538:
3539: case NdisRequestGeneric3:
3540:
3541: //
3542: // It's a set address command.
3543: //
3544:
3545: Adapter->CurrentGroupAddress =
3546: PendOp->COMMAND.NDIS.SET_ADDRESS.NewAddressValue;
3547:
3548:
3549: RequestStatus = SetAdapterGroupAddress(Adapter);
3550:
3551: break;
3552:
3553:
3554: case NdisRequestQueryStatistics:
3555:
3556: //
3557: // We know it's a request for statistics.
3558: //
3559:
3560: RequestStatus = NDIS_STATUS_PENDING;
3561:
3562: SetupAdapterErrorsSrb(Adapter);
3563:
3564: PendOp->COMMAND.NDIS.STATISTICS.ReadLogPending = TRUE;
3565:
3566: //
3567: // Issue adapter command.
3568: //
3569:
3570: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
3571: ISRA_HIGH_COMMAND_IN_SRB);
3572:
3573: break;
3574:
3575: default:
3576:
3577: NdisWriteErrorLogEntry(
3578: Adapter->NdisAdapterHandle,
3579: NDIS_ERROR_CODE_DRIVER_FAILURE,
3580: 3,
3581: IBMTOK_ERRMSG_BAD_OP,
3582: 1,
3583: PendOp->RequestType
3584: );
3585:
3586:
3587: }
3588: }
3589:
3590:
3591:
3592:
3593: if (RequestStatus == NDIS_STATUS_PENDING) {
3594:
3595: //
3596: // Set this up for when the request completes.
3597: //
3598:
3599: Adapter->PendData = PendOp;
3600:
3601: return NDIS_STATUS_PENDING;
3602:
3603: } else if (RequestStatus == NDIS_STATUS_SUCCESS) {
3604:
3605: PIBMTOK_OPEN TmpOpen;
3606:
3607:
3608: switch (PendOp->RequestType) {
3609:
3610: case NdisRequestSetInformation:
3611:
3612: //
3613: // Complete the request.
3614: //
3615:
3616: TmpOpen = PendOp->COMMAND.NDIS.SET_FILTER.Open;
3617:
3618:
3619: NdisReleaseSpinLock(&(Adapter->Lock));
3620:
3621: NdisCompleteRequest(
3622: PendOp->COMMAND.NDIS.SET_FILTER.Open->NdisBindingContext,
3623: PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp),
3624: NDIS_STATUS_SUCCESS
3625: );
3626:
3627: NdisAcquireSpinLock(&(Adapter->Lock));
3628:
3629: TmpOpen->References--;
3630:
3631: break;
3632:
3633:
3634: case NdisRequestClose:
3635:
3636: PendOp->COMMAND.NDIS.CLOSE.Open->References--;
3637: break;
3638:
3639: case NdisRequestGeneric2:
3640: case NdisRequestGeneric3:
3641:
3642: PendOp->COMMAND.NDIS.SET_ADDRESS.Open->References--;
3643: break;
3644:
3645:
3646: case NdisRequestQueryStatistics:
3647:
3648: NdisReleaseSpinLock(&(Adapter->Lock));
3649:
3650: NdisCompleteQueryStatistics(
3651: Adapter->NdisMacHandle,
3652: PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp),
3653: NDIS_STATUS_SUCCESS
3654: );
3655:
3656: NdisAcquireSpinLock(&(Adapter->Lock));
3657:
3658: Adapter->References--;
3659:
3660: break;
3661:
3662: default:
3663:
3664: NdisWriteErrorLogEntry(
3665: Adapter->NdisAdapterHandle,
3666: NDIS_ERROR_CODE_DRIVER_FAILURE,
3667: 3,
3668: startPendQueueOp,
3669: IBMTOK_ERRMSG_BAD_OP,
3670: PendOp->RequestType
3671: );
3672:
3673:
3674: }
3675:
3676: } else {
3677:
3678: NdisWriteErrorLogEntry(
3679: Adapter->NdisAdapterHandle,
3680: NDIS_ERROR_CODE_DRIVER_FAILURE,
3681: 3,
3682: startPendQueueOp,
3683: IBMTOK_ERRMSG_INVALID_STATUS,
3684: RequestStatus
3685: );
3686:
3687: }
3688:
3689: }
3690:
3691: //
3692: // We drained the entire queue without pending.
3693: //
3694:
3695: return NDIS_STATUS_SUCCESS;
3696: }
3697:
3698: STATIC
3699: BOOLEAN
3700: FinishPendQueueOp(
3701: IN PIBMTOK_ADAPTER Adapter,
3702: IN BOOLEAN Successful
3703: )
3704:
3705: /*++
3706:
3707: Routine Description:
3708:
3709: This routine is called when an SRB command completes.
3710: It calles CompleteRequest if needed and does any other
3711: cleanup required.
3712:
3713: NOTE: This routine is called with the lock held and
3714: returns with it held.
3715:
3716: NOTE: This routine assumes that the pended operation to
3717: be completed was specifically requested by the protocol
3718: and, thus, that PendData->Request != NULL.
3719:
3720: Arguments:
3721:
3722: Adapter - The adapter that the queue should be checked for.
3723:
3724: Successful - Was the SRB command completed successfully.
3725:
3726: Return Value:
3727:
3728: TRUE if the operation was completed, FALSE if another command
3729: was submitted to the card to complete the operation.
3730:
3731: --*/
3732:
3733: {
3734: PIBMTOK_PEND_DATA PendOp = Adapter->PendData;
3735:
3736: ASSERT(PendOp != NULL);
3737:
3738:
3739: switch (PendOp->RequestType) {
3740:
3741: case NdisRequestQueryStatistics:
3742:
3743: //
3744: // It was a request for global statistics.
3745: //
3746:
3747: if (Successful){
3748:
3749: NDIS_STATUS StatusToReturn;
3750:
3751: //
3752: // Grab the data
3753: //
3754:
3755: GetAdapterErrorsFromSrb(Adapter);
3756:
3757: //
3758: // Fill in NdisRequest InformationBuffer
3759: //
3760:
3761: StatusToReturn = IbmtokFillInGlobalData(
3762: Adapter,
3763: PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp)
3764: );
3765:
3766: //
3767: // Complete statistics call
3768: //
3769:
3770: Adapter->PendData = NULL;
3771:
3772: NdisReleaseSpinLock(&(Adapter->Lock));
3773:
3774: NdisCompleteQueryStatistics(
3775: Adapter->NdisMacHandle,
3776: PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp),
3777: StatusToReturn
3778: );
3779:
3780: NdisAcquireSpinLock(&(Adapter->Lock));
3781:
3782: Adapter->References--;
3783:
3784: } else {
3785:
3786: //
3787: // Complete statistics call
3788: //
3789:
3790: Adapter->PendData = NULL;
3791:
3792: NdisReleaseSpinLock(&(Adapter->Lock));
3793:
3794: NdisCompleteQueryStatistics(
3795: Adapter->NdisMacHandle,
3796: PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp),
3797: NDIS_STATUS_FAILURE
3798: );
3799:
3800: NdisAcquireSpinLock(&(Adapter->Lock));
3801:
3802: Adapter->References--;
3803:
3804: }
3805:
3806: break;
3807:
3808:
3809: case NdisRequestSetInformation:
3810:
3811:
3812: //
3813: // It was a request for address change.
3814: //
3815: #if DBG
3816: if (IbmtokDbg) {
3817: if (Successful) {
3818: DbgPrint("IBMTOK: SUCCESS\n\n");
3819: } else {
3820: DbgPrint("IBMTOK: FAILURE\n\n");
3821: }
3822: }
3823: #endif
3824:
3825: if (Successful){
3826:
3827: PIBMTOK_OPEN TmpOpen;
3828:
3829: //
3830: // complete the operation.
3831: //
3832:
3833:
3834: if (PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(Adapter->PendData)->DATA.SET_INFORMATION.Oid ==
3835: OID_802_5_CURRENT_GROUP) {
3836:
3837: //
3838: // Store new group address
3839: //
3840:
3841: Adapter->CurrentCardGroup = Adapter->CurrentGroupAddress;
3842:
3843: }
3844:
3845: Adapter->PendData = NULL;
3846:
3847: TmpOpen = PendOp->COMMAND.NDIS.SET_FILTER.Open;
3848:
3849: NdisReleaseSpinLock(&(Adapter->Lock));
3850:
3851: NdisCompleteRequest(
3852: PendOp->COMMAND.NDIS.SET_FILTER.Open->NdisBindingContext,
3853: PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp),
3854: NDIS_STATUS_SUCCESS
3855: );
3856:
3857: NdisAcquireSpinLock(&(Adapter->Lock));
3858:
3859:
3860: TmpOpen->References--;
3861:
3862: } else {
3863:
3864:
3865: //
3866: // complete the operation.
3867: //
3868:
3869: PIBMTOK_OPEN TmpOpen;
3870:
3871: Adapter->PendData = NULL;
3872:
3873: TmpOpen = PendOp->COMMAND.NDIS.SET_FILTER.Open;
3874:
3875: NdisReleaseSpinLock(&(Adapter->Lock));
3876:
3877: NdisCompleteRequest(
3878: PendOp->COMMAND.NDIS.SET_FILTER.Open->NdisBindingContext,
3879: PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp),
3880: NDIS_STATUS_FAILURE
3881: );
3882:
3883: NdisAcquireSpinLock(&(Adapter->Lock));
3884:
3885:
3886: TmpOpen->References--;
3887:
3888: }
3889:
3890: break;
3891:
3892:
3893: case NdisRequestClose:
3894: case NdisRequestGeneric2:
3895: case NdisRequestGeneric3:
3896:
3897: PendOp->COMMAND.NDIS.CLOSE.Open->References--;
3898:
3899: break;
3900:
3901: }
3902:
3903: //
3904: // Now finish up unsuccessful operations based on the type.
3905: //
3906: // NOTE: If we ever have cleanup for successful operations,
3907: // we probably have to copy that code into the
3908: // 'RequestStatus == NDIS_STATUS_SUCCESS' section
3909: // in the function above.
3910: //
3911:
3912: if (!Successful) {
3913:
3914: switch (PendOp->RequestType) {
3915:
3916: case NdisRequestSetInformation:
3917:
3918: //
3919: // We know it was a set filter or set address.
3920: //
3921:
3922: if ((PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp))->DATA.SET_INFORMATION.Oid ==
3923: OID_GEN_CURRENT_PACKET_FILTER){
3924:
3925: //
3926: // It was a set filter.
3927: //
3928:
3929:
3930: Adapter->CurrentPacketFilter = Adapter->OldPacketFilter;
3931:
3932: Adapter->CurrentCardFunctional = (TR_FUNCTIONAL_ADDRESS)0;
3933:
3934: } else {
3935:
3936: //
3937: // It was a set address.
3938: //
3939:
3940: Adapter->CurrentFunctionalAddress = (TR_FUNCTIONAL_ADDRESS)0;
3941:
3942: }
3943:
3944: break;
3945:
3946: case NdisRequestQueryStatistics:
3947:
3948: break;
3949:
3950: case NdisRequestClose:
3951: case NdisRequestGeneric2:
3952: case NdisRequestGeneric3:
3953:
3954: break;
3955:
3956: default:
3957:
3958: NdisWriteErrorLogEntry(
3959: Adapter->NdisAdapterHandle,
3960: NDIS_ERROR_CODE_DRIVER_FAILURE,
3961: 3,
3962: finishPendQueueOp,
3963: IBMTOK_ERRMSG_BAD_OP,
3964: PendOp->RequestType
3965: );
3966:
3967: break;
3968:
3969: }
3970: }
3971:
3972:
3973: return(TRUE);
3974:
3975: }
3976:
3977: STATIC
3978: NDIS_STATUS
3979: SetAdapterFunctionalAddress(
3980: IN PIBMTOK_ADAPTER Adapter
3981: )
3982:
3983:
3984: /*++
3985:
3986: Routine Description:
3987:
3988: This routine checks the functional address on the adapter
3989: against what it should be given the current packet filter
3990: and functional address specified, and queues an update
3991: if necessary.
3992:
3993: NOTE: This routine assumes that it is called with the lock
3994: acquired.
3995:
3996: Arguments:
3997:
3998: Adapter - The adapter to check.
3999:
4000: Return Value:
4001:
4002: NDIS_STATUS_SUCCESS - If no change is necessary.
4003: NDIS_STATUS_PENDING - If the change was queued.
4004:
4005:
4006: --*/
4007: {
4008: //
4009: // The new value we compute for the functional address that
4010: // should be on the card.
4011: //
4012: TR_FUNCTIONAL_ADDRESS NewCardFunctional;
4013:
4014: //
4015: // Holds the value to be returned.
4016: //
4017: NDIS_STATUS StatusOfSet;
4018:
4019: //
4020: // Used if ALL_MULTICAST is selected.
4021: //
4022: ULONG AllFunctionalAddress = 0x7fffffff;
4023:
4024: //
4025: // First calculate what the new functional address
4026: // should be.
4027: //
4028:
4029: #if DBG
4030: if (IbmtokDbg) {
4031: DbgPrint("IBMTOK: Current packet filter : 0x%x\n", Adapter->CurrentPacketFilter);
4032: }
4033: #endif
4034:
4035: if (Adapter->CurrentPacketFilter &
4036: NDIS_PACKET_TYPE_ALL_FUNCTIONAL) {
4037:
4038: //
4039: // We have to set all the bits in the address.
4040: //
4041:
4042: NewCardFunctional = AllFunctionalAddress;
4043:
4044: } else if (Adapter->CurrentPacketFilter &
4045: NDIS_PACKET_TYPE_FUNCTIONAL) {
4046:
4047: NewCardFunctional = Adapter->CurrentFunctionalAddress;
4048:
4049: } else {
4050:
4051: NewCardFunctional = (TR_FUNCTIONAL_ADDRESS)0;
4052:
4053: }
4054:
4055: #if DBG
4056: if (IbmtokDbg) {
4057: DbgPrint("IBMTOK: NewFunc is 0x%x\n", NewCardFunctional);
4058: }
4059: #endif
4060:
4061:
4062: //
4063: // Now queue it up if needed.
4064: //
4065:
4066: if (NewCardFunctional == Adapter->CurrentCardFunctional) {
4067:
4068: #if DBG
4069: if (IbmtokDbg) {
4070: DbgPrint("IBMTOK: SUCCESS\n\n");
4071: }
4072: #endif
4073:
4074: StatusOfSet = NDIS_STATUS_SUCCESS;
4075:
4076: } else {
4077:
4078: SetupFunctionalSrb(
4079: Adapter,
4080: NewCardFunctional
4081: );
4082: Adapter->CurrentCardFunctional = NewCardFunctional;
4083:
4084: StatusOfSet = NDIS_STATUS_PENDING;
4085:
4086: }
4087:
4088: return StatusOfSet;
4089:
4090: }
4091:
4092: STATIC
4093: VOID
4094: SetupFunctionalSrb(
4095: IN PIBMTOK_ADAPTER Adapter,
4096: IN TR_FUNCTIONAL_ADDRESS FunctionalAddress
4097: )
4098:
4099: /*++
4100:
4101: Routine Description:
4102:
4103: This routine sets up the SRB for a DIR.SET.FUNCT.Address.
4104:
4105: Arguments:
4106:
4107: Adapter - The adapter that this packet is coming through.
4108:
4109: FunctionalAddress - The address to set up.
4110:
4111: Return Value:
4112:
4113: None.
4114:
4115: --*/
4116:
4117: {
4118: //
4119: // Used to set up the SRB request.
4120: //
4121: PSRB_SET_FUNCT_ADDRESS FunctSrb =
4122: (PSRB_SET_FUNCT_ADDRESS)Adapter->SrbAddress;
4123:
4124: //
4125: // Used to hold the functional address temporarily.
4126: //
4127: UCHAR TempAddress[4];
4128:
4129: //
4130: // Used to copy down the functional address.
4131: //
4132: UINT i;
4133:
4134:
4135:
4136: NdisWriteRegisterUchar(&(FunctSrb->Command), SRB_CMD_SET_FUNCTIONAL_ADDRESS);
4137: NdisWriteRegisterUchar(&(FunctSrb->ReturnCode), 0xfe);
4138:
4139: //
4140: // Have to worry about setting the functional address
4141: // since it is not aligned correctly.
4142: //
4143: IBMTOK_STORE_ULONG(TempAddress, FunctionalAddress);
4144:
4145: for (i=0; i<4; i++) {
4146:
4147: NdisWriteRegisterUchar(&(FunctSrb->FunctionalAddress[i]), TempAddress[i]);
4148:
4149: }
4150:
4151: }
4152:
4153: STATIC
4154: NDIS_STATUS
4155: SetAdapterGroupAddress(
4156: IN PIBMTOK_ADAPTER Adapter
4157: )
4158:
4159:
4160: /*++
4161:
4162: Routine Description:
4163:
4164: This routine takes the value in Adapter->CurrentGroupAddress and
4165: puts it out to the card.
4166:
4167: NOTE: This routine assumes that it is called with the lock
4168: acquired.
4169:
4170: Arguments:
4171:
4172: Adapter - The adapter to check.
4173:
4174: Return Value:
4175:
4176: NDIS_STATUS_PENDING - If the change was queued.
4177:
4178:
4179: --*/
4180: {
4181: //
4182: // Holds the value to be returned.
4183: //
4184:
4185: SetupGroupSrb(
4186: Adapter,
4187: Adapter->CurrentGroupAddress
4188: );
4189:
4190: return NDIS_STATUS_PENDING;
4191:
4192: }
4193:
4194: STATIC
4195: VOID
4196: SetupGroupSrb(
4197: IN PIBMTOK_ADAPTER Adapter,
4198: IN TR_FUNCTIONAL_ADDRESS GroupAddress
4199: )
4200:
4201: /*++
4202:
4203: Routine Description:
4204:
4205: This routine sets up the SRB for a DIR.SET.GROUP.ADDRESS.
4206:
4207: Arguments:
4208:
4209: Adapter - The adapter that this packet is coming through.
4210:
4211: GroupAddress - The address to set up.
4212:
4213: Return Value:
4214:
4215: None.
4216:
4217: --*/
4218:
4219: {
4220: //
4221: // Used to set up the SRB request.
4222: //
4223: PSRB_SET_GROUP_ADDRESS GroupSrb =
4224: (PSRB_SET_GROUP_ADDRESS)Adapter->SrbAddress;
4225:
4226: //
4227: // Used to hold the group address temporarily.
4228: //
4229: UCHAR TempAddress[4];
4230:
4231: //
4232: // Used to copy down the group address.
4233: //
4234: UINT i;
4235:
4236:
4237:
4238: NdisWriteRegisterUchar(&(GroupSrb->Command), SRB_CMD_SET_GROUP_ADDRESS);
4239: NdisWriteRegisterUchar(&(GroupSrb->ReturnCode), 0xfe);
4240:
4241: //
4242: // Have to worry about setting the group address
4243: // since it is not aligned correctly.
4244: //
4245: IBMTOK_STORE_ULONG(TempAddress, GroupAddress);
4246:
4247: for (i=0; i<4; i++) {
4248:
4249: NdisWriteRegisterUchar(&(GroupSrb->GroupAddress[i]), TempAddress[i]);
4250:
4251: }
4252:
4253: }
4254:
4255: STATIC
4256: VOID
4257: SetupReceivedDataAsb(
4258: IN PIBMTOK_ADAPTER Adapter,
4259: IN SRAM_PTR ReceiveBuffer
4260: )
4261:
4262: /*++
4263:
4264: Routine Description:
4265:
4266: This routine sets up the ASB for a response from
4267: a RECEIVED.DATA ARB.
4268:
4269: Arguments:
4270:
4271: Adapter - The adapter that this packet is coming through.
4272:
4273: ReceiveBuffer - The first receive buffer in the frame.
4274:
4275: Return Value:
4276:
4277: None.
4278:
4279: --*/
4280:
4281: {
4282:
4283: PASB_RECEIVED_DATA_STATUS ReceivedDataAsb;
4284:
4285: ReceivedDataAsb = (PASB_RECEIVED_DATA_STATUS)
4286: Adapter->AsbAddress;
4287:
4288: NdisWriteRegisterUchar(&(ReceivedDataAsb->Command), ARB_CMD_RECEIVED_DATA);
4289: NdisWriteRegisterUchar(&(ReceivedDataAsb->ReturnCode), 0x00);
4290: NdisWriteRegisterUshort(&(ReceivedDataAsb->StationId), 0x0000);
4291: NdisWriteRegisterUshort(&(ReceivedDataAsb->ReceiveBuffer), ReceiveBuffer);
4292:
4293: }
4294:
4295: STATIC
4296: VOID
4297: PutPacketOnWaitingForAsb(
4298: IN PIBMTOK_ADAPTER Adapter,
4299: IN PNDIS_PACKET Packet
4300: )
4301:
4302: /*++
4303:
4304: Routine Description:
4305:
4306: This queues a packet on the Waiting To Copy queue.
4307: It is called and returns with the spinlock held.
4308:
4309: Arguments:
4310:
4311: Adapter - The adapter that this packet is coming through.
4312:
4313: Packet - The packet that is to be transmitted.
4314:
4315: Return Value:
4316:
4317: None.
4318:
4319: --*/
4320:
4321: {
4322:
4323: //
4324: // Points to the MAC reserved portion of this packet. This
4325: // interpretation of the reserved section is only valid during
4326: // the allocation phase of the packet.
4327: //
4328: PIBMTOK_RESERVED Reserved = PIBMTOK_RESERVED_FROM_PACKET(Packet);
4329:
4330:
4331: ASSERT(sizeof(IBMTOK_RESERVED) <=
4332: sizeof(Packet->MacReserved));
4333:
4334:
4335: if (Adapter->FirstWaitingForAsb == NULL) {
4336:
4337: Adapter->FirstWaitingForAsb = Packet;
4338:
4339: } else {
4340:
4341: PIBMTOK_RESERVED_FROM_PACKET(Adapter->FirstWaitingForAsb)->Next = Packet;
4342:
4343: }
4344:
4345: Adapter->LastWaitingForAsb = Packet;
4346:
4347: Reserved->Next = NULL;
4348:
4349: }
4350: extern
4351: VOID
4352: IbmtokHandleDeferred(
4353: IN PIBMTOK_ADAPTER Adapter
4354: )
4355:
4356: /*++
4357:
4358: Routine Description:
4359:
4360: This routine handles any pending resets and closes.
4361: It is called during interrupt processing and also at
4362: the end of every routine if needed.
4363:
4364: NOTE: This routine is called with the spinlock held
4365: and returns with it held.
4366:
4367: Arguments:
4368:
4369: Adapter - The adapter to check deferred processing on.
4370:
4371: Return Value:
4372:
4373: None.
4374:
4375: --*/
4376:
4377: {
4378: PIBMTOK_OPEN Open;
4379:
4380: //
4381: // Note that the following code depends on the fact that
4382: // code above left the spinlock held.
4383: //
4384:
4385: //
4386: // We will only come in here if the adapter's reference
4387: // count is zero, so if a reset is in progress then we
4388: // can start the reset.
4389: //
4390:
4391:
4392:
4393: //
4394: // Make sure we don't start it twice!!
4395: //
4396:
4397: Adapter->References++;
4398:
4399: if (Adapter->ResetInProgress && Adapter->CurrentResetStage == 0) {
4400:
4401: Adapter->CurrentResetStage = 1;
4402:
4403: NdisReleaseSpinLock(&(Adapter->Lock));
4404:
4405: IbmtokStartAdapterReset(Adapter);
4406:
4407: NdisAcquireSpinLock(&(Adapter->Lock));
4408:
4409: }
4410:
4411:
4412: if (!Adapter->ResetInProgress && !IsListEmpty(&(Adapter->CloseDuringResetList))) {
4413:
4414:
4415: //
4416: // Status of the Filter delete call.
4417: //
4418:
4419: NDIS_STATUS Status;
4420:
4421: Open = CONTAINING_RECORD(
4422: Adapter->CloseDuringResetList.Flink,
4423: IBMTOK_OPEN,
4424: OpenList
4425: );
4426:
4427: Open->References++;
4428: #if DBG
4429: if (IbmtokDbg) DbgPrint("IBMTOK: Calling TrDelete\n");
4430: #endif
4431:
4432: Status = TrDeleteFilterOpenAdapter(
4433: Adapter->FilterDB,
4434: Open->NdisFilterHandle,
4435: NULL
4436: );
4437:
4438: #if DBG
4439: if (IbmtokDbg) DbgPrint("IBMTOK: TrDelete returned\n");
4440: #endif
4441:
4442: //
4443: // If the status is successful that merely implies that
4444: // we were able to delete the reference to the open binding
4445: // from the filtering code. If we have a successful status
4446: // at this point we still need to check whether the reference
4447: // count to determine whether we can close.
4448: //
4449: //
4450: // The delete filter routine can return a "special" status
4451: // that indicates that there is a current NdisIndicateReceive
4452: // on this binding.
4453: //
4454:
4455:
4456: if (Status == NDIS_STATUS_SUCCESS) {
4457:
4458: //
4459: // Check whether the reference count is two. If
4460: // it is then we can get rid of the memory for
4461: // this open.
4462: //
4463: // A count of two indicates one for this routine
4464: // and one for the filter which we *know* we can
4465: // get rid of.
4466: //
4467:
4468: if (Open->References == 2) {
4469:
4470: //
4471: // We are the only reference to the open. Remove
4472: // it from the list and delete the memory.
4473: //
4474:
4475: RemoveEntryList(&Open->OpenList);
4476:
4477: //
4478: // Complete the close here.
4479: //
4480:
4481: if (Adapter->LookAhead == Open->LookAhead) {
4482:
4483: IbmtokAdjustMaxLookAhead(Adapter);
4484:
4485: }
4486:
4487: NdisReleaseSpinLock(&Adapter->Lock);
4488:
4489: NdisCompleteCloseAdapter(
4490: Open->NdisBindingContext,
4491: NDIS_STATUS_SUCCESS
4492: );
4493:
4494: IBMTOK_FREE_PHYS(Open,sizeof(IBMTOK_OPEN));
4495:
4496: NdisAcquireSpinLock(&Adapter->Lock);
4497:
4498:
4499: } else {
4500:
4501: //
4502: // Remove the open from the list and put it on
4503: // the closing list.
4504: //
4505:
4506: RemoveEntryList(&Open->OpenList);
4507:
4508: InsertTailList(&Adapter->CloseList,&Open->OpenList);
4509:
4510: //
4511: // Account for this routines reference to the open
4512: // as well as reference because of the filtering.
4513: //
4514:
4515: Open->References -= 2;
4516:
4517:
4518: }
4519:
4520: } else if (Status == NDIS_STATUS_PENDING) {
4521:
4522:
4523: //
4524: // If it pended, there may be
4525: // operations queued.
4526: // Returns with lock released
4527: //
4528:
4529: IbmtokProcessSrbRequests(Adapter);
4530:
4531: //
4532: // Now start closing down this open.
4533: //
4534:
4535: Open->BindingShuttingDown = TRUE;
4536:
4537: //
4538: // Remove the open from the open list and put it on
4539: // the closing list.
4540: //
4541:
4542: RemoveEntryList(&Open->OpenList);
4543: InsertTailList(&Adapter->CloseList,&Open->OpenList);
4544:
4545: //
4546: // Account for this routines reference to the open
4547: // as well as reference because of the filtering.
4548: //
4549:
4550: Open->References -= 2;
4551:
4552: } else {
4553:
4554: //
4555: // We should not get RESET_IN_PROGRESS or any other types.
4556: //
4557:
4558: NdisWriteErrorLogEntry(
4559: Adapter->NdisAdapterHandle,
4560: NDIS_ERROR_CODE_DRIVER_FAILURE,
4561: 3,
4562: handleDeferred,
4563: IBMTOK_ERRMSG_INVALID_STATUS,
4564: Status
4565: );
4566:
4567: }
4568:
4569: }
4570:
4571: //
4572: // If there are any opens on the closing list and their
4573: // reference counts are zero then complete the close and
4574: // delete them from the list.
4575: //
4576: //
4577:
4578: if (!IsListEmpty(&(Adapter->CloseList))){
4579:
4580: Open = CONTAINING_RECORD(
4581: Adapter->CloseList.Flink,
4582: IBMTOK_OPEN,
4583: OpenList
4584: );
4585:
4586: if (!Open->References) {
4587:
4588: if (Adapter->LookAhead == Open->LookAhead) {
4589:
4590: IbmtokAdjustMaxLookAhead(Adapter);
4591:
4592: }
4593:
4594: NdisReleaseSpinLock(&(Adapter->Lock));
4595:
4596: NdisCompleteCloseAdapter(
4597: Open->NdisBindingContext,
4598: NDIS_STATUS_SUCCESS
4599: );
4600:
4601: NdisAcquireSpinLock(&(Adapter->Lock));
4602: RemoveEntryList(&(Open->OpenList));
4603: IBMTOK_FREE_PHYS(Open, sizeof(IBMTOK_OPEN));
4604:
4605: }
4606:
4607: }
4608:
4609: Adapter->References--;
4610:
4611: }
4612:
4613: extern
4614: VOID
4615: IbmtokAbortPending(
4616: IN PIBMTOK_ADAPTER Adapter,
4617: IN NDIS_STATUS AbortStatus
4618: )
4619:
4620: /*++
4621:
4622: Routine Description:
4623:
4624: This routine aborts any pending requests, and calls
4625: IbmtokAbortSends to abort any pending sends.
4626:
4627: NOTE: This routine is called with the spinlock held
4628: and returns with it held.
4629:
4630: Arguments:
4631:
4632: Adapter - The adapter to abort.
4633:
4634: AbortStatus - The status to complete requests with.
4635:
4636: Return Value:
4637:
4638: None.
4639:
4640: --*/
4641:
4642: {
4643: PIBMTOK_OPEN Open;
4644: PIBMTOK_PEND_DATA PendOp;
4645:
4646: while (Adapter->PendQueue) {
4647:
4648: //
4649: // Holds the operation on the head of the queue
4650: //
4651:
4652: PendOp = Adapter->PendQueue;
4653:
4654: Adapter->PendQueue = Adapter->PendQueue->Next;
4655:
4656: if (Adapter->PendQueue == NULL){
4657:
4658: //
4659: // We have just emptied the list.
4660: //
4661:
4662: Adapter->EndOfPendQueue = NULL;
4663:
4664: }
4665:
4666: switch (PendOp->RequestType) {
4667:
4668: case NdisRequestSetInformation:
4669:
4670: //
4671: // Complete the request.
4672: //
4673:
4674: Open = PendOp->COMMAND.NDIS.SET_FILTER.Open;
4675:
4676: NdisDprReleaseSpinLock(&(Adapter->Lock));
4677:
4678: NdisCompleteRequest(
4679: Open->NdisBindingContext,
4680: PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp),
4681: AbortStatus
4682: );
4683:
4684: NdisDprAcquireSpinLock(&(Adapter->Lock));
4685:
4686: Open->References--;
4687:
4688: break;
4689:
4690:
4691: case NdisRequestClose:
4692:
4693: PendOp->COMMAND.NDIS.CLOSE.Open->References--;
4694: break;
4695:
4696: case NdisRequestGeneric1:
4697:
4698: //
4699: // Submitted by the driver
4700: //
4701:
4702: IBMTOK_FREE_PHYS(PendOp, sizeof(IBMTOK_PEND_DATA));
4703: Adapter->PendData = NULL;
4704: break;
4705:
4706: case NdisRequestGeneric2:
4707: case NdisRequestGeneric3:
4708:
4709: //
4710: // Changes in address and filters due to a close
4711: //
4712:
4713: PendOp->COMMAND.NDIS.SET_ADDRESS.Open->References--;
4714: break;
4715:
4716:
4717: case NdisRequestQueryStatistics:
4718:
4719: NdisDprReleaseSpinLock(&(Adapter->Lock));
4720:
4721: NdisCompleteQueryStatistics(
4722: Adapter->NdisMacHandle,
4723: PNDIS_REQUEST_FROM_PIBMTOK_PEND_DATA(PendOp),
4724: AbortStatus
4725: );
4726:
4727: NdisDprAcquireSpinLock(&(Adapter->Lock));
4728:
4729: Adapter->References--;
4730:
4731: break;
4732:
4733: }
4734:
4735: }
4736:
4737: IbmtokAbortSends (Adapter, AbortStatus);
4738:
4739: }
4740:
4741: extern
4742: VOID
4743: IbmtokAbortSends(
4744: IN PIBMTOK_ADAPTER Adapter,
4745: IN NDIS_STATUS AbortStatus
4746: )
4747:
4748: /*++
4749:
4750: Routine Description:
4751:
4752: This routine aborts any pending sends.
4753:
4754: NOTE: This routine is called with the spinlock held
4755: and returns with it held.
4756:
4757: Arguments:
4758:
4759: Adapter - The adapter to abort.
4760:
4761: AbortStatus - The status to complete requests with.
4762:
4763: Return Value:
4764:
4765: None.
4766:
4767: --*/
4768:
4769: {
4770: PIBMTOK_OPEN Open;
4771: PNDIS_PACKET TransmitPacket;
4772: PIBMTOK_RESERVED Reserved;
4773: UINT i;
4774:
4775: //
4776: // First the packet in the SRB.
4777: //
4778:
4779: if (Adapter->TransmittingPacket != NULL) {
4780:
4781: TransmitPacket = Adapter->TransmittingPacket;
4782: Adapter->TransmittingPacket = NULL;
4783:
4784: Reserved = PIBMTOK_RESERVED_FROM_PACKET(TransmitPacket);
4785: Open = PIBMTOK_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle);
4786:
4787: NdisDprReleaseSpinLock(&Adapter->Lock);
4788:
4789: NdisCompleteSend(
4790: Open->NdisBindingContext,
4791: TransmitPacket,
4792: AbortStatus
4793: );
4794:
4795: NdisDprAcquireSpinLock(&Adapter->Lock);
4796: Open->References--;
4797: }
4798:
4799: //
4800: // Then any that are queued up waiting to be given to the card.
4801: //
4802:
4803: while (Adapter->FirstTransmit) {
4804:
4805: TransmitPacket = Adapter->FirstTransmit;
4806:
4807: Reserved = PIBMTOK_RESERVED_FROM_PACKET(TransmitPacket);
4808: Adapter->FirstTransmit = Reserved->Next;
4809:
4810: Open = PIBMTOK_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle);
4811:
4812: NdisDprReleaseSpinLock(&Adapter->Lock);
4813:
4814: NdisCompleteSend(
4815: Open->NdisBindingContext,
4816: TransmitPacket,
4817: AbortStatus
4818: );
4819:
4820: NdisDprAcquireSpinLock(&Adapter->Lock);
4821: Open->References--;
4822:
4823: }
4824:
4825: //
4826: // Finally, the Correlator array (this will include any
4827: // packets on WaitingForAsb).
4828: //
4829:
4830: for (i=0; i<MAX_COMMAND_CORRELATOR; i++) {
4831:
4832: TransmitPacket = Adapter->CorrelatorArray[i];
4833:
4834: if (TransmitPacket != NULL) {
4835:
4836: RemovePacketFromCorrelatorArray (Adapter, TransmitPacket);
4837:
4838: Reserved = PIBMTOK_RESERVED_FROM_PACKET(TransmitPacket);
4839: Open = PIBMTOK_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle);
4840:
4841: NdisDprReleaseSpinLock(&Adapter->Lock);
4842:
4843: NdisCompleteSend(
4844: Open->NdisBindingContext,
4845: Reserved->Packet,
4846: AbortStatus
4847: );
4848:
4849: NdisDprAcquireSpinLock(&Adapter->Lock);
4850: Open->References--;
4851: }
4852:
4853: }
4854:
4855: Adapter->FirstWaitingForAsb = NULL;
4856:
4857: }
4858:
4859: VOID
4860: IbmtokWakeUpDpc(
4861: IN PVOID SystemSpecific1,
4862: IN PVOID Context,
4863: IN PVOID SystemSpecific2,
4864: IN PVOID SystemSpecific3
4865: )
4866:
4867: /*++
4868:
4869: Routine Description:
4870:
4871: This DPC routine is queued every 2 seconds to check on the
4872: queues. If an interrupt was not received
4873: in the last two seconds and there should have been one,
4874: then we abort all operations.
4875:
4876: Arguments:
4877:
4878: Context - Really a pointer to the adapter.
4879:
4880: Return Value:
4881:
4882: None.
4883:
4884: --*/
4885: {
4886: PIBMTOK_ADAPTER Adapter = (PIBMTOK_ADAPTER)Context;
4887:
4888: UNREFERENCED_PARAMETER(SystemSpecific1);
4889: UNREFERENCED_PARAMETER(SystemSpecific2);
4890: UNREFERENCED_PARAMETER(SystemSpecific3);
4891:
4892: NdisDprAcquireSpinLock(&Adapter->Lock);
4893:
4894: if ((Adapter->WakeUpTimeout) &&
4895: ((Adapter->TransmittingPacket != NULL) ||
4896: (Adapter->FirstTransmit != NULL) ||
4897: (Adapter->PendQueue != NULL))) {
4898:
4899: //
4900: // We had a pending operation the last time we ran,
4901: // and it has not been completed...we need to complete
4902: // it now.
4903:
4904: Adapter->NotAcceptingRequests = TRUE;
4905:
4906: Adapter->WakeUpTimeout = FALSE;
4907:
4908: NdisWriteErrorLogEntry(
4909: Adapter->NdisAdapterHandle,
4910: NDIS_ERROR_CODE_HARDWARE_FAILURE,
4911: 0
4912: );
4913:
4914: //
4915: // Complete any pending requests or sends.
4916: //
4917:
4918: IbmtokAbortPending (Adapter, STATUS_SUCCESS);
4919:
4920: Adapter->WakeUpTimeout = FALSE;
4921:
4922: } else {
4923:
4924: if ((Adapter->TransmittingPacket != NULL) ||
4925: (Adapter->FirstTransmit != NULL) ||
4926: (Adapter->PendQueue != NULL)) {
4927:
4928: Adapter->WakeUpTimeout = TRUE;
4929:
4930: }
4931:
4932: }
4933:
4934: //
4935: // If we've been unplugged, and there is not a reset in
4936: // progress, try one.
4937: //
4938:
4939: if ((Adapter->LobeWireFaultIndicated) & (!Adapter->UnpluggedResetInProgress)) {
4940:
4941: Adapter->UnpluggedResetInProgress = TRUE;
4942:
4943: IbmtokSetupForReset(Adapter, NULL);
4944:
4945: IbmtokHandleDeferred(Adapter);
4946: }
4947:
4948: NdisDprReleaseSpinLock(&Adapter->Lock);
4949:
4950: //
4951: // Fire off another Dpc to execute after 30 seconds
4952: //
4953:
4954: NdisSetTimer(
4955: &Adapter->WakeUpTimer,
4956: 30000
4957: );
4958:
4959: }
4960:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.