3 Copyright (c) 2006 - 2007, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 Initialization functions for EFI UNDI32 driver
25 #include <Library/BaseLib.h>
30 PXE_SW_UNDI
*pxe_31
= NULL
; // 3.1 entry
31 UNDI32_DEV
*UNDI32DeviceList
[MAX_NIC_INTERFACES
];
32 NII_TABLE
*UndiDataPointer
= NULL
;
44 When address mapping changes to virtual this should make the appropriate
49 (Standard Event handler)
56 // TODO: Context - add argument and description to function comment
62 Pxe31Pointer
= (VOID
*) pxe_31
;
66 (VOID
**) &Pxe31Pointer
70 // UNDI32DeviceList is an array of pointers
72 for (Index
= 0; Index
< pxe_31
->IFcnt
; Index
++) {
73 UNDI32DeviceList
[Index
]->NIIProtocol_31
.ID
= (UINT64
) (UINTN
) Pxe31Pointer
;
76 (VOID
**) &(UNDI32DeviceList
[Index
])
82 (VOID
**) &(pxe_31
->EntryPoint
)
84 pxe_31
= Pxe31Pointer
;
87 for (Index
= 0; Index
<= PXE_OPCODE_LAST_VALID
; Index
++) {
90 (VOID
**) &api_table
[Index
].api_ptr
105 When EFI is shuting down the boot services, we need to install a
106 configuration table for UNDI to work at runtime!
110 (Standard Event handler)
117 // TODO: Context - add argument and description to function comment
119 InstallConfigTable ();
122 // UNDI Class Driver Global Variables
124 EFI_DRIVER_BINDING_PROTOCOL gUndiDriverBinding
= {
136 UndiDriverSupported (
137 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
138 IN EFI_HANDLE Controller
,
139 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
145 Test to see if this driver supports ControllerHandle. Any ControllerHandle
146 than contains a DevicePath, PciIo protocol, Class code of 2, Vendor ID of 0x8086,
147 and DeviceId of (D100_DEVICE_ID || D102_DEVICE_ID || ICH3_DEVICE_ID_1 ||
148 ICH3_DEVICE_ID_2 || ICH3_DEVICE_ID_3 || ICH3_DEVICE_ID_4 || ICH3_DEVICE_ID_5 ||
149 ICH3_DEVICE_ID_6 || ICH3_DEVICE_ID_7 || ICH3_DEVICE_ID_8) can be supported.
153 This - Protocol instance pointer.
155 Controller - Handle of device to test.
157 RemainingDevicePath - Not used.
161 EFI_SUCCESS - This driver supports this device.
163 other - This driver does not support this device.
168 EFI_PCI_IO_PROTOCOL
*PciIo
;
171 Status
= gBS
->OpenProtocol (
173 &gEfiDevicePathProtocolGuid
,
175 This
->DriverBindingHandle
,
177 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
179 if (EFI_ERROR (Status
)) {
183 Status
= gBS
->OpenProtocol (
185 &gEfiPciIoProtocolGuid
,
187 This
->DriverBindingHandle
,
189 EFI_OPEN_PROTOCOL_BY_DRIVER
191 if (EFI_ERROR (Status
)) {
195 Status
= PciIo
->Pci
.Read (
199 sizeof (PCI_CONFIG_HEADER
),
203 if (!EFI_ERROR (Status
)) {
204 Status
= EFI_UNSUPPORTED
;
206 if (Pci
.Hdr
.ClassCode
[2] == 0x02 && Pci
.Hdr
.VendorId
== PCI_VENDOR_ID_INTEL
) {
207 switch (Pci
.Hdr
.DeviceId
) {
210 case ICH3_DEVICE_ID_1
:
211 case ICH3_DEVICE_ID_2
:
212 case ICH3_DEVICE_ID_3
:
213 case ICH3_DEVICE_ID_4
:
214 case ICH3_DEVICE_ID_5
:
215 case ICH3_DEVICE_ID_6
:
216 case ICH3_DEVICE_ID_7
:
217 case ICH3_DEVICE_ID_8
:
234 Status
= EFI_SUCCESS
;
241 &gEfiPciIoProtocolGuid
,
242 This
->DriverBindingHandle
,
252 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
253 IN EFI_HANDLE Controller
,
254 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
260 Start this driver on Controller by opening PciIo and DevicePath protocol.
261 Initialize PXE structures, create a copy of the Controller Device Path with the
262 NIC's MAC address appended to it, install the NetworkInterfaceIdentifier protocol
263 on the newly created Device Path.
267 This - Protocol instance pointer.
269 Controller - Handle of device to work with.
271 RemainingDevicePath - Not used, always produce all possible children.
275 EFI_SUCCESS - This driver is added to Controller.
277 other - This driver does not support this device.
282 EFI_DEVICE_PATH_PROTOCOL
*UndiDevicePath
;
283 PCI_CONFIG_HEADER
*CfgHdr
;
284 UNDI32_DEV
*UNDI32Device
;
286 UINT8
*TmpPxePointer
;
287 EFI_PCI_IO_PROTOCOL
*PciIoFncs
;
291 Status
= gBS
->OpenProtocol (
293 &gEfiPciIoProtocolGuid
,
294 (VOID
**) &PciIoFncs
,
295 This
->DriverBindingHandle
,
297 EFI_OPEN_PROTOCOL_BY_DRIVER
300 if (EFI_ERROR (Status
)) {
304 Status
= gBS
->OpenProtocol (
306 &gEfiDevicePathProtocolGuid
,
307 (VOID
**) &UndiDevicePath
,
308 This
->DriverBindingHandle
,
310 EFI_OPEN_PROTOCOL_BY_DRIVER
313 if (EFI_ERROR (Status
)) {
316 &gEfiPciIoProtocolGuid
,
317 This
->DriverBindingHandle
,
324 Status
= gBS
->AllocatePool (
325 EfiRuntimeServicesData
,
327 (VOID
**) &UNDI32Device
330 if (EFI_ERROR (Status
)) {
334 ZeroMem ((CHAR8
*) UNDI32Device
, sizeof (UNDI32_DEV
));
337 // Get original PCI attributes
339 Status
= PciIoFncs
->Attributes (
341 EfiPciIoAttributeOperationGet
,
343 &UNDI32Device
->NicInfo
.OriginalPciAttributes
346 if (EFI_ERROR (Status
)) {
351 // allocate and initialize both (old and new) the !pxe structures here,
352 // there should only be one copy of each of these structure for any number
353 // of NICs this undi supports. Also, these structures need to be on a
354 // paragraph boundary as per the spec. so, while allocating space for these,
355 // make sure that there is space for 2 !pxe structures (old and new) and a
356 // 32 bytes padding for alignment adjustment (in case)
358 TmpPxePointer
= NULL
;
359 if (pxe_31
== NULL
) {
360 Status
= gBS
->AllocatePool (
361 EfiRuntimeServicesData
,
362 (sizeof (PXE_SW_UNDI
) + sizeof (PXE_SW_UNDI
) + 32),
363 (VOID
**) &TmpPxePointer
366 if (EFI_ERROR (Status
)) {
367 goto UndiErrorDeleteDevice
;
372 sizeof (PXE_SW_UNDI
) + sizeof (PXE_SW_UNDI
) + 32
375 // check for paragraph alignment here, assuming that the pointer is
376 // already 8 byte aligned.
378 if (((UINTN
) TmpPxePointer
& 0x0F) != 0) {
379 pxe_31
= (PXE_SW_UNDI
*) ((UINTN
) (TmpPxePointer
+ 8));
381 pxe_31
= (PXE_SW_UNDI
*) TmpPxePointer
;
384 PxeStructInit (pxe_31
);
387 UNDI32Device
->NIIProtocol_31
.ID
= (UINT64
) (UINTN
) (pxe_31
);
389 Status
= PciIoFncs
->Attributes (
391 EfiPciIoAttributeOperationSupported
,
395 if (!EFI_ERROR (Status
)) {
396 Supports
&= EFI_PCI_DEVICE_ENABLE
;
397 Status
= PciIoFncs
->Attributes (
399 EfiPciIoAttributeOperationEnable
,
405 // Read all the registers from device's PCI Configuration space
407 Status
= PciIoFncs
->Pci
.Read (
412 &UNDI32Device
->NicInfo
.Config
415 CfgHdr
= (PCI_CONFIG_HEADER
*) &(UNDI32Device
->NicInfo
.Config
[0]);
418 // make sure that this device is a PCI bus master
421 NewCommand
= (UINT16
) (CfgHdr
->Command
| PCI_COMMAND_MASTER
| PCI_COMMAND_IO
);
422 if (CfgHdr
->Command
!= NewCommand
) {
423 PciIoFncs
->Pci
.Write (
430 CfgHdr
->Command
= NewCommand
;
434 // make sure that the latency timer is at least 32
436 if (CfgHdr
->LatencyTimer
< 32) {
437 CfgHdr
->LatencyTimer
= 32;
438 PciIoFncs
->Pci
.Write (
443 &CfgHdr
->LatencyTimer
447 // the IfNum index for the current interface will be the total number
448 // of interfaces initialized so far
450 UNDI32Device
->NIIProtocol_31
.IfNum
= pxe_31
->IFcnt
;
452 PxeUpdate (&UNDI32Device
->NicInfo
, pxe_31
);
454 UNDI32Device
->NicInfo
.Io_Function
= PciIoFncs
;
455 UNDI32DeviceList
[UNDI32Device
->NIIProtocol_31
.IfNum
] = UNDI32Device
;
456 UNDI32Device
->Undi32BaseDevPath
= UndiDevicePath
;
458 Status
= AppendMac2DevPath (
459 &UNDI32Device
->Undi32DevPath
,
460 UNDI32Device
->Undi32BaseDevPath
,
461 &UNDI32Device
->NicInfo
465 goto UndiErrorDeletePxe
;
468 UNDI32Device
->Signature
= UNDI_DEV_SIGNATURE
;
470 UNDI32Device
->NIIProtocol_31
.Revision
= EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION_31
;
471 UNDI32Device
->NIIProtocol_31
.Type
= EfiNetworkInterfaceUndi
;
472 UNDI32Device
->NIIProtocol_31
.MajorVer
= PXE_ROMID_MAJORVER
;
473 UNDI32Device
->NIIProtocol_31
.MinorVer
= PXE_ROMID_MINORVER_31
;
474 UNDI32Device
->NIIProtocol_31
.ImageSize
= 0;
475 UNDI32Device
->NIIProtocol_31
.ImageAddr
= 0;
476 UNDI32Device
->NIIProtocol_31
.Ipv6Supported
= FALSE
;
478 UNDI32Device
->NIIProtocol_31
.StringId
[0] = 'U';
479 UNDI32Device
->NIIProtocol_31
.StringId
[1] = 'N';
480 UNDI32Device
->NIIProtocol_31
.StringId
[2] = 'D';
481 UNDI32Device
->NIIProtocol_31
.StringId
[3] = 'I';
483 UNDI32Device
->DeviceHandle
= NULL
;
486 // install both the 3.0 and 3.1 NII protocols.
488 Status
= gBS
->InstallMultipleProtocolInterfaces (
489 &UNDI32Device
->DeviceHandle
,
490 &gEfiNetworkInterfaceIdentifierProtocolGuid_31
,
491 &UNDI32Device
->NIIProtocol_31
,
492 &gEfiDevicePathProtocolGuid
,
493 UNDI32Device
->Undi32DevPath
,
497 if (EFI_ERROR (Status
)) {
498 goto UndiErrorDeleteDevicePath
;
502 // if the table exists, free it and alloc again, or alloc it directly
504 if (UndiDataPointer
!= NULL
) {
505 Status
= gBS
->FreePool(UndiDataPointer
);
507 if (EFI_ERROR (Status
)) {
508 goto UndiErrorDeleteDevicePath
;
511 Len
= (pxe_31
->IFcnt
* sizeof (NII_ENTRY
)) + sizeof (UndiDataPointer
);
512 Status
= gBS
->AllocatePool (EfiRuntimeServicesData
, Len
, (VOID
**) &UndiDataPointer
);
514 if (EFI_ERROR (Status
)) {
515 goto UndiErrorAllocDataPointer
;
519 // Open For Child Device
521 Status
= gBS
->OpenProtocol (
523 &gEfiPciIoProtocolGuid
,
524 (VOID
**) &PciIoFncs
,
525 This
->DriverBindingHandle
,
526 UNDI32Device
->DeviceHandle
,
527 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
531 UndiErrorAllocDataPointer
:
532 gBS
->UninstallMultipleProtocolInterfaces (
533 &UNDI32Device
->DeviceHandle
,
534 &gEfiNetworkInterfaceIdentifierProtocolGuid_31
,
535 &UNDI32Device
->NIIProtocol_31
,
536 &gEfiDevicePathProtocolGuid
,
537 UNDI32Device
->Undi32DevPath
,
541 UndiErrorDeleteDevicePath
:
542 UNDI32DeviceList
[UNDI32Device
->NIIProtocol_31
.IfNum
] = NULL
;
543 gBS
->FreePool (UNDI32Device
->Undi32DevPath
);
546 PxeUpdate (NULL
, pxe_31
);
547 if (TmpPxePointer
!= NULL
) {
548 gBS
->FreePool (TmpPxePointer
);
552 UndiErrorDeleteDevice
:
554 // Restore original PCI attributes
556 PciIoFncs
->Attributes (
558 EfiPciIoAttributeOperationSet
,
559 UNDI32Device
->NicInfo
.OriginalPciAttributes
,
563 gBS
->FreePool (UNDI32Device
);
568 &gEfiDevicePathProtocolGuid
,
569 This
->DriverBindingHandle
,
575 &gEfiPciIoProtocolGuid
,
576 This
->DriverBindingHandle
,
586 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
587 IN EFI_HANDLE Controller
,
588 IN UINTN NumberOfChildren
,
589 IN EFI_HANDLE
*ChildHandleBuffer
594 Stop this driver on Controller by removing NetworkInterfaceIdentifier protocol and
595 closing the DevicePath and PciIo protocols on Controller.
598 This - Protocol instance pointer.
599 Controller - Handle of device to stop driver on.
600 NumberOfChildren - How many children need to be stopped.
601 ChildHandleBuffer - Not used.
604 EFI_SUCCESS - This driver is removed Controller.
605 other - This driver was not removed from this device.
608 // TODO: EFI_DEVICE_ERROR - add return value to function comment
611 BOOLEAN AllChildrenStopped
;
613 UNDI32_DEV
*UNDI32Device
;
614 EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL
*NIIProtocol
;
615 EFI_PCI_IO_PROTOCOL
*PciIo
;
618 // Complete all outstanding transactions to Controller.
619 // Don't allow any new transaction to Controller to be started.
621 if (NumberOfChildren
== 0) {
624 // Close the bus driver
626 Status
= gBS
->CloseProtocol (
628 &gEfiDevicePathProtocolGuid
,
629 This
->DriverBindingHandle
,
633 Status
= gBS
->CloseProtocol (
635 &gEfiPciIoProtocolGuid
,
636 This
->DriverBindingHandle
,
643 AllChildrenStopped
= TRUE
;
645 for (Index
= 0; Index
< NumberOfChildren
; Index
++) {
647 Status
= gBS
->OpenProtocol (
648 ChildHandleBuffer
[Index
],
649 &gEfiNetworkInterfaceIdentifierProtocolGuid_31
,
650 (VOID
**) &NIIProtocol
,
651 This
->DriverBindingHandle
,
653 EFI_OPEN_PROTOCOL_GET_PROTOCOL
655 if (!EFI_ERROR (Status
)) {
657 UNDI32Device
= UNDI_DEV_FROM_THIS (NIIProtocol
);
660 // Restore original PCI attributes
662 Status
= UNDI32Device
->NicInfo
.Io_Function
->Attributes (
663 UNDI32Device
->NicInfo
.Io_Function
,
664 EfiPciIoAttributeOperationSet
,
665 UNDI32Device
->NicInfo
.OriginalPciAttributes
,
668 ASSERT_EFI_ERROR (Status
);
670 Status
= gBS
->CloseProtocol (
672 &gEfiPciIoProtocolGuid
,
673 This
->DriverBindingHandle
,
674 ChildHandleBuffer
[Index
]
677 Status
= gBS
->UninstallMultipleProtocolInterfaces (
678 ChildHandleBuffer
[Index
],
679 &gEfiDevicePathProtocolGuid
,
680 UNDI32Device
->Undi32DevPath
,
681 &gEfiNetworkInterfaceIdentifierProtocolGuid_31
,
682 &UNDI32Device
->NIIProtocol_31
,
686 if (EFI_ERROR (Status
)) {
689 &gEfiPciIoProtocolGuid
,
691 This
->DriverBindingHandle
,
692 ChildHandleBuffer
[Index
],
693 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
696 gBS
->FreePool (UNDI32Device
->Undi32DevPath
);
697 gBS
->FreePool (UNDI32Device
);
701 if (EFI_ERROR (Status
)) {
702 AllChildrenStopped
= FALSE
;
706 if (!AllChildrenStopped
) {
707 return EFI_DEVICE_ERROR
;
717 IN UINTN MicroSeconds
723 Use the EFI boot services to produce a pause. This is also the routine which
724 gets replaced during RunTime by the O/S in the NIC_DATA_INSTANCE so it can
729 UnqId - Runtime O/S routine might use this, this temp routine does not use it
731 MicroSeconds - Determines the length of pause.
739 gBS
->Stall ((UINT32
) MicroSeconds
);
754 Use the PCI IO abstraction to issue memory or I/O reads and writes. This is also the routine which
755 gets replaced during RunTime by the O/S in the NIC_DATA_INSTANCE so it can do it's own I/O abstractions.
759 UnqId - Runtime O/S routine may use this field, this temp routine does not.
761 ReadWrite - Determine if it is an I/O or Memory Read/Write Operation.
763 Len - Determines the width of the data operation.
765 Port - What port to Read/Write from.
767 BuffAddr - Address to read to or write from.
775 EFI_PCI_IO_PROTOCOL_WIDTH Width
;
776 NIC_DATA_INSTANCE
*AdapterInfo
;
778 Width
= (EFI_PCI_IO_PROTOCOL_WIDTH
) 0;
779 AdapterInfo
= (NIC_DATA_INSTANCE
*) (UINTN
) UnqId
;
782 Width
= (EFI_PCI_IO_PROTOCOL_WIDTH
) 1;
786 Width
= (EFI_PCI_IO_PROTOCOL_WIDTH
) 2;
790 Width
= (EFI_PCI_IO_PROTOCOL_WIDTH
) 3;
796 AdapterInfo
->Io_Function
->Io
.Read (
797 AdapterInfo
->Io_Function
,
802 (VOID
*) (UINTN
) (BuffAddr
)
807 AdapterInfo
->Io_Function
->Io
.Write (
808 AdapterInfo
->Io_Function
,
813 (VOID
*) (UINTN
) (BuffAddr
)
818 AdapterInfo
->Io_Function
->Mem
.Read (
819 AdapterInfo
->Io_Function
,
824 (VOID
*) (UINTN
) (BuffAddr
)
829 AdapterInfo
->Io_Function
->Mem
.Write (
830 AdapterInfo
->Io_Function
,
835 (VOID
*) (UINTN
) (BuffAddr
)
845 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevPtr
,
846 IN EFI_DEVICE_PATH_PROTOCOL
*BaseDevPtr
,
847 IN NIC_DATA_INSTANCE
*AdapterInfo
853 Using the NIC data structure information, read the EEPROM to get the MAC address and then allocate space
854 for a new devicepath (**DevPtr) which will contain the original device path the NIC was found on (*BaseDevPtr)
855 and an added MAC node.
859 DevPtr - Pointer which will point to the newly created device path with the MAC node attached.
861 BaseDevPtr - Pointer to the device path which the UNDI device driver is latching on to.
863 AdapterInfo - Pointer to the NIC data structure information which the UNDI driver is layering on..
867 EFI_SUCCESS - A MAC address was successfully appended to the Base Device Path.
869 other - Not enough resources available to create new Device Path node.
873 EFI_MAC_ADDRESS MACAddress
;
874 PCI_CONFIG_HEADER
*CfgHdr
;
879 MAC_ADDR_DEVICE_PATH MacAddrNode
;
880 EFI_DEVICE_PATH_PROTOCOL
*EndNode
;
887 // set the environment ready (similar to UNDI_Start call) so that we can
888 // execute the other UNDI_ calls to get the mac address
889 // we are using undi 3.1 style
891 AdapterInfo
->Delay
= TmpDelay
;
892 AdapterInfo
->Virt2Phys
= (VOID
*) 0;
893 AdapterInfo
->Block
= (VOID
*) 0;
894 AdapterInfo
->Map_Mem
= (VOID
*) 0;
895 AdapterInfo
->UnMap_Mem
= (VOID
*) 0;
896 AdapterInfo
->Sync_Mem
= (VOID
*) 0;
897 AdapterInfo
->Mem_Io
= TmpMemIo
;
899 // these tmp call-backs follow 3.1 undi style
900 // i.e. they have the unique_id parameter.
902 AdapterInfo
->VersionFlag
= 0x31;
903 AdapterInfo
->Unique_ID
= (UINT64
) (UINTN
) AdapterInfo
;
908 CfgHdr
= (PCI_CONFIG_HEADER
*) &(AdapterInfo
->Config
[0]);
909 AdapterInfo
->ioaddr
= 0;
910 AdapterInfo
->RevID
= CfgHdr
->RevID
;
912 AddrLen
= E100bGetEepromAddrLen (AdapterInfo
);
914 for (Index
= 0, Index2
= 0; Index
< 3; Index
++) {
915 Val
= E100bReadEeprom (AdapterInfo
, Index
, AddrLen
);
916 MACAddress
.Addr
[Index2
++] = (UINT8
) Val
;
917 MACAddress
.Addr
[Index2
++] = (UINT8
) (Val
>> 8);
920 SetMem (MACAddress
.Addr
+ Index2
, sizeof (EFI_MAC_ADDRESS
) - Index2
, 0);
921 //for (; Index2 < sizeof (EFI_MAC_ADDRESS); Index2++) {
922 // MACAddress.Addr[Index2] = 0;
927 AdapterInfo
->Delay
= (VOID
*) 0;
928 AdapterInfo
->Mem_Io
= (VOID
*) 0;
931 // fill the mac address node first
933 ZeroMem ((CHAR8
*) &MacAddrNode
, sizeof MacAddrNode
);
935 (CHAR8
*) &MacAddrNode
.MacAddress
,
936 (CHAR8
*) &MACAddress
,
937 sizeof (EFI_MAC_ADDRESS
)
940 MacAddrNode
.Header
.Type
= MESSAGING_DEVICE_PATH
;
941 MacAddrNode
.Header
.SubType
= MSG_MAC_ADDR_DP
;
942 MacAddrNode
.Header
.Length
[0] = sizeof (MacAddrNode
);
943 MacAddrNode
.Header
.Length
[1] = 0;
946 // find the size of the base dev path.
948 EndNode
= BaseDevPtr
;
950 while (!IsDevicePathEnd (EndNode
)) {
951 EndNode
= NextDevicePathNode (EndNode
);
954 BasePathLen
= (UINT16
) ((UINTN
) (EndNode
) - (UINTN
) (BaseDevPtr
));
957 // create space for full dev path
959 TotalPathLen
= (UINT16
) (BasePathLen
+ sizeof (MacAddrNode
) + sizeof (EFI_DEVICE_PATH_PROTOCOL
));
961 Status
= gBS
->AllocatePool (
962 EfiRuntimeServicesData
,
967 if (Status
!= EFI_SUCCESS
) {
971 // copy the base path, mac addr and end_dev_path nodes
973 *DevPtr
= (EFI_DEVICE_PATH_PROTOCOL
*) DevicePtr
;
974 CopyMem (DevicePtr
, (CHAR8
*) BaseDevPtr
, BasePathLen
);
975 DevicePtr
+= BasePathLen
;
976 CopyMem (DevicePtr
, (CHAR8
*) &MacAddrNode
, sizeof (MacAddrNode
));
977 DevicePtr
+= sizeof (MacAddrNode
);
978 CopyMem (DevicePtr
, (CHAR8
*) EndNode
, sizeof (EFI_DEVICE_PATH_PROTOCOL
));
991 Install a GUID/Pointer pair into the system's configuration table.
999 EFI_SUCCESS - Install a GUID/Pointer pair into the system's configuration table.
1001 other - Did not successfully install the GUID/Pointer pair into the configuration table.
1004 // TODO: VOID - add argument and description to function comment
1007 EFI_CONFIGURATION_TABLE
*CfgPtr
;
1010 NII_TABLE
*UndiData
;
1012 if (pxe_31
== NULL
) {
1016 if(UndiDataPointer
== NULL
) {
1020 UndiData
= (NII_TABLE
*)UndiDataPointer
;
1022 UndiData
->NumEntries
= pxe_31
->IFcnt
;
1023 UndiData
->NextLink
= NULL
;
1025 for (Index
= 0; Index
< pxe_31
->IFcnt
; Index
++) {
1026 UndiData
->NiiEntry
[Index
].InterfacePointer
= &UNDI32DeviceList
[Index
]->NIIProtocol_31
;
1027 UndiData
->NiiEntry
[Index
].DevicePathPointer
= UNDI32DeviceList
[Index
]->Undi32DevPath
;
1031 // see if there is an entry in the config table already
1033 CfgPtr
= gST
->ConfigurationTable
;
1035 for (Index
= 0; Index
< gST
->NumberOfTableEntries
; Index
++) {
1036 Status
= CompareGuid (
1037 &CfgPtr
->VendorGuid
,
1038 &gEfiNetworkInterfaceIdentifierProtocolGuid_31
1040 if (Status
!= EFI_SUCCESS
) {
1047 if (Index
< gST
->NumberOfTableEntries
) {
1048 TmpData
= (NII_TABLE
*) CfgPtr
->VendorTable
;
1051 // go to the last link
1053 while (TmpData
->NextLink
!= NULL
) {
1054 TmpData
= TmpData
->NextLink
;
1057 TmpData
->NextLink
= UndiData
;
1062 UndiData
= (NII_TABLE
*) CfgPtr
->VendorTable
;
1066 // create an entry in the configuration table for our GUID
1068 Status
= gBS
->InstallConfigurationTable (
1069 &gEfiNetworkInterfaceIdentifierProtocolGuid_31
,
1077 Install driver binding protocol of UNDI.
1079 @param[in] ImageHandle The firmware allocated handle for the EFI image.
1080 @param[in] SystemTable A pointer to the EFI System Table.
1082 @retval EFI_SUCCESS The entry point is executed successfully.
1083 @retval other Some error occurs when executing this entry point.
1089 IN EFI_HANDLE ImageHandle
,
1090 IN EFI_SYSTEM_TABLE
*SystemTable
1096 Status
= EfiLibInstallDriverBinding (
1099 &gUndiDriverBinding
,
1102 ASSERT_EFI_ERROR (Status
);
1104 Status
= gBS
->CreateEvent (
1105 EVT_SIGNAL_EXIT_BOOT_SERVICES
,
1111 ASSERT_EFI_ERROR (Status
);
1113 Status
= gBS
->CreateEvent (
1114 EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
,
1120 ASSERT_EFI_ERROR (Status
);