/** Start this driver on ControllerHandle. This service is called by the EFI boot service ConnectController(). In order to make drivers as small as possible, there are a few calling restrictions for this service. ConnectController() must follow these calling restrictions. If any other agent wishes to call Start() it must also follow these calling restrictions. @param This Protocol instance pointer. @param ControllerHandle Handle of device to bind driver to. @param RemainingDevicePath Optional parameter use to pick a specific child device to start. @retval EFI_SUCCESS This driver is added to ControllerHandle @retval EFI_DEVICE_ERROR This driver could not be started due to a device error @retval other This driver does not support this device **/ EFI_STATUS EFIAPI SimpleNetworkDriverStart ( IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE Controller, IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath ) { EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL *Nii; EFI_DEVICE_PATH_PROTOCOL *NiiDevicePath; EFI_STATUS Status; PXE_UNDI *Pxe; SNP_DRIVER *Snp; VOID *Address; EFI_HANDLE Handle; PXE_PCI_CONFIG_INFO ConfigInfo; PCI_TYPE00 *ConfigHeader; UINT32 *TempBar; UINT8 BarIndex; PXE_STATFLAGS InitStatFlags; DEBUG ((EFI_D_NET, "\nSnpNotifyNetworkInterfaceIdentifier() ")); Status = gBS->OpenProtocol ( Controller, &gEfiDevicePathProtocolGuid, (VOID **) &NiiDevicePath, This->DriverBindingHandle, Controller, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { return Status; } Status = gBS->LocateDevicePath ( &gEfiPciIoProtocolGuid, &NiiDevicePath, &Handle ); if (EFI_ERROR (Status)) { return Status; } Status = gBS->OpenProtocol ( Handle, &gEfiPciIoProtocolGuid, (VOID **) &mPciIo, This->DriverBindingHandle, Controller, EFI_OPEN_PROTOCOL_GET_PROTOCOL ); if (EFI_ERROR (Status)) { return Status; } // // Get the NII interface. // Status = gBS->OpenProtocol ( Controller, &gEfiNetworkInterfaceIdentifierProtocolGuid_31, (VOID **) &Nii, This->DriverBindingHandle, Controller, EFI_OPEN_PROTOCOL_BY_DRIVER ); if (EFI_ERROR (Status)) { gBS->CloseProtocol ( Controller, &gEfiDevicePathProtocolGuid, This->DriverBindingHandle, Controller ); return Status; } DEBUG ((EFI_D_INFO, "Start(): UNDI3.1 found\n")); Pxe = (PXE_UNDI *) (UINTN) (Nii->Id); if (Calc8BitCksum (Pxe, Pxe->hw.Len) != 0) { DEBUG ((EFI_D_NET, "\n!PXE checksum is not correct.\n")); goto NiiError; } if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED) != 0) { // // We can get any packets. // } else if ((Pxe->hw.Implementation & PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED) != 0) { // // We need to be able to get broadcast packets for DHCP. // If we do not have promiscuous support, we must at least have // broadcast support or we cannot do DHCP! // } else { DEBUG ((EFI_D_NET, "\nUNDI does not have promiscuous or broadcast support.")); goto NiiError; } // // OK, we like this UNDI, and we know snp is not already there on this handle // Allocate and initialize a new simple network protocol structure. // Status = mPciIo->AllocateBuffer ( mPciIo, AllocateAnyPages, EfiBootServicesData, SNP_MEM_PAGES (sizeof (SNP_DRIVER)), &Address, 0 ); if (Status != EFI_SUCCESS) { DEBUG ((EFI_D_NET, "\nCould not allocate SNP_DRIVER structure.\n")); goto NiiError; } Snp = (SNP_DRIVER *) (UINTN) Address; ZeroMem (Snp, sizeof (SNP_DRIVER)); Snp->PciIo = mPciIo; Snp->Signature = SNP_DRIVER_SIGNATURE; EfiInitializeLock (&Snp->Lock, TPL_NOTIFY); Snp->Snp.Revision = EFI_SIMPLE_NETWORK_PROTOCOL_REVISION; Snp->Snp.Start = SnpUndi32Start; Snp->Snp.Stop = SnpUndi32Stop; Snp->Snp.Initialize = SnpUndi32Initialize; Snp->Snp.Reset = SnpUndi32Reset; Snp->Snp.Shutdown = SnpUndi32Shutdown; Snp->Snp.ReceiveFilters = SnpUndi32ReceiveFilters; Snp->Snp.StationAddress = SnpUndi32StationAddress; Snp->Snp.Statistics = SnpUndi32Statistics; Snp->Snp.MCastIpToMac = SnpUndi32McastIpToMac; Snp->Snp.NvData = SnpUndi32NvData; Snp->Snp.GetStatus = SnpUndi32GetStatus; Snp->Snp.Transmit = SnpUndi32Transmit; Snp->Snp.Receive = SnpUndi32Receive; Snp->Snp.WaitForPacket = NULL; Snp->Snp.Mode = &Snp->Mode; Snp->TxRxBufferSize = 0; Snp->TxRxBuffer = NULL; if (Nii->Revision >= EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION) { Snp->IfNum = Nii->IfNum; } else { Snp->IfNum = (UINT8) (Nii->IfNum & 0xFF); } if ((Pxe->hw.Implementation & PXE_ROMID_IMP_HW_UNDI) != 0) { Snp->IsSwUndi = FALSE; Snp->IssueUndi32Command = &IssueHwUndiCommand; } else { Snp->IsSwUndi = TRUE; if ((Pxe->sw.Implementation & PXE_ROMID_IMP_SW_VIRT_ADDR) != 0) { Snp->IssueUndi32Command = (ISSUE_UNDI32_COMMAND) (UINTN) Pxe->sw.EntryPoint; } else { Snp->IssueUndi32Command = (ISSUE_UNDI32_COMMAND) (UINTN) ((UINT8) (UINTN) Pxe + Pxe->sw.EntryPoint); } } // // Allocate a global CPB and DB buffer for this UNDI interface. // we do this because: // // -UNDI 3.0 wants all the addresses passed to it (even the cpb and db) to be // within 2GB limit, create them here and map them so that when undi calls // v2p callback to check if the physical address is < 2gb, we will pass. // // -This is not a requirement for 3.1 or later UNDIs but the code looks // simpler if we use the same cpb, db variables for both old and new undi // interfaces from all the SNP interface calls (we don't map the buffers // for the newer undi interfaces though) // . // -it is OK to allocate one global set of CPB, DB pair for each UNDI // interface as EFI does not multi-task and so SNP will not be re-entered! // Status = mPciIo->AllocateBuffer ( mPciIo, AllocateAnyPages, EfiBootServicesData, SNP_MEM_PAGES (4096), &Address, 0 ); if (Status != EFI_SUCCESS) { DEBUG ((EFI_D_NET, "\nCould not allocate CPB and DB structures.\n")); goto Error_DeleteSNP; } Snp->Cpb = (VOID *) (UINTN) Address; Snp->Db = (VOID *) ((UINTN) Address + 2048); // // PxeStart call is going to give the callback functions to UNDI, these callback // functions use the BarIndex values from the snp structure, so these must be initialized // with default values before doing a PxeStart. The correct values can be obtained after // getting the config information from UNDI // Snp->MemoryBarIndex = 0; Snp->IoBarIndex = 1; // // we need the undi init information many times in this snp code, just get it // once here and store it in the snp driver structure. to get Init Info // from UNDI we have to start undi first. // Status = PxeStart (Snp); if (Status != EFI_SUCCESS) { goto Error_DeleteSNP; } Snp->Cdb.OpCode = PXE_OPCODE_GET_INIT_INFO; Snp->Cdb.OpFlags = PXE_OPFLAGS_NOT_USED; Snp->Cdb.CPBsize = PXE_CPBSIZE_NOT_USED; Snp->Cdb.CPBaddr = PXE_DBADDR_NOT_USED; Snp->Cdb.DBsize = (UINT16) sizeof (Snp->InitInfo); Snp->Cdb.DBaddr = (UINT64)(UINTN) (&Snp->InitInfo); Snp->Cdb.StatCode = PXE_STATCODE_INITIALIZE; Snp->Cdb.StatFlags = PXE_STATFLAGS_INITIALIZE; Snp->Cdb.IFnum = Snp->IfNum; Snp->Cdb.Control = PXE_CONTROL_LAST_CDB_IN_LIST; DEBUG ((EFI_D_NET, "\nSnp->undi.get_init_info() ")); (*Snp->IssueUndi32Command) ((UINT64)(UINTN) &Snp->Cdb); // // Save the INIT Stat Code... // InitStatFlags = Snp->Cdb.StatFlags; if (Snp->Cdb.StatCode != PXE_STATCODE_SUCCESS) { DEBUG ((EFI_D_NET, "\nSnp->undi.init_info() %xh:%xh\n", Snp->Cdb.StatFlags, Snp->Cdb.StatCode)); PxeStop (Snp); goto Error_DeleteSNP; } Snp->Cdb.OpCode = PXE_OPCODE_GET_CONFIG_INFO; Snp->Cdb.OpFlags = PXE_OPFLAGS_NOT_USED; Snp->Cdb.CPBsize = PXE_CPBSIZE_NOT_USED; Snp->Cdb.CPBaddr = PXE_DBADDR_NOT_USED; Snp->Cdb.DBsize = (UINT16) sizeof (ConfigInfo); Snp->Cdb.DBaddr = (UINT64)(UINTN) &ConfigInfo; Snp->Cdb.StatCode = PXE_STATCODE_INITIALIZE; Snp->Cdb.StatFlags = PXE_STATFLAGS_INITIALIZE; Snp->Cdb.IFnum = Snp->IfNum; Snp->Cdb.Control = PXE_CONTROL_LAST_CDB_IN_LIST; DEBUG ((EFI_D_NET, "\nSnp->undi.get_config_info() ")); (*Snp->IssueUndi32Command) ((UINT64)(UINTN) &Snp->Cdb); if (Snp->Cdb.StatCode != PXE_STATCODE_SUCCESS) { DEBUG ((EFI_D_NET, "\nSnp->undi.config_info() %xh:%xh\n", Snp->Cdb.StatFlags, Snp->Cdb.StatCode)); PxeStop (Snp); goto Error_DeleteSNP; } // // Find the correct BAR to do IO. // // // Enumerate through the PCI BARs for the device to determine which one is // the IO BAR. Save the index of the BAR into the adapter info structure. // for regular 32bit BARs, 0 is memory mapped, 1 is io mapped // ConfigHeader = (PCI_TYPE00 *) ConfigInfo.Config.Byte; TempBar = (UINT32 *) ConfigHeader->Device.Bar; for (BarIndex = 0; BarIndex <= 5; BarIndex++) { if ((*TempBar & PCI_BAR_MEM_MASK) == PCI_BAR_MEM_64BIT) { // // This is a 64-bit memory bar, skip this and the // next bar as well. // TempBar++; } if ((*TempBar & PCI_BAR_IO_MASK) == PCI_BAR_IO_MODE) { Snp->IoBarIndex = BarIndex; break; } TempBar++; } // // Initialize simple network protocol mode structure // Snp->Mode.State = EfiSimpleNetworkStopped; Snp->Mode.HwAddressSize = Snp->InitInfo.HWaddrLen; Snp->Mode.MediaHeaderSize = Snp->InitInfo.MediaHeaderLen; Snp->Mode.MaxPacketSize = Snp->InitInfo.FrameDataLen; Snp->Mode.NvRamAccessSize = Snp->InitInfo.NvWidth; Snp->Mode.NvRamSize = Snp->InitInfo.NvCount * Snp->Mode.NvRamAccessSize; Snp->Mode.IfType = Snp->InitInfo.IFtype; Snp->Mode.MaxMCastFilterCount = Snp->InitInfo.MCastFilterCnt; Snp->Mode.MCastFilterCount = 0; switch (InitStatFlags & PXE_STATFLAGS_CABLE_DETECT_MASK) { case PXE_STATFLAGS_CABLE_DETECT_SUPPORTED: Snp->Mode.MediaPresentSupported = TRUE; break; case PXE_STATFLAGS_CABLE_DETECT_NOT_SUPPORTED: default: Snp->Mode.MediaPresentSupported = FALSE; } switch (InitStatFlags & PXE_STATFLAGS_GET_STATUS_NO_MEDIA_MASK) { case PXE_STATFLAGS_GET_STATUS_NO_MEDIA_SUPPORTED: Snp->MediaStatusSupported = TRUE; break; case PXE_STATFLAGS_GET_STATUS_NO_MEDIA_NOT_SUPPORTED: default: Snp->MediaStatusSupported = FALSE; } if ((Pxe->hw.Implementation & PXE_ROMID_IMP_STATION_ADDR_SETTABLE) != 0) { Snp->Mode.MacAddressChangeable = TRUE; } else { Snp->Mode.MacAddressChangeable = FALSE; } if ((Pxe->hw.Implementation & PXE_ROMID_IMP_MULTI_FRAME_SUPPORTED) != 0) { Snp->Mode.MultipleTxSupported = TRUE; } else { Snp->Mode.MultipleTxSupported = FALSE; } Snp->Mode.ReceiveFilterMask = EFI_SIMPLE_NETWORK_RECEIVE_UNICAST; if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED) != 0) { Snp->Mode.ReceiveFilterMask |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST; } if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED) != 0) { Snp->Mode.ReceiveFilterMask |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS; } if ((Pxe->hw.Implementation & PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED) != 0) { Snp->Mode.ReceiveFilterMask |= EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST; } if ((Pxe->hw.Implementation & PXE_ROMID_IMP_FILTERED_MULTICAST_RX_SUPPORTED) != 0) { Snp->Mode.ReceiveFilterMask |= EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST; } if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED) != 0) { Snp->Mode.ReceiveFilterMask |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST; } Snp->Mode.ReceiveFilterSetting = 0; // // need to get the station address to save in the mode structure. we need to // initialize the UNDI first for this. // Snp->TxRxBufferSize = Snp->InitInfo.MemoryRequired; Status = PxeInit (Snp, PXE_OPFLAGS_INITIALIZE_DO_NOT_DETECT_CABLE); if (EFI_ERROR (Status)) { PxeStop (Snp); goto Error_DeleteSNP; } Status = PxeGetStnAddr (Snp); if (Status != EFI_SUCCESS) { DEBUG ((EFI_D_ERROR, "\nSnp->undi.get_station_addr() failed.\n")); PxeShutdown (Snp); PxeStop (Snp); goto Error_DeleteSNP; } Snp->Mode.MediaPresent = FALSE; // // We should not leave UNDI started and initialized here. this DriverStart() // routine must only find and attach the SNP interface to UNDI layer that it // finds on the given handle! // The UNDI layer will be started when upper layers call Snp->start. // How ever, this DriverStart() must fill up the snp mode structure which // contains the MAC address of the NIC. For this reason we started and // initialized UNDI here, now we are done, do a shutdown and stop of the // UNDI interface! // PxeShutdown (Snp); PxeStop (Snp); // // Create EXIT_BOOT_SERIVES Event // Status = gBS->CreateEventEx ( EVT_NOTIFY_SIGNAL, TPL_NOTIFY, SnpNotifyExitBootServices, Snp, &gEfiEventExitBootServicesGuid, &Snp->ExitBootServicesEvent ); if (EFI_ERROR (Status)) { goto Error_DeleteSNP; } // // add SNP to the undi handle // Status = gBS->InstallProtocolInterface ( &Controller, &gEfiSimpleNetworkProtocolGuid, EFI_NATIVE_INTERFACE, &(Snp->Snp) ); if (!EFI_ERROR (Status)) { return Status; } mPciIo->FreeBuffer ( mPciIo, SNP_MEM_PAGES (4096), Snp->Cpb ); Error_DeleteSNP: mPciIo->FreeBuffer ( mPciIo, SNP_MEM_PAGES (sizeof (SNP_DRIVER)), Snp ); NiiError: gBS->CloseProtocol ( Controller, &gEfiNetworkInterfaceIdentifierProtocolGuid_31, This->DriverBindingHandle, Controller ); gBS->CloseProtocol ( Controller, &gEfiDevicePathProtocolGuid, This->DriverBindingHandle, Controller ); // // If we got here that means we are in error state. // if (!EFI_ERROR (Status)) { Status = EFI_DEVICE_ERROR; } return Status; }
/** Call UNDI to set a new MAC address for the NIC. @param Snp Pointer to Snp driver structure. @param NewMacAddr Pointer to a MAC address to be set for the NIC, if this is NULL then this routine resets the mac address to the NIC's original address. **/ EFI_STATUS PxeSetStnAddr ( SNP_DRIVER *Snp, EFI_MAC_ADDRESS *NewMacAddr ) { PXE_CPB_STATION_ADDRESS *Cpb; PXE_DB_STATION_ADDRESS *Db; Cpb = Snp->Cpb; Db = Snp->Db; Snp->Cdb.OpCode = PXE_OPCODE_STATION_ADDRESS; if (NewMacAddr == NULL) { Snp->Cdb.OpFlags = PXE_OPFLAGS_STATION_ADDRESS_RESET; Snp->Cdb.CPBsize = PXE_CPBSIZE_NOT_USED; Snp->Cdb.CPBaddr = PXE_CPBADDR_NOT_USED; } else { Snp->Cdb.OpFlags = PXE_OPFLAGS_STATION_ADDRESS_WRITE; // // Supplying a new address in the CPB will make undi change the mac address to the new one. // CopyMem (&Cpb->StationAddr, NewMacAddr, Snp->Mode.HwAddressSize); Snp->Cdb.CPBsize = (UINT16) sizeof (PXE_CPB_STATION_ADDRESS); Snp->Cdb.CPBaddr = (UINT64)(UINTN) Cpb; } Snp->Cdb.DBsize = (UINT16) sizeof (PXE_DB_STATION_ADDRESS); Snp->Cdb.DBaddr = (UINT64)(UINTN) Db; Snp->Cdb.StatCode = PXE_STATCODE_INITIALIZE; Snp->Cdb.StatFlags = PXE_STATFLAGS_INITIALIZE; Snp->Cdb.IFnum = Snp->IfNum; Snp->Cdb.Control = PXE_CONTROL_LAST_CDB_IN_LIST; // // Issue UNDI command and check result. // DEBUG ((EFI_D_NET, "\nsnp->undi.station_addr() ")); (*Snp->IssueUndi32Command) ((UINT64)(UINTN) &Snp->Cdb); if (Snp->Cdb.StatCode != PXE_STATCODE_SUCCESS) { DEBUG ( (EFI_D_ERROR, "\nsnp->undi.station_addr() %xh:%xh\n", Snp->Cdb.StatFlags, Snp->Cdb.StatCode) ); // // UNDI command failed. Return UNDI status to caller. // return EFI_DEVICE_ERROR; } // // read the changed address and save it in SNP->Mode structure // PxeGetStnAddr (Snp); return EFI_SUCCESS; }