![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sonic.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / sonic|
Return to sonic.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / sonic |
1.1 root 1: /*++
2:
3: Copyright (c) 1990-1992 Microsoft Corporation
4:
5: Module Name:
6:
7: sonic.c
8:
9: Abstract:
10:
11: This is the main file for the National Semiconductor SONIC
12: Ethernet controller. This driver conforms to the NDIS 3.0 interface.
13:
14: The overall structure and much of the code is taken from
15: the Lance NDIS driver by Tony Ercolano.
16:
17: Author:
18:
19: Anthony V. Ercolano (Tonye) 20-Jul-1990
20: Adam Barr (adamba) 14-Nov-1990
21:
22: Environment:
23:
24: Kernel Mode - Or whatever is the equivalent.
25:
26: Revision History:
27:
28:
29: --*/
30:
31: #include <ndis.h>
32:
33:
34: #include <efilter.h>
35: #include <sonichrd.h>
36: #include <sonicsft.h>
37:
38:
39:
40: //
41: // This variable is used to control debug output.
42: //
43:
44: #if DBG
45: INT SonicDbg = 0;
46: #endif
47:
48:
49: STATIC
50: VOID
51: SonicShutdown(
52: IN PVOID ShutdownContext
53: );
54:
55: STATIC
56: NDIS_STATUS
57: SonicOpenAdapter(
58: OUT PNDIS_STATUS OpenErrorStatus,
59: OUT NDIS_HANDLE *MacBindingHandle,
60: OUT PUINT SelectedMediumIndex,
61: IN PNDIS_MEDIUM MediumArray,
62: IN UINT MediumArraySize,
63: IN NDIS_HANDLE NdisBindingContext,
64: IN NDIS_HANDLE MacAdapterContext,
65: IN UINT OpenOptions,
66: IN PSTRING AddressingInformation OPTIONAL
67: );
68:
69: STATIC
70: NDIS_STATUS
71: SonicCloseAdapter(
72: IN NDIS_HANDLE MacBindingHandle
73: );
74:
75:
76: STATIC
77: VOID
78: SonicUnload(
79: IN NDIS_HANDLE MacMacContext
80: );
81:
82: STATIC
83: NDIS_STATUS
84: SonicAddAdapter(
85: IN NDIS_HANDLE MacMacContext,
86: IN NDIS_HANDLE ConfigurationHandle,
87: IN PNDIS_STRING AdapterName
88: );
89:
90: STATIC
91: VOID
92: SonicRemoveAdapter(
93: IN NDIS_HANDLE MacAdapterContext
94: );
95:
96: STATIC
97: NDIS_STATUS
98: SonicReset(
99: IN NDIS_HANDLE MacBindingHandle
100: );
101:
102: #if 0
103: STATIC
104: UINT
105: CalculateCRC(
106: IN UINT NumberOfBytes,
107: IN PCHAR Input
108: );
109: #endif
110:
111: STATIC
112: BOOLEAN
113: SonicSynchClearIsr(
114: IN PVOID Context
115: );
116:
117: STATIC
118: VOID
119: SonicStopChip(
120: IN PSONIC_ADAPTER Adapter
121: );
122:
123: STATIC
124: BOOLEAN
125: SetupRegistersAndInit(
126: IN PSONIC_ADAPTER Adapter
127: );
128:
129: STATIC
130: BOOLEAN
131: SonicInitialInit(
132: IN PSONIC_ADAPTER Adapter
133: );
134:
135: #ifdef NDIS_NT
136:
137: NTSTATUS
138: DriverEntry(
139: IN PDRIVER_OBJECT DriverObject,
140: IN PUNICODE_STRING RegistryPath
141: );
142:
143: #else
144:
145: NDIS_STATUS
146: DriverEntry(
147: VOID
148: );
149:
150: #endif
151:
152: STATIC
153: NDIS_STATUS
154: SonicRegisterAdapter(
155: IN NDIS_HANDLE NdisMacHandle,
156: IN NDIS_HANDLE ConfigurationHandle,
157: IN PNDIS_STRING DeviceName,
158: IN PUCHAR NetworkAddress,
159: IN UCHAR AdapterType,
160: IN UINT SlotNumber,
161: IN UINT Controller,
162: IN UINT MultifunctionAdapter,
163: IN UINT SonicInterruptVector,
164: IN UINT SonicInterruptLevel,
165: IN NDIS_INTERRUPT_MODE SonicInterruptMode,
166: IN UINT MaximumOpenAdapters
167: );
168:
169: typedef enum {
170: SonicHardwareOk,
171: SonicHardwareChecksum,
172: SonicHardwareConfig
173: } SONIC_HARDWARE_STATUS;
174:
175: STATIC
176: SONIC_HARDWARE_STATUS
177: SonicHardwareGetDetails(
178: IN PSONIC_ADAPTER Adapter,
179: IN UINT SlotNumber,
180: IN UINT Controller,
181: IN UINT MultifunctionAdapter,
182: OUT PULONG InitialPort,
183: OUT PULONG NumberOfPorts,
184: IN OUT PUINT InterruptVector,
185: IN OUT PUINT InterruptLevel,
186: OUT ULONG ErrorLogData[3]
187: );
188:
189: STATIC
190: BOOLEAN
191: SonicHardwareGetAddress(
192: IN PSONIC_ADAPTER Adapter,
193: OUT ULONG ErrorLogData[3]
194: );
195:
196: #ifdef SONIC_INTERNAL
197:
198: //
199: // These routines are support reading the address for the
200: // sonic internal implementation on the R4000 motherboards.
201: //
202:
203: STATIC
204: NTSTATUS
205: SonicHardwareSaveInformation(
206: IN PWSTR ValueName,
207: IN ULONG ValueType,
208: IN PVOID ValueData,
209: IN ULONG ValueLength,
210: IN PVOID Context,
211: IN PVOID EntryContext
212: );
213:
214: STATIC
215: BOOLEAN
216: SonicHardwareVerifyChecksum(
217: IN PSONIC_ADAPTER Adapter,
218: IN PUCHAR EthernetAddress,
219: OUT ULONG ErrorLogData[3]
220: );
221:
222: #endif
223:
224:
225: //
226: // Use the alloc_text pragma to specify the driver initialization routines
227: // (they can be paged out).
228: //
229:
230: #ifdef ALLOC_PRAGMA
231: #pragma alloc_text(init,DriverEntry)
232: #pragma alloc_text(init,SonicRegisterAdapter)
233: #pragma alloc_text(init,SonicInitialInit)
234: #pragma alloc_text(init,SonicAddAdapter)
235: #pragma alloc_text(init,SonicHardwareGetDetails)
236: #pragma alloc_text(init,SonicHardwareGetAddress)
237: #ifdef SONIC_INTERNAL
238: #pragma alloc_text(init,SonicHardwareSaveInformation)
239: #pragma alloc_text(init,SonicHardwareVerifyChecksum)
240: #endif
241: #endif
242:
243:
244:
245: NTSTATUS
246: DriverEntry(
247: IN PDRIVER_OBJECT DriverObject,
248: IN PUNICODE_STRING RegistryPath
249: )
250:
251: /*++
252:
253: Routine Description:
254:
255: This is the primary initialization routine for the sonic driver.
256: It is simply responsible for the intializing the wrapper and registering
257: the MAC. It then calls a system and architecture specific routine that
258: will initialize and register each adapter.
259:
260: Arguments:
261:
262: DriverObject - Pointer to driver object created by the system.
263:
264: Return Value:
265:
266: The status of the operation.
267:
268: --*/
269:
270: {
271:
272: //
273: // Receives the status of the NdisRegisterMac operation.
274: //
275: NDIS_STATUS Status;
276:
277: PSONIC_MAC SonicMac;
278:
279: NDIS_HANDLE SonicWrapperHandle;
280:
281: static const NDIS_STRING MacName = NDIS_STRING_CONST("SONIC");
282: NDIS_MAC_CHARACTERISTICS SonicChar;
283:
284:
285: //
286: // Initialize the wrapper.
287: //
288:
289: NdisInitializeWrapper(
290: &SonicWrapperHandle,
291: DriverObject,
292: RegistryPath,
293: NULL
294: );
295:
296: //
297: // Now allocate memory for our global structure.
298: //
299:
300: SONIC_ALLOC_MEMORY(&Status, &SonicMac, sizeof(SONIC_MAC));
301:
302: if (Status != NDIS_STATUS_SUCCESS) {
303:
304: return NDIS_STATUS_RESOURCES;
305:
306: }
307:
308: SonicMac->WrapperHandle = SonicWrapperHandle;
309:
310: //
311: // Initialize the MAC characteristics for the call to
312: // NdisRegisterMac.
313: //
314:
315: SonicChar.MajorNdisVersion = SONIC_NDIS_MAJOR_VERSION;
316: SonicChar.MinorNdisVersion = SONIC_NDIS_MINOR_VERSION;
317: SonicChar.OpenAdapterHandler = SonicOpenAdapter;
318: SonicChar.CloseAdapterHandler = SonicCloseAdapter;
319: SonicChar.SendHandler = SonicSend;
320: SonicChar.TransferDataHandler = SonicTransferData;
321: SonicChar.ResetHandler = SonicReset;
322: SonicChar.RequestHandler = SonicRequest;
323: SonicChar.QueryGlobalStatisticsHandler = SonicQueryGlobalStatistics;
324: SonicChar.UnloadMacHandler = SonicUnload;
325: SonicChar.AddAdapterHandler = SonicAddAdapter;
326: SonicChar.RemoveAdapterHandler = SonicRemoveAdapter;
327: SonicChar.Name = MacName;
328:
329:
330: NdisRegisterMac(
331: &Status,
332: &SonicMac->MacHandle,
333: SonicWrapperHandle,
334: (NDIS_HANDLE)SonicMac, // MacMacContext
335: &SonicChar,
336: sizeof(SonicChar)
337: );
338:
339: if (Status == NDIS_STATUS_SUCCESS) {
340:
341: return NDIS_STATUS_SUCCESS;
342:
343: }
344:
345:
346: //
347: // We can only get here if something went wrong with registering
348: // the mac or *all* of the adapters.
349: //
350:
351: NdisTerminateWrapper(SonicWrapperHandle, NULL);
352:
353: return NDIS_STATUS_FAILURE;
354:
355: }
356:
357: #if DBG
358: //
359: // Save this to retrieve it in the debugger.
360: //
361:
362: PVOID SonicAdapterAddress;
363: #endif
364:
365:
366: STATIC
367: NDIS_STATUS
368: SonicRegisterAdapter(
369: IN NDIS_HANDLE NdisMacHandle,
370: IN NDIS_HANDLE ConfigurationHandle,
371: IN PNDIS_STRING DeviceName,
372: IN PUCHAR NetworkAddress,
373: IN UCHAR AdapterType,
374: IN UINT SlotNumber,
375: IN UINT Controller,
376: IN UINT MultifunctionAdapter,
377: IN UINT SonicInterruptVector,
378: IN UINT SonicInterruptLevel,
379: IN NDIS_INTERRUPT_MODE SonicInterruptMode,
380: IN UINT MaximumOpenAdapters
381: )
382:
383: /*++
384:
385: Routine Description:
386:
387: This routine (and its interface) are not portable. They are
388: defined by the OS, the architecture, and the particular SONIC
389: implementation.
390:
391: This routine is responsible for the allocation of the datastructures
392: for the driver as well as any hardware specific details necessary
393: to talk with the device.
394:
395: Arguments:
396:
397: NdisMacHandle - The handle given back to the mac from ndis when
398: the mac registered itself.
399:
400: ConfigurationHandle - Config handle passed to MacAddAdapter.
401:
402: DeviceName - The string containing the name to give to the
403: device adapter.
404:
405: NetworkAddress - The network address, or NULL if the default
406: should be used.
407:
408: AdapterType - The type of the adapter; currently SONIC_ADAPTER_TYPE_EISA
409: and SONIC_ADAPTER_TYPE_INTERNAL are supported,
410:
411: SlotNumber - The slot number for the EISA card.
412:
413: Controller - The controller number for INTERNAL chips.
414:
415: MultifunctionAdapter - The INTERNAL bus number for INTERNAL chips.
416:
417: SonicInterruptVector - The interrupt vector to use for the adapter.
418:
419: SonicInterruptLevel - The interrupt request level to use for this
420: adapter.
421:
422: SonicInterruptMode - The interrupt mode to be use for this adapter.
423:
424: MaximumOpenAdapters - The maximum number of opens at any one time.
425:
426: Return Value:
427:
428: Returns a failure status if anything occurred that prevents the
429: initialization of the adapter.
430:
431: --*/
432:
433: {
434:
435: //
436: // Pointer for the adapter root.
437: //
438: PSONIC_ADAPTER Adapter;
439:
440: //
441: // Status of various NDIS calls.
442: //
443: NDIS_STATUS Status;
444:
445: //
446: // Holds information needed when registering the adapter.
447: //
448: NDIS_ADAPTER_INFORMATION AdapterInformation;
449:
450: //
451: // Number of ports needed
452: //
453: ULONG InitialPort;
454: ULONG NumberOfPorts;
455:
456: //
457: // Returned from SonicHardwareGetDetails; if it failed,
458: // we log an error and exit.
459: //
460: SONIC_HARDWARE_STATUS HardwareDetailsStatus;
461:
462: //
463: // Used to store error log data from SonicHardwareGetDetails.
464: //
465: ULONG ErrorLogData[3];
466:
467: //
468: // We put in this assertion to make sure that ushort are 2 bytes.
469: // if they aren't then the initialization block definition needs
470: // to be changed.
471: //
472: // Also all of the logic that deals with status registers assumes
473: // that control registers are only 2 bytes.
474: //
475:
476: ASSERT(sizeof(USHORT) == 2);
477:
478: //
479: // The Sonic uses four bytes four physical addresses, so we
480: // must ensure that this is the case (SONIC_PHYSICAL_ADDRESS)
481: // is defined as a ULONG).
482: //
483:
484: ASSERT(sizeof(SONIC_PHYSICAL_ADDRESS) == 4);
485:
486: //
487: // Allocate the Adapter block.
488: //
489:
490: SONIC_ALLOC_MEMORY(&Status, &Adapter, sizeof(SONIC_ADAPTER));
491:
492: if (Status == NDIS_STATUS_SUCCESS) {
493: #if DBG
494: SonicAdapterAddress = Adapter;
495: #endif
496:
497: SONIC_ZERO_MEMORY(
498: Adapter,
499: sizeof(SONIC_ADAPTER)
500: );
501:
502:
503: Adapter->AdapterType = AdapterType;
504: if (SonicInterruptMode == NdisInterruptLatched) {
505: Adapter->InterruptLatched = TRUE;
506: }
507: Adapter->PermanentAddressValid = FALSE;
508:
509: //
510: // Set up the AdapterInformation structure; zero it out
511: // first using sizeof (in case any fields are added).
512: //
513:
514: SONIC_ZERO_MEMORY (&AdapterInformation, sizeof(NDIS_ADAPTER_INFORMATION));
515: AdapterInformation.DmaChannel = 0;
516: AdapterInformation.Master = TRUE;
517: AdapterInformation.PhysicalMapRegistersNeeded =
518: SONIC_MAX_FRAGMENTS * SONIC_NUMBER_OF_TRANSMIT_DESCRIPTORS;
519: AdapterInformation.MaximumPhysicalMapping =
520: SONIC_LARGE_BUFFER_SIZE;
521:
522: //
523: // This returns the I/O ports used by the Sonic and may
524: // modify SonicInterruptVector and SonicInterruptLevel,
525: // as well as modiying some fields in Adapter.
526: //
527:
528: if ((HardwareDetailsStatus =
529: SonicHardwareGetDetails(
530: Adapter,
531: SlotNumber,
532: Controller,
533: MultifunctionAdapter,
534: &InitialPort,
535: &NumberOfPorts,
536: &SonicInterruptVector,
537: &SonicInterruptLevel,
538: ErrorLogData)) != SonicHardwareOk) {
539:
540: //
541: // If it fails, we call NdisRegisterAdapter anyway
542: // (so we can log an error using the NdisAdapterHandle),
543: // then return failure.
544: //
545:
546: AdapterInformation.NumberOfPortDescriptors = 0;
547:
548: } else {
549:
550: AdapterInformation.NumberOfPortDescriptors = 1;
551: AdapterInformation.PortDescriptors[0].InitialPort = InitialPort;
552: AdapterInformation.PortDescriptors[0].NumberOfPorts = NumberOfPorts;
553: AdapterInformation.PortDescriptors[0].PortOffset = (PVOID *)(&(Adapter->SonicPortAddress));
554:
555: }
556:
557: if (AdapterType == SONIC_ADAPTER_TYPE_EISA) {
558: AdapterInformation.AdapterType = NdisInterfaceEisa;
559: } else {
560: AdapterInformation.AdapterType = NdisInterfaceInternal;
561: }
562:
563: //
564: // Register the adapter with NDIS.
565: //
566:
567: if ((Status = NdisRegisterAdapter(
568: &Adapter->NdisAdapterHandle,
569: NdisMacHandle,
570: Adapter,
571: ConfigurationHandle,
572: DeviceName,
573: &AdapterInformation
574: )) == NDIS_STATUS_SUCCESS) {
575:
576: if (HardwareDetailsStatus != SonicHardwareOk) {
577:
578: //
579: // Log an error and exit.
580: //
581:
582: if (HardwareDetailsStatus == SonicHardwareChecksum) {
583:
584: NdisWriteErrorLogEntry(
585: Adapter->NdisAdapterHandle,
586: NDIS_ERROR_CODE_NETWORK_ADDRESS,
587: 6,
588: hardwareDetails,
589: SONIC_ERRMSG_HARDWARE_ADDRESS,
590: NDIS_STATUS_FAILURE,
591: ErrorLogData[0],
592: ErrorLogData[1],
593: ErrorLogData[2]
594: );
595:
596: } else {
597:
598: NdisWriteErrorLogEntry(
599: Adapter->NdisAdapterHandle,
600: NDIS_ERROR_CODE_MISSING_CONFIGURATION_PARAMETER,
601: 0
602: );
603:
604: }
605:
606: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
607: SONIC_FREE_MEMORY(Adapter, sizeof(SONIC_ADAPTER));
608: return NDIS_STATUS_FAILURE;
609:
610: }
611:
612:
613: //
614: // Allocate memory for all of the adapter structures.
615: //
616:
617: Adapter->NumberOfTransmitDescriptors =
618: SONIC_NUMBER_OF_TRANSMIT_DESCRIPTORS;
619: Adapter->NumberOfReceiveBuffers =
620: SONIC_NUMBER_OF_RECEIVE_BUFFERS;
621: Adapter->NumberOfReceiveDescriptors =
622: SONIC_NUMBER_OF_RECEIVE_DESCRIPTORS;
623:
624:
625: if (AllocateAdapterMemory(Adapter)) {
626:
627: //
628: // Get the network address. This writes
629: // an error log entry if it fails. This routine
630: // may do nothing on some systems, if
631: // SonicHardwareGetDetails has already determined
632: // the network address.
633: //
634:
635: if (!SonicHardwareGetAddress(Adapter, ErrorLogData)) {
636:
637: NdisWriteErrorLogEntry(
638: Adapter->NdisAdapterHandle,
639: NDIS_ERROR_CODE_NETWORK_ADDRESS,
640: 6,
641: hardwareDetails,
642: SONIC_ERRMSG_HARDWARE_ADDRESS,
643: NDIS_STATUS_FAILURE,
644: ErrorLogData[0],
645: ErrorLogData[1],
646: ErrorLogData[2]
647: );
648:
649: DeleteAdapterMemory(Adapter);
650: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
651: SONIC_FREE_MEMORY(Adapter, sizeof(SONIC_ADAPTER));
652: return NDIS_STATUS_FAILURE;
653:
654: }
655:
656: //
657: // Initialize the current hardware address.
658: //
659:
660: SONIC_MOVE_MEMORY(
661: Adapter->CurrentNetworkAddress,
662: (NetworkAddress != NULL) ?
663: NetworkAddress :
664: Adapter->PermanentNetworkAddress,
665: ETH_LENGTH_OF_ADDRESS);
666:
667:
668: InitializeListHead(&Adapter->OpenBindings);
669: Adapter->OpenCount = 0;
670: Adapter->Removed = FALSE;
671: InitializeListHead(&Adapter->CloseList);
672: NdisAllocateSpinLock(&Adapter->Lock);
673:
674:
675: Adapter->LastTransmitDescriptor =
676: Adapter->TransmitDescriptorArea +
677: (Adapter->NumberOfTransmitDescriptors-1);
678: Adapter->NumberOfAvailableDescriptors =
679: Adapter->NumberOfTransmitDescriptors;
680: Adapter->AllocateableDescriptor =
681: Adapter->TransmitDescriptorArea;
682: Adapter->TransmittingDescriptor =
683: Adapter->TransmitDescriptorArea;
684: Adapter->FirstUncommittedDescriptor =
685: Adapter->TransmitDescriptorArea;
686: Adapter->PacketsSinceLastInterrupt = 0;
687:
688: Adapter->CurrentReceiveBufferIndex = 0;
689: Adapter->CurrentReceiveDescriptorIndex = 0;
690: Adapter->LastReceiveDescriptor =
691: &Adapter->ReceiveDescriptorArea[
692: Adapter->NumberOfReceiveDescriptors-1];
693:
694: Adapter->InterruptMaskRegister = SONIC_INT_DEFAULT_VALUE;
695: Adapter->ReceiveDescriptorsExhausted = FALSE;
696: Adapter->ReceiveBuffersExhausted = FALSE;
697: Adapter->ReceiveControlRegister = SONIC_RCR_DEFAULT_VALUE;
698:
699: Adapter->ProcessingReceiveInterrupt = FALSE;
700: Adapter->ProcessingGeneralInterrupt = FALSE;
701: Adapter->ProcessingDeferredOperations = FALSE;
702: Adapter->FirstLoopBack = NULL;
703: Adapter->LastLoopBack = NULL;
704: Adapter->FirstFinishTransmit = NULL;
705: Adapter->LastFinishTransmit = NULL;
706: Adapter->SendStageOpen = TRUE;
707: Adapter->AlreadyProcessingSendStage = FALSE;
708: Adapter->FirstSendStagePacket = NULL;
709: Adapter->LastSendStagePacket = NULL;
710:
711: Adapter->References = 1;
712:
713: Adapter->ResetInProgress = FALSE;
714: Adapter->IndicatingResetStart = FALSE;
715: Adapter->IndicatingResetEnd = FALSE;
716: Adapter->ResettingOpen = NULL;
717: Adapter->FirstInitialization = TRUE;
718:
719: SONIC_ZERO_MEMORY (&Adapter->GeneralMandatory, GM_ARRAY_SIZE * sizeof(ULONG));
720: SONIC_ZERO_MEMORY (&Adapter->GeneralOptionalByteCount, GO_COUNT_ARRAY_SIZE * sizeof(SONIC_LARGE_INTEGER));
721: SONIC_ZERO_MEMORY (&Adapter->GeneralOptionalFrameCount, GO_COUNT_ARRAY_SIZE * sizeof(ULONG));
722: SONIC_ZERO_MEMORY (&Adapter->GeneralOptional, (GO_ARRAY_SIZE - GO_ARRAY_START) * sizeof(ULONG));
723: SONIC_ZERO_MEMORY (&Adapter->MediaMandatory, MM_ARRAY_SIZE * sizeof(ULONG));
724: SONIC_ZERO_MEMORY (&Adapter->MediaOptional, MO_ARRAY_SIZE * sizeof(ULONG));
725:
726: //
727: // Initialize the CAM and associated things.
728: // At the beginning nothing is enabled since
729: // our filter is 0, although we do store
730: // our network address in the first slot.
731: //
732:
733: Adapter->MulticastCamEnableBits = 0x0000;
734: Adapter->CurrentPacketFilter = 0;
735: Adapter->CamDescriptorArea->CamEnable = 0x0000;
736: Adapter->CamDescriptorsUsed = 0x0001;
737: Adapter->CamDescriptorAreaSize = 1;
738:
739: NdisInitializeTimer(
740: &Adapter->DeferredTimer,
741: SonicTimerProcess,
742: (PVOID)Adapter);
743:
744: SONIC_LOAD_CAM_FRAGMENT(
745: &Adapter->CamDescriptorArea->CamFragments[0],
746: 0,
747: Adapter->CurrentNetworkAddress
748: );
749:
750:
751: if (!EthCreateFilter(
752: SONIC_CAM_ENTRIES-1, // maximum MC addresses
753: SonicChangeAddresses,
754: SonicChangeClass,
755: SonicCloseAction,
756: Adapter->CurrentNetworkAddress,
757: &Adapter->Lock,
758: &Adapter->FilterDB
759: )) {
760:
761: NdisWriteErrorLogEntry(
762: Adapter->NdisAdapterHandle,
763: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
764: 2,
765: registerAdapter,
766: SONIC_ERRMSG_CREATE_FILTER
767: );
768:
769: DeleteAdapterMemory(Adapter);
770: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
771: NdisFreeSpinLock(&Adapter->Lock);
772: SONIC_FREE_MEMORY(Adapter, sizeof(SONIC_ADAPTER));
773: return NDIS_STATUS_RESOURCES;
774:
775: } else {
776:
777: //
778: // Initialize the interrupt.
779: //
780:
781: NdisInitializeInterrupt(
782: &Status,
783: &Adapter->Interrupt,
784: Adapter->NdisAdapterHandle,
785: SonicInterruptService,
786: Adapter,
787: SonicDeferredProcessing,
788: SonicInterruptVector,
789: SonicInterruptLevel,
790: TRUE,
791: SonicInterruptMode
792: );
793:
794:
795: if (Status != NDIS_STATUS_SUCCESS) {
796:
797: NdisWriteErrorLogEntry(
798: Adapter->NdisAdapterHandle,
799: NDIS_ERROR_CODE_INTERRUPT_CONNECT,
800: 2,
801: registerAdapter,
802: SONIC_ERRMSG_INIT_INTERRUPT
803: );
804:
805: EthDeleteFilter(Adapter->FilterDB);
806: DeleteAdapterMemory(Adapter);
807: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
808: NdisFreeSpinLock(&Adapter->Lock);
809: SONIC_FREE_MEMORY(Adapter, sizeof(SONIC_ADAPTER));
810: return Status;
811:
812: }
813:
814: //
815: // Start the card up. This writes an error
816: // log entry if it fails.
817: //
818:
819: if (!SonicInitialInit(Adapter)) {
820:
821: NdisRemoveInterrupt(&Adapter->Interrupt);
822: EthDeleteFilter(Adapter->FilterDB);
823: DeleteAdapterMemory(Adapter);
824: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
825: NdisFreeSpinLock(&Adapter->Lock);
826: SONIC_FREE_MEMORY(Adapter, sizeof(SONIC_ADAPTER));
827: return NDIS_STATUS_FAILURE;
828:
829: } else {
830:
831: //
832: // Initialize the wake up timer to catch interrupts that
833: // don't complete. It fires continuously
834: // every 5 seconds, and we check if there are any
835: // uncompleted operations from the previous 5 second
836: // period.
837: //
838:
839: Adapter->WakeUpDpc = (PVOID)SonicWakeUpDpc;
840:
841: NdisInitializeTimer(&Adapter->WakeUpTimer,
842: (PVOID)(Adapter->WakeUpDpc),
843: Adapter );
844:
845: NdisSetTimer(
846: &Adapter->WakeUpTimer,
847: 5000
848: );
849:
850: NdisRegisterAdapterShutdownHandler(
851: Adapter->NdisAdapterHandle,
852: (PVOID)Adapter,
853: SonicShutdown
854: );
855:
856: return NDIS_STATUS_SUCCESS;
857:
858: }
859:
860: }
861:
862:
863: } else {
864:
865: //
866: // Call to AllocateAdapterMemory failed.
867: //
868:
869: NdisWriteErrorLogEntry(
870: Adapter->NdisAdapterHandle,
871: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
872: 2,
873: registerAdapter,
874: SONIC_ERRMSG_ALLOC_MEMORY
875: );
876:
877: DeleteAdapterMemory(Adapter);
878: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
879: SONIC_FREE_MEMORY(Adapter, sizeof(SONIC_ADAPTER));
880: return NDIS_STATUS_RESOURCES;
881:
882: }
883:
884: } else {
885:
886: //
887: // Call to NdisRegisterAdapter failed.
888: //
889:
890: SONIC_FREE_MEMORY(Adapter, sizeof(SONIC_ADAPTER));
891: return Status;
892:
893: }
894:
895: } else {
896:
897: //
898: // Couldn't allocate adapter object.
899: //
900:
901: return Status;
902:
903: }
904:
905: }
906:
907: extern
908: BOOLEAN
909: SonicInitialInit(
910: IN PSONIC_ADAPTER Adapter
911: )
912:
913: /*++
914:
915: Routine Description:
916:
917: This routine sets up the initial init of the driver.
918:
919: Arguments:
920:
921: Adapter - The adapter for the hardware.
922:
923: Return Value:
924:
925: None.
926:
927: --*/
928:
929: {
930:
931: UINT Time = 50;
932:
933: //
934: // First we make sure that the device is stopped.
935: //
936:
937: SonicStopChip(Adapter);
938:
939: //
940: // Set up the registers.
941: //
942:
943: if (!SetupRegistersAndInit(Adapter)) {
944:
945: NdisWriteErrorLogEntry(
946: Adapter->NdisAdapterHandle,
947: NDIS_ERROR_CODE_ADAPTER_NOT_FOUND,
948: 3,
949: registerAdapter,
950: SONIC_ERRMSG_INITIAL_INIT
951: );
952:
953: return FALSE;
954:
955: }
956:
957:
958: //
959: // Delay execution for 1/2 second to give the sonic
960: // time to initialize.
961: //
962:
963: while (Time > 0) {
964:
965: if (!Adapter->FirstInitialization) {
966: break;
967: }
968:
969: NdisStallExecution(10000);
970: Time--;
971:
972: }
973:
974:
975: //
976: // The only way that first initialization could have
977: // been turned off is if we actually initialized.
978: //
979:
980: if (!Adapter->FirstInitialization) {
981:
982: //
983: // We actually did get the initialization.
984: //
985: // We can start the chip. We may not
986: // have any bindings to indicate to but this
987: // is unimportant.
988: //
989:
990: SonicStartChip(Adapter);
991:
992: return TRUE;
993:
994:
995: } else {
996:
997: NdisWriteErrorLogEntry(
998: Adapter->NdisAdapterHandle,
999: NDIS_ERROR_CODE_TIMEOUT,
1000: 2,
1001: registerAdapter,
1002: SONIC_ERRMSG_INITIAL_INIT
1003: );
1004:
1005: return FALSE;
1006:
1007: }
1008:
1009: }
1010:
1011: STATIC
1012: BOOLEAN
1013: SonicSynchClearIsr(
1014: IN PVOID Context
1015: )
1016:
1017: /*++
1018:
1019: Routine Description:
1020:
1021: This routine is used during a reset. It ensures that no
1022: interrupts will come through, and that any DPRs that run
1023: will find no interrupts to process.
1024:
1025: Arguments:
1026:
1027: Context - A pointer to a SONIC_ADAPTER structure.
1028:
1029: Return Value:
1030:
1031: Always returns true.
1032:
1033: --*/
1034:
1035: {
1036:
1037: PSONIC_ADAPTER Adapter = (PSONIC_ADAPTER)Context;
1038:
1039: SONIC_WRITE_PORT(Adapter, SONIC_INTERRUPT_STATUS, 0xffff);
1040: Adapter->IsrValue = 0;
1041:
1042: return TRUE;
1043:
1044: }
1045:
1046: extern
1047: VOID
1048: SonicStartChip(
1049: IN PSONIC_ADAPTER Adapter
1050: )
1051:
1052: /*++
1053:
1054: Routine Description:
1055:
1056: This routine is used to start an already initialized sonic.
1057:
1058: Arguments:
1059:
1060: Adapter - The adapter for the SONIC to start.
1061:
1062: Return Value:
1063:
1064: None.
1065:
1066: --*/
1067:
1068: {
1069:
1070: //
1071: // Take us out of reset mode if we are in it.
1072: //
1073:
1074: SONIC_WRITE_PORT(Adapter, SONIC_COMMAND,
1075: 0x0000
1076: );
1077:
1078: SONIC_WRITE_PORT(Adapter, SONIC_COMMAND,
1079: SONIC_CR_RECEIVER_ENABLE
1080: );
1081:
1082: }
1083:
1084: STATIC
1085: VOID
1086: SonicStopChip(
1087: IN PSONIC_ADAPTER Adapter
1088: )
1089:
1090: /*++
1091:
1092: Routine Description:
1093:
1094: This routine is used to stop a sonic.
1095:
1096: This routine is *not* portable. It is specific to the 386
1097: implementation of the sonic. On the bus master card the ACON bit
1098: must be set in csr3, whereas on the decstation, csr3 remains clear.
1099:
1100: Arguments:
1101:
1102: Adapter - The adapter for the SONIC to stop.
1103:
1104: Return Value:
1105:
1106: None.
1107:
1108: --*/
1109:
1110: {
1111:
1112: SONIC_WRITE_PORT(Adapter, SONIC_COMMAND,
1113: SONIC_CR_RECEIVER_DISABLE |
1114: SONIC_CR_SOFTWARE_RESET
1115: );
1116:
1117: }
1118:
1119: extern
1120: VOID
1121: SonicStartCamReload(
1122: IN PSONIC_ADAPTER Adapter
1123: )
1124:
1125: /*++
1126:
1127: Routine Description:
1128:
1129: This routine starts a CAM reload, which will cause an
1130: interrupt when it is done.
1131:
1132: Arguments:
1133:
1134: Adapter - The adapter for the SONIC to reload.
1135:
1136: Return Value:
1137:
1138: None.
1139:
1140: --*/
1141:
1142: {
1143:
1144: //
1145: // Move CAM Enable into the appropriate spot.
1146: //
1147:
1148: SONIC_LOAD_CAM_ENABLE(
1149: &Adapter->CamDescriptorArea->CamFragments[
1150: Adapter->CamDescriptorAreaSize],
1151: Adapter->CamDescriptorArea->CamEnable
1152: );
1153:
1154:
1155: //
1156: // Flush the CAM before we start the reload.
1157: //
1158:
1159: SONIC_FLUSH_WRITE_BUFFER(Adapter->CamDescriptorAreaFlushBuffer);
1160:
1161:
1162: SONIC_WRITE_PORT(Adapter, SONIC_CAM_DESCRIPTOR,
1163: SONIC_GET_LOW_PART_ADDRESS(Adapter->CamDescriptorAreaPhysical)
1164: );
1165:
1166: SONIC_WRITE_PORT(Adapter, SONIC_CAM_DESCRIPTOR_COUNT,
1167: (USHORT)Adapter->CamDescriptorAreaSize
1168: );
1169:
1170:
1171: //
1172: // Start the Load CAM, which will cause an interrupt
1173: // when it is done.
1174: //
1175:
1176: SONIC_WRITE_PORT(Adapter, SONIC_COMMAND,
1177: SONIC_CR_LOAD_CAM
1178: );
1179:
1180: }
1181:
1182: STATIC
1183: NDIS_STATUS
1184: SonicOpenAdapter(
1185: OUT PNDIS_STATUS OpenErrorStatus,
1186: OUT NDIS_HANDLE *MacBindingHandle,
1187: OUT PUINT SelectedMediumIndex,
1188: IN PNDIS_MEDIUM MediumArray,
1189: IN UINT MediumArraySize,
1190: IN NDIS_HANDLE NdisBindingContext,
1191: IN NDIS_HANDLE MacAdapterContext,
1192: IN UINT OpenOptions,
1193: IN PSTRING AddressingInformation OPTIONAL
1194: )
1195:
1196: /*++
1197:
1198: Routine Description:
1199:
1200: This routine is used to create an open instance of an adapter, in effect
1201: creating a binding between an upper-level module and the MAC module over
1202: the adapter.
1203:
1204: Arguments:
1205:
1206: OpenErrorStatus - Returns more information in some cases.
1207:
1208: MacBindingHandle - A pointer to a location in which the MAC stores
1209: a context value that it uses to represent this binding.
1210:
1211: SelectedMediumIndex - A pointer to a location in which the MAC stores
1212: the medium selected out of MediumArray.
1213:
1214: MediumArray - An array of media that the protocol can support.
1215:
1216: MediumArraySize - The number of elements in MediumArray.
1217:
1218: NdisBindingContext - A value to be recorded by the MAC and passed as
1219: context whenever an indication is delivered by the MAC for this binding.
1220:
1221: MacAdapterContext - The value associated with the adapter that is being
1222: opened when the MAC registered the adapter with NdisRegisterAdapter.
1223:
1224: OpenOptions - A bit mask containing flags with information about this
1225: binding.
1226:
1227: AddressingInformation - An optional pointer to a variable length string
1228: containing hardware-specific information that can be used to program the
1229: device. (This is not used by this MAC.)
1230:
1231: Return Value:
1232:
1233: The function value is the status of the operation. If the MAC does not
1234: complete this request synchronously, the value would be
1235: NDIS_STATUS_PENDING.
1236:
1237:
1238: --*/
1239:
1240: {
1241:
1242: //
1243: // The SONIC_ADAPTER that this open binding should belong too.
1244: //
1245: PSONIC_ADAPTER Adapter;
1246:
1247: //
1248: // Holds the status that should be returned to the caller.
1249: //
1250: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
1251:
1252: //
1253: // Simple iteration variable, for scanning the medium array.
1254: //
1255: UINT i;
1256:
1257: //
1258: // Pointer to the space allocated for the binding.
1259: //
1260: PSONIC_OPEN NewOpen;
1261:
1262: //
1263: // Points to the MacReserved section of NewOpen->OpenCloseRequest.
1264: //
1265: PSONIC_REQUEST_RESERVED Reserved;
1266:
1267:
1268: //
1269: // If we are being removed, don't allow new opens.
1270: //
1271:
1272: Adapter = PSONIC_ADAPTER_FROM_CONTEXT_HANDLE(MacAdapterContext);
1273:
1274: if (Adapter->Removed) {
1275: return NDIS_STATUS_FAILURE;
1276: }
1277:
1278:
1279: //
1280: // Search for the 802.3 media type
1281: //
1282:
1283: for (i=0; i<MediumArraySize; i++) {
1284:
1285: if (MediumArray[i] == NdisMedium802_3) {
1286: break;
1287: }
1288:
1289: }
1290:
1291: if (i == MediumArraySize) {
1292:
1293: return NDIS_STATUS_UNSUPPORTED_MEDIA;
1294:
1295: }
1296:
1297: *SelectedMediumIndex = i;
1298:
1299:
1300: NdisAcquireSpinLock(&Adapter->Lock);
1301: Adapter->References++;
1302:
1303: NdisReleaseSpinLock(&Adapter->Lock);
1304:
1305: //
1306: // Allocate the space for the open binding. Fill in the fields.
1307: //
1308:
1309: SONIC_ALLOC_MEMORY(&StatusToReturn, &NewOpen, sizeof(SONIC_OPEN));
1310:
1311: if (StatusToReturn == NDIS_STATUS_SUCCESS) {
1312:
1313: *MacBindingHandle = BINDING_HANDLE_FROM_PSONIC_OPEN(NewOpen);
1314: InitializeListHead(&NewOpen->OpenList);
1315: NewOpen->NdisBindingContext = NdisBindingContext;
1316: NewOpen->References = 1;
1317: NewOpen->BindingShuttingDown = FALSE;
1318: NewOpen->OwningSonic = Adapter;
1319:
1320: NewOpen->OpenCloseRequest.RequestType = NdisRequestOpen;
1321: Reserved = PSONIC_RESERVED_FROM_REQUEST(&NewOpen->OpenCloseRequest);
1322: Reserved->OpenBlock = NewOpen;
1323: Reserved->Next = (PNDIS_REQUEST)NULL;
1324:
1325: NdisAcquireSpinLock(&Adapter->Lock);
1326:
1327: SonicQueueRequest(Adapter, &NewOpen->OpenCloseRequest);
1328:
1329: StatusToReturn = NDIS_STATUS_PENDING;
1330:
1331: } else {
1332:
1333: NdisWriteErrorLogEntry(
1334: Adapter->NdisAdapterHandle,
1335: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
1336: 2,
1337: openAdapter,
1338: SONIC_ERRMSG_ALLOC_OPEN
1339: );
1340:
1341:
1342: NdisAcquireSpinLock(&Adapter->Lock);
1343:
1344: }
1345:
1346:
1347: //
1348: // This macro assumes it is called with the lock held,
1349: // and releases it.
1350: //
1351:
1352: SONIC_DO_DEFERRED(Adapter);
1353: return StatusToReturn;
1354: }
1355:
1356: STATIC
1357: NDIS_STATUS
1358: SonicCloseAdapter(
1359: IN NDIS_HANDLE MacBindingHandle
1360: )
1361:
1362: /*++
1363:
1364: Routine Description:
1365:
1366: This routine causes the MAC to close an open handle (binding).
1367:
1368: Arguments:
1369:
1370: MacBindingHandle - The context value returned by the MAC when the
1371: adapter was opened. In reality it is a PSONIC_OPEN.
1372:
1373: Return Value:
1374:
1375: The function value is the status of the operation.
1376:
1377:
1378: --*/
1379:
1380: {
1381:
1382: //
1383: // The SONIC_ADAPTER that this open binding should belong too.
1384: //
1385: PSONIC_ADAPTER Adapter;
1386:
1387: //
1388: // Holds the status that should be returned to the caller.
1389: //
1390: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
1391:
1392: //
1393: // Pointer to the space allocated for the binding.
1394: //
1395: PSONIC_OPEN Open;
1396:
1397:
1398: Adapter = PSONIC_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
1399:
1400: //
1401: // Hold the lock while we update the reference counts for the
1402: // adapter and the open.
1403: //
1404:
1405: NdisAcquireSpinLock(&Adapter->Lock);
1406: Adapter->References++;
1407:
1408: Open = PSONIC_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
1409:
1410: //
1411: // Don't do anything if this binding is already closing.
1412: //
1413:
1414: if (!Open->BindingShuttingDown) {
1415:
1416: PSONIC_REQUEST_RESERVED Reserved = PSONIC_RESERVED_FROM_REQUEST(&Open->OpenCloseRequest);
1417:
1418: Open->OpenCloseRequest.RequestType = NdisRequestClose;
1419: Reserved->OpenBlock = Open;
1420: Reserved->Next = (PNDIS_REQUEST)NULL;
1421:
1422: ++Open->References;
1423:
1424: SonicQueueRequest(Adapter, &Open->OpenCloseRequest);
1425:
1426: //
1427: // Remove the creation reference.
1428: //
1429:
1430: --Open->References;
1431:
1432: StatusToReturn = NDIS_STATUS_PENDING;
1433:
1434: } else {
1435:
1436: StatusToReturn = NDIS_STATUS_CLOSING;
1437:
1438: }
1439:
1440: //
1441: // This macro assumes it is called with the lock held,
1442: // and releases it.
1443: //
1444:
1445: SONIC_DO_DEFERRED(Adapter);
1446: return StatusToReturn;
1447:
1448: }
1449:
1450: STATIC
1451: VOID
1452: SonicUnload(
1453: IN NDIS_HANDLE MacMacContext
1454: )
1455:
1456: /*++
1457:
1458: Routine Description:
1459:
1460: SonicUnload is called when the MAC is to unload itself.
1461:
1462: Arguments:
1463:
1464: None.
1465:
1466: Return Value:
1467:
1468: None.
1469:
1470: --*/
1471:
1472: {
1473:
1474: NDIS_STATUS Status;
1475:
1476: PSONIC_MAC SonicMac = (PSONIC_MAC)MacMacContext;
1477:
1478:
1479: NdisDeregisterMac(
1480: &Status,
1481: SonicMac->MacHandle
1482: );
1483:
1484: NdisTerminateWrapper(
1485: SonicMac->WrapperHandle,
1486: NULL
1487: );
1488:
1489: return;
1490:
1491: }
1492:
1493:
1494: STATIC
1495: NDIS_STATUS
1496: SonicAddAdapter(
1497: IN NDIS_HANDLE MacMacContext,
1498: IN NDIS_HANDLE ConfigurationHandle,
1499: IN PNDIS_STRING AdapterName
1500: )
1501:
1502: /*++
1503:
1504: Routine Description:
1505:
1506: SonicAddAdapter adds an adapter to the list supported
1507: by this MAC.
1508:
1509: Arguments:
1510:
1511: MacMacContext - The context passed to NdisRegisterMac (will be NULL).
1512:
1513: ConfigurationHandle - A handle to pass to NdisOpenConfiguration.
1514:
1515: AdapterName - The name to register with via NdisRegisterAdapter.
1516:
1517: Return Value:
1518:
1519: NDIS_STATUS_SUCCESS
1520: NDIS_STATUS_PENDING
1521:
1522: --*/
1523:
1524: {
1525:
1526: NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
1527: PSONIC_MAC SonicMac = (PSONIC_MAC)MacMacContext;
1528: NDIS_HANDLE ConfigHandle;
1529: NDIS_STRING AdapterTypeString = NDIS_STRING_CONST("AdapterType");
1530: #ifdef SONIC_INTERNAL
1531: NDIS_STRING MultifunctionAdapterString = NDIS_STRING_CONST("MultifunctionAdapter");
1532: NDIS_STRING NetworkControllerString = NDIS_STRING_CONST("NetworkController");
1533: #endif
1534: PNDIS_CONFIGURATION_PARAMETER ReturnedValue;
1535: PUCHAR NetworkAddress;
1536: UINT NetworkAddressLength;
1537: UCHAR AdapterType;
1538: UINT InterruptVector;
1539: UINT InterruptLevel;
1540: NDIS_INTERRUPT_MODE InterruptMode;
1541: UINT SlotNumber;
1542: UINT Controller = 0;
1543: UINT MultifunctionAdapter = 0;
1544:
1545: //
1546: // Open the configuration info.
1547: //
1548:
1549: NdisOpenConfiguration(
1550: &Status,
1551: &ConfigHandle,
1552: ConfigurationHandle
1553: );
1554:
1555: if (Status != NDIS_STATUS_SUCCESS) {
1556: return Status;
1557: }
1558:
1559:
1560: //
1561: // Check that adapter type is supported.
1562: // The default depends on the processor type.
1563: //
1564:
1565: AdapterType = SONIC_ADAPTER_TYPE_DEFAULT;
1566:
1567: NdisReadConfiguration(
1568: &Status,
1569: &ReturnedValue,
1570: ConfigHandle,
1571: &AdapterTypeString,
1572: NdisParameterInteger
1573: );
1574:
1575: if (Status == NDIS_STATUS_SUCCESS) {
1576:
1577: //
1578: // See if the adapter type is valid. We skip to AdapterTypeRecognized
1579: // if the AdapterType is known to this driver.
1580: //
1581:
1582: #ifdef SONIC_EISA
1583: if (ReturnedValue->ParameterData.IntegerData == SONIC_ADAPTER_TYPE_EISA) {
1584: goto AdapterTypeRecognized;
1585: }
1586: #endif
1587:
1588: #ifdef SONIC_INTERNAL
1589: if (ReturnedValue->ParameterData.IntegerData == SONIC_ADAPTER_TYPE_INTERNAL) {
1590: goto AdapterTypeRecognized;
1591: }
1592: #endif
1593:
1594: //
1595: // Card type not supported by this driver
1596: //
1597:
1598: #if DBG
1599: DbgPrint("SONIC: Error in adapter type: %lx\n", ReturnedValue->ParameterData.IntegerData);
1600: #endif
1601: NdisCloseConfiguration(ConfigHandle);
1602: return NDIS_STATUS_FAILURE;
1603:
1604:
1605: AdapterTypeRecognized:
1606:
1607: AdapterType = (UCHAR)ReturnedValue->ParameterData.IntegerData;
1608: }
1609:
1610: switch (AdapterType) {
1611:
1612: #ifdef SONIC_EISA
1613:
1614: case SONIC_ADAPTER_TYPE_EISA:
1615: {
1616:
1617: NDIS_EISA_FUNCTION_INFORMATION EisaData;
1618: USHORT Portzc88;
1619: UCHAR zc88Value;
1620: UCHAR Mask;
1621: UCHAR InitType;
1622: UCHAR PortValue;
1623: USHORT PortAddress;
1624: PUCHAR CurrentChar;
1625: BOOLEAN LastEntry;
1626:
1627: NdisReadEisaSlotInformation(
1628: &Status,
1629: ConfigurationHandle,
1630: &SlotNumber,
1631: &EisaData
1632: );
1633:
1634: if (Status != NDIS_STATUS_SUCCESS) {
1635:
1636: #if DBG
1637: DbgPrint("SONIC: Could not read EISA data\n");
1638: #endif
1639: NdisCloseConfiguration(ConfigHandle);
1640: return NDIS_STATUS_FAILURE;
1641:
1642: }
1643:
1644: CurrentChar = EisaData.InitializationData;
1645:
1646: Portzc88 = (SlotNumber << 12) + 0xc88;
1647:
1648: LastEntry = FALSE;
1649: while (!LastEntry) {
1650: InitType = *(CurrentChar++);
1651: PortAddress = *((USHORT UNALIGNED *)CurrentChar);
1652: CurrentChar += sizeof(USHORT);
1653:
1654: if ((InitType & 0x80) == 0) {
1655: LastEntry = TRUE;
1656: }
1657:
1658: PortValue = *(CurrentChar++);
1659:
1660: if (InitType & 0x40) {
1661: Mask = *(CurrentChar++);
1662: } else {
1663: Mask = 0;
1664: }
1665:
1666: //
1667: // The only port we care about is zc88 (z is the
1668: // slot number) since it has the interrupt in it.
1669: //
1670:
1671: if (PortAddress != Portzc88) {
1672: continue;
1673: }
1674:
1675: zc88Value &= Mask;
1676: zc88Value |= PortValue;
1677:
1678: }
1679:
1680: switch ((zc88Value & 0x06) >> 1) {
1681: case 0:
1682: InterruptVector = 5; break;
1683: case 1:
1684: InterruptVector = 9; break;
1685: case 2:
1686: InterruptVector = 10; break;
1687: case 3:
1688: InterruptVector = 11; break;
1689: }
1690:
1691: InterruptLevel = InterruptVector;
1692:
1693: if ((zc88Value & 0x01) != 0) {
1694: InterruptMode = NdisInterruptLatched;
1695: } else {
1696: InterruptMode = NdisInterruptLevelSensitive;
1697: }
1698:
1699: break;
1700:
1701: }
1702:
1703: #endif // SONIC_EISA
1704:
1705: #ifdef SONIC_INTERNAL
1706:
1707: case SONIC_ADAPTER_TYPE_INTERNAL:
1708: {
1709:
1710: //
1711: // For the internal adapter, we read the MultifunctionAdapter number
1712: // and NetworkController number, which are both optional. For
1713: // passing to SonicRegisterAdapter.
1714: //
1715:
1716: NdisReadConfiguration(
1717: &Status,
1718: &ReturnedValue,
1719: ConfigHandle,
1720: &MultifunctionAdapterString,
1721: NdisParameterInteger
1722: );
1723:
1724: if (Status == NDIS_STATUS_SUCCESS) {
1725:
1726: MultifunctionAdapter = ReturnedValue->ParameterData.IntegerData;
1727:
1728: }
1729:
1730: NdisReadConfiguration(
1731: &Status,
1732: &ReturnedValue,
1733: ConfigHandle,
1734: &NetworkControllerString,
1735: NdisParameterInteger
1736: );
1737:
1738: if (Status == NDIS_STATUS_SUCCESS) {
1739:
1740: Controller = ReturnedValue->ParameterData.IntegerData;
1741:
1742: }
1743:
1744: //
1745: // These are filled in by SonicHardwareGetDetails.
1746: //
1747:
1748: InterruptVector = 0;
1749: InterruptLevel = 0;
1750:
1751: //
1752: // The internal adapter is level-sensitive.
1753: //
1754:
1755: InterruptMode = NdisInterruptLevelSensitive;
1756:
1757: break;
1758:
1759: }
1760:
1761: #endif // SONIC_INTERNAL
1762:
1763: default:
1764:
1765: ASSERT(FALSE);
1766: break;
1767:
1768: }
1769:
1770:
1771: //
1772: // Read network address
1773: //
1774:
1775: NdisReadNetworkAddress(
1776: &Status,
1777: (PVOID *)&NetworkAddress,
1778: &NetworkAddressLength,
1779: ConfigHandle);
1780:
1781:
1782: //
1783: // Make sure that the address is the right length asnd
1784: // at least one of the bytes is non-zero.
1785: //
1786:
1787: if ((Status == NDIS_STATUS_SUCCESS) &&
1788: (NetworkAddressLength == ETH_LENGTH_OF_ADDRESS) &&
1789: ((NetworkAddress[0] |
1790: NetworkAddress[1] |
1791: NetworkAddress[2] |
1792: NetworkAddress[3] |
1793: NetworkAddress[4] |
1794: NetworkAddress[5]) != 0)) {
1795:
1796: #if DBG
1797: if (SonicDbg) {
1798: DbgPrint("SONIC: New Address = %.2x-%.2x-%.2x-%.2x-%.2x-%.2x\n",
1799: NetworkAddress[0],
1800: NetworkAddress[1],
1801: NetworkAddress[2],
1802: NetworkAddress[3],
1803: NetworkAddress[4],
1804: NetworkAddress[5]);
1805: }
1806: #endif
1807:
1808: } else {
1809:
1810: //
1811: // Tells SonicRegisterAdapter to use the
1812: // burned-in address.
1813: //
1814:
1815: NetworkAddress = NULL;
1816:
1817: }
1818:
1819: //
1820: // Used passed-in adapter name to register.
1821: //
1822:
1823: Status = SonicRegisterAdapter(
1824: SonicMac->MacHandle,
1825: ConfigurationHandle,
1826: AdapterName,
1827: NetworkAddress,
1828: AdapterType,
1829: SlotNumber,
1830: Controller,
1831: MultifunctionAdapter,
1832: InterruptVector,
1833: InterruptLevel,
1834: InterruptMode,
1835: 32);
1836:
1837:
1838: NdisCloseConfiguration(ConfigHandle);
1839:
1840:
1841: return Status; // should be NDIS_STATUS_SUCCESS
1842:
1843: }
1844:
1845: STATIC
1846: VOID
1847: SonicRemoveAdapter(
1848: IN NDIS_HANDLE MacAdapterContext
1849: )
1850:
1851: /*++
1852:
1853: Routine Description:
1854:
1855: SonicRemoveAdapter removes an adapter previously registered
1856: with NdisRegisterAdapter.
1857:
1858: Arguments:
1859:
1860: MacAdapterContext - The context value that the MAC passed
1861: to NdisRegisterAdapter; actually as pointer to a
1862: SONIC_ADAPTER.
1863:
1864: Return Value:
1865:
1866: None.
1867:
1868: --*/
1869:
1870: {
1871: PSONIC_ADAPTER Adapter;
1872: BOOLEAN Canceled;
1873:
1874: Adapter = PSONIC_ADAPTER_FROM_CONTEXT_HANDLE(MacAdapterContext);
1875:
1876: Adapter->Removed = TRUE;
1877:
1878: //
1879: // Stop the chip.
1880: //
1881:
1882: SonicStopChip (Adapter);
1883:
1884: NdisDeregisterAdapterShutdownHandler(Adapter->NdisAdapterHandle);
1885:
1886: ASSERT (Adapter->OpenCount == 0);
1887:
1888: //
1889: // There are no opens left, so remove ourselves.
1890: //
1891:
1892: //
1893: // Stop the deadman timer
1894: //
1895:
1896: NdisCancelTimer(&Adapter->WakeUpTimer, &Canceled);
1897:
1898: if ( !Canceled ) {
1899: NdisStallExecution(500000);
1900: }
1901:
1902: NdisRemoveInterrupt(&Adapter->Interrupt);
1903:
1904: EthDeleteFilter(Adapter->FilterDB);
1905:
1906: DeleteAdapterMemory(Adapter);
1907: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
1908:
1909: NdisFreeSpinLock(&Adapter->Lock);
1910: SONIC_FREE_MEMORY(Adapter, sizeof(SONIC_ADAPTER));
1911:
1912: }
1913:
1914: STATIC
1915: NDIS_STATUS
1916: SonicReset(
1917: IN NDIS_HANDLE MacBindingHandle
1918: )
1919:
1920: /*++
1921:
1922: Routine Description:
1923:
1924: The SonicReset request instructs the MAC to issue a hardware reset
1925: to the network adapter. The MAC also resets its software state. See
1926: the description of NdisReset for a detailed description of this request.
1927:
1928: Arguments:
1929:
1930: MacBindingHandle - The context value returned by the MAC when the
1931: adapter was opened. In reality, it is a pointer to SONIC_OPEN.
1932:
1933: Return Value:
1934:
1935: The function value is the status of the operation.
1936:
1937:
1938: --*/
1939:
1940: {
1941:
1942: //
1943: // Holds the status that should be returned to the caller.
1944: //
1945: NDIS_STATUS StatusToReturn = NDIS_STATUS_PENDING;
1946:
1947: PSONIC_ADAPTER Adapter =
1948: PSONIC_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
1949:
1950: //
1951: // Hold the locks while we update the reference counts on the
1952: // adapter and the open.
1953: //
1954:
1955: if (Adapter->Removed) {
1956:
1957: return(NDIS_STATUS_FAILURE);
1958:
1959: }
1960:
1961: NdisAcquireSpinLock(&Adapter->Lock);
1962:
1963: Adapter->References++;
1964:
1965: if (!Adapter->ResetInProgress && !Adapter->IndicatingResetStart) {
1966:
1967: PSONIC_OPEN Open;
1968:
1969: Open = PSONIC_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
1970:
1971: if (!Open->BindingShuttingDown) {
1972:
1973: Adapter->IndicatingResetStart = TRUE;
1974:
1975: if (!Adapter->IndicatingResetEnd) {
1976:
1977: //
1978: // Loop through, indicating RESET_START; we
1979: // don't bother with the StatusComplete
1980: // indication until RESET_END is indicated.
1981: //
1982:
1983: PSONIC_OPEN Open;
1984: PLIST_ENTRY CurrentLink;
1985:
1986: CurrentLink = Adapter->OpenBindings.Flink;
1987:
1988: while (CurrentLink != &Adapter->OpenBindings) {
1989:
1990: Open = CONTAINING_RECORD(
1991: CurrentLink,
1992: SONIC_OPEN,
1993: OpenList
1994: );
1995:
1996: Open->References++;
1997: NdisReleaseSpinLock(&Adapter->Lock);
1998:
1999: NdisIndicateStatus(
2000: Open->NdisBindingContext,
2001: NDIS_STATUS_RESET_START,
2002: NULL,
2003: 0
2004: );
2005:
2006: NdisAcquireSpinLock(&Adapter->Lock);
2007: Open->References--;
2008:
2009: CurrentLink = CurrentLink->Flink;
2010:
2011: }
2012:
2013:
2014: Adapter->IndicatingResetStart = FALSE;
2015:
2016: SetupForReset(
2017: Adapter,
2018: PSONIC_OPEN_FROM_BINDING_HANDLE(MacBindingHandle)
2019: );
2020: }
2021:
2022: Open->References++;
2023: Adapter->ResettingOpen = Open;
2024:
2025: StatusToReturn = NDIS_STATUS_PENDING;
2026:
2027: } else {
2028:
2029: StatusToReturn = NDIS_STATUS_CLOSING;
2030:
2031: }
2032:
2033: } else {
2034:
2035: StatusToReturn = NDIS_STATUS_RESET_IN_PROGRESS;
2036:
2037: }
2038:
2039:
2040: //
2041: // This macro assumes it is called with the lock held,
2042: // and releases it.
2043: //
2044:
2045: SONIC_DO_DEFERRED(Adapter);
2046: return StatusToReturn;
2047:
2048: }
2049:
2050: #if 0
2051: STATIC
2052: UINT
2053: CalculateCRC(
2054: IN UINT NumberOfBytes,
2055: IN PCHAR Input
2056: )
2057:
2058: /*++
2059:
2060: Routine Description:
2061:
2062: Calculates a 32 bit crc value over the input number of bytes.
2063:
2064: NOTE: This routine assumes UINTs are 32 bits.
2065:
2066: Arguments:
2067:
2068: NumberOfBytes - The number of bytes in the input.
2069:
2070: Input - An input "string" to calculate a CRC over.
2071:
2072: Return Value:
2073:
2074: A 32 bit crc value.
2075:
2076:
2077: --*/
2078:
2079: {
2080:
2081: const UINT POLY = 0x04c11db6;
2082: UINT CRCValue = 0xffffffff;
2083:
2084: ASSERT(sizeof(UINT) == 4);
2085:
2086: for (
2087: ;
2088: NumberOfBytes;
2089: NumberOfBytes--
2090: ) {
2091:
2092: UINT CurrentBit;
2093: UCHAR CurrentByte = *Input;
2094: Input++;
2095:
2096: for (
2097: CurrentBit = 8;
2098: CurrentBit;
2099: CurrentBit--
2100: ) {
2101:
2102: UINT CurrentCRCHigh = CRCValue >> 31;
2103:
2104: CRCValue <<= 1;
2105:
2106: if (CurrentCRCHigh ^ (CurrentByte & 0x01)) {
2107:
2108: CRCValue ^= POLY;
2109: CRCValue |= 0x00000001;
2110:
2111: }
2112:
2113: CurrentByte >>= 1;
2114:
2115: }
2116:
2117: }
2118:
2119: return CRCValue;
2120:
2121: }
2122: #endif
2123:
2124: extern
2125: VOID
2126: StartAdapterReset(
2127: IN PSONIC_ADAPTER Adapter
2128: )
2129:
2130: /*++
2131:
2132: Routine Description:
2133:
2134: This is the first phase of resetting the adapter hardware.
2135:
2136: It makes the following assumptions:
2137:
2138: 1) That the hardware has been stopped.
2139:
2140: 2) That it can not be preempted.
2141:
2142: 3) That no other adapter activity can occur.
2143:
2144: When this routine is finished all of the adapter information
2145: will be as if the driver was just initialized.
2146:
2147: Arguments:
2148:
2149: Adapter - The adapter whose hardware is to be reset.
2150:
2151: Return Value:
2152:
2153: None.
2154:
2155: --*/
2156: {
2157:
2158: //
2159: // These are used for cleaning the rings.
2160: //
2161:
2162: PSONIC_RECEIVE_DESCRIPTOR CurrentReceiveDescriptor;
2163: PSONIC_TRANSMIT_DESCRIPTOR CurrentTransmitDescriptor;
2164: UINT i;
2165: SONIC_PHYSICAL_ADDRESS SonicPhysicalAdr;
2166:
2167:
2168: //
2169: // Shut down the chip. We won't be doing any more work until
2170: // the reset is complete.
2171: //
2172:
2173: SonicStopChip(Adapter);
2174:
2175: //
2176: // Once the chip is stopped we can't get any more interrupts.
2177: // Any interrupts that are "queued" for processing could
2178: // only possibly service this reset. It is therefore safe for
2179: // us to clear the adapter global csr value.
2180: //
2181: Adapter->IsrValue = 0;
2182:
2183:
2184: Adapter->LastTransmitDescriptor =
2185: Adapter->TransmitDescriptorArea +
2186: (Adapter->NumberOfTransmitDescriptors-1);
2187: Adapter->NumberOfAvailableDescriptors =
2188: Adapter->NumberOfTransmitDescriptors;
2189: Adapter->AllocateableDescriptor =
2190: Adapter->TransmitDescriptorArea;
2191: Adapter->TransmittingDescriptor =
2192: Adapter->TransmitDescriptorArea;
2193: Adapter->FirstUncommittedDescriptor =
2194: Adapter->TransmitDescriptorArea;
2195: Adapter->PacketsSinceLastInterrupt = 0;
2196:
2197: Adapter->CurrentReceiveBufferIndex = 0;
2198: Adapter->CurrentReceiveDescriptorIndex = 0;
2199: Adapter->LastReceiveDescriptor =
2200: &Adapter->ReceiveDescriptorArea[
2201: Adapter->NumberOfReceiveDescriptors-1];
2202:
2203: Adapter->InterruptMaskRegister = SONIC_INT_DEFAULT_VALUE;
2204: Adapter->ReceiveDescriptorsExhausted = FALSE;
2205: Adapter->ReceiveBuffersExhausted = FALSE;
2206: Adapter->ReceiveControlRegister = SONIC_RCR_DEFAULT_VALUE;
2207:
2208: Adapter->SendStageOpen = TRUE;
2209:
2210: Adapter->AlreadyProcessingSendStage = FALSE;
2211:
2212: //
2213: // Clean the receive descriptors and initialize the link
2214: // fields.
2215: //
2216:
2217: SONIC_ZERO_MEMORY(
2218: Adapter->ReceiveDescriptorArea,
2219: (sizeof(SONIC_RECEIVE_DESCRIPTOR)*Adapter->NumberOfReceiveDescriptors)
2220: );
2221:
2222: for (
2223: i = 0, CurrentReceiveDescriptor = Adapter->ReceiveDescriptorArea;
2224: i < Adapter->NumberOfReceiveDescriptors;
2225: i++,CurrentReceiveDescriptor++
2226: ) {
2227:
2228: CurrentReceiveDescriptor->InUse = SONIC_OWNED_BY_SONIC;
2229:
2230: SonicPhysicalAdr = NdisGetPhysicalAddressLow(Adapter->ReceiveDescriptorAreaPhysical) +
2231: (i * sizeof(SONIC_RECEIVE_DESCRIPTOR));
2232:
2233: if (i == 0) {
2234:
2235: Adapter->ReceiveDescriptorArea[
2236: Adapter->NumberOfReceiveDescriptors-1].Link =
2237: SonicPhysicalAdr | SONIC_END_OF_LIST;
2238:
2239: } else {
2240:
2241: Adapter->ReceiveDescriptorArea[i-1].Link = SonicPhysicalAdr;
2242:
2243: }
2244:
2245: }
2246:
2247:
2248: //
2249: // Clean the transmit descriptors and initialize the link
2250: // fields.
2251: //
2252:
2253: SONIC_ZERO_MEMORY(
2254: Adapter->TransmitDescriptorArea,
2255: (sizeof(SONIC_TRANSMIT_DESCRIPTOR)*Adapter->NumberOfTransmitDescriptors)
2256: );
2257:
2258: for (
2259: i = 0, CurrentTransmitDescriptor = Adapter->TransmitDescriptorArea;
2260: i < Adapter->NumberOfTransmitDescriptors;
2261: i++,CurrentTransmitDescriptor++
2262: ) {
2263:
2264: SonicPhysicalAdr = NdisGetPhysicalAddressLow(Adapter->TransmitDescriptorAreaPhysical) +
2265: (i * sizeof(SONIC_TRANSMIT_DESCRIPTOR));
2266:
2267: if (i == 0) {
2268:
2269: Adapter->TransmitDescriptorArea[Adapter->NumberOfTransmitDescriptors-1].Link = SonicPhysicalAdr;
2270:
2271: } else {
2272:
2273: (CurrentTransmitDescriptor-1)->Link = SonicPhysicalAdr;
2274:
2275: }
2276:
2277: }
2278:
2279:
2280: //
2281: // Recover all of the adapter buffers.
2282: //
2283:
2284: {
2285:
2286: UINT i;
2287:
2288: for (
2289: i = 0;
2290: i < (SONIC_NUMBER_OF_SMALL_BUFFERS +
2291: SONIC_NUMBER_OF_MEDIUM_BUFFERS +
2292: SONIC_NUMBER_OF_LARGE_BUFFERS);
2293: i++
2294: ) {
2295:
2296: Adapter->SonicBuffers[i].Next = i+1;
2297:
2298: }
2299:
2300: Adapter->SonicBufferListHeads[0] = -1;
2301: Adapter->SonicBufferListHeads[1] = 0;
2302: Adapter->SonicBuffers[SONIC_NUMBER_OF_SMALL_BUFFERS-1].Next = -1;
2303: Adapter->SonicBufferListHeads[2] = SONIC_NUMBER_OF_SMALL_BUFFERS;
2304: Adapter->SonicBuffers[(SONIC_NUMBER_OF_SMALL_BUFFERS+
2305: SONIC_NUMBER_OF_MEDIUM_BUFFERS)-1].Next = -1;
2306: Adapter->SonicBufferListHeads[3] = SONIC_NUMBER_OF_SMALL_BUFFERS +
2307: SONIC_NUMBER_OF_MEDIUM_BUFFERS;
2308: Adapter->SonicBuffers[(SONIC_NUMBER_OF_SMALL_BUFFERS+
2309: SONIC_NUMBER_OF_MEDIUM_BUFFERS+
2310: SONIC_NUMBER_OF_LARGE_BUFFERS)-1].Next = -1;
2311:
2312: }
2313:
2314: //
2315: // Go through the various transmit lists and abort every packet.
2316: //
2317:
2318: {
2319:
2320: UINT i;
2321: PNDIS_PACKET Packet;
2322: PSONIC_PACKET_RESERVED Reserved;
2323: PSONIC_OPEN Open;
2324: PNDIS_PACKET Next;
2325:
2326: for (
2327: i = 0;
2328: i < 3;
2329: i++
2330: ) {
2331:
2332: switch (i) {
2333:
2334: case 0:
2335: Next = Adapter->FirstLoopBack;
2336: break;
2337: case 1:
2338: Next = Adapter->FirstFinishTransmit;
2339: break;
2340: case 2:
2341: Next = Adapter->FirstSendStagePacket;
2342: break;
2343:
2344: }
2345:
2346:
2347: while (Next) {
2348:
2349: Packet = Next;
2350: Reserved = PSONIC_RESERVED_FROM_PACKET(Packet);
2351: Next = Reserved->Next;
2352: Open =
2353: PSONIC_OPEN_FROM_BINDING_HANDLE(Reserved->MacBindingHandle);
2354:
2355: //
2356: // The completion of the packet is one less reason
2357: // to keep the open around.
2358: //
2359:
2360: ASSERT(Open->References);
2361:
2362: NdisCompleteSend(
2363: Open->NdisBindingContext,
2364: Packet,
2365: NDIS_STATUS_REQUEST_ABORTED
2366: );
2367:
2368: Open->References--;
2369:
2370: }
2371:
2372: }
2373:
2374: Adapter->FirstLoopBack = NULL;
2375: Adapter->LastLoopBack = NULL;
2376: Adapter->FirstFinishTransmit = NULL;
2377: Adapter->LastFinishTransmit = NULL;
2378: Adapter->FirstSendStagePacket = NULL;
2379: Adapter->LastSendStagePacket = NULL;
2380: Adapter->GeneralOptional[GO_TRANSMIT_QUEUE_LENGTH - GO_ARRAY_START] = 0;
2381:
2382: }
2383:
2384: (VOID)SetupRegistersAndInit(Adapter);
2385:
2386: }
2387:
2388: STATIC
2389: BOOLEAN
2390: SetupRegistersAndInit(
2391: IN PSONIC_ADAPTER Adapter
2392: )
2393:
2394: /*++
2395:
2396: Routine Description:
2397:
2398: It is this routines responsibility to make sure that the
2399: initialization block is filled and the chip is initialized
2400: *but not* started.
2401:
2402: NOTE: This routine assumes that it is called with the lock
2403: acquired OR that only a single thread of execution is working
2404: with this particular adapter.
2405:
2406: Arguments:
2407:
2408: Adapter - The adapter whose hardware is to be initialized.
2409:
2410: Return Value:
2411:
2412: TRUE if the registers are initialized successfully.
2413:
2414: --*/
2415: {
2416:
2417: USHORT CommandRegister;
2418: UINT Time;
2419:
2420:
2421: SONIC_WRITE_PORT(Adapter, SONIC_DATA_CONFIGURATION,
2422: Adapter->DataConfigurationRegister
2423: );
2424:
2425: SONIC_WRITE_PORT(Adapter, SONIC_RECEIVE_CONTROL,
2426: Adapter->ReceiveControlRegister
2427: );
2428:
2429: SONIC_WRITE_PORT(Adapter, SONIC_INTERRUPT_MASK,
2430: Adapter->InterruptMaskRegister
2431: );
2432:
2433: SONIC_WRITE_PORT(Adapter, SONIC_INTERRUPT_STATUS,
2434: (USHORT)0xffff
2435: );
2436:
2437:
2438:
2439: SONIC_WRITE_PORT(Adapter, SONIC_UPPER_TRANSMIT_DESCRIPTOR,
2440: SONIC_GET_HIGH_PART_ADDRESS(
2441: NdisGetPhysicalAddressLow(Adapter->TransmitDescriptorAreaPhysical))
2442: );
2443:
2444: SONIC_WRITE_PORT(Adapter, SONIC_CURR_TRANSMIT_DESCRIPTOR,
2445: SONIC_GET_LOW_PART_ADDRESS(
2446: NdisGetPhysicalAddressLow(Adapter->TransmitDescriptorAreaPhysical))
2447: );
2448:
2449:
2450: SONIC_WRITE_PORT(Adapter, SONIC_UPPER_RECEIVE_DESCRIPTOR,
2451: SONIC_GET_HIGH_PART_ADDRESS(
2452: NdisGetPhysicalAddressLow(Adapter->ReceiveDescriptorAreaPhysical))
2453: );
2454:
2455: SONIC_WRITE_PORT(Adapter, SONIC_CURR_RECEIVE_DESCRIPTOR,
2456: SONIC_GET_LOW_PART_ADDRESS(
2457: NdisGetPhysicalAddressLow(Adapter->ReceiveDescriptorAreaPhysical))
2458: );
2459:
2460:
2461: //
2462: // The EOBC value cannot be odd (since the card register
2463: // wants it in words); in addition it appears that the
2464: // value in the register must be even, so this number
2465: // has to be a multiple of 4.
2466: //
2467: ASSERT((SONIC_END_OF_BUFFER_COUNT & 0x3) == 0);
2468:
2469: switch (Adapter->AdapterType) {
2470:
2471: #ifdef SONIC_EISA
2472:
2473: case SONIC_ADAPTER_TYPE_EISA:
2474:
2475: //
2476: // For the EISA card, set EOBC to 2 words more than real
2477: // size.
2478: //
2479:
2480: SONIC_WRITE_PORT(Adapter, SONIC_END_OF_BUFFER_WORD_COUNT,
2481: (SONIC_END_OF_BUFFER_COUNT / 2) + 2
2482: );
2483: break;
2484:
2485: #endif // SONIC_EISA
2486:
2487: #ifdef SONIC_INTERNAL
2488:
2489: case SONIC_ADAPTER_TYPE_INTERNAL:
2490:
2491: SONIC_WRITE_PORT(Adapter, SONIC_END_OF_BUFFER_WORD_COUNT,
2492: SONIC_END_OF_BUFFER_COUNT / 2
2493: );
2494: break;
2495:
2496: #endif // SONIC_INTERNAL
2497:
2498: default:
2499:
2500: ASSERT(FALSE);
2501: break;
2502:
2503: }
2504:
2505:
2506: SONIC_WRITE_PORT(Adapter, SONIC_UPPER_RECEIVE_RESOURCE,
2507: SONIC_GET_HIGH_PART_ADDRESS(
2508: NdisGetPhysicalAddressLow(Adapter->ReceiveResourceAreaPhysical))
2509: );
2510:
2511: SONIC_WRITE_PORT(Adapter, SONIC_RESOURCE_START,
2512: SONIC_GET_LOW_PART_ADDRESS(
2513: NdisGetPhysicalAddressLow(Adapter->ReceiveResourceAreaPhysical))
2514: );
2515:
2516: SONIC_WRITE_PORT(Adapter, SONIC_RESOURCE_END,
2517: (USHORT)(SONIC_GET_LOW_PART_ADDRESS(
2518: NdisGetPhysicalAddressLow(Adapter->ReceiveResourceAreaPhysical)) +
2519: sizeof(SONIC_RECEIVE_RESOURCE) *
2520: Adapter->NumberOfReceiveBuffers)
2521: );
2522:
2523: SONIC_WRITE_PORT(Adapter, SONIC_RESOURCE_READ,
2524: SONIC_GET_LOW_PART_ADDRESS(
2525: NdisGetPhysicalAddressLow(Adapter->ReceiveResourceAreaPhysical))
2526: );
2527:
2528: SONIC_WRITE_PORT(Adapter, SONIC_RESOURCE_WRITE,
2529: SONIC_GET_LOW_PART_ADDRESS(
2530: NdisGetPhysicalAddressLow(Adapter->ReceiveResourceAreaPhysical))
2531: );
2532:
2533:
2534: //
2535: // Now take us out of reset mode...
2536: //
2537:
2538: SONIC_WRITE_PORT(Adapter, SONIC_COMMAND,
2539: 0x0000
2540: );
2541:
2542: //
2543: // ...and issue the Read RRA command.
2544: //
2545:
2546: SONIC_WRITE_PORT(Adapter, SONIC_COMMAND,
2547: SONIC_CR_READ_RRA
2548: );
2549:
2550:
2551:
2552: //
2553: // Wait for 1/5 second for Read RRA to finish.
2554: //
2555:
2556: Time = 20;
2557:
2558: while (Time > 0) {
2559:
2560: NdisStallExecution(10000);
2561:
2562: SONIC_READ_PORT(Adapter, SONIC_COMMAND, &CommandRegister);
2563: if ((CommandRegister & SONIC_CR_READ_RRA) == 0) {
2564: break;
2565: }
2566:
2567: Time--;
2568:
2569: }
2570:
2571: if (Time == 0) {
2572:
2573: #if DBG
2574: DbgPrint("SONIC: Could not read RRA\n");
2575: #endif
2576: return FALSE;
2577:
2578: }
2579:
2580:
2581: //
2582: // This will cause a LOAD_CAM interrupt when it is done.
2583: //
2584:
2585: SonicStartCamReload(Adapter);
2586:
2587: return TRUE;
2588:
2589: }
2590:
2591: extern
2592: VOID
2593: SetupForReset(
2594: IN PSONIC_ADAPTER Adapter,
2595: IN PSONIC_OPEN Open
2596: )
2597:
2598: /*++
2599:
2600: Routine Description:
2601:
2602: This routine is used to fill in the who and why a reset is
2603: being set up as well as setting the appropriate fields in the
2604: adapter.
2605:
2606: NOTE: This routine must be called with the lock acquired.
2607:
2608: Arguments:
2609:
2610: Adapter - The adapter whose hardware is to be initialized.
2611:
2612: Open - A pointer to an sonic open structure.
2613:
2614: Return Value:
2615:
2616: None.
2617:
2618: --*/
2619: {
2620:
2621: PNDIS_REQUEST CurrentRequest;
2622: PNDIS_REQUEST * CurrentNextLocation;
2623: PSONIC_OPEN TmpOpen;
2624:
2625: PSONIC_REQUEST_RESERVED Reserved;
2626:
2627: //
2628: // Shut down the chip. We won't be doing any more work until
2629: // the reset is complete. We take it out of reset mode, however.
2630: //
2631:
2632: SonicStopChip(Adapter);
2633:
2634:
2635: //
2636: // Once the chip is stopped we can't get any more interrupts.
2637: // This call ensures that any ISR which is just about to run
2638: // will find no bits in the ISR, and any DPR which fires will
2639: // find nothing queued to do.
2640: //
2641:
2642: NdisSynchronizeWithInterrupt(
2643: &Adapter->Interrupt,
2644: SonicSynchClearIsr,
2645: (PVOID)Adapter);
2646:
2647:
2648: Adapter->ResetInProgress = TRUE;
2649:
2650: //
2651: // Shut down all of the transmit queues so that the
2652: // transmit portion of the chip will eventually calm down.
2653: //
2654:
2655: Adapter->SendStageOpen = FALSE;
2656:
2657: //
2658: // If there is a close at the top of the queue, then
2659: // it may be in two states:
2660: //
2661: // 1- Has interrupted, and the InterruptDpc got the
2662: // interrupt out of Adapter->IsrValue before we zeroed it.
2663: //
2664: // 2- Has interrupted, but we zeroed Adapter->IsrValue
2665: // before it read it, OR has not yet interrupted.
2666: //
2667: // In case 1, the interrupt will be processed and the
2668: // close will complete without our intervention. In
2669: // case 2, the open will not complete. In that case
2670: // the CAM will have been updated for that open, so
2671: // all that remains is for us to dereference the open
2672: // as would have been done in the interrupt handler.
2673: //
2674: // Closes that are not at the top of the queue we
2675: // leave in place; when we restart the queue after
2676: // the reset, they will get processed.
2677: //
2678:
2679: CurrentRequest = Adapter->FirstRequest;
2680:
2681: if (CurrentRequest) {
2682:
2683: Reserved = PSONIC_RESERVED_FROM_REQUEST(CurrentRequest);
2684:
2685: //
2686: // If the first request is a close, take it off the
2687: // queue, and "complete" it.
2688: //
2689:
2690: if (CurrentRequest->RequestType == NdisRequestClose) {
2691: Adapter->FirstRequest = Reserved->Next;
2692: --(Reserved->OpenBlock)->References;
2693: CurrentRequest = Adapter->FirstRequest;
2694: }
2695:
2696: CurrentNextLocation = &(Adapter->FirstRequest);
2697:
2698: while (CurrentRequest) {
2699:
2700: Reserved = PSONIC_RESERVED_FROM_REQUEST(CurrentRequest);
2701:
2702: if ((CurrentRequest->RequestType == NdisRequestClose) ||
2703: (CurrentRequest->RequestType == NdisRequestOpen)) {
2704:
2705: //
2706: // Opens are inoffensive, we just leave them
2707: // on the list. Closes that were not at the
2708: // head of the list were not processing and
2709: // can be left on also.
2710: //
2711:
2712: CurrentNextLocation = &(Reserved->Next);
2713:
2714: } else {
2715:
2716: //
2717: // Not a close, remove it from the list and
2718: // fail it.
2719: //
2720:
2721: *CurrentNextLocation = Reserved->Next;
2722: TmpOpen = Reserved->OpenBlock;
2723:
2724: NdisReleaseSpinLock(&Adapter->Lock);
2725:
2726: NdisCompleteRequest(
2727: TmpOpen->NdisBindingContext,
2728: CurrentRequest,
2729: NDIS_STATUS_RESET_IN_PROGRESS
2730: );
2731:
2732: NdisAcquireSpinLock(&Adapter->Lock);
2733:
2734: --TmpOpen->References;
2735:
2736: }
2737:
2738: CurrentRequest = *CurrentNextLocation;
2739:
2740: }
2741:
2742: Adapter->RequestInProgress = FALSE;
2743:
2744: }
2745:
2746: }
2747:
2748: #ifdef SONIC_INTERNAL
2749:
2750: //
2751: // The next routines are to support reading the registry to
2752: // obtain information about the internal sonic on the
2753: // MIPS R4000 motherboards.
2754: //
2755:
2756: //
2757: // This structure is used as the Context in the callbacks
2758: // to SonicHardwareSaveInformation.
2759: //
2760:
2761: typedef struct _SONIC_HARDWARE_INFO {
2762:
2763: //
2764: // These are read out of the "Configuration Data"
2765: // data.
2766: //
2767:
2768: CCHAR InterruptVector;
2769: KIRQL InterruptLevel;
2770: USHORT DataConfigurationRegister;
2771: LARGE_INTEGER PortAddress;
2772: BOOLEAN DataValid;
2773: UCHAR EthernetAddress[8];
2774: BOOLEAN AddressValid;
2775:
2776: //
2777: // This is set to TRUE if "Identifier" is equal to
2778: // "SONIC".
2779: //
2780:
2781: BOOLEAN SonicIdentifier;
2782:
2783: } SONIC_HARDWARE_INFO, *PSONIC_HARDWARE_INFO;
2784:
2785:
2786: STATIC
2787: NTSTATUS
2788: SonicHardwareSaveInformation(
2789: IN PWSTR ValueName,
2790: IN ULONG ValueType,
2791: IN PVOID ValueData,
2792: IN ULONG ValueLength,
2793: IN PVOID Context,
2794: IN PVOID EntryContext
2795: )
2796:
2797: /*++
2798:
2799: Routine Description:
2800:
2801: This routine is a callback routine for RtlQueryRegistryValues.
2802: It is called back with the data for the "Identifier" value
2803: and verifies that it is "SONIC", then is called back with
2804: the resource list and records the ports, interrupt number,
2805: and DCR value.
2806:
2807: Arguments:
2808:
2809: ValueName - The name of the value ("Identifier" or "Configuration
2810: Data").
2811:
2812: ValueType - The type of the value (REG_SZ or REG_BINARY).
2813:
2814: ValueData - The null-terminated data for the value.
2815:
2816: ValueLength - The length of ValueData (ignored).
2817:
2818: Context - A pointer to the SONIC_HARDWARE_INFO structure.
2819:
2820: EntryContext - FALSE for "Identifier", TRUE for "Configuration Data".
2821:
2822: Return Value:
2823:
2824: STATUS_SUCCESS
2825:
2826: --*/
2827:
2828: {
2829: PSONIC_HARDWARE_INFO HardwareInfo = (PSONIC_HARDWARE_INFO)Context;
2830:
2831: if ((BOOLEAN)EntryContext) {
2832:
2833: //
2834: // This is the "Configuration Data" callback.
2835: //
2836:
2837: if ((ValueType == REG_BINARY || ValueType == REG_FULL_RESOURCE_DESCRIPTOR) &&
2838: (ValueLength >= sizeof(CM_FULL_RESOURCE_DESCRIPTOR))) {
2839:
2840: BOOLEAN InterruptRead = FALSE;
2841: BOOLEAN PortAddressRead = FALSE;
2842: BOOLEAN DeviceSpecificRead = FALSE;
2843: UINT i;
2844:
2845: PCM_PARTIAL_RESOURCE_LIST ResourceList;
2846: PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor;
2847: PCM_SONIC_DEVICE_DATA SonicDeviceData;
2848:
2849: ResourceList =
2850: &((PCM_FULL_RESOURCE_DESCRIPTOR)ValueData)->PartialResourceList;
2851:
2852: for (i = 0; i < ResourceList->Count; i++) {
2853:
2854: ResourceDescriptor = &(ResourceList->PartialDescriptors[i]);
2855:
2856: switch (ResourceDescriptor->Type) {
2857:
2858: case CmResourceTypePort:
2859:
2860: HardwareInfo->PortAddress = ResourceDescriptor->u.Port.Start;
2861: PortAddressRead = TRUE;
2862: break;
2863:
2864: case CmResourceTypeInterrupt:
2865:
2866: HardwareInfo->InterruptVector = (CCHAR)ResourceDescriptor->u.Interrupt.Vector;
2867: HardwareInfo->InterruptLevel = (KIRQL)ResourceDescriptor->u.Interrupt.Level;
2868: InterruptRead = TRUE;
2869: break;
2870:
2871: case CmResourceTypeDeviceSpecific:
2872:
2873: if (i == ResourceList->Count-1) {
2874:
2875: SonicDeviceData = (PCM_SONIC_DEVICE_DATA)
2876: &(ResourceList->PartialDescriptors[ResourceList->Count]);
2877:
2878: //
2879: // Make sure we have enough room for each element we read.
2880: //
2881:
2882: if (ResourceDescriptor->u.DeviceSpecificData.DataSize >=
2883: (ULONG)(FIELD_OFFSET (CM_SONIC_DEVICE_DATA, EthernetAddress[0]))) {
2884:
2885: HardwareInfo->DataConfigurationRegister =
2886: SonicDeviceData->DataConfigurationRegister;
2887: DeviceSpecificRead = TRUE;
2888:
2889: //
2890: // Version.Revision later than 0.0 means that
2891: // the ethernet address is there too.
2892: //
2893:
2894: if ((SonicDeviceData->Version != 0) ||
2895: (SonicDeviceData->Revision != 0)) {
2896:
2897: if (ResourceDescriptor->u.DeviceSpecificData.DataSize >=
2898: (ULONG)(FIELD_OFFSET (CM_SONIC_DEVICE_DATA, EthernetAddress[0]) + 8)) {
2899:
2900: SONIC_MOVE_MEMORY(
2901: HardwareInfo->EthernetAddress,
2902: SonicDeviceData->EthernetAddress,
2903: 8);
2904:
2905: HardwareInfo->AddressValid = TRUE;
2906:
2907: }
2908:
2909: }
2910:
2911: }
2912:
2913: }
2914:
2915: break;
2916:
2917: }
2918:
2919: }
2920:
2921: //
2922: // Make sure we got all we wanted.
2923: //
2924:
2925: if (PortAddressRead && InterruptRead && DeviceSpecificRead) {
2926: HardwareInfo->DataValid = TRUE;
2927: }
2928:
2929: }
2930:
2931: } else {
2932:
2933: static const WCHAR SonicString[] = L"SONIC";
2934:
2935: //
2936: // This is the "Identifier" callback.
2937: //
2938:
2939: if ((ValueType == REG_SZ) &&
2940: (ValueLength >= sizeof(SonicString)) &&
2941: (RtlCompareMemory (ValueData, (PVOID)&SonicString, sizeof(SonicString)) == sizeof(SonicString))) {
2942:
2943: HardwareInfo->SonicIdentifier = TRUE;
2944:
2945: }
2946:
2947: }
2948:
2949: return STATUS_SUCCESS;
2950:
2951: }
2952:
2953:
2954: STATIC
2955: BOOLEAN
2956: SonicHardwareVerifyChecksum(
2957: IN PSONIC_ADAPTER Adapter,
2958: IN PUCHAR EthernetAddress,
2959: OUT ULONG ErrorLogData[3]
2960: )
2961:
2962: /*++
2963:
2964: Routine Description:
2965:
2966: This routine verifies that the checksum on the address
2967: for an internal sonic on a MIPS R4000 system is correct.
2968:
2969: Arguments:
2970:
2971: Adapter - The adapter which is being verified.
2972:
2973: EthernetAddress - A pointer to the address, with the checksum
2974: following it.
2975:
2976: ErrorLogData - If the checksum is bad, returns the address
2977: and the checksum we expected.
2978:
2979: Return Value:
2980:
2981: TRUE if the checksum is correct.
2982:
2983: --*/
2984:
2985: {
2986:
2987: //
2988: // Iteration variable.
2989: //
2990: UINT i;
2991:
2992: //
2993: // Holds the checksum value.
2994: //
2995: USHORT CheckSum = 0;
2996:
2997:
2998: //
2999: // The network address is stored in the first 6 bytes of
3000: // EthernetAddress. Following that is a zero byte followed
3001: // by a value such that the sum of a checksum on the six
3002: // bytes and this value is 0xff. The checksum is computed
3003: // by adding together the six bytes, with the carry being
3004: // wrapped back to the first byte.
3005: //
3006:
3007: for (i=0; i<6; i++) {
3008:
3009: CheckSum += EthernetAddress[i];
3010: if (CheckSum > 0xff) {
3011: CheckSum -= 0xff;
3012: }
3013:
3014: }
3015:
3016:
3017: if ((EthernetAddress[6] != 0x00) ||
3018: ((EthernetAddress[7] + CheckSum) != 0xff)) {
3019:
3020: ErrorLogData[0] = ((ULONG)(EthernetAddress[3]) << 24) +
3021: ((ULONG)(EthernetAddress[2]) << 16) +
3022: ((ULONG)(EthernetAddress[1]) << 8) +
3023: ((ULONG)(EthernetAddress[0]));
3024: ErrorLogData[1] = ((ULONG)(EthernetAddress[7]) << 24) +
3025: ((ULONG)(EthernetAddress[6]) << 16) +
3026: ((ULONG)(EthernetAddress[5]) << 8) +
3027: ((ULONG)(EthernetAddress[4]));
3028: ErrorLogData[2] = 0xff - CheckSum;
3029:
3030: return FALSE;
3031:
3032: }
3033:
3034: return TRUE;
3035:
3036: }
3037:
3038: #endif // SONIC_INTERNAL
3039:
3040:
3041: STATIC
3042: SONIC_HARDWARE_STATUS
3043: SonicHardwareGetDetails(
3044: IN PSONIC_ADAPTER Adapter,
3045: IN UINT SlotNumber,
3046: IN UINT Controller,
3047: IN UINT MultifunctionAdapter,
3048: OUT PULONG InitialPort,
3049: OUT PULONG NumberOfPorts,
3050: IN OUT PUINT InterruptVector,
3051: IN OUT PUINT InterruptLevel,
3052: OUT ULONG ErrorLogData[3]
3053: )
3054:
3055: /*++
3056:
3057: Routine Description:
3058:
3059: This routine gets the initial port and number of ports for
3060: the Sonic. It also sets Adapter->PortShift. The ports are
3061: numbered 0, 1, 2, etc. but may appear as 16- or 32-bit
3062: ports, so PortShift will be 1 or 2 depending on how wide
3063: the ports are.
3064:
3065: It also sets the value of Adapter->DataConfigurationRegister,
3066: and may modify InterruptVector, InterruptLevel, and
3067: Adapter->PermanentNetworkAddress.
3068:
3069: Arguments:
3070:
3071: Adapter - The adapter in question.
3072:
3073: SlotNumber - For the EISA card this is the slot number that the
3074: card is in.
3075:
3076: Controller - For the internal version, it is the
3077: NetworkController number.
3078:
3079: MultifunctionAdapter - For the internal version, it is the adapter number.
3080:
3081: InitialPort - The base of the Sonic ports.
3082:
3083: NumberOfPorts - The number of bytes of ports to map.
3084:
3085: InterruptVector - A pointer to the interrupt vector. Depending
3086: on the card type, this may be passed in or returned by
3087: this function.
3088:
3089: InterruptLevel - A pointer to the interrupt level. Depending
3090: on the card type, this may be passed in or returned by
3091: this function.
3092:
3093: ErrorLogData - If the return status is SonicHardwareChecksum,
3094: this returns 3 longwords to be included in the error log.
3095:
3096: Return Value:
3097:
3098: SonicHardwareOk if successful, SonicHardwareChecksum if the
3099: checksum is bad, SonicHardwareConfig for other problems.
3100:
3101: --*/
3102:
3103: {
3104:
3105: switch (Adapter->AdapterType) {
3106:
3107: #ifdef SONIC_EISA
3108:
3109: case SONIC_ADAPTER_TYPE_EISA:
3110:
3111: *InitialPort = (SlotNumber << 12);
3112: *NumberOfPorts = 0xD00;
3113: Adapter->PortShift = 1;
3114: Adapter->DataConfigurationRegister =
3115: SONIC_DCR_PROGRAMMABLE_OUTPUT_1 |
3116: SONIC_DCR_USER_DEFINABLE_1 |
3117: SONIC_DCR_3_WAIT_STATE |
3118: SONIC_DCR_BLOCK_MODE_DMA |
3119: SONIC_DCR_32_BIT_DATA_WIDTH |
3120: SONIC_DCR_8_WORD_RECEIVE_FIFO |
3121: SONIC_DCR_8_WORD_TRANSMIT_FIFO;
3122:
3123: return SonicHardwareOk;
3124: break;
3125:
3126: #endif // SONIC_EISA
3127:
3128: #ifdef SONIC_INTERNAL
3129:
3130: case SONIC_ADAPTER_TYPE_INTERNAL:
3131: {
3132:
3133: //
3134: // For MIPS R4000 systems, we have to query the registry to obtain
3135: // information about ports, interrupts, and the value to be
3136: // stored in the DCR register.
3137: //
3138:
3139: //
3140: // NOTE: The following code is NT-specific, since that is
3141: // currently the only system that runs on the MIPS R4000 hardware.
3142: //
3143: // We initialize an RTL_QUERY_TABLE to retrieve the Identifer
3144: // and ConfigurationData strings from the registry.
3145: //
3146:
3147: PWSTR ConfigDataPath = L"\\Registry\\Machine\\Hardware\\Description\\System\\MultifunctionAdapter\\#\\NetworkController\\#";
3148: PWSTR IdentifierString = L"Identifier";
3149: PWSTR ConfigDataString = L"Configuration Data";
3150: RTL_QUERY_REGISTRY_TABLE QueryTable[4];
3151: SONIC_HARDWARE_INFO SonicHardwareInfo;
3152: NTSTATUS Status;
3153:
3154:
3155: //
3156: // Set up QueryTable to do the following:
3157: //
3158:
3159: //
3160: // 1) Call SonicSaveHardwareInformation for the "Identifier"
3161: // value.
3162: //
3163:
3164: QueryTable[0].QueryRoutine = SonicHardwareSaveInformation;
3165: QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
3166: QueryTable[0].Name = IdentifierString;
3167: QueryTable[0].EntryContext = (PVOID)FALSE;
3168: QueryTable[0].DefaultType = REG_NONE;
3169:
3170: //
3171: // 2) Call SonicSaveHardwareInformation for the "Configuration Data"
3172: // value.
3173: //
3174:
3175: QueryTable[1].QueryRoutine = SonicHardwareSaveInformation;
3176: QueryTable[1].Flags = RTL_QUERY_REGISTRY_REQUIRED;
3177: QueryTable[1].Name = ConfigDataString;
3178: QueryTable[1].EntryContext = (PVOID)TRUE;
3179: QueryTable[1].DefaultType = REG_NONE;
3180:
3181: //
3182: // 3) Stop
3183: //
3184:
3185: QueryTable[2].QueryRoutine = NULL;
3186: QueryTable[2].Flags = 0;
3187: QueryTable[2].Name = NULL;
3188:
3189:
3190: //
3191: // Modify ConfigDataPath to replace the two # symbols with
3192: // the MultifunctionAdapter number and NetworkController number.
3193: //
3194:
3195: ConfigDataPath[67] = (WCHAR)('0' + MultifunctionAdapter);
3196: ConfigDataPath[87] = (WCHAR)('0' + Controller);
3197:
3198: SonicHardwareInfo.DataValid = FALSE;
3199: SonicHardwareInfo.AddressValid = FALSE;
3200: SonicHardwareInfo.SonicIdentifier = FALSE;
3201:
3202: Status = RtlQueryRegistryValues(
3203: RTL_REGISTRY_ABSOLUTE,
3204: ConfigDataPath,
3205: QueryTable,
3206: (PVOID)&SonicHardwareInfo,
3207: NULL);
3208:
3209: if (!NT_SUCCESS(Status)) {
3210: #if DBG
3211: DbgPrint ("SONIC: Could not read hardware information\n");
3212: #endif
3213: return SonicHardwareConfig;
3214: }
3215:
3216: if (SonicHardwareInfo.DataValid && SonicHardwareInfo.SonicIdentifier) {
3217:
3218: *InterruptVector = (UINT)SonicHardwareInfo.InterruptVector;
3219: *InterruptLevel = (UINT)SonicHardwareInfo.InterruptLevel;
3220: *InitialPort = SonicHardwareInfo.PortAddress.LowPart;
3221: *NumberOfPorts = 192;
3222: Adapter->PortShift = 2;
3223: Adapter->DataConfigurationRegister =
3224: SonicHardwareInfo.DataConfigurationRegister;
3225:
3226: if (SonicHardwareInfo.AddressValid) {
3227:
3228: if (!SonicHardwareVerifyChecksum(Adapter, SonicHardwareInfo.EthernetAddress, ErrorLogData)) {
3229: #if DBG
3230: DbgPrint("SONIC: Invalid registry network address checksum!!\n");
3231: #endif
3232: return SonicHardwareChecksum;
3233: }
3234:
3235: SONIC_MOVE_MEMORY(
3236: Adapter->PermanentNetworkAddress,
3237: SonicHardwareInfo.EthernetAddress,
3238: 8);
3239: Adapter->PermanentAddressValid = TRUE;
3240:
3241: }
3242:
3243: return SonicHardwareOk;
3244:
3245: } else {
3246:
3247: #if DBG
3248: DbgPrint ("SONIC: Incorrect registry hardware information\n");
3249: #endif
3250: return SonicHardwareConfig;
3251:
3252: }
3253:
3254: break;
3255:
3256: }
3257:
3258: #endif // SONIC_INTERNAL
3259:
3260: default:
3261:
3262: ASSERT(FALSE);
3263: break;
3264:
3265: }
3266:
3267: return SonicHardwareConfig;
3268:
3269: }
3270:
3271:
3272: STATIC
3273: BOOLEAN
3274: SonicHardwareGetAddress(
3275: IN PSONIC_ADAPTER Adapter,
3276: IN ULONG ErrorLogData[3]
3277: )
3278:
3279: /*++
3280:
3281: Routine Description:
3282:
3283: This routine gets the network address from the hardware.
3284:
3285: Arguments:
3286:
3287: Adapter - Where to store the network address.
3288:
3289: ErrorLogData - If the checksum is bad, returns the address
3290: and the checksum we expected.
3291:
3292: Return Value:
3293:
3294: TRUE if successful.
3295:
3296: --*/
3297:
3298: {
3299: #define NVRAM_READ_ONLY_BASE 0x8000b000
3300:
3301: //
3302: // Iteration variable.
3303: //
3304: UINT i;
3305:
3306:
3307: switch (Adapter->AdapterType) {
3308:
3309: #ifdef SONIC_EISA
3310:
3311: case SONIC_ADAPTER_TYPE_EISA:
3312:
3313: //
3314: // The EISA card has the address stored at ports xC90 to xC95,
3315: // where x is the slot number.
3316: //
3317:
3318: for (i = 0; i < 6; i++) {
3319:
3320: NdisRawReadPortUchar(
3321: Adapter->SonicPortAddress + 0xc90 + i,
3322: &Adapter->PermanentNetworkAddress[i]);
3323:
3324: }
3325:
3326: break;
3327:
3328: #endif // SONIC_EISA
3329:
3330: #ifdef SONIC_INTERNAL
3331:
3332: case SONIC_ADAPTER_TYPE_INTERNAL:
3333: {
3334:
3335: NDIS_STATUS Status;
3336: USHORT SiliconRevision;
3337:
3338: if (!Adapter->PermanentAddressValid) {
3339:
3340: //
3341: // Physical addresses for call to NdisMapIoSpace.
3342: //
3343:
3344: NDIS_PHYSICAL_ADDRESS NvRamPhysical =
3345: NDIS_PHYSICAL_ADDRESS_CONST(NVRAM_READ_ONLY_BASE, 0);
3346:
3347: //
3348: // Temporarily maps the NVRAM into our address space.
3349: //
3350: PVOID NvRamMapping;
3351:
3352:
3353:
3354: //
3355: // If PermanentAddressValid is still FALSE then the address
3356: // was not read by SonicHardwareGetDetails, so we must do it
3357: // here.
3358: //
3359:
3360: NdisMapIoSpace (
3361: &Status,
3362: &NvRamMapping,
3363: Adapter->NdisAdapterHandle,
3364: NvRamPhysical,
3365: 8
3366: );
3367:
3368: if (Status != NDIS_STATUS_SUCCESS) {
3369:
3370: NdisWriteErrorLogEntry(
3371: Adapter->NdisAdapterHandle,
3372: NDIS_ERROR_CODE_RESOURCE_CONFLICT,
3373: 0
3374: );
3375:
3376: return(FALSE);
3377:
3378: }
3379:
3380: //
3381: // Verify that the checksum matches.
3382: //
3383:
3384: if (!SonicHardwareVerifyChecksum(Adapter, (PUCHAR)NvRamMapping, ErrorLogData)) {
3385:
3386: #if DBG
3387: DbgPrint("SONIC: Invalid NVRAM network address checksum!!\n");
3388: #endif
3389: NdisUnmapIoSpace(Adapter->NdisAdapterHandle, NvRamMapping, 8);
3390: return FALSE;
3391:
3392: }
3393:
3394: //
3395: // Checksum is OK, save the address.
3396: //
3397:
3398: for (i=0; i<6; i++) {
3399: Adapter->PermanentNetworkAddress[i] = *((PUCHAR)NvRamMapping+i);
3400: }
3401: Adapter->PermanentAddressValid = TRUE;
3402:
3403: NdisUnmapIoSpace(Adapter->NdisAdapterHandle, NvRamMapping, 8);
3404:
3405: }
3406:
3407: //
3408: // The Data Configuration Register is already set up, but we
3409: // change the FIFO initialization for old revisions.
3410: //
3411:
3412: SONIC_READ_PORT(Adapter, SONIC_SILICON_REVISION, &SiliconRevision);
3413:
3414: if (SiliconRevision < 4) {
3415:
3416: Adapter->DataConfigurationRegister =
3417: (Adapter->DataConfigurationRegister & SONIC_DCR_FIFO_MASK) |
3418: SONIC_DCR_8_WORD_RECEIVE_FIFO |
3419: SONIC_DCR_8_WORD_TRANSMIT_FIFO;
3420:
3421: }
3422:
3423: break;
3424:
3425: }
3426:
3427: #endif // SONIC_INTERNAL
3428:
3429: default:
3430:
3431: ASSERT(FALSE);
3432: break;
3433:
3434: }
3435:
3436:
3437: #if DBG
3438: if (SonicDbg) {
3439: DbgPrint("SONIC: ");
3440: DbgPrint("[ %x-%x-%x-%x-%x-%x ]\n",
3441: (UCHAR)Adapter->PermanentNetworkAddress[0],
3442: (UCHAR)Adapter->PermanentNetworkAddress[1],
3443: (UCHAR)Adapter->PermanentNetworkAddress[2],
3444: (UCHAR)Adapter->PermanentNetworkAddress[3],
3445: (UCHAR)Adapter->PermanentNetworkAddress[4],
3446: (UCHAR)Adapter->PermanentNetworkAddress[5]);
3447: DbgPrint("\n");
3448: }
3449: #endif
3450:
3451: return TRUE;
3452:
3453: }
3454:
3455:
3456: VOID
3457: SonicShutdown(
3458: IN PVOID ShutdownContext
3459: )
3460:
3461: /*++
3462:
3463: Routine Description:
3464:
3465: Turns off the card during a powerdown of the system.
3466:
3467: Arguments:
3468:
3469: ShutdownContext - Really a pointer to the adapter structure.
3470:
3471: Return Value:
3472:
3473: None.
3474:
3475: --*/
3476:
3477: {
3478: PSONIC_ADAPTER Adapter = (PSONIC_ADAPTER)(ShutdownContext);
3479:
3480: NdisAcquireSpinLock(&Adapter->Lock);
3481:
3482: //
3483: // Set the flag
3484: //
3485:
3486: Adapter->Removed = TRUE;
3487:
3488: //
3489: // Shut down the chip. We won't be doing any more work until
3490: // the reset is complete.
3491: //
3492:
3493: SonicStopChip(Adapter);
3494:
3495: NdisStallExecution(250000);
3496:
3497: NdisReleaseSpinLock(&Adapter->Lock);
3498:
3499: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.