![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ibmtok.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / ibmtok|
Return to ibmtok.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / ibmtok |
1.1 root 1: /*++
2:
3: Copyright (c) 1990 Microsoft Corporation
4:
5: Module Name:
6:
7: ibmtok.c
8:
9: Abstract:
10:
11: This is the main file for the IBM Token-Ring 16/4 Adapter.
12: 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) 15-Feb-1990
21:
22: Environment:
23:
24: Kernel Mode - Or whatever is the equivalent.
25:
26: Revision History:
27:
28: Sean Selitrennikoff -- 9/15/91:
29: Added code to handle Microchannel with PC I/O bus handling.
30: Fixed bugs.
31: Sean Selitrennikoff -- 10/15/91:
32: Converted to Ndis 3.0 spec.
33: George Joy -- 12/1/91
34: Changed for compilation under DOS as well as NT
35: Sean Selitrennikoff -- 1/8/92:
36: Added error logging
37:
38: --*/
39:
40: #pragma optimize("",off)
41:
42: #include <ndis.h>
43:
44:
45: #include <tfilter.h>
46: #include <tokhrd.h>
47: #include <toksft.h>
48:
49:
50: #if LOG
51:
52: //
53: // Place in the circular buffer.
54: //
55: extern UCHAR IbmtokLogPlace;
56:
57: //
58: // Circular buffer for storing log information.
59: //
60: extern UCHAR IbmtokLog[];
61:
62: #define IF_LOG(A) {IbmtokLog[IbmtokLogPlace++] = (A); IbmtokLog[IbmtokLogPlace+2] = '.';}
63:
64: #else
65:
66: #define IF_LOG(A)
67:
68: #endif
69:
70: //
71: // This constant is used for places where NdisAllocateMemory
72: // needs to be called and the HighestAcceptableAddress does
73: // not matter.
74: //
75:
76: const NDIS_PHYSICAL_ADDRESS HighestAcceptableMax =
77: NDIS_PHYSICAL_ADDRESS_CONST(-1,-1);
78:
79:
80: //
81: // If you add to this, make sure to add the
82: // a case in IbmtokFillInGlobalData() and in
83: // IbmtokQueryGlobalStatistics()
84: //
85: static const UINT IbmtokGlobalSupportedOids[] = {
86: OID_GEN_SUPPORTED_LIST,
87: OID_GEN_HARDWARE_STATUS,
88: OID_GEN_MEDIA_SUPPORTED,
89: OID_GEN_MEDIA_IN_USE,
90: OID_GEN_MAXIMUM_LOOKAHEAD,
91: OID_GEN_MAXIMUM_FRAME_SIZE,
92: OID_GEN_MAXIMUM_TOTAL_SIZE,
93: OID_GEN_MAC_OPTIONS,
94: OID_GEN_PROTOCOL_OPTIONS,
95: OID_GEN_LINK_SPEED,
96: OID_GEN_TRANSMIT_BUFFER_SPACE,
97: OID_GEN_RECEIVE_BUFFER_SPACE,
98: OID_GEN_TRANSMIT_BLOCK_SIZE,
99: OID_GEN_RECEIVE_BLOCK_SIZE,
100: OID_GEN_VENDOR_ID,
101: OID_GEN_VENDOR_DESCRIPTION,
102: OID_GEN_DRIVER_VERSION,
103: OID_GEN_CURRENT_PACKET_FILTER,
104: OID_GEN_CURRENT_LOOKAHEAD,
105: OID_GEN_XMIT_OK,
106: OID_GEN_RCV_OK,
107: OID_GEN_XMIT_ERROR,
108: OID_GEN_RCV_ERROR,
109: OID_GEN_RCV_NO_BUFFER,
110: OID_802_5_PERMANENT_ADDRESS,
111: OID_802_5_CURRENT_ADDRESS,
112: OID_802_5_CURRENT_FUNCTIONAL,
113: OID_802_5_CURRENT_GROUP,
114: OID_802_5_LAST_OPEN_STATUS,
115: OID_802_5_CURRENT_RING_STATUS,
116: OID_802_5_CURRENT_RING_STATE,
117: OID_802_5_LINE_ERRORS,
118: OID_802_5_LOST_FRAMES
119: };
120:
121: //
122: // If you add to this, make sure to add the
123: // a case in IbmtokQueryGlobalStatistics() and in
124: // IbmtokQueryProtocolInformation()
125: //
126: static const UINT IbmtokProtocolSupportedOids[] = {
127: OID_GEN_SUPPORTED_LIST,
128: OID_GEN_HARDWARE_STATUS,
129: OID_GEN_MEDIA_SUPPORTED,
130: OID_GEN_MEDIA_IN_USE,
131: OID_GEN_MAXIMUM_LOOKAHEAD,
132: OID_GEN_MAXIMUM_FRAME_SIZE,
133: OID_GEN_MAXIMUM_TOTAL_SIZE,
134: OID_GEN_MAC_OPTIONS,
135: OID_GEN_PROTOCOL_OPTIONS,
136: OID_GEN_LINK_SPEED,
137: OID_GEN_TRANSMIT_BUFFER_SPACE,
138: OID_GEN_RECEIVE_BUFFER_SPACE,
139: OID_GEN_TRANSMIT_BLOCK_SIZE,
140: OID_GEN_RECEIVE_BLOCK_SIZE,
141: OID_GEN_VENDOR_ID,
142: OID_GEN_VENDOR_DESCRIPTION,
143: OID_GEN_DRIVER_VERSION,
144: OID_GEN_CURRENT_PACKET_FILTER,
145: OID_GEN_CURRENT_LOOKAHEAD,
146: OID_802_5_PERMANENT_ADDRESS,
147: OID_802_5_CURRENT_ADDRESS,
148: OID_802_5_CURRENT_FUNCTIONAL,
149: OID_802_5_CURRENT_GROUP
150: };
151:
152:
153: //
154: // On a development build, don't define functions as static
155: // so we can set breakpoints on them.
156: //
157:
158: #if DEVL
159: #define STATIC
160: #else
161: #define STATIC static
162: #endif
163:
164: #if DBG
165: INT IbmtokDbg = 0;
166: #define LOG 1
167: #else
168: #define LOG 0
169: #endif
170:
171:
172: //
173: // Get from configuration file.
174: //
175:
176: #define MAX_MULTICAST_ADDRESS ((UINT)16)
177: #define MAX_ADAPTERS ((UINT)4)
178:
179:
180: //
181: // This macro determines if the directed address
182: // filtering in the CAM is actually necessary given
183: // the current filter.
184: //
185: #define CAM_DIRECTED_SIGNIFICANT(_Filter) \
186: ((((_Filter) & NDIS_PACKET_TYPE_DIRECTED) && \
187: (!((_Filter) & NDIS_PACKET_TYPE_PROMISCUOUS))) ? 1 : 0)
188:
189:
190: //
191: // This macro determines if the multicast filtering in
192: // the CAM are actually necessary given the current filter.
193: //
194: #define CAM_MULTICAST_SIGNIFICANT(_Filter) \
195: ((((_Filter) & NDIS_PACKET_TYPE_MULTICAST) && \
196: (!((_Filter) & (NDIS_PACKET_TYPE_ALL_MULTICAST | \
197: NDIS_PACKET_TYPE_PROMISCUOUS)))) ? 1 : 0)
198:
199:
200: STATIC
201: NDIS_STATUS
202: IbmtokOpenAdapter(
203: OUT PNDIS_STATUS OpenErrorStatus,
204: OUT NDIS_HANDLE *MacBindingHandle,
205: OUT PUINT SelectedMediumIndex,
206: IN PNDIS_MEDIUM MediumArray,
207: IN UINT MediumArraySize,
208: IN NDIS_HANDLE NdisBindingContext,
209: IN NDIS_HANDLE MacAdapterContext,
210: IN UINT OpenOptions,
211: IN PSTRING AddressingInformation OPTIONAL
212: );
213:
214: STATIC
215: NDIS_STATUS
216: IbmtokCloseAdapter(
217: IN NDIS_HANDLE MacBindingHandle
218: );
219:
220:
221: STATIC
222: NDIS_STATUS
223: IbmtokRequest(
224: IN NDIS_HANDLE MacBindingHandle,
225: IN PNDIS_REQUEST NdisRequest
226: );
227:
228: STATIC
229: NDIS_STATUS
230: IbmtokQueryInformation(
231: IN PIBMTOK_ADAPTER Adapter,
232: IN PIBMTOK_OPEN Open,
233: IN PNDIS_REQUEST NdisRequest
234: );
235:
236:
237: STATIC
238: NDIS_STATUS
239: IbmtokSetInformation(
240: IN PIBMTOK_ADAPTER Adapter,
241: IN PIBMTOK_OPEN Open,
242: IN PNDIS_REQUEST NdisRequest
243: );
244:
245: STATIC
246: NDIS_STATUS
247: IbmtokQueryGlobalStatistics(
248: IN NDIS_HANDLE MacAdapterContext,
249: IN PNDIS_REQUEST NdisRequest
250: );
251:
252: NDIS_STATUS
253: IbmtokAddAdapter(
254: IN NDIS_HANDLE MacMacContext,
255: IN NDIS_HANDLE ConfigurationHandle,
256: IN PNDIS_STRING AdaptName
257: );
258:
259: VOID
260: IbmtokRemoveAdapter(
261: IN PVOID MacAdapterContext
262: );
263:
264: STATIC
265: NDIS_STATUS
266: IbmtokSetPacketFilter(
267: IN PIBMTOK_ADAPTER Adapter,
268: IN PIBMTOK_OPEN Open,
269: IN PNDIS_REQUEST NdisRequest,
270: IN UINT PacketFilter
271: );
272:
273: STATIC
274: NDIS_STATUS
275: IbmtokSetGroupAddress(
276: IN PIBMTOK_ADAPTER Adapter,
277: IN PIBMTOK_OPEN Open,
278: IN PNDIS_REQUEST NdisRequest,
279: IN PUCHAR Address
280: );
281:
282: STATIC
283: NDIS_STATUS
284: IbmtokChangeFunctionalAddress(
285: IN PIBMTOK_ADAPTER Adapter,
286: IN PIBMTOK_OPEN Open,
287: IN PNDIS_REQUEST NdisRequest,
288: IN PUCHAR Address
289: );
290:
291: STATIC
292: NDIS_STATUS
293: IbmtokReset(
294: IN NDIS_HANDLE MacBindingHandle
295: );
296:
297: STATIC
298: NDIS_STATUS
299: IbmtokTest(
300: IN NDIS_HANDLE MacBindingHandle
301: );
302:
303: STATIC
304: NDIS_STATUS
305: IbmtokChangeFilter(
306: IN UINT OldFilterClasses,
307: IN UINT NewFilterClasses,
308: IN NDIS_HANDLE MacBindingHandle,
309: IN PNDIS_REQUEST NdisRequest,
310: IN BOOLEAN Set
311: );
312:
313: STATIC
314: NDIS_STATUS
315: IbmtokChangeAddress(
316: IN TR_FUNCTIONAL_ADDRESS OldFunctionalAddress,
317: IN TR_FUNCTIONAL_ADDRESS NewFunctionalAddress,
318: IN NDIS_HANDLE MacBindingHandle,
319: IN PNDIS_REQUEST NdisRequest,
320: IN BOOLEAN Set
321: );
322:
323: STATIC
324: NDIS_STATUS
325: IbmtokChangeGroupAddress(
326: IN TR_FUNCTIONAL_ADDRESS OldGroupAddress,
327: IN TR_FUNCTIONAL_ADDRESS NewGroupAddress,
328: IN NDIS_HANDLE MacBindingHandle,
329: IN PNDIS_REQUEST NdisRequest,
330: IN BOOLEAN Set
331: );
332:
333: STATIC
334: BOOLEAN
335: IbmtokHardwareDetails(
336: IN PIBMTOK_ADAPTER Adapter
337: );
338:
339: STATIC
340: NDIS_STATUS
341: IbmtokRegisterAdapter(
342: IN PIBMTOK_ADAPTER Adapter,
343: IN NDIS_HANDLE ConfigurationHandle,
344: IN PNDIS_STRING DeviceName,
345: IN BOOLEAN McaCard,
346: IN BOOLEAN ConfigError
347: );
348:
349: STATIC
350: VOID
351: SetInitializeVariables(
352: IN PIBMTOK_ADAPTER Adapter
353: );
354:
355: VOID
356: SetResetVariables(
357: IN PIBMTOK_ADAPTER Adapter
358: );
359:
360: extern
361: VOID
362: IbmtokStartAdapterReset(
363: IN PIBMTOK_ADAPTER Adapter
364: );
365:
366: STATIC
367: VOID
368: IbmtokCloseAction(
369: IN NDIS_HANDLE MacBindingHandle
370: );
371:
372: STATIC
373: VOID
374: IbmtokSetupRegistersAndInit(
375: IN PIBMTOK_ADAPTER Adapter
376: );
377:
378: STATIC
379: NDIS_STATUS
380: IbmtokInitialInit(
381: IN PIBMTOK_ADAPTER Adapter
382: );
383:
384: VOID
385: IbmtokUnload(
386: IN NDIS_HANDLE MacMacContext
387: );
388:
389:
390: NTSTATUS
391: DriverEntry(
392: IN PDRIVER_OBJECT DriverObject,
393: IN PUNICODE_STRING RegistryPath
394: )
395: /*++
396:
397: Routine Description:
398:
399: This is the primary initialization routine for the ibmtok driver.
400: It is simply responsible for the intializing the wrapper and registering
401: the MAC. It then calls a system and architecture specific routine that
402: will initialize and register each adapter.
403:
404: Arguments:
405:
406: DriverObject - Pointer to driver object created by the system.
407:
408: Return Value:
409:
410: The status of the operation.
411:
412: --*/
413:
414: {
415:
416:
417: //
418: // Receives the status of the NdisRegisterMac operation.
419: //
420: NDIS_STATUS InitStatus;
421: PIBMTOK_MAC IbmtokMac;
422: NDIS_HANDLE NdisWrapperHandle;
423: char Tmp[sizeof(NDIS_MAC_CHARACTERISTICS)];
424: PNDIS_MAC_CHARACTERISTICS IbmtokChar = (PNDIS_MAC_CHARACTERISTICS)(PVOID)Tmp;
425: NDIS_STRING MacName = NDIS_STRING_CONST("IbmTok");
426:
427: //
428: // Initialize the wrapper.
429: //
430:
431: NdisInitializeWrapper(
432: &NdisWrapperHandle,
433: DriverObject,
434: RegistryPath,
435: NULL
436: );
437:
438: //
439: // Now allocate memory for our global structure.
440: //
441:
442: InitStatus = IBMTOK_ALLOC_PHYS(&IbmtokMac, sizeof(IBMTOK_MAC));
443:
444: if (InitStatus != NDIS_STATUS_SUCCESS) {
445:
446: return NDIS_STATUS_RESOURCES;
447:
448: }
449:
450: IbmtokMac->NdisWrapperHandle = NdisWrapperHandle;
451:
452: //
453: // Initialize the MAC characteristics for the call to
454: // NdisRegisterMac.
455: //
456:
457:
458: IbmtokChar->MajorNdisVersion = IBMTOK_NDIS_MAJOR_VERSION;
459: IbmtokChar->MinorNdisVersion = IBMTOK_NDIS_MINOR_VERSION;
460: IbmtokChar->OpenAdapterHandler = (OPEN_ADAPTER_HANDLER) IbmtokOpenAdapter;
461: IbmtokChar->CloseAdapterHandler = (CLOSE_ADAPTER_HANDLER) IbmtokCloseAdapter;
462: IbmtokChar->RequestHandler = IbmtokRequest;
463: IbmtokChar->SendHandler = IbmtokSend;
464: IbmtokChar->TransferDataHandler = IbmtokTransferData;
465: IbmtokChar->ResetHandler = IbmtokReset;
466: IbmtokChar->UnloadMacHandler = IbmtokUnload;
467: IbmtokChar->QueryGlobalStatisticsHandler = IbmtokQueryGlobalStatistics;
468: IbmtokChar->AddAdapterHandler = IbmtokAddAdapter;
469: IbmtokChar->RemoveAdapterHandler = IbmtokRemoveAdapter;
470:
471: IbmtokChar->Name = MacName;
472:
473: NdisRegisterMac(
474: &InitStatus,
475: &IbmtokMac->NdisMacHandle,
476: NdisWrapperHandle,
477: (PVOID)IbmtokMac,
478: IbmtokChar,
479: sizeof(*IbmtokChar)
480: );
481:
482: if (InitStatus != NDIS_STATUS_SUCCESS) {
483:
484: NdisTerminateWrapper(NdisWrapperHandle, NULL);
485:
486: return NDIS_STATUS_FAILURE;
487:
488: }
489:
490: return NDIS_STATUS_SUCCESS;
491:
492: }
493:
494:
495: STATIC
496: NDIS_STATUS
497: IbmtokRegisterAdapter(
498: IN PIBMTOK_ADAPTER Adapter,
499: IN NDIS_HANDLE ConfigurationHandle,
500: IN PNDIS_STRING DeviceName,
501: IN BOOLEAN McaCard,
502: IN BOOLEAN ConfigError
503: )
504:
505: /*++
506:
507: Routine Description:
508:
509: This routine (and its interface) are not portable. They are
510: defined by the OS, the architecture, and the particular IBMTOK
511: implementation.
512:
513: This routine is responsible for the allocation of the datastructures
514: for the driver as well as any hardware specific details necessary
515: to talk with the device.
516:
517: Arguments:
518:
519: Adapter - Pointer to the adapter block.
520:
521: ConfigurationHandle - Handle passed to MacAddAdapter, to be passed to
522: NdisRegisterAdapter.
523:
524: DeviceName - Name of this adapter.
525:
526: McaCard - This is an MCA bus.
527:
528: ConfigError - TRUE if a configuration error was found earlier.
529:
530: Return Value:
531:
532: Returns NDIS_STATUS_SUCCESS if everything goes ok, else
533: if anything occurred that prevents the initialization
534: of the adapter it returns an appropriate NDIS error.
535:
536: --*/
537:
538: {
539:
540: NDIS_STATUS Status;
541:
542: //
543: // Holds information needed when registering the adapter.
544: //
545:
546: NDIS_ADAPTER_INFORMATION AdapterInformation;
547:
548: // We put in this assertion to make sure that ushort are 2 bytes.
549: // if they aren't then the initialization block definition needs
550: // to be changed.
551: //
552: // Also all of the logic that deals with status registers assumes
553: // that control registers are only 2 bytes.
554: //
555:
556: ASSERT(sizeof(USHORT) == 2);
557:
558: //
559: // Get the interrupt number and MMIO address.
560: //
561:
562: //
563: // Set the adapter state.
564: //
565:
566: SetInitializeVariables(Adapter);
567:
568: SetResetVariables(Adapter);
569:
570: //
571: // Set up the AdapterInformation structure; zero it
572: // first in case it is extended later.
573: //
574:
575: IBMTOK_ZERO_MEMORY (&AdapterInformation, sizeof(NDIS_ADAPTER_INFORMATION));
576: AdapterInformation.AdapterType = (McaCard ? NdisInterfaceMca : NdisInterfaceIsa);
577: AdapterInformation.NumberOfPortDescriptors = 1;
578: AdapterInformation.PortDescriptors[0].InitialPort = Adapter->IbmtokPortAddress;
579: AdapterInformation.PortDescriptors[0].NumberOfPorts = 4;
580:
581: //
582: // Register the adapter with Ndis.
583: //
584:
585: Status = NdisRegisterAdapter(
586: &Adapter->NdisAdapterHandle,
587: Adapter->NdisMacHandle,
588: Adapter,
589: ConfigurationHandle,
590: DeviceName,
591: &AdapterInformation
592: );
593:
594: if (Status != NDIS_STATUS_SUCCESS) {
595:
596: return(Status);
597:
598: }
599:
600: if (ConfigError) {
601:
602: //
603: // Error and quit
604: //
605:
606: NdisWriteErrorLogEntry(
607: Adapter->NdisAdapterHandle,
608: NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
609: 0
610: );
611:
612: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
613:
614: return(NDIS_STATUS_FAILURE);
615:
616: }
617:
618:
619:
620: if (!IbmtokHardwareDetails(Adapter)) {
621:
622: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
623: return NDIS_STATUS_ADAPTER_NOT_FOUND;
624:
625: }
626:
627:
628: //
629: // Reset the card to put it in a valid state.
630: //
631:
632: if (Adapter->SharedRamPaging) {
633:
634: WRITE_ADAPTER_REGISTER(Adapter, SRPR_LOW, 0xc0);
635:
636: }
637:
638: //
639: // OK, do the reset as detailed in the Tech Ref...
640: //
641:
642: WRITE_ADAPTER_PORT(Adapter, RESET_LATCH, 0);
643:
644: NdisStallExecution(50000);
645:
646: WRITE_ADAPTER_PORT(Adapter, RESET_RELEASE, 0);
647:
648: //
649: // Initialize the interrupt.
650: //
651:
652: NdisAllocateSpinLock(&Adapter->InterruptLock);
653:
654: NdisInitializeInterrupt(
655: &Status,
656: &Adapter->Interrupt,
657: Adapter->NdisAdapterHandle,
658: IbmtokISR,
659: Adapter,
660: IbmtokDPC,
661: Adapter->InterruptLevel,
662: Adapter->InterruptLevel,
663: FALSE,
664: (Adapter->UsingPcIoBus)?NdisInterruptLatched:
665: NdisInterruptLevelSensitive
666: );
667:
668: if (Status == NDIS_STATUS_SUCCESS){
669:
670: //
671: // Set up the Adapter variables. (We have to do the
672: // initial init to get the network address before we
673: // create the filter DB.)
674: //
675: if (IbmtokInitialInit(Adapter) != NDIS_STATUS_SUCCESS) {
676:
677: NdisWriteErrorLogEntry(
678: Adapter->NdisAdapterHandle,
679: NDIS_ERROR_CODE_ADAPTER_NOT_FOUND,
680: 2,
681: registerAdapter,
682: IBMTOK_ERRMSG_NOT_FOUND
683: );
684:
685: NdisRemoveInterrupt(&Adapter->Interrupt);
686:
687: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
688: NdisFreeSpinLock(&(Adapter->Lock));
689: return NDIS_STATUS_ADAPTER_NOT_FOUND;
690:
691: } else {
692:
693: if (!TrCreateFilter(
694: IbmtokChangeAddress,
695: IbmtokChangeGroupAddress,
696: IbmtokChangeFilter,
697: IbmtokCloseAction,
698: Adapter->NetworkAddress,
699: &Adapter->Lock,
700: &Adapter->FilterDB
701: )) {
702:
703: NdisWriteErrorLogEntry(
704: Adapter->NdisAdapterHandle,
705: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
706: 2,
707: registerAdapter,
708: IBMTOK_ERRMSG_CREATE_DB
709: );
710:
711: NdisRemoveInterrupt(&Adapter->Interrupt);
712: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
713: NdisFreeSpinLock(&(Adapter->Lock));
714: return NDIS_STATUS_RESOURCES;
715:
716: } else {
717:
718: //
719: // Initialize the wake up timer to catch interrupts that
720: // don't complete. It fires continuously
721: // every thirty seconds, and we check if there are any
722: // uncompleted operations from the previous two-second
723: // period.
724: //
725:
726: Adapter->WakeUpDpc = (PVOID)IbmtokWakeUpDpc;
727:
728: NdisInitializeTimer(&Adapter->WakeUpTimer,
729: (PVOID)(Adapter->WakeUpDpc),
730: Adapter );
731:
732: NdisSetTimer(
733: &Adapter->WakeUpTimer,
734: 30000
735: );
736:
737: return(NDIS_STATUS_SUCCESS);
738:
739: }
740:
741: }
742:
743: } else {
744:
745: NdisWriteErrorLogEntry(
746: Adapter->NdisAdapterHandle,
747: NDIS_ERROR_CODE_INTERRUPT_CONNECT,
748: 2,
749: registerAdapter,
750: IBMTOK_ERRMSG_INIT_INTERRUPT
751: );
752:
753: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
754: NdisFreeSpinLock(&(Adapter->Lock));
755: return(Status);
756: }
757:
758: }
759:
760: STATIC
761: VOID
762: SetInitializeVariables(
763: IN PIBMTOK_ADAPTER Adapter
764: )
765:
766: /*++
767:
768: Routine Description:
769:
770: This routine initializes all the variables in the Adapter
771: structure that should only be set during adapter initialization
772: (i.e. not during a reset).
773:
774: Arguments:
775:
776: Adapter - The adapter for the hardware.
777:
778: Return Value:
779:
780: None.
781:
782: --*/
783:
784: {
785: InitializeListHead(&Adapter->OpenBindings);
786: InitializeListHead(&Adapter->CloseList);
787: InitializeListHead(&Adapter->CloseDuringResetList);
788:
789: NdisAllocateSpinLock(&Adapter->Lock);
790:
791: //
792: // If this is not true, then uncomment below
793: //
794:
795: ASSERT(FALSE == (BOOLEAN)0);
796:
797: // Adapter->HandleSrbRunning = FALSE;
798: // Adapter->HandleArbRunning = FALSE;
799:
800: // Adapter->OpenInProgress = FALSE;
801:
802: Adapter->AdapterNotOpen = TRUE;
803: Adapter->NotAcceptingRequests = TRUE;
804:
805: // Adapter->ResetInProgress = FALSE;
806: // Adapter->ResettingOpen = NULL;
807: // Adapter->ResetInterruptAllowed = FALSE;
808: // Adapter->ResetInterruptHasArrived = FALSE;
809:
810: // Adapter->BringUp = FALSE;
811:
812: //
813: // Note: These assume that the SAP info will not
814: // take up more than 218 bytes. This is ok, for now, since
815: // we open the card with 0 SAPs allowed.
816: //
817:
818: Adapter->ReceiveBufferLength = 256;
819: Adapter->NumberOfTransmitBuffers = 1;
820:
821: //
822: // Note: The following fields are set in the interrupt handler after
823: // the card tells us if the ring is 16 or 4 Mbps.
824: //
825: //
826: // TransmitBufferLength
827: // NumberOfReceiveBuffers
828: // MaximumTransmittablePacket
829: //
830:
831: // Adapter->IsrpDeferredBits = 0;
832:
833: Adapter->FirstInitialization = TRUE;
834:
835: // Adapter->OutstandingAsbFreeRequest = FALSE;
836: }
837:
838: VOID
839: SetResetVariables(
840: IN PIBMTOK_ADAPTER Adapter
841: )
842:
843: /*++
844:
845: Routine Description:
846:
847: This routine initializes all the variables in the Adapter
848: structure that are set both during an initialization and
849: after a reset.
850:
851: Arguments:
852:
853: Adapter - The adapter for the hardware.
854:
855: Return Value:
856:
857: None.
858:
859: --*/
860:
861: {
862: Adapter->FirstTransmit = NULL;
863: Adapter->LastTransmit = NULL;
864: Adapter->FirstWaitingForAsb = NULL;
865: Adapter->LastWaitingForAsb = NULL;
866: Adapter->TransmittingPacket = NULL;
867:
868: IBMTOK_ZERO_MEMORY(Adapter->CorrelatorArray,
869: sizeof(PNDIS_PACKET) * MAX_COMMAND_CORRELATOR);
870:
871: Adapter->PendQueue = NULL;
872: Adapter->EndOfPendQueue = NULL;
873:
874: Adapter->SrbAvailable = TRUE;
875: Adapter->AsbAvailable = TRUE;
876:
877: Adapter->IsrpBits = 0;
878: Adapter->IsrpLowBits = 0;
879:
880: Adapter->NextCorrelatorToComplete = 0;
881: Adapter->ReceiveWaitingForAsbList = (USHORT)-1;
882: Adapter->ReceiveWaitingForAsbEnd = (USHORT)-1;
883: Adapter->UseNextAsbForReceive = TRUE;
884: }
885:
886: extern
887: NDIS_STATUS
888: IbmtokInitialInit(
889: IN PIBMTOK_ADAPTER Adapter
890: )
891:
892: /*++
893:
894: Routine Description:
895:
896: This routine sets up the initial init of the driver.
897:
898: Arguments:
899:
900: Adapter - The adapter for the hardware.
901:
902: Return Value:
903:
904: None.
905:
906: --*/
907:
908: {
909: USHORT RegValue;
910: UINT Time = 50; // Number of 100 milliseconds to delay while waiting
911: // for the card to initialize.
912:
913: IbmtokSetupRegistersAndInit(Adapter);
914:
915: //
916: // Delay execution for 5 seconds to give the ring
917: // time to initialize.
918: //
919:
920: while((!Adapter->BringUp) && (Time != 0)){
921:
922: NdisStallExecution(100000);
923:
924: Time--;
925:
926: }
927:
928: if (!Adapter->BringUp){
929:
930: return(NDIS_STATUS_ADAPTER_NOT_FOUND);
931:
932: } else {
933:
934: //
935: // Do remaining initialization.
936: //
937:
938: USHORT WrbOffset;
939: PSRB_BRING_UP_RESULT BringUpSrb;
940: PUCHAR EncodedAddress;
941: UCHAR Value1, Value2;
942:
943: READ_ADAPTER_REGISTER(Adapter, WRBR_LOW, &Value1);
944: READ_ADAPTER_REGISTER(Adapter, WRBR_HIGH, &Value2);
945:
946: WrbOffset = (((USHORT)Value1) << 8) + (USHORT)Value2;
947:
948: Adapter->InitialWrbOffset = WrbOffset;
949:
950: #if DBG
951: if (IbmtokDbg) {
952:
953: DbgPrint("IBMTOK: Initial Offset = 0x%x\n", WrbOffset);
954:
955: }
956: #endif
957:
958: BringUpSrb = (PSRB_BRING_UP_RESULT)
959: (Adapter->SharedRam + WrbOffset);
960:
961: NdisReadRegisterUshort(&(BringUpSrb->ReturnCode), &RegValue);
962:
963: if (RegValue != 0x0000) {
964:
965: if (RegValue == 0x30){
966:
967: NdisWriteErrorLogEntry(
968: Adapter->NdisAdapterHandle,
969: NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
970: 0x32,
971: handleSrbSsb,
972: IBMTOK_ERRMSG_BRINGUP_FAILURE
973: );
974:
975:
976: return(NDIS_STATUS_ADAPTER_NOT_FOUND);
977:
978: } else {
979:
980: NdisWriteErrorLogEntry(
981: Adapter->NdisAdapterHandle,
982: NDIS_ERROR_CODE_HARDWARE_FAILURE,
983: 3,
984: handleSrbSsb,
985: IBMTOK_ERRMSG_BRINGUP_FAILURE,
986: (ULONG)RegValue
987: );
988:
989: return(NDIS_STATUS_ADAPTER_NOT_FOUND);
990:
991:
992: }
993:
994: } else {
995:
996: Adapter->FirstInitialization = FALSE;
997: Adapter->BringUp = TRUE;
998:
999: }
1000:
1001: NdisReadRegisterUchar(&(BringUpSrb->InitStatus), &RegValue);
1002:
1003: if (RegValue & 0x01) {
1004:
1005: #if DBG
1006: if (IbmtokDbg) DbgPrint("IBMTOK: 16 Mbps\n");
1007: #endif
1008:
1009: Adapter->Running16Mbps = TRUE;
1010:
1011: } else {
1012:
1013: Adapter->Running16Mbps = FALSE;
1014:
1015: }
1016:
1017: //
1018: // ZZZ: This code assumes that there is no shared ram paging and
1019: // that the MappedSharedRam is all that is available.
1020: //
1021:
1022:
1023: #if DBG
1024: if (IbmtokDbg) DbgPrint( "IBMTOK: shared RAM size is %x (%d)\n", Adapter->MappedSharedRam, Adapter->MappedSharedRam );
1025: #endif
1026: if (Adapter->MappedSharedRam > 0x2000){
1027:
1028: ULONG RamAvailable;
1029: UCHAR NumTransmitBuffers = (UCHAR)Adapter->NumberOfTransmitBuffers;
1030:
1031: //
1032: // 2096 is the amount of shared ram that is current sucked
1033: // up by the areas found on page 7-27 of the Tech. Ref.
1034: //
1035: //
1036:
1037: RamAvailable = Adapter->MappedSharedRam;
1038:
1039: if (Adapter->MappedSharedRam == 0x10000){
1040:
1041: //
1042: // Subtract an extra 8K to account for when we map
1043: // MMIO space to the top 8K of RAM.
1044: //
1045:
1046: RamAvailable = RamAvailable - 2096 - 0x2000;
1047:
1048: } else {
1049:
1050: RamAvailable = RamAvailable - 1584;
1051:
1052: }
1053: #if DBG
1054: if (IbmtokDbg) DbgPrint( "IBMTOK: RAM available is %x (%d)\n", RamAvailable, RamAvailable );
1055: #endif
1056:
1057: //
1058: // The card has more than 8K of ram, so adjust
1059: // transmit buffer size to abuse this.
1060: //
1061:
1062: if (Adapter->Running16Mbps) {
1063:
1064: //
1065: // Use the maximum allowed
1066: //
1067:
1068: Adapter->TransmitBufferLength = Adapter->Max16MbpsDhb;
1069: #if DBG
1070: if (IbmtokDbg) DbgPrint( "IBMTOK: 16 MB ring. Transmit buffer length is %x (%d)\n", Adapter->TransmitBufferLength, Adapter->TransmitBufferLength );
1071: #endif
1072:
1073: } else {
1074:
1075: //
1076: // Use the maximum allowed
1077: //
1078: Adapter->TransmitBufferLength = Adapter->Max4MbpsDhb;
1079: #if DBG
1080: if (IbmtokDbg) DbgPrint( "IBMTOK: 4 MB ring. Transmit buffer length is %x (%d)\n", Adapter->TransmitBufferLength, Adapter->TransmitBufferLength );
1081: #endif
1082:
1083: }
1084:
1085: //
1086: // First we subtract off buffer space for receiving the
1087: // maximum sized packet that can be on the wire. This is
1088: // the *minimum* number of receive buffers and may be
1089: // modified below if the transmit space does not take up
1090: // the rest.
1091: //
1092:
1093: #if DBG
1094: if (IbmtokDbg) DbgPrint( "IBMTOK: Receive buffer length is %x (%d)\n", Adapter->ReceiveBufferLength, Adapter->ReceiveBufferLength );
1095: #endif
1096: if (RamAvailable < Adapter->TransmitBufferLength) {
1097:
1098: //
1099: // There is not enough buffer space for even a single maximum
1100: // sized frame. So, just divide the buffer space into two
1101: // equally sized areas -- receive and transmit.
1102: //
1103:
1104: Adapter->NumberOfReceiveBuffers = (USHORT)((RamAvailable / 2) /
1105: Adapter->ReceiveBufferLength)
1106: + 1;
1107: #if DBG
1108: if (IbmtokDbg) DbgPrint( "IBMTOK: RAM too small. # receive buffers is %x (%d)\n", Adapter->NumberOfReceiveBuffers, Adapter->NumberOfReceiveBuffers );
1109: #endif
1110:
1111: } else {
1112:
1113: Adapter->NumberOfReceiveBuffers = (USHORT)(Adapter->TransmitBufferLength /
1114: Adapter->ReceiveBufferLength) + 1;
1115: #if DBG
1116: if (IbmtokDbg) DbgPrint( "IBMTOK: RAM large enough. # receive buffers is %x (%d)\n", Adapter->NumberOfReceiveBuffers, Adapter->NumberOfReceiveBuffers );
1117: #endif
1118:
1119: }
1120:
1121: RamAvailable = RamAvailable -
1122: (Adapter->NumberOfReceiveBuffers * Adapter->ReceiveBufferLength);
1123: #if DBG
1124: if (IbmtokDbg) {
1125: DbgPrint( "IBMTOK: RAM available for transmit is %x (%d)\n", RamAvailable, RamAvailable );
1126: DbgPrint( "IBMTOK: # transmit buffers is %x (%d)\n", NumTransmitBuffers, NumTransmitBuffers );
1127: }
1128: #endif
1129:
1130: if (Adapter->TransmitBufferLength > (RamAvailable / NumTransmitBuffers)) {
1131:
1132: if ((RamAvailable / NumTransmitBuffers) < 0x1000) {
1133:
1134: Adapter->TransmitBufferLength = 0x800;
1135:
1136: } else if ((RamAvailable / NumTransmitBuffers) < 0x2000) {
1137:
1138: Adapter->TransmitBufferLength = 0x1000;
1139:
1140: } else if ((RamAvailable / NumTransmitBuffers) < 0x4000) {
1141:
1142: Adapter->TransmitBufferLength = 0x2000;
1143:
1144: } else {
1145:
1146: Adapter->TransmitBufferLength = 0x4000;
1147:
1148: }
1149:
1150: #if DBG
1151: if (IbmtokDbg) DbgPrint( "IBMTOK: RAM too small. Transmit buffer length is %x (%d)\n", Adapter->TransmitBufferLength, Adapter->TransmitBufferLength );
1152: #endif
1153: }
1154:
1155:
1156: //
1157: // If computed value is greater than the value that the
1158: // registry allows, then use the registry value.
1159: //
1160:
1161: #if DBG
1162: if (IbmtokDbg) DbgPrint( "IBMTOK: Original max transmit length is %x (%d)\n", Adapter->MaxTransmittablePacket, Adapter->MaxTransmittablePacket );
1163: #endif
1164: if (Adapter->TransmitBufferLength > Adapter->MaxTransmittablePacket) {
1165:
1166: Adapter->TransmitBufferLength = Adapter->MaxTransmittablePacket;
1167: #if DBG
1168: if (IbmtokDbg) DbgPrint( "IBMTOK: Max too small. Transmit buffer length is %x (%d)\n", Adapter->TransmitBufferLength, Adapter->TransmitBufferLength );
1169: #endif
1170:
1171: }
1172:
1173: Adapter->MaxTransmittablePacket = Adapter->TransmitBufferLength - 6;
1174: #if DBG
1175: if (IbmtokDbg) DbgPrint( "IBMTOK: New max transmit length is %x (%d)\n", Adapter->MaxTransmittablePacket, Adapter->MaxTransmittablePacket );
1176: #endif
1177:
1178: //
1179: // Remove space taken up by transmit buffers.
1180: //
1181:
1182: RamAvailable = RamAvailable - ((ULONG)NumTransmitBuffers *
1183: (ULONG)Adapter->TransmitBufferLength);
1184:
1185: //
1186: // Add in any left over space for receive buffers.
1187: //
1188:
1189: Adapter->NumberOfReceiveBuffers += (USHORT)(RamAvailable /
1190: Adapter->ReceiveBufferLength);
1191: #if DBG
1192: if (IbmtokDbg) DbgPrint( "IBMTOK: New # receive buffers is %x (%d)\n", Adapter->NumberOfReceiveBuffers, Adapter->NumberOfReceiveBuffers );
1193: #endif
1194:
1195: } else {
1196:
1197: Adapter->TransmitBufferLength = 0x800;
1198: Adapter->NumberOfTransmitBuffers = 1;
1199: #if DBG
1200: if (IbmtokDbg) {
1201: DbgPrint( "IBMTOK: Only 8K shared RAM. Transmit buffer length is %x (%d)\n", Adapter->TransmitBufferLength, Adapter->TransmitBufferLength );
1202: DbgPrint( "IBMTOK: Transmit buffer length is %x (%d)\n", Adapter->TransmitBufferLength, Adapter->TransmitBufferLength );
1203: }
1204: #endif
1205:
1206: //
1207: // There is only 8K of buffer space, which is not enough space for
1208: // receiving and transmitting packets on even a 4Mbit ring. So,
1209: // use some reasonable values for transmit and receive space.
1210: //
1211:
1212: // If computed value is greater than the value that the
1213: // registry allows, then use the registry value.
1214: //
1215:
1216: #if DBG
1217: if (IbmtokDbg) DbgPrint( "IBMTOK: Original max transmit length is %x (%d)\n", Adapter->MaxTransmittablePacket, Adapter->MaxTransmittablePacket );
1218: #endif
1219: if (Adapter->TransmitBufferLength > Adapter->MaxTransmittablePacket) {
1220:
1221: Adapter->TransmitBufferLength = Adapter->MaxTransmittablePacket;
1222: #if DBG
1223: if (IbmtokDbg) DbgPrint( "IBMTOK: Max too small. Transmit buffer length is %x (%d)\n", Adapter->TransmitBufferLength, Adapter->TransmitBufferLength );
1224: #endif
1225:
1226: }
1227:
1228: Adapter->MaxTransmittablePacket = Adapter->TransmitBufferLength - 6;
1229:
1230: Adapter->NumberOfReceiveBuffers = 15;
1231: #if DBG
1232: if (IbmtokDbg) {
1233: DbgPrint( "IBMTOK: New max transmit length is %x (%d)\n", Adapter->MaxTransmittablePacket, Adapter->MaxTransmittablePacket );
1234: DbgPrint( "IBMTOK: # receive buffers is %x (%d)\n", Adapter->NumberOfReceiveBuffers, Adapter->NumberOfReceiveBuffers );
1235: }
1236: #endif
1237:
1238: }
1239:
1240: #if DBG
1241: if (IbmtokDbg) {
1242: DbgPrint("IBMTOK: Space: 0x%x, # Rcv: 0x%x, TransmitSize: 0x%x\n",
1243: Adapter->RrrLowValue,
1244: Adapter->NumberOfReceiveBuffers,
1245: Adapter->MaxTransmittablePacket
1246: );
1247: }
1248: #endif
1249:
1250: NdisReadRegisterUshort(&(BringUpSrb->EncodedAddressPointer), &RegValue);
1251:
1252: EncodedAddress = (PUCHAR)
1253: SRAM_PTR_TO_PVOID(Adapter,RegValue);
1254:
1255: IBMTOK_MOVE_FROM_MAPPED_MEMORY(Adapter->PermanentNetworkAddress, EncodedAddress,
1256: TR_LENGTH_OF_ADDRESS);
1257:
1258:
1259: if ((Adapter->NetworkAddress[0] == 0x00) &&
1260: (Adapter->NetworkAddress[1] == 0x00) &&
1261: (Adapter->NetworkAddress[2] == 0x00) &&
1262: (Adapter->NetworkAddress[3] == 0x00) &&
1263: (Adapter->NetworkAddress[4] == 0x00) &&
1264: (Adapter->NetworkAddress[5] == 0x00)) {
1265:
1266:
1267: IBMTOK_MOVE_FROM_MAPPED_MEMORY(Adapter->NetworkAddress, EncodedAddress,
1268: TR_LENGTH_OF_ADDRESS);
1269: }
1270:
1271: //
1272: // If required, we have to zero the upper section
1273: // of the Shared RAM now.
1274: //
1275: //
1276: // THIS DOESN'T WORK! It hangs the system while
1277: // zeroing the first address. (One gets an infinite number of
1278: // hardware interrupts w/o any reason)
1279: //
1280:
1281: #if 0
1282: if (Adapter->UpperSharedRamZero) {
1283:
1284: PUCHAR ZeroPointer;
1285: UINT i;
1286: PUCHAR OldSharedRam;
1287: NDIS_PHYSICAL_ADDRESS PhysicalAddress;
1288:
1289: #if DBG
1290: if (IbmtokDbg) DbgPrint("IBMTOK: Zeroing Memory\n");
1291: #endif
1292:
1293:
1294: if (Adapter->MappedSharedRam < 0x10000) {
1295:
1296: //
1297: // This portion of memory is not currently mapped, so do it.
1298: //
1299:
1300: OldSharedRam = Adapter->SharedRam;
1301:
1302: NdisSetPhysicalAddressHigh(PhysicalAddress, 0);
1303: NdisSetPhysicalAddressLow(PhysicalAddress, (Adapter->RrrLowValue << 12) + (0x10000 - 512));
1304:
1305: NdisMapIoSpace(
1306: &Status,
1307: &(Adapter->SharedRam),
1308: Adapter->NdisAdapterHandle,
1309: PhysicalAddress,
1310: 512);
1311:
1312: if (Status != NDIS_STATUS_SUCCESS) {
1313:
1314: NdisWriteErrorLogEntry(
1315: Adapter->NdisAdapterHandle,
1316: NDIS_ERROR_CODE_RESOURCE_CONFLICT,
1317: 0
1318: );
1319:
1320: return(Status);
1321:
1322: }
1323:
1324: }
1325:
1326: if (Adapter->SharedRamPaging){
1327:
1328: SETUP_SRPR(Adapter, SHARED_RAM_ZERO_OFFSET);
1329:
1330: #if DBG
1331: if (IbmtokDbg) DbgPrint("IBMTOK: Shared RAM paging enabled\n");
1332: #endif
1333:
1334: ZeroPointer =
1335: SHARED_RAM_ADDRESS(Adapter,
1336: SHARED_RAM_LOW_BITS(SHARED_RAM_ZERO_OFFSET));
1337:
1338: } else {
1339:
1340: if (Adapter->MappedSharedRam < 0x10000) {
1341:
1342: //
1343: // No offset for this portion, since we just mapped it.
1344: //
1345: //
1346:
1347: ZeroPointer = SHARED_RAM_ADDRESS(Adapter, 0);
1348:
1349: } else {
1350:
1351: ZeroPointer =
1352: SHARED_RAM_ADDRESS(Adapter, SHARED_RAM_ZERO_OFFSET);
1353:
1354: }
1355:
1356: }
1357:
1358: for (i=0; i<SHARED_RAM_ZERO_LENGTH; i++) {
1359:
1360: NdisWriteRegisterUchar(&(ZeroPointer[i]), 0x00);
1361:
1362: }
1363:
1364: if (Adapter->MappedSharedRam < 0x10000) {
1365:
1366: //
1367: // Unmap it
1368: //
1369:
1370: NdisUnmapIoSpace(Adapter->NdisAdapterHandle,
1371: Adapter->SharedRam,
1372: 512);
1373:
1374: Adapter->SharedRam = OldSharedRam;
1375:
1376: }
1377:
1378: }
1379: #endif
1380:
1381:
1382: //
1383: // Now set the timer to the maximum...we still need it
1384: // as a card heartbeat.
1385: //
1386:
1387: WRITE_ADAPTER_REGISTER(Adapter, TVR_HIGH, 0xff);
1388:
1389: return NDIS_STATUS_SUCCESS;
1390:
1391: }
1392:
1393: }
1394:
1395: STATIC
1396: NDIS_STATUS
1397: IbmtokOpenAdapter(
1398: OUT PNDIS_STATUS OpenErrorStatus,
1399: OUT NDIS_HANDLE *MacBindingHandle,
1400: OUT PUINT SelectedMediumIndex,
1401: IN PNDIS_MEDIUM MediumArray,
1402: IN UINT MediumArraySize,
1403: IN NDIS_HANDLE NdisBindingContext,
1404: IN NDIS_HANDLE MacAdapterContext,
1405: IN UINT OpenOptions,
1406: IN PSTRING AddressingInformation OPTIONAL
1407: )
1408:
1409: /*++
1410:
1411: Routine Description:
1412:
1413: OpenErrorStatus - Returns more information about the error status. In
1414: this card it is not used, since this code returns either success or
1415: pending, no failure is possible.
1416:
1417: This routine is used to create an open instance of an adapter, in effect
1418: creating a binding between an upper-level module and the MAC module over
1419: the adapter.
1420:
1421: Arguments:
1422:
1423: OpenErrorStatus - Returns more information about the error status. In
1424: this card it is not used, since this code returns either success or
1425: pending, no failure is possible.
1426:
1427: MacBindingHandle - A pointer to a location in which the MAC stores
1428: a context value that it uses to represent this binding.
1429:
1430:
1431: SelectedMediumIndex - An index into the MediumArray of the medium
1432: typedef that the MAC wishes to viewed as.
1433:
1434: MediumArray - An array of medium types which the protocol supports.
1435:
1436: MediumArraySize - The number of elements in MediumArray.
1437:
1438: NdisBindingContext - A value to be recorded by the MAC and passed as
1439: context whenever an indication is delivered by the MAC for this binding.
1440:
1441: MacAdapterContext - The value associated with the adapter that is being
1442: opened when the MAC registered the adapter with NdisRegisterAdapter.
1443:
1444: IN UINT OpenOptions,
1445:
1446: AddressingInformation - An optional pointer to a variable length string
1447: containing hardware-specific information that can be used to program the
1448: device. (This is not used by this MAC.)
1449:
1450: Return Value:
1451:
1452: The function value is the status of the operation. If the MAC does not
1453: complete this request synchronously, the value would be
1454: NDIS_STATUS_PENDING.
1455:
1456:
1457: --*/
1458:
1459: {
1460:
1461: //
1462: // The IBMTOK_ADAPTER that this open binding should belong too.
1463: //
1464: PIBMTOK_ADAPTER Adapter;
1465:
1466: //
1467: // Holds the status that should be returned to the caller.
1468: //
1469: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
1470:
1471: //
1472: // Pointer to the space allocated for the binding.
1473: //
1474: PIBMTOK_OPEN NewOpen;
1475:
1476: //
1477: // Generic loop variable
1478: //
1479: UINT i;
1480:
1481:
1482: UNREFERENCED_PARAMETER(AddressingInformation);
1483:
1484: *OpenErrorStatus = (NDIS_STATUS)0;
1485:
1486: //
1487: // Search for the medium type (token ring)
1488: //
1489:
1490: for(i=0; i < MediumArraySize; i++){
1491:
1492: if (MediumArray[i] == NdisMedium802_5){
1493:
1494: break;
1495:
1496: }
1497:
1498: }
1499:
1500: if (i == MediumArraySize){
1501:
1502: return(NDIS_STATUS_UNSUPPORTED_MEDIA);
1503:
1504: }
1505:
1506: *SelectedMediumIndex = i;
1507:
1508: Adapter = PIBMTOK_ADAPTER_FROM_CONTEXT_HANDLE(MacAdapterContext);
1509:
1510: NdisInterlockedAddUlong((PULONG)&Adapter->References, 1, &Adapter->Lock);
1511:
1512: //
1513: // Allocate the space for the open binding. Fill in the fields.
1514: //
1515:
1516: if (IBMTOK_ALLOC_PHYS(&NewOpen, sizeof(IBMTOK_OPEN)) ==
1517: NDIS_STATUS_SUCCESS){
1518:
1519: *MacBindingHandle = BINDING_HANDLE_FROM_PIBMTOK_OPEN(NewOpen);
1520: InitializeListHead(&NewOpen->OpenList);
1521: NewOpen->NdisBindingContext = NdisBindingContext;
1522: NewOpen->References = 0;
1523: NewOpen->BindingShuttingDown = FALSE;
1524: NewOpen->OwningIbmtok = Adapter;
1525: NewOpen->OpenPending = FALSE;
1526:
1527: NdisAcquireSpinLock(&Adapter->Lock);
1528: if (!TrNoteFilterOpenAdapter(
1529: NewOpen->OwningIbmtok->FilterDB,
1530: NewOpen,
1531: NdisBindingContext,
1532: &NewOpen->NdisFilterHandle
1533: )) {
1534:
1535: NdisReleaseSpinLock(&Adapter->Lock);
1536:
1537: NdisWriteErrorLogEntry(
1538: Adapter->NdisAdapterHandle,
1539: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
1540: 2,
1541: openAdapter,
1542: IBMTOK_ERRMSG_OPEN_DB
1543: );
1544:
1545: IBMTOK_FREE_PHYS(NewOpen, sizeof(IBMTOK_OPEN));
1546:
1547: StatusToReturn = NDIS_STATUS_FAILURE;
1548: NdisAcquireSpinLock(&Adapter->Lock);
1549:
1550: } else {
1551:
1552: //
1553: // Everything has been filled in. Synchronize access to the
1554: // adapter block and link the new open adapter in and increment
1555: // the opens reference count to account for the fact that the
1556: // filter routines have a "reference" to the open.
1557: //
1558:
1559: NewOpen->LookAhead = IBMTOK_MAX_LOOKAHEAD;
1560:
1561: Adapter->LookAhead = IBMTOK_MAX_LOOKAHEAD;
1562:
1563: InsertTailList(&Adapter->OpenBindings,&NewOpen->OpenList);
1564: NewOpen->References++;
1565:
1566: //
1567: // Now see if the adapter is currently open.
1568: //
1569:
1570: if (Adapter->AdapterNotOpen) {
1571:
1572: //
1573: // The adapter is not open, so this has to pend.
1574: //
1575: NewOpen->OpenPending = TRUE;
1576:
1577: StatusToReturn = NDIS_STATUS_PENDING;
1578:
1579: if (!Adapter->OpenInProgress) {
1580:
1581: //
1582: // Fill in the SRB for the open if this is the first
1583: // one for the card.
1584: //
1585:
1586: PSRB_OPEN_ADAPTER OpenSrb;
1587:
1588: IF_LOG('o');
1589:
1590: Adapter->OpenInProgress = TRUE;
1591: Adapter->CurrentRingState = NdisRingStateOpening;
1592:
1593: NdisReleaseSpinLock(&Adapter->Lock);
1594:
1595: OpenSrb = (PSRB_OPEN_ADAPTER)
1596: (Adapter->SharedRam + Adapter->InitialWrbOffset);
1597:
1598: IBMTOK_ZERO_MAPPED_MEMORY(OpenSrb, sizeof(SRB_OPEN_ADAPTER));
1599:
1600: NdisWriteRegisterUchar(
1601: (PUCHAR)&OpenSrb->Command,
1602: SRB_CMD_OPEN_ADAPTER);
1603: NdisWriteRegisterUshort(
1604: (PUSHORT)&OpenSrb->OpenOptions,
1605: OPEN_CONTENDER);
1606:
1607: for (i=0; i < TR_LENGTH_OF_ADDRESS; i++) {
1608: NdisWriteRegisterUchar((PCHAR)&OpenSrb->NodeAddress[i],
1609: Adapter->NetworkAddress[i]
1610: );
1611: }
1612:
1613: WRITE_IBMSHORT(OpenSrb->ReceiveBufferNum,
1614: Adapter->NumberOfReceiveBuffers);
1615: WRITE_IBMSHORT(OpenSrb->ReceiveBufferLen,
1616: Adapter->ReceiveBufferLength);
1617:
1618: WRITE_IBMSHORT(OpenSrb->TransmitBufferLen,
1619: Adapter->TransmitBufferLength);
1620: NdisWriteRegisterUchar(
1621: (PUCHAR)&OpenSrb->TransmitBufferNum,
1622: (UCHAR)Adapter->NumberOfTransmitBuffers);
1623:
1624: WRITE_ADAPTER_REGISTER(Adapter, ISRA_HIGH_SET,
1625: ISRA_HIGH_COMMAND_IN_SRB);
1626:
1627: NdisAcquireSpinLock(&Adapter->Lock);
1628:
1629: }
1630:
1631: }
1632:
1633: }
1634:
1635: } else {
1636:
1637: NdisWriteErrorLogEntry(
1638: Adapter->NdisAdapterHandle,
1639: NDIS_ERROR_CODE_OUT_OF_RESOURCES,
1640: 2,
1641: openAdapter,
1642: IBMTOK_ERRMSG_ALLOC_MEM
1643: );
1644:
1645: return(NDIS_STATUS_RESOURCES);
1646:
1647: }
1648:
1649:
1650:
1651:
1652: //
1653: // This macro assumes it is called with the lock held,
1654: // and releases it.
1655: //
1656:
1657: IBMTOK_DO_DEFERRED(Adapter);
1658: return StatusToReturn;
1659: }
1660:
1661: VOID
1662: IbmtokAdjustMaxLookAhead(
1663: IN PIBMTOK_ADAPTER Adapter
1664: )
1665: /*++
1666:
1667: Routine Description:
1668:
1669: This routine finds the open with the maximum lookahead value and
1670: stores that in the adapter block.
1671:
1672: Arguments:
1673:
1674: Adapter - A pointer to the adapter block.
1675:
1676: Returns:
1677:
1678: None.
1679:
1680: --*/
1681: {
1682: ULONG CurrentMax = 0;
1683: PLIST_ENTRY CurrentLink;
1684: PIBMTOK_OPEN TempOpen;
1685:
1686: CurrentLink = Adapter->OpenBindings.Flink;
1687:
1688: while (CurrentLink != &(Adapter->OpenBindings)){
1689:
1690: TempOpen = CONTAINING_RECORD(
1691: CurrentLink,
1692: IBMTOK_OPEN,
1693: OpenList
1694: );
1695:
1696: if (TempOpen->LookAhead > CurrentMax) {
1697:
1698: CurrentMax = TempOpen->LookAhead;
1699:
1700: }
1701:
1702: CurrentLink = CurrentLink->Flink;
1703:
1704: }
1705:
1706: if (CurrentMax == 0) {
1707:
1708: CurrentMax = IBMTOK_MAX_LOOKAHEAD;
1709:
1710: }
1711:
1712: Adapter->LookAhead = CurrentMax;
1713:
1714: }
1715:
1716: STATIC
1717: NDIS_STATUS
1718: IbmtokCloseAdapter(
1719: IN NDIS_HANDLE MacBindingHandle
1720: )
1721:
1722: /*++
1723:
1724: Routine Description:
1725:
1726: This routine causes the MAC to close an open handle (binding).
1727:
1728: Arguments:
1729:
1730: MacBindingHandle - The context value returned by the MAC when the
1731: adapter was opened. In reality it is a PIBMTOK_OPEN.
1732:
1733: Return Value:
1734:
1735: The function value is the status of the operation.
1736:
1737:
1738: --*/
1739:
1740: {
1741:
1742: PIBMTOK_ADAPTER Adapter;
1743: PIBMTOK_OPEN Open;
1744:
1745: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
1746:
1747: Adapter = PIBMTOK_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
1748: Open = PIBMTOK_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
1749:
1750: //
1751: // Hold the lock while we update the reference counts for the
1752: // adapter and the open.
1753: //
1754:
1755: NdisAcquireSpinLock(&Adapter->Lock);
1756: Adapter->References++;
1757:
1758: if (!Open->BindingShuttingDown) {
1759:
1760: Open->References++;
1761:
1762: StatusToReturn = TrDeleteFilterOpenAdapter(
1763: Adapter->FilterDB,
1764: Open->NdisFilterHandle,
1765: NULL
1766: );
1767:
1768: //
1769: // If the status is successful that merely implies that
1770: // we were able to delete the reference to the open binding
1771: // from the filtering code. If we have a successful status
1772: // at this point we still need to check whether the reference
1773: // count to determine whether we can close.
1774: //
1775: //
1776: // The delete filter routine can return a "special" status
1777: // that indicates that there is a current NdisIndicateReceive
1778: // on this binding.
1779: //
1780:
1781:
1782: if (StatusToReturn == NDIS_STATUS_SUCCESS) {
1783:
1784: //
1785: // Check whether the reference count is two. If
1786: // it is then we can get rid of the memory for
1787: // this open.
1788: //
1789: // A count of two indicates one for this routine
1790: // and one for the filter which we *know* we can
1791: // get rid of.
1792: //
1793:
1794: if (Open->References == 2) {
1795:
1796: RemoveEntryList(&Open->OpenList);
1797:
1798: //
1799: // We are the only reference to the open. Remove
1800: // it from the open list and delete the memory.
1801: //
1802:
1803: RemoveEntryList(&Open->OpenList);
1804:
1805: if (Open->LookAhead == Adapter->LookAhead) {
1806:
1807: IbmtokAdjustMaxLookAhead(Adapter);
1808:
1809: }
1810:
1811: IBMTOK_FREE_PHYS(Open,sizeof(IBMTOK_OPEN));
1812:
1813: } else {
1814:
1815: Open->BindingShuttingDown = TRUE;
1816:
1817: //
1818: // Remove the open from the open list and put it on
1819: // the closing list.
1820: //
1821:
1822: RemoveEntryList(&Open->OpenList);
1823: InsertTailList(&Adapter->CloseList,&Open->OpenList);
1824:
1825: //
1826: // Account for this routines reference to the open
1827: // as well as reference because of the filtering.
1828: //
1829:
1830: Open->References -= 2;
1831:
1832: //
1833: // Change the status to indicate that we will
1834: // be closing this later.
1835: //
1836:
1837: StatusToReturn = NDIS_STATUS_PENDING;
1838:
1839: }
1840:
1841: } else if (StatusToReturn == NDIS_STATUS_PENDING) {
1842:
1843:
1844: //
1845: // If it pended, there may be
1846: // operations queued.
1847: //
1848:
1849: IbmtokProcessSrbRequests(Adapter);
1850:
1851: //
1852: // Now start closing down this open.
1853: //
1854:
1855: Open->BindingShuttingDown = TRUE;
1856:
1857: //
1858: // Remove the open from the open list and put it on
1859: // the closing list.
1860: //
1861:
1862: RemoveEntryList(&Open->OpenList);
1863: InsertTailList(&Adapter->CloseList,&Open->OpenList);
1864:
1865: //
1866: // Account for this routines reference to the open
1867: // as well as reference because of the filtering.
1868: //
1869:
1870: Open->References -= 2;
1871:
1872: } else if (StatusToReturn == NDIS_STATUS_CLOSING_INDICATING) {
1873:
1874: //
1875: // When we have this status it indicates that the filtering
1876: // code was currently doing an NdisIndicateReceive. It
1877: // would not be wise to delete the memory for the open at
1878: // this point. The filtering code will call our close action
1879: // routine upon return from NdisIndicateReceive and that
1880: // action routine will decrement the reference count for
1881: // the open.
1882: //
1883:
1884: Open->BindingShuttingDown = TRUE;
1885:
1886: //
1887: // This status is private to the filtering routine. Just
1888: // tell the caller the the close is pending.
1889: //
1890:
1891: StatusToReturn = NDIS_STATUS_PENDING;
1892:
1893: //
1894: // Remove the open from the open list and put it on
1895: // the closing list.
1896: //
1897:
1898: RemoveEntryList(&Open->OpenList);
1899: InsertTailList(&Adapter->CloseList,&Open->OpenList);
1900:
1901: //
1902: // Account for this routines reference to the open.
1903: //
1904:
1905: Open->References--;
1906:
1907: } else if (StatusToReturn == NDIS_STATUS_RESET_IN_PROGRESS) {
1908:
1909: Open->BindingShuttingDown = TRUE;
1910:
1911: //
1912: // Remove the open from the open list and put it on
1913: // the closing list.
1914: //
1915:
1916: RemoveEntryList(&Open->OpenList);
1917: InsertTailList(&Adapter->CloseDuringResetList,&Open->OpenList);
1918:
1919:
1920: //
1921: // Account for this routines reference to the open.
1922: //
1923:
1924: Open->References--;
1925:
1926: StatusToReturn = NDIS_STATUS_PENDING;
1927:
1928: } else {
1929:
1930: NdisWriteErrorLogEntry(
1931: Adapter->NdisAdapterHandle,
1932: NDIS_ERROR_CODE_DRIVER_FAILURE,
1933: 2,
1934: IBMTOK_ERRMSG_INVALID_STATUS,
1935: 1
1936: );
1937:
1938: }
1939:
1940: } else {
1941:
1942: StatusToReturn = NDIS_STATUS_CLOSING;
1943:
1944: }
1945:
1946:
1947: //
1948: // This macro assumes it is called with the lock held,
1949: // and releases it.
1950: //
1951:
1952: IBMTOK_DO_DEFERRED(Adapter);
1953: return StatusToReturn;
1954:
1955: }
1956:
1957: STATIC
1958: NDIS_STATUS
1959: IbmtokRequest(
1960: IN NDIS_HANDLE MacBindingHandle,
1961: IN PNDIS_REQUEST NdisRequest
1962: )
1963:
1964: /*++
1965:
1966: Routine Description:
1967:
1968: The IbmtokRequest allows a protocol to query and set information
1969: about the MAC.
1970:
1971: Arguments:
1972:
1973: MacBindingHandle - The context value returned by the MAC when the
1974: adapter was opened. In reality, it is a pointer to IBMTOK_OPEN.
1975:
1976: NdisRequest - A structure which contains the request type (Set or
1977: Query), an array of operations to perform, and an array for holding
1978: the results of the operations.
1979:
1980: Return Value:
1981:
1982: The function value is the status of the operation.
1983:
1984: --*/
1985:
1986: {
1987: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
1988:
1989: PIBMTOK_ADAPTER Adapter = PIBMTOK_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
1990: PIBMTOK_OPEN Open = PIBMTOK_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
1991:
1992: NdisAcquireSpinLock(&(Adapter->Lock));
1993:
1994: Adapter->References++;
1995:
1996: //
1997: // Process request
1998: //
1999:
2000: if (NdisRequest->RequestType == NdisRequestQueryInformation) {
2001:
2002: StatusToReturn = IbmtokQueryInformation(Adapter, Open, NdisRequest);
2003:
2004: } else if (NdisRequest->RequestType == NdisRequestSetInformation) {
2005:
2006:
2007: //
2008: // Make sure Adapter is in a valid state.
2009: //
2010:
2011: if (Adapter->Unplugged) {
2012:
2013: StatusToReturn = NDIS_STATUS_DEVICE_FAILED;
2014:
2015: } else if (!Adapter->NotAcceptingRequests) {
2016:
2017: //
2018: // Make sure the open instance is valid
2019: //
2020:
2021: if (!Open->BindingShuttingDown) {
2022:
2023: StatusToReturn = IbmtokSetInformation(Adapter,Open,NdisRequest);
2024:
2025: } else {
2026:
2027: StatusToReturn = NDIS_STATUS_CLOSING;
2028:
2029: }
2030:
2031: } else {
2032:
2033: if (Adapter->ResetInProgress) {
2034:
2035: StatusToReturn = NDIS_STATUS_RESET_IN_PROGRESS;
2036:
2037: } else if (Adapter->AdapterNotOpen) {
2038:
2039: StatusToReturn = NDIS_STATUS_FAILURE;
2040:
2041: } else {
2042:
2043: NdisWriteErrorLogEntry(
2044: Adapter->NdisAdapterHandle,
2045: NDIS_ERROR_CODE_DRIVER_FAILURE,
2046: 2,
2047: IBMTOK_ERRMSG_INVALID_STATE,
2048: 3
2049: );
2050:
2051: }
2052: }
2053: } else {
2054:
2055: StatusToReturn = NDIS_STATUS_NOT_RECOGNIZED;
2056:
2057: }
2058:
2059: IBMTOK_DO_DEFERRED(Adapter);
2060:
2061: return(StatusToReturn);
2062:
2063: }
2064:
2065: STATIC
2066: NDIS_STATUS
2067: IbmtokQueryProtocolInformation(
2068: IN PIBMTOK_ADAPTER Adapter,
2069: IN PIBMTOK_OPEN Open,
2070: IN NDIS_OID Oid,
2071: IN BOOLEAN GlobalMode,
2072: IN PVOID InfoBuffer,
2073: IN UINT BytesLeft,
2074: OUT PUINT BytesNeeded,
2075: OUT PUINT BytesWritten
2076: )
2077:
2078: /*++
2079:
2080: Routine Description:
2081:
2082: The IbmtokQueryProtocolInformation process a Query request for
2083: NDIS_OIDs that are specific to a binding about the MAC. Note that
2084: some of the OIDs that are specific to bindings are also queryable
2085: on a global basis. Rather than recreate this code to handle the
2086: global queries, I use a flag to indicate if this is a query for the
2087: global data or the binding specific data.
2088:
2089: Arguments:
2090:
2091: Adapter - a pointer to the adapter.
2092:
2093: Open - a pointer to the open instance.
2094:
2095: Oid - the NDIS_OID to process.
2096:
2097: GlobalMode - Some of the binding specific information is also used
2098: when querying global statistics. This is a flag to specify whether
2099: to return the global value, or the binding specific value.
2100:
2101: InfoBuffer - a pointer into the NdisRequest->InformationBuffer
2102: into which store the result of the query.
2103:
2104: BytesLeft - the number of bytes left in the InformationBuffer.
2105:
2106: BytesNeeded - If there is not enough room in the information buffer
2107: then this will contain the number of bytes needed to complete the
2108: request.
2109:
2110: BytesWritten - a pointer to the number of bytes written into the
2111: InformationBuffer.
2112:
2113: Return Value:
2114:
2115: The function value is the status of the operation.
2116:
2117: --*/
2118:
2119: {
2120: NDIS_MEDIUM Medium = NdisMedium802_5;
2121: ULONG GenericULong;
2122: USHORT GenericUShort;
2123: UCHAR GenericArray[6];
2124:
2125: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
2126:
2127: //
2128: // Common variables for pointing to result of query
2129: //
2130:
2131: PVOID MoveSource = (PVOID)(&GenericULong);
2132: ULONG MoveBytes = sizeof(GenericULong);
2133:
2134: NDIS_HARDWARE_STATUS HardwareStatus = NdisHardwareStatusReady;
2135:
2136: //
2137: // General Algorithm:
2138: //
2139: // Switch(Request)
2140: // Get requested information
2141: // Store results in a common variable.
2142: // Copy result in common variable to result buffer.
2143: //
2144:
2145: //
2146: // Switch on request type
2147: //
2148:
2149: switch (Oid) {
2150:
2151: case OID_GEN_MAC_OPTIONS:
2152:
2153: GenericULong = (ULONG)(NDIS_MAC_OPTION_TRANSFERS_NOT_PEND |
2154: NDIS_MAC_OPTION_RECEIVE_SERIALIZED
2155: );
2156:
2157: break;
2158:
2159: case OID_GEN_SUPPORTED_LIST:
2160:
2161: if (!GlobalMode){
2162: MoveSource = (PVOID)(IbmtokProtocolSupportedOids);
2163: MoveBytes = sizeof(IbmtokProtocolSupportedOids);
2164: } else {
2165: MoveSource = (PVOID)(IbmtokGlobalSupportedOids);
2166: MoveBytes = sizeof(IbmtokGlobalSupportedOids);
2167: }
2168: break;
2169:
2170: case OID_GEN_HARDWARE_STATUS:
2171:
2172:
2173: if (Adapter->ResetInProgress){
2174:
2175: HardwareStatus = NdisHardwareStatusReset;
2176:
2177: } else if ((Adapter->FirstInitialization) ||
2178: (Adapter->OpenInProgress)){
2179:
2180: HardwareStatus = NdisHardwareStatusInitializing;
2181:
2182: } else if (Adapter->NotAcceptingRequests){
2183:
2184: HardwareStatus = NdisHardwareStatusNotReady;
2185:
2186: } else
2187: HardwareStatus = NdisHardwareStatusReady;
2188:
2189:
2190: MoveSource = (PVOID)(&HardwareStatus);
2191: MoveBytes = sizeof(NDIS_HARDWARE_STATUS);
2192:
2193: break;
2194:
2195: case OID_GEN_MEDIA_SUPPORTED:
2196: case OID_GEN_MEDIA_IN_USE:
2197:
2198: MoveSource = (PVOID) (&Medium);
2199: MoveBytes = sizeof(NDIS_MEDIUM);
2200: break;
2201:
2202: case OID_GEN_MAXIMUM_LOOKAHEAD:
2203:
2204: GenericULong = IBMTOK_MAX_LOOKAHEAD;
2205:
2206: break;
2207:
2208:
2209: case OID_GEN_MAXIMUM_FRAME_SIZE:
2210: case OID_GEN_MAXIMUM_TOTAL_SIZE:
2211:
2212: GenericULong = (ULONG)(Adapter->MaxTransmittablePacket);
2213:
2214: if (Oid == OID_GEN_MAXIMUM_FRAME_SIZE) {
2215:
2216: //
2217: // For the receive frame size, we subtract the minimum
2218: // header size from the number.
2219: //
2220:
2221: GenericULong -= 14;
2222: }
2223:
2224: break;
2225:
2226:
2227: case OID_GEN_LINK_SPEED:
2228:
2229: GenericULong = (ULONG)(Adapter->Running16Mbps? 160000 : 40000);
2230:
2231: break;
2232:
2233:
2234: case OID_GEN_TRANSMIT_BUFFER_SPACE:
2235:
2236: GenericULong = (ULONG)(Adapter->NumberOfTransmitBuffers *
2237: Adapter->TransmitBufferLength);
2238:
2239: break;
2240:
2241: case OID_GEN_RECEIVE_BUFFER_SPACE:
2242:
2243: GenericULong = (ULONG)(Adapter->NumberOfReceiveBuffers *
2244: Adapter->ReceiveBufferLength);
2245:
2246: break;
2247:
2248: case OID_GEN_TRANSMIT_BLOCK_SIZE:
2249:
2250: GenericULong = (ULONG)(Adapter->TransmitBufferLength);
2251:
2252: break;
2253:
2254: case OID_GEN_RECEIVE_BLOCK_SIZE:
2255:
2256: GenericULong = (ULONG)(Adapter->ReceiveBufferLength);
2257:
2258: break;
2259:
2260: case OID_GEN_VENDOR_ID:
2261:
2262: NdisMoveMemory(
2263: (PVOID)&GenericULong,
2264: Adapter->PermanentNetworkAddress,
2265: 3
2266: );
2267: GenericULong &= 0xFFFFFF00;
2268:
2269: if (Adapter->UsingPcIoBus) {
2270:
2271: GenericULong |= 0x01;
2272:
2273: }
2274:
2275: MoveSource = (PVOID)(&GenericULong);
2276: MoveBytes = sizeof(GenericULong);
2277: break;
2278:
2279: case OID_GEN_VENDOR_DESCRIPTION:
2280:
2281: if (Adapter->UsingPcIoBus){
2282: MoveSource = (PVOID)"Ibm Token Ring Network Card for PC I/O bus.";
2283: MoveBytes = 44;
2284: } else {
2285: MoveSource = (PVOID)"Ibm Token Ring Network Card for MCA bus.";
2286: MoveBytes = 41;
2287: }
2288: break;
2289:
2290: case OID_GEN_DRIVER_VERSION:
2291:
2292: GenericUShort = (USHORT)((IBMTOK_NDIS_MAJOR_VERSION << 8) | IBMTOK_NDIS_MINOR_VERSION);
2293:
2294: MoveSource = (PVOID)(&GenericUShort);
2295: MoveBytes = sizeof(GenericUShort);
2296: break;
2297:
2298:
2299: case OID_GEN_CURRENT_PACKET_FILTER:
2300:
2301: if (GlobalMode) {
2302:
2303: GenericULong = (ULONG)(Adapter->CurrentPacketFilter);
2304:
2305: } else {
2306:
2307: GenericULong = (ULONG)(TR_QUERY_PACKET_FILTER(
2308: Adapter->FilterDB,
2309: Open->NdisFilterHandle));
2310:
2311: }
2312:
2313: break;
2314:
2315: case OID_GEN_CURRENT_LOOKAHEAD:
2316:
2317: if (!GlobalMode){
2318:
2319: GenericULong = Open->LookAhead;
2320:
2321: } else {
2322:
2323: PLIST_ENTRY CurrentLink;
2324: PIBMTOK_OPEN TempOpen;
2325:
2326: CurrentLink = Adapter->OpenBindings.Flink;
2327:
2328: GenericULong = 0;
2329:
2330: while (CurrentLink != &(Adapter->OpenBindings)){
2331:
2332: TempOpen = CONTAINING_RECORD(
2333: CurrentLink,
2334: IBMTOK_OPEN,
2335: OpenList
2336: );
2337:
2338: if (TempOpen->LookAhead > GenericULong) {
2339:
2340: GenericULong = TempOpen->LookAhead;
2341:
2342: if (GenericULong == IBMTOK_MAX_LOOKAHEAD) {
2343:
2344: break;
2345:
2346: }
2347: }
2348:
2349: CurrentLink = CurrentLink->Flink;
2350:
2351: }
2352:
2353: }
2354:
2355: break;
2356:
2357: case OID_802_5_PERMANENT_ADDRESS:
2358:
2359: TR_COPY_NETWORK_ADDRESS((PCHAR)GenericArray,
2360: Adapter->PermanentNetworkAddress);
2361:
2362: MoveSource = (PVOID)(GenericArray);
2363: MoveBytes = sizeof(Adapter->PermanentNetworkAddress);
2364:
2365: break;
2366:
2367: case OID_802_5_CURRENT_ADDRESS:
2368:
2369: TR_COPY_NETWORK_ADDRESS((PCHAR)GenericArray,
2370: Adapter->NetworkAddress);
2371:
2372: MoveSource = (PVOID)(GenericArray);
2373: MoveBytes = sizeof(Adapter->NetworkAddress);
2374:
2375: break;
2376:
2377: case OID_802_5_CURRENT_FUNCTIONAL:
2378:
2379: if (!GlobalMode){
2380:
2381: GenericULong = TR_QUERY_FILTER_BINDING_ADDRESS(
2382: Adapter->FilterDB,
2383: Open->NdisFilterHandle);
2384:
2385: } else {
2386:
2387: GenericULong = Adapter->CurrentCardFunctional & 0xffffffff;
2388:
2389: }
2390:
2391: //
2392: // Now we need to reverse the crazy thing.
2393: //
2394:
2395: GenericULong = (ULONG)(
2396: ((GenericULong >> 24) & 0xFF) |
2397: ((GenericULong >> 8) & 0xFF00) |
2398: ((GenericULong << 8) & 0xFF0000) |
2399: ((GenericULong << 24) & 0xFF000000)
2400: );
2401:
2402: break;
2403:
2404: case OID_802_5_CURRENT_GROUP:
2405:
2406: GenericULong = Adapter->CurrentCardGroup & 0xffffffff;
2407:
2408: //
2409: // Now we need to reverse the crazy thing.
2410: //
2411:
2412: GenericULong = (ULONG)(
2413: ((GenericULong >> 24) & 0xFF) |
2414: ((GenericULong >> 8) & 0xFF00) |
2415: ((GenericULong << 8) & 0xFF0000) |
2416: ((GenericULong << 24) & 0xFF000000)
2417: );
2418:
2419: break;
2420:
2421: default:
2422:
2423: StatusToReturn = NDIS_STATUS_NOT_SUPPORTED;
2424: break;
2425: }
2426:
2427: if (StatusToReturn == NDIS_STATUS_SUCCESS){
2428:
2429: if (MoveBytes > BytesLeft){
2430:
2431: //
2432: // Not enough room in InformationBuffer. Punt
2433: //
2434:
2435: *BytesNeeded = MoveBytes;
2436:
2437: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
2438:
2439: } else {
2440:
2441: //
2442: // Store result.
2443: //
2444:
2445: IBMTOK_MOVE_MEMORY(InfoBuffer, MoveSource, MoveBytes);
2446:
2447: (*BytesWritten) += MoveBytes;
2448:
2449: }
2450: }
2451:
2452: return(StatusToReturn);
2453: }
2454:
2455: STATIC
2456: NDIS_STATUS
2457: IbmtokQueryInformation(
2458: IN PIBMTOK_ADAPTER Adapter,
2459: IN PIBMTOK_OPEN Open,
2460: IN PNDIS_REQUEST NdisRequest
2461: )
2462: /*++
2463:
2464: Routine Description:
2465:
2466: The IbmtokQueryInformation is used by IbmtokRequest to query information
2467: about the MAC.
2468:
2469: Arguments:
2470:
2471: Adapter - A pointer to the adapter.
2472:
2473: Open - A pointer to a particular open instance.
2474:
2475: NdisRequest - A structure which contains the request type (Query),
2476: an array of operations to perform, and an array for holding
2477: the results of the operations.
2478:
2479: Return Value:
2480:
2481: The function value is the status of the operation.
2482:
2483: --*/
2484:
2485: {
2486:
2487: UINT BytesWritten = 0;
2488: UINT BytesNeeded = 0;
2489: UINT BytesLeft = NdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength;
2490: PUCHAR InfoBuffer = (PUCHAR)(NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer);
2491:
2492: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
2493:
2494:
2495: StatusToReturn = IbmtokQueryProtocolInformation(
2496: Adapter,
2497: Open,
2498: NdisRequest->DATA.QUERY_INFORMATION.Oid,
2499: FALSE,
2500: InfoBuffer,
2501: BytesLeft,
2502: &BytesNeeded,
2503: &BytesWritten
2504: );
2505:
2506: NdisRequest->DATA.QUERY_INFORMATION.BytesWritten = BytesWritten;
2507:
2508: NdisRequest->DATA.QUERY_INFORMATION.BytesNeeded = BytesNeeded;
2509:
2510: return(StatusToReturn);
2511: }
2512:
2513: STATIC
2514: NDIS_STATUS
2515: IbmtokSetInformation(
2516: IN PIBMTOK_ADAPTER Adapter,
2517: IN PIBMTOK_OPEN Open,
2518: IN PNDIS_REQUEST NdisRequest
2519: )
2520: /*++
2521:
2522: Routine Description:
2523:
2524: The IbmtokSetInformation is used by IbmtokRequest to set information
2525: about the MAC.
2526:
2527: Arguments:
2528:
2529: Adapter - A pointer to the adapter.
2530:
2531: Open - A pointer to an open instance.
2532:
2533: NdisRequest - A structure which contains the request type (Set),
2534: an array of operations to perform, and an array for holding
2535: the results of the operations.
2536:
2537: Return Value:
2538:
2539: The function value is the status of the operation.
2540:
2541: --*/
2542:
2543: {
2544:
2545: //
2546: // General Algorithm:
2547: //
2548: // Verify length
2549: // Switch(Request)
2550: // Process Request
2551: //
2552:
2553: UINT BytesNeeded = 0;
2554: UINT BytesLeft = NdisRequest->DATA.SET_INFORMATION.InformationBufferLength;
2555: PUCHAR InfoBuffer = (PUCHAR)(NdisRequest->DATA.SET_INFORMATION.InformationBuffer);
2556:
2557: //
2558: // Variables for the request
2559: //
2560:
2561: NDIS_OID Oid;
2562: UINT OidLength;
2563:
2564: //
2565: // Variables for holding the new values to be used.
2566: //
2567:
2568: ULONG LookAhead;
2569: ULONG Filter;
2570:
2571: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
2572:
2573:
2574: //
2575: // Get Oid and Length of request
2576: //
2577:
2578: Oid = NdisRequest->DATA.SET_INFORMATION.Oid;
2579:
2580: OidLength = BytesLeft;
2581:
2582: //
2583: // Verify length
2584: //
2585:
2586: if (OidLength != 4){
2587:
2588: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
2589:
2590: NdisRequest->DATA.SET_INFORMATION.BytesRead = 0;
2591: NdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
2592:
2593: return(StatusToReturn);
2594: }
2595:
2596: switch (Oid) {
2597:
2598: case OID_802_5_CURRENT_FUNCTIONAL:
2599:
2600: StatusToReturn = IbmtokChangeFunctionalAddress(
2601: Adapter,
2602: Open,
2603: NdisRequest,
2604: InfoBuffer
2605: );
2606:
2607: break;
2608:
2609: case OID_GEN_CURRENT_PACKET_FILTER:
2610:
2611: IBMTOK_MOVE_MEMORY(&Filter, InfoBuffer, 4);
2612:
2613: StatusToReturn = IbmtokSetPacketFilter(Adapter,
2614: Open,
2615: NdisRequest,
2616: Filter);
2617:
2618: break;
2619:
2620: case OID_802_5_CURRENT_GROUP:
2621:
2622: StatusToReturn = IbmtokSetGroupAddress(
2623: Adapter,
2624: Open,
2625: NdisRequest,
2626: InfoBuffer
2627: );
2628:
2629: break;
2630:
2631:
2632: case OID_GEN_PROTOCOL_OPTIONS:
2633:
2634: StatusToReturn = NDIS_STATUS_SUCCESS;
2635:
2636: break;
2637:
2638: case OID_GEN_CURRENT_LOOKAHEAD:
2639:
2640: IBMTOK_MOVE_MEMORY(&LookAhead, InfoBuffer, 4);
2641:
2642: if (LookAhead > IBMTOK_MAX_LOOKAHEAD) {
2643:
2644: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
2645:
2646: } else {
2647:
2648: if (LookAhead > Adapter->LookAhead) {
2649:
2650: Open->LookAhead = LookAhead;
2651:
2652: Adapter->LookAhead = LookAhead;
2653:
2654: } else {
2655:
2656: if ((Open->LookAhead == Adapter->LookAhead) &&
2657: (LookAhead < Open->LookAhead)) {
2658:
2659: Open->LookAhead = LookAhead;
2660:
2661: IbmtokAdjustMaxLookAhead(Adapter);
2662:
2663: } else {
2664:
2665: Open->LookAhead = LookAhead;
2666:
2667: }
2668:
2669: }
2670:
2671: }
2672:
2673: break;
2674:
2675: default:
2676:
2677: StatusToReturn = NDIS_STATUS_INVALID_OID;
2678:
2679: NdisRequest->DATA.SET_INFORMATION.BytesRead = 0;
2680: NdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
2681:
2682: break;
2683: }
2684:
2685: if (StatusToReturn == NDIS_STATUS_SUCCESS){
2686:
2687: NdisRequest->DATA.SET_INFORMATION.BytesRead = OidLength;
2688: NdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
2689:
2690: }
2691:
2692:
2693:
2694: return(StatusToReturn);
2695: }
2696:
2697: STATIC
2698: NDIS_STATUS
2699: IbmtokSetPacketFilter(
2700: IN PIBMTOK_ADAPTER Adapter,
2701: IN PIBMTOK_OPEN Open,
2702: IN PNDIS_REQUEST NdisRequest,
2703: IN UINT PacketFilter
2704: )
2705:
2706: /*++
2707:
2708: Routine Description:
2709:
2710: This routine processes the stages necessary to implement changing
2711: the packets that a protocol receives from the MAC.
2712:
2713: Arguments:
2714:
2715: Adapter - A pointer to the Adapter.
2716:
2717: Open - A pointer to the open instance.
2718:
2719: NdisRequest - A pointer to the request submitting the set command.
2720:
2721: PacketFilter - A bit mask that contains flags that correspond to specific
2722: classes of received packets. If a particular bit is set in the mask,
2723: then packet reception for that class of packet is enabled. If the
2724: bit is clear, then packets that fall into that class are not received
2725: by the client. A single exception to this rule is that if the promiscuous
2726: bit is set, then the client receives all packets on the network, regardless
2727: of the state of the other flags.
2728:
2729: Return Value:
2730:
2731: The function value is the status of the operation.
2732:
2733: --*/
2734:
2735: {
2736:
2737: //
2738: // Keeps track of the *MAC's* status. The status will only be
2739: // reset if the filter change action routine is called.
2740: //
2741: NDIS_STATUS StatusOfFilterChange = NDIS_STATUS_SUCCESS;
2742:
2743: //
2744: // Verify bits
2745: //
2746:
2747: if (PacketFilter & (NDIS_PACKET_TYPE_SOURCE_ROUTING |
2748: NDIS_PACKET_TYPE_MULTICAST |
2749: NDIS_PACKET_TYPE_PROMISCUOUS |
2750: NDIS_PACKET_TYPE_ALL_MULTICAST |
2751: NDIS_PACKET_TYPE_SMT |
2752: NDIS_PACKET_TYPE_MAC_FRAME
2753: )) {
2754:
2755: return(NDIS_STATUS_NOT_SUPPORTED);
2756:
2757: }
2758:
2759: //
2760: // Increment the open while it is going through the filtering
2761: // routines.
2762: //
2763:
2764: Open->References++;
2765:
2766: StatusOfFilterChange = TrFilterAdjust(
2767: Adapter->FilterDB,
2768: Open->NdisFilterHandle,
2769: NdisRequest,
2770: PacketFilter,
2771: TRUE
2772: );
2773: Open->References--;
2774:
2775: if (StatusOfFilterChange == NDIS_STATUS_PENDING) {
2776:
2777: //
2778: // If it pended, it will be in the pend
2779: // queue so we should start that up.
2780: //
2781:
2782: IbmtokProcessSrbRequests(Adapter);
2783:
2784: }
2785:
2786: return StatusOfFilterChange;
2787: }
2788:
2789: STATIC
2790: NDIS_STATUS
2791: IbmtokChangeFunctionalAddress(
2792: IN PIBMTOK_ADAPTER Adapter,
2793: IN PIBMTOK_OPEN Open,
2794: IN PNDIS_REQUEST NdisRequest,
2795: IN PUCHAR Address
2796: )
2797:
2798: /*++
2799:
2800: Routine Description:
2801:
2802: This routine processes the stages necessary to implement changing
2803: the packets that a protocol receives from the MAC.
2804:
2805:
2806: Note: The spin lock must be held before entering this routine.
2807:
2808: Arguments:
2809:
2810: Adapter - A pointer to the Adapter.
2811:
2812: Open - A pointer to the open instance.
2813:
2814: NdisRequest - A pointer to the request submitting the set command.
2815:
2816: Address - The new functional address.
2817:
2818: Return Value:
2819:
2820: The function value is the status of the operation.
2821:
2822: --*/
2823:
2824: {
2825:
2826: //
2827: // Keeps track of the *MAC's* status. The status will only be
2828: // reset if the address change action routine is called.
2829: //
2830: NDIS_STATUS StatusOfChange = NDIS_STATUS_SUCCESS;
2831:
2832: //
2833: // Increment the open while it is going through the filtering
2834: // routines.
2835: //
2836:
2837: Open->References++;
2838:
2839: StatusOfChange = TrChangeFunctionalAddress(
2840: Open->OwningIbmtok->FilterDB,
2841: Open->NdisFilterHandle,
2842: NdisRequest,
2843: Address,
2844: TRUE
2845: );
2846:
2847: Open->References--;
2848:
2849: if (StatusOfChange == NDIS_STATUS_PENDING) {
2850:
2851: //
2852: // If it pended, it will be in the pend
2853: // queue so we should start that up.
2854: //
2855:
2856: IbmtokProcessSrbRequests(Adapter);
2857:
2858: }
2859:
2860: return StatusOfChange;
2861: }
2862:
2863: STATIC
2864: NDIS_STATUS
2865: IbmtokSetGroupAddress(
2866: IN PIBMTOK_ADAPTER Adapter,
2867: IN PIBMTOK_OPEN Open,
2868: IN PNDIS_REQUEST NdisRequest,
2869: IN PUCHAR Address
2870: )
2871:
2872: /*++
2873:
2874: Routine Description:
2875:
2876: This routine processes the stages necessary to implement changing
2877: the packets that a protocol receives from the MAC.
2878:
2879:
2880: Note: The spin lock must be held before entering this routine.
2881:
2882: Arguments:
2883:
2884: Adapter - A pointer to the Adapter.
2885:
2886: Open - A pointer to the open instance.
2887:
2888: NdisRequest - A pointer to the request submitting the set command.
2889:
2890: Address - The new group address.
2891:
2892: Return Value:
2893:
2894: The function value is the status of the operation.
2895:
2896: --*/
2897:
2898: {
2899:
2900: //
2901: // Keeps track of the *MAC's* status. The status will only be
2902: // reset if the address change action routine is called.
2903: //
2904: NDIS_STATUS StatusOfChange = NDIS_STATUS_SUCCESS;
2905:
2906: //
2907: // Increment the open while it is going through the filtering
2908: // routines.
2909: //
2910:
2911: Open->References++;
2912:
2913: StatusOfChange = TrChangeGroupAddress(
2914: Open->OwningIbmtok->FilterDB,
2915: Open->NdisFilterHandle,
2916: NdisRequest,
2917: Address,
2918: TRUE
2919: );
2920:
2921: Open->References--;
2922:
2923: if (StatusOfChange == NDIS_STATUS_PENDING) {
2924:
2925: //
2926: // If it pended, it will be in the pend
2927: // queue so we should start that up.
2928: //
2929:
2930: IbmtokProcessSrbRequests(Adapter);
2931:
2932: }
2933:
2934: return StatusOfChange;
2935: }
2936:
2937: NDIS_STATUS
2938: IbmtokFillInGlobalData(
2939: IN PIBMTOK_ADAPTER Adapter,
2940: IN PNDIS_REQUEST NdisRequest
2941: )
2942:
2943: /*++
2944:
2945: Routine Description:
2946:
2947: This routine completes a GlobalStatistics request. It is critical that
2948: if information is needed from the Adapter->* fields, they have been
2949: updated before this routine is called.
2950:
2951: Arguments:
2952:
2953: Adapter - A pointer to the Adapter.
2954:
2955: NdisRequest - A structure which contains the request type (Global
2956: Query), an array of operations to perform, and an array for holding
2957: the results of the operations.
2958:
2959: Return Value:
2960:
2961: The function value is the status of the operation.
2962:
2963: --*/
2964: {
2965: //
2966: // General Algorithm:
2967: //
2968: // Switch(Request)
2969: // Get requested information
2970: // Store results in a common variable.
2971: // default:
2972: // Try protocol query information
2973: // If that fails, fail query.
2974: //
2975: // Copy result in common variable to result buffer.
2976: // Finish processing
2977:
2978: UINT BytesWritten = 0;
2979: UINT BytesNeeded = 0;
2980: UINT BytesLeft = NdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength;
2981: PUCHAR InfoBuffer = (PUCHAR)(NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer);
2982:
2983: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
2984:
2985: //
2986: // This variable holds result of query
2987: //
2988:
2989: ULONG GenericULong;
2990: ULONG MoveBytes = sizeof(ULONG) * 2 + sizeof(NDIS_OID);
2991:
2992:
2993: StatusToReturn = IbmtokQueryProtocolInformation(
2994: Adapter,
2995: NULL,
2996: NdisRequest->DATA.QUERY_INFORMATION.Oid,
2997: TRUE,
2998: InfoBuffer,
2999: BytesLeft,
3000: &BytesNeeded,
3001: &BytesWritten
3002: );
3003:
3004:
3005: if (StatusToReturn == NDIS_STATUS_NOT_SUPPORTED){
3006:
3007: StatusToReturn = NDIS_STATUS_SUCCESS;
3008:
3009: //
3010: // Switch on request type
3011: //
3012:
3013: switch (NdisRequest->DATA.QUERY_INFORMATION.Oid) {
3014:
3015: case OID_GEN_XMIT_OK:
3016:
3017: GenericULong = (ULONG)(Adapter->FramesTransmitted);
3018:
3019: break;
3020:
3021: case OID_GEN_RCV_OK:
3022:
3023: GenericULong = (ULONG)(Adapter->FramesReceived);
3024:
3025: break;
3026:
3027: case OID_GEN_XMIT_ERROR:
3028:
3029: GenericULong = (ULONG)(Adapter->FrameTransmitErrors);
3030:
3031: break;
3032:
3033: case OID_GEN_RCV_ERROR:
3034:
3035: GenericULong = (ULONG)(Adapter->FrameReceiveErrors);
3036:
3037: break;
3038:
3039: case OID_GEN_RCV_NO_BUFFER:
3040:
3041: GenericULong = (ULONG)(Adapter->ReceiveCongestionCount);
3042:
3043: break;
3044:
3045: case OID_802_5_LINE_ERRORS:
3046:
3047: GenericULong = (ULONG)(Adapter->LineErrors);
3048:
3049: break;
3050:
3051: case OID_802_5_LOST_FRAMES:
3052:
3053: GenericULong = (ULONG)(Adapter->LostFrames);
3054:
3055: break;
3056:
3057: case OID_802_5_LAST_OPEN_STATUS:
3058:
3059: GenericULong = (ULONG)(NDIS_STATUS_TOKEN_RING_OPEN_ERROR |
3060: (NDIS_STATUS)(Adapter->OpenErrorCode));
3061:
3062: break;
3063:
3064: case OID_802_5_CURRENT_RING_STATUS:
3065:
3066: GenericULong = (ULONG)(Adapter->LastNotifyStatus);
3067:
3068: break;
3069:
3070: case OID_802_5_CURRENT_RING_STATE:
3071:
3072: GenericULong = (ULONG)(Adapter->CurrentRingState);
3073:
3074: break;
3075:
3076: default:
3077:
3078: StatusToReturn = NDIS_STATUS_INVALID_OID;
3079:
3080: break;
3081:
3082: }
3083:
3084: if (StatusToReturn == NDIS_STATUS_SUCCESS){
3085:
3086: //
3087: // Check to make sure there is enough room in the
3088: // buffer to store the result.
3089: //
3090:
3091: if (BytesLeft >= sizeof(ULONG)) {
3092:
3093: //
3094: // Store the result.
3095: //
3096:
3097: IBMTOK_MOVE_MEMORY(
3098: (PVOID)InfoBuffer,
3099: (PVOID)(&GenericULong),
3100: sizeof(ULONG)
3101: );
3102:
3103: BytesWritten += sizeof(ULONG);
3104:
3105: } else {
3106:
3107: BytesNeeded = sizeof(ULONG) - BytesLeft;
3108:
3109: StatusToReturn = NDIS_STATUS_INVALID_LENGTH;
3110:
3111: }
3112:
3113: }
3114:
3115: }
3116:
3117: NdisRequest->DATA.QUERY_INFORMATION.BytesWritten = BytesWritten;
3118:
3119: NdisRequest->DATA.QUERY_INFORMATION.BytesNeeded = BytesNeeded;
3120:
3121: return(StatusToReturn);
3122: }
3123:
3124: STATIC
3125: NDIS_STATUS
3126: IbmtokQueryGlobalStatistics(
3127: IN NDIS_HANDLE MacAdapterContext,
3128: IN PNDIS_REQUEST NdisRequest
3129: )
3130:
3131: /*++
3132:
3133: Routine Description:
3134:
3135: The IbmtokQueryGlobalStatistics is used by the protocol to query
3136: global information about the MAC.
3137:
3138: Arguments:
3139:
3140: MacAdapterContext - The value associated with the adapter that is being
3141: opened when the MAC registered the adapter with NdisRegisterAdapter.
3142:
3143: NdisRequest - A structure which contains the request type (Query),
3144: an array of operations to perform, and an array for holding
3145: the results of the operations.
3146:
3147: Return Value:
3148:
3149: The function value is the status of the operation.
3150:
3151: --*/
3152:
3153: {
3154:
3155: //
3156: // General Algorithm:
3157: //
3158: //
3159: // Check if a request is going to pend...
3160: // If so, pend the entire operation.
3161: //
3162: // Else
3163: // Fill in the request block.
3164: //
3165: //
3166:
3167: PIBMTOK_ADAPTER Adapter = PIBMTOK_ADAPTER_FROM_CONTEXT_HANDLE(MacAdapterContext);
3168:
3169: NDIS_STATUS StatusToReturn = NDIS_STATUS_SUCCESS;
3170:
3171: //
3172: // Check if a request is valid and going to pend...
3173: // If so, pend the entire operation.
3174: //
3175:
3176: NdisInterlockedAddUlong((PULONG)&Adapter->References, 1 ,&(Adapter->Lock));
3177:
3178: //
3179: // Switch on request type
3180: //
3181:
3182: switch (NdisRequest->DATA.QUERY_INFORMATION.Oid) {
3183: case OID_GEN_SUPPORTED_LIST:
3184: case OID_GEN_HARDWARE_STATUS:
3185: case OID_GEN_MEDIA_SUPPORTED:
3186: case OID_GEN_MEDIA_IN_USE:
3187: case OID_GEN_MAXIMUM_LOOKAHEAD:
3188: case OID_GEN_MAXIMUM_FRAME_SIZE:
3189: case OID_GEN_MAXIMUM_TOTAL_SIZE:
3190: case OID_GEN_MAC_OPTIONS:
3191: case OID_GEN_LINK_SPEED:
3192: case OID_GEN_TRANSMIT_BUFFER_SPACE:
3193: case OID_GEN_RECEIVE_BUFFER_SPACE:
3194: case OID_GEN_TRANSMIT_BLOCK_SIZE:
3195: case OID_GEN_RECEIVE_BLOCK_SIZE:
3196: case OID_GEN_VENDOR_ID:
3197: case OID_GEN_DRIVER_VERSION:
3198: case OID_GEN_CURRENT_PACKET_FILTER:
3199: case OID_GEN_CURRENT_LOOKAHEAD:
3200: case OID_802_5_CURRENT_GROUP:
3201: case OID_802_5_LAST_OPEN_STATUS:
3202: case OID_802_5_CURRENT_RING_STATUS:
3203: case OID_802_5_CURRENT_RING_STATE:
3204: case OID_802_5_PERMANENT_ADDRESS:
3205: case OID_802_5_CURRENT_ADDRESS:
3206: case OID_802_5_CURRENT_FUNCTIONAL:
3207: break;
3208:
3209: case OID_GEN_XMIT_OK:
3210: case OID_GEN_RCV_OK:
3211: case OID_GEN_XMIT_ERROR:
3212: case OID_GEN_RCV_ERROR:
3213: case OID_GEN_RCV_NO_BUFFER:
3214: case OID_802_5_LINE_ERRORS:
3215: case OID_802_5_LOST_FRAMES:
3216:
3217: StatusToReturn = NDIS_STATUS_PENDING;
3218:
3219: break;
3220:
3221: default:
3222:
3223: StatusToReturn = NDIS_STATUS_INVALID_OID;
3224:
3225: break;
3226: }
3227:
3228: if (StatusToReturn == NDIS_STATUS_PENDING) {
3229:
3230: //
3231: // Build a pending operation
3232: //
3233:
3234: PIBMTOK_PEND_DATA PendOp = PIBMTOK_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest);
3235:
3236: PendOp->Next = NULL;
3237: PendOp->COMMAND.NDIS.STATISTICS.ReadLogPending = FALSE;
3238:
3239: NdisAcquireSpinLock(&Adapter->Lock);
3240:
3241: if (Adapter->PendQueue == NULL){
3242:
3243: Adapter->PendQueue = Adapter->EndOfPendQueue = PendOp;
3244:
3245: } else {
3246:
3247: Adapter->EndOfPendQueue->Next = PendOp;
3248:
3249: }
3250:
3251:
3252: //
3253: // It is now in the pend
3254: // queue so we should start that up.
3255: //
3256:
3257: IbmtokProcessSrbRequests(Adapter);
3258:
3259: NdisReleaseSpinLock(&Adapter->Lock);
3260:
3261: //
3262: // Defer subtracting from Adapter->Reference until the
3263: // request completes (see IbmtokFinishPendQueueOp()).
3264: //
3265:
3266: return(StatusToReturn);
3267:
3268: }
3269:
3270: if (StatusToReturn == NDIS_STATUS_SUCCESS){
3271:
3272: StatusToReturn = IbmtokFillInGlobalData(Adapter, NdisRequest);
3273:
3274: }
3275:
3276: NdisAcquireSpinLock(&Adapter->Lock);
3277:
3278: IBMTOK_DO_DEFERRED(Adapter);
3279:
3280: return(StatusToReturn);
3281: }
3282:
3283: STATIC
3284: NDIS_STATUS
3285: IbmtokReset(
3286: IN NDIS_HANDLE MacBindingHandle
3287: )
3288:
3289: /*++
3290:
3291: Routine Description:
3292:
3293: The IbmtokReset request instructs the MAC to issue a hardware reset
3294: to the network adapter. The MAC also resets its software state. See
3295: the description of NdisReset for a detailed description of this request.
3296:
3297: Arguments:
3298:
3299: MacBindingHandle - The context value returned by the MAC when the
3300: adapter was opened. In reality, it is a pointer to IBMTOK_OPEN.
3301:
3302: Return Value:
3303:
3304: The function value is the status of the operation.
3305:
3306:
3307: --*/
3308:
3309: {
3310:
3311: //
3312: // Holds the status that should be returned to the caller.
3313: //
3314: NDIS_STATUS StatusToReturn = NDIS_STATUS_PENDING;
3315:
3316: PIBMTOK_ADAPTER Adapter =
3317: PIBMTOK_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
3318:
3319: PIBMTOK_OPEN Open;
3320:
3321: //
3322: // Hold the locks while we update the reference counts on the
3323: // adapter and the open.
3324: //
3325:
3326: NdisAcquireSpinLock(&Adapter->Lock);
3327: Open = PIBMTOK_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
3328:
3329: Adapter->References++;
3330:
3331: if (Adapter->ResetInProgress) {
3332:
3333: StatusToReturn = NDIS_STATUS_RESET_IN_PROGRESS;
3334:
3335: } else if (Adapter->AdapterNotOpen) {
3336:
3337: StatusToReturn = NDIS_STATUS_FAILURE;
3338:
3339: } else {
3340:
3341: if (!Open->BindingShuttingDown) {
3342:
3343: Open->References++;
3344: IbmtokSetupForReset(
3345: Adapter,
3346: PIBMTOK_OPEN_FROM_BINDING_HANDLE(MacBindingHandle)
3347: );
3348: Open->References--;
3349:
3350: } else {
3351:
3352: StatusToReturn = NDIS_STATUS_CLOSING;
3353:
3354: }
3355:
3356: }
3357:
3358: //
3359: // This macro assumes it is called with the lock held,
3360: // and releases it.
3361: //
3362:
3363: IBMTOK_DO_DEFERRED(Adapter);
3364: return StatusToReturn;
3365:
3366: }
3367:
3368: STATIC
3369: NDIS_STATUS
3370: IbmtokChangeFilter(
3371: IN UINT OldFilterClasses,
3372: IN UINT NewFilterClasses,
3373: IN NDIS_HANDLE MacBindingHandle,
3374: IN PNDIS_REQUEST NdisRequest,
3375: IN BOOLEAN Set
3376: )
3377:
3378: /*++
3379:
3380: Routine Description:
3381:
3382: Action routine that will get called when a particular filter
3383: class is first used or last cleared.
3384:
3385: NOTE: This routine assumes that it is called with the lock
3386: acquired.
3387:
3388: Arguments:
3389:
3390: OldFilterClasses - The values of the class filter before it
3391: was changed.
3392:
3393: NewFilterClasses - The current value of the class filter
3394:
3395: MacBindingHandle - The context value returned by the MAC when the
3396: adapter was opened. In reality, it is a pointer to IBMTOK_OPEN.
3397:
3398: Set - If true the change resulted from a set, otherwise the
3399: change resulted from a open closing.
3400:
3401: Return Value:
3402:
3403: None.
3404:
3405: --*/
3406:
3407: {
3408:
3409:
3410: PIBMTOK_ADAPTER Adapter = PIBMTOK_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
3411:
3412: //
3413: // The open that made this request.
3414: //
3415: PIBMTOK_OPEN Open = PIBMTOK_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
3416:
3417: //
3418: // Holds the change that should be returned to the filtering package.
3419: //
3420: NDIS_STATUS StatusOfChange;
3421:
3422: if (NdisRequest == NULL) {
3423:
3424: NdisRequest = &(Open->CloseRequestChangeFilter);
3425:
3426: NdisRequest->RequestType = NdisRequestClose;
3427:
3428:
3429: }
3430:
3431:
3432: if (Adapter->ResetInProgress) {
3433:
3434: StatusOfChange = NDIS_STATUS_RESET_IN_PROGRESS;
3435:
3436: } else {
3437:
3438: //
3439: // The whole purpose of this routine is to determine whether
3440: // the filtering changes need to result in the hardware being
3441: // reset.
3442: //
3443:
3444: ASSERT(OldFilterClasses != NewFilterClasses);
3445:
3446: #if DBG
3447: if (IbmtokDbg) DbgPrint("IBMTOK: Change filter\n");
3448: #endif
3449:
3450: if (NewFilterClasses &
3451: (NDIS_PACKET_TYPE_PROMISCUOUS | NDIS_PACKET_TYPE_SOURCE_ROUTING)) {
3452:
3453: //
3454: // The adapter cannot support promiscuous mode, or
3455: // source routing which implies promiscuous.
3456: //
3457:
3458: StatusOfChange = NDIS_STATUS_FAILURE;
3459:
3460: } else {
3461:
3462: //
3463: // Queue this request.
3464: //
3465:
3466: PIBMTOK_PEND_DATA PendOp = PIBMTOK_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest);
3467:
3468: //
3469: // Store open block.
3470: //
3471:
3472: PendOp->COMMAND.NDIS.SET_FILTER.Open = Open;
3473:
3474: //
3475: // Hold new Filter value
3476: //
3477:
3478: if (PendOp->RequestType == NdisRequestClose){
3479:
3480: PendOp->COMMAND.NDIS.CLOSE.NewFilterValue = NewFilterClasses;
3481:
3482: } else {
3483:
3484: PendOp->COMMAND.NDIS.SET_FILTER.NewFilterValue = NewFilterClasses;
3485:
3486: }
3487:
3488:
3489: //
3490: // Insert into queue.
3491: //
3492:
3493: PendOp->Next = NULL;
3494:
3495: if (Adapter->PendQueue == NULL) {
3496:
3497: Adapter->PendQueue = Adapter->EndOfPendQueue = PendOp;
3498:
3499: } else {
3500:
3501: Adapter->EndOfPendQueue->Next = PendOp;
3502:
3503: }
3504:
3505: Open->References++;
3506:
3507: StatusOfChange = NDIS_STATUS_PENDING;
3508:
3509:
3510: }
3511:
3512: }
3513:
3514: return StatusOfChange;
3515:
3516: }
3517:
3518: STATIC
3519: NDIS_STATUS
3520: IbmtokChangeAddress(
3521: IN TR_FUNCTIONAL_ADDRESS OldFunctionalAddress,
3522: IN TR_FUNCTIONAL_ADDRESS NewFunctionalAddress,
3523: IN NDIS_HANDLE MacBindingHandle,
3524: IN PNDIS_REQUEST NdisRequest,
3525: IN BOOLEAN Set
3526: )
3527:
3528:
3529: /*++
3530:
3531: Routine Description:
3532:
3533: Action routine that will get called when an address is added to
3534: the filter that wasn't referenced by any other open binding.
3535:
3536: NOTE: This routine assumes that it is called with the lock
3537: acquired.
3538:
3539: Arguments:
3540:
3541: OldFunctionalAddress - The previous functional address.
3542:
3543: NewFunctionalAddress - The new functional address.
3544:
3545: MacBindingHandle - The context value returned by the MAC when the
3546: adapter was opened. In reality, it is a pointer to IBMTOK_OPEN.
3547:
3548: NdisRequest - A pointer to the Request that submitted the set command.
3549:
3550: Set - If true the change resulted from a set, otherwise the
3551: change resulted from a open closing.
3552:
3553: Return Value:
3554:
3555: None.
3556:
3557:
3558: --*/
3559:
3560: {
3561:
3562: PIBMTOK_ADAPTER Adapter = PIBMTOK_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
3563:
3564: //
3565: // Holds the status that should be returned to the filtering package.
3566: //
3567: NDIS_STATUS StatusOfChange;
3568:
3569: //
3570: // The open that made this request.
3571: //
3572: PIBMTOK_OPEN Open = PIBMTOK_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
3573:
3574: #if DBG
3575: if (IbmtokDbg) {
3576: DbgPrint("IBMTOK: Queueing:\n");
3577: DbgPrint(" Req : 0x%x\n", NdisRequest);
3578: DbgPrint(" Old : 0x%x\n", OldFunctionalAddress);
3579: DbgPrint(" New : 0x%x\n", NewFunctionalAddress);
3580: }
3581: #endif
3582:
3583: // Check to see if the device is already resetting. If it is
3584: // then reject this change.
3585: //
3586:
3587: if (NdisRequest == NULL) {
3588:
3589: NdisRequest = &(Open->CloseRequestChangeAddress);
3590:
3591: NdisRequest->RequestType = NdisRequestGeneric2; // Close, set address
3592:
3593: }
3594:
3595:
3596: if (Adapter->ResetInProgress) {
3597:
3598: #if DBG
3599: if (IbmtokDbg) {
3600: DbgPrint("IBMTOK: ResetInProgress\n\n");
3601: }
3602: #endif
3603:
3604: StatusOfChange = NDIS_STATUS_RESET_IN_PROGRESS;
3605:
3606: } else {
3607:
3608: //
3609: // Queue this request.
3610: //
3611:
3612: PIBMTOK_PEND_DATA PendOp = PIBMTOK_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest);
3613:
3614:
3615: //
3616: // Store open block.
3617: //
3618:
3619: PendOp->COMMAND.NDIS.SET_ADDRESS.Open = Open;
3620:
3621: //
3622: // Hold new Address value
3623: //
3624:
3625: PendOp->COMMAND.NDIS.SET_ADDRESS.NewAddressValue = NewFunctionalAddress;
3626:
3627:
3628: //
3629: // Insert into queue.
3630: //
3631:
3632: PendOp->Next = NULL;
3633:
3634: if (Adapter->PendQueue == NULL) {
3635:
3636: Adapter->PendQueue = Adapter->EndOfPendQueue = PendOp;
3637:
3638: } else {
3639:
3640: Adapter->EndOfPendQueue->Next = PendOp;
3641:
3642: }
3643:
3644: Open->References++;
3645:
3646: StatusOfChange = NDIS_STATUS_PENDING;
3647:
3648: }
3649:
3650: return StatusOfChange;
3651:
3652: }
3653:
3654: STATIC
3655: NDIS_STATUS
3656: IbmtokChangeGroupAddress(
3657: IN TR_FUNCTIONAL_ADDRESS OldGroupAddress,
3658: IN TR_FUNCTIONAL_ADDRESS NewGroupAddress,
3659: IN NDIS_HANDLE MacBindingHandle,
3660: IN PNDIS_REQUEST NdisRequest,
3661: IN BOOLEAN Set
3662: )
3663:
3664: /*++
3665:
3666: Routine Description:
3667:
3668: Action routine that will get called when a group address is to
3669: be changed.
3670:
3671: NOTE: This routine assumes that it is called with the lock
3672: acquired.
3673:
3674: Arguments:
3675:
3676: OldGroupAddress - The previous group address.
3677:
3678: NewGroupAddress - The new group address.
3679:
3680: MacBindingHandle - The context value returned by the MAC when the
3681: adapter was opened. In reality, it is a pointer to IBMTOK_OPEN.
3682:
3683: NdisRequest - A pointer to the Request that submitted the set command.
3684:
3685: Set - If true the change resulted from a set, otherwise the
3686: change resulted from a open closing.
3687:
3688: Return Value:
3689:
3690: None.
3691:
3692:
3693: --*/
3694:
3695: {
3696:
3697: PIBMTOK_ADAPTER Adapter = PIBMTOK_ADAPTER_FROM_BINDING_HANDLE(MacBindingHandle);
3698:
3699: //
3700: // Holds the status that should be returned to the filtering package.
3701: //
3702: NDIS_STATUS StatusOfChange;
3703:
3704: //
3705: // The open that made this request.
3706: //
3707: PIBMTOK_OPEN Open = PIBMTOK_OPEN_FROM_BINDING_HANDLE(MacBindingHandle);
3708:
3709:
3710: if (NdisRequest == NULL) {
3711:
3712: NdisRequest = &(Open->CloseRequestChangeGroupAddress);
3713:
3714: NdisRequest->RequestType = NdisRequestGeneric3; // Close, set group address
3715:
3716: }
3717:
3718:
3719: //
3720: // Check to see if the device is already resetting. If it is
3721: // then reject this change.
3722: //
3723:
3724: if (Adapter->ResetInProgress) {
3725:
3726: StatusOfChange = NDIS_STATUS_RESET_IN_PROGRESS;
3727:
3728: } else {
3729:
3730: //
3731: // Queue this request.
3732: //
3733:
3734: PIBMTOK_PEND_DATA PendOp = PIBMTOK_PEND_DATA_FROM_PNDIS_REQUEST(NdisRequest);
3735:
3736:
3737: //
3738: // Store open block.
3739: //
3740:
3741: PendOp->COMMAND.NDIS.SET_ADDRESS.Open = Open;
3742:
3743: //
3744: // Hold new Address value
3745: //
3746:
3747: PendOp->COMMAND.NDIS.SET_ADDRESS.NewAddressValue = NewGroupAddress;
3748:
3749:
3750: //
3751: // Insert into queue.
3752: //
3753:
3754: PendOp->Next = NULL;
3755:
3756: if (Adapter->PendQueue == NULL) {
3757:
3758: Adapter->PendQueue = Adapter->EndOfPendQueue = PendOp;
3759:
3760: } else {
3761:
3762: Adapter->EndOfPendQueue->Next = PendOp;
3763:
3764: }
3765:
3766: Open->References++;
3767:
3768: StatusOfChange = NDIS_STATUS_PENDING;
3769:
3770: }
3771:
3772: return StatusOfChange;
3773:
3774: }
3775:
3776: STATIC
3777: VOID
3778: IbmtokCloseAction(
3779: IN NDIS_HANDLE MacBindingHandle
3780: )
3781:
3782: /*++
3783:
3784: Routine Description:
3785:
3786: Action routine that will get called when a particular binding
3787: was closed while it was indicating through NdisIndicateReceive
3788:
3789: All this routine needs to do is to decrement the reference count
3790: of the binding.
3791:
3792: NOTE: This routine assumes that it is called with the lock acquired.
3793:
3794: Arguments:
3795:
3796: MacBindingHandle - The context value returned by the MAC when the
3797: adapter was opened. In reality, it is a pointer to IBMTOK_OPEN.
3798:
3799: Return Value:
3800:
3801: None.
3802:
3803:
3804: --*/
3805:
3806: {
3807:
3808: PIBMTOK_OPEN_FROM_BINDING_HANDLE(MacBindingHandle)->References--;
3809:
3810: }
3811:
3812: extern
3813: VOID
3814: IbmtokStartAdapterReset(
3815: IN PIBMTOK_ADAPTER Adapter
3816: )
3817:
3818: /*++
3819:
3820: Routine Description:
3821:
3822: This is the first phase of resetting the adapter hardware.
3823:
3824: It makes the following assumptions:
3825:
3826: 1) That the hardware has been stopped.
3827:
3828: 2) That it can not be preempted.
3829:
3830: 3) That no other adapter activity can occur.
3831:
3832: When this routine is finished all of the adapter information
3833: will be as if the driver was just initialized.
3834:
3835: Arguments:
3836:
3837: Adapter - The adapter whose hardware is to be reset.
3838:
3839: Return Value:
3840:
3841: None.
3842:
3843: --*/
3844: {
3845:
3846: //
3847: // Disable these so no pending interrupts
3848: // will fire.
3849: //
3850: CLEAR_ISRP_BITS(Adapter);
3851:
3852: //
3853: // OK, do the reset as detailed in the Tech Ref...
3854: //
3855:
3856: WRITE_ADAPTER_PORT(Adapter, RESET_LATCH, 0);
3857:
3858: NdisStallExecution(50000);
3859:
3860: WRITE_ADAPTER_PORT(Adapter, RESET_RELEASE, 0);
3861:
3862: //
3863: // Have to write this now to enable Shared RAM paging.
3864: //
3865: if (Adapter->SharedRamPaging) {
3866:
3867: WRITE_ADAPTER_REGISTER(Adapter, SRPR_LOW, 0xc0);
3868:
3869: }
3870:
3871:
3872:
3873: //
3874: // If this is a PC I/O Bus....
3875: // Set up the shared RAM to be right after the MMIO.
3876: //
3877:
3878: if (Adapter->UsingPcIoBus){
3879: WRITE_ADAPTER_REGISTER(Adapter, RRR_LOW, Adapter->RrrLowValue);
3880: }
3881:
3882:
3883:
3884: //
3885: // Allow the reset complete interrupt to be
3886: // serviced correctly.
3887: //
3888: SET_INTERRUPT_RESET_FLAG(Adapter);
3889:
3890: //
3891: // Enable card interrupts to get the reset interrupt.
3892: //
3893:
3894: WRITE_ADAPTER_REGISTER(Adapter, ISRP_LOW,
3895: ISRP_LOW_NO_CHANNEL_CHECK | ISRP_LOW_INTERRUPT_ENABLE);
3896:
3897:
3898: //
3899: // The remaining processing is done in the
3900: // interrupt handler.
3901: //
3902:
3903:
3904:
3905: //
3906: // OK, now abort pending requests before we nuke
3907: // everything.
3908: //
3909:
3910: NdisDprAcquireSpinLock (&Adapter->Lock);
3911:
3912: IbmtokAbortSends (Adapter, NDIS_STATUS_REQUEST_ABORTED);
3913:
3914: NdisDprReleaseSpinLock (&Adapter->Lock);
3915:
3916: }
3917:
3918: extern
3919: VOID
3920: IbmtokFinishAdapterReset(
3921: IN PIBMTOK_ADAPTER Adapter
3922: )
3923:
3924: /*++
3925:
3926: Routine Description:
3927:
3928: Called by HandleResetStaging when the last piece
3929: of the adapter reset is complete and normal
3930: operation can resume.
3931:
3932: Called with the lock held and returns with it held.
3933:
3934: Arguments:
3935:
3936: Adapter - The adapter that the reset is for.
3937:
3938: Return Value:
3939:
3940: None.
3941:
3942: --*/
3943:
3944: {
3945: PLIST_ENTRY CurrentLink;
3946: PIBMTOK_OPEN TempOpen;
3947:
3948:
3949: SetResetVariables(Adapter);
3950:
3951: if (Adapter->UnpluggedResetInProgress) {
3952: Adapter->UnpluggedResetInProgress = FALSE;
3953: Adapter->Unplugged = FALSE;
3954: Adapter->LobeWireFaultIndicated = FALSE;
3955: }
3956:
3957: Adapter->ResetInProgress = FALSE;
3958: Adapter->ResetInterruptAllowed = FALSE;
3959: Adapter->ResetInterruptHasArrived = FALSE;
3960: Adapter->NotAcceptingRequests = FALSE;
3961:
3962: //
3963: // Get any interrupts that have been deferred
3964: // while NotAcceptingRequests was TRUE.
3965: //
3966: IbmtokForceAdapterInterrupt(Adapter);
3967:
3968: if (Adapter->ResettingOpen != NULL) {
3969:
3970: PIBMTOK_OPEN ResettingOpen = Adapter->ResettingOpen;
3971:
3972: //
3973: // Indicate reset complete to everybody
3974: //
3975:
3976: CurrentLink = Adapter->OpenBindings.Flink;
3977:
3978: while (CurrentLink != &(Adapter->OpenBindings)){
3979:
3980: TempOpen = CONTAINING_RECORD(
3981: CurrentLink,
3982: IBMTOK_OPEN,
3983: OpenList
3984: );
3985:
3986: NdisReleaseSpinLock(&Adapter->Lock);
3987:
3988: NdisIndicateStatus(TempOpen->NdisBindingContext,
3989: NDIS_STATUS_RESET_END,
3990: NULL,
3991: 0
3992: );
3993:
3994: NdisIndicateStatusComplete(TempOpen->NdisBindingContext);
3995:
3996: NdisAcquireSpinLock(&Adapter->Lock);
3997:
3998: CurrentLink = CurrentLink->Flink;
3999:
4000: }
4001:
4002: //
4003: // Decrement the reference count that was incremented
4004: // in SetupForReset.
4005: //
4006: ResettingOpen->References--;
4007:
4008: NdisReleaseSpinLock(&Adapter->Lock);
4009:
4010: NdisCompleteReset(
4011: ResettingOpen->NdisBindingContext,
4012: NDIS_STATUS_SUCCESS
4013: );
4014:
4015: NdisAcquireSpinLock(&Adapter->Lock);
4016:
4017: }
4018:
4019: }
4020:
4021: STATIC
4022: VOID
4023: IbmtokSetupRegistersAndInit(
4024: IN PIBMTOK_ADAPTER Adapter
4025: )
4026:
4027: /*++
4028:
4029: Routine Description:
4030:
4031: It is this routines responsibility to make sure that the
4032: initialization block is filled and the chip is initialized
4033: *but not* started.
4034:
4035: NOTE: This routine assumes that it is called with the lock
4036: acquired OR that only a single thread of execution is working
4037: with this particular adapter.
4038:
4039: Arguments:
4040:
4041: Adapter - The adapter whose hardware is to be initialized.
4042:
4043: Return Value:
4044:
4045: None.
4046:
4047: --*/
4048: {
4049:
4050: //
4051: // Enable card interrupts to get the reset interrupt.
4052: //
4053:
4054: WRITE_ADAPTER_REGISTER(Adapter, ISRP_LOW,
4055: ISRP_LOW_NO_CHANNEL_CHECK | ISRP_LOW_INTERRUPT_ENABLE);
4056:
4057: //
4058: // Set the timer to 10 milliseconds...this seems to
4059: // be necessary for proper operation (according to
4060: // ChandanC).
4061: //
4062:
4063: WRITE_ADAPTER_REGISTER(Adapter, TVR_HIGH, 0x01);
4064:
4065:
4066: //
4067: // Start the timer and set it to reload, but not to
4068: // interrupt us (TCR_LOW_INTERRUPT_MASK is off). This
4069: // will still cause bit 4 in the ISRP Low to go on,
4070: // but it won't cause an interrupt.
4071: //
4072:
4073: #if 0
4074: WRITE_ADAPTER_REGISTER(Adapter, TCR_LOW,
4075: // TCR_LOW_INTERRUPT_MASK |
4076: TCR_LOW_RELOAD_TIMER | TCR_LOW_COUNTER_ENABLE);
4077: #endif
4078: WRITE_ADAPTER_REGISTER(Adapter, TCR_LOW, 0);
4079:
4080:
4081:
4082: //
4083: // If this is a PC I/O Bus...
4084: // Set up the shared RAM to be right after the MMIO.
4085: //
4086:
4087: if (Adapter->UsingPcIoBus) {
4088: WRITE_ADAPTER_REGISTER(Adapter, RRR_LOW, Adapter->RrrLowValue);
4089: }
4090:
4091:
4092: //
4093: // The remaining initialization processing is done in
4094: // the interrupt handler.
4095: //
4096:
4097: }
4098:
4099: VOID
4100: IbmtokSetupForReset(
4101: IN PIBMTOK_ADAPTER Adapter,
4102: IN PIBMTOK_OPEN Open
4103: )
4104:
4105: /*++
4106:
4107: Routine Description:
4108:
4109: This routine is used to fill in the who and why a reset is
4110: being set up as well as setting the appropriate fields in the
4111: adapter.
4112:
4113: NOTE: This routine must be called with the lock acquired.
4114:
4115: Arguments:
4116:
4117: Adapter - The adapter whose hardware is to be initialized.
4118:
4119: Open - A (possibly NULL) pointer to an sonic open structure.
4120: The reason it could be null is if the adapter is initiating the
4121: reset on its own.
4122:
4123: Return Value:
4124:
4125: None.
4126:
4127: --*/
4128: {
4129: //
4130: // Notify of reset start
4131: //
4132:
4133: PLIST_ENTRY CurrentLink;
4134: PIBMTOK_OPEN TempOpen;
4135:
4136: if (Open != NULL) {
4137:
4138: CurrentLink = Adapter->OpenBindings.Flink;
4139:
4140: while (CurrentLink != &(Adapter->OpenBindings)){
4141:
4142: TempOpen = CONTAINING_RECORD(
4143: CurrentLink,
4144: IBMTOK_OPEN,
4145: OpenList
4146: );
4147:
4148: NdisReleaseSpinLock(&Adapter->Lock);
4149:
4150: NdisIndicateStatus(TempOpen->NdisBindingContext,
4151: NDIS_STATUS_RESET_START,
4152: NULL,
4153: 0
4154: );
4155:
4156: NdisAcquireSpinLock(&Adapter->Lock);
4157:
4158: CurrentLink = CurrentLink->Flink;
4159:
4160: }
4161: }
4162:
4163:
4164: Adapter->ResetInProgress = TRUE;
4165: Adapter->NotAcceptingRequests = TRUE;
4166:
4167: Adapter->ResettingOpen = Open;
4168:
4169: //
4170: // This will go to 1 when StartAdapterReset is called.
4171: //
4172: Adapter->CurrentResetStage = 0;
4173:
4174: //
4175: // If there is a valid open we should up the reference count
4176: // so that the open can't be deleted before we indicate that
4177: // their request is finished.
4178: //
4179:
4180: if (Open != NULL) {
4181:
4182: Open->References++;
4183:
4184: }
4185:
4186: }
4187:
4188: NDIS_STATUS
4189: IbmtokAddAdapter(
4190: IN NDIS_HANDLE MacMacContext,
4191: IN NDIS_HANDLE ConfigurationHandle,
4192: IN PNDIS_STRING AdapterName
4193: )
4194:
4195: /*++
4196:
4197: Routine Description:
4198:
4199: This routine is used to initialize each adapter card/chip.
4200:
4201: Arguments:
4202:
4203: see NDIS 3.0 spec...
4204:
4205: Return Value:
4206:
4207:
4208: NDIS_STATUS_SUCCESS - Adapter was successfully added.
4209: NDIS_STATUS_FAILURE - Adapter was not added, also MAC deregistered.
4210:
4211: --*/
4212:
4213: {
4214: PIBMTOK_ADAPTER Adapter;
4215:
4216: NDIS_HANDLE ConfigHandle;
4217: PNDIS_CONFIGURATION_PARAMETER ReturnedValue;
4218: NDIS_STRING BusTypeStr = NDIS_STRING_CONST("BusType");
4219: NDIS_STRING IOAddressStr = NDIS_STRING_CONST("IoBaseAddress");
4220: NDIS_STRING NetworkAddressStr = NDIS_STRING_CONST("NetworkAddress");
4221: NDIS_STRING PacketSizeStr = NDIS_STRING_CONST("MaximumPacketSize");
4222:
4223: NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
4224:
4225: BOOLEAN PrimaryAdapter = TRUE;
4226: BOOLEAN ConfigError = FALSE;
4227: BOOLEAN McaCard = FALSE;
4228:
4229: UINT SlotNumber;
4230: NDIS_MCA_POS_DATA McaData;
4231:
4232: PVOID NetAddress;
4233: ULONG Length;
4234:
4235: //
4236: // Allocate the Adapter block.
4237: //
4238:
4239: if (IBMTOK_ALLOC_PHYS(&Adapter, sizeof(IBMTOK_ADAPTER)) !=
4240: NDIS_STATUS_SUCCESS) {
4241:
4242: return(NDIS_STATUS_RESOURCES);
4243:
4244: }
4245:
4246:
4247: IBMTOK_ZERO_MEMORY(
4248: Adapter,
4249: sizeof(IBMTOK_ADAPTER)
4250: );
4251:
4252: Adapter->MaxTransmittablePacket = 17960;
4253: Adapter->CurrentRingState = NdisRingStateClosed;
4254:
4255: Adapter->NdisMacHandle = ((PIBMTOK_MAC)MacMacContext)->NdisMacHandle;
4256:
4257:
4258: NdisOpenConfiguration(
4259: &Status,
4260: &ConfigHandle,
4261: ConfigurationHandle
4262: );
4263:
4264: if (Status != NDIS_STATUS_SUCCESS) {
4265:
4266: IBMTOK_FREE_PHYS(Adapter, sizeof(IBMTOK_ADAPTER));
4267:
4268: return NDIS_STATUS_FAILURE;
4269:
4270: }
4271:
4272: //
4273: // Read Bus Type
4274: //
4275:
4276: NdisReadConfiguration(
4277: &Status,
4278: &ReturnedValue,
4279: ConfigHandle,
4280: &BusTypeStr,
4281: NdisParameterHexInteger
4282: );
4283:
4284: if (Status == NDIS_STATUS_SUCCESS) {
4285:
4286: if (ReturnedValue->ParameterData.IntegerData == (ULONG)NdisInterfaceMca) {
4287:
4288: McaCard = TRUE;
4289:
4290: }
4291:
4292: }
4293:
4294: //
4295: // Get I/O Address
4296: //
4297:
4298: if (McaCard) {
4299:
4300: //
4301: // Get I/O Address from Mca Pos info.
4302: //
4303:
4304: NdisReadMcaPosInformation(
4305: &Status,
4306: ConfigurationHandle,
4307: &SlotNumber,
4308: &McaData
4309: );
4310:
4311: if (Status != NDIS_STATUS_SUCCESS) {
4312:
4313: ConfigError = TRUE;
4314: goto RegisterAdapter;
4315:
4316: }
4317:
4318: //
4319: // Now interperet the data
4320: //
4321:
4322: switch (McaData.PosData2 & 0x1) {
4323: case 0x00:
4324: Adapter->IbmtokPortAddress = PRIMARY_ADAPTER_OFFSET;
4325: break;
4326:
4327: case 0x01:
4328: Adapter->IbmtokPortAddress = ALTERNATE_ADAPTER_OFFSET;
4329: break;
4330:
4331: }
4332:
4333: } else {
4334:
4335: //
4336: // Read I/O Address
4337: //
4338:
4339: NdisReadConfiguration(
4340: &Status,
4341: &ReturnedValue,
4342: ConfigHandle,
4343: &IOAddressStr,
4344: NdisParameterInteger
4345: );
4346:
4347: if (Status == NDIS_STATUS_SUCCESS) {
4348:
4349: PrimaryAdapter = (ReturnedValue->ParameterData.IntegerData == 1)?TRUE:FALSE;
4350:
4351: }
4352:
4353: if (PrimaryAdapter) {
4354:
4355: Adapter->IbmtokPortAddress = PRIMARY_ADAPTER_OFFSET;
4356:
4357: } else {
4358:
4359: Adapter->IbmtokPortAddress = ALTERNATE_ADAPTER_OFFSET;
4360:
4361: }
4362:
4363: }
4364:
4365: //
4366: // Read PacketSize
4367: //
4368:
4369: NdisReadConfiguration(
4370: &Status,
4371: &ReturnedValue,
4372: ConfigHandle,
4373: &PacketSizeStr,
4374: NdisParameterInteger
4375: );
4376:
4377: if (Status == NDIS_STATUS_SUCCESS) {
4378:
4379: Adapter->MaxTransmittablePacket = ReturnedValue->ParameterData.IntegerData;
4380:
4381: }
4382:
4383:
4384: //
4385: // Read net address
4386: //
4387:
4388: NdisReadNetworkAddress(
4389: &Status,
4390: &NetAddress,
4391: &Length,
4392: ConfigHandle
4393: );
4394:
4395: if ((Length == TR_LENGTH_OF_ADDRESS) && (Status == NDIS_STATUS_SUCCESS)) {
4396:
4397: TR_COPY_NETWORK_ADDRESS(
4398: Adapter->NetworkAddress,
4399: NetAddress
4400: );
4401:
4402: }
4403:
4404: RegisterAdapter:
4405:
4406: NdisCloseConfiguration(ConfigHandle);
4407:
4408: Status = IbmtokRegisterAdapter(
4409: Adapter,
4410: ConfigurationHandle,
4411: AdapterName,
4412: McaCard,
4413: ConfigError
4414: );
4415:
4416: if (Status != NDIS_STATUS_SUCCESS) {
4417:
4418: IBMTOK_FREE_PHYS(Adapter, sizeof(IBMTOK_ADAPTER));
4419:
4420: }
4421:
4422: return Status;
4423:
4424: }
4425:
4426: VOID
4427: IbmtokRemoveAdapter(
4428: IN PVOID MacAdapterContext
4429: )
4430:
4431:
4432: /*++
4433:
4434: Routine Description:
4435:
4436: This routine is called when an adapter is to be removed.
4437:
4438: Arguments:
4439:
4440: MacAdapterContext - Pointer to global list of adapter blocks.
4441:
4442: Return Value:
4443:
4444: None
4445:
4446: --*/
4447:
4448: {
4449: PIBMTOK_ADAPTER Adapter;
4450: BOOLEAN Canceled;
4451:
4452: Adapter = PIBMTOK_ADAPTER_FROM_CONTEXT_HANDLE(MacAdapterContext);
4453:
4454: //
4455: // There are no opens left, so remove ourselves.
4456: //
4457:
4458: NdisCancelTimer(&Adapter->WakeUpTimer, &Canceled);
4459:
4460: if ( !Canceled ) {
4461:
4462: NdisStallExecution(500000);
4463: }
4464:
4465: NdisRemoveInterrupt(&(Adapter->Interrupt));
4466:
4467: NdisUnmapIoSpace(Adapter->NdisAdapterHandle,
4468: Adapter->SharedRam,
4469: (Adapter->MappedSharedRam == 0x10000) ?
4470: 0x8000 :
4471: Adapter->MappedSharedRam
4472: );
4473:
4474: TrDeleteFilter(Adapter->FilterDB);
4475:
4476: NdisFreeSpinLock(&Adapter->Lock);
4477:
4478: NdisDeregisterAdapter(Adapter->NdisAdapterHandle);
4479:
4480: IBMTOK_FREE_PHYS(Adapter, sizeof(IBMTOK_ADAPTER));
4481:
4482: return;
4483:
4484: }
4485:
4486: VOID
4487: IbmtokUnload(
4488: IN NDIS_HANDLE MacMacContext
4489: )
4490:
4491: /*++
4492:
4493: Routine Description:
4494:
4495: IbmtokUnload is called when the MAC is to unload itself.
4496:
4497: Arguments:
4498:
4499: MacMacContext - nothing.
4500:
4501: Return Value:
4502:
4503: None.
4504:
4505: --*/
4506:
4507: {
4508: NDIS_STATUS InitStatus;
4509:
4510: UNREFERENCED_PARAMETER(MacMacContext);
4511:
4512: NdisDeregisterMac(
4513: &InitStatus,
4514: ((PIBMTOK_MAC)MacMacContext)->NdisMacHandle
4515: );
4516:
4517: NdisTerminateWrapper(
4518: ((PIBMTOK_MAC)MacMacContext)->NdisWrapperHandle,
4519: NULL
4520: );
4521:
4522: return;
4523: }
4524:
4525: STATIC
4526: BOOLEAN
4527: IbmtokHardwareDetails(
4528: IN PIBMTOK_ADAPTER Adapter
4529: )
4530:
4531: /*++
4532:
4533: Routine Description:
4534:
4535: This routine gets the MMIO address and interrupt level.
4536: It also maps the MMIO and Shared RAM.
4537:
4538: Arguments:
4539:
4540: Adapter - Where to store the network address.
4541:
4542: Return Value:
4543:
4544: TRUE if successful.
4545:
4546: --*/
4547:
4548: {
4549:
4550: NDIS_STATUS Status;
4551:
4552: //
4553: // Holds the value read from the SWITCH_READ_1 port.
4554: //
4555: UCHAR SwitchRead1;
4556:
4557: //
4558: // Holds the value read from the SWITCH_READ_2 port in
4559: // the Microchannel Bus.
4560: //
4561: UCHAR SwitchRead2;
4562:
4563: //
4564: // Holds the physical address of the MMIO region.
4565: //
4566: ULONG MmioAddress;
4567:
4568: NDIS_PHYSICAL_ADDRESS PhysicalAddress;
4569:
4570: //
4571: // The interrupt level;
4572: //
4573: UINT InterruptLevel;
4574:
4575: //
4576: // The RRR bits indicating the Shared RAM size:
4577: // 0 = 8K, 1 = 16K, 2 = 32K, 3 = 64K.
4578: //
4579: UCHAR SharedRamBits;
4580:
4581: //
4582: // The actual size of Shared RAM from RRR bits 2,3 in
4583: // the PC I/O Bus adapter.
4584: //
4585: UINT RrrSharedRamSize;
4586:
4587: //
4588: // Common variable for storing total Shared RAM Size.
4589: //
4590: UINT SharedRamSize;
4591:
4592: //
4593: // The actual address of Shared RAM from the SWITCH_READ_2
4594: // port in the Microchannel adapter.
4595: //
4596: UINT McaSharedRam;
4597:
4598: //
4599: // The boundary needed for the Shared RAM mapping.
4600: //
4601: UCHAR BoundaryNeeded;
4602:
4603: //
4604: // The value read from the Shared RAM paging byte of
4605: // the AIP.
4606: //
4607: UCHAR AipSharedRamPaging;
4608:
4609: UCHAR RegValue;
4610:
4611: //
4612: // SwitchRead1 contains the interrupt code in the low 2 bits,
4613: // and bits 18 through 13 of the MMIO address in the high
4614: // 6 bits.
4615: //
4616:
4617: READ_ADAPTER_PORT(Adapter, SWITCH_READ_1, &SwitchRead1);
4618:
4619: //
4620: // SwitchRead2 contains Bit 19 of the MMIO address in the
4621: // low bit. It is always 1 for PC I/O Bus and possibly 0
4622: // for the Microchannel bus
4623: //
4624:
4625: READ_ADAPTER_PORT(Adapter, SWITCH_READ_2, &SwitchRead2);
4626:
4627: //
4628: // To compute MmioAddress, we mask off the low 2 bits of
4629: // SwitchRead1, shift it out by 11 (so that the high 6 bits
4630: // are moved to the right place), and add in the 19th bit value.
4631: //
4632:
4633: MmioAddress = ((SwitchRead1 & 0xfc) << 11) | ((SwitchRead2 & 1) << 19);
4634:
4635: NdisSetPhysicalAddressHigh(PhysicalAddress, 0);
4636: NdisSetPhysicalAddressLow(PhysicalAddress, MmioAddress);
4637:
4638: NdisMapIoSpace(
4639: &Status,
4640: (PVOID *)&(Adapter->MmioRegion),
4641: Adapter->NdisAdapterHandle,
4642: PhysicalAddress,
4643: 0x2000);
4644:
4645: if (Status != NDIS_STATUS_SUCCESS) {
4646:
4647: NdisWriteErrorLogEntry(
4648: Adapter->NdisAdapterHandle,
4649: NDIS_ERROR_CODE_RESOURCE_CONFLICT,
4650: 0
4651: );
4652:
4653: return(FALSE);
4654:
4655: }
4656:
4657:
4658: //
4659: // Now we have mapped the MMIO, look at the AIP. First
4660: // determine the channel identifier.
4661: //
4662:
4663: {
4664: //
4665: // Will hold the Adapter ID as read from the card.
4666: //
4667: ULONG AdapterId[3];
4668:
4669: //
4670: // What AdapterId should contain for a PC I/O bus card.
4671: //
4672: static ULONG PcIoBusId[3] = { 0x5049434f, 0x36313130, 0x39393020 };
4673:
4674: //
4675: // What AdapterId should contain for a Micro Channel card.
4676: //
4677: static ULONG MicroChannelId[3] = { 0x4d415253, 0x36335834, 0x35313820 };
4678:
4679: //
4680: // Loop counters.
4681: //
4682: UINT i, j;
4683:
4684: UCHAR TmpUchar;
4685:
4686: //
4687: // Read in AdapterId.
4688: //
4689: // Turns out that the bytes which identify the card are stored
4690: // in a very odd manner. There are 48 bytes on the card. The
4691: // even numbered bytes contain 4 bits of the card signature.
4692: //
4693:
4694: for (i=0; i<3; i++) {
4695:
4696: AdapterId[i] = 0;
4697:
4698: for (j=0; j<16; j+=2) {
4699:
4700: READ_ADAPTER_REGISTER(Adapter,
4701: CHANNEL_IDENTIFIER + (i*16 + j),
4702: &TmpUchar
4703: );
4704:
4705: AdapterId[i] = (AdapterId[i] << 4) + TmpUchar;
4706:
4707:
4708: }
4709:
4710: }
4711:
4712: if ((AdapterId[0] == PcIoBusId[0]) &&
4713: (AdapterId[1] == PcIoBusId[1]) &&
4714: (AdapterId[2] == PcIoBusId[2])) {
4715:
4716: Adapter->UsingPcIoBus = TRUE;
4717:
4718: } else if ((AdapterId[0] == MicroChannelId[0]) &&
4719: (AdapterId[1] == MicroChannelId[1]) &&
4720: (AdapterId[2] == MicroChannelId[2])) {
4721:
4722: Adapter->UsingPcIoBus = FALSE;
4723:
4724: } else {
4725:
4726: //
4727: // Unknown channel type.
4728: //
4729:
4730:
4731: NdisUnmapIoSpace(Adapter->NdisAdapterHandle,
4732: Adapter->MmioRegion,
4733: 0x2000);
4734:
4735: NdisWriteErrorLogEntry(
4736: Adapter->NdisAdapterHandle,
4737: NDIS_ERROR_CODE_BAD_IO_BASE_ADDRESS,
4738: 0
4739: );
4740:
4741: return FALSE;
4742:
4743: }
4744:
4745: }
4746:
4747: //
4748: // We can read the network address from the AIP but we won't,
4749: // we read it from the bring-up SRB instead.
4750: //
4751:
4752: //
4753: // Read the RRR High to get the Shared RAM size (we are
4754: // only interested in bits 2 and 3).
4755: //
4756:
4757: READ_ADAPTER_REGISTER(Adapter, RRR_HIGH, &SharedRamBits);
4758:
4759: SharedRamBits = ((SharedRamBits & 0x0c) >> 2);
4760:
4761: if (Adapter->UsingPcIoBus) {
4762:
4763: //
4764: // Here we have to tell the Adapter where Shared RAM is
4765: // going to be. To do this we first find the lowest
4766: // address it could be at, and then advance the address
4767: // such that it falls on a correct page boudary.
4768: //
4769:
4770:
4771: //
4772: // To get value to put in RRR Low, which indicates where
4773: // the Shared RAM is mapped, we first compute the lowest
4774: // possible value, which is right after the MMIO region.
4775: // We take the high six bits of SwitchRead and shift
4776: // them right one (so bits 18-13 of the address are in
4777: // bits 6-1), then we turn on bit 7 to indicate that bit
4778: // 19 of the address is on, and leave bit 0 zero since
4779: // it must be.
4780: //
4781:
4782: Adapter->RrrLowValue = (UCHAR)
4783: ((((SwitchRead1 & 0xfc) >> 1) | 0x80) + 0x02);
4784:
4785: //
4786: // We now have to move up to a memory boundary
4787: // based on the value of SharedRamBits; 0 (8K) = 16K boundary,
4788: // 1 (16K) = 16K boundary, 2 (32K) = 32K boundary, and
4789: // 3 (64K) = 64K Boundary. Remember that the way the
4790: // address bits are shifted over in RrrLowValue, bit 1
4791: // is really bit 13 of the final address (turning it on
4792: // adds 8K), bit 2 if bit 14, etc. We compute Boundary
4793: // Needed in this frame of reference.
4794: //
4795:
4796: switch (SharedRamBits) {
4797:
4798: case 0:
4799: case 1:
4800:
4801: //
4802: // 8K or 16K needs a 16K boundary.
4803: //
4804:
4805: RrrSharedRamSize = (SharedRamBits == 0) ? 0x2000 : 0x4000;
4806: BoundaryNeeded = 0x04;
4807: break;
4808:
4809: case 2:
4810:
4811: //
4812: // 32K needs a 32K boundary.
4813: //
4814:
4815: RrrSharedRamSize = 0x8000;
4816: BoundaryNeeded = 0x08;
4817: break;
4818:
4819: case 3:
4820:
4821: //
4822: // 64K needs a 64K boundary.
4823: //
4824:
4825: RrrSharedRamSize = 0x10000;
4826: BoundaryNeeded = 0x10;
4827: break;
4828:
4829: }
4830:
4831:
4832: //
4833: // If RrrLowValue is not on the proper boundary, move it
4834: // forward until it is.
4835: //
4836:
4837: if (Adapter->RrrLowValue & (BoundaryNeeded-1)) {
4838:
4839: Adapter->RrrLowValue = (UCHAR)
4840: ((Adapter->RrrLowValue & ~(BoundaryNeeded-1)) + BoundaryNeeded);
4841:
4842: }
4843:
4844: Adapter->MappedSharedRam = SharedRamSize = RrrSharedRamSize;
4845:
4846: NdisSetPhysicalAddressHigh(PhysicalAddress, 0);
4847: NdisSetPhysicalAddressLow(PhysicalAddress, Adapter->RrrLowValue << 12);
4848:
4849: NdisMapIoSpace(&Status,
4850: (PVOID *)&(Adapter->SharedRam),
4851: Adapter->NdisAdapterHandle,
4852: PhysicalAddress,
4853: RrrSharedRamSize
4854: );
4855:
4856: if (Status != NDIS_STATUS_SUCCESS) {
4857:
4858: NdisUnmapIoSpace(Adapter->NdisAdapterHandle,
4859: Adapter->MmioRegion,
4860: 0x2000);
4861:
4862: NdisWriteErrorLogEntry(
4863: Adapter->NdisAdapterHandle,
4864: NDIS_ERROR_CODE_RESOURCE_CONFLICT,
4865: 0
4866: );
4867:
4868: return(FALSE);
4869:
4870: }
4871:
4872: } else {
4873:
4874: //
4875: // Using Microchannel
4876: //
4877: // No need to set Adapter->RrrLowValue since it is not
4878: // used in the Microchannel adapter.
4879: //
4880:
4881: switch (SharedRamBits){
4882: case 0:
4883: SharedRamSize = 0x2000;
4884: break;
4885: case 1:
4886: SharedRamSize = 0x4000;
4887: break;
4888: case 2:
4889: SharedRamSize = 0x8000;
4890: break;
4891: case 3:
4892: SharedRamSize = 0x10000;
4893: break;
4894: }
4895:
4896: McaSharedRam = ((SwitchRead2 & 0xfe) << 12);
4897:
4898: NdisSetPhysicalAddressHigh(PhysicalAddress, 0);
4899: NdisSetPhysicalAddressLow(PhysicalAddress, McaSharedRam);
4900:
4901: NdisMapIoSpace(&Status,
4902: (PVOID *)&(Adapter->SharedRam),
4903: Adapter->NdisAdapterHandle,
4904: PhysicalAddress,
4905: SharedRamSize);
4906:
4907: if (Status != NDIS_STATUS_SUCCESS) {
4908:
4909: NdisUnmapIoSpace(Adapter->NdisAdapterHandle,
4910: Adapter->MmioRegion,
4911: 0x2000);
4912:
4913: NdisWriteErrorLogEntry(
4914: Adapter->NdisAdapterHandle,
4915: NDIS_ERROR_CODE_RESOURCE_CONFLICT,
4916: 0
4917: );
4918:
4919: return(FALSE);
4920:
4921: }
4922:
4923: Adapter->MappedSharedRam = SharedRamSize;
4924:
4925: }
4926:
4927:
4928:
4929: //
4930: // Get the interrupt level...note that a switch being
4931: // "off" shows up as a 1, "on" is 0.
4932: //
4933:
4934: switch (SwitchRead1 & 0x03) {
4935:
4936: case 0: InterruptLevel = 2; break;
4937: case 1: InterruptLevel = 3; break;
4938: case 2: InterruptLevel = (Adapter->UsingPcIoBus)?6:10; break;
4939: case 3: InterruptLevel = (Adapter->UsingPcIoBus)?7:11; break;
4940:
4941: }
4942:
4943: Adapter->InterruptLevel = InterruptLevel;
4944:
4945: //
4946: // Now determine how much memory the adapter has, and
4947: // whether to use Shared RAM paging.
4948: //
4949:
4950: Adapter->UpperSharedRamZero = FALSE;
4951:
4952: READ_ADAPTER_REGISTER(Adapter, TOTAL_ADAPTER_RAM, &RegValue);
4953:
4954: switch (RegValue) {
4955:
4956: //
4957: // These values are described on page 7-26 of the
4958: // Technical Reference.
4959: //
4960:
4961: case 0xf:
4962:
4963: Adapter->TotalSharedRam = SharedRamSize;
4964: break;
4965:
4966: case 0xe:
4967:
4968: Adapter->TotalSharedRam = 0x2000;
4969: break;
4970:
4971: case 0xd:
4972:
4973: Adapter->TotalSharedRam = 0x4000;
4974: break;
4975:
4976: case 0xc:
4977:
4978: Adapter->TotalSharedRam = 0x8000;
4979: break;
4980:
4981: case 0xb:
4982:
4983: Adapter->TotalSharedRam = 0x10000;
4984:
4985: Adapter->UpperSharedRamZero = TRUE;
4986: break;
4987:
4988: case 0xa:
4989:
4990: Adapter->TotalSharedRam = 0x10000;
4991: break;
4992:
4993: default:
4994:
4995: NdisWriteErrorLogEntry(
4996: Adapter->NdisAdapterHandle,
4997: NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION,
4998: 3,
4999: hardwareDetails,
5000: IBMTOK_ERRMSG_UNSUPPORTED_RAM,
5001: (ULONG)RegValue
5002: );
5003:
5004: NdisUnmapIoSpace(Adapter->NdisAdapterHandle,
5005: Adapter->MmioRegion,
5006: 0x2000);
5007:
5008: if (Adapter->UsingPcIoBus) {
5009: NdisUnmapIoSpace(
5010: Adapter->NdisAdapterHandle,
5011: Adapter->SharedRam,
5012: SharedRamSize);
5013: } else {
5014: NdisUnmapIoSpace(
5015: Adapter->NdisAdapterHandle,
5016: Adapter->SharedRam,
5017: SharedRamSize);
5018: }
5019:
5020: return FALSE;
5021:
5022: }
5023:
5024: //
5025: // Only allow Shared RAM paging if we have 16K selected
5026: // on SharedRamSize, 64K of total adapter memory, and it is allowed
5027: // as specified on p. 7-26 of the Technical Reference.
5028: //
5029:
5030: READ_ADAPTER_REGISTER(Adapter, SHARED_RAM_PAGING, &AipSharedRamPaging);
5031:
5032: #if 0
5033: if (SharedRamSize == 0x4000 &&
5034: Adapter->TotalSharedRam == 0x10000 &&
5035: (AipSharedRamPaging == 0xe || AipSharedRamPaging == 0xc)) {
5036:
5037: Adapter->SharedRamPaging = TRUE;
5038:
5039: } else {
5040:
5041: Adapter->SharedRamPaging = FALSE;
5042:
5043: }
5044: #else
5045: Adapter->SharedRamPaging = FALSE;
5046: #endif
5047:
5048:
5049: //
5050: // Read in the maximum sizes allowed for DHBs based on
5051: // the speed of the adapter (which we don't know yet).
5052: //
5053:
5054: READ_ADAPTER_REGISTER(Adapter, MAX_4_MBPS_DHB, &RegValue);
5055:
5056: switch (RegValue) {
5057:
5058: case 0xf:
5059: default:
5060:
5061: Adapter->Max4MbpsDhb = 2048;
5062: break;
5063:
5064: case 0xe:
5065:
5066: Adapter->Max4MbpsDhb = 4096;
5067: break;
5068:
5069: case 0xd:
5070:
5071: Adapter->Max4MbpsDhb = 4464;
5072: break;
5073:
5074: }
5075:
5076: READ_ADAPTER_REGISTER(Adapter, MAX_16_MBPS_DHB, &RegValue);
5077:
5078: switch (RegValue) {
5079:
5080: case 0xf:
5081: default:
5082:
5083: Adapter->Max16MbpsDhb = 2048;
5084: break;
5085:
5086: case 0xe:
5087:
5088: Adapter->Max16MbpsDhb = 4096;
5089: break;
5090:
5091: case 0xd:
5092:
5093: Adapter->Max16MbpsDhb = 8192;
5094: break;
5095:
5096: case 0xc:
5097:
5098: Adapter->Max16MbpsDhb = 16384;
5099: break;
5100:
5101: case 0xb:
5102:
5103: Adapter->Max16MbpsDhb = 17960;
5104: break;
5105:
5106: }
5107:
5108:
5109: return TRUE;
5110:
5111: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.