[CMAKE]
[reactos.git] / drivers / network / dd / ne2000 / ne2000 / main.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Novell Eagle 2000 driver
4 * FILE: ne2000/main.c
5 * PURPOSE: Driver entry point
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * REVISIONS:
8 * CSH 27/08-2000 Created
9 */
10 #include <ne2000.h>
11 #include <debug.h>
12
13 NTSTATUS
14 NTAPI
15 DriverEntry(
16 PDRIVER_OBJECT DriverObject,
17 PUNICODE_STRING RegistryPath);
18
19
20 #if DBG
21
22 /* See debug.h for debug/trace constants */
23 ULONG DebugTraceLevel = 0;
24
25 #endif /* DBG */
26
27
28 /* List of supported OIDs */
29 static ULONG MiniportOIDList[] = {
30 OID_GEN_SUPPORTED_LIST,
31 OID_GEN_HARDWARE_STATUS,
32 OID_GEN_MEDIA_SUPPORTED,
33 OID_GEN_MEDIA_IN_USE,
34 OID_GEN_MAXIMUM_LOOKAHEAD,
35 OID_GEN_MAXIMUM_FRAME_SIZE,
36 OID_GEN_LINK_SPEED,
37 OID_GEN_TRANSMIT_BUFFER_SPACE,
38 OID_GEN_RECEIVE_BUFFER_SPACE,
39 OID_GEN_TRANSMIT_BLOCK_SIZE,
40 OID_GEN_RECEIVE_BLOCK_SIZE,
41 OID_GEN_VENDOR_ID,
42 OID_GEN_VENDOR_DESCRIPTION,
43 OID_GEN_VENDOR_DRIVER_VERSION,
44 OID_GEN_CURRENT_PACKET_FILTER,
45 OID_GEN_CURRENT_LOOKAHEAD,
46 OID_GEN_DRIVER_VERSION,
47 OID_GEN_MAXIMUM_TOTAL_SIZE,
48 OID_GEN_PROTOCOL_OPTIONS,
49 OID_GEN_MAC_OPTIONS,
50 OID_GEN_MEDIA_CONNECT_STATUS,
51 OID_GEN_MAXIMUM_SEND_PACKETS,
52 OID_802_3_PERMANENT_ADDRESS,
53 OID_802_3_CURRENT_ADDRESS,
54 OID_802_3_MULTICAST_LIST,
55 OID_802_3_MAXIMUM_LIST_SIZE,
56 OID_802_3_MAC_OPTIONS
57 };
58
59 DRIVER_INFORMATION DriverInfo = { NULL, NULL, { NULL, NULL } };
60 NDIS_PHYSICAL_ADDRESS HighestAcceptableMax = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
61
62
63 static BOOLEAN NTAPI MiniportCheckForHang(
64 IN NDIS_HANDLE MiniportAdapterContext)
65 /*
66 * FUNCTION: Examines if an adapter has hung
67 * ARGUMENTS:
68 * MiniportAdapterContext = Pointer to adapter context area
69 * RETURNS:
70 * TRUE if the adapter has hung, FALSE if not
71 */
72 {
73 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
74
75 return FALSE;
76 }
77
78
79 static VOID NTAPI MiniportDisableInterrupt(
80 IN NDIS_HANDLE MiniportAdapterContext)
81 /*
82 * FUNCTION: Disables interrupts from an adapter
83 * ARGUMENTS:
84 * MiniportAdapterContext = Pointer to adapter context area
85 */
86 {
87 NDIS_DbgPrint(MAX_TRACE, ("Called. (MiniportDisableInterrupt).\n"));
88 #ifndef NOCARD
89 NICDisableInterrupts((PNIC_ADAPTER)MiniportAdapterContext);
90 #endif
91 }
92
93
94 static VOID NTAPI MiniportEnableInterrupt(
95 IN NDIS_HANDLE MiniportAdapterContext)
96 /*
97 * FUNCTION: Enables interrupts from an adapter
98 * ARGUMENTS:
99 * MiniportAdapterContext = Pointer to adapter context area
100 */
101 {
102 NDIS_DbgPrint(MAX_TRACE, ("Called. (MiniportEnableInterrupt).\n"));
103 #ifndef NOCARD
104 NICEnableInterrupts((PNIC_ADAPTER)MiniportAdapterContext);
105 #endif
106 }
107
108
109 static VOID NTAPI MiniportHalt(
110 IN NDIS_HANDLE MiniportAdapterContext)
111 /*
112 * FUNCTION: Deallocates resources for and halts an adapter
113 * ARGUMENTS:
114 * MiniportAdapterContext = Pointer to adapter context area
115 */
116 {
117 PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;
118
119 ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
120
121 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
122 #ifndef NOCARD
123 /* Stop the NIC */
124 NICStop(Adapter);
125 #endif
126 /* Wait for any DPCs to complete. FIXME: Use something else */
127 NdisStallExecution(250000);
128
129 if (Adapter->InterruptRegistered)
130 /* Deregister interrupt */
131 NdisMDeregisterInterrupt(&Adapter->Interrupt);
132
133 if (Adapter->IOPortRangeRegistered)
134 /* Deregister I/O port range */
135 NdisMDeregisterIoPortRange(
136 Adapter->MiniportAdapterHandle,
137 Adapter->IoBaseAddress,
138 0x20,
139 Adapter->IOBase);
140
141 if (Adapter->ShutdownHandlerRegistered)
142 NdisMDeregisterAdapterShutdownHandler(Adapter->MiniportAdapterHandle);
143
144 /* Remove adapter from global adapter list */
145 if ((&Adapter->ListEntry)->Blink != NULL) {
146 RemoveEntryList(&Adapter->ListEntry);
147 }
148
149 /* Free adapter context area */
150 NdisFreeMemory(Adapter, sizeof(NIC_ADAPTER), 0);
151 }
152
153
154 static VOID NTAPI MiQueryResources(
155 OUT PNDIS_STATUS Status,
156 IN PNIC_ADAPTER Adapter,
157 IN NDIS_HANDLE WrapperConfigurationContext)
158 {
159 PNDIS_RESOURCE_LIST AssignedResources;
160 UINT BufferSize = 0;
161 PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
162 UINT i;
163
164 NdisMQueryAdapterResources(Status,
165 WrapperConfigurationContext,
166 NULL,
167 &BufferSize);
168 if (*Status == NDIS_STATUS_SUCCESS)
169 return;
170
171 *Status = NdisAllocateMemory((PVOID)&AssignedResources,
172 BufferSize,
173 0,
174 HighestAcceptableMax);
175 if (*Status != NDIS_STATUS_SUCCESS)
176 return;
177
178 NdisMQueryAdapterResources(Status,
179 WrapperConfigurationContext,
180 AssignedResources,
181 &BufferSize);
182 if (*Status != NDIS_STATUS_SUCCESS)
183 return;
184
185 for (i = 0; i < AssignedResources->Count; i++)
186 {
187 Descriptor = AssignedResources->PartialDescriptors + i;
188 switch (Descriptor->Type)
189 {
190 case CmResourceTypeInterrupt:
191 Adapter->InterruptLevel = Descriptor->u.Interrupt.Level;
192 Adapter->InterruptVector = Descriptor->u.Interrupt.Vector;
193 Adapter->InterruptShared = (Descriptor->ShareDisposition == CmResourceShareShared);
194 Adapter->InterruptMode = Descriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED ?
195 NdisInterruptLatched : NdisInterruptLevelSensitive;
196 break;
197 case CmResourceTypePort:
198 Adapter->IoBaseAddress = Descriptor->u.Port.Start.LowPart;
199 break;
200 }
201 }
202 }
203
204 VOID
205 NTAPI
206 MiniportShutdown(PVOID Context)
207 {
208 #ifndef NOCARD
209 NICStop((PNIC_ADAPTER)Context);
210 #endif
211 }
212
213 static NDIS_STATUS NTAPI MiniportInitialize(
214 OUT PNDIS_STATUS OpenErrorStatus,
215 OUT PUINT SelectedMediumIndex,
216 IN PNDIS_MEDIUM MediumArray,
217 IN UINT MediumArraySize,
218 IN NDIS_HANDLE MiniportAdapterHandle,
219 IN NDIS_HANDLE WrapperConfigurationContext)
220 /*
221 * FUNCTION: Adapter initialization function
222 * ARGUMENTS:
223 * OpenErrorStatus = Address of buffer to place additional status information
224 * SelectedMediumIndex = Address of buffer to place selected medium index
225 * MediumArray = Pointer to an array of NDIS_MEDIUMs
226 * MediaArraySize = Number of elements in MediumArray
227 * MiniportAdapterHandle = Miniport adapter handle assigned by NDIS
228 * WrapperConfigurationContext = Handle used to identify configuration context
229 * RETURNS:
230 * Status of operation
231 */
232 {
233 UINT i;
234 NDIS_STATUS Status;
235 PNIC_ADAPTER Adapter;
236 NDIS_HANDLE ConfigurationHandle;
237 UINT *RegNetworkAddress = 0;
238 UINT RegNetworkAddressLength = 0;
239
240 ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
241
242 NDIS_DbgPrint(MAX_TRACE, ("Called (Adapter %X).\n", MiniportAdapterHandle));
243
244 /* Search for 802.3 media which is the only one we support */
245 for (i = 0; i < MediumArraySize; i++) {
246 if (MediumArray[i] == NdisMedium802_3)
247 break;
248 }
249
250 if (i == MediumArraySize) {
251 NDIS_DbgPrint(MIN_TRACE, ("No supported media.\n"));
252 return NDIS_STATUS_UNSUPPORTED_MEDIA;
253 }
254
255 *SelectedMediumIndex = i;
256
257 Status = NdisAllocateMemory((PVOID)&Adapter,
258 sizeof(NIC_ADAPTER),
259 0,
260 HighestAcceptableMax);
261 if (Status != NDIS_STATUS_SUCCESS) {
262 NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
263 return Status;
264 }
265
266 NdisZeroMemory(Adapter, sizeof(NIC_ADAPTER));
267 Adapter->MiniportAdapterHandle = MiniportAdapterHandle;
268 Adapter->IoBaseAddress = DRIVER_DEFAULT_IO_BASE_ADDRESS;
269 Adapter->InterruptLevel = DRIVER_DEFAULT_INTERRUPT_NUMBER;
270 Adapter->InterruptVector = DRIVER_DEFAULT_INTERRUPT_NUMBER;
271 Adapter->InterruptShared = DRIVER_DEFAULT_INTERRUPT_SHARED;
272 Adapter->InterruptMode = DRIVER_DEFAULT_INTERRUPT_MODE;
273 Adapter->MaxMulticastListSize = DRIVER_MAX_MULTICAST_LIST_SIZE;
274 Adapter->InterruptMask = DRIVER_INTERRUPT_MASK;
275 Adapter->LookaheadSize = DRIVER_MAXIMUM_LOOKAHEAD;
276
277 /* Query the resources from PnP. */
278 MiQueryResources(&Status, Adapter, WrapperConfigurationContext);
279
280 /* Get the port, irq, and MAC address from registry if the PnP
281 failed. */
282 if (Status != NDIS_STATUS_SUCCESS)
283 {
284 PNDIS_CONFIGURATION_PARAMETER ConfigurationParameter;
285 UNICODE_STRING Keyword;
286
287 NdisOpenConfiguration(&Status, &ConfigurationHandle, WrapperConfigurationContext);
288 if (Status == NDIS_STATUS_SUCCESS)
289 {
290 NdisInitUnicodeString(&Keyword, L"Irq");
291 NdisReadConfiguration(&Status, &ConfigurationParameter, ConfigurationHandle, &Keyword, NdisParameterHexInteger);
292 if(Status == NDIS_STATUS_SUCCESS)
293 {
294 NDIS_DbgPrint(MID_TRACE,("NdisReadConfiguration for Irq returned successfully, irq 0x%x\n",
295 ConfigurationParameter->ParameterData.IntegerData));
296 Adapter->InterruptLevel =
297 Adapter->InterruptVector = ConfigurationParameter->ParameterData.IntegerData;
298 }
299
300 NdisInitUnicodeString(&Keyword, L"Port");
301 NdisReadConfiguration(&Status, &ConfigurationParameter, ConfigurationHandle, &Keyword, NdisParameterHexInteger);
302 if(Status == NDIS_STATUS_SUCCESS)
303 {
304 NDIS_DbgPrint(MID_TRACE,("NdisReadConfiguration for Port returned successfully, port 0x%x\n",
305 ConfigurationParameter->ParameterData.IntegerData));
306 Adapter->IoBaseAddress = ConfigurationParameter->ParameterData.IntegerData;
307 }
308
309 NdisCloseConfiguration(ConfigurationHandle);
310 }
311 else
312 {
313 NDIS_DbgPrint(MIN_TRACE,("NdisOpenConfiguration returned error 0x%x\n", Status));
314 }
315 }
316
317 /* find the nic */
318 if (!NICCheck(Adapter)) {
319 NDIS_DbgPrint(MID_TRACE, ("No adapter found at (0x%X).\n", Adapter->IoBaseAddress));
320 NdisFreeMemory(Adapter, sizeof(NIC_ADAPTER), 0);
321 return NDIS_STATUS_ADAPTER_NOT_FOUND;
322 } else
323 NDIS_DbgPrint(MID_TRACE, ("Adapter found at (0x%X).\n", Adapter->IoBaseAddress));
324
325 NdisMSetAttributes(
326 MiniportAdapterHandle,
327 (NDIS_HANDLE)Adapter,
328 FALSE,
329 NdisInterfaceIsa);
330
331 Status = NdisMRegisterIoPortRange(
332 (PVOID*)&Adapter->IOBase,
333 MiniportAdapterHandle,
334 Adapter->IoBaseAddress,
335 0x20);
336
337 if (Status != NDIS_STATUS_SUCCESS) {
338 NDIS_DbgPrint(MIN_TRACE, ("Cannot register port range. Status (0x%X).\n", Status));
339 MiniportHalt((NDIS_HANDLE)Adapter);
340 return Status;
341 }
342
343 Adapter->IOPortRangeRegistered = TRUE;
344
345 /* Initialize NIC */
346 #ifndef NOCARD
347 Status = NICInitialize(Adapter);
348 if (Status != NDIS_STATUS_SUCCESS) {
349 NDIS_DbgPrint(MIN_TRACE,("No NE2000 or compatible network adapter found at address 0x%X.\n",
350 Adapter->IOBase));
351
352 NDIS_DbgPrint(MID_TRACE, ("Status (0x%X).\n", Status));
353 MiniportHalt((NDIS_HANDLE)Adapter);
354 return Status;
355 }
356
357 NdisOpenConfiguration(&Status, &ConfigurationHandle, WrapperConfigurationContext);
358 if (Status == NDIS_STATUS_SUCCESS)
359 {
360 NdisReadNetworkAddress(&Status, (PVOID *)&RegNetworkAddress, &RegNetworkAddressLength, ConfigurationHandle);
361 if(Status == NDIS_STATUS_SUCCESS && RegNetworkAddressLength == DRIVER_LENGTH_OF_ADDRESS)
362 {
363 int i;
364 NDIS_DbgPrint(MID_TRACE,("NdisReadNetworkAddress returned successfully, address %x:%x:%x:%x:%x:%x\n",
365 RegNetworkAddress[0], RegNetworkAddress[1], RegNetworkAddress[2], RegNetworkAddress[3],
366 RegNetworkAddress[4], RegNetworkAddress[5]));
367 for(i = 0; i < DRIVER_LENGTH_OF_ADDRESS; i++)
368 Adapter->StationAddress[i] = RegNetworkAddress[i];
369 }
370
371 NdisCloseConfiguration(ConfigurationHandle);
372 }
373
374 if (Status != NDIS_STATUS_SUCCESS || RegNetworkAddressLength != DRIVER_LENGTH_OF_ADDRESS)
375 {
376 int i;
377 for (i = 0; i < DRIVER_LENGTH_OF_ADDRESS; i++)
378 Adapter->StationAddress[i] = Adapter->PermanentAddress[i];
379 }
380
381 NDIS_DbgPrint(MID_TRACE, ("BOARDDATA:\n"));
382 for (i = 0; i < 4; i++) {
383 NDIS_DbgPrint(MID_TRACE, ("%02X %02X %02X %02X\n",
384 Adapter->SAPROM[i*4+0],
385 Adapter->SAPROM[i*4+1],
386 Adapter->SAPROM[i*4+2],
387 Adapter->SAPROM[i*4+3]));
388 }
389
390 /* Setup adapter structure */
391 Adapter->TXStart = ((ULONG_PTR)Adapter->RamBase >> 8);
392 Adapter->TXCount = DRIVER_DEFAULT_TX_BUFFER_COUNT;
393 Adapter->TXFree = DRIVER_DEFAULT_TX_BUFFER_COUNT;
394 Adapter->TXCurrent = -1;
395 Adapter->PageStart = Adapter->TXStart + Adapter->TXCount;
396 Adapter->PageStop = Adapter->TXStart + (Adapter->RamSize >> 8);
397
398 /* Initialize multicast address mask to accept all */
399 for (i = 0; i < 8; i++)
400 Adapter->MulticastAddressMask[i] = 0xFF;
401
402 /* Setup the NIC */
403 NICSetup(Adapter);
404
405 NDIS_DbgPrint(MID_TRACE, ("TXStart (0x%X) TXCount (0x%X) PageStart (0x%X)\n",
406 Adapter->TXStart,
407 Adapter->TXCount,
408 Adapter->PageStart));
409
410 NDIS_DbgPrint(MID_TRACE, ("PageStop (0x%X) CurrentPage (0x%X) NextPacket (0x%X).\n",
411 Adapter->PageStop,
412 Adapter->CurrentPage,
413 Adapter->NextPacket));
414 #endif
415 /* Register the interrupt */
416 Status = NdisMRegisterInterrupt(
417 &Adapter->Interrupt,
418 MiniportAdapterHandle,
419 Adapter->InterruptVector,
420 Adapter->InterruptLevel,
421 FALSE,
422 Adapter->InterruptShared,
423 Adapter->InterruptMode);
424 if (Status != NDIS_STATUS_SUCCESS) {
425 NDIS_DbgPrint(MIN_TRACE, ("Cannot register interrupt. Status (0x%X).\n", Status));
426 MiniportHalt((NDIS_HANDLE)Adapter);
427 return Status;
428 }
429
430 Adapter->InterruptRegistered = TRUE;
431 #ifndef NOCARD
432 /* Start the NIC */
433 NICStart(Adapter);
434 #endif
435
436 /* Register the shutdown handler */
437 NdisMRegisterAdapterShutdownHandler(MiniportAdapterHandle, Adapter, MiniportShutdown);
438
439 Adapter->ShutdownHandlerRegistered = TRUE;
440
441 /* Add adapter to the global adapter list */
442 InsertTailList(&DriverInfo.AdapterListHead, &Adapter->ListEntry);
443
444 NDIS_DbgPrint(MAX_TRACE, ("Leaving.\n"));
445
446 return NDIS_STATUS_SUCCESS;
447 }
448
449
450 static VOID NTAPI MiniportISR(
451 OUT PBOOLEAN InterruptRecognized,
452 OUT PBOOLEAN QueueMiniportHandleInterrupt,
453 IN NDIS_HANDLE MiniportAdapterContext)
454 /*
455 * FUNCTION: Interrupt Service Routine for controlled adapters
456 * ARGUMENTS:
457 * InterruptRecognized = Address of buffer to place wether
458 * the adapter generated the interrupt
459 * QueueMiniportHandleInterrupt = Address of buffer to place wether
460 * MiniportHandleInterrupt should be called
461 * MiniportAdapterContext = Pointer to adapter context area
462 * NOTES:
463 * All pending interrupts are handled
464 */
465 {
466 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
467
468 NICDisableInterrupts((PNIC_ADAPTER)MiniportAdapterContext);
469
470 *InterruptRecognized = TRUE;
471 *QueueMiniportHandleInterrupt = TRUE;
472 }
473
474
475 static NDIS_STATUS NTAPI MiniportQueryInformation(
476 IN NDIS_HANDLE MiniportAdapterContext,
477 IN NDIS_OID Oid,
478 IN PVOID InformationBuffer,
479 IN ULONG InformationBufferLength,
480 OUT PULONG BytesWritten,
481 OUT PULONG BytesNeeded)
482 /*
483 * FUNCTION: Handler to process queries
484 * ARGUMENTS:
485 * MiniportAdapterContext = Pointer to adapter context area
486 * Oid = OID code designating query operation
487 * InformationBuffer = Address of return buffer
488 * InformationBufferLength = Length of return buffer
489 * BytesWritten = Address of buffer to place number of bytes returned
490 * BytesNeeded = Address of buffer to place number of bytes needed
491 * in InformationBuffer for specified OID
492 * RETURNS:
493 * Status of operation
494 */
495 {
496 NDIS_STATUS Status;
497 PVOID CopyFrom;
498 UINT CopySize;
499 ULONG GenericULONG;
500 USHORT GenericUSHORT;
501 NDIS_MEDIUM Medium = NdisMedium802_3;
502 PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;
503
504 NDIS_DbgPrint(MAX_TRACE, ("Called. Oid (0x%X).\n", Oid));
505
506 Status = NDIS_STATUS_SUCCESS;
507 CopyFrom = (PVOID)&GenericULONG;
508 CopySize = sizeof(ULONG);
509
510 switch (Oid) {
511 case OID_GEN_SUPPORTED_LIST:
512 CopyFrom = (PVOID)&MiniportOIDList;
513 CopySize = sizeof(MiniportOIDList);
514 break;
515 case OID_GEN_HARDWARE_STATUS:
516 GenericULONG = (ULONG)NdisHardwareStatusReady;
517 break;
518 case OID_GEN_MEDIA_SUPPORTED:
519 case OID_GEN_MEDIA_IN_USE:
520 CopyFrom = (PVOID)&Medium;
521 CopySize = sizeof(NDIS_MEDIUM);
522 break;
523 case OID_GEN_MAXIMUM_LOOKAHEAD:
524 GenericULONG = DRIVER_MAXIMUM_LOOKAHEAD;
525 break;
526 case OID_GEN_MAXIMUM_FRAME_SIZE:
527 GenericULONG = DRIVER_FRAME_SIZE - DRIVER_HEADER_SIZE;
528 break;
529 case OID_GEN_LINK_SPEED:
530 GenericULONG = 100000; /* 10Mbps */
531 break;
532 case OID_GEN_TRANSMIT_BUFFER_SPACE:
533 GenericULONG = Adapter->TXCount * DRIVER_BLOCK_SIZE;
534 break;
535 case OID_GEN_RECEIVE_BUFFER_SPACE:
536 GenericULONG = Adapter->RamSize -
537 (ULONG_PTR)Adapter->RamBase -
538 (Adapter->TXCount * DRIVER_BLOCK_SIZE);
539 break;
540 case OID_GEN_TRANSMIT_BLOCK_SIZE:
541 GenericULONG = DRIVER_BLOCK_SIZE;
542 break;
543 case OID_GEN_RECEIVE_BLOCK_SIZE:
544 GenericULONG = DRIVER_BLOCK_SIZE;
545 break;
546 case OID_GEN_VENDOR_ID:
547 NdisMoveMemory(&GenericULONG, &Adapter->PermanentAddress, 3);
548 GenericULONG &= 0xFFFFFF00;
549 GenericULONG |= 0x01;
550 break;
551 case OID_GEN_VENDOR_DESCRIPTION:
552 CopyFrom = (PVOID)&DRIVER_VENDOR_DESCRIPTION;
553 CopySize = sizeof(DRIVER_VENDOR_DESCRIPTION);
554 break;
555 case OID_GEN_VENDOR_DRIVER_VERSION:
556 GenericUSHORT = (USHORT)DRIVER_VENDOR_DRIVER_VERSION;
557 CopyFrom = (PVOID)&GenericUSHORT;
558 CopySize = sizeof(USHORT);
559 break;
560 case OID_GEN_CURRENT_PACKET_FILTER:
561 GenericULONG = Adapter->PacketFilter;
562 break;
563 case OID_GEN_CURRENT_LOOKAHEAD:
564 GenericULONG = Adapter->LookaheadSize;
565 break;
566 case OID_GEN_DRIVER_VERSION:
567 GenericUSHORT = ((USHORT)DRIVER_NDIS_MAJOR_VERSION << 8) | DRIVER_NDIS_MINOR_VERSION;
568 CopyFrom = (PVOID)&GenericUSHORT;
569 CopySize = sizeof(USHORT);
570 break;
571 case OID_GEN_MAXIMUM_TOTAL_SIZE:
572 GenericULONG = DRIVER_FRAME_SIZE;
573 break;
574 case OID_GEN_PROTOCOL_OPTIONS:
575 NDIS_DbgPrint(MID_TRACE, ("OID_GEN_PROTOCOL_OPTIONS.\n"));
576 Status = NDIS_STATUS_NOT_SUPPORTED;
577 break;
578 case OID_GEN_MAC_OPTIONS:
579 GenericULONG = NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
580 NDIS_MAC_OPTION_RECEIVE_SERIALIZED |
581 NDIS_MAC_OPTION_TRANSFERS_NOT_PEND |
582 NDIS_MAC_OPTION_NO_LOOPBACK;
583 break;
584 case OID_GEN_MEDIA_CONNECT_STATUS:
585 GenericULONG = (ULONG)NdisMediaStateConnected;
586 break;
587 case OID_GEN_MAXIMUM_SEND_PACKETS:
588 GenericULONG = 1;
589 break;
590 case OID_802_3_PERMANENT_ADDRESS:
591 CopyFrom = (PVOID)&Adapter->PermanentAddress;
592 CopySize = DRIVER_LENGTH_OF_ADDRESS;
593 break;
594 case OID_802_3_CURRENT_ADDRESS:
595 CopyFrom = (PVOID)&Adapter->StationAddress;
596 CopySize = DRIVER_LENGTH_OF_ADDRESS;
597 break;
598 case OID_802_3_MULTICAST_LIST:
599 NDIS_DbgPrint(MID_TRACE, ("OID_802_3_MULTICAST_LIST.\n"));
600 Status = NDIS_STATUS_NOT_SUPPORTED;
601 break;
602 case OID_802_3_MAXIMUM_LIST_SIZE:
603 GenericULONG = Adapter->MaxMulticastListSize;
604 break;
605 case OID_802_3_MAC_OPTIONS:
606 NDIS_DbgPrint(MID_TRACE, ("OID_802_3_MAC_OPTIONS.\n"));
607 Status = NDIS_STATUS_NOT_SUPPORTED;
608 break;
609 default:
610 NDIS_DbgPrint(MIN_TRACE, ("Unknown OID (0x%X).\n", Oid));
611 Status = NDIS_STATUS_INVALID_OID;
612 break;
613 }
614
615 if (Status == NDIS_STATUS_SUCCESS) {
616 if (CopySize > InformationBufferLength) {
617 *BytesNeeded = (CopySize - InformationBufferLength);
618 *BytesWritten = 0;
619 Status = NDIS_STATUS_INVALID_LENGTH;
620 } else {
621 NdisMoveMemory(InformationBuffer, CopyFrom, CopySize);
622 *BytesWritten = CopySize;
623 *BytesNeeded = 0;
624 }
625 }
626
627 NDIS_DbgPrint(MAX_TRACE, ("Leaving. Status is (0x%X).\n", Status));
628
629 return Status;
630 }
631
632
633 static NDIS_STATUS NTAPI MiniportReconfigure(
634 OUT PNDIS_STATUS OpenErrorStatus,
635 IN NDIS_HANDLE MiniportAdapterContext,
636 IN NDIS_HANDLE WrapperConfigurationContext)
637 /*
638 * FUNCTION: Reconfigures an adapter
639 * ARGUMENTS:
640 * OpenErrorStatus = Address of buffer to place additional status information
641 * MiniportAdapterContext = Pointer to adapter context area
642 * WrapperConfigurationContext = Handle used to identify configuration context
643 * RETURNS:
644 * Status of operation
645 * NOTES:
646 * Never called by NDIS library
647 */
648 {
649 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
650
651 return NDIS_STATUS_FAILURE;
652 }
653
654
655
656 static NDIS_STATUS NTAPI MiniportReset(
657 OUT PBOOLEAN AddressingReset,
658 IN NDIS_HANDLE MiniportAdapterContext)
659 /*
660 * FUNCTION: Resets an adapter
661 * ARGUMENTS:
662 * AddressingReset = Address of a buffer to place value indicating
663 * wether NDIS library should call MiniportSetInformation
664 * to restore addressing information
665 * MiniportAdapterContext = Pointer to adapter context area
666 * RETURNS:
667 * Status of operation
668 */
669 {
670 NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
671
672 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
673
674 #ifndef NOCARD
675 NdisStatus = NICReset((PNIC_ADAPTER)MiniportAdapterContext);
676 #endif
677
678 *AddressingReset = TRUE;
679
680 return NdisStatus;
681 }
682
683
684 static NDIS_STATUS NTAPI MiniportSend(
685 IN NDIS_HANDLE MiniportAdapterContext,
686 IN PNDIS_PACKET Packet,
687 IN UINT Flags)
688 /*
689 * FUNCTION: Transmits a packet
690 * ARGUMENTS:
691 * MiniportAdapterContext = Pointer to adapter context area
692 * Packet = Pointer to a packet descriptor specifying
693 * the data to be transmitted
694 * Flags = Specifies optional packet flags
695 * RETURNS:
696 * Status of operation
697 */
698 {
699 PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;
700
701 ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
702
703 #ifndef NOCARD
704 NDIS_DbgPrint(MID_TRACE, ("Queueing packet.\n"));
705
706 /* Queue the packet on the transmit queue */
707 RESERVED(Packet)->Next = NULL;
708 if (Adapter->TXQueueHead == NULL) {
709 Adapter->TXQueueHead = Packet;
710 } else {
711 RESERVED(Adapter->TXQueueTail)->Next = Packet;
712 }
713
714 Adapter->TXQueueTail = Packet;
715
716 /* Transmit the packet */
717 NICTransmit(Adapter);
718
719 return NDIS_STATUS_PENDING;
720 #else
721 return NDIS_STATUS_SUCCESS;
722 #endif
723 }
724
725
726 static NDIS_STATUS NTAPI MiniportSetInformation(
727 IN NDIS_HANDLE MiniportAdapterContext,
728 IN NDIS_OID Oid,
729 IN PVOID InformationBuffer,
730 IN ULONG InformationBufferLength,
731 OUT PULONG BytesRead,
732 OUT PULONG BytesNeeded)
733 /*
734 * FUNCTION: Changes state information in the driver
735 * ARGUMENTS:
736 * MiniportAdapterContext = Pointer to adapter context area
737 * Oid = OID code designating set operation
738 * InformationBuffer = Pointer to buffer with state information
739 * InformationBufferLength = Length of InformationBuffer
740 * BytesRead = Address of buffer to place number of bytes read
741 * BytesNeeded = Address of buffer to place number of extra bytes
742 * needed in InformationBuffer for specified OID
743 * RETURNS:
744 * Status of operation
745 */
746 {
747 ULONG GenericULONG;
748 NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
749 PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;
750
751 NDIS_DbgPrint(MAX_TRACE, ("Called. Oid (0x%X).\n", Oid));
752
753 switch (Oid) {
754 case OID_GEN_CURRENT_PACKET_FILTER:
755 /* Verify length */
756 if (InformationBufferLength < sizeof(ULONG)) {
757 *BytesRead = 0;
758 *BytesNeeded = sizeof(ULONG) - InformationBufferLength;
759 Status = NDIS_STATUS_INVALID_LENGTH;
760 break;
761 }
762
763 NdisMoveMemory(&GenericULONG, InformationBuffer, sizeof(ULONG));
764 /* Check for properties the driver don't support */
765 if (GenericULONG &
766 (NDIS_PACKET_TYPE_ALL_FUNCTIONAL |
767 NDIS_PACKET_TYPE_FUNCTIONAL |
768 NDIS_PACKET_TYPE_GROUP |
769 NDIS_PACKET_TYPE_MAC_FRAME |
770 NDIS_PACKET_TYPE_SMT |
771 NDIS_PACKET_TYPE_SOURCE_ROUTING)) {
772 *BytesRead = 4;
773 *BytesNeeded = 0;
774 Status = NDIS_STATUS_NOT_SUPPORTED;
775 break;
776 }
777
778 Adapter->PacketFilter = GenericULONG;
779
780 /* FIXME: Set filter on hardware */
781
782 break;
783 case OID_GEN_CURRENT_LOOKAHEAD:
784 /* Verify length */
785 if (InformationBufferLength < sizeof(ULONG)) {
786 *BytesRead = 0;
787 *BytesNeeded = sizeof(ULONG) - InformationBufferLength;
788 Status = NDIS_STATUS_INVALID_LENGTH;
789 break;
790 }
791
792 NdisMoveMemory(&GenericULONG, InformationBuffer, sizeof(ULONG));
793 if (GenericULONG > DRIVER_MAXIMUM_LOOKAHEAD)
794 Status = NDIS_STATUS_INVALID_LENGTH;
795 else
796 Adapter->LookaheadSize = GenericULONG;
797 break;
798 case OID_802_3_MULTICAST_LIST:
799 /* Verify length. Must be multiplum of hardware address length */
800 if ((InformationBufferLength % DRIVER_LENGTH_OF_ADDRESS) != 0) {
801 *BytesRead = 0;
802 *BytesNeeded = 0;
803 Status = NDIS_STATUS_INVALID_LENGTH;
804 break;
805 }
806
807 /* Set new multicast address list */
808 NdisMoveMemory(Adapter->Addresses, InformationBuffer, InformationBufferLength);
809
810 /* FIXME: Update hardware */
811
812 break;
813 default:
814 NDIS_DbgPrint(MIN_TRACE, ("Invalid object ID (0x%X).\n", Oid));
815 *BytesRead = 0;
816 *BytesNeeded = 0;
817 Status = NDIS_STATUS_INVALID_OID;
818 break;
819 }
820
821 if (Status == NDIS_STATUS_SUCCESS) {
822 *BytesRead = InformationBufferLength;
823 *BytesNeeded = 0;
824 }
825
826 NDIS_DbgPrint(MAX_TRACE, ("Leaving. Status (0x%X).\n", Status));
827
828 return Status;
829 }
830
831
832 static NDIS_STATUS NTAPI MiniportTransferData(
833 OUT PNDIS_PACKET Packet,
834 OUT PUINT BytesTransferred,
835 IN NDIS_HANDLE MiniportAdapterContext,
836 IN NDIS_HANDLE MiniportReceiveContext,
837 IN UINT ByteOffset,
838 IN UINT BytesToTransfer)
839 /*
840 * FUNCTION: Transfers data from a received frame into an NDIS packet
841 * ARGUMENTS:
842 * Packet = Address of packet to copy received data into
843 * BytesTransferred = Address of buffer to place number of bytes transmitted
844 * MiniportAdapterContext = Pointer to adapter context area
845 * MiniportReceiveContext = Pointer to receive context area (actually NULL)
846 * ByteOffset = Offset within received packet to begin copying
847 * BytesToTransfer = Number of bytes to copy into packet
848 * RETURNS:
849 * Status of operation
850 */
851 {
852 PNDIS_BUFFER DstBuffer;
853 UINT BytesCopied, BytesToCopy, DstSize;
854 ULONG SrcData;
855 PUCHAR DstData;
856 UINT RecvStart;
857 UINT RecvStop;
858 PNIC_ADAPTER Adapter = (PNIC_ADAPTER)MiniportAdapterContext;
859
860 NDIS_DbgPrint(MAX_TRACE, ("Called. Packet (0x%X) ByteOffset (0x%X) BytesToTransfer (%d).\n",
861 Packet, ByteOffset, BytesToTransfer));
862
863 if (BytesToTransfer == 0) {
864 *BytesTransferred = 0;
865 return NDIS_STATUS_SUCCESS;
866 }
867
868 RecvStart = Adapter->PageStart * DRIVER_BLOCK_SIZE;
869 RecvStop = Adapter->PageStop * DRIVER_BLOCK_SIZE;
870
871 NdisQueryPacket(Packet, NULL, NULL, &DstBuffer, NULL);
872 NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
873
874 SrcData = Adapter->PacketOffset + sizeof(DISCARD_HEADER) + ByteOffset;
875 if (ByteOffset + sizeof(DISCARD_HEADER) + BytesToTransfer >
876 Adapter->PacketHeader.PacketLength)
877 BytesToTransfer = Adapter->PacketHeader.PacketLength -
878 sizeof(DISCARD_HEADER) - ByteOffset;
879
880 /* Start copying the data */
881 BytesCopied = 0;
882 for (;;) {
883 BytesToCopy = (DstSize < BytesToTransfer) ? DstSize : BytesToTransfer;
884 if (SrcData + BytesToCopy > RecvStop)
885 BytesToCopy = (RecvStop - SrcData);
886
887 NICReadData(Adapter, DstData, SrcData, BytesToCopy);
888
889 BytesCopied += BytesToCopy;
890 SrcData += BytesToCopy;
891 DstData = (PUCHAR)((ULONG_PTR) DstData + BytesToCopy);
892 BytesToTransfer -= BytesToCopy;
893 if (BytesToTransfer == 0)
894 break;
895
896 DstSize -= BytesToCopy;
897 if (DstSize == 0) {
898 /* No more bytes in destination buffer. Proceed to
899 the next buffer in the destination buffer chain */
900 NdisGetNextBuffer(DstBuffer, &DstBuffer);
901 if (!DstBuffer)
902 break;
903
904 NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
905 }
906
907 if (SrcData == RecvStop)
908 SrcData = RecvStart;
909 }
910
911 NDIS_DbgPrint(MID_TRACE, ("Transferred (%d) bytes.\n", BytesToTransfer));
912
913 *BytesTransferred = BytesCopied;
914
915 return NDIS_STATUS_SUCCESS;
916 }
917
918
919 NTSTATUS
920 NTAPI
921 DriverEntry(
922 PDRIVER_OBJECT DriverObject,
923 PUNICODE_STRING RegistryPath)
924 /*
925 * FUNCTION: Main driver entry point
926 * ARGUMENTS:
927 * DriverObject = Pointer to a driver object for this driver
928 * RegistryPath = Registry node for configuration parameters
929 * RETURNS:
930 * Status of driver initialization
931 */
932 {
933 NDIS_STATUS Status;
934 NDIS_HANDLE NdisWrapperHandle;
935 NDIS_MINIPORT_CHARACTERISTICS Miniport;
936
937 NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
938
939 NdisZeroMemory(&Miniport, sizeof(Miniport));
940 Miniport.MajorNdisVersion = DRIVER_NDIS_MAJOR_VERSION;
941 Miniport.MinorNdisVersion = DRIVER_NDIS_MINOR_VERSION;
942 Miniport.CheckForHangHandler = MiniportCheckForHang;
943 Miniport.DisableInterruptHandler = MiniportDisableInterrupt;
944 Miniport.EnableInterruptHandler = MiniportEnableInterrupt;
945 Miniport.HaltHandler = MiniportHalt;
946 Miniport.HandleInterruptHandler = MiniportHandleInterrupt;
947 Miniport.InitializeHandler = MiniportInitialize;
948 Miniport.ISRHandler = MiniportISR;
949 Miniport.QueryInformationHandler = MiniportQueryInformation;
950 Miniport.ReconfigureHandler = MiniportReconfigure;
951 Miniport.ResetHandler = MiniportReset;
952 Miniport.SendHandler = MiniportSend;
953 Miniport.SetInformationHandler = MiniportSetInformation;
954 Miniport.TransferDataHandler = MiniportTransferData;
955
956 NdisMInitializeWrapper(&NdisWrapperHandle,
957 DriverObject,
958 RegistryPath,
959 NULL);
960
961 if (!NdisWrapperHandle) {
962 NDIS_DbgPrint(MIN_TRACE, ("NdisMInitializeWrapper() failed\n"));
963 return STATUS_UNSUCCESSFUL;
964 }
965
966 DriverInfo.NdisWrapperHandle = NdisWrapperHandle;
967 DriverInfo.NdisMacHandle = NULL;
968 InitializeListHead(&DriverInfo.AdapterListHead);
969
970 Status = NdisMRegisterMiniport(NdisWrapperHandle,
971 &Miniport,
972 sizeof(NDIS_MINIPORT_CHARACTERISTICS));
973 if (Status != NDIS_STATUS_SUCCESS) {
974 NDIS_DbgPrint(MIN_TRACE, ("NdisMRegisterMiniport() failed with status code (0x%X).\n", Status));
975 NdisTerminateWrapper(NdisWrapperHandle, NULL);
976 return STATUS_UNSUCCESSFUL;
977 }
978
979 return STATUS_SUCCESS;
980 }
981
982 #if 0
983 /* while i'm here - some basic registry sanity checks */
984 {
985 /* write tests */
986 NDIS_CONFIGURATION_PARAMETER ParameterValue;
987
988 ParameterValue.ParameterType = NdisParameterInteger;
989 ParameterValue.ParameterData.IntegerData = 0x12345678;
990 NdisInitUnicodeString(&Keyword, L"DwordTest");
991 NdisWriteConfiguration(&Status, ConfigurationHandle, &Keyword, &ParameterValue);
992
993 if(Status != NDIS_STATUS_SUCCESS)
994 {
995 DbgPrint("ne2000!MiniportInitialize: failed to set DwordTest: 0x%x\n", Status);
996 DbgBreakPoint();
997 }
998
999 DbgPrint("ne2000!MiniportInitialize: DwordTest successfully set\n");
1000
1001 NdisInitUnicodeString(&Keyword, L"StringTest");
1002 ParameterValue.ParameterType = NdisParameterString;
1003 NdisInitUnicodeString(&ParameterValue.ParameterData.StringData, L"Testing123");
1004
1005 NdisWriteConfiguration(&Status, ConfigurationHandle, &Keyword, &ParameterValue);
1006
1007 if(Status != NDIS_STATUS_SUCCESS)
1008 {
1009 DbgPrint("ne2000!MiniportInitialize: failed to set StringTest: 0x%x\n", Status);
1010 DbgBreakPoint();
1011 }
1012
1013 DbgPrint("ne2000!MiniportInitialize: StringTest successfully set\n");
1014 }
1015
1016 {
1017 /* read back the test values */
1018 NDIS_CONFIGURATION_PARAMETER *ParameterValue = 0;
1019
1020 NdisInitUnicodeString(&Keyword, L"DwordTest");
1021 NdisReadConfiguration(&Status, &ParameterValue, ConfigurationHandle, &Keyword, NdisParameterInteger);
1022
1023 if(Status != NDIS_STATUS_SUCCESS)
1024 {
1025 DbgPrint("ne2000!MiniportInitialize: failed to read DwordTest: 0x%x\n", Status);
1026 DbgBreakPoint();
1027 }
1028
1029 if(ParameterValue->ParameterData.IntegerData != 0x12345678)
1030 {
1031 DbgPrint("ne2000!MiniportInitialize: DwordTest value is wrong: 0x%x\n",
1032 ParameterValue->ParameterData.IntegerData);
1033 DbgBreakPoint();
1034 }
1035
1036 DbgPrint("ne2000!MiniportInitialize: DwordTest value was correctly read\n");
1037
1038 NdisInitUnicodeString(&Keyword, L"StringTest");
1039 NdisReadConfiguration(&Status, &ParameterValue, ConfigurationHandle, &Keyword, NdisParameterString);
1040
1041 if(Status != NDIS_STATUS_SUCCESS)
1042 {
1043 DbgPrint("ne2000!MiniportInitialize: failed to read StringTest: 0x%x\n", Status);
1044 DbgBreakPoint();
1045 }
1046
1047 if(wcsncmp(ParameterValue->ParameterData.StringData.Buffer, L"Testing123",
1048 wcslen(L"Testing123")))
1049 {
1050 DbgPrint("ne2000!MiniportInitialize: StringTest value is wrong: %wZ\n",
1051 &ParameterValue->ParameterData.StringData);
1052 DbgBreakPoint();
1053 }
1054
1055 DbgPrint("ne2000!MiniportInitialize: StringTest value was correctly read\n");
1056 }
1057
1058 #endif
1059 /* EOF */