diff options
Diffstat (limited to 'Core/EM/usb/rt/usb.c')
| -rw-r--r-- | Core/EM/usb/rt/usb.c | 5300 |
1 files changed, 5300 insertions, 0 deletions
diff --git a/Core/EM/usb/rt/usb.c b/Core/EM/usb/rt/usb.c new file mode 100644 index 0000000..b1baa4a --- /dev/null +++ b/Core/EM/usb/rt/usb.c @@ -0,0 +1,5300 @@ +#pragma warning(disable: 4001) +#pragma warning(disable: 4127) +//**************************************************************************** +//**************************************************************************** +//** ** +//** (C)Copyright 1985-2016, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Pkwy, Norcross, GA 30093 ** +//** ** +//** Phone (770)-246-8600 ** +//** ** +//**************************************************************************** +//**************************************************************************** + +//**************************************************************************** +// $Header: /Alaska/SOURCE/Modules/USB/ALASKA/RT/usb.c 183 10/21/16 1:48a Wilsonlee $ +// +// $Revision: 183 $ +// +// $Date: 10/21/16 1:48a $ +//**************************************************************************** +// Revision History +// ---------------- +// $Log: /Alaska/SOURCE/Modules/USB/ALASKA/RT/usb.c $ +// +// 183 10/21/16 1:48a Wilsonlee +// Fixed Cppcheck error. +// +// 182 10/16/16 10:12p Wilsonlee +// [TAG] EIP288158 +// [Category] Improvement +// [Description] Check if gUsbData is integrity. +// [Files] amiusb.cif, usbsb.c, AmiUsbLib.cif, AmiUsbLib.sdl, +// AmiUsbSmmGlobalDataValidationLib.c, +// AmiUsbSmmGlobalDataValidationLib.cif, +// AmiUsbSmmGlobalDataValidationLib.mak, Crc32.c, amiusb.c, amiusb.h, +// ehci.c, elib.c, ohci.c, syskbc.c, uhci.c, usb.c, usbCCID.c, usbdef.h, +// usbhid.c, usbhub.c, usbkbd.c, usbmass.c, usbms.c, usbrt.mak, xhci.c, +// amiusbhc.c, efiusbccid.c, efiusbmass.c, uhcd.c, usbmisc.c, +// AmiUsbController.h, AmiUsbLibInclude.cif, +// AmiUsbSmmGlobalDataValidationLib.h +// +// 181 7/28/16 4:56a Wilsonlee +// [TAG] EIP264662 +// [Category] Improvement +// [Description] Don't install usb hw smi after reconnecting usb +// controllers. +// [Files] uhcd.c, usb.c, ohci.c, amiusb.c, amiusbhc.c +// +// 180 3/02/16 9:41p Wilsonlee +// [TAG] EIP254309 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] GK-FORCE K83 USB KB function abnormal. +// [RootCause] This device has an interrupt out endpoint and doesn't +// support "Set Report" request. +// [Solution] Use the interrupt out endpoint instead of sending "Set +// Report" request. +// [Files] AmiUsbController.h, xhci.c, usbmass.c, usbkbd.h, usbkbd.c, +// usbhub.c, usbhid.c, usbdef.h, usbCCID.c, usb.c, uhci.c, ohci.c, ehci.c, +// amiusb.h, efiusbms,c, amiusbhc.c +// +// 179 11/04/15 9:51p 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 +// +// 178 9/01/15 10:17p Wilsonlee +// [TAG] EIP235482 +// [Category] Improvement +// [Description] Select this alternate setting for multiple TTs hubs. +// [Files] usbhub.c, usb.c, amiusb.h, usbdef.h +// +// 177 7/24/15 3:30a Wilsonlee +// [TAG] EIP229294 +// [Category] Improvement +// [Description] If the device descriptor returns with a value in its +// length field that is greater 18, it is valid and we should ignore the +// extra bytes. +// [Files] usb.c +// +// 176 5/28/15 4:29a Wilsonlee +// [TAG] EIP219785 +// [Category] Improvement +// [Description] Suspend usb devices which are connected to Hubs. +// [Files] usb.c, usbdef.h +// +// 175 4/29/15 11:26p 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 +// +// 174 4/27/15 2:25a Wilsonlee +// [TAG] EIP211855 +// [Category] Improvement +// [Description] Set the default interface if the device has alternate +// setting for the interface. +// [Files] usb.c, usbdef.h +// +// 173 4/07/15 4:03a Wilsonlee +// [TAG] EIP211598 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Keyboard/Mouse sometimes cannot work when connected to USB +// 3.0 HUB. +// [RootCause] It's failed at setting device address. +// [Solution] Wait 10 ms for stable before we set device address. +// [Files] usb.c +// +// 172 3/08/15 10:49p Wilsonlee +// [TAG] EIP207774 +// [Category] Improvement +// [Description] Set USB_FLAG_DRIVER_STARTED flag when HC is running and +// clear it if we don't start any HC. +// [Files] uhci.c, usb.c, ehci.c, ohci.c, xhci.c, amiusb.h +// +// 171 2/16/15 2:44a Wilsonlee +// [TAG] EIP205373 +// [Category] Improvement +// [Description] Cppcheck errors in Usb module. +// [Files] usb.c, usbport.c, uhcd.c, usbCCID.c +// +// 170 1/22/15 10:19p Wilsonlee +// [TAG] EIP201434 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Number of connected devices isn't correct if we plug out +// keyboards or mice behind hub in xhci. +// [RootCause] The PortConnectChange bit is cleared when we check port +// status for interrupt endpoint transaction error. +// [Solution] Don't clear change bits if we check port status for +// interrupt endpoint transaction error. +// [Files] xhci.c, usbhub.c, usbdef.h, usb.c, uhci.c, ohci.c, ehci.c, +// amiusbhc.c +// +// 169 12/15/14 2:16a Wilsonlee +// [TAG] EIP194720 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] System shutdown delay when connect with cardreader. +// [RootCause] When we reenumerate devices, we still reserve the +// original device info, then we will use the wrong info to send command +// and the device may not respond. +// [Solution] Remove the present flag of devices before we reenumerate. +// [Files] usb.c +// +// 168 11/23/14 10:09p Wilsonlee +// [TAG] EIP189293 +// [Category] Improvement +// [Description] Implement XHCI key repeat function. +// [Files] usb.c, xhci.c , xhci.h, amiusb.c +// +// 167 9/29/14 11:35p 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 +// +// 166 9/02/14 3:53a Wilsonlee +// [TAG] EIP182567 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] POST B4h sometimes stays about 30 sec if using special +// KB/Ms. +// [RootCause] t's timeout in getting config or report descriptor +// commands. +// [Solution] Set the timeout to 500 ms. +// [Files] usb.c, usbhid.c, usbdef.h +// +// 165 7/30/14 5:17a Wilsonlee +// [TAG] EIP176293 +// [Category] Improvement +// [Description] The changes are for DisplayLink USB Network driver. +// [Files] usbbus.c, usb.c +// +// 164 7/28/14 7:39a Wilsonlee +// [TAG] EIP176070 +// [Category] Improvement +// [Description] Add 100 microseconds before we send get configuration +// descriptor command if the device is full speed. +// [Files] usb.c +// +// 163 6/26/14 1:16a 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 +// +// 162 6/20/14 2:11a Wilsonlee +// [TAG] EIP174589 +// [Category] Improvement +// [Description] Fix build error if USB_HID_KEYREPEAT_USE_SETIDLE is 1. +// [Files] usb.c +// +// 161 5/12/14 4:29a Wilsonlee +// [TAG] EIP168515 +// [Category] New Feature +// [Description] Add the token "USB_CONTROLLERS_INITIAL_DELAY_LIST" if +// usb controllers need to delay for stabilization. +// [Files] usb.sdl, usb.c +// +// 160 4/30/14 5:25a 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 +// +// 159 4/29/14 8:30p Wilsonlee +// [TAG] EIP164772 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] System would auto wake up if USB hot-plug in S5 state via +// USB hub. +// [RootCause] The usb hubs have connnect / disconnect wakeup function +// if we send remote wakeup command +// [Solution] Don't send remote wakeup command to the usb hubs. +// [Files] usb.c +// +// 158 2/26/14 1:55a Wilsonlee +// [TAG] EIP149854 +// [Category] Improvement +// [Description] Add data length parameter to polling callback function. +// [Files] usbkbd.c, uhci.c, usb.c, usbhub.c, usbCCID.c, usbms.c, +// usbhid.c, usbpoint.c, usbkbd.h, ehci.c, ohci.c, xhci.c, usbdef.h +// +// 157 11/26/13 1:23a Wilsonlee +// [TAG] EIP143251 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] The usb mouse lost if it behinds TI TUSB8040A1 hub under +// BIOS. +// [RootCause] The device may connect later, then we clear connect +// change without setting the device is connected. +// [Solution] Don't get port status again before we clear the changes. +// [Files] usb.c, usbhub.c +// +// 156 11/04/13 3:26a Wilsonlee +// [TAG] EIP139714 +// [Category] Improvement +// [Description] Improve the UsbIoPortReset function to support the xhci +// controller. +// [Files] usb.c +// +// 155 9/04/13 5:46a 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 +// +// 154 8/16/13 4:17a Ryanchou +// +// 153 8/02/13 6:16a Ryanchou +// +// 152 7/29/13 5:19a 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 +// +// 151 7/22/13 10:31p Wilsonlee +// [TAG] EIP125357 +// [Category] Improvement +// [Description] Check if the port releases to a select host controller. +// [Files] uhci.c, usb.c, usbhub.c, ehci.c, ohci.c, xhci.c, usbdef.h +// +// 150 7/17/13 4:14a Roberthsu +// [TAG] EIP126319 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] TEAC floppy can not detect when cold boot. +// [RootCause] Device need more delay after get config descriptor. +// [Solution] Add delay to 1ms. +// [Files] usb.c +// +// 149 6/26/13 3:36a Roberthsu +// [TAG] EIP125792 +// [Category] Bug Fix +// [Severity:] Normal +// [Symptom:] Keep function not work +// [Root Cause] When check port change. We can not get baseclass. +// [Solution] Add Vaild base class flag. +// [Files] UsbPort.c,Usb.c +// +// 148 5/01/13 9:54p Wilsonlee +// [TAG] EIP121643 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Cannot detect the usb floppy. +// [RootCause] This device doesn't return data when we sned +// get-config-descriptor command. +// [Solution] We retry to send get-config-descriptor command if there is +// no data. +// [Files] usb.c, ehci.c +// +// 147 4/19/13 12:44a Wilsonlee +// Fix build error if token USB_S5_WAKEUP_SUPPORT is enabled. +// +// 146 4/18/13 11:22a Ryanchou +// Fix build error if token x64_BUILD is 0. +// +// 145 3/19/13 3:58a Ryanchou +// [TAG] EIP118177 +// [Category] Improvement +// [Description] Dynamically allocate HCStrucTable at runtime. +// [Files] usb.sdl, usbport.c, usbsb.c, amiusb.c, ehci.c, ohci.c, +// syskbc.c, sysnokbc.c, uhci.c, usb.c, usbCCID.c, usbdef.h, usbhid.c, +// usbhub.c, usbmass.c, usbrt.mak, usb.sd, amiusbhc.c, efiusbccid.c, +// efiusbhid.c, efiusbmass.c, efiusbms.c, uhcd.c, uhcd.h, uhcd.mak, +// usbmisc.c, usbsrc.sdl +// +// 144 3/15/13 5:57a Ryanchou +// +// 143 3/15/13 4:59a Ryanchou +// [TAG] EIP117211 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] USB Memory Allocation Failure for Sizes Above 4k +// [RootCause] The variable count will be reset when across a page +// boundary. +// [Solution] Only reset the variable Count if the allocated blocks less +// than a page. +// [Files] usb.c +// +// 142 3/07/13 9:25p Wilsonlee +// [TAG] EIP116044 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] TEAC FDD is not recognized after hot plugging under DOS. +// [RootCause] Setting the device configuration is failed. +// [Solution] This device configure successfully by that we set the +// device address after sending the first get-device-descriptor command. +// [Files] usb.c +// +// 141 3/07/13 8:52a Ryanchou +// [TAG] EIP113218 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] USB keyboard cannot work after ownership change back to +// BIOS +// [RootCause] The key repeat SMI does not generated because the HC is +// stopped. +// [Solution] Use the other HC to generate key repeat SMI +// [Files] usb.c, usbhid.c, usbkbd.c +// +// 140 1/23/13 8:33p Wilsonlee +// [TAG] EIP108891 +// [Category] Improvement +// [Description] For usb wakp up function, we need to add some delay to +// wait the usb devces connect. +// [Files] usb.c +// +// 139 1/22/13 2:38a 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 +// +// 138 1/11/13 4:15a 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 +// +// 137 12/05/12 4:23a Roberthsu +// [TAG] EIP96616 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] When Legacy to EFI, USB KB can't be used. +// [RootCause] Usb device driver content incorrect driver entry.Legacy +// insert a devicet,when legacy to efi,device does not install efi driver. +// [Solution] When legacy to efi, scan device info table and put it +// to smiqueue. +// [Files] usb.sdl,uhcd.c,usb.c +// +// 136 11/29/12 7:47a Ryanchou +// [TAG] EIP107586 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Unplug USB keyboard does not uninstall EFI USB keyboard +// driver properly +// [RootCause] The EIP99431 changes clear DEV_INFO.bSubDeviceType in +// runtime keyboard driver, that cause EFI keyboard driver does not know +// what type of the device is. +// [Solution] Do not clear DEV_INFO.bSubDeviceType in runtime keyboard +// driver. +// [Files] usb.c, usbhid.c, efiusbhid.c +// +// 135 11/22/12 9:20p Wilsonlee +// [TAG] EIP106887 +// [Category] New Feature +// [Description] Support usb S5 wake up function for UHCI. +// [Files] usb.c, uhci.c, uhci.h +// +// 134 11/13/12 7:11a Wilsonlee +// [TAG] EIP82553 +// [Category] New Feature +// [Description] Support usb S5 wake up function for XHCI. +// [Files] usb.c, ehci.c, ohci.c, xhci.c, xhci.h +// +// 133 11/10/12 6:39a 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 +// +// 132 10/25/12 4:14a Wilsonlee +// [TAG] EIP82354 +// [Category] New Feature +// [Description] Support usb S5 wake up function for OHCI. +// [Files] usb.c, ehci.c, ohci.c +// +// 131 9/28/12 2:38a Wilsonlee +// [TAG] EIP93154 +// [Category] Improvement +// [Description] Change the unit of the FixedDelay from 15 us to 1 us. +// [Files] amiusb.h, xhci.c, ehci.c, ohci.c, uhci.c, usb.c, usbCCID.c, +// usbmass.c, usbhub.c, elib.c +// +// 130 9/03/12 4:55a Roberthsu +// [TAG] EIP98145 +// [Category] Improvement +// [Description] Add skip function message. +// [Files] usb.c,usbsrc.sdl +// +// 129 8/29/12 9:32a Ryanchou +// [TAG] EIP88307 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Key repeat cannot be stopped if the keyboard is connected +// to xHCI. +// [RootCause] Periodic timer SMI stop generating when USB SMI and +// periodic timer SMI is generated frequently. +// [Solution] Reduces the key repeat rate to avoid this issue. +// [Files] ehci.c, usb.c, usb.sdl +// +// 128 8/29/12 8:18a Ryanchou +// [TAG] EIP77262 +// [Category] New Feature +// [Description] Remove SMM dependency of USB. +// [Files] usb.sdl, usbport.c, amiusb.c, amiusb.dxs, amiusb.h, ehci.c, +// elib.c, ohci.c, uhci.c, usb.c, usbdef.h, usbrt.mak, xhci.c, amiusbhc.c, +// efiusbccid.c, efiusbhid.c, efiusbkb.c, efiusbmass.c, uhcd.c, uhcd.dxs, +// uhcd.h, usbmisc.c, AmiUsbController.h +// +// 127 8/22/12 4:59a Wilsonlee +// [TAG] EIP98230 +// [Category] Improvement +// [Description] Set the default of the MaxPacket for endpoint 0 by the +// device speed. +// [Files] usb.c +// +// 126 6/13/12 2:39a Roberthsu +// [TAG] EIP90124 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Insert barcode when pxe option rom running.Barcode will not +// work under dos. +// [RootCause] Because pxe option under legacy mode.Back to efi mode +// barcode after reinit will fail under dos. +// [Solution] In function USB_ReConfigDevice check device initial done. +// [Files] usb.c +// +// 125 5/22/12 10:04a Ryanchou +// [TAG] EIP90154 +// [Category] Improvement +// [Description] Remove the USBSB_EnableSmmPeriodicSmi and +// USBSB_DisableSmmPeriodicSmi hooks. +// [Files] amidef.h, amiusb.c, usb.c, usbsb.c +// +// 124 5/22/12 4:48a Wilsonlee +// [TAG] EIP89641 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] USB Keyboard driver overwrites INT0 vector (address 0:0) +// [RootCause] The Queue Head cross the page boundary. +// [Solution] Added page alignment restriction into memory allocation +// routine. +// [Files] usb.c +// +// 123 5/04/12 6:40a 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 +// +// 122 5/04/12 5:27a 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 +// +// 121 4/24/12 3:36a Wilsonlee +// [TAG] EIP81761 +// [Category] Improvement +// [Description] Determine the limit of devices after checking whether +// this device is reconnected. +// [Files] usb.c +// +// 120 2/16/12 8:53p 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 +// +// 119 1/13/12 4:24a 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 +// +// 118 1/04/12 6:23a Ryanchou +// +// 117 1/04/12 6:22a Ryanchou +// [TAG] EIP78861 +// [Category] Improvement +// [Description] Some device will be disconnected after port +// reset, and reconnected for a while, added 100 ms delay in this case. +// [Files] usb.c +// +// 116 12/26/11 2:24a Roberthsu +// [TAG] EIP74609 +// [Category] Improvement +// [Description] Add check oemskiplist at check port change. +// [Files] usbport.c,usb.c,AmiUsbController.h +// +// 115 12/08/11 1:46a Ryanchou +// [TAG] EIP75441 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] System hangs at 0xB4 after restart from Win7 +// [RootCause] The device does not use standard BOT protocol under +// Windows. +// [Solution] Add the device into bad device table. +// [Files] usb.c usbport.c +// +// 114 11/28/11 8:36p Wilsonlee +// [TAG] EIP73803 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] The mouse can't work under setup after hot-plug. +// [RootCause] The device may fail at the get device descriptor or set +// device configuration. +// [Solution] Add 10 msec delay before getting device descriptor if the +// device is low or full speed and add 2 msec delay after setting the +// device's address. +// [Files] usb.c +// +// 113 11/08/11 8:21a Wilsonlee +// [TAG] EIP74876 +// [Category] New Feature +// [Description] Add USB API for shutdown single USB controller. +// [Files] amiusb.c, amiusb.h, usb.c, usbdef.h, uhcd.c, uhcd.h, +// AmiUsbController.h +// +// 112 11/05/11 7:36a Wilsonlee +// [TAG] EIP64781 +// [Category] New Feature +// [Description] Added SDL token +// SKIP_CARD_READER_CONNECT_BEEP_IF_NO_MEDIA that skip the connect beep if +// no media present in USB card reader. +// [Files] usbport.c, usbmass.c, usb.c, usbdef.h, uhcd.c, usbsrc.sdl +// +// 111 10/25/11 8:23a Wilsonlee +// [TAG] EIP71750 +// [Category] New Feature +// [Description] Support extraUSB device driver hook by elink. +// +// 110 10/25/11 3:51a Ryanchou +// [TAG] EIP70933 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] System hangs at checkpoint 0x98 when webcam plugged +// [RootCause] The webcam return invalid data in configuration +// descriptor. +// [Solution] Get the configuration descriptor twice, the first time is +// to receive the returned configure descriptor to get the total length +// and the second time is to feed the length to the function again. +// [Files] usb.c, usbdef.h +// +// 109 8/08/11 6:59a Ryanchou +// [TAG] EIP54018 +// [Category] New Feature +// [Description] Added USB S5 wake up support. +// [Files] amiusb.c, ehci.c, ohci.c, uhci.c, usb.c, usb.sdl, usbdef.h, +// usbsb.c xhci.c +// +// 108 8/08/11 5:17a Ryanchou +// [TAG] EIP60561 +// [Category] New Feature +// [Description] Add USB timing policy protocol for timing override. +// [Files] ehci.c, guids.c, ohci.c, uhcd.c, uhci.c usb.c, usbdef.h, +// usbhub.c, usbmass.c, UsbPolicy.h, usbport.c usbsrc.sdl +// +// 107 8/05/11 6:18a Ryanchou +// [TAG] EIP60706 +// [Category] Improvement +// [Description] Move gUsbBadDeviceTable into SMRAM. +// [Files] usbport.c, amiusb.c, usb.c, uhcd.c, AmiUsbController.h +// +// 106 7/22/11 5:37a Ryanchou +// [TAG] EIP65385 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] USB mouse can not be detected. +// [RootCause] The device is connected in disconnect progress, port +// reset is not issued. +// [Solution] Remove the code that check device connection in disconnect +// progress. +// [Files] usb.c +// +// 105 7/19/11 5:17a Ryanchou +// [TAG] EIP64498 +// [Category] New Feature +// [Description] Implement EHCI key repeat function. +// [Files] ehci.c, ehci.h, usb.c, usbdef.h +// +// 104 7/15/11 6:11a Ryanchou +// [TAG] EIP38434 +// [Category] New Feature +// [Description] Added USB HID report protocol support. +// [Files] amiusb.c, AmiUsbController.h, amiusbhc.c, efiusbkb.c, +// efiusbkb.h, ehci.c, ohci.c, uhcd.c uhcd.cif, uhci.c, usb.c, usbdef.h, +// usbkbd.c, usbkbd.h, usbms.c, usbrt.cif, usbsb.c, usbsetup.c, +// usbsrc.sdl, xhci.c +// +// 103 7/13/11 2:47a Ryanchou +// [TAG] EIP60460 +// [Category] Improvement +// [Description] Adds a flag when device disconnected during data +// transfer, BIOS will not issue a transfer to the devicce if this flag is +// set. This change is for Fresco USB 3.0 controller. +// [Files] usb.c, usbdef.h, xhci.c, xhci.h +// +// 102 7/12/11 8:09a Ryanchou +// [TAG] EIP56918 +// [Category] New Feature +// [Description] Added CCID device support. +// [Files] amiusb.c, amiusb.h, amiusbrtCCID.h, ehci.c, ohci.c, uhci.c, +// usb.c, UsbCCID.c, usbdef.h, usbrt.cif, usbsetup.c, efiusbccid.c, +// framework.cif, uhcd.c, uhcd.cif, uhcd.h, usbsrc.sdl, AmiusbCCID.h, +// AmiUsbController.h, AmiUSBProtocols.cif +// +// 101 6/22/11 9:36a 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 +// +// 100 6/22/11 1:44a Ryanchou +// [TAG] EIP59738 +// [Category] Improvement +// [Description] Support Block size other than 512 bytes USB HDD in UEFI +// mode. +// [Files] efiusbmass.c, uhci.c, usb.c, usbdef.h, usbmass.c +// +// 99 6/21/11 9:33a Ryanchou +// [TAG] EIP59601 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] USB devices can't be detected if webcam is connected. +// [RootCause] The configuration descriptor length is greater than +// buffer length, the causes the last descriptor is invalid. +// [Solution] If the next descriptor cross the buffer boundary, skip the +// descriptor. +// [Files] usb.c +// +// 98 4/06/11 5:27a Tonylo +// [TAG] EIP52339 +// [Category] New Feature +// [Description] USB changes of USB host safe disabling solution. +// +// 97 4/06/11 1:33a Ryanchou +// [TAG] EIP54782 +// [Category] Improvement +// [Description] Change polling data size of HID devices to max packet +// size of interrupt endpoint. +// [Files] ehci.c, ohci.c, uhci.c, usb.c, usbdef.h, xhci.c +// +// 96 4/06/11 12:49a Ryanchou +// [TAG] EIP51653 +// [Category] New Feature +// [Description] Added an interface that skips specific port +// enumeration. +// [Files] AmiUsbController.h, uhcd.c, uhcd.h, usb.c, usbdef.h, +// usbport.c +// +// 95 3/30/11 8:13a 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 +// +// 94 3/29/11 10:52p Ryanchou +// [TAG] EIP55401 +// [Category] Improvement +// [Description] Improve the USB 3.0 device compatibility. +// [Files] ehci.c, ehci.h, ohci.c, uhci.c, usb.c, usbdef.h, usbhub.c, +// xhci.c +// +// 93 3/29/11 10:08a Ryanchou +// [TAG] EIP53518 +// [Category] Improvement +// [Description] Added chipset xHCI chip support. +// [Files] amiusb.c, amiusb.h, ehci.c, ohci.c, uhcd.c, uhci.c, usb.c, +// usb.sdl, usbdef.h, usbport, usbsb.c, xhci.c +// +// 92 1/17/11 3:51a Ryanchou +// [TAG] EIP50361 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] Hot plug USB 3.0 flash drive in setup will cause system +// hang. +// [RootCause] The memory may be destroyed if the Address Device command +// fails. +// [Solution] Check the memory has been allocated when free the memory. +// [Files] usb.c xhci.c xhci.h +// +// 91 11/11/10 11:36p Ryanchou +// [TAG] EIP45578 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] USB 3.0 device can't be detected. +// [RootCause] Address Device Command fails. +// [Solution] Reset the device and attempt the Address Device Command +// again. +// [Files] ehci.c, ohci.c, uhci.c, usb.c, usbdef.h, usbhub.c, xhci.c +// +// 90 10/28/10 12:34a Ryanchou +// EIP46865: Comment out unnecessary ASSERT macro. +// +// 89 10/28/10 12:24a Ryanchou +// EIP45643: Fixed system hangs when hot plug USB mass storage quickly on +// USB 3.0 port. +// +// 88 10/21/10 10:12a Ryanchou +// EIP45121: Added xHCI Supported Protocol Capability and fix the problem +// that USB 3.0 device can't be detected. +// +// 87 10/20/10 10:24a Ryanchou +// EIP44702: Added USB 3.0 hub support. +// +// 86 10/20/10 12:55a Ryanchou +// EIP45828: If the flag DEV_INFO_MASS_DEV_REGD is set, check if the +// controller type is difference between old DevInfo and new one. +// +// 85 9/16/10 9:22a Ryanchou +// EIP44149: Disable slot if the Address Device command was unsuccessful. +// +// 84 9/07/10 4:12a Tonylo +// Remove user tags for coding standard. +// +// 83 8/18/10 4:23p Olegi +// Klockwork related fixes; EIP37978 +// +// 82 8/13/10 4:10p Olegi +// Bugfix in CheckDeviceLimit function. EIP41442 +// +// 81 7/15/10 4:39a Tonylo +// EIP15489 - Add USB HandOff function for shurdown/init USB legacy +// through USB API function. +// +// 80 7/13/10 5:09a Ryanchou +// EIP39838: Fixed configure USB hub fail. +// +// 79 7/02/10 1:59a Ryanchou +// Update DevMiscInfo field when hot plug USB mass storage. +// +// 78 6/22/10 9:29a Ryanchou +// EIP39374: Fixed USB mass storage hot plug issue. +// +// 77 6/11/10 1:43a Ryanchou +// EIP36720: Fixed USB keyboard hot plug in setup issue. +// +// 76 5/11/10 11:02a Olegi +// Bugfix in USB_InitDeviceDataDummy; EIP37974 +// +// 75 3/19/10 10:05a Olegi +// +// 74 3/11/10 9:42a Olegi +// +// 73 3/10/10 6:36p Olegi +// +// 72 3/10/10 6:35p Olegi +// +// 71 3/06/10 1:11p Olegi +// +// 70 2/27/10 11:58a Olegi +// Change in the arguments of pfnHCDInitDeviceData function. +// +// 69 2/26/10 4:23p Olegi +// +// 68 2/23/10 1:20p Olegi +// Work around Klockwork issues. EIP34370 +// +// 67 2/08/10 9:38a Olegi +// EIP34448: Bugfix in prepareForLegacyOS. +// +// 66 1/13/10 3:20p Olegi +// Correction in CheckDeviceLimit routine, EIP32804. +// +// 65 12/31/09 9:53a Olegi +// +// 64 12/10/09 10:12a Olegi +// Added UsbControlTimeout setup selection. EIP30079. +// +// 63 11/12/09 6:09p Olegi +// +// 62 11/09/09 5:40p Olegi +// +// 61 10/30/09 5:47p Olegi +// +// 60 10/13/09 8:55a Olegi +// EIP28323: Change in USBGetProperDeviceInfoStructure: +// - Undo the checking for DEV_INFO_DEV_BUS so that in device structure +// re-used. +// +// 59 10/09/09 5:57p Olegi +// +// 58 10/08/09 10:18a Olegi +// EIP28031: USB_SmiQueuePut must not be called after OS booted as it +// modifies the BS memory. +// +// 57 10/07/09 9:48a Olegi +// USB Hub error handling improvement. EIP#25601. +// +// 56 10/02/09 10:49a Olegi +// Code cleanup. +// +// 55 9/15/09 12:21p Olegi +// Added KEY_REPEAT_LOGIC functionality. EIP#25841 +// +// 54 8/26/09 11:41a Olegi +// Changes that prevent collision of keyboard activity and mass storage +// access. EIP#22808 +// +// 53 8/18/09 2:36p Rameshr +// Symptom: When the system is inside the Option rom, connect uSb keyboard +// and it doesn't work. +// Rootcause: In post only EFI driver configure the USB keyboard. So Once +// comes out from option rom Usbkeyboard works. +// Solution: When you are inside the option rom configure the newly +// connected USB keyboard and notify EFI driver. +// +// 52 8/06/09 4:15p Olegi +// Changes related to EIP#23335: connect status change is not maintained +// properly when device is disconnected while connection is in progress. +// +// 51 6/11/09 5:29p Olegi +// Increased the default timeout value to 20 sec. Thermlake external HDD +// is not responding to the first READ_10 command for 14 seconds. +// +// 50 6/04/09 3:42p Olegi +// USB_ConfigureDevice: for the existing devices copy the information +// about the parent controller/hub/port# into the new device structure. +// +// 49 6/01/09 2:48p Olegi +// EIP#22046: while detecting the new device we get the configuration +// descriptor, assuming it is followed by the interface descriptor; if it +// is not an interface descriptor, we used to think it is not the first +// one, so we never send set address and configuration request. +// +// 47 5/08/09 8:56a Olegi +// Increased the timeout value from 5 sec to 10 sec. Several types of +// external USB HDDs require this change to be properly enumerated. +// +// 46 1/29/09 2:32p Olegi +// Added the check for device limit before device is configured. +// +// 44 9/05/08 4:21p Olegi +// fpCallbackNotify4 is replaced with the local function. +// +// 42 5/16/08 12:01p Olegi +// Compliance with AMI coding standard. +// +// 39 10/30/07 12:07p Olegi +// Set configuration one more time: it was found that for some devices +// SET_CONFIGURATION must be the executed right before issuing device +// specific commands. Example is USB Netac Key (VID 0x0644 DID 0x0000). +// +// 38 10/15/07 5:20p Olegi +// Modified USB_on_identifyDev() routine. +// +// 37 9/26/07 9:15a Olegi +// Added USB_FORCE_64BIT_ALIGNMENT flag. +// +// 36 9/06/07 5:59p Olegi +// Added support for 64-byte pool allocation byte alignment. +// +// 35 7/09/07 2:11p Olegi +// Changed the maximum data size of the BulkTransfer from 1kB to 64kB. +// +// 32 5/05/07 1:54p Olegi +// Persistent DOS drives. +// +// 31 4/17/07 8:43a Michaela +// Bugfix in USB_DetectNewDevice function. +// +// 30 4/17/07 8:24a Olegi +// Device detection algorythm update, in sync with Core8. +// +// 24 12/22/06 4:05p Olegi +// Timeout implementation. +// +// 17 4/14/06 6:39p Olegi +// Conversion to be able to use x64 compiler. +// +// 16 3/20/06 3:37p Olegi +// Version 8.5 - x64 compatible. +// +// 14 3/06/06 6:24p Olegi +// Lun devices support modifications: supported using the index in +// DEV_INFO table, not through dedicated massLun table. +// +// 13 3/01/06 3:50p Olegi +// USB_FLAG_RUNNING_UNDER_OS flag added. +// +// 11 1/11/06 11:51a Olegi +// Multi-functional devices handling changed. +// +// 10 12/19/05 10:17a Olegi +// USB_StopHostControllers modified to control the sequence of stopping +// (EHCI first, others follow). +// +// 9 11/03/05 6:31p Andriyn +// LUN Support changes +// +// 7 6/20/05 8:55a Olegi +// .NET compiler with highest warning level and warning-as-error +// modification. +// +// 6 6/16/05 12:19p Andriyn +// Fix usb device lost after boot to legacy OS: don't disable port even if +// device is not +// supported by USBRT: there could be another device at the same address +// +// 5 6/15/05 1:59p Andriyn +// Comments were changed +// +// 4 6/01/05 5:34p Olegi +// Bugfix in USB_DetectNewDevice. +// +// 3 5/17/05 7:51p Andriyn +// USB BUS pre-release +// +// 2 5/10/05 4:11p Andriyn +// USBBUS implementation +// +// 1 3/15/05 9:23a Olegi +// Initial VSS check-in. +// +//**************************************************************************** + +//<AMI_FHDR_START> +//----------------------------------------------------------------------------- +// +// Name: Usb.c +// +// Description: AMI USB main wrapper +// +//----------------------------------------------------------------------------- +//<AMI_FHDR_END> + +#include <Token.h> +#include "amidef.h" +#include "usbdef.h" + +#if USB_RUNTIME_DRIVER_IN_SMM +#include <AmiBufferValidationLib.h> +#include <AmiUsbSmmGlobalDataValidationLib.h> +#endif + +#include <PCI.h> //(EIP54018+) + +BOOLEAN gKeyRepeatStatus = FALSE; +extern BOOLEAN gCheckUsbApiParameter; + +BOOLEAN OEMSkipList(UINT8,UINT8,UINT16,UINT8,UINT8); //(EIP74609+) + +#if USB_DEV_HUB +UINT8 USBHub_EnablePort(HC_STRUC*, UINT8, UINT8); +UINT8 USBHub_DisablePort(HC_STRUC*, UINT8, UINT8); +UINT8 USBHub_ResetPort(HC_STRUC*, UINT8, UINT8); +//VOID USBHubFillDriverEntries (DEV_DRIVER*); //(EIP71750-) +UINT8 USBHub_GetPortStatus (HC_STRUC*, UINT8, UINT8, BOOLEAN); +#endif + +VOID SpeakerBeep (UINT8, UINT16, HC_STRUC*); +VOID FixedDelay(UINTN); +//VOID BusFillDriverEntries(DEV_DRIVER*); //(EIP71750-) + //(EIP38434+)> +//#if USB_DEV_KBD +//VOID USBKBDFillDriverEntries (DEV_DRIVER*); +//#endif +//#if USB_DEV_MOUSE +//VOID USBMSFillDriverEntries (DEV_DRIVER*); +//#endif + //(EIP71750-)> +//VOID USBHIDFillDriverEntries (DEV_DRIVER*); + //<(EIP38434+) +//#if USB_DEV_MASS +//VOID USBMassFillDriverEntries (DEV_DRIVER*); +//#endif +//#if USB_DEV_CCID +//VOID USBCCIDFillDriverEntries (DEV_DRIVER*); +//#endif + //<(EIP71750-) +VOID MemFill (UINT8*, UINT32, UINT8); +VOID MemCopy (UINT8*, UINT8*, UINT32); + +VOID USBAPI_CheckDevicePresence (URP_STRUC*); + +extern USB_BADDEV_STRUC gUsbBadDeviceTable[]; //(EIP60706) + +DEV_INFO* USB_GetDeviceInfoStruc(UINT8, DEV_INFO*, UINT8, HC_STRUC*); //(EIP98145) +VOID* USB_MemAlloc(UINT16); +UINT8 USB_MemFree (VOID*, UINT16); +UINT8* USB_GetDescriptor (HC_STRUC*, DEV_INFO*, UINT8*, UINT16, UINT8 , UINT8); +UINT8 USB_SetAddress(HC_STRUC*,DEV_INFO*, UINT8); +DEV_INFO* USBIdentifyAndConfigureDevice (HC_STRUC* , DEV_INFO* , UINT8* , UINT16 ,UINT16 ); +UINT8 USB_DisconnectDevice (HC_STRUC*, UINT8, UINT8 ); +VOID USB_InitFrameList (HC_STRUC*, UINT32); +DEV_DRIVER* UsbFindDeviceDriverEntry(DEV_DRIVER*); + +UINT8 USB_MemInit (VOID); +UINT8 USBInitHostController(UINT16 *, UINT8); +UINT8 USB_EnumerateRootHubPorts(UINT8); +UINT8 USBLogError(UINT16); +BOOLEAN CheckDeviceLimit(UINT8); +VOID USB_SmiQueuePutMsg(QUEUE_T*, VOID*, int); + + //(EIP54018+)> +UINT32 ReadPCIConfig(UINT16, UINT8); +#if USB_S5_WAKEUP_SUPPORT +VOID DwordWritePCIConfig(UINT16, UINT8, UINT32); +VOID WordWritePCIConfig(UINT16, UINT8, UINT16); +VOID ByteWritePCIConfig(UINT16, UINT8, UINT8); +VOID UsbSbEnablePme(VOID); +#endif + //<(EIP54018+) + +extern USB_GLOBAL_DATA *gUsbData; // Defined in AMIUHCD + +#ifdef USB_CONTROLLERS_INITIAL_DELAY_LIST +typedef struct { + UINT16 Vid; + UINT16 Did; + UINT16 DelayTime; +} CONTROLLERS_INITIAL_DELAY_LIST; + +CONTROLLERS_INITIAL_DELAY_LIST gControllersInitialDelayList[] = {USB_CONTROLLERS_INITIAL_DELAY_LIST}; +#endif + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_StartHostControllers +// +// Description: This function initializes the USB host controllers and +// enumerate the root hub ports for possible USB devices. +// +// Output: fpGlobalDataArea Far pointer to the global data area +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_StartHostControllers(UINT8* fpGlobalDataArea) +{ + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: StopControllerType +// +// Description: This function stops all USB host controllers of a given type +// +// Output: HC type +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +StopControllerType( + UINT8 hc_type +) +{ + UINT8 i; + HC_STRUC* fpHCStruc; + + USB_DEBUG(DEBUG_LEVEL_3, "stopping all HC type %x:", hc_type); + for (i = 0; i < gUsbData->HcTableCount; i++) { + fpHCStruc = gUsbData->HcTable[i]; + if (fpHCStruc == NULL) { + continue; + } + if ((fpHCStruc->bHCType == hc_type) && + (fpHCStruc->dHCFlag & HC_STATE_RUNNING)) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDStop)(fpHCStruc); + USB_DEBUG(DEBUG_LEVEL_3, "."); + } + } + USB_DEBUG(DEBUG_LEVEL_3, "\n"); +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: StartControllerType +// +// Description: This function start all USB host controllers of a given type +// +// Output: HC type +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +StartControllerType( + UINT8 hc_type +) +{ + UINT8 i; + HC_STRUC* fpHCStruc; + + USB_DEBUG(DEBUG_LEVEL_3, "starting all HC type %x:", hc_type); + for (i=0; i<gUsbData->HcTableCount; i++) { + fpHCStruc = gUsbData->HcTable[i]; + if (fpHCStruc == NULL) { + continue; + } + if (!(fpHCStruc->dHCFlag & HC_STATE_USED)) { + continue; + } + if ((fpHCStruc->bHCType == hc_type) ) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDStart)(fpHCStruc); + USB_DEBUG(DEBUG_LEVEL_3, "."); + } + } + USB_DEBUG(DEBUG_LEVEL_3, "\n"); +} + + //(EIP74876+)> +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: StopControllerBdf +// +// Description: This function stops the USB host controllers of a given Bus Dev Function +// +// Input: BusDevFuncNum +// +// Output: None +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +StopControllerBdf( + UINT16 BusDevFuncNum +) +{ + UINT8 i; + HC_STRUC* HcStruc; + + for (i = 0; i < gUsbData->HcTableCount; i++) { + HcStruc = gUsbData->HcTable[i]; + if (HcStruc == NULL) { + continue; + } + if ((HcStruc->wBusDevFuncNum == BusDevFuncNum) && + (HcStruc->dHCFlag & HC_STATE_RUNNING)) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDStop)(HcStruc); + break; + } + } +} + //<(EIP74876+) + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_StopHostControllers +// +// Description: This function stops the USB host controllers and +// frees the data structures associated with the host controllers +// In case of USB2.0 first stop USB1.1 controllers, then USB2.0. +// +// Output: None +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_StopHostControllers (VOID) +{ + // Suppress disconnect beeps as they might be confusing + gUsbData->dUSBStateFlag &= (~USB_FLAG_ENABLE_BEEP_MESSAGE); + + StopControllerType(USB_HC_XHCI); //(EIP52339+) + StopControllerType(USB_HC_UHCI); + StopControllerType(USB_HC_OHCI); + StopControllerType(USB_HC_EHCI); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: UsbHcStart +// +// Description: This function initializes the USB host controller and +// enumerate the root hub ports for possible USB devices. +// +// Input: HcStruc HC struc pointer +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UsbHcStart(HC_STRUC* HcStruc) +{ + UINT8 Index = 0; + + USB_DEBUG(DEBUG_LEVEL_3, "Starting HC %X, HCNum %d, type %x\n", + HcStruc->wBusDevFuncNum, HcStruc->bHCNumber, HcStruc->bHCType); + + // Execute start routine of the host controller driver + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDStart)(HcStruc); + + // Check if the HC is running + if ((HcStruc->dHCFlag & HC_STATE_RUNNING) == 0) { + return USB_ERROR; + } + + for (Index = 0; Index < gUsbData->HcTableCount; Index++) { + if (gUsbData->HcTable[Index] == NULL) { + continue; + } + if (HcStruc == gUsbData->HcTable[Index]) { + continue; + } + if (HcStruc->BaseAddress == gUsbData->HcTable[Index]->BaseAddress) { + break; + } + if (HcStruc->fpFrameList != NULL) { + if (HcStruc->fpFrameList == gUsbData->HcTable[Index]->fpFrameList) { + break; + } + } + if (HcStruc->usbbus_data != NULL) { + if (HcStruc->usbbus_data == gUsbData->HcTable[Index]->usbbus_data) { + break; + } + } +#if USB_RUNTIME_DRIVER_IN_SMM + if (HcStruc->wBusDevFuncNum == gUsbData->HcTable[Index]->wBusDevFuncNum) { + break; + } +#endif + } + + if (Index != gUsbData->HcTableCount) { + HcStruc->dHCFlag &= ~HC_STATE_RUNNING; + return USB_ERROR; + } + + HcStruc->dHCFlag |= HC_STATE_INITIALIZED; + +#if USB_RUNTIME_DRIVER_IN_SMM +#if defined(PI_SPECIFICATION_VERSION)&&(PI_SPECIFICATION_VERSION>=0x0001000A)&&(CORE_COMBINED_VERSION >= 0x4028B) + UpdateAmiUsbSmmGlobalDataCrc32(gUsbData); +#endif +#endif + +#ifdef USB_CONTROLLERS_INITIAL_DELAY_LIST + for (Index = 0; Index < COUNTOF(gControllersInitialDelayList); Index++) { + if ((gControllersInitialDelayList[Index].Vid == HcStruc->Vid) && + (gControllersInitialDelayList[Index].Did == HcStruc->Did)) { + if (gControllersInitialDelayList[Index].DelayTime) { + FixedDelay(gControllersInitialDelayList[Index].DelayTime * 1000); + } + break; + } + } +#endif + + USB_DEBUG(DEBUG_LEVEL_3, "Enumerating HC#%d, type 0x%x\n", HcStruc->bHCNumber, HcStruc->bHCType); + // Issue enumerate call for this HC + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDEnumeratePorts)(HcStruc); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: UsbHcStop +// +// Description: This function stops the USB host controller. +// +// Input: HcStruc HC struc pointer +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UsbHcStop(HC_STRUC* HcStruc) +{ + if ((HcStruc->dHCFlag & HC_STATE_RUNNING) == 0) { + return USB_ERROR; + } + + USB_DEBUG(DEBUG_LEVEL_3, "Stopping HC %X, HCNum %d, type %x\n", + HcStruc->wBusDevFuncNum, HcStruc->bHCNumber, HcStruc->bHCType); + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDStop)(HcStruc); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: CheckBiosOwnedHc +// +// Description: This function checks bios owned hc. +// Clear USB_FLAG_DRIVER_STARTED if we don't start +// any host controller. +// +// Input: None +// +// Output: None +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +CheckBiosOwnedHc( + VOID +) +{ + UINT8 Index; + HC_STRUC *HcStruc; + + for (Index = 0; Index < gUsbData->HcTableCount; Index++) { + HcStruc = gUsbData->HcTable[Index]; + if (HcStruc == NULL) { + continue; + } + if (HcStruc->dHCFlag & HC_STATE_RUNNING) { + return; + } + } + + gUsbData->dUSBStateFlag &= ~(USB_FLAG_DRIVER_STARTED); + + return; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_EnmumerateRootHubPorts +// +// Description: This function enumerates the root hub ports of the all +// selected type HCs +// +// +// Output: bType - HC type +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_EnumerateRootHubPorts (UINT8 bType) +{ + UINT8 Index; + HC_STRUC* fpHCStruc; + + USB_DEBUG(DEBUG_LEVEL_4, "Enumerating HC Ports.\n"); + for (Index = 0; Index < gUsbData->HcTableCount; Index++) { + // + // Get the HCStruc pointer associated with this controller + // + fpHCStruc = gUsbData->HcTable[Index]; + if (fpHCStruc == NULL) { + continue; + } + + if((fpHCStruc->bHCType) == bType && (fpHCStruc->dHCFlag & HC_STATE_RUNNING)) { + USB_DEBUG(DEBUG_LEVEL_3, "Enumerating HC#%d, type 0x%x\n", fpHCStruc->bHCNumber, bType); + // + // Issue enumerate call for this HC + // + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(bType)].pfnHCDEnumeratePorts)(fpHCStruc); + } + } + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_InitHostControllers +// +// Description: This function initializes the specified type of the HC +// from the provided list of host controller PCI addresses +// +// Output: pHCPCIAddrList Pointer to table of HC PCI addresses in the system +// bHCType Type of HC to be initialized (EHCI, OHCI etc) +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBInitHostController( + UINT16 * pHCPCIAddrList, + UINT8 bHCType) +{ + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_GetHubPortStatus +// +// Description: This function returns the hub port status +// +// Input: HcStruc HC struc pointer +// HubAddr USB device address of the hub or HC number +// BIT7 = 1/0 Roothub/Hub +// PortNum Port number +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_GetHubPortStatus ( + HC_STRUC* HcStruc, + UINT8 HubAddr, + UINT8 PortNum, + BOOLEAN ClearChangeBits +) +{ + // + // Check whether the request is for root hub or generic hub + // + if (HubAddr & BIT7) { + // Root hub + return (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDGetRootHubStatus)( + HcStruc, PortNum, ClearChangeBits); + } else { + #if USB_DEV_HUB + return USBHub_GetPortStatus (HcStruc, HubAddr, PortNum, ClearChangeBits); + #else + return 0; + #endif + } +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_DisableHubPort +// +// Description: This function disables the hub port +// +// Output: fpHCStruc HC struc pointer +// bHubAddr USB device address of the hub or HC number +// BIT7 = 1/0 Roothub/Hub +// bPortNum Port number +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_DisableHubPort( + HC_STRUC* fpHCStruc, + UINT8 bHubAddr, + UINT8 bPortNum) +{ + // + // Check whether the request is for root hub or generic hub + // + if (bHubAddr & BIT7) { + // + // Issue the disable root hub call to disable the hub port + // + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDDisableRootHub)( + fpHCStruc, + bPortNum); +#if USB_DEV_HUB + } + else { + USBHub_DisablePort (fpHCStruc, bHubAddr, bPortNum); +#endif + } + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_EnableHubPort +// +// Description: This function enables the hub port +// +// Output: fpHCStruc HC struc pointer +// bHubAddr USB device address of the hub or HC number +// BIT7 = 1/0 Roothub/Hub +// bPortNum Port number +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_EnableHubPort ( + HC_STRUC* fpHCStruc, + UINT8 bHubAddr, + UINT8 bPortNum) +{ + // + // Check whether the request is for root hub or generic hub + // + if (bHubAddr & BIT7) { + // + // Root hub + // Issue the disable root hub call to disable the hub port + // + return (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDEnableRootHub)(fpHCStruc, bPortNum); + } else { + #if USB_DEV_HUB + return USBHub_EnablePort (fpHCStruc, bHubAddr, bPortNum); + #else + return USB_ERROR; // Only root hub could be successfully enabled + #endif + } +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_ResetHubPort +// +// Description: This function resets the hub port +// +// Input: HcStruc HC struc pointer +// HubAddr USB device address of the hub or HC number +// BIT7 = 1/0 Roothub/Hub +// PortNum Port number +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_ResetHubPort ( + HC_STRUC* HcStruc, + UINT8 HubAddr, + UINT8 PortNum) +{ + // + // Check whether the request is for root hub or generic hub + // + if (HubAddr & BIT7) { + // + // Root hub + // Issue the reset root hub call to reset the hub port + // + return (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDResetRootHub)(HcStruc, PortNum); + } else { + #if USB_DEV_HUB + return USBHub_ResetPort (HcStruc, HubAddr, PortNum); + #else + return USB_ERROR; // Only root hub could be successfully reset + #endif + } +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_DetectNewDevice +// +// Description: This function checks the port status provided and depending +// on the status it invokes device connect/disconnect routine +// +// Output: fpHCStruc Pointer to HCStruc +// bHubAddr For root port this is the host controller index +// in gUsbData->aHCStrucTable combined with BIT7; +// For devices connected to a hub this is parent +// hub USB address +// bHubPort Parent hub port number +// bPortStatus Port status read +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +DEV_INFO* +USB_DetectNewDevice( + HC_STRUC* fpHCStruc, + UINT8 bHubAddr, + UINT8 bHubPort, + UINT8 bPortStatus +) +{ + UINT8 bErrorFlag = 0; + UINT16 wDescLength; + UINT8 bDevConfigured; + UINTN ConfigLevel = 0; + UINT16 wTotalLength; + UINT8 *fpBuffer = NULL; + DEV_INFO *fpDevInfo, + *fPointer; + DEV_DESC *fpDevDesc; + CNFG_DESC *fpCnfgDesc; + INTRF_DESC *fpIntrfDesc; + UINT8 *DevMiscInfo; + UINT8 Status; + BOOLEAN SkipConnectBeep = FALSE; //(EIP64781+) + UINT16 OrgTimeOutValue; //(EIP75441+) + UINT8 DeviceAddress; + + // + // Get the temporary device info structure pointer (index 0) + // + fpDevInfo = gUsbData->aDevInfoTable; + + // + // Fill the necessary entries in the device info + // + fpDevInfo->Flag = DEV_INFO_VALID_STRUC; + fpDevInfo->bDeviceAddress = 0; + //fpDevInfo->wEndp0MaxPacket = 0x40; //(EIP98230-) + fpDevInfo->bDeviceType = 0; + fpDevInfo->wIncompatFlags = 0; + fpDevInfo->DevMiscInfo = NULL; + + // + // Fill the hub/host controller information + // + fpDevInfo->bHubDeviceNumber = bHubAddr; + fpDevInfo->bHubPortNumber = bHubPort; + + // + // Fill the device speed + // +USB_DEBUG(DEBUG_LEVEL_3, "USB_DetectNewDevice: wPS = %x\n", bPortStatus); + fpDevInfo->bEndpointSpeed = (bPortStatus & USB_PORT_STAT_DEV_SPEED_MASK) >> + USB_PORT_STAT_DEV_SPEED_MASK_SHIFT; + + //(EIP98145+)> +#if SHOW_SKIP_PORT_INFORMATION +{ + UINT8 i; + DEV_INFO *tmpDevInfo; + tmpDevInfo = fpDevInfo; + USB_DEBUG(3, "==== SHOW_SKIP_PORT_INFORMATION ==== \n"); + USB_DEBUG(DEBUG_LEVEL_3, "BDF %x \nRoutePath = ",fpHCStruc->wBusDevFuncNum); + for(i=0;i<5;i++) + { + if(tmpDevInfo->bHubDeviceNumber & BIT7) + { + USB_DEBUG(3, "\nRootPort %x \n",tmpDevInfo->bHubPortNumber); + break; + } + USB_DEBUG(3, "%x ",tmpDevInfo->bHubPortNumber); + tmpDevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_ADDR, 0, tmpDevInfo->bHubDeviceNumber, 0); + if(tmpDevInfo == NULL) break; + } + USB_DEBUG(3, "==== SHOW_SKIP_PORT_INFORMATION ==== \n"); +} +#endif + //<(EIP98145+) + //(EIP98230+)> + switch (fpDevInfo->bEndpointSpeed) { + case USB_DEV_SPEED_SUPER_PLUS: + case USB_DEV_SPEED_SUPER: + fpDevInfo->wEndp0MaxPacket = 0x200; + break; + case USB_DEV_SPEED_HIGH: + fpDevInfo->wEndp0MaxPacket = 0x40; + break; + case USB_DEV_SPEED_FULL: + case USB_DEV_SPEED_LOW: + fpDevInfo->wEndp0MaxPacket = 0x08; + break; + } + //<(EIP98230+) + + // + // Fill the HC struc index value + // + fpDevInfo->bHCNumber = fpHCStruc->bHCNumber; + + bErrorFlag = TRUE; // Assume as error + bDevConfigured = FALSE; // No device configured + + // + // Allocate memory for device requests + // + ConfigLevel = USB_ERR_DEV_INIT_MEM_ALLOC; // For proper error handling + fpBuffer = USB_MemAlloc (GET_MEM_BLK_COUNT(MAX_CONTROL_DATA_SIZE)); + if (fpBuffer == NULL) { + SpeakerBeep(8, 0x2000, fpHCStruc); + return (DEV_INFO*)ConfigLevel; + } + ConfigLevel = USB_ERR_DEV_INIT_GET_DESC_8; + + // Initialize HC specific data before device configuration + Status = (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDInitDeviceData)( + fpHCStruc, fpDevInfo, bPortStatus, &DevMiscInfo); + if(Status != USB_SUCCESS) { + USB_MemFree(fpBuffer, (UINT8)(MAX_CONTROL_DATA_SIZE / sizeof(MEM_BLK))); + SpeakerBeep(8, 0x2000, fpHCStruc); + return (DEV_INFO*)ConfigLevel; + } + fpDevInfo->DevMiscInfo = (VOID*)DevMiscInfo; + +// +// Next send a GetDescriptor command to the device to get its Device +// Descriptor. Assume a MaxPacket size of 64 bytes (the device will use 8, +// 16, 32, or 64). Regardless of the packet size used by te device we can +// always get the real MaxPacket size that the device is using, because +// this piece of information is at offset 7 in the device descriptor. +// + OrgTimeOutValue = gUsbData->wTimeOutValue; //(EIP75441+) + gUsbData->wTimeOutValue = 1000; //(EIP75441+) + + fpDevDesc = (DEV_DESC*)USB_GetDescriptor( + fpHCStruc, + fpDevInfo, + fpBuffer, + 8, + DESC_TYPE_DEVICE, + 0); + + gUsbData->wTimeOutValue = OrgTimeOutValue; //(EIP75441+) + if(fpDevDesc == NULL) { + goto detection_complete; + } + + // + // Get and store the endpoint 0 max packet size + // + ConfigLevel = USB_ERR_DEV_INIT_SET_ADDR; + // + // Endpoint 0 max packet size check. + // CyQ've USB modem(Model:MQ4UFM560) return invalid device descriptor after + // warm reset. + // + //(EIP81612)> + if (fpDevDesc->BcdUsb >= 0x0300) { + fpDevInfo->wEndp0MaxPacket = (UINT16)1 << fpDevDesc->MaxPacketSize0; + } else { + fpDevInfo->wEndp0MaxPacket = (fpDevDesc->MaxPacketSize0)? + (UINT16)fpDevDesc->MaxPacketSize0 : 0x40; + } + //<(EIP81612) + //(EIP73803)> + if((fpDevInfo->bEndpointSpeed == USB_DEV_SPEED_LOW) || + (fpDevInfo->bEndpointSpeed == USB_DEV_SPEED_FULL) || + (fpDevInfo->bEndpointSpeed == USB_DEV_SPEED_HIGH)){ + FixedDelay(10 * 1000); // 10msec delay + } + //<(EIP73803) + + //To assign an address to a USB device, the USB device transitions the state + //from the Default to the Address state. + for (DeviceAddress = 1; DeviceAddress < 64; DeviceAddress++) { + if (gUsbData->DeviceAddressMap & Shl64(1, DeviceAddress)) { + break; + } + } + + if (DeviceAddress == 64) { + goto detection_complete; + } + Status = USB_SetAddress(fpHCStruc, fpDevInfo, DeviceAddress); + if (Status == USB_ERROR) { + goto detection_complete; + } + gUsbData->DeviceAddressMap &= ~(Shl64(1, DeviceAddress)); + fpDevInfo->bDeviceAddress = DeviceAddress; + FixedDelay(2 * 1000); + + // + // Now send a GetDescriptor command to the device to get its device descriptor. + // + fpDevDesc = (DEV_DESC*)USB_GetDescriptor( + fpHCStruc, + fpDevInfo, + fpBuffer, + 18, + DESC_TYPE_DEVICE, + 0); + + //ASSERT(fpDevDesc != NULL); + if (fpDevDesc == NULL) { + goto detection_complete; + } + // If a descriptor returns with a value in its length field that is + // less than defined by USB specification, the descriptor is invalid. + if (fpDevDesc->DescLength < 18) { + goto detection_complete; + } + if (fpDevDesc->NumConfigs == 0) { + fpDevDesc->NumConfigs = 1; + } + + MemCopy((UINT8*)fpDevDesc, (UINT8*)&fpDevInfo->DevDesc, sizeof(DEV_DESC)); + + ConfigLevel = USB_ERR_DEV_INIT_GET_DESC_200; + // + // Get the relevant information from the descriptor and store it in + // device information struture + // + fpDevInfo->wVendorId = fpDevDesc->VendorId; + fpDevInfo->wDeviceId = fpDevDesc->DeviceId; +// +// Look at each of the device's ConfigDescriptors and InterfaceDescriptors +// until an InterfaceDescriptor is found with BaseClass, SubClass, and +// Protocol fields indicating boot keyboard, mouse, hub or storage support. +// + fpDevInfo->bConfigNum = 0; + + if (fpDevInfo->bEndpointSpeed == USB_DEV_SPEED_FULL) { + FixedDelay(100); + } + + do { // For processing multiple configurations + //(EIP70933+)> + fpCnfgDesc = (CNFG_DESC*)USB_GetDescriptor( + fpHCStruc, + fpDevInfo, + fpBuffer, + 0xFF, + DESC_TYPE_CONFIG, + fpDevInfo->bConfigNum); + if(fpCnfgDesc == NULL) { + break; + } + wTotalLength = fpCnfgDesc->wTotalLength; + if (wTotalLength > 0xFF) { + if(wTotalLength > (MAX_CONTROL_DATA_SIZE - 1)) { + wTotalLength = MAX_CONTROL_DATA_SIZE - 1; + } + fpCnfgDesc = (CNFG_DESC*)USB_GetDescriptor( + fpHCStruc, + fpDevInfo, + fpBuffer, + wTotalLength, + DESC_TYPE_CONFIG, + fpDevInfo->bConfigNum); + //<(EIP70933+) + if(fpCnfgDesc == NULL) { + break; + } + } + if (fpDevInfo->bEndpointSpeed == USB_DEV_SPEED_FULL) { + FixedDelay(100); + } +// +// fpCnfgDesc should now point to a ConfigDescriptor. Verify this and +// then get some fields out of it. Then point to the next descriptor. +// + if(fpCnfgDesc->bDescType == DESC_TYPE_CONFIG) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDEnableEndpoints)( + fpHCStruc, fpDevInfo, (UINT8*)fpCnfgDesc); + + //wTotalLength = fpCnfgDesc->wTotalLength; //(EIP70933-) + wDescLength = (UINT8)fpCnfgDesc->bDescLength; + fpDevInfo->bConfigNum = fpCnfgDesc->bConfigValue; + + //(EIP70933-)> +/* + if(wTotalLength > (MAX_CONTROL_DATA_SIZE - 1)) { + wTotalLength = MAX_CONTROL_DATA_SIZE - 1; + } +*/ + //<(EIP70933-) + + // Check if the device has alternate setting for the interface. + for (;wDescLength < wTotalLength;) { + // + // fpIntrfDesc should now point to an InterfaceDescriptor. Verify this + // and then check its BaseClass, SubClass, and Protocol fields for + // usable devices. + // + fpIntrfDesc = (INTRF_DESC*)((UINT8*)fpCnfgDesc + wDescLength); + //(EIP59601+)> + if ((fpIntrfDesc->bDescLength == 0) || + ((fpIntrfDesc->bDescLength + wDescLength) > wTotalLength)) { + break; + } + if ((fpIntrfDesc->bDescType == DESC_TYPE_INTERFACE) && (fpIntrfDesc->bAltSettingNum != 0)) { + fpDevInfo->Flag |= DEV_INFO_ALT_SETTING_IF; + break; + } + if (fpIntrfDesc->bDescLength) { + wDescLength += (UINT16)fpIntrfDesc->bDescLength; + } else { + break; + } + } + + wDescLength = (UINT8)fpCnfgDesc->bDescLength; + + for (;wDescLength < wTotalLength;) { + // + // fpIntrfDesc should now point to an InterfaceDescriptor. Verify this + // and then check its BaseClass, SubClass, and Protocol fields for + // usable devices. + // + fpIntrfDesc = (INTRF_DESC*)((UINT8*)fpCnfgDesc + wDescLength); + //(EIP59601+)> + if ((fpIntrfDesc->bDescLength == 0) || + ((fpIntrfDesc->bDescLength + wDescLength) > wTotalLength)) { + break; + } + //<(EIP59601+) + if ((fpIntrfDesc->bDescType == DESC_TYPE_INTERFACE) && (fpIntrfDesc->bAltSettingNum == 0)) { + fpDevInfo->bInterfaceNum = fpIntrfDesc->bInterfaceNum; + fpDevInfo->bAltSettingNum = 0; + //USB_DEBUG(DEBUG_LEVEL_6, "USBIdentifyAndConfigureDevice::fpIntrfDesc %lx\n",fpIntrfDesc); + USB_DEBUG(DEBUG_LEVEL_3, "USBIdentifyAndConfigureDevice:: %04x/%04x Intrf %d, AltSetting %d\n", + fpDevInfo->wVendorId, fpDevInfo->wDeviceId, fpIntrfDesc->bInterfaceNum, fpIntrfDesc->bAltSettingNum); + USB_DEBUG(3, "fpCnfgDesc %x, wDescLength 0x%x, wTotalLength 0x%x\n", fpCnfgDesc, wDescLength, wTotalLength); + fPointer = USBIdentifyAndConfigureDevice( + fpHCStruc, + fpDevInfo, + (UINT8*)fpCnfgDesc, + wDescLength, + wTotalLength); + if(fPointer != NULL) { + fpDevInfo = fPointer; + bDevConfigured = TRUE; // At-least one device is configured + //(EIP64781+)> + if(gUsbData->dUSBStateFlag & USB_FLAG_SKIP_CARD_READER_CONNECT_BEEP) { + if(fpDevInfo->bBaseClass == BASE_CLASS_MASS_STORAGE) { + SkipConnectBeep = TRUE; + } + } + //<(EIP64781+) + } + //(EIP22046+)> + // + // There is one more config. Set device info structure entry 0 for it + // + if ((fpCnfgDesc->bNumInterfaces > 1) && bDevConfigured) { + gUsbData->aDevInfoTable[0].Flag |= DEV_INFO_MULTI_IF; + } + //<(EIP22046+) + } + if (fpIntrfDesc->bDescLength && + !(fpIntrfDesc->bDescType == DESC_TYPE_INTERFACE && + fpIntrfDesc->bBaseClass == BASE_CLASS_HUB)) { + wDescLength += (UINT16)fpIntrfDesc->bDescLength; + if (wDescLength < wTotalLength) { + //(EIP22046-)> + // + // There is one more config. Set device info structure entry 0 for it + // + /* + if (fpDevInfo->bInterfaceNum > 0) { + fpDevInfo->Flag |= DEV_INFO_MULTI_IF; + } + gUsbData->aDevInfoTable[0].Flag |= DEV_INFO_MULTI_IF; + */ + //<(EIP22046-) + fpDevInfo = gUsbData->aDevInfoTable; + } + } else { + break; // fpIntrfDesc->bDescLength == 0 + } + } // while () + } // if + // + // Check if we have at least one usable device + // + if (bDevConfigured) { + bErrorFlag = FALSE; // Device successfully configured + ConfigLevel = (UINTN)gUsbData->aDevInfoTable; + goto detection_complete; + } + else { + fpDevInfo->bConfigNum++; + } + } while (fpDevInfo->bConfigNum < fpDevInfo->DevDesc.NumConfigs); // while + +detection_complete: + // + // At this point, if bErrorFlag is FALSE then we successfully configured + // atleast a device. + // If bErrorFlag is TRUE then there is error in configuring the device + // + if (bErrorFlag) { + USBLogError((UINT16)ConfigLevel); // Log configuration level + + SpeakerBeep(8, 0x2000, fpHCStruc); + + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDDeinitDeviceData) + (fpHCStruc, fpDevInfo); + if(ConfigLevel != USB_ERR_DEV_INIT_GET_DESC_8) { + // + // Disable the hub port + // + USB_DisableHubPort( + fpHCStruc, + fpDevInfo->bHubDeviceNumber, + fpDevInfo->bHubPortNumber); + ConfigLevel = 0; + } + if (fpDevInfo->bDeviceAddress) { + gUsbData->DeviceAddressMap |= Shl64(1, fpDevInfo->bDeviceAddress); + } + } + else { + //(EIP64781+)> + if(!SkipConnectBeep) { + SpeakerBeep(4, 0x1000, fpHCStruc); + } + //<(EIP64781+) + } + USB_MemFree(fpBuffer, (UINT8)(MAX_CONTROL_DATA_SIZE / sizeof(MEM_BLK))); + + return (DEV_INFO*)ConfigLevel; + +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_StopDevice +// +// Description: This function stops the device: +// - calls its disconnect function if available +// - stops polling the device's interrupt endpoint +// - updates device address memory map +// +// +// Output: fpHCStruc Pointer to HCStruc +// bHCNubAddr Hub address +// bHCPort Port number +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_StopDevice( + HC_STRUC* fpHCStruc, + UINT8 bHubAddr, + UINT8 bHCPort) +{ + UINT8 bCount; + DEV_DRIVER* fpDevDriver; + DEV_INFO* fpDevice; + UINT8 Status; + + Status = USB_ERROR; + // + // Find the device entry that would match the input. + // + for (bCount = 1; bCount < MAX_DEVICES; bCount++) + { + fpDevice = &gUsbData->aDevInfoTable[bCount]; + if((fpDevice->Flag & (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_DUMMY)) == + DEV_INFO_VALID_STRUC) { + if((fpDevice->bHubDeviceNumber == bHubAddr) && + (fpDevice->bHubPortNumber == bHCPort)) + { + // + // Device found - issue disconnect call for the device + // + if (gUsbData->dUSBStateFlag & USB_FLAG_RUNNING_UNDER_EFI) { + if (!(fpDevice->Flag & DEV_INFO_IN_QUEUE)) { + USB_SmiQueuePut(fpDevice); + fpDevice->Flag |= DEV_INFO_IN_QUEUE; + } + } + + fpDevDriver = UsbFindDeviceDriverEntry(fpDevice->fpDeviceDriver); + // + // Check disconnect function is valid, if yes - execute it + // + if (fpDevDriver && fpDevDriver->pfnDisconnectDevice) + { + fpDevDriver->pfnDisconnectDevice(fpDevice); + fpDevice->fpDeviceDriver = NULL; + } else { + // + // Stop polling the device's interrupt endpoint + // + if (fpDevice->IntInEndpoint) { + Status = (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDDeactivatePolling) + (fpHCStruc, fpDevice); + fpDevice->IntInEndpoint = 0; + } + } + + // HC device removal call + Status = (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDDeinitDeviceData) + (fpHCStruc, fpDevice); + + // Reset the disconnecting flag + fpDevice->Flag &= ~DEV_INFO_DEV_DISCONNECTING; + + // + // Update Device Address Map, preserving the address for registered devices + // + gUsbData->DeviceAddressMap |= Shl64(1, fpDevice->bDeviceAddress); + fpDevice->Flag &= ~DEV_INFO_DEV_PRESENT; + if (!(fpDevice->Flag & (DEV_INFO_DEV_BUS | DEV_INFO_MASS_DEV_REGD))) { + // Reset the device info structure validity ~flag + fpDevice->Flag &= ~DEV_INFO_VALID_STRUC; + } + USB_DEBUG(3, "Release Dev[%d]: %x, flag %x\n", bCount, fpDevice, fpDevice->Flag); + } + } + } + return Status; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_DisconnectDevice +// +// Description: This function is called when a device disconnect is +// detected. This routine disables the hub port and stops the +// device and its children by calling another routine. +// +// Output: fpHCStruc Far pointer to HCStruc of the host controller +// bHubAddr USB device address of the hub whose status +// has changed +// bit 7 : 1 - Root hub, 0 for other hubs +// bit 6-0 : Device address of the hub +// bPortNum Port number +// +// Output: Status: USB_SUCCESS = Success +// USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_DisconnectDevice( + HC_STRUC* fpHCStruc, + UINT8 bHubAddr, + UINT8 bHCPort) +{ + // + // A device has been disconnected from the USB. First disable the hub port + // that the device was plugged into. Then free up the device's entry in the + // DeviceTable. If there an error occurs while disabling the port, assume + // that the device is still present an leave its DeviceTable entry in place. + // + USB_DisableHubPort(fpHCStruc, bHubAddr, bHCPort); + + USB_StopDevice(fpHCStruc, bHubAddr, bHCPort); + + return USB_SUCCESS; + +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Procedure: USBCheckPortChange +// +// Description: This routine processes the port status change (like connect, +// disconnect, etc.) for the root hub and external hubs. +// +// Output: HcStruc Pointer to Host Controller structure +// HubAddr Device address of the hub whose status +// has changed: +// bit 7 : 1 - Root hub, 0 for other hubs +// bit 6-0 : Device address of the hub +// PortNum Hub port number +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBCheckPortChange ( + HC_STRUC *HcStruc, + UINT8 HubAddr, + UINT8 PortNum +) +{ + UINT8 PortStatus; + DEV_INFO *Dev; + UINT8 Count; + + for (Count = 0; Count < 5; Count++) { + PortStatus = USB_GetHubPortStatus(HcStruc, HubAddr, PortNum, TRUE); + + // + // Check the obtained port status + // + if (PortStatus == USB_ERROR) { + return USB_ERROR; + } + if (!(PortStatus & USB_PORT_STAT_DEV_OWNER)) { + return USB_SUCCESS; + } + if (OEMSkipList(HubAddr,PortNum,HcStruc->wBusDevFuncNum,0,0)) { + USB_DEBUG(3, "Match the skip table ; skipping this device.\n"); //(EIP98145) + return USB_SUCCESS; + } + if (!Count && !(PortStatus & USB_PORT_STAT_DEV_CONNECT_CHANGED)) { + return USB_SUCCESS; + } + + if (PortStatus & USB_PORT_STAT_DEV_CONNECTED) { + if (gUsbData->bHandOverInProgress) { + USB_DisableHubPort(HcStruc, HubAddr, PortNum); + return USB_SUCCESS; + } + if ((Count != 0) || !(PortStatus & USB_PORT_STAT_DEV_ENABLED)) { + // Reset and enable the port + USB_ResetHubPort(HcStruc, HubAddr, PortNum); + USB_EnableHubPort(HcStruc, HubAddr, PortNum); + PortStatus = USB_GetHubPortStatus(HcStruc, HubAddr, PortNum, TRUE); + + if (PortStatus == USB_ERROR) { + return USB_ERROR; + } + if (!(PortStatus & USB_PORT_STAT_DEV_OWNER)) { + return USB_SUCCESS; + } + if (!(PortStatus & USB_PORT_STAT_DEV_CONNECTED)) { + // Some device will be disconnected after + // port reset, and reconnected for a while. + FixedDelay(100 * 1000); + continue; + } + // Check whether port is enabled + if (!(PortStatus & USB_PORT_STAT_DEV_ENABLED)) { + FixedDelay(100 * 1000); // 100msec delay + continue; + } + } + Dev = USB_DetectNewDevice(HcStruc, HubAddr, PortNum, PortStatus); + if ((UINTN)Dev == USB_ERR_DEV_INIT_GET_DESC_8) { + FixedDelay(100 * 1000); // 100msec delay + continue; + } + if ((UINTN)Dev == 0) { + return USB_ERROR; + } + if ((UINTN)Dev > USB_ERR_DEV_INIT_GET_DESC_200) { + return USB_SUCCESS; + } + SpeakerBeep(16, 0x4000, HcStruc); // Issue error beep + return USB_ERROR; + } else { // Disconnect + USB_DisconnectDevice(HcStruc, HubAddr, PortNum); + SpeakerBeep(8, 0x1000, HcStruc); + return USB_SUCCESS; + } + } + if (Count == 5) { + USB_DisableHubPort(HcStruc, HubAddr, PortNum); + return USB_ERROR; + } + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_MemAlloc +// +// Description: This routine allocates blocks of memory from the global +// memory pool +// +// Output: bNumBlocks Number of 32 byte blocks needed +// +// Output: Start offset to the allocated block (NULL on error) +// +// NOTES: This routine allocates continuous 32 byte memory blocks. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID _FAR_ * +USB_MemAlloc(UINT16 wNumBlk) +{ + UINT8 bMemIsFound = FALSE, + bBitCount = 0, + bStart = 0; + UINT16 wCount; + UINT16 Count = 0; // Contiguous blocks counter + + UINT16 BlkOffset = 0, + wMapDwordPtr; + //(EIP89641)> + UINT16 PageCount = 0; + UINT16 MapDwordCount = 0; + UINT32 BlksStsDwordsPerPage = 0; + + UINT32 dMask, + dTemp; + + if (wNumBlk == 0) return NULL; + +#if USB_FORCE_64BIT_ALIGNMENT + if (wNumBlk % 2) wNumBlk++; +#endif + wCount = wNumBlk; + + BlksStsDwordsPerPage = (gUsbData->MemBlkStsBytes >> 2) / gUsbData->MemPages; + + // + // Locate wNumBlk contiguous blocks from each memory page + // + for(PageCount = 0; (PageCount < gUsbData->MemPages) && !bMemIsFound; PageCount++) { + + // Do not reset the counter if the allocated blocks greater than a page. + if (wNumBlk <= (0x1000 / sizeof(MEM_BLK))) { + Count = 0; // Reset contiguous blocks counter + } + + for (MapDwordCount = 0; MapDwordCount < BlksStsDwordsPerPage; MapDwordCount++) { + // + // Read the next DWORD memory map data + // + wMapDwordPtr = (PageCount * BlksStsDwordsPerPage) + MapDwordCount; + dTemp = gUsbData->aMemBlkSts[wMapDwordPtr]; + + for (bBitCount = 0; bBitCount < 32; bBitCount++) { + BlkOffset++; + if (dTemp & (UINT32)(1 << bBitCount)) { + Count++; // Found another free block + if(Count == wCount) { + BlkOffset = (UINT16)(BlkOffset-Count); + bMemIsFound = TRUE; + break; // Found the requested number of free blocks + } + } + else + { + Count = 0; // Reset contiguous blocks counter + } + } + if (bMemIsFound) break; + } + } + //<(EIP89641) + if (!bMemIsFound) { + ASSERT(FALSE); + return NULL; + } + +// +// Change the appropriate bits in the memory map to indicate that some memory +// is being allocated +// +// At this point, +// bBitCount points to the end of the block within DWORD +// wMapDwordPtr points to the status dword in question + +// We have to reset bCount number of bits starting from +// wMapDwordPtr[bBitCount] to wStsX[BitPosY] +// where wStsX is the status double word of the starting block, +// BitPosY is the bit position of the starting block. +// + USB_DEBUG(DEBUG_LEVEL_4, "wMapDwordPtr = %d\n", wMapDwordPtr); +// +// Let us have a do loop to do the trick +// + do { + // + // Find out how many bits we can reset in current (pointed by wMapDwordPtr) + // double word + // + Count = (UINT16)((bBitCount >= (wCount-1)) ? wCount : bBitCount+1); + // + // Find out the starting bit offset + // + bStart = (UINT8)(bBitCount + 1 - Count); + // + // Form the 32bit mask for the AND operation + // First prepare the bits left on the left + // + // Note: FFFFFFFF << 32 treated differently by different compilers; it + // results as 0 for 16 bit compiler and FFFFFFFF for 32 bit. That's why + // we use caution while preparing the AND mask for the memory map update. + // + dMask = ((Count + bStart) < 32) ? (0xFFFFFFFF << (Count + bStart)) : 0; + + // + // Second, prepare the bits on the right + // + if (bStart) + { + dMask = dMask | ~(0xFFFFFFFF << bStart); + } + + // + // Reset the specified number of bits + // + gUsbData->aMemBlkSts[wMapDwordPtr] &= dMask; + + // + // Update the bCount, StsWordCount & BitCount + // + bBitCount = 31; // End of previous double word where we have to start + wMapDwordPtr--; // Previous double word + wCount = wCount - Count; + } while ( wCount ); + + USB_DEBUG(DEBUG_LEVEL_4, "MemAlloc: %d block(s) at %x %x %x\n", + wNumBlk, + gUsbData->fpMemBlockStart + BlkOffset * sizeof(MEM_BLK), + gUsbData->aMemBlkSts[0], + gUsbData->aMemBlkSts[1]); + + return ((VOID _FAR_ *) + (gUsbData->fpMemBlockStart + (UINT32)BlkOffset * sizeof(MEM_BLK))); +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_MemFree +// +// Description: This routine frees the chunk of memory allocated using +// the USBMem_Alloc call +// +// Output: fpPtr Pointer to the memory block to be freed +// bNumBlocks Number of 32 byte blocks to be freed +// +// Output: Start offset to the allocated block (NULL on error) +// +// NOTES: This routine frees continuous memory blocks starting +// from the fpPtr. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_MemFree ( + VOID _FAR_ * fpPtr, + UINT16 wNumBlk) +{ + UINT8 bOffset, bCount; + UINT16 wBlkCount, wBlkOffset, wStsWord; + +#if USB_FORCE_64BIT_ALIGNMENT + if (wNumBlk % 2) wNumBlk++; +#endif + wBlkCount = wNumBlk; + wBlkOffset = 0; + + // + // Check for pointer validity + // + if (fpPtr == NULL) return USB_ERROR; + + if ((fpPtr < (VOID *)gUsbData->fpMemBlockStart) || + (fpPtr > (VOID *)(gUsbData->fpMemBlockStart + + (MEM_BLK_COUNT+1)*sizeof(MEM_BLK)))) { + return USB_ERROR; + } + + wBlkOffset = (UINT16)((UINTN)fpPtr - (UINTN)gUsbData->fpMemBlockStart) / sizeof (MEM_BLK); + + if (wBlkOffset >= MEM_BLK_COUNT) { + return USB_ERROR; + } + + wStsWord = (UINT16)(wBlkOffset >> 5); // Divide by 32 + bOffset = (UINT8)(wBlkOffset & 0x1F); // Mod 32 + bCount = 0; + + do { + gUsbData->aMemBlkSts[wStsWord] |= ((UINT32)1 << (bCount + bOffset)); + wBlkCount--; + bCount++; + + if ((bCount + bOffset) && (!((bCount + bOffset) & 0x1F))) { + wStsWord ++; + bCount = bOffset = 0; + } + } while (wBlkCount); + + USB_DEBUG(DEBUG_LEVEL_4, "MemFree: %d block(s) at %x %x %x\n", + wNumBlk, fpPtr, + gUsbData->aMemBlkSts[0], gUsbData->aMemBlkSts[1]); + // + // Pointer is valid. Fill the memory with 0's + // + MemFill (fpPtr, (UINT32)(wNumBlk * sizeof (MEM_BLK)), 0); + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_InstallCallBackFunction +// +// Description: This function adds a new callback function to the globall +// callback function list and returns the index of it. +// +// Output: pfnCallBackFunction Callback function address +// +// Output: Callback function index +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_InstallCallBackFunction ( + CALLBACK_FUNC CallBackFunction +) +{ + UINT8 Index; + // + // Check whether this function is already installed or none found + // + for (Index = 0; Index < MAX_CALLBACK_FUNCTION; Index++) { + // + // Check for null entry + // + if (gUsbData->aCallBackFunctionTable[Index] == 0) { + break; // No entry found + } + + if (gUsbData->aCallBackFunctionTable[Index] == CallBackFunction) { + return (UINT8)(Index+1); + } + } + + ASSERT(Index != MAX_CALLBACK_FUNCTION); + if (Index == MAX_CALLBACK_FUNCTION) { + EFI_DEADLOOP(); // Exceeding max # of callback function is illegal + } else { + // + // Store the call back function + // + gUsbData->aCallBackFunctionTable[Index] = CallBackFunction; + } + + return (UINT8)(Index + 1); +} + +DEV_DRIVER* +UsbFindDeviceDriverEntry( + DEV_DRIVER* DevDriver +) +{ + UINTN Index; + + if (DevDriver == NULL) { + return DevDriver; + } + + for (Index = 0; Index < MAX_DEVICE_TYPES; Index++) { + if (DevDriver == &gUsbData->aDevDriverTable[Index]) { + return &gUsbData->aDevDriverTable[Index]; + } + if (DevDriver == &gUsbData->aDelayedDrivers[Index]) { + return &gUsbData->aDelayedDrivers[Index]; + } + } + + return NULL; + +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_GetDescriptor +// +// Description: This function executes a get descriptor command to the +// given USB device and endpoint +// +// Output: fpHCStruc HCStruc pointer +// fpDevInfo Device info pointer +// fpBuffer Buffer to be used for the transfer +// wLength Size of the requested descriptor +// bDescType Requested descriptor type +// bDescIndex Descriptor index +// +// Output: Pointer to memory buffer containing the descriptor +// NULL on error +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8* +USB_GetDescriptor( + HC_STRUC* fpHCStruc, + DEV_INFO* fpDevInfo, + UINT8* fpBuffer, + UINT16 wLength, + UINT8 bDescType, + UINT8 bDescIndex) +{ + UINT8 bGetDescIteration; + UINT16 wReg, + wStatus; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return NULL; + } + + EfiStatus = UsbDevInfoValidation(fpDevInfo); + + if (EFI_ERROR(EfiStatus)) { + return NULL; + } + +#if USB_RUNTIME_DRIVER_IN_SMM + if (gCheckUsbApiParameter) { + EfiStatus = AmiValidateMemoryBuffer((VOID*)fpBuffer, wLength); + if (EFI_ERROR(EfiStatus)) { + return NULL; + } + gCheckUsbApiParameter = FALSE; + } +#endif + //(EIP60640)> + for (bGetDescIteration = 0; bGetDescIteration < 5; bGetDescIteration++) { + wReg = (UINT16)((bDescType << 8) + bDescIndex); + wStatus = (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDControlTransfer)( + fpHCStruc, + fpDevInfo, + (UINT16)USB_RQ_GET_DESCRIPTOR, + (UINT16)0, + wReg, + fpBuffer, + wLength); + if (wStatus) { + return fpBuffer; + } + if (gUsbData->dLastCommandStatusExtended & USB_TRNSFR_TIMEOUT) { + break; + } + FixedDelay(10 * 1000); + } + //<(EIP60640) + return NULL; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_SetAddress +// +// Description: This function sets the USB device address of device 0 to +// the given value. After this call the USB device will respond +// at its new address. +// +// Output: fpHCStruc Pointer to HCStruc structure +// fpDevInfo Pointer to device info structure +// bNewDevAddr New device address to set +// +// Output: USB_SUCCESS or USB_ERROR +// +// Notes: Skip SET_ADDRESS request for XHCI controllers +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_SetAddress( + HC_STRUC* fpHCStruc, + DEV_INFO* fpDevInfo, + UINT8 bNewDevAddr) +{ + //(EIP60640)> + UINT8 SetAddressIteration; + + for (SetAddressIteration = 0; SetAddressIteration < 5; SetAddressIteration++) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(fpHCStruc->bHCType)].pfnHCDControlTransfer)( + fpHCStruc, + fpDevInfo, + (UINT16)USB_RQ_SET_ADDRESS, + 0, + (UINT16)bNewDevAddr, + 0, + 0); + if (!(gUsbData->bLastCommandStatus & USB_CONTROL_STALLED )) { + USB_DEBUG(DEBUG_LEVEL_5, "USB_SetAddress#%d\n",bNewDevAddr); + return USB_SUCCESS; + } + } + return USB_ERROR; + //<(EIP60640) +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_SetConfig +// +// Description: This function sets the device configuration. +// +// Input: HcStruc Pointer to HCStruc structure +// DevInfo Pointer to device info structure +// ConfigNum Configuration Value +// +// Output: USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_SetConfig( + HC_STRUC* HcStruc, + DEV_INFO* DevInfo, + UINT8 ConfigNum) +{ + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDControlTransfer)( + HcStruc, + DevInfo, + USB_RQ_SET_CONFIGURATION, + 0, + (UINT16)ConfigNum, + 0, + 0); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: UsbSetInterface +// +// Description: This function sets the device interface. +// +// Input: HcStruc Pointer to HCStruc structure +// DevInfo Pointer to device info structure +// InterfaceNum Interface Value +// +// Output: USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UsbSetInterface( + HC_STRUC* HcStruc, + DEV_INFO* DevInfo, + UINT8 InterfaceNum +) +{ + USB_DEBUG(3, "UsbSetInterface %d\n", InterfaceNum); + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDControlTransfer)( + HcStruc, + DevInfo, + USB_RQ_SET_INTERFACE, + 0, + (UINT16)InterfaceNum, + 0, + 0); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USBLogError +// +// Description: This routine logs the USB error in the data area. This +// logged errors will be displayed during the POST. +// +// Output: wErrorCode Error code to log +// +// Output: USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBLogError(UINT16 wErrorCode) +{ + // + // First check for end of the buffer + // + if(gUsbData->bErrorLogIndex < MAX_USB_ERRORS_NUM) + { + // + // Still have space to log errors + // + gUsbData->aErrorLogBuffer[gUsbData->bErrorLogIndex] = wErrorCode; + gUsbData->bErrorLogIndex++; + } + return USB_ERROR; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_GetDeviceInfoStruc +// +// Description: This function is used to retrieve the device info structure +// for the particular device address & HCStruc +// +// Output: bSearchFlag Flag indicating search type +// = USB_SRCH_DEV_ADDR to search by device address and +// HCStruc pointer +// = USB_SRCH_DEV_TYPE to search by device type +// = USB_SRCH_HC_STRUC to search by HC struc pointer +// = USB_SRCH_DEV_NUM to count the number of devices connected: +// if fpHCStruc is not NULL - count only devices connected to +// certain controller, otherwise - all devices of requested +// type. +// = USB_SERCH_DEV_INDX to search by device location in the DEV_INFO: +// a) if fpDevInfo <> 0 return index or the fpDevInfo +// b) if bDevAddr <> 0 return the corresponding fpDevInfo +// c) if both bDevAddr <> 0 and fpDevInfo <> 0, consider a) +// +// fpDevInfoPtr Pointer to the device info structure from where the +// search begins (if 0 start from first entry) +// bDev Device address/drive number/device type +// pHCStruc Pointer to the HCStruc structure +// +// Output: Depending on bSearchFlag this function returns: +// - pointer to DEV_INFO structure +// - table index +// - number of devices +// Function returns NULL if device is not found. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +DEV_INFO* +USB_GetDeviceInfoStruc( + UINT8 bSearchFlag, + DEV_INFO* fpDev_Info, + UINT8 bDev, + HC_STRUC* fpHcStruc +) +{ + UINT8 Index; + BOOLEAN TerminateSearch = FALSE; + UINT32 dDeviceCounter = 0; + + if (bSearchFlag == USB_SRCH_DEV_INDX) { + if (fpDev_Info) { + for (Index=1; Index < MAX_DEVICES; Index++) { + if (&gUsbData->aDevInfoTable[Index] == fpDev_Info) { + return (DEV_INFO*)(UINTN)Index; + } + } + return NULL; // Device address not found in the table + } + if (bDev == USB_HOTPLUG_FDD_ADDRESS) return &gUsbData->FddHotplugDev; + if (bDev == USB_HOTPLUG_HDD_ADDRESS) return &gUsbData->HddHotplugDev; + if (bDev == USB_HOTPLUG_CDROM_ADDRESS) return &gUsbData->CdromHotplugDev; + + if (bDev) return &gUsbData->aDevInfoTable[bDev]; + return NULL; // Invalid input - both bDev and fpDevInfo are zeroes. + } + + for (Index = 1; Index < MAX_DEVICES; Index ++) { + // + // if fpDev_Info is not null then position the search at the correct + // index that matches the fpDev_Info + // + if (fpDev_Info) { + if (&gUsbData->aDevInfoTable[Index] != fpDev_Info) + continue; + else { + fpDev_Info = 0; + continue; + } + } + // + // For USB_SRCH_DEVBASECLASS_NUM devices are counted regardless of their + // DEV_INFO_VALID_STRUC flag + // + if (bSearchFlag == USB_SRCH_DEVBASECLASS_NUM) + { + if(gUsbData->aDevInfoTable[Index].bBaseClass == bDev) { + if (fpHcStruc) { + // + // Check if device belongs to the specified HC + // + if (gUsbData->aDevInfoTable[Index].bHCNumber != fpHcStruc->bHCNumber) + { + continue; + } + } + if (gUsbData->aDevInfoTable[Index].Flag & DEV_INFO_DEV_PRESENT) + { + dDeviceCounter++; + } + } + continue; + } + + if ((gUsbData->aDevInfoTable[Index].Flag & DEV_INFO_VALIDPRESENT) == + DEV_INFO_VALIDPRESENT){ + switch(bSearchFlag) { + case USB_SRCH_HC_STRUC: + if (fpHcStruc == NULL) return NULL; + if (gUsbData->HcTable + [gUsbData->aDevInfoTable[Index].bHCNumber-1] == fpHcStruc) { + TerminateSearch = TRUE; + } + break; + + case USB_SRCH_DEV_TYPE: + if (gUsbData->aDevInfoTable[Index].bDeviceType == bDev) { + TerminateSearch = TRUE; + } + break; + case USB_SRCH_DEV_NUM: + if (gUsbData->aDevInfoTable[Index].bDeviceType == bDev) { + if (fpHcStruc) { + // + // Check if device belongs to the specified HC + // + if (gUsbData->aDevInfoTable[Index].bHCNumber != fpHcStruc->bHCNumber) + { + break; + } + } + dDeviceCounter++; + } + break; // Do not change TerminateSearch so loop continues + case USB_SRCH_DEV_ADDR: + if (gUsbData->aDevInfoTable[Index].bDeviceAddress == bDev) { + if ((fpHcStruc == NULL) || + (gUsbData->HcTable + [gUsbData->aDevInfoTable[Index].bHCNumber-1] == fpHcStruc)) { + TerminateSearch = TRUE; + } + } + break; + + default: + return NULL; + } + } + if (TerminateSearch) return ((DEV_INFO*)&gUsbData->aDevInfoTable[Index]); + } + if ( (bSearchFlag == USB_SRCH_DEV_NUM) || (bSearchFlag == USB_SRCH_DEVBASECLASS_NUM) ) + return (DEV_INFO*)(UINTN)dDeviceCounter; + + return NULL; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// PROCEDURE: UsbAllocDevInfo +// +// Description: Finds a non-used DEV_INFO record in aDevInfoTable and marks it +// reserved. To free the user need to clear DEV_INFO_VALID_STRUC +// bit in bFlag of DEV_INFO +// +// Output: Pointer to new device info. struc. 0 on error +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +DEV_INFO* UsbAllocDevInfo() +{ + UINT8 bIndex; + DEV_INFO *fpNewDevInfo; + + for (bIndex = 1; bIndex < MAX_DEVICES; bIndex ++){ + fpNewDevInfo = gUsbData->aDevInfoTable +bIndex; + if ((fpNewDevInfo->Flag & + ( DEV_INFO_VALID_STRUC | DEV_INFO_DEV_BUS)) == 0 ){ + // + // Free device info structure. Save it if not. + // + fpNewDevInfo->Flag |= DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT; + return fpNewDevInfo; + } + } + return NULL; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBGetProperDeviceInfoStructure +// +// Description: This routine searches for a device info structure that +// matches the vendor and device id, and LUN of the device +// found. If such a device info structure not found, then it +// will return a free device info structure +// +// Input: Vendor, Device ID, Current LUN +// +// Output: Pointer to new device info. struc. NULL on error +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +DEV_INFO* +USBGetProperDeviceInfoStructure( + DEV_INFO* Dev, + UINT8 Lun) +{ + UINT8 bCount; + DEV_INFO *fpDevInfo, *fpFreeDevInfo; + + fpFreeDevInfo = NULL; + +// +// Scan through the device info table for a free entry. Also if the device +// connected is a mass storage device look for a device info structure whose +// device is disconnected and its vendor & device id matches the one of +// current device. If such a structure found that means this device may be +// reconnected - use the same structure +// + for (bCount = 1; bCount < MAX_DEVICES; bCount++) + { + fpDevInfo = (DEV_INFO*) &gUsbData->aDevInfoTable[bCount]; + + if (fpDevInfo->Flag & DEV_INFO_DEV_DUMMY) { + continue; + } + + // Check whether the structure is valid + if (!(fpDevInfo->Flag & DEV_INFO_VALID_STRUC)) { + if (fpFreeDevInfo == NULL) { + fpFreeDevInfo = fpDevInfo; // Store the value of the free device info + } + } else { + // + // Yes, structure is valid. Check for device presence + // + if (fpDevInfo->Flag & DEV_INFO_DEV_PRESENT) { + if ((fpDevInfo->bHubDeviceNumber != Dev->bHubDeviceNumber) || + (fpDevInfo->bHubPortNumber != Dev->bHubPortNumber)) { + continue; + } + } + // + // Device is not present. Match the vendor, device id and LUN with + // current device info + // + if ((fpDevInfo->wVendorId == Dev->wVendorId) && + (fpDevInfo->wDeviceId == Dev->wDeviceId) && + (fpDevInfo->bInterfaceNum == Dev->bInterfaceNum) && + (fpDevInfo->bEndpointSpeed == Dev->bEndpointSpeed) && + (fpDevInfo->bLUN == Lun)) { + return fpDevInfo; // "Abandoned" device entry found + } + } + } + return fpFreeDevInfo; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// PROCEDURE: USB_ConfigureDevice +// +// Description: This routine completes the USB device configuration for +// the devices supported by USB BIOS. This routine +// handles the generic configuration for the devices. +// +// Output: pHCStruc HCStruc pointer +// pDevInfo Device information structure pointer +// pDesc Pointer to the descriptor structure +// wStart Offset within interface descriptor +// supported by the device +// wEnd End offset of the device descriptor +// +// Output: Pointer to new device info. struc. 0 on error +// +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +DEV_INFO* +USB_ConfigureDevice ( + HC_STRUC* HcStruc, + DEV_INFO* DevInfo, + UINT8* Desc, + UINT16 Start, + UINT16 End +) +{ + DEV_INFO *NewDevInfo; + + NewDevInfo = USBGetProperDeviceInfoStructure(DevInfo, 0); + + if (NewDevInfo == NULL) { + return NULL; + } + // + // Check whether this device is reconnected by checking the valid + // structure flag + // + if (NewDevInfo->Flag & DEV_INFO_VALID_STRUC) { + USB_DEBUG(DEBUG_LEVEL_3, "USB_ConfigureDevice: Existing device.\n"); + // + // This device is reconnected. Reuse the old device address so that + // INT13h can identify this drive properly + // + DevInfo->Flag |= NewDevInfo->Flag; + NewDevInfo->wDataInSync = 0; + NewDevInfo->wDataOutSync = 0; + } + else { + // + // Check whether we reached the limit of devices of this type + // + if (CheckDeviceLimit(DevInfo->bBaseClass) == TRUE) { + return NULL; + } + } + + // + // For registered devices skip updating bFlag + // + if (!(NewDevInfo->Flag & DEV_INFO_MASS_DEV_REGD)) { + // + // Since DeviceInfo[0] already has many fields filled in, the new entry + // should be initialized with a copy of DeviceInfo[0]. But, the new + // DeviceInfo should not be marked as "present" until the device + // is successfully initialized. + // + // Copy old DeviceInfo struc to new DeviceInfo struc and zero device[0] + // + MemCopy ((UINT8*)DevInfo, (UINT8*)NewDevInfo, sizeof (DEV_INFO)); + NewDevInfo->Flag &= DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT | + DEV_INFO_MASS_DEV_REGD | DEV_INFO_DEV_BUS | + DEV_INFO_IN_QUEUE | DEV_INFO_ALT_SETTING_IF; + } else { + // Change the parent HC number and port number in the existing DEV_INFO + NewDevInfo->bHCNumber = DevInfo->bHCNumber; + NewDevInfo->bHubDeviceNumber = DevInfo->bHubDeviceNumber; + NewDevInfo->bHubPortNumber = DevInfo->bHubPortNumber; + NewDevInfo->bEndpointSpeed = DevInfo->bEndpointSpeed; + NewDevInfo->wEndp0MaxPacket = DevInfo->wEndp0MaxPacket; + NewDevInfo->DevMiscInfo = DevInfo->DevMiscInfo; + NewDevInfo->bDeviceAddress = DevInfo->bDeviceAddress; + } + + // + // Do a SetConfiguration command to the device to set it to its + // HID/Boot configuration. + // + NewDevInfo->Flag |= DEV_INFO_VALIDPRESENT; + if (!(DevInfo->Flag & DEV_INFO_MULTI_IF)) { + USB_SetConfig(HcStruc, NewDevInfo, NewDevInfo->bConfigNum); + if (DevInfo->Flag & DEV_INFO_ALT_SETTING_IF) { + UsbSetInterface(HcStruc, NewDevInfo, NewDevInfo->bAltSettingNum); + } + } + + USB_DEBUG(3, "new dev: %x, flag: %x, addr %d\n", + NewDevInfo, NewDevInfo->Flag, NewDevInfo->bDeviceAddress); + + return NewDevInfo; + +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBCheckNonCompliantDevice +// +// Description: This function checks for non-compliant USB devices by +// by comparing the device's vendor and device id with +// the non-compliant device table list and updates the +// data structures appropriately to support the device. +// +// Input: fpHCStruc - HCStruc pointer +// fpDevInfo - Device information structure pointer +// fpDesc - Pointer to the descriptor structure +// wDescLength - End offset of the device descriptor +// +// Output: Updated fpDevInfo->wIncompatFlags field +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID +USBCheckNonCompliantDevice( + HC_STRUC* fpHCStruc, + DEV_INFO* fpDevInfo, + UINT8* fpDesc, + UINT16 wLength, + UINT16 wDescLength +) +{ + USB_BADDEV_STRUC *fpBadDevice; + INTRF_DESC *fpIntrfDesc; + + fpIntrfDesc = (INTRF_DESC*)((UINT8*)fpDesc + wLength); + + // + // Search the bad device table to get the structure for this device + // + for (fpBadDevice = gUsbBadDeviceTable; + fpBadDevice->wDID | fpBadDevice->wVID; fpBadDevice++) { + + if ((fpBadDevice->wDID != fpDevInfo->wDeviceId) || + (fpBadDevice->wVID != fpDevInfo->wVendorId)) { + continue; + } +USB_DEBUG(DEBUG_LEVEL_3, "Found non-compatible device: DID=%x, VID=%x\n", fpBadDevice->wDID, fpBadDevice->wVID); + // + // Save the incompatibility flag into device info structure + // + fpDevInfo->wIncompatFlags = fpBadDevice->wFlags; + + // + // Check which fields to update in the interface descriptor + // + // Check for base class field + // + if (fpBadDevice->bBaseClass) { + // + // Update base class field in the interface descriptor + // + fpIntrfDesc->bBaseClass = fpBadDevice->bBaseClass; + } + // + // Check for base sub class field + // + if (fpBadDevice->bSubClass) { + // + // Update sub class field in the interface descriptor + // + fpIntrfDesc->bSubClass = fpBadDevice->bSubClass; + } + // + // Check for protocol field + // + if (fpBadDevice->bProtocol) { + // + // Update protocol field in the interface descriptor + // + fpIntrfDesc->bProtocol = fpBadDevice->bProtocol; + } + break; + } +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// PROCEDURE: USBIdentifyAndConfigureDevice +// +// Description: This routine invokes the device drivers 'check device type' +// routine and identifies the device type. +// +// Output: pHCStruc HCStruc pointer +// pDevInfo Device information structure pointer +// pDesc Pointer to the descriptor structure +// wStart Offset within interface descriptor +// supported by the device +// wEnd End offset of the device descriptor +// +// Output: Pointer to new device info. struc, NULL on error +// +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +DEV_INFO* +USBIdentifyAndConfigureDevice ( + HC_STRUC* fpHCStruc, + DEV_INFO* fpDevInfo, + UINT8* fpDesc, + UINT16 wLength, + UINT16 wDescLength) +{ + UINT8 bBaseClass, bSubClass, bProtocol, + bIndex, bRetValue; + DEV_INFO* fpDevInfoLocal; + DEV_DRIVER* fpDevDriver; + INTRF_DESC* fpIntrfDesc; + + // + // Check for non-compliant device. If non-compliant device found then + // the descriptor values will get updated depending on the need. + // + USBCheckNonCompliantDevice ( + fpHCStruc, + fpDevInfo, + fpDesc, + wLength, + wDescLength); + + USB_DEBUG(DEBUG_LEVEL_3, "USBIdentifyAndConfigureDevice..."); + + // + // Check whether device needs to be disable + // + if (fpDevInfo->wIncompatFlags & USB_INCMPT_DISABLE_DEVICE) { + USB_DEBUG(DEBUG_LEVEL_3, "not compatible device.\n"); + return NULL; + } + + fpIntrfDesc = (INTRF_DESC*)(fpDesc + wLength); + +//(EIP74609+)> + if(OEMSkipList(fpDevInfo->bHubDeviceNumber,fpDevInfo->bHubPortNumber,fpHCStruc->wBusDevFuncNum,fpIntrfDesc->bBaseClass,1)) { + USB_DEBUG(3, "Match the skip table ; skipping this device.\n"); //(EIP98145) + return NULL; + } +//<(EIP74609+) + // + // Get the base, sub class & protocol values + // + bBaseClass = fpIntrfDesc->bBaseClass; + bSubClass = fpIntrfDesc->bSubClass; + bProtocol = fpIntrfDesc->bProtocol; + + // + // Check for matching device driver + // + fpDevInfoLocal = NULL; + bRetValue = USB_ERROR; + + //(EIP96616+)> + for (bIndex = 0; bIndex < MAX_DEVICE_TYPES; bIndex ++) { + fpDevDriver = &gUsbData->aDevDriverTable[bIndex]; + // + // Check structure validity + // + if (!fpDevDriver->bDevType) { + continue; // Driver table not valid + } + // + // Verify presence of Check Device routine + // + if (fpDevDriver->pfnCheckDeviceType) { + // + // Check device type is implemented. Execute it! + // + bRetValue = (*fpDevDriver->pfnCheckDeviceType)( + fpDevInfo,bBaseClass, + bSubClass,bProtocol); + if (bRetValue != USB_ERROR) + break; + } else { + // + // Check device type is not implemented. Compare the class codes + // + if((fpDevDriver->bBaseClass == bBaseClass) || + (fpDevDriver->bSubClass == bSubClass) || + (fpDevDriver->bProtocol == bProtocol)) { + // + // If the class codes match set bRetValue with the bDevType from the Device Driver + // + bRetValue = fpDevDriver->bDevType; + break; + } + } + } + if(bRetValue != USB_ERROR){ + // + // Check whether we reached the limit of devices of this type + // + //if (CheckDeviceLimit(bBaseClass) == TRUE) continue; //(EIP81761-) + + // + // Set the device type in the Device Info structure + // + fpDevInfo->bDeviceType = bRetValue; + + // + // Set Base Class, Subclass and Protocol information + // + fpDevInfo->bBaseClass = bBaseClass; + fpDevInfo->bProtocol = bProtocol; + fpDevInfo->bSubClass = bSubClass; + + // + // Device identified. Issue common configure call + // Call a common routine to handle the remaining initialization that is done + // for all devices. + // + fpDevInfoLocal = USB_ConfigureDevice( + fpHCStruc, + fpDevInfo, + fpDesc, + wLength, + wDescLength); + + if (fpDevInfoLocal == NULL) { + USB_DEBUG(DEBUG_LEVEL_3, "USB: Common configure failed.\n"); + return fpDevInfoLocal; + } + + if (gUsbData->dUSBStateFlag & USB_FLAG_RUNNING_UNDER_EFI) { + if (!(fpDevInfoLocal->Flag & DEV_INFO_IN_QUEUE)) { + USB_SmiQueuePut(fpDevInfoLocal); + fpDevInfoLocal->Flag |= DEV_INFO_IN_QUEUE; + } + } + + fpDevInfoLocal->fpDeviceDriver = fpDevDriver; + fpDevInfoLocal = (*fpDevDriver->pfnConfigureDevice)( + fpHCStruc, + fpDevInfoLocal, + fpDesc, + wLength, + wDescLength); + if (!fpDevInfoLocal || + !(fpDevInfoLocal->Flag & DEV_INFO_VALID_STRUC) ) + { + fpDevInfoLocal = 0; + USB_DEBUG(DEBUG_LEVEL_3, "USB: Device specific configure failed.\n"); + return fpDevInfoLocal; + } + + //<(EIP96616+) + } + + USB_DEBUG(DEBUG_LEVEL_3, "%x\n", fpDevInfoLocal); + + return fpDevInfoLocal; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: USB_InitFrameList +// +// Description: This routine initializes the frame list pointed by fpPtr +// with the dValue provided +// +// Output: fpHCStruc Pointer to the Host Controller structure +// dValue Value to be initialized with +// +// Output: Nothing +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + + +VOID +USB_InitFrameList( + HC_STRUC* fpHCStruc, + UINT32 dValue) +{ + UINT16 wIndex; + UINT32 *fpPtr = (UINT32*)fpHCStruc->fpFrameList; + + for (wIndex = 0; wIndex < fpHCStruc->wAsyncListSize; wIndex ++) { + fpPtr[wIndex] = dValue; + } + return; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBKeyRepeat +// +// Description: This function handles different key repeat related functions +// depending on the input +// +// Input: fpHCStruc - pointer for the HC that implements the key repeat function +// bAction - sub-function index: +// 0 Install key repeat HCStruc +// 1 Disable key repeat +// 2 Enable key repeat +// 3 Uninstall key repeat HCStruc +// +// Output: None +// +// Note: fpHCStruc is only relevant for sub-function 0. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBKeyRepeat( + HC_STRUC* HcStruc, + UINT8 Action +) +{ + +//USB_DEBUG(DEBUG_LEVEL_3, "KR%d\n", bAction); + UINT8 i; + + switch (Action) { + case 0: // Sub-function 0: Save the HCStruc value for later use + if (gKeyRepeatStatus == FALSE) { + gUsbData->fpKeyRepeatHCStruc = HcStruc; + } + break; + case 1: // Sub-function 0: Disable key repeat + if (gKeyRepeatStatus) { +#if USB_HID_KEYREPEAT_USE_SETIDLE == 1 + if (gUsbData->fpKeyRepeatDevInfo != NULL) { + // + // Set the HID SET_IDLE request to 0 + // + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(gUsbData->HcTable[gUsbData->fpKeyRepeatDevInfo->bHCNumber - 1]->bHCType)].pfnHCDControlTransfer) + (gUsbData->HcTable[gUsbData->fpKeyRepeatDevInfo->bHCNumber - 1], + gUsbData->fpKeyRepeatDevInfo,(UINT16)HID_RQ_SET_IDLE, gUsbData->fpKeyRepeatDevInfo->bInterfaceNum, 0, 0, 0); //(EIP54782) + } +#else + if (gUsbData->fpKeyRepeatHCStruc) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX( + gUsbData->fpKeyRepeatHCStruc->bHCType)].pfnHCDDisableKeyRepeat)( + gUsbData->fpKeyRepeatHCStruc); + } +#endif + gKeyRepeatStatus = FALSE; + } + break; + case 2: // Sub-function 0: Enable key repeat + if (!gKeyRepeatStatus) { +#if USB_HID_KEYREPEAT_USE_SETIDLE == 1 + if(gUsbData->fpKeyRepeatDevInfo != NULL) { + // + // Set the HID SET_IDLE request to 0x200 (8ms) + // + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(gUsbData->HcTable[gUsbData->fpKeyRepeatDevInfo->bHCNumber - 1]->bHCType)].pfnHCDControlTransfer) + (gUsbData->HcTable[gUsbData->fpKeyRepeatDevInfo->bHCNumber - 1], + gUsbData->fpKeyRepeatDevInfo,(UINT16)HID_RQ_SET_IDLE, gUsbData->fpKeyRepeatDevInfo->bInterfaceNum, 0x400, 0, 0); //(EIP54782) + } +#else + if (gUsbData->fpKeyRepeatHCStruc) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX( + gUsbData->fpKeyRepeatHCStruc->bHCType)].pfnHCDEnableKeyRepeat)( + gUsbData->fpKeyRepeatHCStruc); + } +#endif + gKeyRepeatStatus=TRUE; + } + break; + case 3: + if (gUsbData->fpKeyRepeatHCStruc == HcStruc) { + gUsbData->fpKeyRepeatHCStruc = NULL; + for (i = 0; i < gUsbData->HcTableCount; i++) { + if (gUsbData->HcTable[i] == NULL) { + continue; + } + if (gUsbData->HcTable[i] == HcStruc) { + continue; + } + if (gUsbData->HcTable[i]->dHCFlag & HC_STATE_RUNNING) { + gUsbData->fpKeyRepeatHCStruc = gUsbData->HcTable[i]; + if (gKeyRepeatStatus) { + gKeyRepeatStatus = FALSE; + USBKeyRepeat(NULL, 2); + } + break; + } + } + } + break; + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: BusFillDriverEntries +// +// Description: Install drivers that redirects ...???? +// +// Input: fpDevDriver - record that the routine can use to install the drive +// Output: None +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_bus_interrupt_handler ( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo, + UINT8 *Td, + UINT8 *Buffer, + UINT16 DataLength +) +{ + USBHC_INTERRUPT_DEVNINFO_T *Idi = (USBHC_INTERRUPT_DEVNINFO_T *)DevInfo->pExtra; + EFI_STATUS Status = EFI_SUCCESS; + + ASSERT(Idi); + if (Idi == NULL) { + return USB_SUCCESS; + } + +#if USB_RUNTIME_DRIVER_IN_SMM + Status = AmiValidateMemoryBuffer((VOID*)Idi, sizeof(USBHC_INTERRUPT_DEVNINFO_T)); + if (EFI_ERROR(Status)) { + return USB_ERROR; + } +#endif + + USB_SmiQueuePutMsg(&Idi->QCompleted, Buffer, (int)Idi->DataLength); + return USB_SUCCESS; +} + +VOID +UsbBusDeviceInit( + VOID +) +{ + USB_InstallCallBackFunction(USB_bus_interrupt_handler); + return; +} + +DEV_INFO* +USB_on_configDev( + HC_STRUC *fpHCStruc, + DEV_INFO *fpDevInfo, + UINT8 *fpDesc, + UINT16 wStart, + UINT16 wEnd +) +{ + fpDevInfo->bDeviceType = (UINT8)BIOS_DEV_TYPE_USBBUS; + fpDevInfo->bCallBackIndex = USB_InstallCallBackFunction(USB_bus_interrupt_handler); + return(fpDevInfo); +} + +UINT8 +USB_on_identifyDev( + DEV_INFO* fpDevInfo, + UINT8 bBaseClass, + UINT8 bSubClass, + UINT8 bProtocol +) +{ + //(EIP96616+)> + if (gUsbData->dUSBStateFlag & USB_FLAG_RUNNING_UNDER_EFI) + return BIOS_DEV_TYPE_USBBUS; + else + return USB_ERROR; + //<(EIP96616+) +} + +UINT8 +USB_on_disconnectDev( + DEV_INFO* fpDevInfo +) +{ + return USB_SUCCESS; +} + +VOID +BusFillDriverEntries( + DEV_DRIVER *fpDevDriver +) +{ + fpDevDriver->bDevType = BIOS_DEV_TYPE_USBBUS; + fpDevDriver->bBaseClass = 0; + fpDevDriver->bSubClass = 0; + fpDevDriver->bProtocol = 0; + fpDevDriver->pfnDeviceInit = UsbBusDeviceInit; + fpDevDriver->pfnCheckDeviceType = USB_on_identifyDev; + fpDevDriver->pfnConfigureDevice = USB_on_configDev; + fpDevDriver->pfnDisconnectDevice = USB_on_disconnectDev; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USB_ReConfigDevice, USB_ReConfigDevice2 +// +// Description: EFI code will call this function to give a chance for +// SMI dev driver to complete the configuration of device +// +// Before call, USB device is connected, address is assigned +// and configuration is set. DEV_INFO structure is initalized +// from information parsed from descriptors and linked +// to USBBUS dev driver. Device driver specific to the type +// of USB device wasn't called on this device +// +// After the call returns, a specific device driver +// initialization was performed by calling pfnCheckDeviceType +// and pfnConfigureDevice functions of device driver. Parameters +// to those functions are taken from descriptors downloaded from +// the device. Device preserve old address and active configuration +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +int USB_ReConfigDevice2( HC_STRUC* fpHCStruc, DEV_INFO* fpDevInfo, + CNFG_DESC *fpCnfgDesc, + INTRF_DESC * fpIntrfDesc ); + +int USB_ReConfigDevice( HC_STRUC* fpHCStruc, DEV_INFO* fpDevInfo ) +{ + INTRF_DESC *fpIntrfDesc=NULL; + + UINT8 iConfig; + int status = USB_SUCCESS; //(EIP90124) + UINT8* fpBuffer; + CNFG_DESC *fpCnfgDesc=NULL; + UINT16 OrgTimeOutValue; + + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + EfiStatus = UsbDevInfoValidation(fpDevInfo); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + gCheckUsbApiParameter = FALSE; + + if (fpDevInfo->bDeviceType != 0 && + fpDevInfo->bDeviceType != BIOS_DEV_TYPE_USBBUS) { + return USB_SUCCESS; + } + + fpBuffer = USB_MemAlloc (GET_MEM_BLK_COUNT(MAX_CONTROL_DATA_SIZE)); + if (fpBuffer == NULL) { + return USB_ERROR; + } + // + // Find configuration desc + // + for (iConfig = 0; iConfig < fpDevInfo->DevDesc.NumConfigs;++iConfig){ + + OrgTimeOutValue = gUsbData->wTimeOutValue; + gUsbData->wTimeOutValue = USB_GET_CONFIG_DESC_TIMEOUT_MS; + + fpCnfgDesc = (CNFG_DESC*)USB_GetDescriptor( + fpHCStruc, + fpDevInfo, + fpBuffer, + (MAX_CONTROL_DATA_SIZE - 1), + DESC_TYPE_CONFIG, + iConfig); + + gUsbData->wTimeOutValue = OrgTimeOutValue; + + if (fpDevInfo->bEndpointSpeed == USB_DEV_SPEED_FULL) { + FixedDelay(1000); + } + if(fpCnfgDesc != NULL && fpCnfgDesc->bDescType == DESC_TYPE_CONFIG && + fpDevInfo->bConfigNum == fpCnfgDesc->bConfigValue ){ + break; + } + + fpCnfgDesc = NULL; + } + + if( fpCnfgDesc ){ + UINT16 offset; + UINT16 wDescLength; + INTRF_DESC *pIntrf; + + if(fpCnfgDesc->wTotalLength > MAX_CONTROL_DATA_SIZE - 1) + fpCnfgDesc->wTotalLength = MAX_CONTROL_DATA_SIZE - 1; + wDescLength = fpCnfgDesc->wTotalLength; + for(offset=(UINT16)fpCnfgDesc->bDescLength;offset <wDescLength ;offset = offset + (UINT16)pIntrf->bDescLength){ + pIntrf = (INTRF_DESC*)((UINT8*)fpCnfgDesc + offset); + if(pIntrf->bDescLength == 0) { + break; + } + if (pIntrf->bDescType == DESC_TYPE_INTERFACE && + fpDevInfo->bInterfaceNum == pIntrf->bInterfaceNum && + fpDevInfo->bAltSettingNum == pIntrf->bAltSettingNum ) { + fpIntrfDesc =pIntrf; + break; + } + } + } + + USB_DEBUG(DEBUG_LEVEL_3, + "USB_reConfigDev:: CfgDsc=%x; IntrfDsc=%x\n", + fpCnfgDesc, fpIntrfDesc); + + if (fpIntrfDesc && fpCnfgDesc) { + status = USB_ReConfigDevice2(fpHCStruc, fpDevInfo, + fpCnfgDesc, fpIntrfDesc); + } else { + status = USB_ERROR; + } + + USB_MemFree(fpBuffer, (UINT8)(MAX_CONTROL_DATA_SIZE / sizeof(MEM_BLK))); + + return status; +} + +//---------------------------------------------------------------------------- +// USB_ReConfigDevice2 +//---------------------------------------------------------------------------- +int +USB_ReConfigDevice2( + HC_STRUC *fpHCStruc, + DEV_INFO *fpDevInfo, + CNFG_DESC *fpCnfgDesc, + INTRF_DESC *fpIntrfDesc +) +{ +// int abort=0; + int bIndex; + UINT8 bRetValue = USB_ERROR; + DEV_DRIVER *fpDevDriver = NULL; + DEV_INFO *fpDevInfoLocal; + UINT8 bBaseClass, bSubClass, bProtocol; + EFI_STATUS EfiStatus; + + USB_DEBUG(DEBUG_LEVEL_3, "USB_ReConfigDevice2.\n"); + + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + EfiStatus = UsbDevInfoValidation(fpDevInfo); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + +#if USB_RUNTIME_DRIVER_IN_SMM + if (gCheckUsbApiParameter) { + EfiStatus = AmiValidateMemoryBuffer((VOID*)fpCnfgDesc, sizeof(CNFG_DESC)); + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + EfiStatus = AmiValidateMemoryBuffer((VOID*)fpCnfgDesc, fpCnfgDesc->wTotalLength); + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + EfiStatus = AmiValidateMemoryBuffer((VOID*)fpIntrfDesc, sizeof(INTRF_DESC)); + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + gCheckUsbApiParameter = FALSE; + } +#endif + + // + // Check for non-compliant device. If non-compliant device found then + // the descriptor values will get updated depending on the need. + // + USBCheckNonCompliantDevice ( + fpHCStruc, + fpDevInfo, + (UINT8*)fpCnfgDesc, + fpCnfgDesc->bDescLength, + fpCnfgDesc->wTotalLength); + + // + // Check whether device needs to be disable + // + if (fpDevInfo->wIncompatFlags & USB_INCMPT_DISABLE_DEVICE) + { + return USB_ERROR; + } + + // + // Get the base, sub class & protocol values + // + bBaseClass = fpIntrfDesc->bBaseClass; + bSubClass = fpIntrfDesc->bSubClass; + bProtocol = fpIntrfDesc->bProtocol; + + // + // Check for matching device driver + // + fpDevInfoLocal = NULL; + for (bIndex = 0, bRetValue = USB_ERROR; + bIndex < MAX_DEVICE_TYPES && bRetValue == USB_ERROR; bIndex ++) { + fpDevDriver = &gUsbData->aDelayedDrivers[bIndex]; + if (!fpDevDriver->bDevType) + continue; + if (fpDevDriver->pfnCheckDeviceType){ + bRetValue = (*fpDevDriver->pfnCheckDeviceType)( + fpDevInfo,bBaseClass,bSubClass,bProtocol); + }else if((fpDevDriver->bBaseClass == bBaseClass) && + (fpDevDriver->bSubClass == bSubClass) && + (fpDevDriver->bProtocol == bProtocol)){ + bRetValue = fpDevDriver->bDevType; + } + } + if(bRetValue == USB_ERROR) + return bRetValue; + + //driver was found + + fpDevInfo->bDeviceType = bRetValue; + fpDevInfo->fpDeviceDriver = fpDevDriver; + fpDevInfoLocal = (*fpDevDriver->pfnConfigureDevice)( + fpHCStruc,fpDevInfo,(UINT8*)fpCnfgDesc, + (UINT16)(UINTN)((char*)fpIntrfDesc - (char*)fpCnfgDesc),fpCnfgDesc->wTotalLength); + if (!fpDevInfoLocal) + { + USB_DEBUG(DEBUG_LEVEL_0, "USB_ReConfigDevice2: Device specific configure failed.\n"); + return USB_ERROR; + } + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: hcnum2hcstruc +// +// Description: Search for the HC_STRUC with specified bHCNumber +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +HC_STRUC* +hcnum2hcstruc( + UINT8 bHCNumber +) +{ + return gUsbData->HcTable[bHCNumber - 1]; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: prepareForLegacyOS +// +// Description: Changes global state of USBSMI module to function properly +// in non-EFI OS - without support from EFI drivers +// +// Before call USB BUS is a driver that handles all devices ( +// except hub) and rest of the drivers are delayed. Number of +// devices are supported by SUBBUS driver and custom EFI driver +// +// After call returns, USBBUS driver is removed and all drivers +// that where +// delayed became active. All USBBUS devices are reconfigured. +// Devices that are not supported by now active drivers are decon- +// figured. +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +prepareForLegacyOS() +{ + //(EIP96616)> + DEV_INFO* di; + HC_STRUC* fpHCStruc; + DEV_INFO* e = gUsbData->aDevInfoTable + COUNTOF(gUsbData->aDevInfoTable); + int status; + + gCheckUsbApiParameter = FALSE; + + + // + //First Reconfigure all USBBUS device (while drivers are in delayed array) + // + for( di = &gUsbData->aDevInfoTable[1]; di != e; ++di ){ //(EIP34448) + if((di->Flag & DEV_INFO_VALIDPRESENT) == DEV_INFO_VALIDPRESENT && + di->bDeviceType == BIOS_DEV_TYPE_USBBUS ) + { + fpHCStruc = hcnum2hcstruc(di->bHCNumber); + status = USB_ReConfigDevice(fpHCStruc, di ); + if(status == USB_ERROR){ + // + // Release DEV_INFO + // + di->Flag &= ~DEV_INFO_VALIDPRESENT; + } + } + //di->Flag &= ~DEV_INFO_DEV_BUS; + } + //<(EIP96616) + + + USBKeyRepeat(NULL, 1); // Disable key repeat + //gUsbData->dUSBStateFlag |= USB_FLAG_RUNNING_UNDER_OS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USB_ResetAndReconfigDev +// +// Description: This routine resets and reconfigures the device. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 +USB_ResetAndReconfigDev( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo +) +{ + DEV_INFO *Dev; + UINT32 Status; + UINT8 DevAddr; + UINT8 *Buffer; + DEV_DESC *DevDesc; + CNFG_DESC *CnfgDesc; + INTRF_DESC *IntrfDesc; + UINT8 ConfigIndx; + UINT8 IntrfIndx; + DEV_DRIVER *DevDriver; + UINT8 i; + UINT8 PortStatus; + UINT8 *DevMiscInfo; + UINT16 TotalLength; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + EfiStatus = UsbDevInfoValidation(DevInfo); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + gCheckUsbApiParameter = FALSE; + + for (i = 1; i < MAX_DEVICES; i++) { + Dev = &gUsbData->aDevInfoTable[i]; + if ((Dev->Flag & (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT | + DEV_INFO_DEV_DUMMY)) != (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT)) { + continue; + } + if ((Dev->bHubDeviceNumber == DevInfo->bHubDeviceNumber) && + (Dev->bHubPortNumber == DevInfo->bHubPortNumber) && + (Dev->bDeviceType != BIOS_DEV_TYPE_USBBUS)) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX( + HcStruc->bHCType)].pfnHCDDeactivatePolling)(HcStruc, Dev); + } + } + + Status = (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDDeinitDeviceData) + (HcStruc, DevInfo); + if (Status != USB_SUCCESS) { + return Status; + } + + Status = USB_ResetHubPort(HcStruc, DevInfo->bHubDeviceNumber, DevInfo->bHubPortNumber); + if (Status != USB_SUCCESS) { + return Status; + } + + Status = USB_EnableHubPort(HcStruc, DevInfo->bHubDeviceNumber, DevInfo->bHubPortNumber); + if (Status != USB_SUCCESS) { + return Status; + } + + PortStatus = USB_GetHubPortStatus(HcStruc, DevInfo->bHubDeviceNumber, DevInfo->bHubPortNumber, TRUE); + + if (PortStatus == USB_ERROR) { + return USB_ERROR; + } + + if (!(PortStatus & USB_PORT_STAT_DEV_ENABLED)) { + return USB_ERROR; + } + + // Initialize HC specific data before device configuration + Status = (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDInitDeviceData)( + HcStruc, DevInfo, PortStatus, &DevMiscInfo); + if (Status != USB_SUCCESS) { + return Status; + } + + DevInfo->DevMiscInfo = (VOID*)DevMiscInfo; + + Buffer = USB_MemAlloc(GET_MEM_BLK_COUNT(sizeof(DEV_DESC))); + if (Buffer == NULL) { + return USB_ERROR; + } + + DevAddr = DevInfo->bDeviceAddress; + DevInfo->bDeviceAddress = 0; + + DevDesc = (DEV_DESC*)USB_GetDescriptor(HcStruc, DevInfo, Buffer, sizeof(DEV_DESC), + DESC_TYPE_DEVICE, 0); + if(DevDesc == NULL) { + USB_MemFree(Buffer, GET_MEM_BLK_COUNT(sizeof(DEV_DESC))); + return USB_ERROR; + } + + Status = USB_SetAddress(HcStruc, DevInfo, DevAddr); + if (Status != USB_SUCCESS) { + USB_MemFree(DevDesc, GET_MEM_BLK_COUNT(sizeof(DEV_DESC))); + return Status; + } + + DevInfo->bDeviceAddress = DevAddr; + + Buffer = USB_MemAlloc(GET_MEM_BLK_COUNT(MAX_CONTROL_DATA_SIZE)); + if (Buffer == NULL) { + USB_MemFree(DevDesc, GET_MEM_BLK_COUNT(sizeof(DEV_DESC))); + return USB_ERROR; + } + + for (ConfigIndx = 0; ConfigIndx < DevDesc->NumConfigs; ConfigIndx++) { + CnfgDesc = (CNFG_DESC*)USB_GetDescriptor(HcStruc, DevInfo, Buffer, + 0xFF, DESC_TYPE_CONFIG, ConfigIndx); + if (CnfgDesc == NULL) { + continue; + } + TotalLength = CnfgDesc->wTotalLength; + if (TotalLength > 0xFF) { + if (TotalLength > (MAX_CONTROL_DATA_SIZE - 1)) { + TotalLength = MAX_CONTROL_DATA_SIZE - 1; + } + CnfgDesc = (CNFG_DESC*)USB_GetDescriptor(HcStruc, DevInfo, Buffer, + TotalLength, DESC_TYPE_CONFIG, ConfigIndx); + if (CnfgDesc == NULL) { + continue; + } + } + + if (CnfgDesc->bDescType == DESC_TYPE_CONFIG) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDEnableEndpoints)( + HcStruc, DevInfo, (UINT8*)CnfgDesc); + } + + USB_SetConfig(HcStruc, DevInfo, CnfgDesc->bConfigValue); + + IntrfDesc = (INTRF_DESC*)CnfgDesc; + for (IntrfIndx = 0; IntrfIndx < CnfgDesc->bNumInterfaces; IntrfIndx++) { + do { + IntrfDesc = (INTRF_DESC*)((UINTN)IntrfDesc + IntrfDesc->bDescLength); + if ((UINTN)IntrfDesc > ((UINTN)CnfgDesc + CnfgDesc->wTotalLength) || + (UINTN)IntrfDesc > ((UINTN)CnfgDesc + MAX_CONTROL_DATA_SIZE)) { + break; + } + } while (IntrfDesc->bDescType != DESC_TYPE_INTERFACE); + + if (IntrfDesc->bDescType != DESC_TYPE_INTERFACE) { + break; + } + + for (i = 1; i < MAX_DEVICES; i++) { + Dev = &gUsbData->aDevInfoTable[i]; + if ((Dev->Flag & (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT | + DEV_INFO_DEV_DUMMY)) != (DEV_INFO_VALID_STRUC | DEV_INFO_DEV_PRESENT)) { + continue; + } + if ((Dev->bHubDeviceNumber == DevInfo->bHubDeviceNumber) && + (Dev->bHubPortNumber == DevInfo->bHubPortNumber) && + (Dev->bConfigNum == CnfgDesc->bConfigValue) && + (Dev->bInterfaceNum == IntrfDesc->bInterfaceNum) && + (Dev->bAltSettingNum == IntrfDesc->bAltSettingNum)) { + break; + } + } + if (i == MAX_DEVICES) { + continue; + } + + Dev->wVendorId = DevDesc->VendorId; + Dev->wDeviceId = DevDesc->DeviceId; + + if (Dev->bDeviceType != BIOS_DEV_TYPE_USBBUS) { + DevDriver = UsbFindDeviceDriverEntry(Dev->fpDeviceDriver); + if (DevDriver != NULL) { + (*DevDriver->pfnConfigureDevice)(HcStruc, Dev, (UINT8*)CnfgDesc, + (UINT16)((UINTN)IntrfDesc - (UINTN)CnfgDesc), CnfgDesc->wTotalLength); + } + } + } + } + + USB_MemFree(DevDesc, GET_MEM_BLK_COUNT(sizeof(DEV_DESC))); + USB_MemFree(Buffer, GET_MEM_BLK_COUNT(MAX_CONTROL_DATA_SIZE)); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USB_DevDriverDisconnect +// +// Description: +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 +USB_DevDriverDisconnect( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo +) +{ + DEV_DRIVER* DevDriver; + UINT8 Index; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + EfiStatus = UsbDevInfoValidation(DevInfo); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + gCheckUsbApiParameter = FALSE; + + DevDriver = UsbFindDeviceDriverEntry(DevInfo->fpDeviceDriver); + + if (DevDriver && DevDriver->pfnDisconnectDevice) { + DevDriver->pfnDisconnectDevice(DevInfo); + + DevInfo->bDeviceType = 0; + DevInfo->fpDeviceDriver = NULL; + + for (Index = 0; Index < MAX_DEVICE_TYPES; Index++) { + DevDriver = &gUsbData->aDevDriverTable[Index]; + + if (DevDriver->bDevType == BIOS_DEV_TYPE_USBBUS) { + DevInfo->bDeviceType = DevDriver->bDevType; + DevDriver->pfnConfigureDevice(HcStruc, DevInfo, NULL, 0, 0); + break; + } + } + } else { + if (DevInfo->IntInEndpoint) { + // Stop polling the device's interrupt endpoint + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDDeactivatePolling) + (HcStruc, DevInfo); + DevInfo->IntInEndpoint = 0; + } + } + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: VALID_DEVINFO +// +// Description: Checks if DEV_INFO is a valid connected device info +// Due to hot-plug a DEV_INFO can become invalid in the +// midle of configuration +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +int VALID_DEVINFO(DEV_INFO* pDevInfo) +{ + return (pDevInfo->Flag & DEV_INFO_VALIDPRESENT)!=0; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: USB_AbortConnectHubChildren +// +// Description: Mark DEV_INFO not valid for all the devices connected to a +// given hub. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USB_AbortConnectHubChildren( + UINT8 HubAddr +) +{ + UINT8 i; + DEV_INFO *Dev = &gUsbData->aDevInfoTable[1]; + + for (i=1; i<MAX_DEVICES; i++, Dev++) { + if ((Dev->bHubDeviceNumber == HubAddr) && (Dev->Flag & DEV_INFO_VALIDPRESENT)) { + Dev->Flag &= ~DEV_INFO_DEV_PRESENT; + if (!(Dev->Flag & DEV_INFO_MASS_DEV_REGD)) { + Dev->Flag &= ~DEV_INFO_VALID_STRUC; + } + + USB_DEBUG(DEBUG_LEVEL_3, "USB: abort device [%x] connected to hub[%x]\n", + Dev->bDeviceAddress, HubAddr); + + if (Dev->bDeviceType == BIOS_DEV_TYPE_HUB) { + USB_AbortConnectHubChildren(Dev->bDeviceAddress); + } + } + } +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: USB_FreeDeviceAddress +// +// Description: This routine releases the given device's address by +// updating gUsbData->dDeviceAddressMap. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USB_FreeDeviceAddress( + DEV_INFO *DevInfo +) +{ + UINT8 i; + UINT8 Found = 0; + + if (DevInfo->bDeviceAddress) + { + for (i=1; i<MAX_DEVICES; i++) { + if (gUsbData->aDevInfoTable+i != DevInfo && + gUsbData->aDevInfoTable[i].bDeviceAddress == DevInfo->bDeviceAddress) + { + Found++; + } + } + if (Found == 0){ + //The DevInfo was the only function with allocated address - + // return the address to the pool + gUsbData->DeviceAddressMap |= Shl64(1, DevInfo->bDeviceAddress); + } + } +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USB_AbortConnectDev +// +// Description: Mark DEV_INFO not valid and release its device address +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USB_AbortConnectDev( + DEV_INFO* pDevInfo +) +{ + USB_DEBUG(DEBUG_LEVEL_3, "USB: abort connect [%x].flag = %x\n", + pDevInfo, pDevInfo->Flag); + + pDevInfo->Flag &= ~DEV_INFO_DEV_PRESENT; + + if (!(pDevInfo->Flag & DEV_INFO_MASS_DEV_REGD)) { + pDevInfo->Flag &= ~DEV_INFO_VALID_STRUC; + if (pDevInfo->bDeviceAddress == 0) return; + + USB_FreeDeviceAddress(pDevInfo); + } + + // Remove children (if any) from aborted parent hub device. + // Assume the child device has not been connected since + // the hub has to be connected first. + if (pDevInfo->bDeviceType == BIOS_DEV_TYPE_HUB) { + USB_AbortConnectHubChildren(pDevInfo->bDeviceAddress); + } +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: USB_SmiQueuePut +// +// Description: Puts the pointer pointer into the queue for processing, +// updates queue head and tail. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USB_SmiQueuePut(VOID * d) +{ + QUEUE_T* q = &gUsbData->QueueCnnctDisc; + + while (q->head >= q->maxsize) { + q->head -= q->maxsize; + } + + q->data[q->head++] = d; + if (q->head == q->maxsize) { + q->head -= q->maxsize; + } + if (q->head == q->tail) { + //Drop data from queue + q->tail++; + while (q->tail >= q->maxsize) { + q->tail -= q->maxsize; + } + } +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Procedure: QueuePutMsg +// +// Description: Add a variable size item to the queue +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USB_SmiQueuePutMsg( QUEUE_T* q, VOID * d, int sz ) +{ + EFI_STATUS Status = EFI_SUCCESS; + + if (q->head + sz > q->maxsize) { + q->head = 0; + } +#if USB_RUNTIME_DRIVER_IN_SMM + Status = AmiValidateMemoryBuffer((VOID*)((UINTN)q->data + q->head), sz); + if (EFI_ERROR(Status)) { + return; + } +#endif + MemCopy((UINT8*)d, (UINT8*)((UINTN)q->data + q->head), sz); + q->head += sz; + if(q->head==q->maxsize) q->head = 0; + if(q->head==q->tail){ + //Drop data from queue + q->tail+=sz; + if( q->tail >= q->maxsize ) q->tail = 0; + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: CheckDeviceLimit +// +// Description: Verifies whether the number of initialized devices of a given +// class has reached the limit. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +BOOLEAN +CheckDeviceLimit( + UINT8 BaseClass +) +{ + URP_STRUC Urp; + UINT8 DevNumber; + + Urp.bFuncNumber = USB_API_CHECK_DEVICE_PRESENCE; + Urp.bSubFunc = 1; + Urp.ApiData.ChkDevPrsnc.fpHCStruc = NULL; + Urp.ApiData.ChkDevPrsnc.bDevType = BaseClass; + + USBAPI_CheckDevicePresence(&Urp); + + if (Urp.bRetValue == USB_SUCCESS) + { + DevNumber = Urp.ApiData.ChkDevPrsnc.bNumber; + if ((BaseClass == BASE_CLASS_HID) + && ((USB_DEV_HID_COUNT == 0) || (DevNumber == USB_DEV_HID_COUNT))) + { + USB_DEBUG(3, "Reached the limit of supported HIDs (%d); skipping this device.\n", USB_DEV_HID_COUNT); + return TRUE; + } + + if ((BaseClass == BASE_CLASS_HUB) + && ((USB_DEV_HUB_COUNT == 0) || (DevNumber == USB_DEV_HUB_COUNT))) + { + USB_DEBUG(3, "Reached the limit of supported HUBs (%d); skipping this device.\n", USB_DEV_HUB_COUNT); + return TRUE; + } + + if ((BaseClass == BASE_CLASS_MASS_STORAGE) + && ((USB_DEV_MASS_COUNT == 0) || (DevNumber == USB_DEV_MASS_COUNT))) + { + USB_DEBUG(3, "Reached the limit of supported Mass Storage Devices (%d); skipping this device.\n", USB_DEV_MASS_COUNT); + return TRUE; + } + if ((BaseClass == BASE_CLASS_CCID_STORAGE) + && ((USB_DEV_CCID_COUNT == 0) || (DevNumber == USB_DEV_CCID_COUNT+1))) + { + USB_DEBUG(3, "Reached the limit of supported CCID Devices (%d); skipping this device.\n", USB_DEV_CCID_COUNT); + return TRUE; + } + } + return FALSE; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: UsbControlTransfer +// +// Description: +// +// Input: +// +// Output: +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UsbControlTransfer( + HC_STRUC* HcStruc, + DEV_INFO* DevInfo, + DEV_REQ DevReq, + UINT16 Timeout, + VOID* Buffer) +{ + UINT16 Status; + UINT16 SavedTimeout; + + SavedTimeout = gUsbData->wTimeOutValue; + gUsbData->wTimeOutValue = Timeout; + + Status = (*gUsbData->aHCDriverTable[ + GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDControlTransfer)( + HcStruc, + DevInfo, + DevReq.wRequestType, + DevReq.wIndex, + DevReq.wValue, + Buffer, + DevReq.wDataLength); + + gUsbData->wTimeOutValue = SavedTimeout; + + return DevReq.wDataLength && (Status == 0)? USB_ERROR : USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: UsbInterruptTransfer +// +// Description: This function executes an interrupt transaction on the USB. +// +// Input: +// HcStruc Pointer to HCStruc of the host controller. +// DevInfo DeviceInfo structure (if available else 0). +// EndpointAddress The destination USB device endpoint to which the device request +// is being sent. +// MaxPktSize Indicates the maximum packet size the target endpoint is capable +// of sending or receiving. +// Buffer Buffer containing data to be sent to the device or buffer to be +// used to receive data. +// Length Length request parameter, number of bytes of data to be transferred. +// Timeout Indicates the maximum time, in milliseconds, which the transfer +// is allowed to complete. +// +// Output: USB_SUCCESS or USB_ERROR +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UsbInterruptTransfer ( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo, + UINT8 EndpointAddress, + UINT16 MaxPktSize, + VOID *Buffer, + UINT16 Length, + UINT16 Timeout +) +{ + UINT16 SavedTimeout; + UINT16 BytesTransferred; + + SavedTimeout = gUsbData->wTimeOutValue; + gUsbData->wTimeOutValue = Timeout; + + BytesTransferred = (*gUsbData->aHCDriverTable[ + GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDInterruptTransfer)( + HcStruc, + DevInfo, + EndpointAddress, + MaxPktSize, + Buffer, + Length); + + gUsbData->wTimeOutValue = SavedTimeout; + + if (BytesTransferred == 0) { + return USB_ERROR; + } else { + return USB_SUCCESS; + } + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: USB_EnableEndpointsDummy +// +// Description: Dummy HC API function used by the HC drivers that do not need +// to implement enable endpoint function. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USB_EnableEndpointsDummy ( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo, + UINT8 *Desc +) +{ + return USB_SUCCESS; +} + +UINT8 +USB_InitDeviceDataDummy ( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo, + UINT8 PortStatus, + UINT8 **DeviceData +) +{ + *DeviceData = NULL; + return USB_SUCCESS; +} + +UINT8 +USB_DeinitDeviceDataDummy ( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo +) +{ + return USB_SUCCESS; +} + + //(EIP54018+)> +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Name: LocatePwrCapOffset +// +// Description: +// This function locate power management capability offset +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +LocatePwrCapOffset ( + IN UINT16 BusDevFunc +) +{ +#if USB_RUNTIME_DRIVER_IN_SMM + UINT16 StatusReg; + UINT8 CapOffset; + EFI_PCI_CAPABILITY_HDR CapHeader; + + // Check if device supports extended capabilities + StatusReg = (UINT16)ReadPCIConfig(BusDevFunc, PCI_STATUS_REGISTER_OFFSET); + if((StatusReg & PCI_STS_CAPABILITY) == 0) { + return 0; + } + // Get offset of first capability structure + CapOffset = (UINT8)ReadPCIConfig(BusDevFunc, EFI_PCI_CAPABILITY_PTR); + // Check capabilities until PMI is found or no more capabilities + while (CapOffset) { + CapHeader.CAP_HDR = (UINT16)ReadPCIConfig(BusDevFunc, CapOffset); + // If PMI block, return offset + if(CapHeader.CapabilityID == PCI_CAP_ID_PMI) { + return CapOffset; + } + // If not, check for next offset + CapOffset = CapHeader.NextItemPtr; + } +#endif + return 0; +} + +#if USB_S5_WAKEUP_SUPPORT +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Name: ResumePciBridge +// +// Description: +// This function resumed PciBridge +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID +ResumePciBridge( + UINT16 BusDevFun +) +{ + UINT32 PmStaCtlReg; + UINT32 PmCapReg; + UINT8 PwrCapPtr; + UINT8 PciCommand; + + PwrCapPtr = LocatePwrCapOffset(BusDevFun); + + if (PwrCapPtr) { + PmCapReg = ReadPCIConfig(BusDevFun, PwrCapPtr); + PmStaCtlReg = ReadPCIConfig(BusDevFun, PwrCapPtr + 0x04); + if (PmCapReg & (BIT31 | BIT30)) { + PmStaCtlReg |= BIT8; + } + if (PmStaCtlReg & (BIT0 | BIT1)) { + PmStaCtlReg &= ~(BIT0 | BIT1); + } + DwordWritePCIConfig(BusDevFun, PwrCapPtr + 0x04, PmStaCtlReg); + } + + PciCommand = (UINT8)ReadPCIConfig(BusDevFun, PCI_COMMAND_REGISTER_OFFSET); + PciCommand |= (PCI_CMD_MEMORY_SPACE + PCI_CMD_BUS_MASTER); + ByteWritePCIConfig(BusDevFun, PCI_COMMAND_REGISTER_OFFSET, PciCommand); + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Name: StopPciBridge +// +// Description: +// This function stopped PciBridge +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID +StopPciBridge( + UINT16 BusDevFun +) +{ + UINT32 PmStaCtlReg; + UINT8 PwrCapPtr; + UINT8 PciCommand; + + PwrCapPtr = LocatePwrCapOffset(BusDevFun); + + if (PwrCapPtr) { + PmStaCtlReg = ReadPCIConfig(BusDevFun, PwrCapPtr + 0x04); + PmStaCtlReg |= (BIT0 + BIT1); + DwordWritePCIConfig(BusDevFun, PwrCapPtr + 0x04, PmStaCtlReg); + } + + PciCommand = (UINT8)ReadPCIConfig(BusDevFun, PCI_COMMAND_REGISTER_OFFSET); + PciCommand &= (~PCI_CMD_BUS_MASTER); + ByteWritePCIConfig(BusDevFun, PCI_COMMAND_REGISTER_OFFSET, PciCommand); + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Name: EnablePciBridge +// +// Description: +// This function scaned PciBridge +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +ScanPciBridge( + UINT16 *BridgePciAddr +) +{ + HC_STRUC *HcStruc; + UINT8 HcBus[256]; + UINT16 HcBusIndex = 0; + UINT16 MaxHcBus = 0; + UINT16 i; + UINT16 PciAddr; + UINT16 PciBus; + UINT16 PciDev; + UINT16 PciFun; + UINT16 BridgeIndex = 255; + UINT16 DownstreamBus; + + for (i = 0; i < gUsbData->HcTableCount; i++) { + HcStruc = gUsbData->HcTable[i]; + if (HcStruc == NULL) { + continue; + } + + if (!(HcStruc->dHCFlag & HC_STATE_USED)) { + continue; + } + + if (HcStruc->dHCFlag & HC_STATE_EXTERNAL) { + HcBus[HcBusIndex] = (UINT8)(HcStruc->wBusDevFuncNum >> 8); + if(MaxHcBus < HcBus[HcBusIndex]) { + MaxHcBus = HcBus[HcBusIndex]; + } + HcBusIndex++; + } + } + + for (PciBus = 0; PciBus < MaxHcBus; PciBus++) { + for (PciDev = 0; PciDev < 0x20 ; PciDev++) { + PciAddr = (UINT16)((PciBus << 8) | (PciDev << 3) | 0); + if (ReadPCIConfig(PciAddr, PCI_VID) != 0xffffffff) { + PciFun = ((UINT8)ReadPCIConfig(PciAddr, PCI_HDR) & 0x80) ? 8 : 1; + do { + PciFun--; + PciAddr = (UINT16)((PciBus << 8) | (PciDev << 3) | PciFun); + if (PciFun != 0) { + if (ReadPCIConfig(PciAddr, PCI_VID) == 0xffffffff) { + continue; + } + } + if (ReadPCIConfig(PciAddr, PCI_SCC) == 0x0604) { + DownstreamBus = (UINT16)ReadPCIConfig(PciAddr, PCI_SBUS); + for (i = 0; i < HcBusIndex; i++) { + if ((HcBus[i] >= (UINT8)(DownstreamBus)) && + (HcBus[i] <= (UINT8)(DownstreamBus >> 8))) { + ResumePciBridge(PciAddr); + BridgePciAddr[BridgeIndex] = PciAddr; + BridgeIndex--; + break; + } + } + } + } while (PciFun); + } + } + } +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Input: UsbSuspendHubPort +// +// Description: This function suspends the hub port +// +// Input: DevInfo Device info pointer +// +// Output: Status: EFI_SUCCESS = Success +// EFI_DEVICE_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbSuspendHubPort ( + DEV_INFO *DevInfo +) +{ + UINT32 Index; + DEV_INFO *HubDevInfo; + HC_STRUC *HcStruc; + UINT16 OrgTimeOutValue; + + if (DevInfo->bHubDeviceNumber & BIT7) { + return EFI_SUCCESS; + } + + for (Index = 1; Index < MAX_DEVICES; Index++) { + HubDevInfo = &gUsbData->aDevInfoTable[Index]; + if ((HubDevInfo->Flag & DEV_INFO_VALIDPRESENT) != DEV_INFO_VALIDPRESENT) { + continue; + } + if (DevInfo->bHubDeviceNumber == HubDevInfo->bDeviceAddress) { + HcStruc = gUsbData->HcTable[HubDevInfo->bHCNumber - 1]; + + OrgTimeOutValue = gUsbData->wTimeOutValue; + gUsbData->wTimeOutValue = USB_SUSPEND_HUB_PORT_TIMEOUT_MS; + + (*gUsbData->aHCDriverTable[GET_HCD_INDEX( + HcStruc->bHCType)].pfnHCDControlTransfer)( + HcStruc, + HubDevInfo, + (UINT16)HUB_RQ_SET_PORT_FEATURE, + DevInfo->bHubPortNumber, + (UINT16)PortSuspend, + 0, 0); + + gUsbData->wTimeOutValue = OrgTimeOutValue; + return EFI_SUCCESS; + } + } + return EFI_DEVICE_ERROR; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Name: UsbSuspendDevices +// +// Description: +// This function suspends usb devices. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UsbSuspendDevices ( + VOID +) +{ + UINT32 Index; + DEV_INFO *DevInfo; + + for (Index = MAX_DEVICES; Index > 0; Index--) { + + DevInfo = &gUsbData->aDevInfoTable[Index]; + + if ((DevInfo->Flag & DEV_INFO_VALIDPRESENT) != DEV_INFO_VALIDPRESENT) { + continue; + } + UsbSuspendHubPort(DevInfo); + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Name: UsbSuspend +// +// Description: +// This function suspend USB +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UsbSuspend( + VOID +) +{ + HC_STRUC *HcStruc; + DEV_INFO *DevInfo; + CNFG_DESC *CnfgDesc; + UINT8 *Buffer; + UINT16 i; + UINT32 PmStaCtlReg; + UINT32 PmCapReg; + UINT16 BridgePciAddr[256]; + UINT32 HcLowBaseAddress; + UINT32 HcHighBaseAddress; + UINT16 HcIoAddress; + UINT16 OrgTimeOutValue; + + for (i = 0; i < 256; i++) { + BridgePciAddr[i] = 0; + } + + ScanPciBridge(BridgePciAddr); + + for (i = 0; i < gUsbData->HcTableCount; i++) { + HcStruc = gUsbData->HcTable[i]; + if (HcStruc == NULL) { + continue; + } + + if (!(HcStruc->dHCFlag & HC_STATE_USED)) { + continue; + } + + HcStruc->PwrCapPtr = LocatePwrCapOffset(HcStruc->wBusDevFuncNum); + if (HcStruc->PwrCapPtr) { + PmCapReg = ReadPCIConfig(HcStruc->wBusDevFuncNum, + HcStruc->PwrCapPtr); + PmStaCtlReg = ReadPCIConfig(HcStruc->wBusDevFuncNum, + HcStruc->PwrCapPtr + 0x04); + if (PmCapReg & (BIT31 | BIT30)) { + PmStaCtlReg |= BIT8; + } + if (PmStaCtlReg & (BIT0 | BIT1)) { + PmStaCtlReg &= ~(BIT0 | BIT1); + } + DwordWritePCIConfig(HcStruc->wBusDevFuncNum, + HcStruc->PwrCapPtr + 0x04, PmStaCtlReg); + } + if (HcStruc->bHCType == USB_HC_UHCI) { + HcIoAddress = (UINT16)ReadPCIConfig(HcStruc->wBusDevFuncNum, USB_IO_BASE_ADDRESS); + if (HcStruc->BaseAddress != HcIoAddress) { + WordWritePCIConfig(HcStruc->wBusDevFuncNum, + USB_IO_BASE_ADDRESS, (UINT32)HcStruc->BaseAddress); + } + ByteWritePCIConfig(HcStruc->wBusDevFuncNum, + PCI_CMD, PCI_CMD_IO_SPACE | PCI_CMD_BUS_MASTER); + } else { + HcLowBaseAddress = ReadPCIConfig(HcStruc->wBusDevFuncNum, PCI_BAR0); + if ((((UINT8)HcLowBaseAddress & (BIT1 |BIT2)) == BIT2) && ((sizeof(VOID*) / sizeof(UINT32)) == 2)) { + HcHighBaseAddress = ReadPCIConfig(HcStruc->wBusDevFuncNum, PCI_BAR1); + if(HcStruc->BaseAddress != ((UINTN)(HcLowBaseAddress & 0xFFFFFFF0)) + + (Shl64((UINTN)HcHighBaseAddress, 32))) { + DwordWritePCIConfig(HcStruc->wBusDevFuncNum, + PCI_BAR0, (UINT32)HcStruc->BaseAddress); + DwordWritePCIConfig(HcStruc->wBusDevFuncNum, + PCI_BAR1, (UINT32)(Shr64(HcStruc->BaseAddress, 32))); + } + } else { + if (HcStruc->BaseAddress != (HcLowBaseAddress & 0xFFFFFFF0)) { + DwordWritePCIConfig(HcStruc->wBusDevFuncNum, + PCI_BAR0, (UINT32)HcStruc->BaseAddress); + } + } + ByteWritePCIConfig(HcStruc->wBusDevFuncNum, + PCI_CMD, PCI_CMD_MEMORY_SPACE | PCI_CMD_BUS_MASTER); + } + } + + // Remove the prsent flag of devices before we reenumerate. + for (i = 1; i < MAX_DEVICES; i++) { + DevInfo = &gUsbData->aDevInfoTable[i]; + DevInfo->Flag &= ~DEV_INFO_DEV_PRESENT; + } + + gUsbData->UsbSetupData.UsbMassDriverSupport = FALSE; + gUsbData->bHandOverInProgress = FALSE; + + //Start XHCI + StartControllerType(USB_HC_XHCI); + //Start EHCI + StartControllerType(USB_HC_EHCI); + //Start UHCI + StartControllerType(USB_HC_UHCI); + //Start OHCI + StartControllerType(USB_HC_OHCI); + + //Wait for the usb devices connect. + FixedDelay(50 * 1000); + + USB_EnumerateRootHubPorts(USB_HC_XHCI); + USB_EnumerateRootHubPorts(USB_HC_EHCI); + USB_EnumerateRootHubPorts(USB_HC_UHCI); + USB_EnumerateRootHubPorts(USB_HC_OHCI); + + Buffer = USB_MemAlloc(sizeof(CNFG_DESC)); + + OrgTimeOutValue = gUsbData->wTimeOutValue; + gUsbData->wTimeOutValue = 500; + + for (i = 1; i < MAX_DEVICES; i++) { + + DevInfo = &gUsbData->aDevInfoTable[i]; + + if ((DevInfo->Flag & DEV_INFO_VALIDPRESENT) != DEV_INFO_VALIDPRESENT) { + continue; + } + + if (DevInfo->bDeviceType == BIOS_DEV_TYPE_HUB) { + continue; + } + + HcStruc = gUsbData->HcTable[DevInfo->bHCNumber - 1]; + + CnfgDesc = (CNFG_DESC*)USB_GetDescriptor( + HcStruc, + DevInfo, + Buffer, + sizeof(CNFG_DESC), + DESC_TYPE_CONFIG, + 0); + + if (CnfgDesc == NULL) { + continue; + } + + //Check the device have the capable of remote wakeup + if (CnfgDesc ->bConfigFlags & BIT5) { + //Send device wakeup command to the device + (*gUsbData->aHCDriverTable[GET_HCD_INDEX( + HcStruc->bHCType)].pfnHCDControlTransfer)( + HcStruc, + DevInfo, + (UINT16)USB_RQ_SET_FEATURE, + 0, + (UINT16)USB_FSEL_DEV_REMOTE_WAKEUP, + 0, 0); + + } + + } + + gUsbData->wTimeOutValue = OrgTimeOutValue; + + USB_MemFree(Buffer, sizeof(CNFG_DESC)); + + UsbSuspendDevices(); + + for (i = 0; i < gUsbData->HcTableCount; i++) { + HcStruc = gUsbData->HcTable[i]; + if (HcStruc == NULL) { + continue; + } + + //Global suspend host + if (HcStruc->dHCFlag & HC_STATE_RUNNING) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX( + HcStruc->bHCType)].pfnHCDGlobalSuspend)(HcStruc); + if (HcStruc->PwrCapPtr) { + PmStaCtlReg = ReadPCIConfig(HcStruc->wBusDevFuncNum, + HcStruc->PwrCapPtr + 0x04); + PmStaCtlReg |= (BIT0 + BIT1); + DwordWritePCIConfig(HcStruc->wBusDevFuncNum, + HcStruc->PwrCapPtr + 0x04, PmStaCtlReg); + } + } + } + + for (i = 0; i < 256; i++) { + if (BridgePciAddr[i] != 0) { + StopPciBridge(BridgePciAddr[i]); + } + } + + UsbSbEnablePme(); + +} + +#endif + //<(EIP54018+) +UINT8 +UsbGetDataToggle( + DEV_INFO *DevInfo, + UINT8 EndpointAddr +) +{ + DEV_INFO *DevInfoToToggle; + UINT8 ToggleBit = (EndpointAddr & 0xF) - 1; + UINT16 *DataSync; + EFI_STATUS Status; + + if (DevInfo->fpLUN0DevInfoPtr) { + Status = UsbDevInfoValidation(DevInfo->fpLUN0DevInfoPtr); + if (EFI_ERROR(Status)) { + return 0; + } + DevInfoToToggle = DevInfo->fpLUN0DevInfoPtr; + } else { + DevInfoToToggle = DevInfo; + } + + if (EndpointAddr & BIT7) { + DataSync = &DevInfoToToggle->wDataInSync; + } else { + DataSync = &DevInfoToToggle->wDataOutSync; + } + + return (UINT8)((*DataSync) >> ToggleBit) & 0x1; +} + +VOID +UsbUpdateDataToggle( + DEV_INFO *DevInfo, + UINT8 EndpointAddr, + UINT8 DataToggle +) +{ + DEV_INFO *DevInfoToToggle; + UINT8 ToggleBit = (EndpointAddr & 0xF) - 1; + UINT16 *DataSync; + EFI_STATUS Status; + + if (DevInfo->fpLUN0DevInfoPtr) { + Status = UsbDevInfoValidation(DevInfo->fpLUN0DevInfoPtr); + if (EFI_ERROR(Status)) { + return; + } + DevInfoToToggle = DevInfo->fpLUN0DevInfoPtr; + } else { + DevInfoToToggle = DevInfo; + } + + if (EndpointAddr & BIT7) { + DataSync = &DevInfoToToggle->wDataInSync; + } else { + DataSync = &DevInfoToToggle->wDataOutSync; + } + + *DataSync &= (UINT16)~(1 << ToggleBit); + *DataSync |= (UINT16)(DataToggle << ToggleBit); + return; +} + +//**************************************************************************** +//**************************************************************************** +//** ** +//** (C)Copyright 1985-2016, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Pkwy, Norcross, GA 30093 ** +//** ** +//** Phone (770)-246-8600 ** +//** ** +//**************************************************************************** +//**************************************************************************** |