diff options
Diffstat (limited to 'Core/EM/usb/usbbus.c')
| -rw-r--r-- | Core/EM/usb/usbbus.c | 3118 |
1 files changed, 3118 insertions, 0 deletions
diff --git a/Core/EM/usb/usbbus.c b/Core/EM/usb/usbbus.c new file mode 100644 index 0000000..12002bd --- /dev/null +++ b/Core/EM/usb/usbbus.c @@ -0,0 +1,3118 @@ +//**************************************************************************** +//**************************************************************************** +//** ** +//** (C)Copyright 1985-2015, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Pkwy, Norcross, GA 30093 ** +//** ** +//** Phone (770)-246-8600 ** +//** ** +//**************************************************************************** +//**************************************************************************** + +//**************************************************************************** +// $Header: /Alaska/SOURCE/Modules/USB/ALASKA/usbbus.c 101 11/04/15 9:52p Wilsonlee $ +// +// $Revision: 101 $ +// +// $Date: 11/04/15 9:52p $ +// +//**************************************************************************** +// Revision History +// ---------------- +// $Log: /Alaska/SOURCE/Modules/USB/ALASKA/usbbus.c $ +// +// 101 11/04/15 9:52p Wilsonlee +// TAG] EIP241067 +// [Category] Improvement +// [Description] Add the device descriptor to the DEV_INFO structure. +// [Files] usb.c, usbdef.h, xhci.c, usbbus.c, AmiUsbController.h +// +// 100 5/28/15 5:01a Wilsonlee +// [TAG] EIP218997 +// [Category] Improvement +// [Description] Break the GetQueue loop if UninstallDevice is failed. +// [Files] usbbus.c, efiusbkb.c, efiusbmass.c, efiusbms.c, +// efiusbpoint.c, efiusbhid.c +// +// 99 5/26/15 10:49p Wilsonlee +// [TAG] EIP219177 +// [Category] Improvement +// [Description] Fixed static code analysis issues in Usb module. +// [Files] UsbInt13.c, ehci.c, usbbus.c +// +// 98 4/29/15 11:29p Wilsonlee +// [TAG] EIP215031 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Transcend USB 3.0 HDD is disappeared in the setup menu by +// cold boot. +// [RootCause] We only can get SerialNumber string descriptor before +// setting configuration for this device, otherwise it is failed at +// getting this descriptor and inquiry command is also failed. +// [Solution] Retry inquiry command. +// [Files] usb.c, usbmass.c, efiusbmass.c, usbbus.c, usbdef.h +// +// 97 3/20/15 7:19a Wilsonlee +// [TAG] EIP209904 +// [Category] Improvement +// [Description] Remove "ASSERT(HubNode != NULL);" because it will be to +// see a DEV_INFO from not-yet-installed hub in the some cases. +// [Files] usbbus.c +// +// 96 11/23/14 9:11p Wilsonlee +// [TAG] EIP188119 +// [Category] Improvement +// [Description] Disconnect devices and uninstall usb device related +// protocols if we call stop api for the host controllers. +// [Files] usbkbd.c, usbbus.c, uhcd.h, uhcd.c +// +// 95 10/23/14 10:07p Wilsonlee +// [TAG] EIP183572 +// [Category] Improvement +// [Description] Change tpl of UsbHcOnTimer to EFI_TPL_CALLBACK +// [Files] efiusbmass.c, usbbus.c +// +// 94 9/30/14 2:07a Wilsonlee +// [TAG] EIP183572 +// [Category] Improvement +// [Description] Change tpl of UsbHcOnTimer to EFI_TPL_CALLBACK +// [Files] efiusbmass.c, usbbus.c +// +// 93 9/29/14 11:37p Wilsonlee +// [TAG] EIP181169 +// [Category] Improvement +// [Description] Support XHCI 1.1/USB 3.1. +// [Files] xhci.c, xhci.h, usb.c, usbbus.c, usbdef.h, UsbHc.h +// +// 92 9/04/14 7:27a Wilsonlee +// [TAG] EIP179794 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Unplug RTKUSB LAN on BSU cause system hang up. +// [RootCause] We return the wrong status for UsbIoTransfers if the +// device is not present. +// [Solution] Return EFI_DEVICE_ERROR if the device is not present. +// [Files] usbbus.c +// +// 91 8/20/14 10:03p Wilsonlee +// [TAG] EIP180089 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] After updated to AMI_USB_07, we get EHCI TIMEOUT for +// specific mouse. +// [RootCause] This device may not respond getting string descriptors +// which describing manufacturer, product and the device's serial number. +// [Solution] Set the timeout value to 100 ms, the original is 20 secs. +// [Files] usbbus.c, usbdef.h +// +// 90 7/30/14 5:16a Wilsonlee +// [TAG] EIP176293 +// [Category] Improvement +// [Description] The changes are for DisplayLink USB Network driver. +// [Files] usbbus.c, usb.c +// +// 89 7/06/14 11:02p Wilsonlee +// [TAG] EIP176289 +// [Category] Improvement +// [Description] The device path for multiple LUN devices is created +// using MSG_DEVICE_LOGICAL_UNIT_DP node. +// [Files] usbbus.c +// +// 88 6/26/14 1:18a Wilsonlee +// [TAG] EIP173387 +// [Category] Improvement +// [Description] Remove TODO comments. +// [Files] usbsetup.c, xhci.c, usbmass.c, usbCCID.c, usb.c, uhci.c, +// syskbc.c, usbport.c, usbbus.c, uhcd.c, UsbBotPeim.c, PeiXhci.c, +// PeiEhci.c +// +// 87 4/30/14 5:27a Wilsonlee +// [TAG] EIP164842 +// [Category] Improvement +// [Description] Check if the devices have put into to our queue before +// we put them. +// [Files] UsbInt13.c, amiusb.c, ehci.c, ohci.c, usb.c, usbdef.h, +// usbmass.c, xhci.c, amiusbhc.c, efiusbmass.c, uhcd.c, usbbus.c, usbsb.c +// +// 86 4/29/14 8:37p Wilsonlee +// [TAG] EIP165318 +// [Category] Improvement +// [Description] Retry the DisconnectController() from a timer event +// until it succeeds if it fails. +// [Files] usbbus.c +// +// 85 4/03/14 4:40a Wilsonlee +// [TAG] EIP158119 +// [Category] Improvement +// [Description] Change parent port number of USB device paths to +// 0-based. +// [Files] usbbus.c +// +// 84 12/20/13 3:42a Wilsonlee +// [TAG] EIP147402 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] System hang at 0xA2 if plugging Seagate USB device. +// [RootCause] This device doesn't respond get descriptor command after +// we install mass storage driver. +// [Solution] We store the string descriptor when we load the langid +// table. +// [Files] usbbus.c, usbbus.h +// +// 83 11/04/13 2:58a Wilsonlee +// [TAG] EIP135009 +// [Category] Improvement +// [Description] Retry 3 times when devices stall the get descriptor +// command. +// [Files] usbbus.c +// +// 82 9/04/13 5:47a Wilsonlee +// [TAG] EIP134478 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] The devices which behind the hub don't install successfully +// in shell. +// [RootCause] Find the wrong root hub port. +// [Solution] Check DEV_INFO_VALID_STRUC and DEV_INFO_DEV_PRESENT flag +// to find the root hub port. +// [Files] usb.c, xhci.c, usbbus.c +// +// 81 8/16/13 4:19a Ryanchou +// +// 80 7/30/13 2:31a Roberthsu +// [TAG] EIP126741 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Cannot boot to uefi usb device with Sophos software. +// [RootCause] When boot into tool. Ownership to os event occur.Usb +// will disconnect device.And record this disconnect event. Then ownership +// to bios,bios will connect all device.Run legacy to efi function. Bios +// run disconnect event first.Then reconnect device.Because usb key behind +// hub. So usb key disconnect also. +// [Solution] Check device when device reconnect.If device and port +// number the same.Use the same device info. +// [Files] usb.c,usbmass.c,efiusbmass.c,uhcd.c,usbbus.c +// +// 79 4/14/13 11:01p Wilsonlee +// [TAG] EIP120345 +// [Category] Improvement +// [Description] EFI_USB_IO_PROTOCOL.UsbGetStringDescriptor() returns +// EFI_SUCCESS if String is NULL. +// [Files] usbbus.c +// +// 78 1/23/13 4:38a Wilsonlee +// [TAG] EIP109538 +// [Category] Improvement +// [Description] Fix the code check error result. +// [Files] usbkbd.c, usbCCID.c, usbbus.c, efiusbccid.c +// +// 77 1/22/13 2:39a Wilsonlee +// [TAG] EIP110305 +// [Category] Improvement +// [Description] Set the device address after we send the first +// get-device-descriptor command. +// [Files] usbmass.c, usb.c, usbdef.h, usbbus.c, efiusbmass.c, uhcd.c, +// usbport.c +// +// 76 1/11/13 4:19a Ryanchou +// [TAG] EIP102491 +// [Category] Improvement +// [Description] Synchronized with Aptio V USB module +// [Files] usbport.c, usbsb.c, ehci.c, ehci.h, ohci.c, ohci.h, uhci.h, +// usb.c, usbdef.h, usbhid.c, usbhub.c, usbkbd.c, usbkbd.h, usbmass.c. +// usbms.c, usbpoint.c, xhci.h, usb.sd, amiusbhc.c, componentname.c, +// efiusbkc.c, efiusbmass.c, uhcd.c, uhcd.h, usbbus.c, usbbus.h, usbmisc.c +// +// 75 1/07/13 12:57a Wilsonlee +// [TAG] EIP111305 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] It is failed at reloading the usb keyboard driver. +// [RootCause] The DEV_INFO_VALID_STRUC and DEV_INFO_DEV_PRESENT flag +// were cleared when the usb driver is disconnecting. +// [Solution] We should not clear the DEV_INFO_VALID_STRUC and +// DEV_INFO_DEV_PRESENT flag at USBKBDDisconnectDevice. +// [Files] usbkbd.c, usbbus.c +// +// 74 11/10/12 6:41a Ryanchou +// [TAG] EIP99431 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Cannot use the UsbIo's UsbAsyncInterruptTransfer for +// keyboard input +// [RootCause] Stopping EFI USB keyboard driver does not stop the +// endpoint polling, then application calls UsbAsyncInterruptTransfer, +// error will be returned. +// [Solution] Stops endpoint polling and release resource when +// disconnecting the device driver. And improve the +// UsbSyncInterruptTransfer. +// [Files] amiusb.c, amiusb.h, ehci.c, ohci.c, uhci.c, usb.c, +// usbCCID.c, usbdef.h, usbhub.c, usbkbd.c, usbmass.c, usbms.c, +// usbpoint.c, amiusbhc.c, efiusbhid.c, usbbus.c, usbbus.h +// +// 73 11/09/12 12:25a Wilsonlee +// [TAG] EIP104910 +// [Category] Improvement +// [Description] Raise the tpl to TPL_CALLBACK when we connect or +// disconnect controller for the usb device. +// [Files] usbbus.c +// +// 72 9/12/12 3:49a Wilsonlee +// [TAG] EIP100371 +// [Category] Improvement +// [Description] Set the tpl to TPL_APPLICATION when we connect or +// disconnect controller for the usb device. +// [Files] usbbus.c +// +// 71 9/04/12 6:15a Ryanchou +// [TAG] EIP99123 +// [Category] Improvement +// [Description] Roll back EIP79221 changes that has device +// compatibility issue. +// [Files] usbbus.c, usbbus.h +// +// 70 8/29/12 10:03p Wilsonlee +// [TAG] EIP97609 +// [Category] Improvement +// [Description] Handle the set interface request in the +// UsbIoControlTransfer. +// [Files] usbbus.c +// +// 69 6/01/12 5:44a Ryanchou +// [TAG] EIP90535 +// [Category] Improvement +// [Description] Increase the buffer size in the function +// GetUsbDescriptor. +// [Files] usbbus.c +// +// 68 5/04/12 6:43a Ryanchou +// [TAG] EIP82875 +// [Category] Improvement +// [Description] Support start/stop individual USB host to avoid +// reconnect issues. +// [Files] usbport.c, usbsb.c, amiusb.c, amiusb.h, ehci.c, ohci.c, +// uhci.c, uhci.h, usb.c, usbdef.h, xhci.c, amiusbhc.c, uhcd.c, uhcd.h, +// usbbus.c, usbmisc.c +// +// 67 5/04/12 5:33a Wilsonlee +// [TAG] EIP89307 +// [Category] Improvement +// [Description] Modify incorrect #pragma pack directive. +// [Files] amidef.h, amiusb.c, ehci.h, ohci.c, ohci.h, uhci.h, usb.c, +// usbdef.h, xhci.h, efiusbmass.c, uhcd.c, uhcd.h, usbbus.c, usbbus.h, +// UsbIo.h +// +// 66 4/05/12 7:34a Wilsonlee +// [TAG] EIP84215 +// [Category] Improvement +// [Description] Update the DataSync in LUN0 DevInfo if it is a +// multi-lun device. +// [Files] usbbus.c +// +// 65 2/16/12 8:54p Wilsonlee +// [TAG] EIP81612 +// [Category] Spec Update +// [Severity] Minor +// [Description] Add EFI_USB_SPEED_SUPER in EFI_USB2_HC_PROTOCOL +// according to UEFI 2.3.1 spec +// [Files] usb.c, usbbus.c, amiusbhc.c +// +// 64 1/31/12 12:34a Roberthsu +// [TAG] EIP79221 +// [Category] Improvement +// [Description] Add get serial number and product string descriptor. +// [Files] usbbus.c,usbbus.h +// +// 63 1/13/12 4:26a Ryanchou +// [TAG] EIP47348 +// [Category] New Feature +// [Description] Support for USB Port Reset function. +// [Files] amiusb.c, amiusb.h, amiusbhc.c, uhci.c, usb.c, usbbus.c, +// usbbus.h, usbmass.c +// +// 62 1/06/12 1:02a Rajeshms +// [TAG] EIP62737 +// [Category] Improvement +// [Description] Added USB Device number into USB mass device name +// string based on SDL Token. +// [Files] Usb.sdl, usbport.c, usbmass.c, UsbInt13.h, UsbInt13.c, +// usbbus.c, Bfiusb.equ +// +// 61 12/14/11 2:09a Ryanchou +// [TAG] EIP76397 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] ASSERT occurred when executing "reconnect -r" under shell +// [RootCause] The EIP63188 changes locate all USB controllers at one +// time, the "reconnect -r" will connect ConIn and ConOut first, so USB +// driver only locate a controller. +// [Solution] Rollback the EIP63188 changes to avoid this issue. +// [Files] amiusbhc.c, efiusbhid.c, efiusbkb.c, uhcd.c, uhcd.h, +// usbbus.c usbhid.c +// +// 60 8/05/11 7:31a Ryanchou +// [TAG] EIP66231 +// [Category] Improvement +// [Description] Remove token POINT_SUPPORT.Add token USB_DEV_POINT.Add +// check core version in point driver.Add check device descriptor to send +// get lang id command.Modify check button usage page. +// [Files] efiusbhid.c, efiusbpoint.c, usbbus.c, usbhid.c, usbpoint.c, +// usbsrc.sdl +// +// 59 7/13/11 4:10a Ryanchou +// [TAG] EIP59332 +// [Category] Improvement +// [Description] Modified the Stop function for UHCD and USBBUS to +// properly stop devices and uninstall the protocols. +// [Files] uhcd.c, uhcd.h, uhci.c, usbbus.c, UsbInt13.c, usbmisc.c +// +// 58 6/23/11 6:49a Ryanchou +// [TAG] EIP61644 +// [Category] Improvement +// [Description] Uninstall USB bus driver only DEV_INFO_DEV_BUS is set. +// [Files] usbbus.c +// +// 57 6/22/11 9:38a Ryanchou +// [TAG] EIP60640 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Logitec USB keyboard has no function in DOS. +// [RootCause] The USB keybaord may stall get configuration descriptor +// request or set address request. +// [Solution] Retry five times when the device stalls these request. +// [Files] usb.c, usbbus.c +// +// 56 6/21/11 11:57p Ryanchou +// [TAG] EIP60745 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] USB driver doesn't pass SCT 2.3 ComponentName2 protocol +// test +// [RootCause] USB driver fails to pass SCT 2.3 ComponentName2 protocol +// test - function GetControllerName conformance test, because there is no +// checking if passed handle is valid or not, or even NULL +// [Solution] Check the handle is valid in GetControllerName function. +// [Files] uhcd.c, usbbus.c +// +// 55 5/03/11 10:45a Ryanchou +// [TAG] EIP59272 +// [Category] Improvement +// [Description] According Uefi 2.1 Aptio porting document, changes made +// to install the component name protocol. +// [Files] componentname.c, componentname.h, efiusbkb.c, efiusbmass.c, +// efiusbms.c, uhcd.c, uhcd.h, usbbus.c +// +// 54 3/30/11 8:25a Ryanchou +// [TAG] EIP54126 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Sometimes system hangs at checkpoint 0xB4. +// [RootCause] The bLength field of configuration descriptor is zero. +// [Solution] Check wether bLength field is zero before paring next +// descriptor. +// [Files] usb.c, usbbus.c, usbhub.c, usbkbd.c, usbmass.c, usbms.c +// +// 53 3/16/11 5:34p Anandakrishnanl +// [TAG] EIP56121 +// [Category] Defect +// [Description] GetSupportedLanguages() returns invalid return status +// [Files] usbbus.c +// +// 52 3/04/11 1:29p Olegi +// +// 51 3/04/11 1:25p Olegi +// [TAG] EIP55172 +// [Category] Spec Update +// [Severity] Important +// [Description] Install EFI_COMPONENT_NAME_PROTOCOL if BIOS is in UEFI +// 2.0 mode and EFI_COMPONENT_NAME2_PROTOCOL if BIOS is in UEFI 2.1 mode. +// [Files] uhcd.c +// usbbus.c +// efiusbkb.c +// efiusbmass.c +// efiusbms.c +// componentname.c +// componentname.h +// +// 50 1/06/11 11:28a Olegi +// [TAG] EIP51191 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] USB mass storage device name is different for UEFI and +// Legacy device +// [RootCause] The change in InstallDevice done for 47749; it uninstalls +// UsbIo for a current device if ConnectController is unsuccessful. +// ConnectController could be unsecsessful for a number of legitemate +// reasons, one of them is the driver for this device is not present in +// the project (which is the case for a USB hub). +// [Solution] Removed UsbIo uninstallation in case of ConnectController +// failure. +// [Files] USBBUS.C +// +// 49 11/08/10 10:03a Olegi +// [TAG] EIP47749 +// [Category] Improvement +// [Description] Intermittently with Certain USB devices at PC B4h +// [Files] usbbus.c +// +// 48 10/19/10 4:22p Krishnakumarg +// +// [TAG] EIP45589 +// [Category] DEFECT +// [Severity] MAJOR +// [Symptom] USB3.0 controller did not show boot option when only one +// USB device connected. +// [RootCause] USB Bus polling time was high(one second). +// [Solution] Reduce the usb bus polling time(100ms) +// [Files] usbbus.c +// +// 47 8/18/10 4:21p Olegi +// Klockwork related fixes; EIP37978 +// +// 46 6/17/10 10:35a Olegi +// EIP39326: Runtime data moved to runtime memory region. +// +// 45 3/15/10 12:14p Olegi +// UsbBusStart: Raise the tpl level more then EFI_TPL_CALLBACK to make it +// can be called in other callback function.EIP35956 +// +// 44 2/27/10 12:00p Olegi +// +// 43 2/08/10 10:06a Olegi +// EIP33381: Implement multiple bulk endpoint in UsbIoProtocol. +// +// 42 10/30/09 5:48p Olegi +// +// 41 9/24/09 1:32p Olegi +// EIP27593: Fix in UsbIoGetStringDescriptor. +// +// 40 8/18/09 11:53a Olegi +// +// 39 12/16/08 10:51a Olegi +// Correction in the return values: 0 changed to NULL. EIP#17767. +// +// 38 10/22/08 4:25p Olegi +// QueueData1 declaration and initialization is moved to UHCD.C +// +// 37 9/05/08 4:17p Olegi +// gQueueCnnctDisc is made a part of global data structure. +// +// 36 9/02/08 10:35a Olegi +// Bugfix in UsbIoBulkTransfer. +// +// 35 6/27/08 5:57p Olegi +// - Coding standard related modifications +// - LoadName function modified to return USB mass storage device name +// from the INQUIRY command +// +// 34 6/19/08 5:01p Olegi +// +// 33 5/16/08 12:02p Olegi +// Compliance with AMI coding standard. +// +// 21 10/26/06 3:58p Olegi +// EFI_USB2_HC_PROTOCOL implementatin. +// +// 17 5/31/06 6:56p Mirk +// Core 4.5 compliant - DP Length manipulation changes. +// +// 15 3/20/06 3:37p Olegi +// Version 8.5 - x64 compatible. +// +// 12 11/03/05 6:32p Andriyn +// LUN support +// +// 9 6/15/05 1:59p Andriyn +// Comments were changed +//**************************************************************************** +//<AMI_FHDR_START> +// +// Name: UsbBus.c +// +// Description: USB Bus driver implementation +// +//<AMI_FHDR_END> +//**************************************************************************** + +//#include "Efi.h" +#include "amidef.h" +#include "usbdef.h" +#include "uhcd.h" + +#include "usbdef.h" +#include "usbbus.h" +#include "componentname.h" + +//#pragma warning(disable: 4244) + +extern EFI_GUID gEfiUsb2HcProtocolGuid; + +EFI_DRIVER_BINDING_PROTOCOL gUSBBusDriverBinding = { + UsbBusSupported, + UsbBusStart, + UsbBusStop, + USB_DRIVER_VERSION, + NULL, + NULL +}; + +extern USB_GLOBAL_DATA* gUsbData; + +TREENODE_T UsbRootRoot = {0,}; +TREENODE_T* gUsbRootRoot = &UsbRootRoot; +EFI_EVENT gEvUsbEnumTimer=0; +int gCounterUsbEnumTimer=0; +int gBustreeLock = 0; + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIo2Dev +// +// Description: This function returns a pointer to USB device from UsbIo. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +USBDEV_T* UsbIo2Dev(EFI_USB_IO_PROTOCOL* UsbIo) +{ + return (USBDEV_T*)((char*)UsbIo - (UINTN)&((USBDEV_T*)0)->io ); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: HcByIndex +// +// Description: Predicate for searching host controller node in the tree +// by bHcNumber +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +int HcByIndex(VOID* n, VOID* d) +{ + USBBUS_HC_T* HcNode = (USBBUS_HC_T*)n; + + return n && (HcNode->type == NodeHC) + && (HcNode->hc_data->bHCNumber == *(UINT8*)d ); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: HcByHandle +// +// Description: Predicate for searching host controller node in the tree +// by EFI controller handle +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +int HcByHandle(VOID* n, VOID* d) +{ + USBBUS_HC_T* HcNode = (USBBUS_HC_T*)n; + return (HcNode->type == NodeHC) && (HcNode->hc_data->Controller == *(EFI_HANDLE*)d ); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: DevByIndex +// +// Description: Predicate for searching device node in the tree +// by index of the DEV_INFO structure in the aDevInfoTable +// array of USB data +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +int DevByIndex(VOID* n, VOID* d) +{ + USBDEV_T* Dev = (USBDEV_T*)n; + return (Dev->type == NodeDevice) && (Dev->dev_info == + gUsbData->aDevInfoTable + *(UINT8*)d ); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: DevGrpByAddr +// +// Description: Predicate for searching device node in the tree +// by USB address of the device +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +int DevGrpByAddr(VOID* n, VOID* d) +{ + USBDEV_T* Dev = (USBDEV_T*)n; + return (Dev->type == NodeDevice || Dev->type == NodeGroup) && + (Dev->dev_info->bDeviceAddress == *(UINT8*)d ); +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: DevGrpByPortIf +// +// Description: Predicate for searching device node in the tree +// by parent hub port of the device, interface and LUN +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +int DevGrpByPortIf(VOID* n, VOID* d) +{ + USBDEV_T* Dev = (USBDEV_T*)n; + return (Dev->type == NodeDevice || Dev->type == NodeGroup) && + (Dev->dev_info->bHubPortNumber == ((DEV_INFO*)d)->bHubPortNumber ) && + (Dev->dev_info->bInterfaceNum == ((DEV_INFO*)d)->bInterfaceNum ) && + (Dev->dev_info->bLUN == ((DEV_INFO*)d)->bLUN ); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: DevByInfo +// +// Description: Predicate for searching device node in the tree +// by comparing pointers to the DEV_INFO structure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +int DevByInfo(VOID* n, VOID* d ) +{ + USBDEV_T* Dev = (USBDEV_T*)n; + return (Dev->type == NodeDevice) && (Dev->dev_info == (DEV_INFO*)d ); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: DevByAdrIf +// +// Description: Predicate for searching device node in the tree +// by USB address and interface number of the device +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +int DevByAdrIf(VOID* n, VOID* d) +{ + USBDEV_T* Dev = (USBDEV_T*)n; + + return ((Dev->type == NodeDevice) && + (Dev->dev_info->bDeviceAddress == ((DEV_INFO*)d)->bDeviceAddress ) && + (Dev->dev_info->bInterfaceNum == ((DEV_INFO*)d)->bInterfaceNum )&& + (Dev->dev_info->bLUN == ((DEV_INFO*)d)->bLUN)); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbDevGetGroup +// +// Description: Retrieve DEVGROUP_T that is parent of +// the specified USB device in the USB Bus tree +// +// Input: Device for which the parent is requested +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +DEVGROUP_T* UsbDevGetGroup(USBDEV_T* Dev) +{ + return (DEVGROUP_T*)Dev->node.parent->data; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: DpAddUsbSegment +// +// Description: Builds a new path appending a USB segment +// +// Output: Pointer to a callee allocated memory buffer +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_DEVICE_PATH_PROTOCOL* +DpAddUsbSegment( + EFI_DEVICE_PATH_PROTOCOL* Dp, + UINT8 bHubPortNumber, + UINT8 bInterfaceNum +) +{ + USB_DEVICE_PATH DpNewSegment = {0,}; + DpNewSegment.Header.Type = MESSAGING_DEVICE_PATH; + DpNewSegment.Header.SubType = MSG_USB_DP; + SET_NODE_LENGTH(&DpNewSegment.Header, sizeof(DpNewSegment)); + + DpNewSegment.InterfaceNumber = bInterfaceNum; + DpNewSegment.ParentPortNumber = bHubPortNumber; + return EfiAppendDevicePathNode(Dp,(EFI_DEVICE_PATH_PROTOCOL*)&DpNewSegment); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: DpAddLun +// +// Description: Builds a new path appending a LUN node +// +// +// Output: Pointer to a callee allocated memory buffer +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_DEVICE_PATH_PROTOCOL* +DpAddLun( + EFI_DEVICE_PATH_PROTOCOL* Dp, + UINT8 Lun +) +{ + LOGICAL_UNIT_DEVICE_PATH DpNewSegment = {0,}; + + DpNewSegment.Header.Type = MESSAGING_DEVICE_PATH; + DpNewSegment.Header.SubType = MSG_USB_LOGICAL_UNIT_CLASS_DP; + SET_NODE_LENGTH(&DpNewSegment.Header, sizeof(DpNewSegment)); + DpNewSegment.Lun = Lun; + return EfiAppendDevicePathNode(Dp,(EFI_DEVICE_PATH_PROTOCOL*)&DpNewSegment); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: ReadUsbDescriptor +// +// Description: This function executes a get descriptor command to the +// given USB device and endpoint +// +// Input: dev a pointer to USBDEV_T corresponding to the device +// fpBuffer Buffer to be used for the transfer +// wLength Size of the requested descriptor +// bDescType Requested descriptor type +// bDescIndex Descriptor index +// wLangIndex LangIndex +// +// Output: Pointer to memory buffer containing the descriptor +// NULL on error +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8* +ReadUsbDescriptor( USBDEV_T* Dev, + UINT8* Buffer, + UINT16 Length, + UINT8 DescType, + UINT8 DescIndex, + UINT16 LangIndex ) +{ + HC_STRUC* HcStruc = Dev->hc_info; + DEV_INFO* DevInfo = Dev->dev_info; + UINT8 GetDescIteration; + UINT16 Reg; + UINT16 Status; + + for (GetDescIteration = 0; GetDescIteration < 3; GetDescIteration++) { + Reg = (UINT16)((DescType << 8) + DescIndex); + Status = UsbSmiControlTransfer( + HcStruc, + DevInfo, + (UINT16)USB_RQ_GET_DESCRIPTOR, + (UINT16)LangIndex, + Reg, + Buffer, + Length); + if (Status) { + return Buffer; + } + if (gUsbData->dLastCommandStatusExtended & USB_TRNSFR_TIMEOUT) { + break; + } + pBS->Stall(10 * 1000); + } + + return NULL; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: GetUsbDescriptor +// +// Description: Allocates memory necessary to hold complete descriptor +// and returns the descriptor there +// +// Input: dev a pointer to USBDEV_T corresponding to the device +// type Requested descriptor type +// index Descriptor index +// langindex LangIndex +// +// Output: Pointer to memory buffer containing the descriptor +// NULL on error +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +USB_DESCRIPTOR_T* +GetUsbDescriptor( + USBDEV_T* Dev, + UINT8 Type, + UINT8 Index, + UINT16 LangIndex) +{ + UINT8 Buffer[0xFF] = {0}; + USB_DESCRIPTOR_T *Desc; + UINT8* DescBuffer; + + DescBuffer= ReadUsbDescriptor(Dev, Buffer, sizeof(Buffer), Type, Index, LangIndex); + + if ((DescBuffer == NULL) || + (((USB_DESCRIPTOR_T*)Buffer)->DescriptorType != Type) || + (((USB_DESCRIPTOR_T*)Buffer)->Length == 0)) { + return NULL; + } + gBS->AllocatePool(EfiBootServicesData, ((USB_DESCRIPTOR_T*)Buffer)->Length, &Desc); + + EfiCopyMem(Desc, Buffer, ((USB_DESCRIPTOR_T*)Buffer)->Length); + + return Desc; + +/* + EfiZeroMem(Desc, ((USB_DESCRIPTOR_T*)Buffer)->Length); + DescBuffer = ReadUsbDescriptor(Dev, (UINT8*)Desc, + ((USB_DESCRIPTOR_T*)Buffer)->Length, Type, Index, LangIndex); + //ASSERT(Desc->DescriptorType == Type); //(EIP60640-) + if (DescBuffer == NULL){ + gBS->FreePool(Desc); + return NULL; + } + // + //Decriptor Type cannot be 0, this case means that Get Descriptor cmd timed out + // + if (Desc->DescriptorType == 0) { + gBS->FreePool(Desc); + return NULL; + } else { + return Desc; + } +*/ +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: FreeConfigDesc +// +// Description: Delocates memory that was used by the descriptor +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID FreeConfigDesc( VOID* Desc ) +{ + if (Desc != 0) gBS->FreePool(Desc); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: NextDescriptor +// +// Description: Returns pointer to the next descriptor for the pack of +// USB descriptors located in continues memory segment +// - result of reading CONFIG_DESCRIPTOR +// Notes: +// Uses TotalLength of the CONFIG_DESCRIPTOR and Length +// field of each USB descriptor found inside the pack +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +int +NextDescriptor( + EFI_USB_CONFIG_DESCRIPTOR* Desc, + UINTN* Offset +) +{ + if( Desc == NULL || *Offset >= Desc->TotalLength ) return FALSE; + if( ((EFI_USB_CONFIG_DESCRIPTOR*)((char*)Desc+*Offset))->Length == 0) return FALSE; + *Offset += ((EFI_USB_CONFIG_DESCRIPTOR*)((char*)Desc+*Offset))->Length; + if( *Offset >= Desc->TotalLength ) return FALSE; + + return TRUE; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbDevConfigDesc +// +// Description: Returns a pointer to the memory containing CONFIG_DESCRIPTOR +// reported by the USB device +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_USB_CONFIG_DESCRIPTOR* +DevGroupConfigDesc( DEVGROUP_T* Grp ){ + return Grp->f_DevDesc && (Grp->active_config != -1)? + Grp->configs[Grp->active_config]:NULL; +} + +EFI_USB_CONFIG_DESCRIPTOR* +UsbDevConfigDesc( USBDEV_T* Dev ){ + return DevGroupConfigDesc( UsbDevGetGroup(Dev)); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbDevLoadAllDescritors +// +// Description: Reads DEVICE and CONFIG descriptors for each +// configuration available in the device. Marks +// the index of the buffer containing CONFIG descriptor +// for active configurations currently selected in +// USB device +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UsbDevLoadAllDescritors( + DEVGROUP_T* Dev +) +{ + UINT8 i; + EFI_STATUS Status; + + //ASSERT( Dev->f_DevDesc == 0 ); + Dev->configs = NULL; + // + // Device descriptor + // + gBS->CopyMem((UINT8*)&Dev->dev_desc, (UINT8*)&Dev->dev_info->DevDesc, sizeof(Dev->dev_desc)); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USB Bus: dev descr: "); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "cls:%x;subcls:%x;proto:%x;vndr:%x;id:%x\n", + Dev->dev_desc.DeviceClass, + Dev->dev_desc.DeviceSubClass, + Dev->dev_desc.DeviceProtocol, + Dev->dev_desc.IdVendor, + Dev->dev_desc.IdProduct); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "\t\tstr1:%x,str2:%x,str3:%x\n", + Dev->dev_desc.StrManufacturer, + Dev->dev_desc.StrProduct, + Dev->dev_desc.StrSerialNumber ); + + Dev->f_DevDesc = TRUE; + + // + // Config descriptor + // + Dev->config_count = Dev->dev_desc.NumConfigurations; +// dev->configs = (EFI_USB_CONFIG_DESCRIPTOR**)MallocZ(dev->config_count*sizeof(EFI_USB_CONFIG_DESCRIPTOR*)); + Status = gBS->AllocatePool (EfiBootServicesData, + Dev->config_count*sizeof(EFI_USB_CONFIG_DESCRIPTOR*), (VOID *)&Dev->configs); + ASSERT_EFI_ERROR(Status); + EfiZeroMem(Dev->configs, Dev->config_count*sizeof(EFI_USB_CONFIG_DESCRIPTOR*)); + + Dev->active_config = -1; + for(i=0; i<Dev->config_count; ++i){ + //read each configuration + //first failed read will terminate loop + + //Optimization: allloc&read MAX size first + // and read second time only if total length is greater + //Read 1 : get total length + EFI_USB_CONFIG_DESCRIPTOR tmp = {0,0,}; + UINT8* p = ReadUsbDescriptor((USBDEV_T*)Dev,(UINT8*)&tmp, + sizeof(tmp),DESC_TYPE_CONFIG,i, 0 ); + //ASSERT(tmp.DescriptorType == DESC_TYPE_CONFIG); + //ASSERT(tmp.TotalLength >= sizeof(tmp)); + // + //Addressing timeouts caused by device errors - empty DESC structure will be returned + // + if( (p == NULL) || (tmp.DescriptorType == 0) ) { + break; + } + + //Read 2: Actual content +// dev->configs[i] = MallocZ(tmp.TotalLength); + Status = gBS->AllocatePool (EfiBootServicesData, tmp.TotalLength, &Dev->configs[i]); + ASSERT_EFI_ERROR(Status); + EfiZeroMem(Dev->configs[i], tmp.TotalLength); + + p = ReadUsbDescriptor((USBDEV_T*)Dev, (UINT8*)Dev->configs[i], + tmp.TotalLength, DESC_TYPE_CONFIG, i, 0); + //ASSERT(Dev->configs[i]->DescriptorType == DESC_TYPE_CONFIG); //(EIP60640-) + // + //Addressing timeouts caused by device errors - empty DESC structure will be returned + // + if( (p == NULL) || (Dev->configs[i]->DescriptorType == 0) ){ + gBS->FreePool(Dev->configs[i]); + Dev->configs[i] = 0; + break; + } + //config Desc is here + + //Active Config + if( Dev->configs[i]->ConfigurationValue == Dev->dev_info->bConfigNum ){ + Dev->active_config = i; + } + } +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbDevLoadEndpoints +// +// Description: Locates information about each endpoint inside the +// descriptors pack loaded with CONFIG descriptor +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UsbDevLoadEndpoints( + USBDEV_T* Dev +) +{ + EFI_USB_INTERFACE_DESCRIPTOR *TmpDesc; + EFI_USB_ENDPOINT_DESCRIPTOR *EpDesc; + EFI_USB_CONFIG_DESCRIPTOR *CfgDesc; + int j; + UINTN Offset; + DEVGROUP_T *Grp = UsbDevGetGroup(Dev); + + Dev->first_endpoint = Grp->endpoint_count; + Dev->end_endpoint = Grp->endpoint_count; + + CfgDesc = UsbDevConfigDesc(Dev); + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "\tScanning config desc: "); + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "%x(type:%x;len:%x;val:%x;total:%x)\n", + CfgDesc,CfgDesc->DescriptorType,CfgDesc->Length, + CfgDesc->ConfigurationValue,CfgDesc->TotalLength ); + + // + // Search interface descriptor + // + for(Offset = 0; NextDescriptor(CfgDesc,&Offset);) + { + TmpDesc = (EFI_USB_INTERFACE_DESCRIPTOR *)((char*)CfgDesc+Offset); + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "\t\tdesc: %x(type:%x;len:%x;if:%x;aif:%x)\n", + TmpDesc,TmpDesc->DescriptorType,TmpDesc->Length, + TmpDesc->InterfaceNumber, TmpDesc->AlternateSetting ); + if( TmpDesc->DescriptorType == DESC_TYPE_INTERFACE && + TmpDesc->InterfaceNumber== Dev->dev_info->bInterfaceNum && + TmpDesc->AlternateSetting == Dev->dev_info->bAltSettingNum) + { + //found + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "\t...IF found.\n" ); + + Dev->descIF= TmpDesc; + + ASSERT(TmpDesc->NumEndpoints < COUNTOF(Grp->endpoints)); + for(j=0;j<TmpDesc->NumEndpoints && NextDescriptor(CfgDesc,&Offset);){ + EpDesc = (EFI_USB_ENDPOINT_DESCRIPTOR*)((char*)CfgDesc+Offset); + if( EpDesc->DescriptorType == DESC_TYPE_ENDPOINT ){ + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "\t\tend-point desc: %x", EpDesc); + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "(index:%x;type:%x;len:%x;addr:%x;pcksz:%x;attr:%x,t:%x)\n", + Grp->endpoint_count, + EpDesc->DescriptorType,EpDesc->Length, + EpDesc->EndpointAddress, EpDesc->MaxPacketSize, + EpDesc->Attributes, EpDesc->Interval); + Grp->endpoints[Grp->endpoint_count].address = EpDesc->EndpointAddress; + Grp->endpoints[Grp->endpoint_count++].desc = EpDesc; + Grp->a2endpoint[COMPRESS_EP_ADR(EpDesc->EndpointAddress)] = EpDesc; + j++; + } + if( EpDesc->DescriptorType == DESC_TYPE_INTERFACE ){ + //Oops, We stepped into another interface + break; + } + } + Dev->end_endpoint = Grp->endpoint_count; + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "\t\tinterface end-points: "); + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "first:%x; end:%x, grp.endpoint_count:%x\n", + Dev->first_endpoint, Dev->end_endpoint, Grp->endpoint_count); + return; + } + } + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "\t...IF not found.\n" ); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: GetMaxPacket +// +// Description: Retrieves information about a max packet size +// for the specified endpoint of the device +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 +GetMaxPacket( + UINT8 Endpoint, + USBDEV_T* Dev +) +{ + DEVGROUP_T *Grp = UsbDevGetGroup(Dev); + EFI_USB_ENDPOINT_DESCRIPTOR* Desc = Grp->a2endpoint[COMPRESS_EP_ADR(Endpoint)]; + if (Desc == 0) return 0; + return Desc->MaxPacketSize; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: GetEndpointDesc +// +// Description: Retrieves information about a max packet size +// for the specified endpoint of the device +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_USB_ENDPOINT_DESCRIPTOR* +GetEndpointDesc( + UINT8 Endpoint, + USBDEV_T* Dev +) +{ + DEVGROUP_T *Grp = UsbDevGetGroup(Dev); + EFI_USB_ENDPOINT_DESCRIPTOR* Desc; + + if (((Endpoint & 0x7F)==0) || ((Endpoint & 0x7F) > 0xF)) + return NULL; + Desc = Grp->a2endpoint[COMPRESS_EP_ADR(Endpoint)]; + + return Desc; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoControlTransfer +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoControlTransfer( + IN EFI_USB_IO_PROTOCOL *UsbIo, + IN EFI_USB_DEVICE_REQUEST *Request, + IN EFI_USB_DATA_DIRECTION Direction, + IN UINT32 Timeout, + IN OUT VOID *Data, + IN UINTN DataLength, + OUT UINT32 *UsbStatus +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + EFI_STATUS Status; + + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + + if( Request == NULL || UsbStatus == NULL ) return EFI_INVALID_PARAMETER; + if (Direction > EfiUsbNoData) return EFI_INVALID_PARAMETER; + + if (!(Dev->dev_info->Flag & DEV_INFO_DEV_PRESENT)) { + return EFI_DEVICE_ERROR; + } + + Status = Dev->hc->ControlTransfer( + Dev->hc, Dev->dev_info->bDeviceAddress, GetSpeed(Dev), + (UINTN)Dev->dev_info->wEndp0MaxPacket, //(EIP81612) + Request, Direction, Data, &DataLength, Timeout, NULL, UsbStatus); + if (EFI_ERROR(Status)) { + return Status; + } + if ((Request->Request == (USB_RQ_SET_INTERFACE >> 8)) && + (Request->RequestType == (USB_RQ_SET_INTERFACE & 0x0F) ) && + (Request->Index == Dev->dev_info->bInterfaceNum)) { + Dev->dev_info->bAltSettingNum = (UINT8)Request->Value; + UsbDevLoadEndpoints(Dev); + } + return Status; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoBulkTransfer +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoBulkTransfer( + IN EFI_USB_IO_PROTOCOL *UsbIo, + IN UINT8 Endpoint, + IN OUT VOID *Data, + IN OUT UINTN *DataLength, + IN UINTN Timeout, + OUT UINT32 *UsbStatus +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + UINT16 MaxPacket; + UINT8 ToggleBit = (Endpoint & 0xF) - 1; + //(EIP84215)> + UINT16 *wDataSync; + UINT8 Toggle; + EFI_STATUS Status; + EFI_USB_ENDPOINT_DESCRIPTOR* EpDesc = GetEndpointDesc(Endpoint, Dev); + DEV_INFO *DevInfoToDataSync; + //<(EIP84215) + if (((Endpoint & 0x7F)==0) || ((Endpoint & 0x7F) > 0xF)) + return EFI_INVALID_PARAMETER; + +// if ( Dev->dev_info->bBulkInEndpoint && +// ((Endpoint & 0x80) && ((Endpoint & 0x7F) != Dev->dev_info->bBulkInEndpoint)) ) { +// return EFI_INVALID_PARAMETER; +// } + +// if ( Dev->dev_info->bBulkOutEndpoint && +// (!(Endpoint & 0x80) && (Endpoint != Dev->dev_info->bBulkOutEndpoint)) ) { +// return EFI_INVALID_PARAMETER; +// } + + if ( Data == NULL || DataLength == NULL || UsbStatus == NULL ) { + return EFI_INVALID_PARAMETER; + } + + if( EpDesc == NULL ) { + return EFI_INVALID_PARAMETER; + } + MaxPacket = EpDesc->MaxPacketSize; + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + + if( UsbStatus == NULL || MaxPacket == 0) { + return EFI_INVALID_PARAMETER; + } + + if ( (EpDesc->Attributes & EP_DESC_FLAG_TYPE_BITS) != EP_DESC_FLAG_TYPE_BULK ) { + return EFI_INVALID_PARAMETER; + } + + if (!(Dev->dev_info->Flag & DEV_INFO_DEV_PRESENT)) { + return EFI_DEVICE_ERROR; + } + //(EIP84215+)> + if (Dev->dev_info->fpLUN0DevInfoPtr) { + DevInfoToDataSync = Dev->dev_info->fpLUN0DevInfoPtr; + }else { + DevInfoToDataSync = Dev->dev_info; + } + + if (Endpoint & 0x80) { + wDataSync = &DevInfoToDataSync->wDataInSync; + }else { + wDataSync = &DevInfoToDataSync->wDataOutSync; + } + //<(EIP84215+) + GETBIT( *wDataSync, Toggle, ToggleBit ); + + Status = Dev->hc->BulkTransfer( + Dev->hc, Dev->dev_info->bDeviceAddress, Endpoint, GetSpeed(Dev), + MaxPacket, 1, &Data, DataLength, &Toggle, Timeout, NULL, UsbStatus); + + SETBIT( *wDataSync, Toggle, ToggleBit ); + + return Status; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoIsochronousTransfer +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoAsyncInterruptTransfer( + IN EFI_USB_IO_PROTOCOL *UsbIo, + IN UINT8 Endpoint, + IN BOOLEAN IsNewTransfer, + IN UINTN PollingInterval, + IN UINTN DataLength, + IN EFI_ASYNC_USB_TRANSFER_CALLBACK InterruptCallback, + IN VOID *Context +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + UINT8 Toggle; + UINT8 ToggleBit = (Endpoint & 0xF) - 1; + //(EIP84215)> + UINT16 *wDataSync; + EFI_STATUS Status; + EFI_USB_ENDPOINT_DESCRIPTOR* EpDesc = GetEndpointDesc(Endpoint, Dev); + DEV_INFO *DevInfoToDataSync; + //<(EIP84215) + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + + // Check whether Endpoint is valid + if(EpDesc == NULL) { + return EFI_INVALID_PARAMETER; + } + + if ((EpDesc->Attributes & EP_DESC_FLAG_TYPE_BITS) != EP_DESC_FLAG_TYPE_INT ) { + return EFI_INVALID_PARAMETER; + } + + if (IsNewTransfer && (PollingInterval < 1 || PollingInterval > 255)) { + return EFI_INVALID_PARAMETER; + } + + if (IsNewTransfer) { + if (!(Dev->dev_info->Flag & DEV_INFO_DEV_PRESENT)) { + return EFI_DEVICE_ERROR; + } + } + //(EIP84215+)> + if (Dev->dev_info->fpLUN0DevInfoPtr) { + DevInfoToDataSync = Dev->dev_info->fpLUN0DevInfoPtr; + }else { + DevInfoToDataSync = Dev->dev_info; + } + + if (Endpoint & 0x80) { + wDataSync = &DevInfoToDataSync->wDataInSync; + }else { + wDataSync = &DevInfoToDataSync->wDataOutSync; + } + //<(EIP84215+) + GETBIT( *wDataSync, Toggle, ToggleBit ); + + Status = Dev->hc->AsyncInterruptTransfer( + Dev->hc, Dev->dev_info->bDeviceAddress, Endpoint, + GetSpeed(Dev), EpDesc->MaxPacketSize, IsNewTransfer, + &Toggle, PollingInterval, DataLength, NULL, + InterruptCallback, Context ); + + SETBIT( *wDataSync, Toggle, ToggleBit ); + + if (!EFI_ERROR(Status)) { + Dev->async_endpoint = IsNewTransfer ? Endpoint : 0; + } + return Status; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoSyncInterruptTransfer +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoSyncInterruptTransfer( + IN EFI_USB_IO_PROTOCOL *UsbIo, + IN UINT8 Endpoint, + IN OUT VOID *Data, + IN OUT UINTN *DataLength, + IN UINTN Timeout, + OUT UINT32 *UsbStatus +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + UINT8 Toggle; + UINT8 ToggleBit = (Endpoint & 0xF) - 1; + //(EIP84215)> + UINT16 *wDataSync; + EFI_STATUS Status; + EFI_USB_ENDPOINT_DESCRIPTOR* EpDesc = GetEndpointDesc(Endpoint, Dev); + DEV_INFO *DevInfoToDataSync; + //<(EIP84215) + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + + // Check whether Endpoint is valid + if( EpDesc == NULL ) { + return EFI_INVALID_PARAMETER; + } + + if ( (EpDesc->Attributes & EP_DESC_FLAG_TYPE_BITS) != EP_DESC_FLAG_TYPE_INT ) { + return EFI_INVALID_PARAMETER; + } + + if ( Data == NULL || DataLength == NULL || UsbStatus == NULL ) { + return EFI_INVALID_PARAMETER; + } + + if (!(Dev->dev_info->Flag & DEV_INFO_DEV_PRESENT)) { + return EFI_DEVICE_ERROR; + } + //(EIP84215+)> + if (Dev->dev_info->fpLUN0DevInfoPtr) { + DevInfoToDataSync = Dev->dev_info->fpLUN0DevInfoPtr; + }else { + DevInfoToDataSync = Dev->dev_info; + } + + if (Endpoint & 0x80) { + wDataSync = &DevInfoToDataSync->wDataInSync; + }else { + wDataSync = &DevInfoToDataSync->wDataOutSync; + } + //<(EIP84215+) + GETBIT( *wDataSync, Toggle, ToggleBit ); + Status = Dev->hc->SyncInterruptTransfer( + Dev->hc, Dev->dev_info->bDeviceAddress, Endpoint, + GetSpeed(Dev), EpDesc->MaxPacketSize, + Data, DataLength, &Toggle, Timeout, NULL, UsbStatus); + SETBIT( *wDataSync, Toggle, ToggleBit ); + + return Status; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoIsochronousTransfer +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoIsochronousTransfer( + IN EFI_USB_IO_PROTOCOL *UsbIo, + IN UINT8 Endpoint, + IN OUT VOID *Data, + IN UINTN DataLength, + OUT UINT32 *Status +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + UINT16 MaxPacket;// = GetMaxPacket(Endpoint,dev); + EFI_USB_ENDPOINT_DESCRIPTOR* EpDesc = GetEndpointDesc(Endpoint, Dev); + + if (EpDesc == NULL) { + return EFI_INVALID_PARAMETER; + } + + MaxPacket = EpDesc->MaxPacketSize; + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + + if (Status == NULL || MaxPacket == 0) { + return EFI_INVALID_PARAMETER; + } + + if ((EpDesc->Attributes & EP_DESC_FLAG_TYPE_BITS) != EP_DESC_FLAG_TYPE_ISOC) { + return EFI_INVALID_PARAMETER; + } + + if (!(Dev->dev_info->Flag & DEV_INFO_DEV_PRESENT)) { + return EFI_DEVICE_ERROR; + } + + return Dev->hc->IsochronousTransfer( + Dev->hc, Dev->dev_info->bDeviceAddress, Endpoint, GetSpeed(Dev), + MaxPacket, 1, &Data, DataLength, NULL, Status); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoAsyncIsochronousTransfer +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoAsyncIsochronousTransfer( + IN EFI_USB_IO_PROTOCOL *UsbIo, + IN UINT8 Endpoint, + IN OUT VOID *Data, + IN UINTN DataLength, + IN EFI_ASYNC_USB_TRANSFER_CALLBACK IsochronousCallback, + IN VOID *Context +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + UINT16 MaxPacket;// = GetMaxPacket(Endpoint, Dev); + EFI_USB_ENDPOINT_DESCRIPTOR* EpDesc = GetEndpointDesc(Endpoint, Dev); + + if (EpDesc == NULL) { + return EFI_INVALID_PARAMETER; + } + MaxPacket = EpDesc->MaxPacketSize; + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + if ((EpDesc->Attributes & EP_DESC_FLAG_TYPE_BITS) != EP_DESC_FLAG_TYPE_ISOC) { + return EFI_INVALID_PARAMETER; + } + + if (!(Dev->dev_info->Flag & DEV_INFO_DEV_PRESENT)) { + return EFI_DEVICE_ERROR; + } + + return Dev->hc->AsyncIsochronousTransfer( + Dev->hc, Dev->dev_info->bDeviceAddress, Endpoint, GetSpeed(Dev), + MaxPacket, 1, &Data, DataLength, NULL, IsochronousCallback, Context ); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoPortReset +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoPortReset( + IN EFI_USB_IO_PROTOCOL *UsbIo +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + DEVGROUP_T* Grp = UsbDevGetGroup(Dev); + UINT8 Status; + UINT8 i; + + if (Dev->dev_info->bDeviceType == BIOS_DEV_TYPE_HUB) + return EFI_INVALID_PARAMETER; + + Status = UsbResetAndReconfigDev(Dev->hc_info, Dev->dev_info); + if (Status != USB_SUCCESS) { + return EFI_DEVICE_ERROR; + } + + if( UsbSmiGetDescriptor(Dev->hc_info, Dev->dev_info, (UINT8*)&Grp->dev_desc, + sizeof(Grp->dev_desc), DESC_TYPE_DEVICE, 0) == 0 ){ + return EFI_DEVICE_ERROR; + } + + for(i = 0; i < Grp->dev_desc.NumConfigurations; i++) { + if (ReadUsbDescriptor(Dev, (UINT8*)Grp->configs[i], + Grp->configs[i]->TotalLength, DESC_TYPE_CONFIG, i, 0) == 0) { + return EFI_DEVICE_ERROR; + } + } + + return EFI_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoGetDeviceDescriptor +// +// Description: Retrieves the USB Device Descriptor. +// +// Input: +// UsbIo A pointer to the EFI_USB_IO_PROTOCOL instance. Type +// EFI_USB_IO_PROTOCOL is defined in Section 14.2.5. +// Desc A pointer to the caller allocated USB Device Descriptor. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoGetDeviceDescriptor( + IN EFI_USB_IO_PROTOCOL *UsbIo, + OUT EFI_USB_DEVICE_DESCRIPTOR *Desc +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + DEVGROUP_T* Grp = UsbDevGetGroup(Dev); + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + if( Desc == NULL ) return EFI_INVALID_PARAMETER; + + if( Grp->f_DevDesc ){ + *Desc = Grp->dev_desc; + return EFI_SUCCESS; + } else + return EFI_NOT_FOUND; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoGetConfigDescriptor +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoGetConfigDescriptor( + IN EFI_USB_IO_PROTOCOL *UsbIo, + OUT EFI_USB_CONFIG_DESCRIPTOR *Desc +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + DEVGROUP_T* Grp = UsbDevGetGroup(Dev); + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + if( Desc == NULL ) return EFI_INVALID_PARAMETER; + + if( Grp->configs && Grp->active_config != -1 && + Grp->configs[Grp->active_config] ){ + *Desc = *Grp->configs[Grp->active_config]; + return EFI_SUCCESS; + } else + return EFI_NOT_FOUND; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoGetInterfaceDescriptor +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoGetInterfaceDescriptor( + IN EFI_USB_IO_PROTOCOL *UsbIo, + OUT EFI_USB_INTERFACE_DESCRIPTOR *Desc +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + if (Desc == NULL) return EFI_INVALID_PARAMETER; + + if (Dev->descIF == NULL) return EFI_NOT_FOUND; + + *Desc = *Dev->descIF; + + return EFI_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoGetEndpointDescriptor +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoGetEndpointDescriptor( + IN EFI_USB_IO_PROTOCOL *UsbIo, + IN UINT8 EndpointIndex, + OUT EFI_USB_ENDPOINT_DESCRIPTOR *Desc +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + DEVGROUP_T *Grp; + EFI_USB_ENDPOINT_DESCRIPTOR* DescCopy; + + if( Desc == NULL || EndpointIndex >= 0x10) return EFI_INVALID_PARAMETER; + + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + + USB_DEBUG( 3, "Get Endpoint desc: devaddr: 0x%x; Endpoint: 0x%x\n", + Dev->dev_info->bDeviceAddress, EndpointIndex ); + USB_DEBUG( 3, "\tfirst Endpoint: 0x%x; last Endpoint: 0x%x\n", + Dev->first_endpoint, Dev->end_endpoint-1 ); + + if( Dev->first_endpoint + EndpointIndex >= Dev->end_endpoint ) + return EFI_NOT_FOUND; + + ASSERT( Dev->first_endpoint + EndpointIndex < 0x20 ); + + Grp = UsbDevGetGroup(Dev); + DescCopy = Grp->endpoints[Dev->first_endpoint + EndpointIndex].desc; + + ASSERT( DescCopy ); + + if (DescCopy==NULL) return EFI_NOT_FOUND; + + USB_DEBUG( 3, "\tendp addr: 0x%x; attr: 0x%x; MaxPacket: 0x%x\n", + DescCopy->EndpointAddress, + DescCopy->Attributes, DescCopy->MaxPacketSize ); + + *Desc = *DescCopy; + + return EFI_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoGetStringDescriptor +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS +UsbIoGetStringDescriptor( + IN EFI_USB_IO_PROTOCOL *UsbIo, + IN UINT16 LangId, + IN UINT8 StringId, + OUT CHAR16 **String +) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + EFI_USB_STRING_DESCRIPTOR* StrDesc = NULL; + UINT16 Index; + UINT16 *LangIdTable; + DEVGROUP_T* Grp; + EFI_STATUS Status = EFI_NOT_FOUND; + + ASSERT(Dev->dev_info); + ASSERT(Dev->hc); + + Grp = UsbDevGetGroup(Dev); + + if (StringId == 0 || Grp->lang_table == NULL) { + //reserved ids: stringid==0 => langid table descripto; + return Status; + } + // search langid_table + LangIdTable = Grp->lang_table->langID; + for (Index = 0; Index < Grp->lang_table->len ; Index++) { + if (LangId == LangIdTable[Index]) { + break; + } + } + + if (Index == Grp->lang_table->len) { + return Status; + } + + if (LangId == USB_US_LAND_ID) { + if (StringId == Grp->dev_desc.StrSerialNumber) { + StrDesc = Grp->SerialNumberStrDesc; + } else if (StringId == Grp->dev_desc.StrProduct) { + StrDesc = Grp->ProductStrDesc; + } else if (StringId == Grp->dev_desc.StrManufacturer) { + StrDesc = Grp->ManufacturerStrDesc; + } + } + // + // Get string descriptor: variable size + // + if (StrDesc == NULL) { + StrDesc = (EFI_USB_STRING_DESCRIPTOR*)GetUsbDescriptor(Dev, DESC_TYPE_STRING, + StringId, LangId); + } + + if (StrDesc == NULL) { + return Status; + } + + if (StrDesc->Length > 2 && StrDesc->DescriptorType == DESC_TYPE_STRING) { + // + // Allocate memory for string & copy + // + if (String != NULL) { + gBS->AllocatePool(EfiBootServicesData, StrDesc->Length, String); + EfiZeroMem(*String, StrDesc->Length); + EfiCopyMem(*String, StrDesc->String, StrDesc->Length -2); + } + Status = EFI_SUCCESS; + } + if ((StrDesc != Grp->SerialNumberStrDesc) && (StrDesc != Grp->ProductStrDesc) && + (StrDesc != Grp->ManufacturerStrDesc)) { + gBS->FreePool(StrDesc); + } + return Status; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbIoGetSupportedLanguages +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbIoGetSupportedLanguages( + IN EFI_USB_IO_PROTOCOL *UsbIo, + OUT UINT16 **LangIdTable, + OUT UINT16 *TableSize ) +{ + USBDEV_T* Dev = UsbIo2Dev(UsbIo); + DEVGROUP_T* Grp; + + ASSERT( Dev->dev_info ); + ASSERT( Dev->hc ); + Grp = UsbDevGetGroup(Dev); + if (LangIdTable == NULL || TableSize == NULL) { + return EFI_SUCCESS; + } + if (Grp->lang_table == NULL) { + *LangIdTable = 0; + *TableSize = 0; + } else { + *LangIdTable = Grp->lang_table->langID; + *TableSize = Grp->lang_table->len*2; + } + return EFI_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: LoadName +// +// Description: loads STRING descriptor that corresponds to +// the name of the USB device +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +CHAR16* +LoadName( + USBDEV_T* Dev +) +{ + EFI_USB_INTERFACE_DESCRIPTOR DescIf = {0,}; + EFI_USB_DEVICE_DESCRIPTOR DescDev = {0,}; + DEVGROUP_T* Grp = UsbDevGetGroup(Dev); + CHAR16* StrIf = 0; + CHAR16* StrProduct = 0; +// CHAR16* StrManufact=0; + CHAR16 Lang; + CHAR16 *MassStorageName; + UINT8 *p; + UINT8 i; + + for (i = 0; i < 64; i++) { + if (Dev->dev_info->DevNameString[i] != 0) { + break; + } + } + + if (i != 64) { + gBS->AllocatePool (EfiBootServicesData, 128, &MassStorageName); + EfiZeroMem(MassStorageName, 128); + for (p = (UINT8*)&Dev->dev_info->DevNameString, i=0; i<64; i++) { + if (p[i] == 0) break; + MassStorageName[i] = (CHAR16)p[i]; + } + return MassStorageName; + } + + if( Grp->lang_table == 0 || Grp->lang_table->len == 0 ) return 0; + + Lang = Grp->lang_table->langID[0]; + + UsbIoGetInterfaceDescriptor(&Dev->io,&DescIf); + if( DescIf.Interface && !EFI_ERROR( + UsbIoGetStringDescriptor(&Dev->io, Lang, + DescIf.Interface, &StrIf ))) + return StrIf; + + UsbIoGetDeviceDescriptor(&Dev->io, &DescDev); + if( DescDev.StrProduct && !EFI_ERROR( + UsbIoGetStringDescriptor(&Dev->io, Lang, + DescDev.StrProduct, &StrProduct ))) + return StrProduct; + + return NULL; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: InstallDevice +// +// Description: Adds a device to the tree; creates an EFI handle for the +// usb device; installs USB_IO and DEVICEPATH protocols +// on a new device handle; connects a new device to +// EFI device drivers +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +TREENODE_T* +UsbDevHubNode( + TREENODE_T *HcNode, + DEV_INFO *DevInfo +) +{ +// int i; + TREENODE_T *HubNode=0; + TREENODE_T *HubGrpNode; + + HubGrpNode = TreeSearchDeep(HcNode->child, DevGrpByAddr, &DevInfo->bHubDeviceNumber ); + if (HubGrpNode != NULL){ + HubNode = HubGrpNode->child; + ASSERT(HubNode); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: parent Hub found: %x\n", HubNode ); + return HubNode; + } +/* + for( i=0;i<COUNTOF(gUsbData->aDevInfoTable) && (HubNode==0);i++){ + if((gUsbData->aDevInfoTable[i].Flag & (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT)) + != (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT)) + continue; + if( gUsbData->aDevInfoTable[i].bHCNumber == DevInfo->bHCNumber && + gUsbData->aDevInfoTable[i].bDeviceAddress == DevInfo->bHubDeviceNumber ) + { + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: UsbDevHubNode: valid hub info [%d]: %x\n",i, gUsbData->aDevInfoTable +i ); + InstallDevice( gUsbData->aDevInfoTable +i ); + HubNode = TreeSearchDeep(HcNode->child, DevByInfo, gUsbData->aDevInfoTable +i ); + ASSERT(HubNode); + } + } +*/ + return HubNode; +} + +VOID InstallDevice(DEV_INFO* DevInfo) +{ + TREENODE_T* HcNode; + TREENODE_T* HubNode; + TREENODE_T* ParentNode; + USBDEV_T* Dev; + DEVGROUP_T* Grp; + EFI_STATUS Status; + EFI_TPL OldTpl; + UINT16 Index; + UINT16 *LangId; + UINT16 OrgTimeOutValue; + + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: InstallDevice "); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "(hc:%x,hub:%x,port:%x,addr:%x,if:%x,aif:%x,lun:%x)\n", + DevInfo->bHCNumber, DevInfo->bHubDeviceNumber, DevInfo->bHubPortNumber, DevInfo->bDeviceAddress, + DevInfo->bInterfaceNum, DevInfo->bAltSettingNum, DevInfo->bLUN ); + + // Find HC node in tree + HcNode = TreeSearchSibling(gUsbRootRoot->child, HcByIndex, &DevInfo->bHCNumber ); + + // Do not assert here: it's fine to see a DEV_INFO from not-yet-installed HC + if( HcNode == NULL ) return; + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: HC node found: %x\n", HcNode ); + + // Find a hub node in tree + if( DevInfo->bHubDeviceNumber & BIT7){ // hub is a root HC + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: Connecting to root Hub\n", DevInfo->bHCNumber ); + ASSERT( (DevInfo->bHubDeviceNumber & ~BIT7 )== DevInfo->bHCNumber ); + HubNode = HcNode; + } else { // hub is usb hub device + HubNode = UsbDevHubNode(HcNode, DevInfo); + // Do not assert here: it may be to see a DEV_INFO from not-yet-installed hub. + //ASSERT(HubNode != NULL); + if (HubNode == NULL) return; + } + + ParentNode = NULL; + ParentNode = TreeSearchSibling(HubNode->child, + DevGrpByAddr, &DevInfo->bDeviceAddress ); + + if( ParentNode == NULL ){ + // Create group + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: group created\n" ); + Status = gBS->AllocatePool (EfiBootServicesData, sizeof(DEVGROUP_T), &Grp); + ASSERT_EFI_ERROR(Status); + EfiZeroMem(Grp, sizeof(DEVGROUP_T)); + + Grp->dev_info = DevInfo; + Grp->hc = ((USBBUS_HC_T*)HcNode->data)->hc; + Grp->hc_info = ((USBBUS_HC_T*)HcNode->data)->hc_data; + Grp->f_DevDesc = FALSE; + Grp->configs = NULL; + Grp->config_count = 0; + Grp->ManufacturerStrDesc = NULL; + Grp->ProductStrDesc = NULL; + Grp->SerialNumberStrDesc = NULL; + Grp->type = NodeGroup; + Grp->active_config = 0; + UsbDevLoadAllDescritors(Grp); + // + // Check at least for Device Descriptor present before proceeding + // + if(Grp->f_DevDesc == FALSE) { + // + //When no Device Descriptor present quit installing the device + // + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: dev install aborted - no device descriptor\n"); + return; + } + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: descriptors loaded\n" ); + + //(EIP66231+)> + if ((Grp->dev_desc.StrManufacturer != 0) || (Grp->dev_desc.StrProduct != 0) || + (Grp->dev_desc.StrSerialNumber != 0)) { + // Load langid table + Grp->lang_table = (lang_table_t*)GetUsbDescriptor((USBDEV_T*)Grp, DESC_TYPE_STRING, 0, 0); + if (Grp->lang_table && Grp->lang_table->len != 0) { + Grp->lang_table->len = (Grp->lang_table->len -2) / sizeof(UINT16); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: LangID table loaded\n" ); + + LangId = Grp->lang_table->langID; + + for (Index = 0; Index < Grp->lang_table->len; Index++) { + if (LangId[Index] == USB_US_LAND_ID) { + break; + } + } + + if (Index != Grp->lang_table->len) { + // Some devices may not respond getting string descriptors + // whcih describing manufacturer, product set the timeout value to 100 ms. + OrgTimeOutValue = gUsbData->wTimeOutValue; + gUsbData->wTimeOutValue = USB_GET_STRING_DESC_TIMEOUT_MS; + if (Grp->dev_desc.StrManufacturer != 0) { + Grp->ManufacturerStrDesc = + (EFI_USB_STRING_DESCRIPTOR*)GetUsbDescriptor( + (USBDEV_T*)Grp, DESC_TYPE_STRING, + Grp->dev_desc.StrManufacturer, USB_US_LAND_ID); + } + if (Grp->dev_desc.StrProduct != 0) { + Grp->ProductStrDesc = + (EFI_USB_STRING_DESCRIPTOR*)GetUsbDescriptor( + (USBDEV_T*)Grp, DESC_TYPE_STRING, + Grp->dev_desc.StrProduct, USB_US_LAND_ID); + } + if (Grp->dev_desc.StrSerialNumber != 0) { + // Set timeout value to 3000 ms for the serial number string descriptor. + gUsbData->wTimeOutValue = USB_GET_SERIAL_NUMBER_DESC_TIMEOUT_MS; + Grp->SerialNumberStrDesc = + (EFI_USB_STRING_DESCRIPTOR*)GetUsbDescriptor( + (USBDEV_T*)Grp, DESC_TYPE_STRING, + Grp->dev_desc.StrSerialNumber, USB_US_LAND_ID); + } + gUsbData->wTimeOutValue = OrgTimeOutValue; + } + } + } + //<(EIP66231+) + TreeAddChild(HubNode,(ParentNode = TreeCreate(&Grp->node, Grp))); + } else { + // Old group was found in tree + TREENODE_T *tmp = TreeSearchSibling(ParentNode->child, DevByAdrIf, DevInfo ); + if(tmp){ + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: IF is already in tree: %x\n", tmp ); + return; + } + + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: multi-function; group node found: %x\n", ParentNode ); + Grp = (DEVGROUP_T*)ParentNode->data; + } + + // Create new device node as a child of HubNode + gBS->AllocatePool (EfiBootServicesData, sizeof(USBDEV_T), &Dev); + ASSERT(Dev); + if (Dev == NULL) return; + EfiZeroMem(Dev, sizeof(USBDEV_T)); + + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: device node created: %x\n", + &Dev->node ); + Dev->type = NodeDevice; + TreeAddChild(ParentNode, TreeCreate(&Dev->node, Dev)); + Dev->dev_info = DevInfo; + Dev->hc = ((USBBUS_HC_T*)HcNode->data)->hc; + Dev->hc_info = ((USBBUS_HC_T*)HcNode->data)->hc_data; + Dev->f_connected = FALSE; + + UsbDevLoadEndpoints(Dev); + + // Speed 00/10/01 - High/Full/Low + //(EIP81612)> + switch (Dev->dev_info->bEndpointSpeed) { + case USB_DEV_SPEED_SUPER_PLUS: + Dev->speed = EFI_USB_SPEED_SUPER_PLUS; + break; + case USB_DEV_SPEED_SUPER: + Dev->speed = EFI_USB_SPEED_SUPER; + break; + case USB_DEV_SPEED_FULL: + Dev->speed = EFI_USB_SPEED_FULL; + break; + case USB_DEV_SPEED_LOW: + Dev->speed = EFI_USB_SPEED_LOW; + break; + case USB_DEV_SPEED_HIGH: + Dev->speed = EFI_USB_SPEED_HIGH; + } + //<(EIP81612) + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: endpoints loaded\n" ); + + // Create Device Path + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: preparing DP...\n" ); + + ASSERT(((USBDEV_T*)HubNode->data)->dp); + Dev->dp = DpAddUsbSegment(((USBDEV_T*)HubNode->data)->dp, + DevInfo->bHubPortNumber - 1, DevInfo->bInterfaceNum); + if (DevInfo->bLUN) { + Dev->dp = DpAddLun(Dev->dp, DevInfo->bLUN); + } + ASSERT(Dev->dp); + + // Install USB_IO protocol + Dev->io.UsbControlTransfer = UsbIoControlTransfer; + Dev->io.UsbBulkTransfer = UsbIoBulkTransfer; + Dev->io.UsbAsyncInterruptTransfer = UsbIoAsyncInterruptTransfer; + Dev->io.UsbSyncInterruptTransfer = UsbIoSyncInterruptTransfer; + Dev->io.UsbIsochronousTransfer = UsbIoIsochronousTransfer; + Dev->io.UsbAsyncIsochronousTransfer = UsbIoAsyncIsochronousTransfer; + + Dev->io.UsbGetDeviceDescriptor = UsbIoGetDeviceDescriptor; + Dev->io.UsbGetConfigDescriptor = UsbIoGetConfigDescriptor; + Dev->io.UsbGetInterfaceDescriptor = UsbIoGetInterfaceDescriptor; + Dev->io.UsbGetEndpointDescriptor = UsbIoGetEndpointDescriptor; + Dev->io.UsbGetStringDescriptor = UsbIoGetStringDescriptor; + Dev->io.UsbGetSupportedLanguages = UsbIoGetSupportedLanguages; + + Dev->io.UsbPortReset = UsbIoPortReset; + +// DEBUG_DELAY(); + //Install DP_ protocol + Status = gBS->InstallMultipleProtocolInterfaces ( + &Dev->handle, + &gEfiUsbIoProtocolGuid, &Dev->io, + &gEfiDevicePathProtocolGuid, Dev->dp, + NULL); + ASSERT_EFI_ERROR(Status); + + *(UINTN*)Dev->dev_info->Handle = (UINTN)Dev->handle; + Dev->dev_info->Flag |= DEV_INFO_DEV_BUS; + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: USB_IO %x installed on Dev %x\n", &Dev->io, Dev ); + + { + VOID* tmp; + VERIFY_EFI_ERROR( + gBS->OpenProtocol ( + Dev->hc_info->Controller, + &gEfiUsb2HcProtocolGuid, + &tmp, + gUSBBusDriverBinding.DriverBindingHandle, + Dev->handle, + EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER )); + } + + PROGRESS_CODE(DXE_USB_HOTPLUG); + + OldTpl = pBS->RaiseTPL(TPL_HIGH_LEVEL); + pBS->RestoreTPL(TPL_CALLBACK); + + // Connect controller to start device drvirs + Status = gBS->ConnectController(Dev->handle,NULL,NULL,TRUE); + + pBS->RaiseTPL(TPL_HIGH_LEVEL); + pBS->RestoreTPL(OldTpl); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: instdev: connect controller: %r\n", Status ); + + if( !EFI_ERROR(Status)){ + Dev->f_connected = TRUE; + } + return; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UninstallDevice +// +// Description: Disconnects device; uninstalls USB_IO and DEVICEPATH protocols +// delocates all memory used USB Bus driver to support the device +// removes device node from the tree; if device has children, all +// UninstallDevice procedure is repeated for each child. +// +// In case if disconnect or protocol uninstall fails, it reports +// error stauts returned from Boot service procedure. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS UninstallDevice(USBDEV_T* Dev) +{ + EFI_STATUS Status; + EFI_TPL OldTpl; + + // + // Uninstall connected devices if it's a hub + // + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: UninstallDevice: node %x; ", &Dev->node); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "info:%x [adr:%d;if:%d] uninstalling children...\n", + Dev->dev_info,Dev->dev_info->bDeviceAddress, Dev->dev_info->bInterfaceNum); + if( TreeSearchSibling( Dev->node.child, eUninstallDevice, &Status )) + return Status; + + OldTpl = pBS->RaiseTPL(TPL_HIGH_LEVEL); + pBS->RestoreTPL(TPL_CALLBACK); + + Status = gBS->DisconnectController(Dev->handle, NULL, NULL); + + pBS->RaiseTPL(TPL_HIGH_LEVEL); + pBS->RestoreTPL(OldTpl); + + if (EFI_ERROR(Status)) { + QueuePut(&gUsbData->QueueCnnctDisc, Dev->dev_info); + Dev->dev_info->Flag |= DEV_INFO_IN_QUEUE; + return Status; + } + + if (Dev->async_endpoint != 0) { + Status = Dev->io.UsbAsyncInterruptTransfer(&Dev->io, Dev->async_endpoint, FALSE, + 0, 0, NULL, NULL); + Dev->async_endpoint = 0; + } + + Status = gBS->CloseProtocol ( + Dev->hc_info->Controller, + &gEfiUsb2HcProtocolGuid, + gUSBBusDriverBinding.DriverBindingHandle, + Dev->handle + ); + ASSERT_EFI_ERROR(Status); + if (EFI_ERROR(Status)) return Status; + + // + // Try to uninstall protocols + // + // they can be denied to uninstall, which result in + // keeping this device and all bus alive + // + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: uninstdev: [%d:%d] uninstalling protocols...", + Dev->dev_info->bDeviceAddress, Dev->dev_info->bInterfaceNum); + Status = gBS->UninstallMultipleProtocolInterfaces ( + Dev->handle, + &gEfiUsbIoProtocolGuid, &Dev->io, + &gEfiDevicePathProtocolGuid, Dev->dp, + NULL); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "%r\n", Status ); + ASSERT_EFI_ERROR(Status); + if (EFI_ERROR(Status)) return Status; + + Dev->dev_info->Flag &= ~DEV_INFO_DEV_BUS; + if (!(Dev->dev_info->Flag & (DEV_INFO_MASS_DEV_REGD | DEV_INFO_DEV_PRESENT))) { + Dev->dev_info->Flag &= ~DEV_INFO_VALID_STRUC; + } + + // + // Unistall succeeded, free usbdev + // + TreeRemove(&Dev->node); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: uninstdev: [%d:%d] done.\n", + Dev->dev_info->bDeviceAddress, Dev->dev_info->bInterfaceNum); + + if(Dev->name) + gBS->FreePool(Dev->name); + gBS->FreePool(Dev); + + return EFI_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: eUninstallDevice +// +// Description: Enumeration call-back function that is usded +// uninstall all enumerated device nodes +// Stops enumeration as soon as error was recieved +// Input: +// Node - tree node of the USB device or group +// Contex - pointer to the EFI_STATUS variable that +// recieves status information if error +// was recieved +// Output: TRUE on error found; this will stop enumeration +// FALSE on succesfull uninstall operation +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> +int +eUninstallDevice( + VOID* Node, + VOID* Context +) +{ + EFI_STATUS *Status = (EFI_STATUS*)Context; + DEVGROUP_T* Grp = (DEVGROUP_T*)Node; + ASSERT(Status); + + if (Grp->type == NodeGroup) { + // + // Uninstall all CONNECTED devices within group + // + TreeSearchSibling( Grp->node.child, eUninstallDevice, Status ); + if (EFI_ERROR(*Status)) { + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: devgroup uninstall failed: devaddr:0x%x\n", + Grp->dev_info->bDeviceAddress ); + return TRUE; //stop enumeration + } + // Free devgroup + TreeRemove(&Grp->node); + if (Grp->configs) { + int i; + for (i = 0; i < Grp->config_count; ++i) { + if (Grp->configs[i]) { + gBS->FreePool(Grp->configs[i]); + } + } + gBS->FreePool(Grp->configs); + } + if (Grp->ManufacturerStrDesc) { + gBS->FreePool(Grp->ManufacturerStrDesc); + } + if (Grp->ProductStrDesc) { + gBS->FreePool(Grp->ProductStrDesc); + } + if (Grp->SerialNumberStrDesc) { + gBS->FreePool(Grp->SerialNumberStrDesc); + } + gBS->FreePool(Grp); + } else if (Grp->type == NodeDevice ) { + // + //Uninstall Device + // + *Status = UninstallDevice((USBDEV_T*)Node); + if (EFI_ERROR(*Status)) { + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: usbdev uninstall failed: if:%d\n", + ((USBDEV_T*)Node)->dev_info->bInterfaceNum ); + return TRUE; //stop enumeration + } + } + return FALSE;// continue enumeration +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: RemoveHubEcho +// +// Description: Finds the USB hub node that sits on the same +// path (seq. of (hub ports,if) ) but have different +// USB address or DEV_INFO node. This could be the result +// of lost disconnect event or previous error to uninstall +// USB_IO +// Input: +// pDevInfo - DEV_INFO structure that is checked for +// echoes in the bus +// Output: EFI_SUCCESS - echo wasn't found or was succesfully removed +// otherwise return status resulted from attemp to remove the node +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +RemoveHubEcho( + TREENODE_T *HcNode, + UINT8 Addr +) +{ + while(!( Addr & BIT7 )){ + // + // Find hub DEV_INFO + // + int i; + TREENODE_T *HubNode; + TREENODE_T* DevNode; + DEV_INFO* DevInfo=NULL; + + for ( i= 1; i < MAX_DEVICES; i++) { + if( ((gUsbData->aDevInfoTable[i].Flag & + (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT | DEV_INFO_DEV_DUMMY)) + != (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT)) && + gUsbData->aDevInfoTable[i].bDeviceAddress == Addr ) + { + DevInfo = gUsbData->aDevInfoTable+i; + break; + } + } + if ( DevInfo == NULL ) + return EFI_NOT_FOUND; + + // + // Search for parent hub + // + if( DevInfo->bHubDeviceNumber & BIT7 ){ + //Root hub + HubNode = HcNode; + } else { + //USB hub device + TREENODE_T* HubGrpNode = TreeSearchDeep(HcNode->child, + DevGrpByAddr, &DevInfo->bHubDeviceNumber ); + if( HubGrpNode != NULL ){ + USBDEV_T* Dev; + + HubNode = HubGrpNode->child; + ASSERT(HubNode); + DevNode = TreeSearchSibling(HubNode->child, + DevGrpByPortIf, DevInfo); + if(DevNode==NULL) return EFI_SUCCESS; + Dev = (USBDEV_T*)DevNode->data; + if( Dev && (DevInfo->bDeviceAddress != + Dev->dev_info->bDeviceAddress || + DevInfo != Dev->dev_info )) + { + // + // The disconnect event must have been droped + // disconnect old info now + // + + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: echo found [%x]:\n" ); + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "\t(hc:0x%x,hub:0x%x,port:%d,addr:0x%x,if:%d)\n", + Dev->dev_info->bHCNumber, + Dev->dev_info->bHubDeviceNumber, + Dev->dev_info->bHubPortNumber, + Dev->dev_info->bDeviceAddress, + Dev->dev_info->bInterfaceNum); + return RemoveDevInfo(Dev->dev_info); + } + return EFI_SUCCESS; + } else { + // + // Either hub wasn't added to bus yet; or there is echo for the + // brunch. The the later case succesfull removal of the burnch + // removes an echo for this device info + // + Addr = DevInfo->bHubDeviceNumber; + + } + } + } + return EFI_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: RemoveDevInfoEcho +// +// Description: Finds the USB device node that sits on the same +// path (seq. of (hub ports,if) ) but have different +// USB address or DEV_INFO node. This could be the result +// of lost disconnect event or previous error to uninstall +// USB_IO +// Input: +// DevInfo - DEV_INFO structure that is checked for +// echoes in the bus +// Output: EFI_SUCCESS - echo wasn't found or was succesfully removed +// otherwise return status resulted from attemp to remove the node +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +RemoveDevInfoEcho( + DEV_INFO *DevInfo +) +{ + USBDEV_T *Dev; + TREENODE_T *DevNode; + TREENODE_T *HcNode, *HubNode; + + HcNode = TreeSearchSibling(gUsbRootRoot->child,HcByIndex, + &DevInfo->bHCNumber); + if(HcNode==NULL) return EFI_SUCCESS; + + if( DevInfo->bHubDeviceNumber & BIT7 ){ + //Root hub + HubNode = HcNode; + } else { + //USB hub device + TREENODE_T* HubGrpNode = TreeSearchDeep(HcNode->child, + DevGrpByAddr, &DevInfo->bHubDeviceNumber ); + if( HubGrpNode != NULL ){ + HubNode = HubGrpNode->child; + ASSERT(HubNode); + } else { + // + // Either hub wasn't added to bus yet; or there is echo for the + // brunch. The the later case succesfull removal of the burnch + // removes an echo for this device info + // + //return RemoveHubEcho(HcNode, DevInfo->bHubDeviceNumber); + return EFI_SUCCESS; + } + } + DevNode = TreeSearchSibling(HubNode->child, DevGrpByPortIf, DevInfo); + if(DevNode==NULL) return EFI_SUCCESS; + Dev = (USBDEV_T*)DevNode->data; + if (Dev != NULL) { + // + // The disconnect event must have been droped + // disconnect old info now + // + + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: echo found [%x]:\n" ); + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "\t(hc:0x%x,hub:0x%x,port:%d,addr:0x%x,if:%d)\n", + Dev->dev_info->bHCNumber, + Dev->dev_info->bHubDeviceNumber, + Dev->dev_info->bHubPortNumber, + Dev->dev_info->bDeviceAddress, + Dev->dev_info->bInterfaceNum); + return RemoveDevInfo(Dev->dev_info); + } + return EFI_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: RemoveDevInfo +// +// Description: Removes device node from the USB bus tree. Device node +// corresponds to the DEV_INFO. Device gets removed in response to +// the pending removal event sheduled from SMM when disconnect +// was detected on USB +// Input: +// DevInfo - DEV_INFO structure that was disconnect +// +// Output: EFI_SUCCESS - echo wasn't found or was succesfully removed +// otherwise return status resulted from attemp to remove the node +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS RemoveDevInfo(DEV_INFO* DevInfo) +{ + TREENODE_T *DevNode; + TREENODE_T *HcNode; + EFI_STATUS Status; + + HcNode = TreeSearchSibling(gUsbRootRoot->child, HcByIndex, + &DevInfo->bHCNumber); + if(HcNode==NULL) return EFI_NOT_FOUND; + + //Check for echoes + + DevNode = TreeSearchDeep(HcNode->child,DevGrpByAddr, + &DevInfo->bDeviceAddress); + if (DevNode==NULL){ + USB_DEBUG(DEBUG_LEVEL_USBBUS, "\tdevice is not found in the tree...\n" ); + return EFI_NOT_FOUND; + } + USB_DEBUG(DEBUG_LEVEL_USBBUS, "\tdevice found in the tree...\n" ); + + Status = EFI_SUCCESS; + eUninstallDevice(DevNode->data, &Status); + USB_DEBUG(DEBUG_LEVEL_USBBUS, "\tDisconnect complete: %r.\n", Status ); + + return Status; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbHcOnTimer +// +// Description: Timer call-back routine that is +// is used to monitor changes on USB Bus +// It monitors the state of queueCnnct and queueDiscnct queues +// which get populated by UsbSmiNotify call-back routine +// +// When this routine finds a new device connected to usb it +// will install a device node for that device by calling +// InstallDevice +// +// When this routine finds a disconneced device it uninstalls the +// device node by calling UninstallDevice +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UsbHcOnTimer( + EFI_EVENT Event, + VOID *Context +) +{ + DEV_INFO* EventCnnct = 0; + static int i = 0; + int Lock; + EFI_STATUS Status; + + UsbSmiPeriodicEvent(); + + if (Event) { + gBS->SetTimer(Event, TimerCancel, ONESECOND / 10); + } + + ATOMIC({Lock = gBustreeLock; gBustreeLock = 1;}); + + if (Lock) { + USB_DEBUG(DEBUG_LEVEL_USBBUS, "UsbHcOnTimer:: is locked; return\n"); + return; + } + + do { + ATOMIC({EventCnnct = QueueGet(&gUsbData->QueueCnnctDisc);}); + + if (EventCnnct == NULL) { + break; + } + EventCnnct->Flag &= ~DEV_INFO_IN_QUEUE; + // + // There is no need to raise tpl here: this is callback of Event with + // TPL_CALLBACK, so this code doesn't reenter; the Install and Uninstall + // are also called from driver stop and start. Stop and start protect + // the code at TPL_CALLBACK level + // + if( (EventCnnct->Flag & (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT | + DEV_INFO_DEV_DUMMY)) == (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT) ){ + USB_DEBUG(DEBUG_LEVEL_USBBUS, "UsbHcOnTimer:: event connect [%d]: %x\n", i++, EventCnnct); + + RemoveDevInfoEcho(EventCnnct); + InstallDevice(EventCnnct); + } else if ((EventCnnct->Flag & (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT | + DEV_INFO_DEV_DUMMY)) == DEV_INFO_VALID_STRUC) { + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "UsbHcOnTimer:: event disconnect [%d]: %x\n", i++, EventCnnct); + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "\t(hc:0x%x,hub:0x%x,port:%d,addr:0x%x,if:%d)\n", + EventCnnct->bHCNumber, EventCnnct->bHubDeviceNumber, + EventCnnct->bHubPortNumber, EventCnnct->bDeviceAddress, + EventCnnct->bInterfaceNum); + //RemoveDevInfoEcho(EventCnnct); + Status = RemoveDevInfo(EventCnnct); + if (EFI_ERROR(Status)) { + break; + } + } + } while ( EventCnnct != NULL ); + + gBustreeLock = 0; + + if (Event) { + gBS->SetTimer(Event, TimerPeriodic, ONESECOND / 10); + } +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: PopulateTree +// +// Description: Enumerate all DEV_INFO structures in the aDevInfoTable array +// and install all currently connected device +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +PopulateTree( + HC_STRUC *HcStruc +) +{ + UINT16 i; + + PROGRESS_CODE(DXE_USB_DETECT); + + UsbHcOnTimer(NULL, NULL); + + for (i = 1; i < COUNTOF(gUsbData->aDevInfoTable); i++) { + if ((gUsbData->aDevInfoTable[i].Flag & (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT | + DEV_INFO_DEV_DUMMY | DEV_INFO_DEV_BUS)) == (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT)) { + if (HcStruc != gUsbData->HcTable[gUsbData->aDevInfoTable[i].bHCNumber - 1]) { + continue; + } + // + // Valid and present device behind specified HC, so insert it in the tree + // + USB_DEBUG(DEBUG_LEVEL_3, "USBBUS: PopulateTree: found valid dev info[%d]: %x\n",i, gUsbData->aDevInfoTable +i ); + + //RemoveDevInfoEcho(&gUsbData->aDevInfoTable[i]); + //InstallDevice( gUsbData->aDevInfoTable + i ); + if (!(gUsbData->aDevInfoTable[i].Flag & DEV_INFO_IN_QUEUE)) { + QueuePut(&gUsbData->QueueCnnctDisc, &gUsbData->aDevInfoTable[i]); + gUsbData->aDevInfoTable[i].Flag |= DEV_INFO_IN_QUEUE; + } + } + } +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbBusGetControllerName +// +// Description: This function is a part of binding protocol, it returns +// the string with the controller name. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +CHAR16* +UsbBusGetControllerName( + EFI_HANDLE Controller, + EFI_HANDLE Child +) +{ + //(EIP60745+)> + EFI_STATUS Status; + + Status = gBS->OpenProtocol ( Controller, + &gEfiUsb2HcProtocolGuid, + NULL, + gUSBBusDriverBinding.DriverBindingHandle, + Controller, + EFI_OPEN_PROTOCOL_TEST_PROTOCOL ); + + if (Status != EFI_SUCCESS && Status != EFI_ALREADY_STARTED) { + return NULL; + } + //<(EIP60745+) + if(Child) { + //Get name for USB device + EFI_USB_IO_PROTOCOL *UsbIo; + USBDEV_T *Dev ; + if( EFI_ERROR(gBS->HandleProtocol(Child,& gEfiUsbIoProtocolGuid, &UsbIo))) + { + return NULL; + } + Dev = UsbIo2Dev(UsbIo); + if( Dev->name == 0) + Dev->name = LoadName(Dev); + return Dev->name; + } else { + //Get name for USB HC + return L"USB Host Controller (USBBUS)"; + } +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbBusInit +// +// Description: Install driver binding and controller name protocols +// for the USB bus driver. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbBusInit( + EFI_HANDLE ImageHandle, + EFI_HANDLE ServiceHandle +) +{ + //(EIP59272)> + static NAME_SERVICE_T usbbus_names; + gUSBBusDriverBinding.DriverBindingHandle = ServiceHandle; + gUSBBusDriverBinding.ImageHandle = ImageHandle; + + return gBS->InstallMultipleProtocolInterfaces( + &gUSBBusDriverBinding.DriverBindingHandle, + &gEfiDriverBindingProtocolGuid, &gUSBBusDriverBinding, + &gEfiComponentName2ProtocolGuid, InitNamesProtocol(&usbbus_names, + L"USB bus", UsbBusGetControllerName), + NULL); + //<(EIP59272) +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbBusSupported +// +// Description: This is a binding protocol function that returns EFI_SUCCESS +// for USB controller and EFI_UNSUPPORTED for any other kind of +// controller. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbBusSupported( + EFI_DRIVER_BINDING_PROTOCOL *This, + EFI_HANDLE Controller, + EFI_DEVICE_PATH_PROTOCOL *DevicePath +) +{ + EFI_STATUS Status; + VOID* Ptr = 0; + + Status = gBS->OpenProtocol ( Controller, &gEfiUsb2HcProtocolGuid, + &Ptr, This->DriverBindingHandle, Controller, EFI_OPEN_PROTOCOL_BY_DRIVER ); + + if (Status != EFI_SUCCESS && Status != EFI_ALREADY_STARTED) { + return EFI_UNSUPPORTED; + } else if (Status == EFI_ALREADY_STARTED) { + return Status; + } + + gBS->CloseProtocol ( Controller, &gEfiUsb2HcProtocolGuid, + This->DriverBindingHandle, Controller); + + Status = gBS->OpenProtocol ( Controller, &gEfiDevicePathProtocolGuid, + NULL, This->DriverBindingHandle, Controller, EFI_OPEN_PROTOCOL_TEST_PROTOCOL ); + + if (Status != EFI_SUCCESS && Status != EFI_ALREADY_STARTED) { + return EFI_UNSUPPORTED; + } + + return Status; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbBusStop +// +// Description: This function is part of binding protocol installed on USB +// controller. It stops the controller and removes all the +// children. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbBusStop ( + EFI_DRIVER_BINDING_PROTOCOL *This, + EFI_HANDLE Controller, + UINTN NumberOfChildren, + EFI_HANDLE *Children ) +{ + EFI_STATUS Status = EFI_SUCCESS; + TREENODE_T *HcNode; + USBBUS_HC_T *HcDev; + + //EFI_TPL SaveTpl = gBS->RaiseTPL (EFI_TPL_NOTIFY); + //ASSERT(SaveTpl <= EFI_TPL_NOTIFY ); + + HcNode = TreeSearchSibling(gUsbRootRoot->child, HcByHandle, &Controller ); + ASSERT(HcNode); + if( HcNode == NULL ) { + //gBS->RestoreTPL(SaveTpl); + return EFI_DEVICE_ERROR; + } + HcDev = (USBBUS_HC_T*)HcNode->data; + + VERIFY_EFI_ERROR( + gBS->SetTimer( gEvUsbEnumTimer, TimerCancel, ONESECOND/10)); + + UsbHcOnTimer(NULL, NULL); + + if (TreeSearchSibling(HcNode->child, eUninstallDevice, &Status) != NULL) + { + USB_DEBUG(DEBUG_LEVEL_USBBUS, + "USBBUS: Stop HC: [%d] failed to uninstall children\n", + ((USBBUS_HC_T*)HcNode->data)->hc_data->bHCNumber); + //gBS->RestoreTPL(SaveTpl); + VERIFY_EFI_ERROR( + gBS->SetTimer ( gEvUsbEnumTimer, TimerPeriodic, ONESECOND/10)); + return Status; + } + + if (NumberOfChildren == 0) { + TreeRemove(HcNode); + + // + // Close Protocols opened by driver + // + gBS->CloseProtocol ( + Controller, &gEfiUsb2HcProtocolGuid, + This->DriverBindingHandle, Controller); + + gBS->FreePool(HcDev); + + if(--gCounterUsbEnumTimer==0){ + VERIFY_EFI_ERROR( + gBS->SetTimer ( gEvUsbEnumTimer, TimerCancel, ONESECOND/10)); + VERIFY_EFI_ERROR( + gBS->CloseEvent (gEvUsbEnumTimer)); + gEvUsbEnumTimer=0; + } + } + + if (gCounterUsbEnumTimer != 0) { + VERIFY_EFI_ERROR( + gBS->SetTimer ( gEvUsbEnumTimer, TimerPeriodic, ONESECOND/10)); + } + //gBS->RestoreTPL(SaveTpl); + + return EFI_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbBusStart +// +// Description: This function is part of binding protocol installed on USB +// controller. It starts the USB bus for a given controller. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbBusStart( + EFI_DRIVER_BINDING_PROTOCOL *This, + EFI_HANDLE Controller, + EFI_DEVICE_PATH_PROTOCOL *DevicePathProtocol +) +{ + USBBUS_HC_T* HcDev = 0; + EFI_STATUS Status = EFI_UNSUPPORTED; + + VERIFY_EFI_ERROR ( + gBS->AllocatePool ( + EfiBootServicesData, + sizeof(USBBUS_HC_T), + &HcDev )); + HcDev->type = NodeHC; + HcDev->hc_data = FindHcStruc(Controller); + +// ASSERT(HcDev->hc_data); + if (HcDev->hc_data == NULL) { + gBS->FreePool(HcDev); + return EFI_DEVICE_ERROR; + } + + // + // Open Protocols + // + Status = gBS->OpenProtocol ( Controller, + &gEfiUsb2HcProtocolGuid, &HcDev->hc, + This->DriverBindingHandle, Controller, + EFI_OPEN_PROTOCOL_BY_DRIVER ); + ASSERT_EFI_ERROR(Status); + if (EFI_ERROR(Status)) { + return Status; + } + + Status = gBS->OpenProtocol ( Controller, + &gEfiDevicePathProtocolGuid, + &HcDev->dp, This->DriverBindingHandle, + Controller, EFI_OPEN_PROTOCOL_GET_PROTOCOL ); + ASSERT_EFI_ERROR(Status); + if (EFI_ERROR(Status)) { + return Status; + } + + // + // Install Polling timer + // + { + //EFI_TPL SaveTpl = gBS->RaiseTPL (EFI_TPL_NOTIFY); + //ASSERT( SaveTpl <= EFI_TPL_NOTIFY); + if(gEvUsbEnumTimer != 0) { + VERIFY_EFI_ERROR( + gBS->SetTimer ( gEvUsbEnumTimer, TimerCancel, ONESECOND/10)); + } + // + // Critical section + +// HookSmiNotify(1); + + USB_DEBUG(DEBUG_LEVEL_USBBUS,"**** \tnew hc_struc: %x(type:%x,number:%x)\n", + HcDev->hc_data, HcDev->hc_data->bHCType, HcDev->hc_data->bHCNumber); + + // + // Create HC branch in the USB root + // + TreeAddChild(gUsbRootRoot, TreeCreate(&HcDev->node,HcDev)); + + gCounterUsbEnumTimer++; + PopulateTree(HcDev->hc_data); + + UsbHcOnTimer(NULL, NULL); + + // Setting up global: gUsbDeviceToDisconnect, gUsbDeviceToConnect + if (gEvUsbEnumTimer == 0) { + USB_DEBUG(DEBUG_LEVEL_USBBUS, "USBBUS: Start: setup timer callback %x\n", &UsbHcOnTimer ); + VERIFY_EFI_ERROR( + gBS->CreateEvent ( EFI_EVENT_TIMER | EFI_EVENT_NOTIFY_SIGNAL, + EFI_TPL_CALLBACK, UsbHcOnTimer,0,&gEvUsbEnumTimer)); + } + VERIFY_EFI_ERROR( + gBS->SetTimer ( gEvUsbEnumTimer, TimerPeriodic, ONESECOND/10)); + //gBS->RestoreTPL(SaveTpl); + } + + return EFI_SUCCESS; +} + +#if defined(DEBUG_SWITCH) && (DEBUG_SWITCH == 1) +VOID DEBUG_DELAY() +{ + int i; + PrintDebugMsg(3,"\nDELAY: "); + for(i=0;i<10;i++){ + PrintDebugMsg(3,"%d..",i); + pBS->Stall(200*1000); + } + PrintDebugMsg(3,"\n"); +} +#endif + +//**************************************************************************** +//**************************************************************************** +//** ** +//** (C)Copyright 1985-2015, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Pkwy, Norcross, GA 30093 ** +//** ** +//** Phone (770)-246-8600 ** +//** ** +//**************************************************************************** +//**************************************************************************** |