![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lance.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / lance|
Return to lance.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / lance |
1.1 root 1: /*++
2:
3: Copyright (c) 1990 Microsoft Corporation
4:
5: Module Name:
6:
7: lance.c
8:
9: Abstract:
10:
11: This is the main file for the Advanced Micro Devices LANCE (Am 7990)
12: Ethernet controller. This driver conforms to the NDIS 3.0 interface.
13:
14: The idea for handling loopback and sends simultaneously is largely
15: adapted from the EtherLink II NDIS driver by Adam Barr.
16:
17: Author:
18:
19: Anthony V. Ercolano (Tonye) 20-Jul-1990
20:
21: Environment:
22:
23: Kernel Mode - Or whatever is the equivalent on OS/2 and DOS.
24:
25: Revision History:
26:
27: 31-Jul-1992 R.D. Lanser:
28:
29: Changed DECST card type to DECTC for the DEC TurboChannel option
30: PMAD-AA (Lance ethernet). This option will be available for all
31: TurboChannel systems regardless of CPU type or system.
32:
33: Removed UsedLanceBuffer conditional (always true).
34:
35: Added InterruptRequestLevel to the _LANCE_ADAPTER structure because
36: 'lance.c' was passing the InterruptVector as the IRQL to the interrupt
37: connect routine which is not correct. This works on JAZZ because the
38: JAZZ HalGetInterruptVector is hardcoded to return a fixed IRQL for
39: EISA devices.
40:
41: Remove hardcoded configuration information and added gets from the
42: registry for the base address, interrupt vector, and interrupt
43: request level.
44:
45:
46: --*/
47:
48: #include <ndis.h>
49: #include <efilter.h>
50: #include "lancehrd.h"
51: #include "lancesft.h"
52: #include "dectc.h"
53:
54: #if DBG
55: #define STATIC
56: #else
57: #define STATIC static
58: #endif
59:
60:
61: #if DBG
62:
63: UCHAR LanceSendFails[256];
64: UCHAR LanceSendFailPlace = 0;
65:
66: #endif
67:
68:
69: NDIS_HANDLE LanceNdisWrapperHandle;
70: NDIS_HANDLE LanceMacHandle;
71: PDRIVER_OBJECT LanceDriverObject;
72:
73: //
74: // This constant is used for places where NdisAllocateMemory
75: // needs to be called and the HighestAcceptableAddress does
76: // not matter.
77: //
78:
79: NDIS_PHYSICAL_ADDRESS HighestAcceptableMax =
80: NDIS_PHYSICAL_ADDRESS_CONST(-1,-1);
81:
82:
83: #if LANCELOG
84:
85: NDIS_TIMER LogTimer;
86: BOOLEAN LogTimerRunning = FALSE;
87:
88: UCHAR Log[LOG_SIZE];
89:
90: UCHAR LogPlace = 0;
91: UCHAR LogWrapped = 0;
92:
93: UCHAR LancePrintLog = 0;
94:
95: void
96: LogDpc(
97: IN PVOID SystemSpecific1,
98: PVOID Context,
99: IN PVOID SystemSpecific2,
100: IN PVOID SystemSpecific3
101: )
102: {
103:
104: UNREFERENCED_PARAMETER(Context);
105: UNREFERENCED_PARAMETER(SystemSpecific1);
106: UNREFERENCED_PARAMETER(SystemSpecific2);
107: UNREFERENCED_PARAMETER(SystemSpecific3);
108:
109: LOG(TIMER);
110:
111: NdisSetTimer(&LogTimer, 1000);
112:
113: }
114:
115:
116: #endif
117:
118:
119:
120:
121: #define MAX_MULTICAST_ADDRESS ((UINT)32)
122:
123: //
124: // Used for accessing the filter package multicast address list.
125: //
126:
127: static CHAR MulticastAddresses[MAX_MULTICAST_ADDRESS][ETH_LENGTH_OF_ADDRESS];
128:
129:
130:
131: //
132: // If you add to this, make sure to add the
133: // a case in LanceFillInGlobalData() and in
134: // LanceQueryGlobalStatistics() if global
135: // information only or
136: // LanceQueryProtocolStatistics() if it is
137: // protocol queriable information.
138: //
139: UINT LanceGlobalSupportedOids[] = {
140: OID_GEN_SUPPORTED_LIST,
141: OID_GEN_HARDWARE_STATUS,
142: OID_GEN_MEDIA_SUPPORTED,
143: OID_GEN_MEDIA_IN_USE,
144: OID_GEN_MAXIMUM_LOOKAHEAD,
145: OID_GEN_MAXIMUM_FRAME_SIZE,
146: OID_GEN_MAXIMUM_TOTAL_SIZE,
147: OID_GEN_MAC_OPTIONS,
148: OID_GEN_PROTOCOL_OPTIONS,
149: OID_GEN_LINK_SPEED,
150: OID_GEN_TRANSMIT_BUFFER_SPACE,
151: OID_GEN_RECEIVE_BUFFER_SPACE,
152: OID_GEN_TRANSMIT_BLOCK_SIZE,
153: OID_GEN_RECEIVE_BLOCK_SIZE,
154: OID_GEN_VENDOR_ID,
155: OID_GEN_VENDOR_DESCRIPTION,
156: OID_GEN_DRIVER_VERSION,
157: OID_GEN_CURRENT_PACKET_FILTER,
158: OID_GEN_CURRENT_LOOKAHEAD,
159: OID_GEN_XMIT_OK,
160: OID_GEN_RCV_OK,
161: OID_GEN_XMIT_ERROR,
162: OID_GEN_RCV_ERROR,
163: OID_GEN_RCV_NO_BUFFER,
164: OID_802_3_PERMANENT_ADDRESS,
165: OID_802_3_CURRENT_ADDRESS,
166: OID_802_3_MULTICAST_LIST,
167: OID_802_3_MAXIMUM_LIST_SIZE,
168: OID_802_3_RCV_ERROR_ALIGNMENT,
169: OID_802_3_XMIT_ONE_COLLISION,
170: OID_802_3_XMIT_MORE_COLLISIONS
171: };
172:
173: //
174: // If you add to this, make sure to add the
175: // a case in LanceQueryGlobalStatistics() and in
176: // LanceQueryProtocolInformation()
177: //
178: UINT LanceProtocolSupportedOids[] = {
179: OID_GEN_SUPPORTED_LIST,
180: OID_GEN_HARDWARE_STATUS,
181: OID_GEN_MEDIA_SUPPORTED,
182: OID_GEN_MEDIA_IN_USE,
183: OID_GEN_MAXIMUM_LOOKAHEAD,
184: OID_GEN_MAXIMUM_FRAME_SIZE,
185: OID_GEN_MAXIMUM_TOTAL_SIZE,
186: OID_GEN_MAC_OPTIONS,
187: OID_GEN_PROTOCOL_OPTIONS,
188: OID_GEN_LINK_SPEED,
189: OID_GEN_TRANSMIT_BUFFER_SPACE,
190: OID_GEN_RECEIVE_BUFFER_SPACE,
191: OID_GEN_TRANSMIT_BLOCK_SIZE,
192: OID_GEN_RECEIVE_BLOCK_SIZE,
193: OID_GEN_VENDOR_ID,
194: OID_GEN_VENDOR_DESCRIPTION,
195: OID_GEN_DRIVER_VERSION,
196: OID_GEN_CURRENT_PACKET_FILTER,
197: OID_GEN_CURRENT_LOOKAHEAD,
198: OID_802_3_PERMANENT_ADDRESS,
199: OID_802_3_CURRENT_ADDRESS,
200: OID_802_3_MULTICAST_LIST,
201: OID_802_3_MAXIMUM_LIST_SIZE
202: };
203:
204:
205:
206: //
207: // This macro is to synchronize execution with interrupts. It
208: // gets the stored value of the CSR 0 and clears the old value.
209: //
210: #define GET_CSR0_SINCE_LAST_PROCESSED(A,V) \
211: { \
212: PLANCE_ADAPTER _A = A; \
213: LANCE_SYNCH_CONTEXT _C; \
214: _C.Adapter = _A; \
215: _C.LocalRead = (V); \
216: NdisSynchronizeWithInterrupt( \
217: &(_A)->Interrupt, \
218: LanceInterruptSynch, \
219: &_C \
220: ); \
221: }
222:
223: //
224: // We define a constant csr0 value that is useful for initializing
225: // an already stopped LANCE.
226: //
227: // This also enables the chip for interrupts.
228: //
229: #define LANCE_CSR0_INIT_CHIP ((USHORT)0x41)
230:
231: //
232: // We define a constant csr0 value that is useful for clearing all of
233: // the interesting bits that *could* be set on an interrupt.
234: //
235: #define LANCE_CSR0_CLEAR_INTERRUPT_BITS ((USHORT)0x7f00)
236:
237: STATIC
238: NDIS_STATUS
239: LanceOpenAdapter(
240: OUT PNDIS_STATUS OpenErrorStatus,
241: OUT NDIS_HANDLE *MacBindingHandle,
242: OUT PUINT SelectedMediumIndex,
243: IN PNDIS_MEDIUM MediumArray,
244: IN UINT MediumArraySize,
245: IN NDIS_HANDLE NdisBindingContext,
246: IN NDIS_HANDLE MacAdapterContext,
247: IN UINT OpenOptions,
248: IN PSTRING AddressingInformation OPTIONAL
249: );
250:
251:
252: VOID
253: LanceUnload(
254: IN NDIS_HANDLE MacMacContext
255: );
256:
257: STATIC
258: NDIS_STATUS
259: LanceCloseAdapter(
260: IN NDIS_HANDLE MacBindingHandle
261: );
262:
263:
264: STATIC
265: NDIS_STATUS
266: LanceRequest(
267: IN NDIS_HANDLE MacBindingHandle,
268: IN PNDIS_REQUEST NdisRequest
269: );
270:
271: NDIS_STATUS
272: LanceQueryProtocolInformation(
273: IN PLANCE_ADAPTER Adapter,
274: IN PLANCE_OPEN Open,
275: IN NDIS_OID Oid,
276: IN BOOLEAN GlobalMode,
277: IN PVOID InfoBuffer,
278: IN UINT BytesLeft,
279: OUT PUINT BytesNeeded,
280: OUT PUINT BytesWritten
281: );
282:
283: NDIS_STATUS
284: LanceQueryInformation(
285: IN PLANCE_ADAPTER Adapter,
286: IN PLANCE_OPEN Open,
287: IN PNDIS_REQUEST NdisRequest
288: );
289:
290: NDIS_STATUS
291: LanceSetInformation(
292: IN PLANCE_ADAPTER Adapter,
293: IN PLANCE_OPEN Open,
294: IN PNDIS_REQUEST NdisRequest
295: );
296:
297: STATIC
298: NDIS_STATUS
299: LanceReset(
300: IN NDIS_HANDLE MacBindingHandle
301: );
302:
303:
304: STATIC
305: NDIS_STATUS
306: LanceSetPacketFilter(
307: IN PLANCE_ADAPTER Adapter,
308: IN PLANCE_OPEN Open,
309: IN PNDIS_REQUEST NdisRequest,
310: IN UINT PacketFilter
311: );
312:
313:
314: NDIS_STATUS
315: LanceFillInGlobalData(
316: IN PLANCE_ADAPTER Adapter,
317: IN PNDIS_REQUEST NdisRequest
318: );
319:
320:
321: STATIC
322: NDIS_STATUS
323: LanceQueryGlobalStatistics(
324: IN NDIS_HANDLE MacAdapterContext,
325: IN PNDIS_REQUEST NdisRequest
326: );
327:
328: NDIS_STATUS
329: LanceChangeMulticastAddresses(
330: IN UINT OldFilterCount,
331: IN CHAR OldAddresses[][ETH_LENGTH_OF_ADDRESS],
332: IN UINT NewFilterCount,
333: IN CHAR NewAddresses[][ETH_LENGTH_OF_ADDRESS],
334: IN NDIS_HANDLE MacBindingHandle,
335: IN PNDIS_REQUEST NdisRequest,
336: IN BOOLEAN Set
337: );
338:
339: STATIC
340: NDIS_STATUS
341: LanceChangeFilterClasses(
342: IN UINT OldFilterClasses,
343: IN UINT NewFilterClasses,
344: IN NDIS_HANDLE MacBindingHandle,
345: IN PNDIS_REQUEST NdisRequest,
346: IN BOOLEAN Set
347: );
348:
349: STATIC
350: VOID
351: LanceCloseAction(
352: IN NDIS_HANDLE MacBindingHandle
353: );
354:
355: STATIC
356: BOOLEAN
357: AllocateAdapterMemory(
358: IN PLANCE_ADAPTER Adapter
359: );
360:
361: STATIC
362: VOID
363: DeleteAdapterMemory(
364: IN PLANCE_ADAPTER Adapter
365: );
366:
367: STATIC
368: VOID
369: ReturnAdapterResources(
370: IN PLANCE_ADAPTER Adapter,
371: IN UINT BufferIndex
372: );
373:
374: STATIC
375: VOID
376: RelinquishReceivePacket(
377: IN PLANCE_ADAPTER Adapter,
378: IN UINT StartingIndex,
379: IN UINT NumberOfBuffers
380: );
381:
382: STATIC
383: BOOLEAN
384: ProcessReceiveInterrupts(
385: IN PLANCE_ADAPTER Adapter
386: );
387:
388: STATIC
389: BOOLEAN
390: ProcessTransmitInterrupts(
391: IN PLANCE_ADAPTER Adapter
392: );
393:
394: STATIC
395: VOID
396: LanceStandardInterruptDPC(
397: IN PVOID SystemSpecific,
398: IN PVOID Context,
399: IN PVOID SystemArgument1,
400: IN PVOID SystemArgument2
401: );
402:
403:
404: extern
405: BOOLEAN
406: LanceISR(
407: IN PVOID Context
408: );
409:
410: STATIC
411: BOOLEAN
412: LanceInterruptSynch(
413: IN PVOID Context
414: );
415:
416: STATIC
417: UINT
418: CalculateCRC(
419: IN UINT NumberOfBytes,
420: IN PCHAR Input
421: );
422:
423: STATIC
424: VOID
425: ProcessInterrupt(
426: IN PLANCE_ADAPTER Adapter
427: );
428:
429: STATIC
430: VOID
431: LanceStartChip(
432: IN PLANCE_ADAPTER Adapter
433: );
434:
435: STATIC
436: VOID
437: LanceSetInitializationBlock(
438: IN PLANCE_ADAPTER Adapter
439: );
440:
441: STATIC
442: VOID
443: SetInitBlockAndInit(
444: IN PLANCE_ADAPTER Adapter
445: );
446:
447: STATIC
448: VOID
449: StartAdapterReset(
450: IN PLANCE_ADAPTER Adapter
451: );
452:
453: STATIC
454: VOID
455: SetupForReset(
456: IN PLANCE_ADAPTER Adapter,
457: IN PLANCE_OPEN Open,
458: IN PNDIS_REQUEST NdisRequest,
459: IN NDIS_REQUEST_TYPE RequestType
460: );
461:
462: STATIC
463: NDIS_STATUS
464: LanceInitialInit(
465: IN PLANCE_ADAPTER Adapter
466: );
467:
468:
469: STATIC
470: VOID
471: FinishPendOp(
472: IN PLANCE_ADAPTER Adapter,
473: IN BOOLEAN Successful
474: );
475:
476:
477: //
478: // Non portable interface.
479: //
480:
481: NTSTATUS
482: DriverEntry(
483: IN PDRIVER_OBJECT DriverObject,
484: IN PUNICODE_STRING RegistryPath
485: )
486:
487: /*++
488:
489: Routine Description:
490:
491: This is the primary initialization routine for the lance driver.
492: It is simply responsible for the intializing the wrapper and registering
493: the MAC. It then calls a system and architecture specific routine that
494: will initialize and register each adapter.
495:
496: Arguments:
497:
498: DriverObject - Pointer to driver object created by the system.
499:
500: Return Value:
501:
502: The status of the operation.
503:
504: --*/
505:
506: {
507:
508:
509: //
510: // Receives the status of the NdisRegisterMac operation.
511: //
512: NDIS_STATUS InitStatus;
513:
514: NDIS_HANDLE NdisMacHandle;
515:
516: NDIS_HANDLE NdisWrapperHandle;
517:
518: char Tmp[sizeof(NDIS_MAC_CHARACTERISTICS)];
519: PNDIS_MAC_CHARACTERISTICS LanceChar = (PNDIS_MAC_CHARACTERISTICS)Tmp;
520:
521: NDIS_STRING MacName = NDIS_STRING_CONST("Lance");
522:
523: //
524: // Initialize the wrapper.
525: //
526:
527: NdisInitializeWrapper(&NdisWrapperHandle,
528: DriverObject,
529: RegistryPath,
530: NULL
531: );
532:
533: //
534: // Initialize the MAC characteristics for the call to
535: // NdisRegisterMac.
536: //
537:
538: LanceChar->MajorNdisVersion = LANCE_NDIS_MAJOR_VERSION;
539: LanceChar->MinorNdisVersion = LANCE_NDIS_MINOR_VERSION;
540: LanceChar->OpenAdapterHandler = LanceOpenAdapter;
541: LanceChar->CloseAdapterHandler = LanceCloseAdapter;
542: LanceChar->SendHandler = LanceSend;
543: LanceChar->TransferDataHandler = LanceTransferData;
544: LanceChar->ResetHandler = LanceReset;
545: LanceChar->RequestHandler = LanceRequest;
546: LanceChar->AddAdapterHandler = LanceAddAdapter;
547: LanceChar->UnloadMacHandler = LanceUnload;
548: LanceChar->RemoveAdapterHandler = LanceRemoveAdapter;
549: LanceChar->QueryGlobalStatisticsHandler = LanceQueryGlobalStatistics;
550:
551: LanceChar->Name = MacName;
552:
553: LanceDriverObject = DriverObject;
554: LanceNdisWrapperHandle = NdisWrapperHandle;
555:
556: NdisRegisterMac(
557: &InitStatus,
558: &NdisMacHandle,
559: NdisWrapperHandle,
560: &NdisMacHandle,
561: LanceChar,
562: sizeof(*LanceChar)
563: );
564:
565: LanceMacHandle = NdisMacHandle;
566:
567: if (InitStatus == NDIS_STATUS_SUCCESS) {
568:
569: return NDIS_STATUS_SUCCESS;
570:
571: }
572:
573: NdisTerminateWrapper(NdisWrapperHandle, NULL);
574:
575: return NDIS_STATUS_FAILURE;
576:
577: }
578:
579: NDIS_STATUS
580: LanceAddAdapter(
581: IN NDIS_HANDLE MacMacContext,
582: IN NDIS_HANDLE ConfigurationHandle,
583: IN PNDIS_STRING AdapterName
584: )
585: /*++
586: Routine Description:
587:
588: This is the Wd MacAddAdapter routine. The system calls this routine
589: to add support for a particular WD adapter. This routine extracts
590: configuration information from the configuration data base and registers
591: the adapter with NDIS.
592:
593: Arguments:
594:
595: see NDIS 3.0 spec...
596:
597: Return Value:
598:
599: NDIS_STATUS_SUCCESS - Adapter was successfully added.
600: NDIS_STATUS_FAILURE - Adapter was not added, also MAC deregistered.
601:
602: --*/
603: {
604: //
605: // Pointer for the adapter root.
606: //
607: PLANCE_ADAPTER Adapter;
608:
609:
610: NDIS_HANDLE ConfigHandle;
611: PNDIS_CONFIGURATION_PARAMETER ReturnedValue;
612: NDIS_STRING IoAddressStr = NDIS_STRING_CONST("IoBaseAddress");
613: NDIS_STRING MaxMulticastListStr = NDIS_STRING_CONST("MaximumMulticastList");
614: NDIS_STRING NetworkAddressStr = NDIS_STRING_CONST("NetworkAddress");
615: NDIS_STRING InterruptStr = NDIS_STRING_CONST("InterruptNumber");
616: NDIS_STRING CardStr = NDIS_STRING_CONST("CardType");
617: NDIS_STRING MemoryBaseAddrStr = NDIS_STRING_CONST("MemoryMappedBaseAddress");
618:
619: NDIS_HANDLE NdisMacHandle = (NDIS_HANDLE)(*((PNDIS_HANDLE)MacMacContext));
620:
621: NDIS_STATUS Status;
622:
623: NDIS_ADAPTER_INFORMATION AdapterInformation; // needed to register adapter
624: NDIS_EISA_FUNCTION_INFORMATION EisaData;
625: USHORT ConfigValue = 0;
626: UCHAR HiBaseValue = 0;
627:
628: UINT MaxMulticastList = 32;
629: PVOID NetAddress;
630: UINT Length;
631:
632: USHORT RegUshort;
633: UCHAR RegUchar;
634: UINT LanceSlot = 1;
635:
636: BOOLEAN ConfigError = FALSE;
637: NDIS_STATUS ConfigErrorCode;
638:
639:
640: //
641: // Allocate the Adapter block.
642: //
643:
644: LANCE_ALLOC_PHYS(&Adapter, sizeof(LANCE_ADAPTER));
645:
646: if (Adapter == NULL){
647:
648: return NDIS_STATUS_RESOURCES;
649:
650: }
651:
652: LANCE_ZERO_MEMORY(
653: Adapter,
654: sizeof(LANCE_ADAPTER)
655: );
656:
657: Adapter->NdisMacHandle = NdisMacHandle;
658:
659:
660: //
661: // Start with the default card
662: //
663:
664: Adapter->LanceCard = LANCE_DE201;
665:
666: Adapter->RAP = LANCE_DE201_PRI_RAP_ADDRESS;
667: Adapter->RDP = LANCE_DE201_PRI_RDP_ADDRESS;
668: Adapter->Nicsr = LANCE_DE201_PRI_NICSR_ADDRESS;
669: Adapter->NicsrDefaultValue = 0;
670: Adapter->NetworkHardwareAddress = LANCE_DE201_PRI_NETWORK_ADDRESS;
671: Adapter->HardwareBaseAddr = LANCE_DE201_BASE;
672: Adapter->AmountOfHardwareMemory = LANCE_DE201_HARDWARE_MEMORY;
673: Adapter->InterruptNumber = LANCE_DE201_INTERRUPT_VECTOR;
674: Adapter->InterruptRequestLevel = LANCE_DE201_INTERRUPT_VECTOR;
675:
676: NdisOpenConfiguration(
677: &Status,
678: &ConfigHandle,
679: ConfigurationHandle
680: );
681:
682: if (Status != NDIS_STATUS_SUCCESS) {
683:
684: return NDIS_STATUS_FAILURE;
685:
686: }
687:
688: //
689: // Read Card Type
690: //
691:
692: NdisReadConfiguration(
693: &Status,
694: &ReturnedValue,
695: ConfigHandle,
696: &CardStr,
697: NdisParameterInteger
698: );
699:
700: if (Status == NDIS_STATUS_SUCCESS) {
701:
702: if (ReturnedValue->ParameterData.IntegerData == 2) {
703:
704: Adapter->LanceCard = LANCE_DE201;
705:
706: } else if (ReturnedValue->ParameterData.IntegerData == 1) {
707:
708: Adapter->LanceCard = LANCE_DE100;
709:
710: } else if (ReturnedValue->ParameterData.IntegerData == 3) {
711:
712: Adapter->LanceCard = LANCE_DEPCA;
713:
714: #ifndef i386
715: } else if (ReturnedValue->ParameterData.IntegerData == 4) {
716:
717: Adapter->LanceCard = LANCE_DECTC;
718:
719: ConfigErrorCode = LanceDecTcGetConfiguration(ConfigHandle, Adapter);
720:
721: if ( ConfigErrorCode != NDIS_STATUS_SUCCESS ) {
722: ConfigError = TRUE;
723: }
724: #endif // i386
725:
726: } else if (ReturnedValue->ParameterData.IntegerData == 5) {
727:
728: Adapter->LanceCard = LANCE_DE422;
729:
730: } else if (ReturnedValue->ParameterData.IntegerData == 6) {
731:
732: //
733: // This is the De200, but it operates exactly like the 201.
734: //
735:
736: Adapter->LanceCard = LANCE_DE201;
737:
738: } else if (ReturnedValue->ParameterData.IntegerData == 7) {
739:
740: //
741: // This is the De101, but it operates exactly like the 100.
742: //
743:
744: Adapter->LanceCard = LANCE_DE100;
745:
746: } else {
747:
748: ConfigError = TRUE;
749: ConfigErrorCode = NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION;
750:
751: goto RegisterAdapter;
752: }
753:
754: }
755:
756: //
757: // Read MaxMulticastList
758: //
759:
760: NdisReadConfiguration(
761: &Status,
762: &ReturnedValue,
763: ConfigHandle,
764: &MaxMulticastListStr,
765: NdisParameterInteger
766: );
767:
768: if (Status == NDIS_STATUS_SUCCESS) {
769:
770: MaxMulticastList = ReturnedValue->ParameterData.IntegerData;
771:
772: }
773:
774: //
775: // Read net address
776: //
777:
778: NdisReadNetworkAddress(
779: &Status,
780: &NetAddress,
781: &Length,
782: ConfigHandle
783: );
784:
785: if ((Length == ETH_LENGTH_OF_ADDRESS) && (Status == NDIS_STATUS_SUCCESS)) {
786:
787: ETH_COPY_NETWORK_ADDRESS(
788: Adapter->CurrentNetworkAddress,
789: NetAddress
790: );
791:
792: }
793:
794: if (Adapter->LanceCard & (LANCE_DE201 | LANCE_DE100)) {
795:
796: //
797: // Read IoAddress
798: //
799:
800: NdisReadConfiguration(
801: &Status,
802: &ReturnedValue,
803: ConfigHandle,
804: &IoAddressStr,
805: NdisParameterInteger
806: );
807:
808: if (Status == NDIS_STATUS_SUCCESS) {
809:
810: if (ReturnedValue->ParameterData.IntegerData == 1) {
811:
812: Adapter->RAP = LANCE_DE201_PRI_RAP_ADDRESS;
813:
814: Adapter->RDP = LANCE_DE201_PRI_RDP_ADDRESS;
815:
816: Adapter->Nicsr = LANCE_DE201_PRI_NICSR_ADDRESS;
817:
818: Adapter->NetworkHardwareAddress = LANCE_DE201_PRI_NETWORK_ADDRESS;
819:
820: } else if (ReturnedValue->ParameterData.IntegerData == 2) {
821:
822: Adapter->RAP = LANCE_DE201_SEC_RAP_ADDRESS;
823:
824: Adapter->RDP = LANCE_DE201_SEC_RDP_ADDRESS;
825:
826: Adapter->Nicsr = LANCE_DE201_SEC_NICSR_ADDRESS;
827:
828: Adapter->NetworkHardwareAddress = LANCE_DE201_SEC_NETWORK_ADDRESS;
829:
830: } else {
831:
832: ConfigError = TRUE;
833: ConfigErrorCode = NDIS_ERROR_CODE_BAD_IO_BASE_ADDRESS;
834:
835: goto RegisterAdapter;
836: }
837:
838: }
839:
840:
841:
842:
843: //
844: // Read Interrupt
845: //
846:
847: NdisReadConfiguration(
848: &Status,
849: &ReturnedValue,
850: ConfigHandle,
851: &InterruptStr,
852: NdisParameterInteger
853: );
854:
855: if (Status == NDIS_STATUS_SUCCESS) {
856:
857: Adapter->InterruptNumber = (CCHAR)(ReturnedValue->ParameterData.IntegerData);
858: Adapter->InterruptRequestLevel = Adapter->InterruptNumber;
859:
860: if (Adapter->LanceCard == LANCE_DE201) {
861:
862: if (!((Adapter->InterruptNumber == 5) ||
863: (Adapter->InterruptNumber == 9) ||
864: (Adapter->InterruptNumber == 10) ||
865: (Adapter->InterruptNumber == 11) ||
866: (Adapter->InterruptNumber == 15))) {
867:
868: ConfigError = TRUE;
869: ConfigErrorCode = NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION;
870:
871: goto RegisterAdapter;
872:
873: }
874:
875: } else {
876:
877: if (!((Adapter->InterruptNumber == 2) ||
878: (Adapter->InterruptNumber == 3) ||
879: (Adapter->InterruptNumber == 4) ||
880: (Adapter->InterruptNumber == 5) ||
881: (Adapter->InterruptNumber == 7))) {
882:
883: ConfigError = TRUE;
884: ConfigErrorCode = NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION;
885:
886: goto RegisterAdapter;
887:
888: }
889:
890: }
891:
892: }
893:
894:
895:
896: //
897: // Read MemoryBaseAddress
898: //
899:
900:
901: NdisReadConfiguration(
902: &Status,
903: &ReturnedValue,
904: ConfigHandle,
905: &MemoryBaseAddrStr,
906: NdisParameterHexInteger
907: );
908:
909: if (Status == NDIS_STATUS_SUCCESS) {
910:
911: Adapter->HardwareBaseAddr = (PVOID)(ReturnedValue->ParameterData.IntegerData);
912:
913: if (!((Adapter->HardwareBaseAddr == (PVOID)0xC0000) ||
914: (Adapter->HardwareBaseAddr == (PVOID)0xC8000) ||
915: (Adapter->HardwareBaseAddr == (PVOID)0xD0000) ||
916: (Adapter->HardwareBaseAddr == (PVOID)0xD8000) ||
917: (Adapter->HardwareBaseAddr == (PVOID)0xE0000) ||
918: (Adapter->HardwareBaseAddr == (PVOID)0xE8000))) {
919:
920: ConfigError = TRUE;
921: ConfigErrorCode = NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION;
922:
923: goto RegisterAdapter;
924:
925: }
926:
927: }
928:
929:
930: if (((ULONG)Adapter->HardwareBaseAddr) & 0x8000) {
931:
932: Adapter->AmountOfHardwareMemory = 0x8000;
933: Adapter->HardwareBaseOffset = 0x8000;
934:
935: } else {
936:
937: Adapter->AmountOfHardwareMemory = 0x10000;
938: Adapter->HardwareBaseOffset = 0x0;
939:
940: }
941:
942: } else if (Adapter->LanceCard == LANCE_DEPCA) {
943:
944: Adapter->NetworkHardwareAddress = LANCE_DEPCA_EPROM_ADDRESS;
945: Adapter->InterruptNumber = LANCE_DEPCA_INTERRUPT_VECTOR;
946: Adapter->InterruptRequestLevel = LANCE_DEPCA_INTERRUPT_VECTOR;
947: Adapter->RAP = LANCE_DEPCA_RAP_ADDRESS;
948: Adapter->RDP = LANCE_DEPCA_RDP_ADDRESS;
949: Adapter->AmountOfHardwareMemory = LANCE_DEPCA_HARDWARE_MEMORY;
950: Adapter->HardwareBaseAddr = LANCE_DEPCA_BASE;
951: Adapter->Nicsr = LANCE_DEPCA_NICSR_ADDRESS;
952: Adapter->LanceCard = LANCE_DE100;
953:
954: } else if (Adapter->LanceCard == LANCE_DE422) {
955:
956: PUCHAR CurrentChar;
957: BOOLEAN LastEntry;
958: UCHAR InitType;
959: USHORT PortAddress, PortValue, Mask;
960:
961: NdisReadEisaSlotInformation(
962: &Status,
963: ConfigurationHandle,
964: &Adapter->SlotNumber,
965: &EisaData
966: );
967:
968: if (Status != NDIS_STATUS_SUCCESS) {
969:
970: ConfigError = TRUE;
971: ConfigErrorCode = NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION;
972:
973: goto RegisterAdapter;
974:
975: }
976:
977: //
978: // Setup Ports
979: //
980:
981: Adapter->RAP = (((ULONG)Adapter->SlotNumber) << 12) +
982: LANCE_DE422_RAP_ADDRESS;
983:
984: Adapter->RDP = (((ULONG)Adapter->SlotNumber) << 12) +
985: LANCE_DE422_RDP_ADDRESS;
986:
987: Adapter->Nicsr = (((ULONG)Adapter->SlotNumber) << 12) +
988: LANCE_DE422_NICSR_ADDRESS;
989:
990: Adapter->NetworkHardwareAddress = (((ULONG)Adapter->SlotNumber) << 12) +
991: LANCE_DE422_NETWORK_ADDRESS;
992:
993: CurrentChar = (PUCHAR) (EisaData.InitializationData);
994: LastEntry = FALSE;
995:
996: while (!LastEntry) {
997:
998: InitType = *(CurrentChar++);
999: PortAddress = *((USHORT UNALIGNED *) CurrentChar++);
1000:
1001: CurrentChar++;
1002:
1003: if ((InitType & 0x80) == 0) {
1004: LastEntry = TRUE;
1005: }
1006:
1007:
1008:
1009: if (PortAddress == (USHORT)(Adapter->NetworkHardwareAddress)) {
1010:
1011: PortValue = *((USHORT UNALIGNED *) CurrentChar++);
1012:
1013: } else if (PortAddress == ((Adapter->SlotNumber << 12) +
1014: LANCE_DE422_EXTENDED_MEMORY_BASE_ADDRESS)) {
1015:
1016: PortValue = (USHORT)(*(CurrentChar++));
1017:
1018: } else {
1019:
1020: continue;
1021:
1022: }
1023:
1024:
1025:
1026: if (InitType & 0x40) {
1027:
1028: if (PortAddress == Adapter->NetworkHardwareAddress) {
1029:
1030: Mask = *((USHORT UNALIGNED *) CurrentChar++);
1031:
1032: } else {
1033:
1034: Mask = (USHORT)(*(CurrentChar++));
1035:
1036: }
1037:
1038: } else {
1039:
1040: Mask = 0;
1041:
1042: }
1043:
1044: if (PortAddress == Adapter->NetworkHardwareAddress) {
1045:
1046: ConfigValue &= Mask;
1047: ConfigValue |= PortValue;
1048:
1049: } else {
1050:
1051: HiBaseValue &= (UCHAR)Mask;
1052: HiBaseValue |= (UCHAR)PortValue;
1053:
1054: }
1055:
1056: }
1057:
1058: //
1059: // Interpret values
1060: //
1061:
1062: switch (ConfigValue & 0x78) {
1063:
1064: case 0x40:
1065:
1066: Adapter->InterruptNumber = 11;
1067: break;
1068:
1069: case 0x20:
1070:
1071: Adapter->InterruptNumber = 10;
1072: break;
1073:
1074: case 0x10:
1075:
1076: Adapter->InterruptNumber = 9;
1077: break;
1078:
1079: case 0x08:
1080:
1081: Adapter->InterruptNumber = 5;
1082: break;
1083:
1084: default:
1085:
1086: ConfigError = TRUE;
1087: ConfigErrorCode = NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION;
1088:
1089: goto RegisterAdapter;
1090:
1091: }
1092:
1093: Adapter->InterruptRequestLevel = Adapter->InterruptNumber;
1094: //
1095: // We postpone the rest of the processing since we have to read from
1096: // the NICSR to get the amount of hardware memory and cannot do that
1097: // until after we have called NdisRegisterAdater.
1098: //
1099:
1100: }
1101:
1102: RegisterAdapter:
1103:
1104: NdisCloseConfiguration(ConfigHandle);
1105:
1106: //
1107: // The adapter is initialized, register it with NDIS.
1108: // This must occur before interrupts are enabled since the
1109: // InitializeInterrupt routine requires the NdisAdapterHandle
1110: //
1111:
1112: //
1113: // Set up the AdapterInformation structure; zero it
1114: // first in case it is extended later.
1115: //
1116:
1117: LANCE_ZERO_MEMORY(&AdapterInformation, sizeof(NDIS_ADAPTER_INFORMATION));
1118:
1119: if (Adapter->LanceCard & (LANCE_DE100 | LANCE_DE201)) {
1120:
1121: AdapterInformation.AdapterType = NdisInterfaceIsa;
1122:
1123: } else if (Adapter->LanceCard == LANCE_DE422) {
1124:
1125: AdapterInformation.AdapterType = NdisInterfaceEisa;
1126:
1127: }
1128:
1129: AdapterInformation.NumberOfPortDescriptors = 1;
1130:
1131: #ifndef i386
1132:
1133: if (Adapter->LanceCard == LANCE_DECTC) {
1134:
1135: Status = LanceDecTcGetInformation(Adapter, &AdapterInformation);
1136: if (Status != NDIS_STATUS_SUCCESS) {
1137: return Status;
1138: }
1139:
1140: } else
1141:
1142: #endif
1143:
1144: if (Adapter->LanceCard & (LANCE_DE100 | LANCE_DE201)) {
1145:
1146: AdapterInformation.PortDescriptors[0].InitialPort = (ULONG)Adapter->Nicsr;
1147: AdapterInformation.PortDescriptors[0].NumberOfPorts = 0x10;
1148:
1149: } else if (Adapter->LanceCard == LANCE_DE422) {
1150:
1151: AdapterInformation.PortDescriptors[0].InitialPort = (ULONG)(Adapter->Nicsr);
1152: AdapterInformation.PortDescriptors[0].NumberOfPorts = 0x90;
1153:
1154: }
1155:
1156: if ((Status = NdisRegisterAdapter(
1157: &Adapter->NdisAdapterHandle,
1158: Adapter->NdisMacHandle,
1159: Adapter,
1160: ConfigurationHandle,
1161: AdapterName,
1162: &AdapterInformation
1163: )) != NDIS_STATUS_SUCCESS) {
1164:
1165: LANCE_FREE_PHYS(Adapter, sizeof(LANCE_ADAPTER));
1166:
1167: return Status;
1168:
1169: }
1170:
1171:
1172: if (ConfigError) {
1173:
1174: NdisWriteErrorLogEntry(
1175: Adapter->NdisAdapterHandle,
1176: ConfigErrorCode,
1177: 0
1178: );
1179:
1180: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
1181:
1182: LANCE_FREE_PHYS(Adapter, sizeof(LANCE_ADAPTER));
1183:
1184: return NDIS_STATUS_FAILURE;
1185:
1186: }
1187:
1188: //
1189: // Now we get the rest of the information necessary for the DE422.
1190: //
1191:
1192: if (Adapter->LanceCard == LANCE_DE422) {
1193:
1194: //
1195: // Verify card is a DE422
1196: //
1197:
1198: NdisReadPortUshort(Adapter->NdisAdapterHandle,
1199: (((ULONG)(Adapter->SlotNumber)) << 12) +
1200: LANCE_DE422_EISA_IDENTIFICATION,
1201: &RegUshort
1202: );
1203:
1204: if (RegUshort != 0xA310) {
1205:
1206: //
1207: // Not a DE422 card
1208: //
1209:
1210: NdisWriteErrorLogEntry(
1211: Adapter->NdisAdapterHandle,
1212: NDIS_ERROR_CODE_ADAPTER_NOT_FOUND,
1213: 0
1214: );
1215:
1216: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
1217:
1218: LANCE_FREE_PHYS(Adapter, sizeof(LANCE_ADAPTER));
1219:
1220: return NDIS_STATUS_FAILURE;
1221:
1222: }
1223:
1224: NdisReadPortUshort(Adapter->NdisAdapterHandle,
1225: (((ULONG)(Adapter->SlotNumber)) << 12) +
1226: LANCE_DE422_EISA_IDENTIFICATION + 2,
1227: &RegUshort
1228: );
1229:
1230: if (RegUshort != 0x2042) {
1231:
1232: //
1233: // Not a DE422 card
1234: //
1235:
1236: NdisWriteErrorLogEntry(
1237: Adapter->NdisAdapterHandle,
1238: NDIS_ERROR_CODE_ADAPTER_NOT_FOUND,
1239: 0
1240: );
1241:
1242: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
1243:
1244: LANCE_FREE_PHYS(Adapter, sizeof(LANCE_ADAPTER));
1245:
1246: return NDIS_STATUS_FAILURE;
1247:
1248: }
1249:
1250: //
1251: // Check that the card is enabled.
1252: //
1253:
1254: NdisReadPortUchar(Adapter->NdisAdapterHandle,
1255: (((ULONG)(Adapter->SlotNumber)) << 12) +
1256: LANCE_DE422_EISA_CONTROL,
1257: &RegUchar
1258: );
1259:
1260: if (!(RegUchar & 0x1)) {
1261:
1262: NdisWriteErrorLogEntry(
1263: Adapter->NdisAdapterHandle,
1264: NDIS_ERROR_CODE_ADAPTER_DISABLED,
1265: 0
1266: );
1267:
1268: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
1269:
1270: LANCE_FREE_PHYS(Adapter, sizeof(LANCE_ADAPTER));
1271:
1272: return NDIS_STATUS_FAILURE;
1273:
1274: }
1275:
1276: //
1277: // Get Memory size
1278: //
1279:
1280: NdisReadPortUshort(Adapter->NdisAdapterHandle,
1281: Adapter->Nicsr,
1282: &RegUshort
1283: );
1284:
1285: if (RegUshort & LANCE_NICSR_BUFFER_SIZE) {
1286:
1287: Adapter->AmountOfHardwareMemory = 0x8000;
1288:
1289: } else if (RegUshort & LANCE_NICSR_128K) {
1290:
1291: Adapter->AmountOfHardwareMemory = 0x20000;
1292: Adapter->NicsrDefaultValue = LANCE_NICSR_128K;
1293:
1294: } else {
1295:
1296: Adapter->AmountOfHardwareMemory = 0x10000;
1297:
1298: }
1299:
1300: //
1301: // Get Base memory address
1302: //
1303:
1304: switch (Adapter->AmountOfHardwareMemory) {
1305:
1306: case 0x8000:
1307:
1308: switch (ConfigValue & 0x07) {
1309:
1310: case 0x04:
1311:
1312: Adapter->HardwareBaseAddr = (PVOID)((HiBaseValue << 24) + 0xC8000);
1313: Adapter->HardwareBaseOffset = 0x8000;
1314: break;
1315:
1316: case 0x05:
1317:
1318: Adapter->HardwareBaseAddr = (PVOID)((HiBaseValue << 24) + 0xE8000);
1319: Adapter->HardwareBaseOffset = 0x8000;
1320: break;
1321:
1322: case 0x06:
1323:
1324: Adapter->HardwareBaseAddr = (PVOID)((HiBaseValue << 24) + 0xD8000);
1325: Adapter->HardwareBaseOffset = 0x8000;
1326: break;
1327:
1328: case 0x07:
1329:
1330: Adapter->HardwareBaseAddr = (PVOID)((HiBaseValue << 24) + 0xF8000);
1331: Adapter->HardwareBaseOffset = 0x8000;
1332: break;
1333:
1334: default:
1335:
1336: NdisWriteErrorLogEntry(
1337: Adapter->NdisAdapterHandle,
1338: NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
1339: 0
1340: );
1341:
1342: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
1343:
1344: LANCE_FREE_PHYS(Adapter, sizeof(LANCE_ADAPTER));
1345:
1346: return NDIS_STATUS_FAILURE;
1347:
1348: }
1349: break;
1350:
1351: case 0x10000:
1352:
1353: switch (ConfigValue & 0x07) {
1354:
1355: case 0x00:
1356:
1357: Adapter->HardwareBaseAddr = (PVOID)((HiBaseValue << 24) + 0xC0000);
1358: Adapter->HardwareBaseOffset = 0x0000;
1359: break;
1360:
1361: case 0x01:
1362:
1363: Adapter->HardwareBaseAddr = (PVOID)((HiBaseValue << 24) + 0xE0000);
1364: Adapter->HardwareBaseOffset = 0x0000;
1365: break;
1366:
1367: case 0x02:
1368:
1369: Adapter->HardwareBaseAddr = (PVOID)((HiBaseValue << 24) + 0xD0000);
1370: Adapter->HardwareBaseOffset = 0x0000;
1371: break;
1372:
1373: case 0x03:
1374:
1375: Adapter->HardwareBaseAddr = (PVOID)((HiBaseValue << 24) + 0xF0000);
1376: Adapter->HardwareBaseOffset = 0x0000;
1377: break;
1378:
1379: default:
1380:
1381: NdisWriteErrorLogEntry(
1382: Adapter->NdisAdapterHandle,
1383: NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
1384: 0
1385: );
1386:
1387: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
1388:
1389: LANCE_FREE_PHYS(Adapter, sizeof(LANCE_ADAPTER));
1390:
1391: return NDIS_STATUS_FAILURE;
1392:
1393: }
1394: break;
1395:
1396: case 0x20000:
1397:
1398: switch (ConfigValue & 0x07) {
1399:
1400: case 0x00:
1401:
1402: Adapter->HardwareBaseAddr = (PVOID)((HiBaseValue << 24) + 0xC0000);
1403: Adapter->HardwareBaseOffset = 0x0000;
1404: break;
1405:
1406: case 0x01:
1407:
1408: Adapter->HardwareBaseAddr = (PVOID)((HiBaseValue << 24) + 0xD0000);
1409: Adapter->HardwareBaseOffset = 0x0000;
1410: break;
1411:
1412: default:
1413:
1414: NdisWriteErrorLogEntry(
1415: Adapter->NdisAdapterHandle,
1416: NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
1417: 0
1418: );
1419:
1420: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
1421:
1422: LANCE_FREE_PHYS(Adapter, sizeof(LANCE_ADAPTER));
1423:
1424: return NDIS_STATUS_FAILURE;
1425:
1426: }
1427:
1428: break;
1429:
1430: }
1431:
1432: }
1433:
1434: //
1435: // Set the port addresses and the network address.
1436: //
1437:
1438: Adapter->InterruptsStopped = FALSE;
1439: Adapter->MaxMulticastList = MaxMulticastList;
1440:
1441: Status = LanceRegisterAdapter(
1442: Adapter
1443: );
1444:
1445: if (Status != NDIS_STATUS_SUCCESS) {
1446:
1447:
1448:
1449: //
1450: // LanceRegisterAdapter failed.
1451: //
1452:
1453: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
1454:
1455: LANCE_FREE_PHYS(Adapter, sizeof(LANCE_ADAPTER));
1456:
1457: return NDIS_STATUS_FAILURE;
1458:
1459: }
1460:
1461: return NDIS_STATUS_SUCCESS;
1462: }
1463:
1464:
1465: VOID
1466: LanceRemoveAdapter(
1467: IN PVOID MacAdapterContext
1468: )
1469: /*++
1470:
1471: Routine Description:
1472:
1473: LanceRemoveAdapter removes an adapter previously registered
1474: with NdisRegisterAdapter.
1475:
1476: Arguments:
1477:
1478: MacAdapterContext - The context value that the MAC passed
1479: to NdisRegisterAdapter; actually as pointer to an
1480: LANCE_ADAPTER.
1481:
1482: Return Value:
1483:
1484: None.
1485:
1486: --*/
1487: {
1488:
1489: PLANCE_ADAPTER Adapter;
1490: BOOLEAN Canceled;
1491:
1492: Adapter = PLANCE_ADAPTER_FROM_CONTEXT_HANDLE(MacAdapterContext);
1493:
1494: //
1495: // There are no opens left, so remove ourselves.
1496: //
1497:
1498: #if LANCELOG
1499: if (LogTimerRunning) {
1500: NdisCancelTimer(&LogTimer, &Canceled);
1501: LogTimerRunning = FALSE;
1502: }
1503: #endif
1504:
1505: NdisCancelTimer(&Adapter->WakeUpTimer, &Canceled);
1506:
1507: if ( !Canceled ) {
1508:
1509: NdisStallExecution(500000);
1510: }
1511:
1512: NdisRemoveInterrupt(&(Adapter->Interrupt));
1513:
1514: NdisUnmapIoSpace(
1515: Adapter->NdisAdapterHandle,
1516: Adapter->MmMappedBaseAddr,
1517: Adapter->AmountOfHardwareMemory
1518: );
1519:
1520: EthDeleteFilter(Adapter->FilterDB);
1521:
1522: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
1523:
1524: NdisFreeSpinLock(&Adapter->Lock);
1525:
1526: NdisFreeMemory(Adapter, sizeof(LANCE_ADAPTER), 0);
1527:
1528: return;
1529: }
1530:
1531: VOID
1532: LanceUnload(
1533: IN NDIS_HANDLE MacMacContext
1534: )
1535:
1536: /*++
1537:
1538: Routine Description:
1539:
1540: LanceUnload is called when the MAC is to unload itself.
1541:
1542: Arguments:
1543:
1544: MacMacContext - not used.
1545:
1546: Return Value:
1547:
1548: None.
1549:
1550: --*/
1551:
1552: {
1553: NDIS_STATUS InitStatus;
1554:
1555: UNREFERENCED_PARAMETER(MacMacContext);
1556:
1557: NdisDeregisterMac(
1558: &InitStatus,
1559: LanceMacHandle
1560: );
1561:
1562: NdisTerminateWrapper(
1563: LanceNdisWrapperHandle,
1564: NULL
1565: );
1566:
1567: return;
1568: }
1569:
1570: LanceRegisterAdapter(
1571: IN PLANCE_ADAPTER Adapter
1572: )
1573:
1574: /*++
1575:
1576: Routine Description:
1577:
1578: This routine (and its interface) are not portable. They are
1579: defined by the OS, the architecture, and the particular LANCE
1580: implementation.
1581:
1582: This routine is responsible for the allocation of the datastructures
1583: for the driver as well as any hardware specific details necessary
1584: to talk with the device.
1585:
1586: Arguments:
1587:
1588: Adapter - Pointer to the adapter block.
1589:
1590: Return Value:
1591:
1592: Returns false if anything occurred that prevents the initialization
1593: of the adapter.
1594:
1595: --*/
1596: {
1597:
1598: //
1599: // Result of Ndis Calls.
1600: //
1601: NDIS_STATUS Status;
1602:
1603:
1604: //
1605: // We put in this assertion to make sure that ushort are 2 bytes.
1606: // if they aren't then the initialization block definition needs
1607: // to be changed.
1608: //
1609: // Also all of the logic that deals with status registers assumes
1610: // that control registers are only 2 bytes.
1611: //
1612:
1613: ASSERT(sizeof(USHORT) == 2);
1614:
1615: //
1616: // This assertion checks that the network address in the initialization
1617: // block does start on the third byte of the initalization block.
1618: //
1619: // If this is true then other fields in the initialization block
1620: // and the send and receive descriptors should be at their correct
1621: // locations.
1622: //
1623:
1624: ASSERT(FIELD_OFFSET(LANCE_INITIALIZATION_BLOCK,PhysicalAddress[0]) == 2);
1625:
1626:
1627: //
1628: // Allocate memory for all of the adapter structures.
1629: //
1630:
1631: Adapter->NumberOfTransmitRings = LANCE_NUMBER_OF_TRANSMIT_RINGS;
1632: Adapter->LogNumberTransmitRings = LANCE_LOG_TRANSMIT_RINGS;
1633:
1634: #ifndef i386
1635:
1636: if (Adapter->LanceCard == LANCE_DECTC) {
1637:
1638: Status = LanceDecTcSoftwareDetails(Adapter);
1639: if (Status != NDIS_STATUS_SUCCESS) {
1640: return Status;
1641: }
1642:
1643: } else
1644:
1645:
1646: #endif
1647:
1648: {
1649:
1650: if (Adapter->AmountOfHardwareMemory == 0x20000) {
1651:
1652: ASSERT(Adapter->LanceCard == LANCE_DE422);
1653:
1654: Adapter->SizeOfReceiveBuffer = LANCE_128K_SIZE_OF_RECEIVE_BUFFERS;
1655: Adapter->NumberOfSmallBuffers = LANCE_128K_NUMBER_OF_SMALL_BUFFERS;
1656: Adapter->NumberOfMediumBuffers= LANCE_128K_NUMBER_OF_MEDIUM_BUFFERS;
1657: Adapter->NumberOfLargeBuffers = LANCE_128K_NUMBER_OF_LARGE_BUFFERS;
1658:
1659: Adapter->NumberOfReceiveRings = LANCE_128K_NUMBER_OF_RECEIVE_RINGS;
1660: Adapter->LogNumberReceiveRings = LANCE_128K_LOG_RECEIVE_RINGS;
1661:
1662: } else if (Adapter->AmountOfHardwareMemory == 0x10000) {
1663:
1664: Adapter->NumberOfReceiveRings = LANCE_64K_NUMBER_OF_RECEIVE_RINGS;
1665: Adapter->LogNumberReceiveRings = LANCE_64K_LOG_RECEIVE_RINGS;
1666:
1667: Adapter->SizeOfReceiveBuffer = LANCE_64K_SIZE_OF_RECEIVE_BUFFERS;
1668: Adapter->NumberOfSmallBuffers = LANCE_64K_NUMBER_OF_SMALL_BUFFERS;
1669: Adapter->NumberOfMediumBuffers= LANCE_64K_NUMBER_OF_MEDIUM_BUFFERS;
1670: Adapter->NumberOfLargeBuffers = LANCE_64K_NUMBER_OF_LARGE_BUFFERS;
1671:
1672: } else {
1673:
1674: Adapter->NumberOfReceiveRings = LANCE_32K_NUMBER_OF_RECEIVE_RINGS;
1675: Adapter->LogNumberReceiveRings = LANCE_32K_LOG_RECEIVE_RINGS;
1676:
1677: Adapter->SizeOfReceiveBuffer = LANCE_32K_SIZE_OF_RECEIVE_BUFFERS;
1678: Adapter->NumberOfSmallBuffers = LANCE_32K_NUMBER_OF_SMALL_BUFFERS;
1679: Adapter->NumberOfMediumBuffers= LANCE_32K_NUMBER_OF_MEDIUM_BUFFERS;
1680: Adapter->NumberOfLargeBuffers = LANCE_32K_NUMBER_OF_LARGE_BUFFERS;
1681:
1682: }
1683:
1684: }
1685:
1686: #ifndef i386
1687:
1688: if (((Adapter->LanceCard == LANCE_DECTC) &&
1689: (LanceDecTcHardwareDetails(Adapter) == NDIS_STATUS_SUCCESS)) ||
1690: LanceHardwareDetails(Adapter)) {
1691:
1692: #else
1693:
1694: if (LanceHardwareDetails(Adapter)) {
1695:
1696: #endif
1697:
1698: NDIS_PHYSICAL_ADDRESS PhysicalAddress;
1699:
1700: //
1701: // Get hold of the RAP and RDP address as well
1702: // as filling in the hardware assigned network
1703: // address.
1704: //
1705:
1706: if ((Adapter->CurrentNetworkAddress[0] == 0x00) &&
1707: (Adapter->CurrentNetworkAddress[1] == 0x00) &&
1708: (Adapter->CurrentNetworkAddress[2] == 0x00) &&
1709: (Adapter->CurrentNetworkAddress[3] == 0x00) &&
1710: (Adapter->CurrentNetworkAddress[4] == 0x00) &&
1711: (Adapter->CurrentNetworkAddress[5] == 0x00)) {
1712:
1713: Adapter->CurrentNetworkAddress[0] = Adapter->NetworkAddress[0];
1714: Adapter->CurrentNetworkAddress[1] = Adapter->NetworkAddress[1];
1715: Adapter->CurrentNetworkAddress[2] = Adapter->NetworkAddress[2];
1716: Adapter->CurrentNetworkAddress[3] = Adapter->NetworkAddress[3];
1717: Adapter->CurrentNetworkAddress[4] = Adapter->NetworkAddress[4];
1718: Adapter->CurrentNetworkAddress[5] = Adapter->NetworkAddress[5];
1719:
1720: }
1721:
1722: NdisSetPhysicalAddressHigh(PhysicalAddress, 0);
1723: NdisSetPhysicalAddressLow(PhysicalAddress, (ULONG)(Adapter->HardwareBaseAddr));
1724:
1725: NdisMapIoSpace(
1726: &Status,
1727: &(Adapter->MmMappedBaseAddr),
1728: Adapter->NdisAdapterHandle,
1729: PhysicalAddress,
1730: Adapter->AmountOfHardwareMemory
1731: );
1732:
1733: if (Status != NDIS_STATUS_SUCCESS) {
1734:
1735: NdisWriteErrorLogEntry(
1736: Adapter->NdisAdapterHandle,
1737: NDIS_ERROR_CODE_RESOURCE_CONFLICT,
1738: 0
1739: );
1740:
1741: return(Status);
1742:
1743: }
1744:
1745: Adapter->CurrentMemoryFirstFree = Adapter->MmMappedBaseAddr;
1746:
1747:
1748: Adapter->MemoryFirstUnavailable =
1749: (PUCHAR)(Adapter->CurrentMemoryFirstFree) +
1750: Adapter->AmountOfHardwareMemory;
1751:
1752: if (!AllocateAdapterMemory(Adapter)) {
1753:
1754: NdisWriteErrorLogEntry(
1755: Adapter->NdisAdapterHandle,
1756: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
1757: 0
1758: );
1759:
1760: return( NDIS_STATUS_ADAPTER_NOT_FOUND );
1761:
1762: }
1763:
1764: InitializeListHead(&Adapter->OpenBindings);
1765: InitializeListHead(&Adapter->CloseList);
1766:
1767: NdisAllocateSpinLock(&Adapter->Lock);
1768:
1769: Adapter->InterruptDPC = (PVOID)LanceStandardInterruptDPC;
1770: Adapter->LoopbackDPC = (PVOID)LanceStandardInterruptDPC;
1771:
1772:
1773: Adapter->AllocateableRing = Adapter->TransmitRing;
1774: Adapter->TransmittingRing = Adapter->TransmitRing;
1775: Adapter->FirstUncommittedRing = Adapter->TransmitRing;
1776: Adapter->NumberOfAvailableRings = Adapter->NumberOfTransmitRings;
1777: Adapter->LastTransmitRingEntry = Adapter->TransmitRing +
1778: (Adapter->NumberOfTransmitRings-1);
1779:
1780: Adapter->FirstLoopBack = NULL;
1781: Adapter->LastLoopBack = NULL;
1782: Adapter->FirstFinishTransmit = NULL;
1783: Adapter->LastFinishTransmit = NULL;
1784: Adapter->StageOpen = TRUE;
1785: Adapter->AlreadyProcessingStage = FALSE;
1786: Adapter->FirstStage1Packet = NULL;
1787: Adapter->LastStage1Packet = NULL;
1788: Adapter->CurrentReceiveIndex = 0;
1789: Adapter->OutOfReceiveBuffers = 0;
1790: Adapter->CRCError = 0;
1791: Adapter->FramingError = 0;
1792: Adapter->RetryFailure = 0;
1793: Adapter->LostCarrier = 0;
1794: Adapter->LateCollision = 0;
1795: Adapter->UnderFlow = 0;
1796: Adapter->Deferred = 0;
1797: Adapter->OneRetry = 0;
1798: Adapter->MoreThanOneRetry = 0;
1799: Adapter->ResetInProgress = FALSE;
1800: Adapter->ResetInitStarted = FALSE;
1801: Adapter->ResettingOpen = NULL;
1802: Adapter->FirstInitialization = TRUE;
1803: Adapter->HardwareFailure = FALSE;
1804: Adapter->PendQueue = NULL;
1805: Adapter->PendQueueTail = NULL;
1806:
1807: //
1808: // First we make sure that the device is stopped. We call
1809: // directly since we don't have an Interrupt object yet.
1810: //
1811:
1812: LanceSyncStopChip(Adapter);
1813:
1814:
1815: //
1816: // Initialize the interrupt.
1817: //
1818:
1819: NdisInitializeInterrupt(
1820: &Status,
1821: &Adapter->Interrupt,
1822: Adapter->NdisAdapterHandle,
1823: (PNDIS_INTERRUPT_SERVICE)LanceISR,
1824: Adapter,
1825: (PNDIS_DEFERRED_PROCESSING)Adapter->InterruptDPC,
1826: Adapter->InterruptNumber,
1827: Adapter->InterruptRequestLevel,
1828: FALSE,
1829: NdisInterruptLatched
1830: );
1831:
1832: if (Status != NDIS_STATUS_SUCCESS){
1833:
1834: NdisWriteErrorLogEntry(
1835: Adapter->NdisAdapterHandle,
1836: NDIS_ERROR_CODE_INTERRUPT_CONNECT,
1837: 0
1838: );
1839:
1840: NdisUnmapIoSpace(
1841: Adapter->NdisAdapterHandle,
1842: Adapter->MmMappedBaseAddr,
1843: Adapter->AmountOfHardwareMemory);
1844:
1845: DeleteAdapterMemory(Adapter);
1846:
1847: return Status;
1848: }
1849:
1850:
1851: if (!EthCreateFilter(
1852: Adapter->MaxMulticastList,
1853: LanceChangeMulticastAddresses,
1854: LanceChangeFilterClasses,
1855: LanceCloseAction,
1856: Adapter->CurrentNetworkAddress,
1857: &Adapter->Lock,
1858: &Adapter->FilterDB
1859: )) {
1860:
1861: NdisWriteErrorLogEntry(
1862: Adapter->NdisAdapterHandle,
1863: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
1864: 0
1865: );
1866:
1867: NdisUnmapIoSpace(
1868: Adapter->NdisAdapterHandle,
1869: Adapter->MmMappedBaseAddr,
1870: Adapter->AmountOfHardwareMemory);
1871:
1872: DeleteAdapterMemory(Adapter);
1873:
1874: NdisRemoveInterrupt(&Adapter->Interrupt);
1875:
1876: return NDIS_STATUS_RESOURCES;
1877:
1878: }
1879:
1880: if ((Status = LanceInitialInit(Adapter)) != NDIS_STATUS_SUCCESS) {
1881:
1882:
1883: NdisWriteErrorLogEntry(
1884: Adapter->NdisAdapterHandle,
1885: NDIS_ERROR_CODE_HARDWARE_FAILURE,
1886: 0
1887: );
1888:
1889: EthDeleteFilter(Adapter->FilterDB);
1890:
1891: NdisUnmapIoSpace(
1892: Adapter->NdisAdapterHandle,
1893: Adapter->MmMappedBaseAddr,
1894: Adapter->AmountOfHardwareMemory);
1895:
1896: DeleteAdapterMemory(Adapter);
1897:
1898: NdisRemoveInterrupt(&Adapter->Interrupt);
1899:
1900: return Status;
1901:
1902: }
1903:
1904: //
1905: // Initialize the wake up timer to catch interrupts that
1906: // don't complete. It fires continuously
1907: // every 5 seconds, and we check if there are any
1908: // uncompleted operations from the previous two-second
1909: // period.
1910: //
1911:
1912: Adapter->WakeUpDpc = (PVOID)LanceWakeUpDpc;
1913:
1914: NdisInitializeTimer(&Adapter->WakeUpTimer,
1915: (PVOID)(Adapter->WakeUpDpc),
1916: Adapter );
1917:
1918: NdisSetTimer(
1919: &Adapter->WakeUpTimer,
1920: 5000
1921: );
1922:
1923: return Status;
1924:
1925: } else {
1926:
1927: NdisWriteErrorLogEntry(
1928: Adapter->NdisAdapterHandle,
1929: NDIS_ERROR_CODE_ADAPTER_NOT_FOUND,
1930: 0
1931: );
1932:
1933: return NDIS_STATUS_FAILURE;
1934:
1935: }
1936:
1937: }
1938:
1939: extern
1940: NDIS_STATUS
1941: LanceInitialInit(
1942: IN PLANCE_ADAPTER Adapter
1943: )
1944:
1945: /*++
1946:
1947: Routine Description:
1948:
1949: This routine sets up the initial init of the driver.
1950:
1951: Arguments:
1952:
1953: Adapter - The adapter for the hardware.
1954:
1955: Return Value:
1956:
1957: None.
1958:
1959: --*/
1960:
1961: {
1962:
1963: if (Adapter->LanceCard & (LANCE_DE201 | LANCE_DE100 | LANCE_DE422)) {
1964:
1965: //
1966: // Allow interrupts
1967: //
1968:
1969: Adapter->InterruptsStopped = FALSE;
1970:
1971: LOG(UNPEND);
1972:
1973: LANCE_WRITE_NICSR(Adapter, LANCE_NICSR_INT_ON);
1974:
1975: }
1976:
1977: SetInitBlockAndInit(Adapter);
1978:
1979: //
1980: // Delay execution for 1/2 second to give the lance
1981: // time to initialize.
1982: //
1983:
1984:
1985: NdisStallExecution( 500000 );
1986:
1987: NdisAcquireSpinLock(&Adapter->Lock);
1988:
1989: //
1990: // The only way that first initialization could have
1991: // been turned off is if we actually initialized.
1992: //
1993:
1994: if (!Adapter->FirstInitialization) {
1995:
1996: //
1997: // Initialize the Deferred processing timer.
1998: //
1999:
2000: NdisInitializeTimer(&Adapter->DeferredTimer,
2001: Adapter->LoopbackDPC,
2002: Adapter);
2003:
2004: #if LANCELOG
2005:
2006: if (!LogTimerRunning) {
2007:
2008: NdisInitializeTimer(&LogTimer,
2009: (PVOID)LogDpc,
2010: (PVOID)(&LogTimer)
2011: );
2012:
2013: NdisSetTimer(&LogTimer,1000);
2014:
2015: LogTimerRunning = TRUE;
2016:
2017: }
2018:
2019: #endif
2020:
2021: //
2022: // We actually did get the initialization.
2023: //
2024:
2025: NdisReleaseSpinLock(&Adapter->Lock);
2026:
2027: //
2028: // We can start the chip. We may not
2029: // have any bindings to indicateto but this
2030: // is unimportant.
2031: //
2032:
2033: LanceStartChip(Adapter);
2034:
2035:
2036: return NDIS_STATUS_SUCCESS;
2037:
2038:
2039: } else {
2040:
2041: NdisReleaseSpinLock(&Adapter->Lock);
2042:
2043: return NDIS_STATUS_FAILURE;
2044:
2045: }
2046:
2047: }
2048:
2049: STATIC
2050: VOID
2051: LanceStartChip(
2052: IN PLANCE_ADAPTER Adapter
2053: )
2054:
2055: /*++
2056:
2057: Routine Description:
2058:
2059: This routine is used to start an already initialized lance.
2060:
2061: Arguments:
2062:
2063: Adapter - The adapter for the LANCE to start.
2064:
2065: Return Value:
2066:
2067: None.
2068:
2069: --*/
2070:
2071: {
2072:
2073: if (Adapter->ResetInProgress) {
2074:
2075: return;
2076:
2077: }
2078:
2079: //
2080: // Set the RAP to csr0.
2081: //
2082:
2083: LANCE_WRITE_RAP(
2084: Adapter,
2085: LANCE_SELECT_CSR0
2086: );
2087:
2088: //
2089: // Set the RDP to a start chip.
2090: //
2091:
2092: LANCE_WRITE_RDP(
2093: Adapter,
2094: LANCE_CSR0_START | LANCE_CSR0_INTERRUPT_ENABLE
2095: );
2096:
2097: }
2098:
2099: STATIC
2100: BOOLEAN
2101: LanceInterruptSynch(
2102: IN PVOID Context
2103: )
2104:
2105: /*++
2106:
2107: Routine Description:
2108:
2109: This routine is used by the normal interrupt processing routine
2110: to synchronize with interrupts from the card. It will or
2111: the value of the stored csr 0 into the other passed address
2112: in the context and clear the stored csr 0 value.
2113: block and clear the stored csr0.
2114:
2115: Arguments:
2116:
2117: Context - This is really a pointer to a record type peculiar
2118: to this routine. The record contains a pointer to the adapter
2119: and a pointer to an address in which to place the contents
2120: of csr 0.
2121:
2122: Return Value:
2123:
2124: Always returns true.
2125:
2126: --*/
2127:
2128: {
2129:
2130: PLANCE_SYNCH_CONTEXT C = Context;
2131:
2132: *(C->LocalRead) = *(C->LocalRead) | C->Adapter->CSR0Value;
2133:
2134: C->Adapter->CSR0Value = 0;
2135:
2136: return TRUE;
2137:
2138: }
2139:
2140: extern
2141: BOOLEAN
2142: LanceISR(
2143: IN PVOID Context
2144: )
2145:
2146: /*++
2147:
2148: Routine Description:
2149:
2150: Interrupt service routine for the lance. It's main job is
2151: to get the value of CSR0 and record the changes in the
2152: adapters own list of interrupt reasons.
2153:
2154: Arguments:
2155:
2156: Context - Really a pointer to the adapter.
2157:
2158: Return Value:
2159:
2160: Returns true if the INTR bit of CSR0 of the lance is enabled.
2161:
2162: --*/
2163:
2164: {
2165:
2166: //
2167: // Will hold the value from the csr.
2168: //
2169: USHORT LocalCSR0Value;
2170:
2171: //
2172: // Holds the pointer to the adapter.
2173: //
2174: PLANCE_ADAPTER Adapter = Context;
2175:
2176: BOOLEAN StoppedInterrupts=FALSE;
2177:
2178: LOG(IN_ISR);
2179:
2180: if (Adapter->LanceCard & (LANCE_DE201 | LANCE_DE100 | LANCE_DE422)) {
2181:
2182: //
2183: // If not currently pended, pend interrupts...
2184: //
2185:
2186: if (!(Adapter->InterruptsStopped)){
2187:
2188: //
2189: // Pend interrupts
2190: //
2191:
2192: StoppedInterrupts = TRUE;
2193:
2194: Adapter->InterruptsStopped = TRUE;
2195:
2196: LOG(PEND);
2197:
2198: LANCE_ISR_WRITE_NICSR(Adapter,
2199: LANCE_NICSR_IMASK | LANCE_NICSR_LED_ON | LANCE_NICSR_INT_ON);
2200:
2201: }
2202:
2203: }
2204:
2205: //
2206: // We don't need to select csr0, as the only way we could get
2207: // an interrupt is to have already selected 0.
2208: //
2209:
2210: LANCE_ISR_READ_RDP(Adapter, &LocalCSR0Value);
2211:
2212: if (LocalCSR0Value & LANCE_CSR0_INTERRUPT_FLAG) {
2213:
2214: //
2215: // It's our interrupt. Clear only those bits that we got
2216: // in this read of csr0. We do it this way incase any new
2217: // reasons for interrupts occur between the time that we
2218: // read csr0 and the time that we clear the bits.
2219: //
2220:
2221: LANCE_ISR_WRITE_RDP(
2222: Adapter,
2223: (USHORT)((LANCE_CSR0_CLEAR_INTERRUPT_BITS & LocalCSR0Value) |
2224: LANCE_CSR0_INTERRUPT_ENABLE)
2225: );
2226:
2227:
2228: if (Adapter->FirstInitialization &&
2229: (LocalCSR0Value & LANCE_CSR0_INITIALIZATION_DONE)) {
2230:
2231: Adapter->FirstInitialization = FALSE;
2232:
2233: if ((Adapter->LanceCard & (LANCE_DE201 | LANCE_DE100 | LANCE_DE422)) &&
2234: StoppedInterrupts) {
2235:
2236: //
2237: // Allow interrupts
2238: //
2239:
2240: Adapter->InterruptsStopped = FALSE;
2241:
2242: LOG(UNPEND);
2243:
2244: LANCE_ISR_WRITE_NICSR(Adapter, LANCE_NICSR_INT_ON);
2245:
2246: }
2247:
2248: LOG(OUT_ISR);
2249:
2250: return FALSE;
2251:
2252: } else {
2253:
2254: //
2255: // Or the csr value into the adapter version of csr 0.
2256: //
2257:
2258: Adapter->CSR0Value |= LocalCSR0Value;
2259:
2260: LOG(OUT_ISR);
2261:
2262: return TRUE;
2263:
2264: }
2265:
2266: } else {
2267:
2268: if ((Adapter->LanceCard & (LANCE_DE201 | LANCE_DE100 | LANCE_DE422)) &&
2269: StoppedInterrupts) {
2270:
2271: //
2272: // Allow interrupts
2273: //
2274:
2275: Adapter->InterruptsStopped = FALSE;
2276:
2277: LOG(UNPEND);
2278:
2279: LANCE_ISR_WRITE_NICSR(Adapter, LANCE_NICSR_INT_ON);
2280:
2281: }
2282:
2283: LOG(OUT_ISR);
2284:
2285: return FALSE;
2286:
2287: }
2288:
2289: }
2290:
2291: STATIC
2292: VOID
2293: LanceStandardInterruptDPC(
2294: IN PVOID SystemSpecific,
2295: IN PVOID Context,
2296: IN PVOID SystemArgument1,
2297: IN PVOID SystemArgument2
2298: )
2299:
2300: /*++
2301:
2302: Routine Description:
2303:
2304: This DPC routine is queued by the interrupt service routine
2305: and other routines within the driver that notice that
2306: some deferred processing needs to be done. It's main
2307: job is to call the interrupt processing code.
2308:
2309: Arguments:
2310:
2311: SystemSpecific - not used.
2312:
2313: Context - Really a pointer to the adapter.
2314:
2315:
2316: SystemArgument1 - Flag if we should turn interrupts on when done
2317: processing.
2318:
2319: SystemArgument2 - Not used.
2320:
2321: Return Value:
2322:
2323: None.
2324:
2325: --*/
2326:
2327: {
2328: //
2329: // Holds the pointer to the adapter.
2330: //
2331: PLANCE_ADAPTER Adapter = Context;
2332:
2333: USHORT InterruptsStopped;
2334:
2335: UNREFERENCED_PARAMETER(SystemSpecific);
2336: UNREFERENCED_PARAMETER(SystemArgument1);
2337: UNREFERENCED_PARAMETER(SystemArgument2);
2338:
2339: LOG(IN_DPC);
2340:
2341: NdisDprAcquireSpinLock(&Adapter->Lock);
2342:
2343: if (Adapter->ProcessInterruptRunning) {
2344:
2345: LOG(OUT_DPC);
2346:
2347: NdisDprReleaseSpinLock(&Adapter->Lock);
2348:
2349: return;
2350:
2351: }
2352:
2353: Adapter->ProcessInterruptRunning = TRUE;
2354:
2355: ProcessInterrupt(Adapter);
2356:
2357: InterruptsStopped = Adapter->InterruptsStopped;
2358:
2359: if ((Adapter->LanceCard & (LANCE_DE201 | LANCE_DE100 | LANCE_DE422)) &&
2360: InterruptsStopped) {
2361:
2362: //
2363: // Allow interrupts
2364: //
2365:
2366: LOG(UNPEND);
2367:
2368: LOG(OUT_DPC);
2369:
2370:
2371: //
2372: // Safe to write here since the ISR will not fire with interrupts stopped.
2373: //
2374:
2375: Adapter->InterruptsStopped = FALSE;
2376:
2377: LANCE_WRITE_NICSR(Adapter, LANCE_NICSR_INT_ON);
2378:
2379: } else {
2380:
2381: LOG(OUT_DPC);
2382:
2383: }
2384:
2385: NdisDprReleaseSpinLock(&Adapter->Lock);
2386:
2387: }
2388:
2389: STATIC
2390: BOOLEAN
2391: AllocateAdapterMemory(
2392: IN PLANCE_ADAPTER Adapter
2393: )
2394:
2395: /*++
2396:
2397: Routine Description:
2398:
2399: This routine allocates memory for:
2400:
2401: - Transmit ring entries
2402:
2403: - Receive ring entries
2404:
2405: - Receive buffers
2406:
2407: - Adapter buffers for use if user transmit buffers don't meet hardware
2408: contraints
2409:
2410: - Structures to map transmit ring entries back to the packets.
2411:
2412: Arguments:
2413:
2414: Adapter - The adapter to allocate memory for.
2415:
2416: Return Value:
2417:
2418: Returns FALSE if some memory needed for the adapter could not
2419: be allocated.
2420:
2421: --*/
2422:
2423: {
2424:
2425: //
2426: // Pointer to a transmit ring entry. Used while initializing
2427: // the ring.
2428: //
2429: PLANCE_TRANSMIT_ENTRY CurrentTransmitEntry;
2430:
2431: //
2432: // Pointer to a receive ring entry. Used while initializing
2433: // the ring.
2434: //
2435: PLANCE_RECEIVE_ENTRY CurrentReceiveEntry;
2436:
2437: //
2438: // Simple iteration variable.
2439: //
2440: UINT i;
2441:
2442: //
2443: // These variables exist to reduce the amount of checking below.
2444: //
2445:
2446: ULONG NumberOfSmallBuffers;
2447: ULONG NumberOfMediumBuffers;
2448: ULONG NumberOfLargeBuffers;
2449:
2450:
2451: NumberOfSmallBuffers = Adapter->NumberOfSmallBuffers;
2452: NumberOfMediumBuffers = Adapter->NumberOfMediumBuffers;
2453: NumberOfLargeBuffers = Adapter->NumberOfLargeBuffers;
2454:
2455:
2456:
2457: //
2458: // Allocate memory for the initialization block. Note that
2459: // this memory can not cross a page boundary.
2460: //
2461:
2462: LANCE_ALLOCATE_MEMORY_FOR_HARDWARE(
2463: Adapter,
2464: sizeof(LANCE_INITIALIZATION_BLOCK),
2465: &Adapter->InitBlock
2466: );
2467:
2468: if (Adapter->InitBlock == NULL) {
2469: DeleteAdapterMemory(Adapter);
2470: return FALSE;
2471: }
2472:
2473: //
2474: // Allocate the transmit ring descriptors.
2475: //
2476:
2477: LANCE_ALLOCATE_MEMORY_FOR_HARDWARE(
2478: Adapter,
2479: sizeof(LANCE_TRANSMIT_ENTRY)*Adapter->NumberOfTransmitRings,
2480: &Adapter->TransmitRing
2481: )
2482:
2483: if (Adapter->TransmitRing == NULL) {
2484: DeleteAdapterMemory(Adapter);
2485: return FALSE;
2486: }
2487:
2488: //
2489: // We have the transmit ring descriptors. Make sure each is
2490: // in a clean state.
2491: //
2492:
2493: for (
2494: i = 0, CurrentTransmitEntry = Adapter->TransmitRing;
2495: i < Adapter->NumberOfTransmitRings;
2496: i++,CurrentTransmitEntry++
2497: ) {
2498:
2499: LANCE_ZERO_MEMORY_FOR_HARDWARE(
2500: CurrentTransmitEntry,
2501: sizeof(LANCE_TRANSMIT_ENTRY)
2502: );
2503:
2504: }
2505:
2506:
2507: //
2508: // Allocate all of the receive ring entries
2509: //
2510:
2511: LANCE_ALLOCATE_MEMORY_FOR_HARDWARE(
2512: Adapter,
2513: sizeof(LANCE_RECEIVE_ENTRY)*Adapter->NumberOfReceiveRings,
2514: &Adapter->ReceiveRing
2515: )
2516:
2517: if (Adapter->ReceiveRing == NULL) {
2518: DeleteAdapterMemory(Adapter);
2519: return FALSE;
2520: }
2521:
2522: //
2523: // We have the receive ring descriptors. Allocate an
2524: // array to hold the virtual addresses of each receive
2525: // buffer.
2526: //
2527:
2528: LANCE_ALLOC_PHYS(
2529: &(Adapter->ReceiveVAs),
2530: sizeof(PVOID) * Adapter->NumberOfReceiveRings
2531: );
2532:
2533: if (Adapter->ReceiveVAs == NULL) {
2534: DeleteAdapterMemory(Adapter);
2535: return FALSE;
2536: }
2537:
2538: //
2539: // Clean the above memory
2540: //
2541:
2542: LANCE_ZERO_MEMORY(
2543: Adapter->ReceiveVAs,
2544: (sizeof(PVOID)*Adapter->NumberOfReceiveRings)
2545: );
2546:
2547:
2548: //
2549: // We have the receive ring descriptors. Allocate a buffer
2550: // for each descriptor and make sure descriptor is in a clean state.
2551: //
2552: // While we're at it, relinquish ownership of the ring discriptors to
2553: // the lance.
2554: //
2555:
2556: for (
2557: i = 0, CurrentReceiveEntry = Adapter->ReceiveRing;
2558: i < Adapter->NumberOfReceiveRings;
2559: i++,CurrentReceiveEntry++
2560: ) {
2561:
2562: LANCE_ALLOCATE_MEMORY_FOR_HARDWARE(
2563: Adapter,
2564: Adapter->SizeOfReceiveBuffer,
2565: &Adapter->ReceiveVAs[i]
2566: );
2567:
2568: if (Adapter->ReceiveVAs[i] == NULL) {
2569: DeleteAdapterMemory(Adapter);
2570: return FALSE;
2571: }
2572:
2573:
2574: LANCE_SET_RECEIVE_BUFFER_ADDRESS(
2575: Adapter,
2576: CurrentReceiveEntry,
2577: Adapter->ReceiveVAs[i]
2578: );
2579:
2580:
2581: LANCE_SET_RECEIVE_BUFFER_LENGTH(
2582: CurrentReceiveEntry,
2583: Adapter->SizeOfReceiveBuffer
2584: );
2585:
2586: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
2587: CurrentReceiveEntry->ReceiveSummaryBits,
2588: LANCE_RECEIVE_OWNED_BY_CHIP
2589: );
2590:
2591:
2592: }
2593:
2594: //
2595: // Allocate the ring to packet structure.
2596: //
2597:
2598: LANCE_ALLOC_PHYS(
2599: &(Adapter->RingToPacket),
2600: sizeof(LANCE_RING_TO_PACKET) * Adapter->NumberOfTransmitRings
2601: );
2602:
2603: if (Adapter->RingToPacket == NULL) {
2604: DeleteAdapterMemory(Adapter);
2605: return FALSE;
2606: }
2607:
2608: LANCE_ZERO_MEMORY(
2609: Adapter->RingToPacket,
2610: sizeof(LANCE_RING_TO_PACKET) * Adapter->NumberOfTransmitRings
2611: );
2612:
2613: //
2614: // Allocate the array of buffer descriptors.
2615: //
2616:
2617: LANCE_ALLOC_PHYS(
2618: &(Adapter->LanceBuffers),
2619: sizeof(LANCE_BUFFER_DESCRIPTOR) *
2620: (NumberOfSmallBuffers +
2621: NumberOfMediumBuffers +
2622: NumberOfLargeBuffers)
2623: );
2624:
2625: if (Adapter->LanceBuffers == NULL) {
2626: DeleteAdapterMemory(Adapter);
2627: return FALSE;
2628: }
2629:
2630: //
2631: // Zero the memory of all the descriptors so that we can
2632: // know which buffers wern't allocated incase we can't allocate
2633: // them all.
2634: //
2635: LANCE_ZERO_MEMORY(
2636: Adapter->LanceBuffers,
2637: sizeof(LANCE_BUFFER_DESCRIPTOR)*
2638: (NumberOfSmallBuffers +
2639: NumberOfMediumBuffers +
2640: NumberOfLargeBuffers)
2641: );
2642:
2643: //
2644: // Allocate each of the small lance buffers and fill in the
2645: // buffer descriptor.
2646: //
2647:
2648: Adapter->LanceBufferListHeads[0] = -1;
2649: Adapter->LanceBufferListHeads[1] = 0;
2650:
2651: for (
2652: i = 0;
2653: i < NumberOfSmallBuffers;
2654: i++
2655: ) {
2656:
2657: LANCE_ALLOCATE_MEMORY_FOR_HARDWARE(
2658: Adapter,
2659: LANCE_SMALL_BUFFER_SIZE,
2660: &Adapter->LanceBuffers[i].VirtualLanceBuffer
2661: );
2662:
2663: if (Adapter->LanceBuffers[i].VirtualLanceBuffer == NULL) {
2664: DeleteAdapterMemory(Adapter);
2665: return FALSE;
2666: }
2667:
2668: Adapter->LanceBuffers[i].Next = i+1;
2669: Adapter->LanceBuffers[i].BufferSize = LANCE_SMALL_BUFFER_SIZE;
2670:
2671: }
2672:
2673: //
2674: // Make sure that the last buffer correctly terminates the free list.
2675: //
2676:
2677: Adapter->LanceBuffers[i-1].Next = -1;
2678:
2679: //
2680: // Do the medium buffers now.
2681: //
2682:
2683: Adapter->LanceBufferListHeads[2] = i;
2684:
2685: for (
2686: ;
2687: i < NumberOfSmallBuffers + NumberOfMediumBuffers;
2688: i++
2689: ) {
2690:
2691: LANCE_ALLOCATE_MEMORY_FOR_HARDWARE(
2692: Adapter,
2693: LANCE_MEDIUM_BUFFER_SIZE,
2694: &Adapter->LanceBuffers[i].VirtualLanceBuffer
2695: );
2696:
2697: if (Adapter->LanceBuffers[i].VirtualLanceBuffer == NULL) {
2698: DeleteAdapterMemory(Adapter);
2699: return FALSE;
2700: }
2701:
2702:
2703: Adapter->LanceBuffers[i].Next = i+1;
2704: Adapter->LanceBuffers[i].BufferSize = LANCE_MEDIUM_BUFFER_SIZE;
2705:
2706: }
2707:
2708: //
2709: // Make sure that the last buffer correctly terminates the free list.
2710: //
2711:
2712: Adapter->LanceBuffers[i-1].Next = -1;
2713:
2714:
2715: Adapter->LanceBufferListHeads[3] = i;
2716:
2717: for (
2718: ;
2719: i < NumberOfSmallBuffers + NumberOfMediumBuffers + NumberOfLargeBuffers;
2720: i++
2721: ) {
2722:
2723:
2724: LANCE_ALLOCATE_MEMORY_FOR_HARDWARE(
2725: Adapter,
2726: LANCE_LARGE_BUFFER_SIZE,
2727: &Adapter->LanceBuffers[i].VirtualLanceBuffer
2728: );
2729:
2730: if (Adapter->LanceBuffers[i].VirtualLanceBuffer == NULL) {
2731: DeleteAdapterMemory(Adapter);
2732: return FALSE;
2733: }
2734:
2735:
2736: Adapter->LanceBuffers[i].Next = i+1;
2737: Adapter->LanceBuffers[i].BufferSize = LANCE_LARGE_BUFFER_SIZE;
2738:
2739: }
2740:
2741: //
2742: // Make sure that the last buffer correctly terminates the free list.
2743: //
2744:
2745: Adapter->LanceBuffers[i-1].Next = -1;
2746:
2747: return TRUE;
2748:
2749: }
2750:
2751: STATIC
2752: VOID
2753: DeleteAdapterMemory(
2754: IN PLANCE_ADAPTER Adapter
2755: )
2756:
2757: /*++
2758:
2759: Routine Description:
2760:
2761: This routine deallocates memory for:
2762:
2763: - Transmit ring entries
2764:
2765: - Receive ring entries
2766:
2767: - Receive buffers
2768:
2769: - Adapter buffers for use if user transmit buffers don't meet hardware
2770: contraints
2771:
2772: - Structures to map transmit ring entries back to the packets.
2773:
2774: Arguments:
2775:
2776: Adapter - The adapter to deallocate memory for.
2777:
2778: Return Value:
2779:
2780: None.
2781:
2782: --*/
2783:
2784: {
2785:
2786: //
2787: // These variables exist to reduce the amount of checking below.
2788: //
2789:
2790: ULONG NumberOfSmallBuffers;
2791: ULONG NumberOfMediumBuffers;
2792: ULONG NumberOfLargeBuffers;
2793:
2794: NumberOfSmallBuffers = Adapter->NumberOfSmallBuffers;
2795: NumberOfMediumBuffers = Adapter->NumberOfMediumBuffers;
2796: NumberOfLargeBuffers = Adapter->NumberOfLargeBuffers;
2797:
2798:
2799: if (Adapter->InitBlock) {
2800:
2801: LANCE_DEALLOCATE_MEMORY_FOR_HARDWARE(
2802: Adapter,
2803: Adapter->InitBlock
2804: );
2805:
2806: }
2807:
2808: if (Adapter->TransmitRing) {
2809:
2810: LANCE_DEALLOCATE_MEMORY_FOR_HARDWARE(
2811: Adapter,
2812: Adapter->TransmitRing
2813: );
2814:
2815: }
2816:
2817: if (Adapter->ReceiveRing) {
2818:
2819: LANCE_DEALLOCATE_MEMORY_FOR_HARDWARE(
2820: Adapter,
2821: Adapter->ReceiveRing
2822: );
2823:
2824: }
2825:
2826: if (Adapter->ReceiveVAs) {
2827:
2828: UINT i;
2829:
2830: for (
2831: i = 0;
2832: i < Adapter->NumberOfReceiveRings;
2833: i++
2834: ) {
2835:
2836: if (Adapter->ReceiveVAs[i]) {
2837:
2838: LANCE_DEALLOCATE_MEMORY_FOR_HARDWARE(
2839: Adapter,
2840: Adapter->ReceiveVAs[i]
2841: );
2842:
2843: } else {
2844:
2845: break;
2846:
2847: }
2848:
2849: }
2850:
2851: LANCE_FREE_PHYS(
2852: Adapter->ReceiveVAs,
2853: sizeof(PVOID) * Adapter->NumberOfReceiveRings
2854: );
2855:
2856: }
2857:
2858: if (Adapter->RingToPacket) {
2859:
2860: LANCE_FREE_PHYS(
2861: Adapter->RingToPacket,
2862: sizeof(LANCE_RING_TO_PACKET) * Adapter->NumberOfTransmitRings
2863: );
2864:
2865: }
2866:
2867: if (Adapter->LanceBuffers) {
2868:
2869: UINT i;
2870:
2871: for (
2872: i = 0;
2873: i < NumberOfSmallBuffers + NumberOfMediumBuffers + NumberOfLargeBuffers;
2874: i++) {
2875:
2876: if (Adapter->LanceBuffers[i].VirtualLanceBuffer) {
2877:
2878: LANCE_DEALLOCATE_MEMORY_FOR_HARDWARE(
2879: Adapter,
2880: Adapter->LanceBuffers[i].VirtualLanceBuffer
2881: );
2882:
2883: } else {
2884:
2885: break;
2886:
2887: }
2888:
2889: }
2890:
2891: LANCE_FREE_PHYS(
2892: Adapter->LanceBuffers,
2893: sizeof(LANCE_BUFFER_DESCRIPTOR) *
2894: (NumberOfSmallBuffers +
2895: NumberOfMediumBuffers +
2896: NumberOfLargeBuffers)
2897: );
2898:
2899: }
2900:
2901: }
2902:
2903: STATIC
2904: NDIS_STATUS
2905: LanceOpenAdapter(
2906: OUT PNDIS_STATUS OpenErrorStatus,
2907: OUT NDIS_HANDLE *MacBindingHandle,
2908: OUT PUINT SelectedMediumIndex,
2909: IN PNDIS_MEDIUM MediumArray,
2910: IN UINT MediumArraySize,
2911: IN NDIS_HANDLE NdisBindingContext,
2912: IN NDIS_HANDLE MacAdapterContext,
2913: IN UINT OpenOptions,
2914: IN PSTRING AddressingInformation OPTIONAL
2915: )
2916:
2917: /*++
2918:
2919: Routine Description:
2920:
2921: This routine is used to create an open instance of an adapter, in effect
2922: creating a binding between an upper-level module and the MAC module over
2923: the adapter.
2924:
2925: Arguments:
2926:
2927: MacBindingHandle - A pointer to a location in which the MAC stores
2928: a context value that it uses to represent this binding.
2929:
2930: SelectedMediumIndex - Index of MediumArray which this adapter supports.
2931:
2932: MediumArray - Array of Medium types which the protocol is requesting.
2933:
2934: MediumArraySize - Number of entries in MediumArray.
2935:
2936: NdisBindingContext - A value to be recorded by the MAC and passed as
2937: context whenever an indication is delivered by the MAC for this binding.
2938:
2939: MacAdapterContext - The value associated with the adapter that is being
2940: opened when the MAC registered the adapter with NdisRegisterAdapter.
2941:
2942: OpenOptions - A bit mask of flags. Not used.
2943:
2944: AddressingInformation - An optional pointer to a variable length string
2945: containing hardware-specific information that can be used to program the
2946: device. (This is not used by this MAC.)
2947:
2948: Return Value:
2949:
2950: The function value is the status of the operation. If the MAC does not
2951: complete this request synchronously, the value would be
2952: NDIS_STATUS_PENDING.
2953:
2954:
2955: --*/
2956:
2957: {
2958:
2959: //
2960: // The LANCE_ADAPTER that this open binding should belong too.
2961: //
2962: PLANCE_ADAPTER Adapter;
2963:
2964: //
2965: // Holds the status that should be returned to the caller.
2966: //
2967: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
2968:
2969: PLANCE_OPEN NewOpen;
2970:
2971:
2972: UNREFERENCED_PARAMETER(OpenOptions);
2973: UNREFERENCED_PARAMETER(OpenErrorStatus);
2974: UNREFERENCED_PARAMETER(AddressingInformation);
2975:
2976:
2977: //
2978: // Search for correct medium.
2979: //
2980:
2981: for (; MediumArraySize > 0; MediumArraySize--){
2982:
2983: if (MediumArray[MediumArraySize - 1] == NdisMedium802_3){
2984:
2985: MediumArraySize--;
2986:
2987: break;
2988:
2989: }
2990:
2991: }
2992:
2993: if (MediumArray[MediumArraySize] != NdisMedium802_3){
2994:
2995: return(NDIS_STATUS_UNSUPPORTED_MEDIA);
2996:
2997: }
2998:
2999: *SelectedMediumIndex = MediumArraySize;
3000:
3001:
3002: Adapter = PLANCE_ADAPTER_FROM_CONTEXT_HANDLE(MacAdapterContext);
3003:
3004: NdisInterlockedAddUlong(&Adapter->References, 1, &Adapter->Lock);
3005:
3006: //
3007: // Allocate the space for the open binding. Fill in the fields.
3008: //
3009:
3010: LANCE_ALLOC_PHYS(&NewOpen,sizeof(LANCE_OPEN));
3011:
3012: if (NewOpen != NULL){
3013:
3014: *MacBindingHandle = BINDING_HANDLE_FROM_PLANCE_OPEN(NewOpen);
3015:
3016: InitializeListHead(&NewOpen->OpenList);
3017:
3018: NewOpen->NdisBindingContext = NdisBindingContext;
3019: NewOpen->References = 0;
3020: NewOpen->BindingShuttingDown = FALSE;
3021: NewOpen->OwningLance = Adapter;
3022:
3023: NewOpen->LookAhead = LANCE_MAX_LOOKAHEAD;
3024:
3025: NdisAcquireSpinLock(&Adapter->Lock);
3026:
3027: Adapter->MaxLookAhead = LANCE_MAX_LOOKAHEAD;
3028:
3029: if (!EthNoteFilterOpenAdapter(
3030: NewOpen->OwningLance->FilterDB,
3031: NewOpen,
3032: NdisBindingContext,
3033: &NewOpen->NdisFilterHandle
3034: )) {
3035:
3036: NdisReleaseSpinLock(&Adapter->Lock);
3037:
3038: LANCE_FREE_PHYS(NewOpen, sizeof(LANCE_OPEN));
3039:
3040: StatusToReturn = NDIS_STATUS_FAILURE;
3041:
3042: NdisAcquireSpinLock(&Adapter->Lock);
3043:
3044: } else {
3045:
3046: //
3047: // Everything has been filled in. Synchronize access to the
3048: // adapter block and link the new open adapter in and increment
3049: // the opens reference count to account for the fact that the
3050: // filter routines have a "reference" to the open.
3051: //
3052:
3053: InsertTailList(&Adapter->OpenBindings,&NewOpen->OpenList);
3054: NewOpen->References++;
3055:
3056: }
3057:
3058: } else {
3059:
3060: NdisWriteErrorLogEntry(
3061: Adapter->NdisAdapterHandle,
3062: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
3063: 1,
3064: (ULONG)openAdapter
3065: );
3066:
3067:
3068: StatusToReturn = NDIS_STATUS_RESOURCES;
3069:
3070: NdisAcquireSpinLock(&Adapter->Lock);
3071:
3072: }
3073:
3074: LANCE_DO_DEFERRED(Adapter);
3075:
3076: return StatusToReturn;
3077: }
3078:
3079: VOID
3080: LanceAdjustMaxLookAhead(
3081: IN PLANCE_ADAPTER Adapter
3082: )
3083: /*++
3084:
3085: Routine Description:
3086:
3087: This routine finds the open with the maximum lookahead value and
3088: stores that in the adapter block.
3089:
3090: Arguments:
3091:
3092: Adapter - A pointer to the adapter block.
3093:
3094: Returns:
3095:
3096: None.
3097:
3098: --*/
3099: {
3100: ULONG CurrentMax = 0;
3101: PLIST_ENTRY Link = &(Adapter->OpenBindings);
3102:
3103: while (Link->Flink != &(Adapter->OpenBindings)) {
3104:
3105: if (((PLANCE_OPEN)(Link->Flink))->LookAhead > CurrentMax) {
3106:
3107: CurrentMax = ((PLANCE_OPEN)(Link->Flink))->LookAhead;
3108:
3109: }
3110:
3111: Link = Link->Flink;
3112:
3113: }
3114:
3115: if (CurrentMax == 0) {
3116:
3117: CurrentMax = LANCE_MAX_LOOKAHEAD;
3118:
3119: }
3120:
3121: Adapter->MaxLookAhead = CurrentMax;
3122:
3123: }
3124:
3125:
3126: STATIC
3127: NDIS_STATUS
3128: LanceCloseAdapter(
3129: IN NDIS_HANDLE MacBindingHandle
3130: )
3131:
3132: /*++
3133:
3134: Routine Description:
3135:
3136: This routine causes the MAC to close an open handle (binding).
3137:
3138: Arguments:
3139:
3140: MacBindingHandle - The context value returned by the MAC when the
3141: adapter was opened. In reality it is a PLANCE_OPEN.
3142:
3143: Return Value:
3144:
3145: The function value is the status of the operation.
3146:
3147:
3148: --*/
3149:
3150: {
3151:
3152: PLANCE_ADAPTER Adapter;
3153:
3154: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
3155:
3156: PLANCE_OPEN Open;
3157:
3158: Adapter = PLANCE_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
3159:
3160: //
3161: // Hold the lock while we update the reference counts for the
3162: // adapter and the open.
3163: //
3164:
3165: Open = PLANCE_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
3166:
3167: NdisAcquireSpinLock(&Adapter->Lock);
3168:
3169: Adapter->References++;
3170:
3171: if (!Open->BindingShuttingDown) {
3172:
3173: Open->References++;
3174:
3175: StatusToReturn = EthDeleteFilterOpenAdapter(
3176: Adapter->FilterDB,
3177: Open->NdisFilterHandle,
3178: NULL
3179: );
3180:
3181: //
3182: // If the status is successful that merely implies that
3183: // we were able to delete the reference to the open binding
3184: // from the filtering code. If we have a successful status
3185: // at this point we still need to check whether the reference
3186: // count to determine whether we can close.
3187: //
3188: //
3189: // The delete filter routine can return a "special" status
3190: // that indicates that there is a current NdisIndicateReceive
3191: // on this binding. See below.
3192: //
3193:
3194: if (StatusToReturn == NDIS_STATUS_SUCCESS) {
3195:
3196: //
3197: // Check whether the reference count is two. If
3198: // it is then we can get rid of the memory for
3199: // this open.
3200: //
3201: // A count of two indicates one for this routine
3202: // and one for the filter which we *know* we can
3203: // get rid of.
3204: //
3205:
3206: if (Open->References == 2) {
3207:
3208: //
3209: // We are the only reference to the open. Remove
3210: // it from the open list and delete the memory.
3211: //
3212:
3213: RemoveEntryList(&Open->OpenList);
3214:
3215: if (Adapter->MaxLookAhead == Open->LookAhead) {
3216:
3217: LanceAdjustMaxLookAhead(Adapter);
3218:
3219: }
3220:
3221: LANCE_FREE_PHYS(Open, sizeof(LANCE_OPEN));
3222:
3223: } else {
3224:
3225: Open->BindingShuttingDown = TRUE;
3226:
3227: //
3228: // Remove the open from the open list and put it on
3229: // the closing list.
3230: //
3231:
3232: RemoveEntryList(&Open->OpenList);
3233: InsertTailList(&Adapter->CloseList,&Open->OpenList);
3234:
3235: //
3236: // Account for this routines reference to the open
3237: // as well as reference because of the filtering.
3238: //
3239:
3240: Open->References -= 2;
3241:
3242: //
3243: // Change the status to indicate that we will
3244: // be closing this later.
3245: //
3246:
3247: StatusToReturn = NDIS_STATUS_PENDING;
3248:
3249: }
3250:
3251: } else if (StatusToReturn == NDIS_STATUS_PENDING) {
3252:
3253: Open->BindingShuttingDown = TRUE;
3254:
3255: //
3256: // Remove the open from the open list and put it on
3257: // the closing list.
3258: //
3259:
3260: RemoveEntryList(&Open->OpenList);
3261: InsertTailList(&Adapter->CloseList,&Open->OpenList);
3262:
3263: //
3264: // Account for this routines reference to the open
3265: // as well as original open reference.
3266: //
3267:
3268: Open->References -= 2;
3269:
3270: } else if (StatusToReturn == NDIS_STATUS_CLOSING_INDICATING) {
3271:
3272: //
3273: // When we have this status it indicates that the filtering
3274: // code was currently doing an NdisIndicateReceive. It
3275: // would not be wise to delete the memory for the open at
3276: // this point. The filtering code will call our close action
3277: // routine upon return from NdisIndicateReceive and that
3278: // action routine will decrement the reference count for
3279: // the open.
3280: //
3281:
3282: Open->BindingShuttingDown = TRUE;
3283:
3284: //
3285: // This status is private to the filtering routine. Just
3286: // tell the caller the the close is pending.
3287: //
3288:
3289: StatusToReturn = NDIS_STATUS_PENDING;
3290:
3291: //
3292: // Remove the open from the open list and put it on
3293: // the closing list.
3294: //
3295:
3296: RemoveEntryList(&Open->OpenList);
3297: InsertTailList(&Adapter->CloseList,&Open->OpenList);
3298:
3299: //
3300: // Account for this routines reference to the open. CloseAction
3301: // will remove the second reference.
3302: //
3303:
3304: Open->References--;
3305:
3306: } else {
3307:
3308: //
3309: // Account for this routines reference to the open.
3310: //
3311:
3312: Open->References--;
3313:
3314: }
3315:
3316: } else {
3317:
3318: StatusToReturn = NDIS_STATUS_CLOSING;
3319:
3320: }
3321:
3322:
3323: LANCE_DO_DEFERRED(Adapter);
3324:
3325: return StatusToReturn;
3326:
3327: }
3328:
3329: NDIS_STATUS
3330: LanceRequest(
3331: IN NDIS_HANDLE MacBindingHandle,
3332: IN PNDIS_REQUEST NdisRequest
3333: )
3334:
3335: /*++
3336:
3337: Routine Description:
3338:
3339: This routine allows a protocol to query and set information
3340: about the MAC.
3341:
3342: Arguments:
3343:
3344: MacBindingHandle - The context value returned by the MAC when the
3345: adapter was opened. In reality, it is a pointer to PLANCE_OPEN.
3346:
3347: NdisRequest - A structure which contains the request type (Set or
3348: Query), an array of operations to perform, and an array for holding
3349: the results of the operations.
3350:
3351: Return Value:
3352:
3353: The function value is the status of the operation.
3354:
3355: --*/
3356:
3357: {
3358: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
3359:
3360: PLANCE_OPEN Open = (PLANCE_OPEN)(MacBindingHandle);
3361: PLANCE_ADAPTER Adapter = (Open->OwningLance);
3362:
3363: if (Adapter->HardwareFailure) {
3364:
3365: return(NDIS_STATUS_FAILURE);
3366:
3367: }
3368:
3369:
3370: //
3371: // Ensure that the open does not close while in this function.
3372: //
3373:
3374: NdisAcquireSpinLock(&Adapter->Lock);
3375:
3376: Adapter->References++;
3377:
3378: #if LANCE_TRACE
3379: DbgPrint("In LanceRequest\n");
3380: #endif
3381:
3382: //
3383: // Process request
3384: //
3385:
3386: if (NdisRequest->RequestType == NdisRequestQueryInformation) {
3387:
3388: StatusToReturn = LanceQueryInformation(Adapter, Open, NdisRequest);
3389:
3390: } else {
3391:
3392: if (NdisRequest->RequestType == NdisRequestSetInformation) {
3393:
3394: StatusToReturn = LanceSetInformation(Adapter,Open,NdisRequest);
3395:
3396: } else {
3397:
3398: StatusToReturn = NDIS_STATUS_NOT_RECOGNIZED;
3399:
3400: }
3401:
3402: }
3403:
3404: LANCE_DO_DEFERRED(Adapter);
3405:
3406: #if LANCE_TRACE
3407: DbgPrint("Out LanceRequest %x\n",StatusToReturn);
3408: #endif
3409:
3410: return(StatusToReturn);
3411:
3412: }
3413:
3414: NDIS_STATUS
3415: LanceQueryProtocolInformation(
3416: IN PLANCE_ADAPTER Adapter,
3417: IN PLANCE_OPEN Open,
3418: IN NDIS_OID Oid,
3419: IN BOOLEAN GlobalMode,
3420: IN PVOID InfoBuffer,
3421: IN UINT BytesLeft,
3422: OUT PUINT BytesNeeded,
3423: OUT PUINT BytesWritten
3424: )
3425:
3426: /*++
3427:
3428: Routine Description:
3429:
3430: The LanceQueryProtocolInformation process a Query request for
3431: NDIS_OIDs that are specific to a binding about the MAC. Note that
3432: some of the OIDs that are specific to bindings are also queryable
3433: on a global basis. Rather than recreate this code to handle the
3434: global queries, I use a flag to indicate if this is a query for the
3435: global data or the binding specific data.
3436:
3437: Arguments:
3438:
3439: Adapter - a pointer to the adapter.
3440:
3441: Open - a pointer to the open instance.
3442:
3443: Oid - the NDIS_OID to process.
3444:
3445: GlobalMode - Some of the binding specific information is also used
3446: when querying global statistics. This is a flag to specify whether
3447: to return the global value, or the binding specific value.
3448:
3449: PlaceInInfoBuffer - a pointer into the NdisRequest->InformationBuffer
3450: into which store the result of the query.
3451:
3452: BytesLeft - the number of bytes left in the InformationBuffer.
3453:
3454: BytesNeeded - If there is not enough room in the information buffer
3455: then this will contain the number of bytes needed to complete the
3456: request.
3457:
3458: BytesWritten - a pointer to the number of bytes written into the
3459: InformationBuffer.
3460:
3461: Return Value:
3462:
3463: The function value is the status of the operation.
3464:
3465: --*/
3466:
3467: {
3468: NDIS_MEDIUM Medium = NdisMedium802_3;
3469: ULONG GenericULong;
3470: USHORT GenericUShort;
3471: UCHAR GenericArray[6];
3472:
3473: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
3474:
3475: //
3476: // Common variables for pointing to result of query
3477: //
3478:
3479: PVOID MoveSource;
3480: ULONG MoveBytes;
3481:
3482: NDIS_HARDWARE_STATUS HardwareStatus = NdisHardwareStatusReady;
3483:
3484: //
3485: // General Algorithm:
3486: //
3487: // Switch(Request)
3488: // Get requested information
3489: // Store results in a common variable.
3490: // Copy result in common variable to result buffer.
3491: //
3492:
3493: //
3494: // Make sure that ulong is 4 bytes. Else GenericULong must change
3495: // to something of size 4.
3496: //
3497: ASSERT(sizeof(ULONG) == 4);
3498:
3499:
3500: #if LANCE_TRACE
3501: DbgPrint("In LanceQueryProtocolInfo\n");
3502: #endif
3503:
3504: //
3505: // Set default values
3506: //
3507:
3508: MoveSource = (PVOID)(&GenericULong);
3509: MoveBytes = sizeof(GenericULong);
3510:
3511: //
3512: // Switch on request type
3513: //
3514:
3515: switch (Oid) {
3516:
3517: case OID_GEN_MAC_OPTIONS:
3518:
3519: GenericULong = (ULONG)(NDIS_MAC_OPTION_TRANSFERS_NOT_PEND |
3520: NDIS_MAC_OPTION_RECEIVE_SERIALIZED
3521: );
3522:
3523: break;
3524:
3525: case OID_GEN_SUPPORTED_LIST:
3526:
3527: if (!GlobalMode){
3528:
3529: MoveSource = (PVOID)(LanceProtocolSupportedOids);
3530: MoveBytes = sizeof(LanceProtocolSupportedOids);
3531:
3532: } else {
3533:
3534: MoveSource = (PVOID)(LanceGlobalSupportedOids);
3535: MoveBytes = sizeof(LanceGlobalSupportedOids);
3536:
3537: }
3538: break;
3539:
3540: case OID_GEN_HARDWARE_STATUS:
3541:
3542:
3543: if (Adapter->ResetInProgress){
3544:
3545: HardwareStatus = NdisHardwareStatusReset;
3546:
3547: } else {
3548:
3549: HardwareStatus = NdisHardwareStatusReady;
3550:
3551: }
3552:
3553:
3554: MoveSource = (PVOID)(&HardwareStatus);
3555: MoveBytes = sizeof(NDIS_HARDWARE_STATUS);
3556:
3557: break;
3558:
3559: case OID_GEN_MEDIA_SUPPORTED:
3560: case OID_GEN_MEDIA_IN_USE:
3561:
3562: MoveSource = (PVOID) (&Medium);
3563: MoveBytes = sizeof(NDIS_MEDIUM);
3564: break;
3565:
3566: case OID_GEN_MAXIMUM_LOOKAHEAD:
3567:
3568: GenericULong = LANCE_MAX_LOOKAHEAD;
3569:
3570: break;
3571:
3572:
3573: case OID_GEN_MAXIMUM_FRAME_SIZE:
3574:
3575: GenericULong = (ULONG)(LANCE_LARGE_BUFFER_SIZE - LANCE_HEADER_SIZE);
3576:
3577: break;
3578:
3579:
3580: case OID_GEN_MAXIMUM_TOTAL_SIZE:
3581:
3582: GenericULong = (ULONG)(LANCE_LARGE_BUFFER_SIZE);
3583:
3584: break;
3585:
3586:
3587: case OID_GEN_LINK_SPEED:
3588:
3589: GenericULong = (ULONG)(100000);
3590:
3591: break;
3592:
3593:
3594: case OID_GEN_TRANSMIT_BUFFER_SPACE:
3595:
3596: GenericULong = (ULONG)((LANCE_SMALL_BUFFER_SIZE * Adapter->NumberOfSmallBuffers) +
3597: (LANCE_MEDIUM_BUFFER_SIZE * Adapter->NumberOfMediumBuffers) +
3598: (LANCE_LARGE_BUFFER_SIZE * Adapter->NumberOfLargeBuffers));
3599:
3600:
3601: break;
3602:
3603: case OID_GEN_RECEIVE_BUFFER_SPACE:
3604:
3605: GenericULong = (ULONG)(Adapter->NumberOfReceiveRings *
3606: Adapter->SizeOfReceiveBuffer);
3607:
3608: break;
3609:
3610: case OID_GEN_TRANSMIT_BLOCK_SIZE:
3611:
3612: GenericULong = (ULONG)(LANCE_SMALL_BUFFER_SIZE);
3613:
3614: break;
3615:
3616: case OID_GEN_RECEIVE_BLOCK_SIZE:
3617:
3618: GenericULong = (ULONG)(Adapter->SizeOfReceiveBuffer);
3619:
3620: break;
3621:
3622: case OID_GEN_VENDOR_ID:
3623:
3624: NdisMoveMemory(
3625: (PVOID)&GenericULong,
3626: Adapter->NetworkAddress,
3627: 3
3628: );
3629:
3630: GenericULong &= 0xFFFFFF00;
3631:
3632: if (Adapter->LanceCard == LANCE_DE201) {
3633:
3634: GenericULong |= 0x01;
3635:
3636: } else if (Adapter->LanceCard == LANCE_DE100) {
3637:
3638: GenericULong |= 0x02;
3639:
3640: } else if (Adapter->LanceCard == LANCE_DE422) {
3641:
3642: GenericULong |= 0x03;
3643:
3644: } else {
3645:
3646: GenericULong |= 0x04;
3647:
3648: }
3649:
3650: MoveSource = (PVOID)(&GenericULong);
3651: MoveBytes = sizeof(GenericULong);
3652: break;
3653:
3654: case OID_GEN_VENDOR_DESCRIPTION:
3655:
3656: if (Adapter->LanceCard == LANCE_DE201) {
3657:
3658: MoveSource = (PVOID)"DEC Etherworks Turbo Adapter";
3659: MoveBytes = 29;
3660:
3661: } else if (Adapter->LanceCard == LANCE_DE100) {
3662:
3663: MoveSource = (PVOID)"DEC Etherworks Adapter";
3664: MoveBytes = 23;
3665:
3666: } else if (Adapter->LanceCard == LANCE_DE422) {
3667:
3668: MoveSource = (PVOID)"DEC Etherworks Turbo EISA Adapter";
3669: MoveBytes = 34;
3670:
3671: } else {
3672:
3673: MoveSource = (PVOID)"Lance Adapter";
3674: MoveBytes = 15;
3675:
3676: }
3677:
3678: break;
3679:
3680: case OID_GEN_DRIVER_VERSION:
3681:
3682: GenericUShort = (USHORT)0x0301;
3683:
3684: MoveSource = (PVOID)(&GenericUShort);
3685: MoveBytes = sizeof(GenericUShort);
3686: break;
3687:
3688:
3689: case OID_GEN_CURRENT_PACKET_FILTER:
3690:
3691: if (GlobalMode ) {
3692:
3693: GenericULong = ETH_QUERY_FILTER_CLASSES(
3694: Adapter->FilterDB
3695: );
3696:
3697: } else {
3698:
3699: GenericULong = ETH_QUERY_PACKET_FILTER(
3700: Adapter->FilterDB,
3701: Open->NdisFilterHandle
3702: );
3703:
3704: }
3705:
3706: break;
3707:
3708: case OID_GEN_CURRENT_LOOKAHEAD:
3709:
3710: if ( GlobalMode ) {
3711:
3712: GenericULong = Adapter->MaxLookAhead;
3713:
3714: } else {
3715:
3716: GenericULong = Open->LookAhead;
3717:
3718: }
3719:
3720: break;
3721:
3722: case OID_802_3_PERMANENT_ADDRESS:
3723:
3724: LANCE_MOVE_MEMORY((PCHAR)GenericArray,
3725: Adapter->NetworkAddress,
3726: ETH_LENGTH_OF_ADDRESS
3727: );
3728:
3729: MoveSource = (PVOID)(GenericArray);
3730: MoveBytes = sizeof(Adapter->NetworkAddress);
3731: break;
3732:
3733: case OID_802_3_CURRENT_ADDRESS:
3734:
3735:
3736: LANCE_MOVE_MEMORY((PCHAR)GenericArray,
3737: Adapter->CurrentNetworkAddress,
3738: ETH_LENGTH_OF_ADDRESS
3739: );
3740:
3741: MoveSource = (PVOID)(GenericArray);
3742: MoveBytes = sizeof(Adapter->CurrentNetworkAddress);
3743: break;
3744:
3745: case OID_802_3_MULTICAST_LIST:
3746:
3747:
3748: {
3749: UINT NumAddresses;
3750:
3751: if (GlobalMode) {
3752:
3753: NumAddresses = ETH_NUMBER_OF_GLOBAL_FILTER_ADDRESSES(Adapter->FilterDB);
3754:
3755: if ((NumAddresses * ETH_LENGTH_OF_ADDRESS) > BytesLeft) {
3756:
3757: *BytesNeeded = (NumAddresses * ETH_LENGTH_OF_ADDRESS);
3758:
3759: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
3760:
3761: break;
3762:
3763: }
3764:
3765: EthQueryGlobalFilterAddresses(
3766: &StatusToReturn,
3767: Adapter->FilterDB,
3768: BytesLeft,
3769: &NumAddresses,
3770: InfoBuffer
3771: );
3772:
3773: *BytesWritten = NumAddresses * ETH_LENGTH_OF_ADDRESS;
3774:
3775: //
3776: // Should not be an error since we held the spinlock
3777: // nothing should have changed.
3778: //
3779:
3780: ASSERT(StatusToReturn == NDIS_STATUS_SUCCESS);
3781:
3782: } else {
3783:
3784: NumAddresses = EthNumberOfOpenFilterAddresses(
3785: Adapter->FilterDB,
3786: Open->NdisFilterHandle
3787: );
3788:
3789: if ((NumAddresses * ETH_LENGTH_OF_ADDRESS) > BytesLeft) {
3790:
3791: *BytesNeeded = (NumAddresses * ETH_LENGTH_OF_ADDRESS);
3792:
3793: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
3794:
3795: break;
3796:
3797: }
3798:
3799: EthQueryOpenFilterAddresses(
3800: &StatusToReturn,
3801: Adapter->FilterDB,
3802: Open->NdisFilterHandle,
3803: BytesLeft,
3804: &NumAddresses,
3805: InfoBuffer
3806: );
3807:
3808: //
3809: // Should not be an error since we held the spinlock
3810: // nothing should have changed.
3811: //
3812:
3813: ASSERT(StatusToReturn == NDIS_STATUS_SUCCESS);
3814:
3815: *BytesWritten = NumAddresses * ETH_LENGTH_OF_ADDRESS;
3816:
3817: }
3818:
3819: }
3820:
3821: MoveSource = (PVOID)NULL;
3822: MoveBytes = 0;
3823:
3824: break;
3825:
3826: case OID_802_3_MAXIMUM_LIST_SIZE:
3827:
3828: GenericULong = Adapter->MaxMulticastList;
3829:
3830: break;
3831:
3832:
3833:
3834: default:
3835:
3836: StatusToReturn = NDIS_STATUS_NOT_SUPPORTED;
3837: break;
3838: }
3839:
3840: if (StatusToReturn == NDIS_STATUS_SUCCESS){
3841:
3842: if (MoveBytes > BytesLeft){
3843:
3844: //
3845: // Not enough room in InformationBuffer. Punt
3846: //
3847:
3848: *BytesNeeded = MoveBytes;
3849:
3850: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
3851:
3852: } else {
3853:
3854: //
3855: // Store result.
3856: //
3857:
3858: LANCE_MOVE_MEMORY(InfoBuffer, MoveSource, MoveBytes);
3859:
3860: (*BytesWritten) += MoveBytes;
3861:
3862: }
3863: }
3864:
3865: #if LANCE_TRACE
3866: DbgPrint("Out LanceQueryProtocolInfo\n");
3867: #endif
3868:
3869: return(StatusToReturn);
3870: }
3871:
3872: NDIS_STATUS
3873: LanceQueryInformation(
3874: IN PLANCE_ADAPTER Adapter,
3875: IN PLANCE_OPEN Open,
3876: IN PNDIS_REQUEST NdisRequest
3877: )
3878: /*++
3879:
3880: Routine Description:
3881:
3882: The LanceQueryInformation is used by LanceRequest to query information
3883: about the MAC.
3884:
3885: Arguments:
3886:
3887: Adapter - A pointer to the adapter.
3888:
3889: Open - A pointer to a particular open instance.
3890:
3891: NdisRequest - A structure which contains the request type (Query),
3892: an array of operations to perform, and an array for holding
3893: the results of the operations.
3894:
3895: Return Value:
3896:
3897: The function value is the status of the operation.
3898:
3899: --*/
3900:
3901: {
3902:
3903: UINT BytesWritten = 0;
3904: UINT BytesNeeded = 0;
3905: UINT BytesLeft = NdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength;
3906: PUCHAR InfoBuffer = (PUCHAR)(NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer);
3907:
3908: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
3909:
3910:
3911: #if LANCE_TRACE
3912: DbgPrint("In LanceQueryInfo\n");
3913: #endif
3914:
3915:
3916: StatusToReturn = LanceQueryProtocolInformation(
3917: Adapter,
3918: Open,
3919: NdisRequest->DATA.QUERY_INFORMATION.Oid,
3920: FALSE,
3921: InfoBuffer,
3922: BytesLeft,
3923: &BytesNeeded,
3924: &BytesWritten
3925: );
3926:
3927:
3928: NdisRequest->DATA.QUERY_INFORMATION.BytesWritten = BytesWritten;
3929:
3930: NdisRequest->DATA.QUERY_INFORMATION.BytesNeeded = BytesNeeded;
3931:
3932: #if LANCE_TRACE
3933: DbgPrint("Out LanceQueryInfo\n");
3934: #endif
3935:
3936: return(StatusToReturn);
3937: }
3938:
3939: NDIS_STATUS
3940: LanceSetInformation(
3941: IN PLANCE_ADAPTER Adapter,
3942: IN PLANCE_OPEN Open,
3943: IN PNDIS_REQUEST NdisRequest
3944: )
3945: /*++
3946:
3947: Routine Description:
3948:
3949: The LanceSetInformation is used by LanceRequest to set information
3950: about the MAC.
3951:
3952: Note: Assumes it is called with the lock held.
3953:
3954: Arguments:
3955:
3956: Adapter - A pointer to the adapter.
3957:
3958: Open - A pointer to an open instance.
3959:
3960: NdisRequest - A structure which contains the request type (Set),
3961: an array of operations to perform, and an array for holding
3962: the results of the operations.
3963:
3964: Return Value:
3965:
3966: The function value is the status of the operation.
3967:
3968: --*/
3969:
3970: {
3971:
3972: //
3973: // General Algorithm:
3974: //
3975: // For each request
3976: // Verify length
3977: // Switch(Request)
3978: // Process Request
3979: //
3980:
3981: UINT BytesRead = 0;
3982: UINT BytesNeeded = 0;
3983: UINT BytesLeft = NdisRequest->DATA.SET_INFORMATION.InformationBufferLength;
3984: PUCHAR InfoBuffer = (PUCHAR)(NdisRequest->DATA.SET_INFORMATION.InformationBuffer);
3985:
3986: //
3987: // Variables for a particular request
3988: //
3989:
3990: NDIS_OID Oid;
3991: UINT OidLength;
3992:
3993: //
3994: // Variables for holding the new values to be used.
3995: //
3996:
3997: ULONG LookAhead;
3998: ULONG Filter;
3999:
4000: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
4001:
4002:
4003: #if LANCE_TRACE
4004: DbgPrint("In LanceSetInfo\n");
4005: #endif
4006:
4007:
4008: //
4009: // Get Oid and Length of next request
4010: //
4011:
4012: Oid = NdisRequest->DATA.SET_INFORMATION.Oid;
4013:
4014: OidLength = BytesLeft;
4015:
4016: switch (Oid) {
4017:
4018:
4019: case OID_802_3_MULTICAST_LIST:
4020:
4021: //
4022: // Verify length
4023: //
4024:
4025: if ((OidLength % ETH_LENGTH_OF_ADDRESS) != 0){
4026:
4027: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
4028:
4029: NdisRequest->DATA.SET_INFORMATION.BytesRead = 0;
4030: NdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
4031:
4032: return(StatusToReturn);
4033:
4034: }
4035:
4036: //
4037: // Call into filter package.
4038: //
4039:
4040: if (!Open->BindingShuttingDown) {
4041:
4042: //
4043: // Increment the open while it is going through the filtering
4044: // routines.
4045: //
4046:
4047: Open->References++;
4048:
4049: StatusToReturn = EthChangeFilterAddresses(
4050: Adapter->FilterDB,
4051: Open->NdisFilterHandle,
4052: NdisRequest,
4053: OidLength / ETH_LENGTH_OF_ADDRESS,
4054: (CHAR **)InfoBuffer,
4055: TRUE
4056: );
4057:
4058: Open->References--;
4059:
4060: } else {
4061:
4062: StatusToReturn = NDIS_STATUS_CLOSING;
4063:
4064: }
4065:
4066: break;
4067:
4068:
4069: case OID_GEN_CURRENT_PACKET_FILTER:
4070:
4071: //
4072: // Verify length
4073: //
4074:
4075: if (OidLength != 4) {
4076:
4077: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
4078:
4079: NdisRequest->DATA.SET_INFORMATION.BytesRead = 0;
4080: NdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
4081:
4082: break;
4083:
4084: }
4085:
4086:
4087: LANCE_MOVE_MEMORY(&Filter, InfoBuffer, 4);
4088:
4089: //
4090: // Verify bits
4091: //
4092:
4093: if (Filter & (NDIS_PACKET_TYPE_SOURCE_ROUTING |
4094: NDIS_PACKET_TYPE_SMT |
4095: NDIS_PACKET_TYPE_MAC_FRAME |
4096: NDIS_PACKET_TYPE_FUNCTIONAL |
4097: NDIS_PACKET_TYPE_ALL_FUNCTIONAL |
4098: NDIS_PACKET_TYPE_GROUP
4099: )) {
4100:
4101: StatusToReturn = NDIS_STATUS_NOT_SUPPORTED;
4102:
4103: NdisRequest->DATA.SET_INFORMATION.BytesRead = 4;
4104: NdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
4105:
4106: break;
4107:
4108: }
4109:
4110: StatusToReturn = LanceSetPacketFilter(Adapter,
4111: Open,
4112: NdisRequest,
4113: Filter);
4114:
4115: break;
4116:
4117: case OID_GEN_CURRENT_LOOKAHEAD:
4118:
4119: //
4120: // Verify length
4121: //
4122:
4123: if (OidLength != 4) {
4124:
4125: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
4126:
4127: NdisRequest->DATA.SET_INFORMATION.BytesRead = 0;
4128: NdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
4129:
4130: break;
4131:
4132: }
4133:
4134: LANCE_MOVE_MEMORY(&LookAhead, InfoBuffer, 4);
4135:
4136: if (LookAhead <= (LANCE_MAX_LOOKAHEAD)) {
4137:
4138: if (Open->LookAhead > Adapter->MaxLookAhead) {
4139:
4140: Open->LookAhead = LookAhead;
4141:
4142: Adapter->MaxLookAhead = LookAhead;
4143:
4144: } else {
4145:
4146: if ((Open->LookAhead == Adapter->MaxLookAhead) &&
4147: (LookAhead < Adapter->MaxLookAhead)) {
4148:
4149: Open->LookAhead = LookAhead;
4150:
4151: LanceAdjustMaxLookAhead(Adapter);
4152:
4153: } else {
4154:
4155: Open->LookAhead = LookAhead;
4156:
4157: }
4158:
4159: }
4160:
4161: } else {
4162:
4163: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
4164:
4165: }
4166:
4167: break;
4168:
4169: case OID_GEN_PROTOCOL_OPTIONS:
4170:
4171: StatusToReturn = NDIS_STATUS_SUCCESS;
4172: break;
4173:
4174: default:
4175:
4176: StatusToReturn = NDIS_STATUS_INVALID_OID;
4177:
4178: NdisRequest->DATA.SET_INFORMATION.BytesRead = 0;
4179: NdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
4180:
4181: break;
4182: }
4183:
4184: if (StatusToReturn == NDIS_STATUS_SUCCESS){
4185:
4186: NdisRequest->DATA.SET_INFORMATION.BytesRead = OidLength;
4187: NdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
4188:
4189: }
4190:
4191: #if LANCE_TRACE
4192: DbgPrint("Out LanceSetInfo\n");
4193: #endif
4194:
4195: return(StatusToReturn);
4196: }
4197:
4198: STATIC
4199: NDIS_STATUS
4200: LanceSetPacketFilter(
4201: IN PLANCE_ADAPTER Adapter,
4202: IN PLANCE_OPEN Open,
4203: IN PNDIS_REQUEST NdisRequest,
4204: IN UINT PacketFilter
4205: )
4206:
4207: /*++
4208:
4209: Routine Description:
4210:
4211: The LanceSetPacketFilter request allows a protocol to control the types
4212: of packets that it receives from the MAC.
4213:
4214: Note : Assumes that the lock is currently held.
4215:
4216: Arguments:
4217:
4218: Adapter - Pointer to the LANCE_ADAPTER.
4219:
4220: Open - Pointer to the instance of LANCE_OPEN for Ndis.
4221:
4222: NdisRequest - Pointer to the NDIS_REQUEST which submitted the set
4223: packet filter command.
4224:
4225: PacketFilter - A bit mask that contains flags that correspond to specific
4226: classes of received packets. If a particular bit is set in the mask,
4227: then packet reception for that class of packet is enabled. If the
4228: bit is clear, then packets that fall into that class are not received
4229: by the client. A single exception to this rule is that if the promiscuous
4230: bit is set, then the client receives all packets on the network, regardless
4231: of the state of the other flags.
4232:
4233: Return Value:
4234:
4235: The function value is the status of the operation.
4236:
4237: --*/
4238:
4239: {
4240:
4241: //
4242: // Keeps track of the *MAC's* status. The status will only be
4243: // reset if the filter change action routine is called.
4244: //
4245: NDIS_STATUS StatusOfFilterChange = NDIS_STATUS_SUCCESS;
4246:
4247:
4248: #if LANCE_TRACE
4249: DbgPrint("In LanceSetPacketFilter\n");
4250: #endif
4251:
4252: Adapter->References++;
4253:
4254: if (!Open->BindingShuttingDown) {
4255:
4256: //
4257: // Increment the open while it is going through the filtering
4258: // routines.
4259: //
4260:
4261: Open->References++;
4262:
4263: StatusOfFilterChange = EthFilterAdjust(
4264: Adapter->FilterDB,
4265: Open->NdisFilterHandle,
4266: NdisRequest,
4267: PacketFilter,
4268: TRUE
4269: );
4270:
4271: Open->References--;
4272:
4273: } else {
4274:
4275: StatusOfFilterChange = NDIS_STATUS_CLOSING;
4276:
4277: }
4278:
4279: Adapter->References--;
4280:
4281: #if LANCE_TRACE
4282: DbgPrint("Out LanceSetPacketFilter\n");
4283: #endif
4284:
4285: return StatusOfFilterChange;
4286: }
4287:
4288:
4289: NDIS_STATUS
4290: LanceFillInGlobalData(
4291: IN PLANCE_ADAPTER Adapter,
4292: IN PNDIS_REQUEST NdisRequest
4293: )
4294:
4295: /*++
4296:
4297: Routine Description:
4298:
4299: This routine completes a GlobalStatistics request. It is critical that
4300: if information is needed from the Adapter->* fields, they have been
4301: updated before this routine is called.
4302:
4303: Arguments:
4304:
4305: Adapter - A pointer to the Adapter.
4306:
4307: NdisRequest - A structure which contains the request type (Global
4308: Query), an array of operations to perform, and an array for holding
4309: the results of the operations.
4310:
4311: Return Value:
4312:
4313: The function value is the status of the operation.
4314:
4315: --*/
4316: {
4317: //
4318: // General Algorithm:
4319: //
4320: // Switch(Request)
4321: // Get requested information
4322: // Store results in a common variable.
4323: // default:
4324: // Try protocol query information
4325: // If that fails, fail query.
4326: //
4327: // Copy result in common variable to result buffer.
4328: // Finish processing
4329:
4330: UINT BytesWritten = 0;
4331: UINT BytesNeeded = 0;
4332: UINT BytesLeft = NdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength;
4333: PUCHAR InfoBuffer = (PUCHAR)(NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer);
4334:
4335: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
4336:
4337: //
4338: // This variable holds result of query
4339: //
4340:
4341: ULONG GenericULong;
4342: ULONG MoveBytes = sizeof(ULONG) * 2 + sizeof(NDIS_OID);
4343:
4344: //
4345: // Make sure that int is 4 bytes. Else GenericULong must change
4346: // to something of size 4.
4347: //
4348: ASSERT(sizeof(ULONG) == 4);
4349:
4350:
4351: StatusToReturn = LanceQueryProtocolInformation(
4352: Adapter,
4353: NULL,
4354: NdisRequest->DATA.QUERY_INFORMATION.Oid,
4355: TRUE,
4356: InfoBuffer,
4357: BytesLeft,
4358: &BytesNeeded,
4359: &BytesWritten
4360: );
4361:
4362:
4363: if (StatusToReturn == NDIS_STATUS_NOT_SUPPORTED){
4364:
4365: StatusToReturn = NDIS_STATUS_SUCCESS;
4366:
4367: NdisAcquireSpinLock(&Adapter->Lock);
4368:
4369: //
4370: // Switch on request type
4371: //
4372:
4373: switch (NdisRequest->DATA.QUERY_INFORMATION.Oid) {
4374:
4375: case OID_GEN_XMIT_OK:
4376:
4377: GenericULong = (ULONG)(Adapter->Transmit +
4378: Adapter->LateCollision);
4379:
4380: break;
4381:
4382: case OID_GEN_RCV_OK:
4383:
4384: GenericULong = (ULONG)(Adapter->Receive);
4385:
4386: break;
4387:
4388: case OID_GEN_XMIT_ERROR:
4389:
4390: GenericULong = (ULONG)(Adapter->LostCarrier);
4391:
4392: break;
4393:
4394: case OID_GEN_RCV_ERROR:
4395:
4396: GenericULong = (ULONG)(Adapter->CRCError);
4397:
4398: break;
4399:
4400: case OID_GEN_RCV_NO_BUFFER:
4401:
4402: GenericULong = (ULONG)(Adapter->OutOfReceiveBuffers);
4403:
4404: break;
4405:
4406: case OID_802_3_RCV_ERROR_ALIGNMENT:
4407:
4408: GenericULong = (ULONG)(Adapter->FramingError);
4409:
4410: break;
4411:
4412: case OID_802_3_XMIT_ONE_COLLISION:
4413:
4414: GenericULong = (ULONG)(Adapter->OneRetry);
4415:
4416: break;
4417:
4418: case OID_802_3_XMIT_MORE_COLLISIONS:
4419:
4420: GenericULong = (ULONG)(Adapter->MoreThanOneRetry);
4421:
4422: break;
4423:
4424:
4425: default:
4426:
4427: StatusToReturn = NDIS_STATUS_INVALID_OID;
4428:
4429: break;
4430:
4431: }
4432:
4433: NdisReleaseSpinLock(&Adapter->Lock);
4434:
4435: if (StatusToReturn == NDIS_STATUS_SUCCESS){
4436:
4437: //
4438: // Check to make sure there is enough room in the
4439: // buffer to store the result.
4440: //
4441:
4442: if (BytesLeft >= sizeof(ULONG)){
4443:
4444: //
4445: // Store the result.
4446: //
4447:
4448: LANCE_MOVE_MEMORY(
4449: (PVOID)InfoBuffer,
4450: (PVOID)(&GenericULong),
4451: sizeof(UINT)
4452: );
4453:
4454: BytesWritten += sizeof(ULONG);
4455:
4456: } else {
4457:
4458: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
4459:
4460: }
4461:
4462: }
4463:
4464: }
4465:
4466: NdisRequest->DATA.QUERY_INFORMATION.BytesWritten = BytesWritten;
4467:
4468: NdisRequest->DATA.QUERY_INFORMATION.BytesNeeded = BytesNeeded;
4469:
4470: return(StatusToReturn);
4471: }
4472:
4473: NDIS_STATUS
4474: LanceQueryGlobalStatistics(
4475: IN NDIS_HANDLE MacAdapterContext,
4476: IN PNDIS_REQUEST NdisRequest
4477: )
4478:
4479: /*++
4480:
4481: Routine Description:
4482:
4483: The LanceQueryGlobalStatistics is used by the protocol to query
4484: global information about the MAC.
4485:
4486: Arguments:
4487:
4488: MacAdapterContext - The value associated with the adapter that is being
4489: opened when the MAC registered the adapter with NdisRegisterAdapter.
4490:
4491: NdisRequest - A structure which contains the request type (Query),
4492: an array of operations to perform, and an array for holding
4493: the results of the operations.
4494:
4495: Return Value:
4496:
4497: The function value is the status of the operation.
4498:
4499: --*/
4500:
4501: {
4502:
4503: //
4504: // General Algorithm:
4505: //
4506: //
4507: // Check if a request is going to pend...
4508: // If so, pend the entire operation.
4509: //
4510: // Else
4511: // Fill in the request block.
4512: //
4513: //
4514:
4515: PLANCE_ADAPTER Adapter = (PLANCE_ADAPTER)(MacAdapterContext);
4516:
4517: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
4518:
4519: //
4520: // Check if a request is valid and going to pend...
4521: // If so, pend the entire operation.
4522: //
4523:
4524:
4525: //
4526: // Switch on request type
4527: //
4528:
4529: switch (NdisRequest->DATA.QUERY_INFORMATION.Oid) {
4530: case OID_GEN_SUPPORTED_LIST:
4531: case OID_GEN_HARDWARE_STATUS:
4532: case OID_GEN_MEDIA_SUPPORTED:
4533: case OID_GEN_MEDIA_IN_USE:
4534: case OID_GEN_MAXIMUM_LOOKAHEAD:
4535: case OID_GEN_MAXIMUM_FRAME_SIZE:
4536: case OID_GEN_MAXIMUM_TOTAL_SIZE:
4537: case OID_GEN_MAC_OPTIONS:
4538: case OID_GEN_LINK_SPEED:
4539: case OID_GEN_TRANSMIT_BUFFER_SPACE:
4540: case OID_GEN_RECEIVE_BUFFER_SPACE:
4541: case OID_GEN_TRANSMIT_BLOCK_SIZE:
4542: case OID_GEN_RECEIVE_BLOCK_SIZE:
4543: case OID_GEN_VENDOR_ID:
4544: case OID_GEN_VENDOR_DESCRIPTION:
4545: case OID_GEN_DRIVER_VERSION:
4546: case OID_GEN_CURRENT_PACKET_FILTER:
4547: case OID_GEN_CURRENT_LOOKAHEAD:
4548: case OID_802_3_PERMANENT_ADDRESS:
4549: case OID_802_3_CURRENT_ADDRESS:
4550: case OID_802_5_CURRENT_FUNCTIONAL:
4551: case OID_GEN_XMIT_OK:
4552: case OID_GEN_RCV_OK:
4553: case OID_GEN_XMIT_ERROR:
4554: case OID_GEN_RCV_ERROR:
4555: case OID_GEN_RCV_NO_BUFFER:
4556: case OID_802_3_MULTICAST_LIST:
4557: case OID_802_3_MAXIMUM_LIST_SIZE:
4558: case OID_802_3_RCV_ERROR_ALIGNMENT:
4559: case OID_802_3_XMIT_ONE_COLLISION:
4560: case OID_802_3_XMIT_MORE_COLLISIONS:
4561:
4562: break;
4563:
4564: default:
4565:
4566: StatusToReturn = NDIS_STATUS_INVALID_OID;
4567:
4568: break;
4569:
4570: }
4571:
4572: if (StatusToReturn == NDIS_STATUS_SUCCESS){
4573:
4574: StatusToReturn = LanceFillInGlobalData(Adapter, NdisRequest);
4575:
4576: }
4577:
4578: return(StatusToReturn);
4579: }
4580:
4581:
4582:
4583: STATIC
4584: NDIS_STATUS
4585: LanceReset(
4586: IN NDIS_HANDLE MacBindingHandle
4587: )
4588:
4589: /*++
4590:
4591: Routine Description:
4592:
4593: The LanceReset request instructs the MAC to issue a hardware reset
4594: to the network adapter. The MAC also resets its software state. See
4595: the description of NdisReset for a detailed description of this request.
4596:
4597: Arguments:
4598:
4599: MacBindingHandle - The context value returned by the MAC when the
4600: adapter was opened. In reality, it is a pointer to LANCE_OPEN.
4601:
4602: Return Value:
4603:
4604: The function value is the status of the operation.
4605:
4606:
4607: --*/
4608:
4609: {
4610:
4611: //
4612: // Holds the status that should be returned to the caller.
4613: //
4614: NDIS_STATUS StatusToReturn = NDIS_STATUS_PENDING;
4615:
4616: PLANCE_ADAPTER Adapter =
4617: PLANCE_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
4618:
4619: //
4620: // Hold the locks while we update the reference counts on the
4621: // adapter and the open.
4622: //
4623:
4624: NdisAcquireSpinLock(&Adapter->Lock);
4625:
4626: Adapter->References++;
4627:
4628: if (!Adapter->ResetInProgress) {
4629:
4630: PLANCE_OPEN Open;
4631:
4632: Open = PLANCE_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
4633:
4634: if (!Open->BindingShuttingDown) {
4635:
4636: //
4637: // Is was a reset request
4638: //
4639:
4640: PLIST_ENTRY CurrentLink;
4641:
4642: Open->References++;
4643:
4644: CurrentLink = Adapter->OpenBindings.Flink;
4645:
4646: while (CurrentLink != &Adapter->OpenBindings) {
4647:
4648: Open = CONTAINING_RECORD(
4649: CurrentLink,
4650: LANCE_OPEN,
4651: OpenList
4652: );
4653:
4654: Open->References++;
4655:
4656: NdisReleaseSpinLock(&Adapter->Lock);
4657:
4658: NdisIndicateStatus(
4659: Open->NdisBindingContext,
4660: NDIS_STATUS_RESET_START,
4661: NULL,
4662: 0
4663: );
4664:
4665: NdisAcquireSpinLock(&Adapter->Lock);
4666:
4667: Open->References--;
4668:
4669: CurrentLink = CurrentLink->Flink;
4670:
4671: }
4672:
4673: Open = PLANCE_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
4674:
4675: #if LANCE_TRACE
4676: DbgPrint("Starting reset for 0x%x\n", Open);
4677: #endif
4678:
4679: SetupForReset(
4680: Adapter,
4681: Open,
4682: NULL,
4683: NdisRequestGeneric1 // Means Reset
4684: );
4685:
4686: Open->References--;
4687:
4688: } else {
4689:
4690: StatusToReturn = NDIS_STATUS_CLOSING;
4691:
4692: }
4693:
4694: } else {
4695:
4696: StatusToReturn = NDIS_STATUS_SUCCESS;
4697:
4698: }
4699:
4700: LANCE_DO_DEFERRED(Adapter);
4701:
4702: return StatusToReturn;
4703:
4704: }
4705:
4706: STATIC
4707: VOID
4708: LanceSetInitializationBlock(
4709: IN PLANCE_ADAPTER Adapter
4710: )
4711:
4712: /*++
4713:
4714: Routine Description:
4715:
4716: This routine simply fills the initialization block
4717: with the information necessary for initialization.
4718:
4719: NOTE: This routine assumes that it is called with the lock
4720: acquired OR that only a single thread of execution is accessing
4721: the particular adapter.
4722:
4723: Arguments:
4724:
4725: Adapter - The adapter which holds the initialization block
4726: to initialize.
4727:
4728: Return Value:
4729:
4730: None.
4731:
4732:
4733: --*/
4734:
4735: {
4736:
4737: PHYSICAL_ADDRESS PhysAdr;
4738:
4739: UINT PacketFilters;
4740:
4741: PLANCE_RECEIVE_ENTRY CurrentEntry = Adapter->ReceiveRing;
4742: USHORT Mode;
4743: UCHAR RingNumber;
4744: UCHAR i;
4745:
4746: #if LANCE_TRACE
4747: DbgPrint("in SetInitBlock\n");
4748: #endif
4749:
4750: LANCE_ZERO_MEMORY_FOR_HARDWARE(
4751: Adapter->InitBlock,
4752: sizeof(LANCE_INITIALIZATION_BLOCK)
4753: );
4754:
4755: for (i=0; i < ETH_LENGTH_OF_ADDRESS; i++) {
4756:
4757: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4758: Adapter->InitBlock->PhysicalAddress[i],
4759: Adapter->CurrentNetworkAddress[i]
4760: );
4761:
4762: }
4763:
4764: PhysAdr = LANCE_GET_HARDWARE_PHYSICAL_ADDRESS(Adapter, Adapter->TransmitRing);
4765:
4766:
4767: LANCE_WRITE_HARDWARE_LOW_PART_ADDRESS(
4768: Adapter->InitBlock->LowTransmitRingAddress,
4769: LANCE_GET_LOW_PART_ADDRESS(PhysAdr.LowPart)
4770: );
4771: LANCE_WRITE_HARDWARE_HIGH_PART_ADDRESS(
4772: Adapter->InitBlock->HighTransmitRingAddress,
4773: LANCE_GET_HIGH_PART_ADDRESS(PhysAdr.LowPart)
4774: );
4775:
4776: PhysAdr = LANCE_GET_HARDWARE_PHYSICAL_ADDRESS(Adapter, Adapter->ReceiveRing);
4777:
4778: //
4779: // Set that the chip owns each entry in the ring
4780: //
4781:
4782: for (CurrentEntry = Adapter->ReceiveRing, RingNumber = 0;
4783: RingNumber < Adapter->NumberOfReceiveRings ;
4784: RingNumber++, CurrentEntry++) {
4785:
4786: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4787: CurrentEntry->ReceiveSummaryBits,
4788: LANCE_RECEIVE_OWNED_BY_CHIP
4789: );
4790:
4791: }
4792:
4793:
4794: LANCE_WRITE_HARDWARE_LOW_PART_ADDRESS(
4795: Adapter->InitBlock->LowReceiveRingAddress,
4796: LANCE_GET_LOW_PART_ADDRESS(PhysAdr.LowPart)
4797: );
4798: LANCE_WRITE_HARDWARE_HIGH_PART_ADDRESS(
4799: Adapter->InitBlock->HighReceiveRingAddress,
4800: LANCE_GET_HIGH_PART_ADDRESS(PhysAdr.LowPart)
4801: );
4802:
4803: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4804: Adapter->InitBlock->TransmitLengthLow5BitsReserved,
4805: (UCHAR)(Adapter->LogNumberTransmitRings << 5)
4806: );
4807:
4808: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4809: Adapter->InitBlock->ReceiveLengthLow5BitsReserved,
4810: (UCHAR)(Adapter->LogNumberReceiveRings << 5)
4811: );
4812:
4813: //
4814: // Set up the address filtering.
4815: //
4816: // First get hold of the combined packet filter.
4817: //
4818:
4819: PacketFilters = ETH_QUERY_FILTER_CLASSES(Adapter->FilterDB);
4820:
4821: #if LANCE_TRACE
4822: DbgPrint("Filters 0x%x\n", PacketFilters);
4823: #endif
4824:
4825: if (PacketFilters & NDIS_PACKET_TYPE_PROMISCUOUS) {
4826:
4827: //
4828: // If one binding is promiscuous there is no point in
4829: // setting up any other filtering. Every packet is
4830: // going to be accepted by the hardware.
4831: //
4832:
4833: LANCE_READ_HARDWARE_MEMORY_USHORT(
4834: Adapter->InitBlock->ModeRegister,
4835: &Mode
4836: );
4837:
4838: LANCE_WRITE_HARDWARE_MEMORY_USHORT(
4839: Adapter->InitBlock->ModeRegister,
4840: Mode | LANCE_MODE_PROMISCUOUS
4841: );
4842:
4843: } else if (PacketFilters & NDIS_PACKET_TYPE_ALL_MULTICAST) {
4844:
4845: //
4846: // We turn on all the bits in the filter since one binding
4847: // wants every multicast address.
4848: //
4849:
4850: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4851: Adapter->InitBlock->LogicalAddressFilter[0],
4852: 0xff
4853: );
4854: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4855: Adapter->InitBlock->LogicalAddressFilter[1],
4856: 0xff
4857: );
4858: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4859: Adapter->InitBlock->LogicalAddressFilter[2],
4860: 0xff
4861: );
4862: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4863: Adapter->InitBlock->LogicalAddressFilter[3],
4864: 0xff
4865: );
4866: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4867: Adapter->InitBlock->LogicalAddressFilter[4],
4868: 0xff
4869: );
4870: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4871: Adapter->InitBlock->LogicalAddressFilter[5],
4872: 0xff
4873: );
4874: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4875: Adapter->InitBlock->LogicalAddressFilter[6],
4876: 0xff
4877: );
4878: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4879: Adapter->InitBlock->LogicalAddressFilter[7],
4880: 0xff
4881: );
4882:
4883: } else if (PacketFilters & NDIS_PACKET_TYPE_MULTICAST) {
4884:
4885: //
4886: // At least one open binding wants multicast addresses.
4887: //
4888: // We get the multicast addresses from the filter and
4889: // put each one through a CRC. We then take the high
4890: // order 6 bits from the 32 bit CRC and set that bit
4891: // in the logical address filter.
4892: //
4893:
4894: UINT NumberOfAddresses;
4895:
4896: NDIS_STATUS Status;
4897:
4898: EthQueryGlobalFilterAddresses(
4899: &Status,
4900: Adapter->FilterDB,
4901: MAX_MULTICAST_ADDRESS * ETH_LENGTH_OF_ADDRESS,
4902: &NumberOfAddresses,
4903: MulticastAddresses
4904: );
4905:
4906:
4907: ASSERT(Status == NDIS_STATUS_SUCCESS);
4908:
4909: ASSERT(sizeof(ULONG) == 4);
4910:
4911: for (
4912: ;
4913: NumberOfAddresses;
4914: NumberOfAddresses--
4915: ) {
4916:
4917: UINT CRCValue;
4918:
4919: UINT HashValue = 0;
4920:
4921: CRCValue = CalculateCRC(
4922: 6,
4923: MulticastAddresses[NumberOfAddresses-1]
4924: );
4925:
4926: HashValue |= ((CRCValue & 0x00000001)?(0x00000020):(0x00000000));
4927: HashValue |= ((CRCValue & 0x00000002)?(0x00000010):(0x00000000));
4928: HashValue |= ((CRCValue & 0x00000004)?(0x00000008):(0x00000000));
4929: HashValue |= ((CRCValue & 0x00000008)?(0x00000004):(0x00000000));
4930: HashValue |= ((CRCValue & 0x00000010)?(0x00000002):(0x00000000));
4931: HashValue |= ((CRCValue & 0x00000020)?(0x00000001):(0x00000000));
4932:
4933: LANCE_READ_HARDWARE_MEMORY_UCHAR(
4934: Adapter->InitBlock->LogicalAddressFilter[HashValue >> 3],
4935: &RingNumber
4936: );
4937:
4938: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
4939: Adapter->InitBlock->LogicalAddressFilter[HashValue >> 3],
4940: RingNumber | (1 << (HashValue & 0x00000007))
4941: );
4942:
4943: }
4944:
4945: }
4946:
4947: #if LANCE_TRACE
4948: DbgPrint("out SetInitBlock\n");
4949: #endif
4950: }
4951:
4952: STATIC
4953: UINT
4954: CalculateCRC(
4955: IN UINT NumberOfBytes,
4956: IN PCHAR Input
4957: )
4958:
4959: /*++
4960:
4961: Routine Description:
4962:
4963: Calculates a 32 bit crc value over the input number of bytes.
4964:
4965: Arguments:
4966:
4967: NumberOfBytes - The number of bytes in the input.
4968:
4969: Input - An input "string" to calculate a CRC over.
4970:
4971: Return Value:
4972:
4973: A 32 bit crc value.
4974:
4975:
4976: --*/
4977:
4978: {
4979:
4980: const UINT POLY = 0x04c11db6;
4981: UINT CRCValue = 0xffffffff;
4982:
4983: ASSERT(sizeof(UINT) == 4);
4984:
4985: for (
4986: ;
4987: NumberOfBytes;
4988: NumberOfBytes--
4989: ) {
4990:
4991: UINT CurrentBit;
4992: UCHAR CurrentByte = *Input;
4993: Input++;
4994:
4995: for (
4996: CurrentBit = 8;
4997: CurrentBit;
4998: CurrentBit--
4999: ) {
5000:
5001: UINT CurrentCRCHigh = CRCValue >> 31;
5002:
5003: CRCValue <<= 1;
5004:
5005: if (CurrentCRCHigh ^ (CurrentByte & 0x01)) {
5006:
5007: CRCValue ^= POLY;
5008: CRCValue |= 0x00000001;
5009:
5010: }
5011:
5012: CurrentByte >>= 1;
5013:
5014: }
5015:
5016: }
5017:
5018: return CRCValue;
5019:
5020: }
5021:
5022: STATIC
5023: NDIS_STATUS
5024: LanceChangeMulticastAddresses(
5025: IN UINT OldFilterCount,
5026: IN CHAR OldAddresses[][ETH_LENGTH_OF_ADDRESS],
5027: IN UINT NewFilterCount,
5028: IN CHAR NewAddresses[][ETH_LENGTH_OF_ADDRESS],
5029: IN NDIS_HANDLE MacBindingHandle,
5030: IN PNDIS_REQUEST NdisRequest,
5031: IN BOOLEAN Set
5032: )
5033:
5034: /*++
5035:
5036: Routine Description:
5037:
5038: Action routine that will get called when a particular filter
5039: class is first used or last cleared.
5040:
5041: NOTE: This routine assumes that it is called with the lock
5042: acquired.
5043:
5044: Arguments:
5045:
5046:
5047: OldFilterCount - Number of Addresses in the old list of multicast
5048: addresses.
5049:
5050: OldAddresses - An array of all the multicast addresses that used
5051: to be on the adapter.
5052:
5053: NewFilterCount - Number of Addresses that should be put on the adapter.
5054:
5055: NewAddresses - An array of all the multicast addresses that should
5056: now be used.
5057:
5058: MacBindingHandle - The context value returned by the MAC when the
5059: adapter was opened. In reality, it is a pointer to LANCE_OPEN.
5060:
5061: NdisRequest - The request which submitted the filter change.
5062: Must use when completing this request with the NdisCompleteRequest
5063: service, if the MAC completes this request asynchronously.
5064:
5065: Set - If true the change resulted from a set, otherwise the
5066: change resulted from a open closing.
5067:
5068: Return Value:
5069:
5070: None.
5071:
5072:
5073: --*/
5074:
5075: {
5076:
5077:
5078: PLANCE_ADAPTER Adapter = PLANCE_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
5079:
5080: UNREFERENCED_PARAMETER(OldFilterCount);
5081: UNREFERENCED_PARAMETER(OldAddresses);
5082: UNREFERENCED_PARAMETER(NewFilterCount);
5083: UNREFERENCED_PARAMETER(NewAddresses);
5084:
5085: #if LANCE_TRACE
5086: DbgPrint("In LanceChangeMultiAdresses\n");
5087: #endif
5088:
5089: if (Adapter->HardwareFailure) {
5090:
5091: return(NDIS_STATUS_SUCCESS);
5092:
5093: }
5094:
5095: if (NdisRequest == NULL) {
5096:
5097: //
5098: // It's a close request.
5099: //
5100:
5101: NdisRequest = (PNDIS_REQUEST)
5102: &(PLANCE_OPEN_FROM_BINDING_HANDLE(MacBindingHandle)->CloseMulticastRequest);
5103:
5104: }
5105:
5106: //
5107: // Check to see if the device is already resetting. If it is
5108: // then pend this add.
5109: //
5110:
5111: if (Adapter->ResetInProgress) {
5112:
5113: if (Adapter->PendQueue == NULL) {
5114:
5115: Adapter->PendQueue = Adapter->PendQueueTail = NdisRequest;
5116:
5117: } else {
5118:
5119: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(Adapter->PendQueueTail)->Next =
5120: NdisRequest;
5121:
5122: }
5123:
5124: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->Next = NULL;
5125:
5126: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->Open =
5127: PLANCE_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
5128:
5129: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->RequestType =
5130: Set ? NdisRequestGeneric2 : NdisRequestClose;
5131:
5132: return(NDIS_STATUS_PENDING);
5133:
5134: } else {
5135:
5136: //
5137: // We need to add this to the hardware multicast filtering.
5138: //
5139:
5140: SetupForReset(
5141: Adapter,
5142: PLANCE_OPEN_FROM_BINDING_HANDLE(MacBindingHandle),
5143: NdisRequest,
5144: Set ? NdisRequestGeneric2 : // Means SetMulticastAddress
5145: NdisRequestClose
5146: );
5147:
5148: }
5149:
5150: #if LANCE_TRACE
5151: DbgPrint("Out LanceChangeMultiAdresses\n");
5152: #endif
5153:
5154: return NDIS_STATUS_PENDING;
5155:
5156: }
5157:
5158: STATIC
5159: NDIS_STATUS
5160: LanceChangeFilterClasses(
5161: IN UINT OldFilterClasses,
5162: IN UINT NewFilterClasses,
5163: IN NDIS_HANDLE MacBindingHandle,
5164: IN PNDIS_REQUEST NdisRequest,
5165: IN BOOLEAN Set
5166: )
5167:
5168: /*++
5169:
5170: Routine Description:
5171:
5172: Action routine that will get called when an address is added to
5173: the filter that wasn't referenced by any other open binding.
5174:
5175: NOTE: This routine assumes that it is called with the lock
5176: acquired.
5177:
5178: Arguments:
5179:
5180: OldFilterClasses - The filter mask that used to be on the adapter.
5181:
5182: NewFilterClasses - The new filter mask to be put on the adapter.
5183:
5184: MacBindingHandle - The context value returned by the MAC when the
5185: adapter was opened. In reality, it is a pointer to LANCE_OPEN.
5186:
5187: NdisRequest - The request which submitted the filter change.
5188: Must use when completing this request with the NdisCompleteRequest
5189: service, if the MAC completes this request asynchronously.
5190:
5191: Set - If true the change resulted from a set, otherwise the
5192: change resulted from a open closing.
5193:
5194: --*/
5195:
5196: {
5197:
5198: PLANCE_ADAPTER Adapter = PLANCE_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
5199:
5200: UNREFERENCED_PARAMETER(OldFilterClasses);
5201: UNREFERENCED_PARAMETER(NewFilterClasses);
5202:
5203: #if LANCE_TRACE
5204: DbgPrint("In LanceChangeFilterClasses\n");
5205: #endif
5206:
5207:
5208: if (Adapter->HardwareFailure) {
5209:
5210: return(NDIS_STATUS_SUCCESS);
5211:
5212: }
5213:
5214:
5215: if (NdisRequest == NULL) {
5216:
5217: //
5218: // It's a close request.
5219: //
5220:
5221: NdisRequest = (PNDIS_REQUEST)
5222: &(PLANCE_OPEN_FROM_BINDING_HANDLE(MacBindingHandle)->CloseFilterRequest);
5223:
5224: }
5225:
5226: //
5227: // Check to see if the device is already resetting. If it is
5228: // then pend this add.
5229: //
5230:
5231:
5232: if (Adapter->ResetInProgress) {
5233:
5234: if (Adapter->PendQueue == NULL) {
5235:
5236: Adapter->PendQueue = Adapter->PendQueueTail = NdisRequest;
5237:
5238: } else {
5239:
5240: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(Adapter->PendQueueTail)->Next =
5241: NdisRequest;
5242:
5243: }
5244:
5245: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->Next = NULL;
5246:
5247: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->Open =
5248: PLANCE_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
5249:
5250: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->RequestType =
5251: Set ? NdisRequestGeneric2 : NdisRequestClose;
5252:
5253: return(NDIS_STATUS_PENDING);
5254:
5255: } else {
5256:
5257: //
5258: // We need to add this to the hardware multicast filtering.
5259: //
5260:
5261: SetupForReset(
5262: Adapter,
5263: PLANCE_OPEN_FROM_BINDING_HANDLE(MacBindingHandle),
5264: NdisRequest,
5265: Set ? NdisRequestGeneric3 : // Means SetPacketFilter
5266: NdisRequestClose
5267: );
5268:
5269: }
5270:
5271: #if LANCE_TRACE
5272: DbgPrint("Out LanceChangeFilterClasses\n");
5273: #endif
5274:
5275: return NDIS_STATUS_PENDING;
5276:
5277: }
5278:
5279: STATIC
5280: VOID
5281: LanceCloseAction(
5282: IN NDIS_HANDLE MacBindingHandle
5283: )
5284:
5285: /*++
5286:
5287: Routine Description:
5288:
5289: Action routine that will get called when a particular binding
5290: was closed while it was indicating through NdisIndicateReceive
5291:
5292: All this routine needs to do is to decrement the reference count
5293: of the binding.
5294:
5295: NOTE: This routine assumes that it is called with the lock acquired.
5296:
5297: Arguments:
5298:
5299: MacBindingHandle - The context value returned by the MAC when the
5300: adapter was opened. In reality, it is a pointer to LANCE_OPEN.
5301:
5302: Return Value:
5303:
5304: None.
5305:
5306:
5307: --*/
5308:
5309: {
5310:
5311: PLANCE_OPEN_FROM_BINDING_HANDLE(MacBindingHandle)->References--;
5312:
5313: }
5314:
5315: STATIC
5316: VOID
5317: ProcessInterrupt(
5318: IN PLANCE_ADAPTER Adapter
5319: )
5320:
5321: /*++
5322:
5323: Routine Description:
5324:
5325: Main routine for processing interrupts.
5326:
5327: NOTE: MUST BE CALLED WITH LOCK HELD!
5328:
5329: Arguments:
5330:
5331: Adapter - The Adapter to process interrupts for.
5332:
5333: Return Value:
5334:
5335: None.
5336:
5337: --*/
5338:
5339: {
5340:
5341: //
5342: // Holds a value of csr0.
5343: //
5344: USHORT Csr = 0;
5345:
5346: //
5347: // Loop until there are no more processing sources.
5348: //
5349:
5350: while (TRUE) {
5351:
5352: Adapter->WakeUpTimeout = FALSE;
5353:
5354: GET_CSR0_SINCE_LAST_PROCESSED(
5355: Adapter,
5356: &Csr
5357: );
5358:
5359: //
5360: // Check the interrupt source and other reasons
5361: // for processing. If there are no reasons to
5362: // process then exit this loop.
5363: //
5364: // Note that when we check the for processing sources
5365: // that we "carefully" check to see if we are already
5366: // processing one of the stage queues. We do this
5367: // by checking the "AlreadyProcessingStageX" variables
5368: // in the adapter. If any of these are true then
5369: // we let whoever set that boolean take care of pushing
5370: // the packet through the stage queues.
5371: //
5372: // By checking the "AlreadyProcessingStageX" variables
5373: // we can prevent a possible priority inversion where
5374: // we get "stuck" behind something that is processing
5375: // at a lower priority level.
5376: //
5377:
5378: if (((!Adapter->ResetInitStarted) &&
5379: ((Csr & (LANCE_CSR0_MEMORY_ERROR |
5380: LANCE_CSR0_MISSED_PACKET |
5381: LANCE_CSR0_BABBLE |
5382: LANCE_CSR0_RECEIVER_INTERRUPT |
5383: LANCE_CSR0_TRANSMITTER_INTERRUPT)) ||
5384: (Adapter->FirstLoopBack) ||
5385: (Adapter->ResetInProgress && (!Adapter->References)) ||
5386: ((!Adapter->AlreadyProcessingStage) &&
5387: (Adapter->StageOpen && Adapter->FirstStage1Packet)))) ||
5388: (Csr & LANCE_CSR0_INITIALIZATION_DONE)) {
5389:
5390: Adapter->References++;
5391:
5392: } else {
5393:
5394: break;
5395:
5396: }
5397:
5398: //
5399: // Check for initialization.
5400: //
5401: // Note that we come out of the synchronization above holding
5402: // the spinlock.
5403: //
5404:
5405: if (Csr & LANCE_CSR0_INITIALIZATION_DONE) {
5406:
5407: //
5408: // This will point (possibly null) to the open that
5409: // initiated the reset.
5410: //
5411: PLANCE_OPEN ResettingOpen;
5412:
5413: //
5414: // Possibly undefined reason why the reset was requested.
5415: //
5416: // It is undefined if the adapter initiated the reset
5417: // request on its own. It could do that if there
5418: // were some sort of error not associated with any particular
5419: // open.
5420: //
5421: NDIS_REQUEST_TYPE ResetRequestType;
5422:
5423: //
5424: // Possibly undefined request for the reset request.
5425: //
5426: PNDIS_REQUEST ResetNdisRequest;
5427:
5428: LOG(RESET_STEP_3);
5429:
5430: ASSERT(!Adapter->FirstInitialization);
5431:
5432: Csr &= ~LANCE_CSR0_INITIALIZATION_DONE;
5433:
5434: Adapter->ResetInProgress = FALSE;
5435: Adapter->ResetInitStarted = FALSE;
5436:
5437: //
5438: // We save off the open that caused this reset incase
5439: // we get *another* reset while we're indicating the
5440: // last reset is done.
5441: //
5442:
5443: ResettingOpen = Adapter->ResettingOpen;
5444: ResetRequestType = Adapter->ResetRequestType;
5445: ResetNdisRequest = Adapter->ResetNdisRequest;
5446:
5447: //
5448: // We need to signal every open binding that the
5449: // reset is complete. We increment the reference
5450: // count on the open binding while we're doing indications
5451: // so that the open can't be deleted out from under
5452: // us while we're indicating (recall that we can't own
5453: // the lock during the indication).
5454: //
5455:
5456: {
5457:
5458: PLANCE_OPEN Open;
5459:
5460: //
5461: // Look to see which open initiated the reset.
5462: //
5463: // If the reset was initiated by an open because it
5464: // was closing we will let the closing binding loop
5465: // further on in this routine indicate that the
5466: // request was complete.
5467: //
5468: // If the reset was initiated for some obscure hardware
5469: // reason that can't be associated with a particular
5470: // open (e.g. memory error on receiving a packet) then
5471: // we won't have an initiating request so we can't
5472: // indicate. (The ResettingOpen pointer will be
5473: // NULL in this case.)
5474: //
5475:
5476: #if LANCE_TRACE
5477: DbgPrint("0x%x 0x%x 0x%x %d %d\n",
5478: Adapter,
5479: ResettingOpen,
5480: ResetNdisRequest,
5481: ResetRequestType,
5482: NdisRequestClose
5483: );
5484: #endif
5485:
5486: if ((ResettingOpen != NULL) &&
5487: (ResetRequestType != NdisRequestClose)) {
5488:
5489: if (ResetNdisRequest != NULL) {
5490:
5491: //
5492: // It was a request submitted by a protocol.
5493: //
5494:
5495: FinishPendOp(Adapter, TRUE);
5496:
5497: } else {
5498:
5499: //
5500: // It was a request submitted by the MAC or
5501: // a reset command.
5502: //
5503:
5504: if (ResetRequestType == NdisRequestGeneric1) {
5505:
5506: //
5507: // Is was a reset request
5508: //
5509:
5510: PLIST_ENTRY CurrentLink;
5511:
5512: CurrentLink = Adapter->OpenBindings.Flink;
5513:
5514: while (CurrentLink != &Adapter->OpenBindings) {
5515:
5516: Open = CONTAINING_RECORD(
5517: CurrentLink,
5518: LANCE_OPEN,
5519: OpenList
5520: );
5521:
5522: Open->References++;
5523: NdisDprReleaseSpinLock(&Adapter->Lock);
5524:
5525: NdisIndicateStatus(
5526: Open->NdisBindingContext,
5527: NDIS_STATUS_RESET_END,
5528: NULL,
5529: 0
5530: );
5531:
5532: NdisIndicateStatusComplete(
5533: Open->NdisBindingContext
5534: );
5535:
5536: NdisDprAcquireSpinLock(&Adapter->Lock);
5537:
5538: Open->References--;
5539:
5540: CurrentLink = CurrentLink->Flink;
5541:
5542: }
5543:
5544: #if DBG
5545: Adapter->ResettingOpen = NULL;
5546: Adapter->ResetNdisRequest = NULL;
5547: Adapter->ResetRequestType = (NDIS_REQUEST_TYPE)0;
5548: #endif
5549:
5550: #if LANCE_TRACE
5551: DbgPrint("Completing reset\n");
5552: #endif
5553:
5554: NdisDprReleaseSpinLock(&Adapter->Lock);
5555:
5556: NdisCompleteReset(
5557: ResettingOpen->NdisBindingContext,
5558: NDIS_STATUS_SUCCESS
5559: );
5560:
5561:
5562: NdisDprAcquireSpinLock(&Adapter->Lock);
5563:
5564: ResettingOpen->References--;
5565:
5566: }
5567:
5568:
5569: }
5570:
5571: //
5572: // Restart the chip.
5573: //
5574:
5575: LanceStartChip(Adapter);
5576:
5577: } else {
5578:
5579: //
5580: // It was a close that pended (if there is
5581: // a ResettingOpen). Subtract 2, one for the
5582: // reset and one for the pended operation.
5583: //
5584:
5585: if (ResettingOpen) {
5586:
5587: ResettingOpen->References--;
5588:
5589: #if DBG
5590: Adapter->ResettingOpen = NULL;
5591: Adapter->ResetNdisRequest = NULL;
5592: Adapter->ResetRequestType = (NDIS_REQUEST_TYPE)0;
5593: #endif
5594:
5595: }
5596:
5597: if (!Adapter->ResetInProgress) {
5598:
5599: LanceStartChip(Adapter);
5600:
5601: }
5602:
5603: }
5604:
5605: }
5606:
5607: //
5608: // Fire off any pending operations...
5609: //
5610:
5611: if (Adapter->PendQueue != NULL) {
5612:
5613: PNDIS_REQUEST NdisRequest;
5614:
5615: NdisRequest = Adapter->PendQueue;
5616:
5617: Adapter->PendQueue =
5618: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->Next;
5619:
5620: if (NdisRequest == Adapter->PendQueueTail) {
5621:
5622: Adapter->PendQueueTail = NULL;
5623:
5624: }
5625:
5626: if (PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->RequestType ==
5627: NdisRequestClose) {
5628:
5629: SetupForReset(
5630: Adapter,
5631: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->Open,
5632: NULL,
5633: NdisRequestClose
5634: );
5635:
5636: } else {
5637:
5638: SetupForReset(
5639: Adapter,
5640: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->Open,
5641: NdisRequest,
5642: PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest)->RequestType
5643: );
5644:
5645: }
5646:
5647: }
5648:
5649: goto LoopBottom;
5650:
5651: }
5652:
5653: //
5654: // Note that the following code depends on the fact that
5655: // code above left the spinlock held.
5656: //
5657:
5658: //
5659: // If we have a reset in progress and the adapters reference
5660: // count is 1 (meaning no routine is in the interface and
5661: // we are the only "active" interrupt processing routine) then
5662: // it is safe to start the reset.
5663: //
5664:
5665: if (Adapter->ResetInProgress &&
5666: !Adapter->ResetInitStarted &&
5667: (Adapter->References == 1)) {
5668:
5669: #if LANCE_TRACE
5670: DbgPrint("Starting Initialization.\n");
5671: #endif
5672:
5673: StartAdapterReset(Adapter);
5674:
5675: Adapter->ResetInitStarted = TRUE;
5676: goto LoopBottom;
5677:
5678: }
5679:
5680: //
5681: // Check for non-packet related errors.
5682: //
5683:
5684: if (Csr & (LANCE_CSR0_MEMORY_ERROR |
5685: LANCE_CSR0_MISSED_PACKET |
5686: LANCE_CSR0_BABBLE)) {
5687:
5688: if (Csr & LANCE_CSR0_MISSED_PACKET) {
5689:
5690: Adapter->MissedPacket++;
5691:
5692: } else if (Csr & LANCE_CSR0_BABBLE) {
5693:
5694: //
5695: // A babble error implies that we've sent a
5696: // packet that is greater than the ethernet length.
5697: // This implies that the driver is broken.
5698: //
5699:
5700: Adapter->Babble++;
5701:
5702: NdisWriteErrorLogEntry(
5703: Adapter->NdisAdapterHandle,
5704: NDIS_ERROR_CODE_DRIVER_FAILURE,
5705: 2,
5706: (ULONG)processInterrupt,
5707: (ULONG)0x1
5708: );
5709:
5710:
5711: } else {
5712:
5713: //
5714: // Could only be a memory error. This shuts down
5715: // the receiver and the transmitter. We have to
5716: // reset to get the device started again.
5717: //
5718:
5719: Adapter->MemoryError++;
5720:
5721: SetupForReset(
5722: Adapter,
5723: NULL,
5724: NULL,
5725: NdisRequestGeneric4 // Means MAC issued
5726: );
5727:
5728: }
5729:
5730: Csr &= ~LANCE_CSR0_ERROR_BITS;
5731:
5732: }
5733:
5734: //
5735: // Check the interrupt vector and see if there are any
5736: // more receives to process. After we process any
5737: // other interrupt source we always come back to the top
5738: // of the loop to check if any more receive packets have
5739: // come in. This is to lessen the probability that we
5740: // drop a receive.
5741: //
5742:
5743:
5744: if (Csr & LANCE_CSR0_RECEIVER_INTERRUPT) {
5745:
5746: if (ProcessReceiveInterrupts(Adapter)) {
5747:
5748: Csr &= ~LANCE_CSR0_RECEIVER_INTERRUPT;
5749:
5750: }
5751:
5752: }
5753:
5754: //
5755: // Process the transmit interrupts if there are any.
5756: //
5757:
5758: if (Csr & LANCE_CSR0_TRANSMITTER_INTERRUPT) {
5759:
5760: //
5761: // We need to check if the transmitter has
5762: // stopped as a result of an error. If it
5763: // has then we really need to reset the adapter.
5764: //
5765:
5766: if (!(Csr & LANCE_CSR0_TRANSMITTER_ON)) {
5767:
5768: //
5769: // Might as well turn off the transmitter interrupt
5770: // source since we won't ever be processing them
5771: // and we don't want to come back here again.
5772: //
5773:
5774: Csr &= ~LANCE_CSR0_TRANSMITTER_INTERRUPT;
5775:
5776: //
5777: // Before we setup for the reset make sure that
5778: // we aren't already resetting.
5779: //
5780:
5781: if (!Adapter->ResetInProgress) {
5782:
5783: SetupForReset(
5784: Adapter,
5785: NULL,
5786: 0,
5787: NdisRequestGeneric4 // means MAC issued
5788: );
5789:
5790: }
5791:
5792: goto LoopBottom;
5793:
5794: } else {
5795:
5796: if (!ProcessTransmitInterrupts(Adapter)) {
5797:
5798: //
5799: // Process interrupts returns false if it
5800: // finds no more work to do. If this so we
5801: // turn off the transmitter interrupt source.
5802: //
5803:
5804: Csr &= ~LANCE_CSR0_TRANSMITTER_INTERRUPT;
5805:
5806: }
5807:
5808: }
5809:
5810: }
5811:
5812:
5813: //
5814: // Only try to push a packet through the stage queues
5815: // if somebody else isn't already doing it and
5816: // there is some hope of moving some packets
5817: // ahead.
5818: //
5819:
5820: if ((!Adapter->AlreadyProcessingStage) &&
5821: (Adapter->StageOpen && Adapter->FirstStage1Packet)) {
5822:
5823: LanceStagedAllocation(Adapter);
5824:
5825: }
5826:
5827: //
5828: // Process the loopback queue.
5829: //
5830: //
5831:
5832: if (Adapter->FirstLoopBack != NULL) {
5833:
5834: LanceProcessLoopback(Adapter);
5835:
5836: }
5837:
5838: //
5839: // If there are any opens on the closing list and their
5840: // reference counts are zero then complete the close and
5841: // delete them from the list.
5842: //
5843: //
5844:
5845: LoopBottom:;
5846:
5847: //
5848: // NOTE: This code assumes that the above code left
5849: // the spinlock acquired.
5850: //
5851: // Bottom of the interrupt processing loop. Another dpc
5852: // could be coming in at this point to process interrupts.
5853: // We clear the flag that says we're processing interrupts
5854: // so that some invocation of the DPC can grab it and process
5855: // any further interrupts.
5856: //
5857:
5858: if (!IsListEmpty(&Adapter->CloseList)) {
5859:
5860: PLANCE_OPEN Open;
5861: PLIST_ENTRY Link = &(Adapter->CloseList);
5862:
5863:
5864: while (Link->Flink != &(Adapter->CloseList)) {
5865:
5866: Open = CONTAINING_RECORD(
5867: Link->Flink,
5868: LANCE_OPEN,
5869: OpenList
5870: );
5871:
5872:
5873: if (!Open->References) {
5874:
5875: NdisDprReleaseSpinLock(&Adapter->Lock);
5876:
5877: NdisCompleteCloseAdapter(
5878: Open->NdisBindingContext,
5879: NDIS_STATUS_SUCCESS
5880: );
5881:
5882: NdisDprAcquireSpinLock(&Adapter->Lock);
5883:
5884: RemoveEntryList(&Open->OpenList);
5885:
5886: if (Adapter->MaxLookAhead == Open->LookAhead) {
5887:
5888: LanceAdjustMaxLookAhead(Adapter);
5889:
5890: }
5891:
5892: LANCE_FREE_PHYS(Open, sizeof(LANCE_OPEN));
5893:
5894: }
5895:
5896: Link = Link->Flink;
5897:
5898: }
5899:
5900:
5901: }
5902:
5903: Adapter->References--;
5904:
5905: }
5906:
5907: Adapter->ProcessInterruptRunning = FALSE;
5908:
5909: //
5910: // Check if we indicated any packets.
5911: //
5912: // Note: The only way to get out of the loop (via the break above) is
5913: // while we're still holding the spin lock.
5914: //
5915:
5916: if (Adapter->IndicatedAPacket) {
5917:
5918: Adapter->IndicatedAPacket = FALSE;
5919:
5920: NdisDprReleaseSpinLock(&Adapter->Lock);
5921:
5922: EthFilterIndicateReceiveComplete(Adapter->FilterDB);
5923:
5924: NdisDprAcquireSpinLock(&Adapter->Lock);
5925:
5926: }
5927:
5928: }
5929:
5930: STATIC
5931: BOOLEAN
5932: ProcessReceiveInterrupts(
5933: IN PLANCE_ADAPTER Adapter
5934: )
5935:
5936: /*++
5937:
5938: Routine Description:
5939:
5940: Process the packets that have finished receiving.
5941:
5942: NOTE: This routine assumes that no other thread of execution
5943: is processing receives! THE LOCK MUST BE HELD
5944:
5945: Arguments:
5946:
5947: Adapter - The adapter to indicate to.
5948:
5949: Return Value:
5950:
5951: Whether to clear the interrupt or not.
5952:
5953: --*/
5954:
5955: {
5956:
5957:
5958: //
5959: // We don't get here unless there was a receive. Loop through
5960: // the receive descriptors starting at the last known descriptor
5961: // owned by the hardware that begins a packet.
5962: //
5963: // Examine each receive ring descriptor for errors.
5964: //
5965: // We keep an array whose elements are indexed by the ring
5966: // index of the receive descriptors. The arrays elements are
5967: // the virtual addresses of the buffers pointed to by
5968: // each ring descriptor.
5969: //
5970: // When we have the entire packet (and error processing doesn't
5971: // prevent us from indicating it), we give the routine that
5972: // processes the packet through the filter, the buffers virtual
5973: // address (which is always the lookahead size) and as the
5974: // MAC context the index to the first and last ring descriptors
5975: // comprising the packet.
5976: //
5977:
5978: //
5979: // Index of the ring descriptor in the ring.
5980: //
5981: UINT CurrentIndex = Adapter->CurrentReceiveIndex;
5982:
5983: //
5984: // Pointer to the ring descriptor being examined.
5985: //
5986: PLANCE_RECEIVE_ENTRY CurrentEntry = Adapter->ReceiveRing + CurrentIndex;
5987:
5988: //
5989: // Hold in a local the top receive ring index so that we don't
5990: // need to get it from the adapter all the time.
5991: //
5992: const UINT TopReceiveIndex = Adapter->NumberOfReceiveRings - 1;
5993:
5994: //
5995: // Boolean to record the fact that we've finished processing
5996: // one packet and we're about to start a new one.
5997: //
5998: BOOLEAN NewPacket = FALSE;
5999:
6000: //
6001: // Count of the number of buffers in the current packet.
6002: //
6003: UINT NumberOfBuffers = 1;
6004:
6005: //
6006: // Pointer to host addressable space for the lookahead buffer
6007: //
6008: PUCHAR LookaheadBuffer;
6009:
6010: ULONG ReceivePacketCount = 0;
6011:
6012: while (TRUE) {
6013:
6014: UCHAR ReceiveSummaryBits;
6015:
6016:
6017: //
6018: // Check to see whether we own the packet. If
6019: // we don't then simply return to the caller.
6020: //
6021:
6022: LANCE_READ_HARDWARE_MEMORY_UCHAR(
6023: CurrentEntry->ReceiveSummaryBits,
6024: &ReceiveSummaryBits
6025: );
6026:
6027: if (ReceiveSummaryBits & LANCE_RECEIVE_OWNED_BY_CHIP) {
6028:
6029: LOG(RECEIVE);
6030:
6031: return TRUE;
6032:
6033: } else if (ReceivePacketCount > 10) {
6034:
6035: LOG(RECEIVE)
6036:
6037: return FALSE;
6038:
6039: } else if (ReceiveSummaryBits & LANCE_RECEIVE_ERROR_SUMMARY) {
6040:
6041:
6042: //
6043: // We have an error in the packet. Record
6044: // the details of the error.
6045: //
6046:
6047: //
6048: // Synch with the set/query information routines.
6049: //
6050:
6051: if (ReceiveSummaryBits & LANCE_RECEIVE_BUFFER_ERROR) {
6052:
6053: //
6054: // Probably ran out of descriptors.
6055: //
6056:
6057: Adapter->OutOfReceiveBuffers++;
6058:
6059: } else if (ReceiveSummaryBits & LANCE_RECEIVE_CRC_ERROR) {
6060:
6061: Adapter->CRCError++;
6062:
6063: } else if (ReceiveSummaryBits & LANCE_RECEIVE_OVERFLOW_ERROR) {
6064:
6065: Adapter->OutOfReceiveBuffers++;
6066:
6067: } else if (ReceiveSummaryBits & LANCE_RECEIVE_FRAMING_ERROR) {
6068:
6069: Adapter->FramingError++;
6070:
6071: }
6072:
6073: ReceivePacketCount++;
6074:
6075: //
6076: // Give the packet back to the hardware.
6077: //
6078:
6079: RelinquishReceivePacket(
6080: Adapter,
6081: Adapter->CurrentReceiveIndex,
6082: NumberOfBuffers
6083: );
6084:
6085: NewPacket = TRUE;
6086:
6087: } else if (ReceiveSummaryBits & LANCE_RECEIVE_END_OF_PACKET) {
6088:
6089: //
6090: // We've reached the end of the packet. Prepare
6091: // the parameters for indication, then indicate.
6092: //
6093:
6094: UINT PacketSize;
6095: UINT LookAheadSize;
6096:
6097: LANCE_RECEIVE_CONTEXT Context;
6098:
6099: ASSERT(sizeof(LANCE_RECEIVE_CONTEXT) == sizeof(NDIS_HANDLE));
6100:
6101: //
6102: // Check just before we do indications that we aren't
6103: // resetting.
6104: //
6105:
6106: if (Adapter->ResetInProgress) {
6107:
6108: return TRUE;
6109: }
6110:
6111: Context.INFO.IsContext = TRUE;
6112: Context.INFO.FirstBuffer = Adapter->CurrentReceiveIndex;
6113: Context.INFO.LastBuffer = CurrentIndex;
6114:
6115: LANCE_GET_MESSAGE_SIZE(CurrentEntry, PacketSize);
6116:
6117: LookAheadSize = PacketSize;
6118:
6119: //
6120: // Find amount to indicate.
6121: //
6122:
6123: LookAheadSize = ((LookAheadSize < Adapter->SizeOfReceiveBuffer) ?
6124: LookAheadSize :
6125: Adapter->SizeOfReceiveBuffer);
6126:
6127: LookAheadSize -= LANCE_HEADER_SIZE;
6128:
6129: //
6130: // Increment the number of packets succesfully received.
6131: //
6132:
6133: Adapter->Receive++;
6134:
6135: LOG(INDICATE);
6136:
6137: Adapter->IndicatingMacReceiveContext = Context;
6138:
6139: Adapter->IndicatedAPacket = TRUE;
6140:
6141: NdisDprReleaseSpinLock(&Adapter->Lock);
6142:
6143: NdisCreateLookaheadBufferFromSharedMemory(
6144: (PVOID)(Adapter->ReceiveVAs[Adapter->CurrentReceiveIndex]),
6145: LookAheadSize + LANCE_HEADER_SIZE,
6146: &LookaheadBuffer
6147: );
6148:
6149: if (LookaheadBuffer != NULL) {
6150:
6151: if (PacketSize < LANCE_HEADER_SIZE) {
6152:
6153: if (PacketSize >= ETH_LENGTH_OF_ADDRESS) {
6154:
6155: //
6156: // Runt packet
6157: //
6158:
6159: EthFilterIndicateReceive(
6160: Adapter->FilterDB,
6161: (NDIS_HANDLE)Context.WholeThing,
6162: LookaheadBuffer,
6163: LookaheadBuffer,
6164: PacketSize,
6165: NULL,
6166: 0,
6167: 0
6168: );
6169:
6170: }
6171:
6172: } else {
6173:
6174: EthFilterIndicateReceive(
6175: Adapter->FilterDB,
6176: (NDIS_HANDLE)Context.WholeThing,
6177: LookaheadBuffer,
6178: LookaheadBuffer,
6179: LANCE_HEADER_SIZE,
6180: LookaheadBuffer + LANCE_HEADER_SIZE,
6181: LookAheadSize,
6182: PacketSize - LANCE_HEADER_SIZE
6183: );
6184:
6185: }
6186:
6187: NdisDestroyLookaheadBufferFromSharedMemory(
6188: LookaheadBuffer
6189: );
6190:
6191: }
6192:
6193: NdisDprAcquireSpinLock(&Adapter->Lock);
6194:
6195: ReceivePacketCount++;
6196:
6197: //
6198: // Give the packet back to the hardware.
6199: //
6200:
6201: RelinquishReceivePacket(
6202: Adapter,
6203: Adapter->CurrentReceiveIndex,
6204: NumberOfBuffers
6205: );
6206:
6207: NewPacket = TRUE;
6208:
6209: }
6210:
6211: //
6212: // We're at some indermediate packet. Advance to
6213: // the next one.
6214: //
6215:
6216: if (CurrentIndex == TopReceiveIndex) {
6217:
6218: CurrentIndex = 0;
6219: CurrentEntry = Adapter->ReceiveRing;
6220:
6221: } else {
6222:
6223: CurrentIndex++;
6224: CurrentEntry++;
6225:
6226: }
6227:
6228: if (NewPacket) {
6229:
6230: Adapter->CurrentReceiveIndex = CurrentIndex;
6231: NewPacket = FALSE;
6232: NumberOfBuffers = 0;
6233:
6234: }
6235:
6236: NumberOfBuffers++;
6237:
6238: if (NumberOfBuffers > (TopReceiveIndex + 1)) {
6239:
6240: //
6241: // Error! For some reason we wrapped without ever seeing
6242: // the end of packet. The card is hosed. Stop the
6243: // whole process.
6244: //
6245:
6246: //
6247: // There are opens to notify
6248: //
6249:
6250: PLIST_ENTRY CurrentLink;
6251: PLANCE_OPEN Open;
6252: BOOLEAN Cancel;
6253:
6254: Adapter->HardwareFailure = TRUE;
6255:
6256: CurrentLink = Adapter->OpenBindings.Flink;
6257:
6258: while (CurrentLink != &Adapter->OpenBindings) {
6259:
6260: Open = CONTAINING_RECORD(
6261: CurrentLink,
6262: LANCE_OPEN,
6263: OpenList
6264: );
6265:
6266: Open->References++;
6267:
6268: NdisDprReleaseSpinLock(&Adapter->Lock);
6269:
6270: NdisIndicateStatus(
6271: Open->NdisBindingContext,
6272: NDIS_STATUS_CLOSING,
6273: NULL,
6274: 0
6275: );
6276:
6277: NdisIndicateStatusComplete(
6278: Open->NdisBindingContext
6279: );
6280:
6281: NdisDprAcquireSpinLock(&Adapter->Lock);
6282:
6283: Open->References--;
6284:
6285: CurrentLink = CurrentLink->Flink;
6286:
6287: }
6288:
6289: #if LANCELOG
6290:
6291: if (LogTimerRunning) {
6292:
6293: NdisCancelTimer(&LogTimer, &Cancel);
6294: NdisStallExecution(500000);
6295: LogTimerRunning = FALSE;
6296:
6297: }
6298:
6299: #endif
6300:
6301:
6302: NdisRemoveInterrupt(&(Adapter->Interrupt));
6303:
6304: NdisWriteErrorLogEntry(
6305: Adapter->NdisAdapterHandle,
6306: NDIS_ERROR_CODE_HARDWARE_FAILURE,
6307: 0
6308: );
6309:
6310: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
6311:
6312: return TRUE;
6313:
6314: }
6315:
6316: }
6317:
6318: }
6319:
6320: STATIC
6321: VOID
6322: RelinquishReceivePacket(
6323: IN PLANCE_ADAPTER Adapter,
6324: IN UINT StartingIndex,
6325: IN UINT NumberOfBuffers
6326: )
6327:
6328: /*++
6329:
6330: Routine Description:
6331:
6332: Gives a range of receive descriptors back to the hardware.
6333:
6334: NOTE: MUST BE CALLED WITH THE LOCK HELD!!
6335:
6336: Arguments:
6337:
6338: Adapter - The adapter that the ring works with.
6339:
6340: StartingIndex - The first ring to return. Note that since
6341: we are dealing with a ring, this value could be greater than
6342: the EndingIndex.
6343:
6344: NumberOfBuffers - The number of buffers (or ring descriptors) in
6345: the current packet.
6346:
6347: Return Value:
6348:
6349: None.
6350:
6351: --*/
6352:
6353: {
6354:
6355: //
6356: // Index of the ring descriptor in the ring.
6357: //
6358: UINT CurrentIndex = StartingIndex;
6359:
6360: //
6361: // Pointer to the ring descriptor being returned.
6362: //
6363: PLANCE_RECEIVE_ENTRY CurrentEntry = Adapter->ReceiveRing + CurrentIndex;
6364:
6365: //
6366: // Hold in a local so that we don't need to access via the adapter.
6367: //
6368: const UINT TopReceiveIndex = Adapter->NumberOfReceiveRings - 1;
6369:
6370: UCHAR Tmp;
6371:
6372: LANCE_READ_HARDWARE_MEMORY_UCHAR(
6373: CurrentEntry->ReceiveSummaryBits,
6374: &Tmp
6375: );
6376:
6377: ASSERT(!(Tmp & LANCE_RECEIVE_OWNED_BY_CHIP));
6378: ASSERT(Tmp & LANCE_RECEIVE_START_OF_PACKET);
6379:
6380: for (
6381: ;
6382: NumberOfBuffers;
6383: NumberOfBuffers--
6384: ) {
6385:
6386: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
6387: CurrentEntry->ReceiveSummaryBits,
6388: LANCE_RECEIVE_OWNED_BY_CHIP
6389: );
6390:
6391: if (CurrentIndex == TopReceiveIndex) {
6392:
6393: CurrentEntry = Adapter->ReceiveRing;
6394: CurrentIndex = 0;
6395:
6396: } else {
6397:
6398: CurrentEntry++;
6399: CurrentIndex++;
6400:
6401: }
6402:
6403: }
6404:
6405: }
6406:
6407: STATIC
6408: BOOLEAN
6409: ProcessTransmitInterrupts(
6410: IN PLANCE_ADAPTER Adapter
6411: )
6412:
6413: /*++
6414:
6415: Routine Description:
6416:
6417: Process the packets that have finished transmitting.
6418:
6419: NOTE: This routine assumes that it is being executed in a
6420: single thread of execution. CALLED WITH LOCK HELD!!!
6421:
6422: Arguments:
6423:
6424: Adapter - The adapter that was sent from.
6425:
6426: Return Value:
6427:
6428: This function will return TRUE if it finished up the
6429: send on a packet. It will return FALSE if for some
6430: reason there was no packet to process.
6431:
6432: --*/
6433:
6434: {
6435: //
6436: // Index into the ring to packet structure. This index points
6437: // to the first ring entry for the first buffer used for transmitting
6438: // the packet.
6439: //
6440: UINT FirstIndex;
6441:
6442: //
6443: // Pointer to the last ring entry for the packet to be transmitted.
6444: // This pointer might actually point to a ring entry before the first
6445: // ring entry for the packet since the ring structure is, simply, a ring.
6446: //
6447: PLANCE_TRANSMIT_ENTRY LastRingEntry;
6448:
6449: //
6450: // Pointer to the packet that started this transmission.
6451: //
6452: PNDIS_PACKET OwningPacket;
6453:
6454: //
6455: // First Buffer
6456: //
6457: PNDIS_BUFFER FirstBuffer;
6458:
6459: //
6460: // Virtual address of first buffer
6461: //
6462: PVOID BufferVA;
6463:
6464: //
6465: // Length of the first buffer
6466: //
6467: UINT Length;
6468:
6469: //
6470: // Points to the reserved part of the OwningPacket.
6471: //
6472: PLANCE_RESERVED Reserved;
6473:
6474: UCHAR TransmitSummaryBits;
6475: USHORT ErrorSummaryInfo;
6476:
6477: //
6478: // Used to hold the ring to packet mapping information so that
6479: // we can release the ring entries as quickly as possible.
6480: //
6481: LANCE_RING_TO_PACKET SavedRingMapping;
6482:
6483:
6484: //
6485: // Get hold of the first transmitted packet.
6486: //
6487:
6488: //
6489: // First we check that this is a packet that was transmitted
6490: // but not already processed. Recall that this routine
6491: // will be called repeatedly until this tests false, Or we
6492: // hit a packet that we don't completely own.
6493: //
6494:
6495: //
6496: // NOTE: I found a problem where FirstUncommitedRing wraps around
6497: // and becomes equal to TransmittingRing. This only happens when
6498: // NumberOfAvailableRings is 0 (JohnsonA)
6499: //
6500:
6501: if ((Adapter->TransmittingRing == Adapter->FirstUncommittedRing) &&
6502: (Adapter->NumberOfAvailableRings > 0)) {
6503:
6504: return FALSE;
6505:
6506: } else {
6507:
6508: FirstIndex = Adapter->TransmittingRing - Adapter->TransmitRing;
6509:
6510: }
6511:
6512:
6513: //
6514: // We put the mapping into a local variable so that we
6515: // can return the mapping as soon as possible.
6516: //
6517:
6518: SavedRingMapping = Adapter->RingToPacket[FirstIndex];
6519:
6520: //
6521: // Get a pointer to the last ring entry for this packet.
6522: //
6523:
6524: LastRingEntry = Adapter->TransmitRing +
6525: SavedRingMapping.RingIndex;
6526:
6527: //
6528: // Get a pointer to the owning packet and the reserved part of
6529: // the packet.
6530: //
6531:
6532: OwningPacket = SavedRingMapping.OwningPacket;
6533:
6534: SavedRingMapping.OwningPacket = NULL;
6535:
6536: if (OwningPacket == NULL) {
6537:
6538: //
6539: // We seem to be in a messed up state. Ignore this interrupt and
6540: // the wake up dpc will reset the card if necessary.
6541: //
6542:
6543: ASSERT(OwningPacket != NULL);
6544: return(FALSE);
6545:
6546: }
6547:
6548: if (Adapter->FirstFinishTransmit == NULL) {
6549:
6550: //
6551: // We seem to be in a messed up state. Ignore this interrupt and
6552: // the wake up dpc will reset the card if necessary.
6553: //
6554:
6555: ASSERT(Adapter->FirstFinishTransmit != NULL);
6556: return(FALSE);
6557:
6558: }
6559:
6560: Reserved = PLANCE_RESERVED_FROM_PACKET(OwningPacket);
6561:
6562: //
6563: // Check that the host does indeed own this entire packet.
6564: //
6565:
6566: LANCE_READ_HARDWARE_MEMORY_UCHAR(
6567: LastRingEntry->TransmitSummaryBits,
6568: &TransmitSummaryBits
6569: );
6570:
6571: if (TransmitSummaryBits & LANCE_TRANSMIT_OWNED_BY_CHIP) {
6572:
6573: //
6574: // We don't own this last packet. We return FALSE to indicate
6575: // that we don't have any more packets to work on.
6576: //
6577:
6578: return FALSE;
6579:
6580: } else {
6581:
6582: //
6583: // Pointer to the current ring descriptor being examine for errors
6584: // and the statistics accumulated during its transmission.
6585: //
6586: PLANCE_TRANSMIT_ENTRY CurrentRingEntry;
6587:
6588: //
6589: // The binding that is submitting this packet.
6590: //
6591: PLANCE_OPEN Open;
6592:
6593: //
6594: // Holds whether the packet successfully transmitted or not.
6595: //
6596: BOOLEAN Successful = TRUE;
6597:
6598: LOG(TRANSMIT_COMPLETE);
6599:
6600: CurrentRingEntry = Adapter->TransmitRing + FirstIndex;
6601:
6602: //
6603: // now return these buffers to the adapter.
6604: //
6605:
6606: ReturnAdapterResources(
6607: Adapter,
6608: SavedRingMapping.LanceBuffersIndex
6609: );
6610:
6611: //
6612: // Since the host owns the entire packet check the ring
6613: // entries from first to last for any errors in transmission.
6614: // Any errors found or multiple tries should be recorded in
6615: // the information structure for the adapter.
6616: //
6617: // We treat Late Collisions as success since the packet was
6618: // fully transmitted and may have been received.
6619: //
6620:
6621: while (TRUE) {
6622:
6623: LANCE_READ_HARDWARE_MEMORY_UCHAR(
6624: CurrentRingEntry->TransmitSummaryBits,
6625: &TransmitSummaryBits
6626: );
6627:
6628: LANCE_READ_HARDWARE_MEMORY_USHORT(
6629: CurrentRingEntry->ErrorSummaryInfo,
6630: &ErrorSummaryInfo
6631: );
6632:
6633: if ((TransmitSummaryBits & LANCE_TRANSMIT_ANY_ERRORS) &&
6634: !(ErrorSummaryInfo & LANCE_TRANSMIT_LATE_COLLISION)) {
6635:
6636: if (ErrorSummaryInfo & LANCE_TRANSMIT_RETRY) {
6637:
6638: Adapter->RetryFailure++;
6639:
6640: } else if (ErrorSummaryInfo & LANCE_TRANSMIT_LOST_CARRIER) {
6641:
6642: Adapter->LostCarrier++;
6643:
6644: } else if (ErrorSummaryInfo & LANCE_TRANSMIT_UNDERFLOW) {
6645:
6646: Adapter->UnderFlow++;
6647:
6648: }
6649:
6650: #if DBG
6651: LanceSendFails[LanceSendFailPlace] =
6652: (UCHAR)(ErrorSummaryInfo);
6653: LanceSendFailPlace++;
6654:
6655:
6656: #endif
6657:
6658: #if LANCE_TRACE
6659: DbgPrint("Unsuccessful Transmit 0x%x\n",
6660: ErrorSummaryInfo);
6661: #endif
6662:
6663: Successful = FALSE;
6664:
6665: //
6666: // Move the pointer to transmitting but unprocessed
6667: // ring entries to after this packet, and recover
6668: // the remaining now available ring entries.
6669: //
6670:
6671: Adapter->NumberOfAvailableRings +=
6672: (CurrentRingEntry <= LastRingEntry)?
6673: ((LastRingEntry - CurrentRingEntry)+1):
6674: ((Adapter->LastTransmitRingEntry - CurrentRingEntry) +
6675: (LastRingEntry-Adapter->TransmitRing) + 2);
6676:
6677: if (LastRingEntry == Adapter->LastTransmitRingEntry) {
6678:
6679: Adapter->TransmittingRing = Adapter->TransmitRing;
6680:
6681: } else {
6682:
6683: Adapter->TransmittingRing = LastRingEntry + 1;
6684:
6685: }
6686:
6687: break;
6688:
6689: } else {
6690:
6691: //
6692: // Logical variable that records whether this
6693: // is the last packet.
6694: //
6695: BOOLEAN DoneWithPacket =
6696: TransmitSummaryBits &
6697: LANCE_TRANSMIT_END_OF_PACKET;
6698:
6699: if (ErrorSummaryInfo &
6700: LANCE_TRANSMIT_LATE_COLLISION) {
6701:
6702: Adapter->LateCollision++;
6703:
6704: }
6705:
6706: if (TransmitSummaryBits &
6707: LANCE_TRANSMIT_START_OF_PACKET) {
6708:
6709: //
6710: // Collect some statistics on how many tries were needed.
6711: //
6712:
6713: if (TransmitSummaryBits & LANCE_TRANSMIT_DEFERRED) {
6714:
6715: Adapter->Deferred++;
6716:
6717: } else if (TransmitSummaryBits & LANCE_TRANSMIT_ONE_RETRY) {
6718:
6719: Adapter->OneRetry++;
6720:
6721: } else if (TransmitSummaryBits & LANCE_TRANSMIT_MORE_THAN_ONE_RETRY) {
6722:
6723: Adapter->MoreThanOneRetry++;
6724:
6725:
6726: }
6727:
6728: }
6729:
6730: if (CurrentRingEntry == Adapter->LastTransmitRingEntry) {
6731:
6732: CurrentRingEntry = Adapter->TransmitRing;
6733:
6734: } else {
6735:
6736: CurrentRingEntry++;
6737:
6738: }
6739:
6740: Adapter->TransmittingRing = CurrentRingEntry;
6741: Adapter->NumberOfAvailableRings++;
6742:
6743: if (DoneWithPacket) {
6744:
6745: break;
6746:
6747: }
6748:
6749: }
6750:
6751: }
6752:
6753: //
6754: // Store result
6755: //
6756:
6757: if (Successful) {
6758:
6759: //
6760: // Increment number of packets successfully sent.
6761: //
6762:
6763: Adapter->Transmit++;
6764:
6765: }
6766:
6767: //
6768: // Remove packet from sending queue
6769: //
6770:
6771: Adapter->FirstFinishTransmit = Reserved->Next;
6772:
6773: if (Adapter->FirstFinishTransmit == NULL) {
6774:
6775: Adapter->LastFinishTransmit = NULL;
6776:
6777: }
6778:
6779: //
6780: // Do a quick check to see if the packet has a high likelyhood
6781: // of needing to loopback. (NOTE: This means that if the packet
6782: // must be loopbacked then this function will return true. If
6783: // the packet doesn't need to be loopbacked then the function
6784: // will probably return false.)
6785: //
6786:
6787: //
6788: // Get first buffer
6789: //
6790:
6791: NdisQueryPacket(
6792: OwningPacket,
6793: NULL,
6794: NULL,
6795: &FirstBuffer,
6796: NULL
6797: );
6798:
6799: //
6800: // Get VA of first buffer
6801: //
6802:
6803: NdisQueryBuffer(
6804: FirstBuffer,
6805: &BufferVA,
6806: &Length
6807: );
6808:
6809: if (EthShouldAddressLoopBack(
6810: Adapter->FilterDB,
6811: BufferVA
6812: )) {
6813:
6814: Reserved->SuccessfulTransmit = Successful;
6815:
6816: if (!Adapter->FirstLoopBack) {
6817:
6818: Adapter->FirstLoopBack = OwningPacket;
6819:
6820: } else {
6821:
6822: PLANCE_RESERVED_FROM_PACKET(Adapter->LastLoopBack)->Next = OwningPacket;
6823:
6824: }
6825:
6826: Reserved->Next = NULL;
6827: Adapter->LastLoopBack = OwningPacket;
6828:
6829: } else {
6830:
6831:
6832: Open = PLANCE_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle);
6833:
6834: //
6835: // Along with at least one reference because of the coming
6836: // indication there should be a reference because of the
6837: // packet to indicate.
6838: //
6839:
6840: ASSERT(Open->References > 0);
6841:
6842: NdisDprReleaseSpinLock(&Adapter->Lock);
6843:
6844: NdisCompleteSend(
6845: Open->NdisBindingContext,
6846: OwningPacket,
6847: ((Successful)?(NDIS_STATUS_SUCCESS):(NDIS_STATUS_FAILURE))
6848: );
6849:
6850: NdisDprAcquireSpinLock(&Adapter->Lock);
6851:
6852: //
6853: // Remove reference for packet
6854: //
6855:
6856: Open->References--;
6857:
6858: }
6859:
6860: //
6861: // Since we've given back some ring entries we should
6862: // open of the stage if it was closed and we are not resetting.
6863: //
6864:
6865: if ((!Adapter->StageOpen) && (!Adapter->ResetInProgress)) {
6866:
6867: Adapter->StageOpen = TRUE;
6868:
6869: }
6870:
6871: return TRUE;
6872: }
6873:
6874: }
6875:
6876: STATIC
6877: VOID
6878: ReturnAdapterResources(
6879: IN PLANCE_ADAPTER Adapter,
6880: IN UINT BufferIndex
6881: )
6882:
6883: /*++
6884:
6885: Routine Description:
6886:
6887: Given that a packet has used adapter resources (which the routine
6888: asserts), return those resources to the adapter.
6889:
6890: NOTE: CALLED WITH LOCK HELD!!!
6891:
6892: Arguments:
6893:
6894: Adapter - The adapter that the packet came through.
6895:
6896: BufferIndex - The adapter buffer descriptor index to put back on the
6897: free list.
6898:
6899:
6900: Return Value:
6901:
6902: None.
6903:
6904: --*/
6905: {
6906:
6907: //
6908: // The adapter buffer descriptor that was allocated to this packet.
6909: //
6910: PLANCE_BUFFER_DESCRIPTOR BufferDescriptor = Adapter->LanceBuffers +
6911: BufferIndex;
6912:
6913: //
6914: // Index of the listhead that heads the list that the adapter
6915: // buffer descriptor belongs too.
6916: //
6917: INT ListHeadIndex = BufferDescriptor->Next;
6918:
6919: //
6920: // Put the adapter buffer back on the free list.
6921: //
6922:
6923: BufferDescriptor->Next = Adapter->LanceBufferListHeads[ListHeadIndex];
6924: Adapter->LanceBufferListHeads[ListHeadIndex] = BufferIndex;
6925:
6926: //
6927: // If the stage was closed and we aren't resetting then open
6928: // it back up.
6929: //
6930:
6931: if ((!Adapter->StageOpen) && (!Adapter->ResetInProgress)) {
6932:
6933: Adapter->StageOpen = TRUE;
6934:
6935: }
6936:
6937: }
6938:
6939: STATIC
6940: VOID
6941: StartAdapterReset(
6942: IN PLANCE_ADAPTER Adapter
6943: )
6944:
6945: /*++
6946:
6947: Routine Description:
6948:
6949: This is the first phase of resetting the adapter hardware.
6950:
6951: It makes the following assumptions:
6952:
6953: 1) That the hardware has been stopped.
6954:
6955: 2) That it can not be preempted.
6956:
6957: 3) That no other adapter activity can occur.
6958:
6959: When this routine is finished all of the adapter information
6960: will be as if the driver was just initialized.
6961:
6962: Arguments:
6963:
6964: Adapter - The adapter whose hardware is to be reset.
6965:
6966: Return Value:
6967:
6968: None.
6969:
6970: --*/
6971:
6972: {
6973: UINT i;
6974: PNDIS_PACKET Packet;
6975: PLANCE_RESERVED Reserved;
6976: PLANCE_OPEN Open;
6977: PNDIS_PACKET Next;
6978:
6979:
6980: #if LANCE_TRACE
6981: DbgPrint("In StartAdapterReset\n");
6982: #endif
6983:
6984: LOG(RESET_STEP_2);
6985:
6986: //
6987: // Go through the various transmit lists and....
6988: //
6989:
6990:
6991: for (
6992: i = 3;
6993: i > 0;
6994: i--
6995: ) {
6996:
6997: switch (i) {
6998:
6999: case 1:
7000: Next = Adapter->FirstFinishTransmit;
7001: break;
7002: case 2:
7003: Next = Adapter->FirstStage1Packet;
7004: break;
7005: case 3:
7006: Next = Adapter->FirstLoopBack;
7007: break;
7008:
7009: }
7010:
7011:
7012: while (Next) {
7013:
7014: Packet = Next;
7015: Reserved = PLANCE_RESERVED_FROM_PACKET(Packet);
7016: Next = Reserved->Next;
7017: Open =
7018: PLANCE_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle);
7019:
7020:
7021: if (Adapter->ResetRequestType == NdisRequestGeneric1) {
7022:
7023: //
7024: // Abort the packet
7025: //
7026: // The completion of the packet is one less reason
7027: // to keep the open around.
7028: //
7029:
7030: ASSERT(Open->References);
7031:
7032: Open->References--;
7033:
7034: NdisReleaseSpinLock(&Adapter->Lock);
7035:
7036: NdisCompleteSend(
7037: Open->NdisBindingContext,
7038: Packet,
7039: NDIS_STATUS_REQUEST_ABORTED
7040: );
7041:
7042: NdisAcquireSpinLock(&Adapter->Lock);
7043:
7044: } else if ((i == 1) || (i ==3)) {
7045:
7046: //
7047: // Complete these sends
7048: //
7049: // The completion of the packet is one less reason
7050: // to keep the open around.
7051: //
7052:
7053: ASSERT(Open->References);
7054:
7055: Adapter->Transmit++;
7056:
7057: LOG(RESET_COMPLETE_PACKET);
7058:
7059: NdisReleaseSpinLock(&Adapter->Lock);
7060:
7061: NdisCompleteSend(
7062: Open->NdisBindingContext,
7063: Packet,
7064: NDIS_STATUS_SUCCESS
7065: );
7066:
7067: NdisAcquireSpinLock(&Adapter->Lock);
7068:
7069: Open->References--;
7070:
7071: }
7072:
7073: }
7074:
7075: }
7076:
7077:
7078:
7079: Adapter->CSR0Value = 0;
7080: Adapter->NumberOfAvailableRings = Adapter->NumberOfTransmitRings;
7081: Adapter->AllocateableRing = Adapter->TransmitRing;
7082: Adapter->TransmittingRing = Adapter->TransmitRing;
7083: Adapter->FirstUncommittedRing = Adapter->TransmitRing;
7084:
7085:
7086: Adapter->StageOpen = TRUE;
7087:
7088: Adapter->AlreadyProcessingStage = FALSE;
7089:
7090: Adapter->CurrentReceiveIndex = 0;
7091:
7092: //
7093: // Clean all of the receive ring entries.
7094: //
7095:
7096: {
7097:
7098: PLANCE_RECEIVE_ENTRY CurrentReceive = Adapter->ReceiveRing;
7099: const PLANCE_RECEIVE_ENTRY After = Adapter->ReceiveRing+
7100: Adapter->NumberOfReceiveRings;
7101:
7102: do {
7103:
7104: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
7105: CurrentReceive->ReceiveSummaryBits,
7106: LANCE_RECEIVE_OWNED_BY_CHIP
7107: );
7108: CurrentReceive++;
7109:
7110:
7111: } while (CurrentReceive != After);
7112:
7113: }
7114:
7115:
7116: //
7117: // Clean all of the transmit ring entries.
7118: //
7119:
7120: {
7121:
7122: PLANCE_TRANSMIT_ENTRY CurrentTransmit = Adapter->TransmitRing;
7123: const PLANCE_TRANSMIT_ENTRY After = Adapter->TransmitRing+
7124: Adapter->NumberOfTransmitRings;
7125:
7126: do {
7127:
7128: LANCE_WRITE_HARDWARE_MEMORY_UCHAR(
7129: CurrentTransmit->TransmitSummaryBits,
7130: 0x00
7131: );
7132: CurrentTransmit++;
7133:
7134:
7135: } while (CurrentTransmit != After);
7136:
7137: }
7138:
7139: //
7140: // Recover all of the adapter buffers.
7141: //
7142:
7143: for (
7144: i = 0;
7145: i < (Adapter->NumberOfSmallBuffers +
7146: Adapter->NumberOfMediumBuffers +
7147: Adapter->NumberOfLargeBuffers);
7148: i++
7149: ) {
7150:
7151: Adapter->LanceBuffers[i].Next = i+1;
7152:
7153: }
7154:
7155: Adapter->LanceBufferListHeads[0] = -1;
7156: Adapter->LanceBufferListHeads[1] = 0;
7157: Adapter->LanceBuffers[(Adapter->NumberOfSmallBuffers)-1].Next = -1;
7158: Adapter->LanceBufferListHeads[2] = Adapter->NumberOfSmallBuffers;
7159: Adapter->LanceBuffers[(Adapter->NumberOfSmallBuffers +
7160: Adapter->NumberOfMediumBuffers)-1].Next = -1;
7161: Adapter->LanceBufferListHeads[3] = Adapter->NumberOfSmallBuffers +
7162: Adapter->NumberOfMediumBuffers;
7163: Adapter->LanceBuffers[(Adapter->NumberOfSmallBuffers+
7164: Adapter->NumberOfMediumBuffers+
7165: Adapter->NumberOfLargeBuffers)-1].Next = -1;
7166:
7167: //
7168: // If it was a Reset from LanceReset(), clear out all queues.
7169: //
7170:
7171: if (Adapter->ResetRequestType == NdisRequestGeneric1) {
7172:
7173: Adapter->FirstLoopBack = NULL;
7174: Adapter->LastLoopBack = NULL;
7175: Adapter->FirstFinishTransmit = NULL;
7176: Adapter->LastFinishTransmit = NULL;
7177: Adapter->FirstStage1Packet = NULL;
7178: Adapter->LastStage1Packet = NULL;
7179:
7180: } else {
7181:
7182: //
7183: // It was a reset from a SetInfo,
7184: // Clear out only the intermediate queues - the
7185: // packets were moved out and back to stage1. (sigh)
7186: //
7187:
7188: Adapter->FirstFinishTransmit = NULL;
7189: Adapter->LastFinishTransmit = NULL;
7190:
7191: //
7192: // Re-allocate all the stage 1 packets.
7193: //
7194:
7195: Next = Adapter->FirstStage1Packet;
7196:
7197: Adapter->FirstStage1Packet = NULL;
7198: Adapter->LastStage1Packet = NULL;
7199:
7200: while (Next != NULL) {
7201:
7202: LOG(RESET_RECOVER_PACKET);
7203:
7204: Packet = Next,
7205: Reserved = PLANCE_RESERVED_FROM_PACKET(Packet);
7206: Next = Reserved->Next;
7207:
7208: SetupAllocate(Adapter, Reserved->MacBindingHandle, Packet);
7209:
7210: }
7211:
7212: }
7213:
7214:
7215: SetInitBlockAndInit(Adapter);
7216:
7217: #if LANCE_TRACE
7218: DbgPrint("Out StartAdapterReset\n");
7219: #endif
7220:
7221: }
7222:
7223: STATIC
7224: VOID
7225: SetInitBlockAndInit(
7226: IN PLANCE_ADAPTER Adapter
7227: )
7228:
7229: /*++
7230:
7231: Routine Description:
7232:
7233: It is this routines responsibility to make sure that the
7234: initialization block is filled and the chip is initialized
7235: *but not* started.
7236:
7237: NOTE: This routine assumes that it is called with the lock
7238: acquired OR that only a single thread of execution is working
7239: with this particular adapter.
7240:
7241: Arguments:
7242:
7243: Adapter - The adapter whose hardware is to be initialized.
7244:
7245: Return Value:
7246:
7247: None.
7248:
7249: --*/
7250: {
7251:
7252: PHYSICAL_ADDRESS PhysAdr;
7253:
7254: //
7255: // Fill in the adapters initialization block.
7256: //
7257:
7258: LanceSetInitializationBlock(Adapter);
7259:
7260: PhysAdr = LANCE_GET_HARDWARE_PHYSICAL_ADDRESS(Adapter,Adapter->InitBlock);
7261:
7262: //
7263: // Make sure that it does have even byte alignment.
7264: //
7265:
7266: ASSERT(!(PhysAdr.LowPart & 0x01));
7267:
7268: //
7269: // Write the address of the initialization block to csr1 and csr2.
7270: //
7271:
7272: LANCE_WRITE_RAP(
7273: Adapter,
7274: LANCE_SELECT_CSR1
7275: );
7276:
7277: LANCE_WRITE_RDP(
7278: Adapter,
7279: LANCE_GET_LOW_PART_ADDRESS(PhysAdr.LowPart)
7280: );
7281:
7282: LANCE_WRITE_RAP(
7283: Adapter,
7284: LANCE_SELECT_CSR2
7285: );
7286:
7287: LANCE_WRITE_RDP(
7288: Adapter,
7289: LANCE_GET_HIGH_PART_ADDRESS(PhysAdr.LowPart)
7290: );
7291:
7292: //
7293: // Write to csr0 to initialize the chip.
7294: //
7295:
7296: LANCE_WRITE_RAP(
7297: Adapter,
7298: LANCE_SELECT_CSR0
7299: );
7300:
7301: LANCE_WRITE_RDP(
7302: Adapter,
7303: LANCE_CSR0_INIT_CHIP
7304: );
7305:
7306: }
7307:
7308: STATIC
7309: VOID
7310: SetupForReset(
7311: IN PLANCE_ADAPTER Adapter,
7312: IN PLANCE_OPEN Open,
7313: IN PNDIS_REQUEST NdisRequest,
7314: IN NDIS_REQUEST_TYPE RequestType
7315: )
7316:
7317: /*++
7318:
7319: Routine Description:
7320:
7321: This routine is used to fill in the who and why a reset is
7322: being set up as well as setting the appropriate fields in the
7323: adapter.
7324:
7325: NOTE: This routine must be called with the lock acquired.
7326:
7327: Arguments:
7328:
7329: Adapter - The adapter whose hardware is to be initialized.
7330:
7331: Open - A (possibly NULL) pointer to an lance open structure.
7332: The reason it could be null is if the adapter is initiating the
7333: reset on its own.
7334:
7335: NdisRequest - A pointer to the NDIS_REQUEST which requested the reset.
7336:
7337: RequestType - If the open is not null then the request type that
7338: is causing the reset.
7339:
7340: Return Value:
7341:
7342: None.
7343:
7344: --*/
7345: {
7346:
7347: #if LANCE_TRACE
7348: DbgPrint("In SetupForReset\n");
7349: #endif
7350:
7351: LOG(RESET_STEP_1);
7352:
7353: //
7354: // Shut down the chip. We won't be doing any more work until
7355: // the reset is complete.
7356: //
7357:
7358: NdisSynchronizeWithInterrupt(
7359: &Adapter->Interrupt,
7360: LanceSyncStopChip,
7361: (PVOID)Adapter
7362: );
7363:
7364: //
7365: // Once the chip is stopped we can't get any more interrupts.
7366: // Any interrupts that are "queued" for processing could
7367: // only possibly service this reset. It is therefore safe for
7368: // us to clear the adapter global csr value.
7369: //
7370:
7371: Adapter->CSR0Value = 0;
7372:
7373: Adapter->ResetInProgress = TRUE;
7374: Adapter->ResetInitStarted = FALSE;
7375:
7376: //
7377: // Shut down all of the transmit queues so that the
7378: // transmit portion of the chip will eventually calm down.
7379: //
7380:
7381: Adapter->StageOpen = FALSE;
7382:
7383: Adapter->ResetNdisRequest = NdisRequest;
7384: Adapter->ResettingOpen = Open;
7385: Adapter->ResetRequestType = RequestType;
7386:
7387: //
7388: // If there is a valid open we should up the reference count
7389: // so that the open can't be deleted before we indicate that
7390: // their request is finished.
7391: //
7392:
7393: if (Open) {
7394:
7395: Open->References++;
7396:
7397: }
7398:
7399: #if LANCE_TRACE
7400: DbgPrint("Out SetupForReset\n");
7401: #endif
7402:
7403: }
7404:
7405:
7406: STATIC
7407: VOID
7408: FinishPendOp(
7409: IN PLANCE_ADAPTER Adapter,
7410: IN BOOLEAN Successful
7411: )
7412:
7413: /*++
7414:
7415: Routine Description:
7416:
7417: This routine is called when a pended operation completes.
7418: It calles CompleteRequest if needed and does any other
7419: cleanup required.
7420:
7421: NOTE: This routine is called with the lock held and
7422: returns with it held.
7423:
7424: NOTE: This routine assumes that the pended operation to
7425: be completed was specifically requested by the protocol.
7426:
7427:
7428: Arguments:
7429:
7430: Adapter - The adapter.
7431:
7432: Successful - Was the pended operation completed successfully.
7433:
7434: Return Value:
7435:
7436: None.
7437:
7438: --*/
7439:
7440: {
7441: ASSERT(Adapter->ResetNdisRequest != NULL);
7442:
7443:
7444: //
7445: // It was a request for filter change or multicastlist change.
7446: //
7447:
7448: if (Successful) {
7449:
7450: //
7451: // complete the operation.
7452: //
7453:
7454:
7455: NdisReleaseSpinLock(&(Adapter->Lock));
7456:
7457: NdisCompleteRequest(
7458: Adapter->ResettingOpen->NdisBindingContext,
7459: Adapter->ResetNdisRequest,
7460: NDIS_STATUS_SUCCESS
7461: );
7462:
7463: NdisAcquireSpinLock(&(Adapter->Lock));
7464:
7465: Adapter->ResetNdisRequest = NULL;
7466:
7467: Adapter->ResettingOpen->References--;
7468:
7469: } else {
7470:
7471:
7472: //
7473: // complete the operation.
7474: //
7475:
7476:
7477: NdisReleaseSpinLock(&(Adapter->Lock));
7478:
7479: NdisCompleteRequest(
7480: Adapter->ResettingOpen->NdisBindingContext,
7481: Adapter->ResetNdisRequest,
7482: NDIS_STATUS_FAILURE
7483: );
7484:
7485: NdisAcquireSpinLock(&(Adapter->Lock));
7486:
7487: Adapter->ResetNdisRequest = NULL;
7488:
7489: Adapter->ResettingOpen->References--;
7490:
7491: }
7492:
7493: return;
7494:
7495: }
7496:
7497:
7498:
7499: STATIC
7500: BOOLEAN
7501: LanceSyncWriteRAP(
7502: IN PVOID Context
7503: )
7504: /*++
7505:
7506: Routine Description:
7507:
7508: This routine is used by the normal interrupt processing routine
7509: to synchronize with interrupts from the card. It will write
7510: to the RAP
7511:
7512:
7513: Arguments:
7514:
7515: Context - This is really a pointer to a record type peculiar
7516: to this routine. The record contains a pointer to the adapter
7517: and a pointer to the value to write.
7518:
7519:
7520: Return Value:
7521:
7522: Always returns true.
7523:
7524: --*/
7525:
7526: {
7527:
7528:
7529: PLANCE_SYNCH_CONTEXT C = Context;
7530:
7531: LANCE_ISR_WRITE_RAP(C->Adapter, C->LocalWrite);
7532:
7533: return FALSE;
7534:
7535: }
7536:
7537: BOOLEAN
7538: LanceSyncWriteRDP(
7539: IN PVOID Context
7540: )
7541: /*++
7542:
7543: Routine Description:
7544:
7545: This routine is used by the normal interrupt processing routine
7546: to synchronize with interrupts from the card. It will write
7547: into the RDP register
7548:
7549:
7550: Arguments:
7551:
7552: Context - This is really a pointer to a record type peculiar
7553: to this routine. The record contains a pointer to the adapter
7554: and a pointer to the value to write.
7555:
7556: Return Value:
7557:
7558: Always returns true.
7559:
7560: --*/
7561:
7562: {
7563:
7564:
7565: PLANCE_SYNCH_CONTEXT C = Context;
7566:
7567: LANCE_ISR_WRITE_RDP(C->Adapter, C->LocalWrite);
7568:
7569: return FALSE;
7570:
7571:
7572: }
7573:
7574: STATIC
7575: BOOLEAN
7576: LanceSyncReadRDP(
7577: IN PVOID Context
7578: )
7579: /*++
7580:
7581: Routine Description:
7582:
7583: This routine is used by the normal interrupt processing routine
7584: to synchronize with interrupts from the card. It will read
7585: from the RDP.
7586:
7587: Arguments:
7588:
7589: Context - This is really a pointer to a record type peculiar
7590: to this routine. The record contains a pointer to the adapter
7591: and a pointer to a USHORT to store the value into.
7592:
7593: Return Value:
7594:
7595: Always returns true.
7596:
7597: --*/
7598:
7599: {
7600:
7601:
7602: PLANCE_SYNCH_CONTEXT C = Context;
7603:
7604: LANCE_ISR_READ_RDP(C->Adapter, C->LocalRead);
7605:
7606: return FALSE;
7607:
7608: }
7609:
7610: STATIC
7611: BOOLEAN
7612: LanceSyncWriteNicsr(
7613: IN PVOID Context
7614: )
7615: /*++
7616:
7617: Routine Description:
7618:
7619: This routine is used by the normal interrupt processing routine
7620: to synchronize with interrupts from the card. It will
7621: Write to the NIC Status Register.
7622:
7623: Arguments:
7624:
7625: Context - This is really a pointer to a record type peculiar
7626: to this routine. The record contains a pointer to the adapter
7627: and a pointer to an address which holds the value to write.
7628:
7629: Return Value:
7630:
7631: Always returns false.
7632:
7633: --*/
7634:
7635: {
7636:
7637: PLANCE_SYNCH_CONTEXT C = Context;
7638:
7639: LANCE_ISR_WRITE_NICSR(C->Adapter, C->LocalWrite);
7640:
7641: return FALSE;
7642:
7643: }
7644:
7645: STATIC
7646: BOOLEAN
7647: LanceSyncStopChip(
7648: IN PVOID Context
7649: )
7650:
7651: /*++
7652:
7653: Routine Description:
7654:
7655: This routine is used to stop a lance.
7656:
7657:
7658:
7659: Arguments:
7660:
7661: Adapter - The adapter for the LANCE to stop.
7662:
7663: Return Value:
7664:
7665: FALSE
7666:
7667: --*/
7668:
7669: {
7670:
7671: PLANCE_ADAPTER Adapter = (PLANCE_ADAPTER)Context;
7672:
7673: //
7674: // Set the RAP to csr0.
7675: //
7676:
7677: LANCE_ISR_WRITE_RAP(
7678: Adapter,
7679: LANCE_SELECT_CSR0
7680: );
7681:
7682: //
7683: // Set the RDP to stop chip.
7684: //
7685:
7686: LANCE_ISR_WRITE_RDP(
7687: Adapter,
7688: LANCE_CSR0_STOP
7689: );
7690:
7691: if (Adapter->LanceCard & (LANCE_DE201 | LANCE_DE100 | LANCE_DE422)) {
7692:
7693: //
7694: // Always reset the ACON bit after a stop.
7695: //
7696:
7697: LANCE_ISR_WRITE_RAP(
7698: Adapter,
7699: LANCE_SELECT_CSR3
7700: );
7701:
7702: LANCE_ISR_WRITE_RDP(
7703: Adapter,
7704: LANCE_CSR3_ACON
7705: );
7706:
7707: }
7708:
7709: //
7710: // Select CSR0 again.
7711: //
7712:
7713: LANCE_ISR_WRITE_RAP(
7714: Adapter,
7715: LANCE_SELECT_CSR0
7716: );
7717:
7718: return(FALSE);
7719: }
7720:
7721:
7722: VOID
7723: LanceWakeUpDpc(
7724: IN PVOID SystemSpecific1,
7725: IN PVOID Context,
7726: IN PVOID SystemSpecific2,
7727: IN PVOID SystemSpecific3
7728: )
7729:
7730: /*++
7731:
7732: Routine Description:
7733:
7734: This DPC routine is queued every 5 seconds to check on the
7735: queues. If an interrupt was not received
7736: in the last 5 seconds and there should have been one,
7737: then we abort all operations.
7738:
7739: Arguments:
7740:
7741: Context - Really a pointer to the adapter.
7742:
7743: Return Value:
7744:
7745: None.
7746:
7747: --*/
7748: {
7749: PLANCE_ADAPTER Adapter = (PLANCE_ADAPTER)Context;
7750: PLANCE_OPEN TmpOpen;
7751: PNDIS_PACKET TransmitPacket;
7752: PLANCE_PEND_DATA PendOp;
7753: PNDIS_REQUEST Request;
7754: PLANCE_RESERVED Reserved;
7755:
7756: UNREFERENCED_PARAMETER(SystemSpecific1);
7757: UNREFERENCED_PARAMETER(SystemSpecific2);
7758: UNREFERENCED_PARAMETER(SystemSpecific3);
7759:
7760: NdisDprAcquireSpinLock(&Adapter->Lock);
7761:
7762: if ((Adapter->WakeUpTimeout) &&
7763: ((Adapter->FirstFinishTransmit != NULL) ||
7764: (Adapter->FirstStage1Packet != NULL) ||
7765: (Adapter->PendQueue != NULL) ||
7766: (Adapter->ResetNdisRequest != NULL))) {
7767:
7768: //
7769: // We had a pending operation the last time we ran,
7770: // and it has not been completed...we need to complete
7771: // it now.
7772:
7773: Adapter->WakeUpTimeout = FALSE;
7774:
7775: Adapter->TimeoutCount++;
7776:
7777: if (Adapter->TimeoutCount < 10) {
7778:
7779: //
7780: // Limit the number of error log entries
7781: //
7782:
7783: NdisWriteErrorLogEntry(
7784: Adapter->NdisAdapterHandle,
7785: NDIS_ERROR_CODE_HARDWARE_FAILURE,
7786: 0
7787: );
7788:
7789:
7790: }
7791:
7792: if ((Adapter->ResettingOpen != NULL) &&
7793: (Adapter->ResetRequestType != NdisRequestClose)) {
7794:
7795: if (Adapter->ResetNdisRequest != NULL) {
7796:
7797: //
7798: // It was a request submitted by a protocol.
7799: //
7800:
7801: TmpOpen = Adapter->ResettingOpen;
7802:
7803: NdisDprReleaseSpinLock(&(Adapter->Lock));
7804:
7805: NdisCompleteRequest(
7806: Adapter->ResettingOpen->NdisBindingContext,
7807: Adapter->ResetNdisRequest,
7808: NDIS_STATUS_SUCCESS
7809: );
7810:
7811: NdisDprAcquireSpinLock(&(Adapter->Lock));
7812:
7813: TmpOpen->References--;
7814:
7815: }
7816:
7817: }
7818:
7819: while (Adapter->PendQueue) {
7820:
7821: Request = Adapter->PendQueue;
7822: PendOp = PLANCE_PEND_DATA_FROM_PNDIS_REQUEST(Request);
7823:
7824: Adapter->PendQueue = PendOp->Next;
7825:
7826: if (Adapter->PendQueue == NULL){
7827:
7828: //
7829: // We have just emptied the list.
7830: //
7831:
7832: Adapter->PendQueueTail = NULL;
7833:
7834: }
7835:
7836:
7837: if ((PendOp->Open != NULL) &&
7838: (PendOp->RequestType != NdisRequestClose)) {
7839:
7840: //
7841: // It was a request submitted by a protocol.
7842: //
7843:
7844: TmpOpen = PendOp->Open;
7845:
7846: NdisDprReleaseSpinLock(&(Adapter->Lock));
7847:
7848: NdisCompleteRequest(
7849: PendOp->Open->NdisBindingContext,
7850: Request,
7851: NDIS_STATUS_SUCCESS
7852: );
7853:
7854: NdisDprAcquireSpinLock(&(Adapter->Lock));
7855:
7856: TmpOpen->References--;
7857:
7858: }
7859:
7860: }
7861:
7862: while (Adapter->FirstFinishTransmit != NULL) {
7863:
7864: TransmitPacket = Adapter->FirstFinishTransmit;
7865:
7866: Reserved = PLANCE_RESERVED_FROM_PACKET(TransmitPacket);
7867:
7868: Adapter->FirstFinishTransmit = Reserved->Next;
7869:
7870: if (Adapter->FirstFinishTransmit == NULL) {
7871:
7872: Adapter->LastFinishTransmit = NULL;
7873:
7874: }
7875:
7876: TmpOpen = PLANCE_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle);
7877:
7878: NdisDprReleaseSpinLock(&Adapter->Lock);
7879:
7880: NdisCompleteSend(
7881: TmpOpen->NdisBindingContext,
7882: TransmitPacket,
7883: NDIS_STATUS_SUCCESS
7884: );
7885:
7886: NdisDprAcquireSpinLock(&Adapter->Lock);
7887:
7888: TmpOpen->References--;
7889:
7890: }
7891:
7892: while (Adapter->FirstStage1Packet != NULL) {
7893:
7894: TransmitPacket = Adapter->FirstStage1Packet;
7895:
7896: Reserved = PLANCE_RESERVED_FROM_PACKET(TransmitPacket);
7897:
7898: //
7899: // Remove the packet from the queue.
7900: //
7901:
7902: Adapter->FirstStage1Packet = Reserved->Next;
7903:
7904: if (Adapter->FirstStage1Packet == NULL) {
7905:
7906: Adapter->LastStage1Packet = NULL;
7907:
7908: }
7909:
7910: TmpOpen = PLANCE_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle);
7911:
7912: NdisDprReleaseSpinLock(&Adapter->Lock);
7913:
7914: NdisCompleteSend(
7915: TmpOpen->NdisBindingContext,
7916: TransmitPacket,
7917: NDIS_STATUS_SUCCESS
7918: );
7919:
7920: NdisDprAcquireSpinLock(&Adapter->Lock);
7921:
7922: TmpOpen->References--;
7923:
7924: }
7925:
7926: Adapter->WakeUpTimeout = FALSE;
7927:
7928: SetupForReset(
7929: Adapter,
7930: NULL,
7931: NULL,
7932: NdisRequestGeneric4 // Means MAC issued
7933: );
7934:
7935: NdisSetTimer(&Adapter->DeferredTimer, 0);
7936:
7937: NdisDprReleaseSpinLock(&Adapter->Lock);
7938:
7939: } else {
7940:
7941: if ((Adapter->FirstFinishTransmit != NULL) ||
7942: (Adapter->FirstStage1Packet != NULL) ||
7943: (Adapter->PendQueue != NULL) ||
7944: (Adapter->ResetNdisRequest != NULL)) {
7945:
7946: Adapter->WakeUpTimeout = TRUE;
7947:
7948: }
7949:
7950: NdisDprReleaseSpinLock(&Adapter->Lock);
7951:
7952:
7953: }
7954:
7955: //
7956: // Fire off another Dpc to execute after 5 seconds
7957: //
7958:
7959: NdisSetTimer(
7960: &Adapter->WakeUpTimer,
7961: 5000
7962: );
7963:
7964: }
7965:
7966:
7967:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.