diff options
Diffstat (limited to 'Core/EM/usb/rt/amiusb.c')
| -rw-r--r-- | Core/EM/usb/rt/amiusb.c | 3402 |
1 files changed, 3402 insertions, 0 deletions
diff --git a/Core/EM/usb/rt/amiusb.c b/Core/EM/usb/rt/amiusb.c new file mode 100644 index 0000000..89a2975 --- /dev/null +++ b/Core/EM/usb/rt/amiusb.c @@ -0,0 +1,3402 @@ +//**************************************************************************** +//**************************************************************************** +//** ** +//** (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/amiusb.c 121 10/16/16 10:11p Wilsonlee $ +// +// $Revision: 121 $ +// +// $Date: 10/16/16 10:11p $ +// +//**************************************************************************** +// Revision History +// ---------------- +// $Log: /Alaska/SOURCE/Modules/USB/ALASKA/RT/amiusb.c $ +// +// 121 10/16/16 10:11p 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 +// +// 120 7/29/16 3:13a 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 +// +// 119 7/29/16 3:09a Wilsonlee +// [TAG] EIP277810 +// [Category] Improvement +// [Description] Validate the memory buffer is entirely outside of SMM. +// [Files] usbsb.c, amiusb.c, ehci.c, ohci.c, uhci.c, usbCCID.c, +// usbdef.h, usbmass.c, xhci.c, amiusbhc.c, efiusbccid.c, efiusbmass.c, +// uhcd.c, uhcd.h, usbmisc.c +// +// 117 7/07/16 1:09a Wilsonlee +// [TAG] EIP277810 +// [Category] Improvement +// [Description] Validate the memory buffer is entirely outside of SMM. +// [Files] usbsb.c, amiusb.c, ehci.c, ohci.c, uhci.c, usbCCID.c, +// usbdef.h, usbmass.c, xhci.c, amiusbhc.c, efiusbccid.c, efiusbmass.c, +// uhcd.c, uhcd.h, usbmisc.c +// +// 116 10/16/15 3:34a Wilsonlee +// [TAG] EIP241977 +// [Category] Improvement +// [Description] Improve UsbKbcAccessControl api function. +// [Files] amiusb.c +// +// 115 4/10/15 3:12a Wilsonlee +// [TAG] EIP207413 +// [Category] Improvement +// [Description] Install UsbApiTable and UsbMassApitTable in +// AmiUsbSmmProtocol. +// [Files] amiusbhc.c, AmiUsbController.h, usbdef.h, usbCCID.c, uhci.c, +// ehci.c, amiusbrtCCID.h, amiusb.h, amiusb.c, uhcd.c +// +// 114 2/10/15 12:20a Wilsonlee +// Fixed build error in non-smm projects. +// +// 113 12/03/14 9:36p Wilsonlee +// [TAG] EIP193805 +// [Category] Improvement +// [Description] Security Enhancement for SMIHandler in USB module. +// [Files] amiusb.c, uhcd.c, usbrt.mak, usbdef.h, usbsb.c +// +// 112 11/23/14 10:10p Wilsonlee +// [TAG] EIP189293 +// [Category] Improvement +// [Description] Implement XHCI key repeat function. +// [Files] usb.c, xhci.c , xhci.h, amiusb.c +// +// 111 6/05/14 9:15p Wilsonlee +// [TAG] EIP171837 +// [Category] Bug Fix +// [Severity] Critical +// [Symptom] When use afuwin update BIOS or read ROMID under pure Win8.1 +// OS, sometimes the system will blue screen. +// [RootCause] UsbData->EfiKeyboardBuffer is EfiBootServicesData. This +// memory isn't reserved in OS. We can't write data to this memory in OS. +// [Solution] We clear the buffer at USBKBDProcessKeyboardData function +// if the system is under EFI. +// [Files] amiusb.c +// +// 110 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 +// +// 109 4/07/14 1:28a Wilsonlee +// [TAG] EIP157193 +// [Category] Improvement +// [Description] Stop the usb host controllers at AcpiModeEnable if they +// art extend cards or don't support HW SMI. +// [Files] amiusb.c +// +// 108 2/10/14 1:19a Ryanchou +// [TAG] EIP149929 +// [Category] Improvement +// [Description] Stop all external EHCI HCs in ACPI enable call. +// [Files] amiusb.c +// +// 107 12/15/13 10:16p Wilsonlee +// [TAG] EIP136594 +// [Category] New Feature +// [Description] Support 64 bits LBA of usb mass storages. +// [Files] Bfiusb.asm, Bfiusb.equ, UsbInt13.c, UsbInt13.h, amiusb.c, +// usbdef.h, usbmass.c, UsbMass.h, efiusbmass.c, UI13.bin +// +// 106 11/05/13 4:46a Ryanchou +// [TAG] EIP135636 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] NumLock LED cannot be on/off properly. +// [RootCause] It is the side effect of EIP #107429 changes, the +// keyboard does not generate break code when pressing NumLock. +// [Solution] Remove the EIP #107429 changes. +// [Files] amiusb.c, usbkbd.c, efiusbkb.c +// +// 105 10/19/13 7:06a Ryanchou +// [TAG] EIP138257 +// [Category] Improvement +// [Description] Correct USB HID device type. +// [Files] amiusb.c, usbdef.h, usbhid.c, efiusbhid.c, uhcd.c +// +// 104 8/06/13 4:21a Wilsonlee +// [TAG] EIP128970 +// [Category] Improvement +// [Description] UsbInstallHwSmiHandler returns EFI_UNSUPPORTED if +// HCType is invalid. +// [Files] amiusb.c +// +// 103 6/02/13 11:43p Wilsonlee +// [TAG] EIP123235 +// [Category] Improvement +// [Description] Stop the usb host controller at ExitBootService if it +// is an extend card or it doesn't support HW SMI. +// [Files] xhci.c, ehci.c, uhci.c, ohci.c, amiusb.c, usbdef.h, usbsb.c, +// uhcd.c +// +// 102 4/10/13 9:29p Wilsonlee +// [TAG] EIP120573 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] Afuwinx64/Safuwinx64 hang up issue. +// [RootCause] EfiZeroMem is a boot service function, we can't use it +// during runtime. +// [Solution] Use MemFill function to clear the KBC buffers. +// [Files] amiusb.c +// +// 101 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 +// +// 100 1/23/13 4:15a Ryanchou +// [TAG] EIP111280 +// [Category] Improvement +// [Description] Add USB APIs for external driver. +// [Files] amiusb.c, amiusb.h, usbdef.h +// +// 99 1/22/13 3:09a Wilsonlee +// [TAG] EIP112938 +// [Category] Improvement +// [Description] Create a header file for usb mass storage driver. +// [Files] UsbMass.h, usbmass.c, usbdef.h, amiusb.c, efiusbmass.c +// +// 98 12/21/12 5:02a Ryanchou +// [TAG] EIP71730 +// [Category] New Feature +// [Description] Added OHCI handoff support. +// [Files] usb.sdl, usbport.c, amiusb.c, usbdef.h, UsbPolicy.h, usb.sd, +// usb.uni +// +// 97 12/09/12 12:12a Wilsonlee +// [TAG] EIP107429 +// [Category] Improvement +// [Description] Process the make code even if there is no break code. +// [Files] efiusbkb.c, amiusb.c +// +// 96 12/02/12 10:23p Roberthsu +// [TAG] EIP102150 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Push key and unplug KB , character repeat can not. +// stop +// [RootCause] Because repeat key does not clear when usb keyboard +// unplug. +// [Solution] When keyboard disconnrct, clear keyboard device id with +// device id buffer and scancode buffer. +// [Files] amiusb.c,syskbc.c,uhcd.c,usbkbd.c +// +// 95 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 +// +// 94 8/29/12 8:10a 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 +// +// 93 8/07/12 9:39p Wilsonlee +// [TAG] EIP96366 +// [Category] New Feature +// [Description] Add the token "DEFAULT_USB_EMUL6064_OPTION" that +// control the default value of the I/O port 60h/64h emulation support +// option. +// [Files] usb.sd, usb.sdl, amiusb.c, amiusb.h +// +// 92 6/13/12 7:31a Lavanyap +// [TAG] EIP89825 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] System get's hangs inside the SMI handler while flashing +// the Bios. +// [RootCause] Port 60/64 access SMI will not be generated immediately +// if accessed inside an SMI handler when KbcEmulation is enabled. +// [Solution] Emulation is disabled while accessing the Port 60/64. +// [Files] amiusb.c +// +// 91 5/22/12 10:03a Ryanchou +// [TAG] EIP90154 +// [Category] Improvement +// [Description] Remove the USBSB_EnableSmmPeriodicSmi and +// USBSB_DisableSmmPeriodicSmi hooks. +// [Files] amidef.h, amiusb.c, usb.c, usbsb.c +// +// 90 5/04/12 6:37a 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 +// +// 89 5/04/12 5:21a Wilsonlee +// [TAG] EIP89307 +// [Category] Improvement +// [Description] Modify incorrect #pragma pack directive. +// [Files] amidef.h, amiusb.c, ehci.c, ohci.c, ohci.h, uhci.h, usb.c, +// usbdef.h, xhci.h, efiusbmass.c, uhcd.c, uhcd.h, usbbus.c, usbbus.h, +// UsbIo.h +// +// 88 5/03/12 5:50a Roberthsu +// [TAG] EIP84455 +// [Category] Improvement +// [Description] Implement usb hid device gencric. +// [Files] amiusb.c,amiusbhc.c,efiusbhid.c,efiusbkb.c,ehci.c,ohci.c,uhc +// d.c,uhci.c,usbdef.h,usbhid.c,usbhub.c,usbkbd.c,usbkbd.h,usbms.c,usbsb.c +// ,usbsrc.sdl +// +// 87 1/16/12 6:01a Ryanchou +// [TAG] EIP81132 +// [Description] Add core version check for EIP80609 solution. +// [Files] amiusb.c, usbrt.mak, usbsb.c +// +// 86 1/14/12 4:09a Ryanchou +// [TAG] EIP80609 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] If to enable debug mode and set launch CSM is "Never" in +// setup, system will hang at 0xB1 +// [RootCause] The pointer AmiUsb is invalid if CSM is not launched, +// that may cause CPU exception. +// [Solution] Added USB smm protocol, and use SmmLocateProtocol to get +// the pointer. +// [Files] amiusb.c, AmiUsbController.h, usbrt.mak, usbsb.c +// +// 85 1/13/12 4:23a 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 +// +// 84 12/09/11 3:09p Ryanchou +// [TAG] EIP7768 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] USB mass storage can't work after unplug and plug under DOS +// [RootCause] The SW SMI handler checks USB_FLAG_RUNNING_UNDER_EFI flag +// to get the URP from USB global data area or EBDA. Legacy boot event +// clears the flag, and UsbPrepareForLegacyOS will not be invoked. +// [Solution] Check the URP in USB global data area, if it is not empty, +// get it in USB global data area, or get it in EBDA. +// [Files] amiusb.c +// +// 83 11/08/11 8:22a 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 +// +// 82 11/08/11 1:41a Ryanchou +// [TAG] EIP63188 +// [Category] Improvement +// [Description] External USB controller support. +// [Files] amidef.h, amiusb.c, ehci.c, ohci.c, uhcd.c, uhcd.h, uhci.c, +// usbdef.h, usbmisc.c, usbsb.c, xhci.c +// +// 81 11/05/11 3:26a Ryanchou +// [TAG] EIP70094 +// [Category] Improvement +// [Description] Microsoft CSM Opt-Out feature implementation. +// [Files] amiusb.c, uhcd.c +// +// 80 10/17/11 2:24a Ryanchou +// [TAG] EIP69136 +// [Category] Improvement +// [Description] Remove the dependency of EBDA in USB module for CSM +// disabling. +// [Files] amiusb.c, uhcd.c, usbport.c, usbsb.c +// +// 79 9/28/11 10:45a Ryanchou +// [TAG] EIP66064 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] System hangs when waiting for finger swipe +// [RootCause] USB driver save the URP pointer to EBDA in function +// UsbSmiCore and UsbSmiHc, the pointer will be destroyed if someone also +// invoke the two functions. +// [Solution] Save the URP pointer before generate SW SMI and restore it +// after return from SMI. +// [Files] amiusb.c, amiusbhc.c, usbport.c +// +// 78 8/08/11 6:57a 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 +// +// 77 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 +// +// 76 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 +// +// 75 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 +// +// 74 5/03/11 8:44a Ryanchou +// [TAG] EIP57521 +// [Category] Improvement +// [Description] Enumerate root hub ports after start host controllers +// in USB_StartLegacy. +// [Files] amiusb.c +// +// 73 3/30/11 9:02a Ryanchou +// [TAG] EIP41483 +// [Category] Improvement +// [Description] Stop timer SMI after legacy shutdown. +// [Files] amiusb.c, AmiUsbController.h, ohci.c +// +// 72 3/29/11 10:07a 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 +// +// 71 12/24/10 5:02a Tonylo +// [TAG] EIP48323 +// [Category] Improvement +// [Description] Reflush USB keyboard data buffer to avoid junk data +// sent after enable USB keyboard data throughput. +// [Files] AMIUSB.C +// +// 70 11/22/10 8:42a Ryanchou +// [TAG] EIP48064 +// [Category] Improvement +// [Description] The SB template implemented elink +// AcpiEnableCallbackList, the XHCI/EHCI hand off function should be +// invoked via the elink AcpiEnableCallbackList. +// [Files] amidef.h, amiusb.c, amiusb.dxs, amiusb.h, +// AmiUsbController.h, usb.sdl, usbrt.mak, usbsb.c +// +// 69 10/07/10 9:32a Ryanchou +// EIP42986: Remove the retry loop in UsbHwSmiHandler. +// +// 68 8/31/10 8:57a Tonylo +// Remove user tags for coding standard. +// +// Description: Remove user tags for coding standard. +// +// 67 8/18/10 4:22p Olegi +// Klockwork related fixes; EIP37978 +// +// 66 7/27/10 9:11a Ryanchou +// EIP41216: Return correct error code when device isn't present. +// +// 65 7/15/10 4:33a Tonylo +// EIP21649 - USB mass storage device still appear in BBS menu when USB +// legacy support is disabled. +// +// 64 6/07/10 8:56a Ryanchou +// EIP38547: Fixed system halt when installing FreeBSD. +// +// 63 3/31/10 6:26p Olegi +// +// 62 3/25/10 9:45a Olegi +// +// 61 3/19/10 10:05a Olegi +// +// 60 1/27/10 5:19p Olegi +// Added chipset porting hook to initialize timers. +// +// 59 12/01/09 10:06a Olegi +// EIP31535: RWV error code corrected. +// +// 58 11/25/09 8:05a Olegi +// EIPEIP29733: Added KBC access control API +// +// 57 10/30/09 5:47p Olegi +// +// 56 10/02/09 10:49a Olegi +// Code cleanup. +// +// 54 9/15/09 10:21a Olegi +// Added USB_INCMPT_HID_DATA_OVERFLOW incompatibility type. +// +// 53 8/26/09 11:41a Olegi +// Changes that prevent collision of keyboard activity and mass storage +// access. EIP#22808 +// +// 52 5/22/09 1:46p Olegi +// Added the special treatment for in-built hubs. +// +// 51 5/21/09 5:11p Olegi +// Added checking for hotplug fake drives in Read/Write/Verify functions. +// +// 50 1/29/09 2:31p Olegi +// USB API CheckDevicePresence is extended with USB_SRCH_DEVBASECLASS_NUM +// search key. +// +// 49 1/23/09 4:28p Olegi +// Added EXTRA_CHECK_DEVICE_READY condition for the fix to EIP#15037. +// +// 48 1/05/09 9:40a Olegi +// Changes for EIP#15037. Extra CheckDeviceReady call added to read/write +// functions. +// +// 46 10/06/08 3:33p Olegi +// EHCI change ownership testing in DOS fix (EIP#14855). +// +// 44 9/24/08 4:01p Olegi +// Modified USBAPI_ChangeOwner so that it allows multiple calls to +// acquiring the ownership without releasing it. +// +// 43 7/04/08 1:07p Olegi +// Device "Ultra-X, Inc.: Ultra-X QTP USB HD 1.01" is removed from +// incompatible device list. +// +// 42 6/27/08 5:52p Olegi +// Added incompatible devices. +// +// 41 5/16/08 12:01p Olegi +// Compliance with AMI coding standard. +// +// 40 12/17/07 4:04p Olegi +// KBC emulation support added. +// +// 39 12/05/07 4:36p Olegi +// Modification in USBSWSMIHandler() related to the 64/32-bit pointers. +// +// 36 7/09/07 2:11p Olegi +// Changed the maximum data size of the BulkTransfer from 1kB to 64kB. +// +// 34 6/11/07 2:53p Olegi +// Bugfix in device read/write routine: do not issue RWV command if there +// is no media present. +// +// 32 3/20/07 12:16p Olegi +// SMITHUNK removed. +// +// 28 10/18/06 9:40a Andriyn +// Fix: race condition on hot-plug in / plug-off +// +// 27 10/12/06 4:41p Olegi +// Modified the method of passing arguments into USBSWSMIHandler: it is +// done through memory location, not using CPU register. This change is +// only valid for CSM16 versions 31 and later. +// +// 26 4/14/06 6:39p Olegi +// Conversion to be able to use x64 compiler. +// +// 24 3/20/06 3:37p Olegi +// Version 8.5 - x64 compatible. +// +// 23 3/06/06 6:22p Olegi +// Lun devices support modifications: supported using the index in +// DEV_INFO table, not through dedicated massLun table. +// +// 21 1/11/06 11:51a Olegi +// LegacyUsbSupport setup question functionality added. +// +// 18 10/20/05 3:08p Olegi +// ReadDevice correction (EST change). +// +// 14 8/25/05 7:19p Andriyn +// USB Keyboard and mouse to use EMUL 60/64 for passing data to KBC. +// Fall-back when EMUL 60/64 is not present +// +// 13 8/23/05 5:50p Olegi +// USBMassGetDeviceParameters function added. +// +// 12 8/11/05 9:53a Olegi +// 60/64 port emulation related fixes for EMU6064 driver. +// +// 11 8/04/05 5:58p Andriyn +// Legacy over LegacyFree +// +// 10 6/20/05 8:55a Olegi +// .NET compiler with highest warning level and warning-as-error +// modification. +// +// 9 6/15/05 1:59p Andriyn +// Comments were changed +// +// 6 6/03/05 6:06p Olegi +// UsbHwSmiHandler modified to be called individually from UHCI, OHCI and +// EHCI drivers. +// +// 5 6/03/05 9:28a Olegi +// ATA Error reporting is corrected in USBWrapGetATAErrorCode. +// +// 4 6/01/05 5:21p Olegi +// Debug message shortened. +// +// 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: AMIUSB.C +// +// Description: AMI USB API implementation. The following code will be +// copied to SMM; only RT functions can be used. gUsbData +// is obtained from AMIUHCD in the entry point and can be +// used afterwards. +// +//---------------------------------------------------------------------------- +//<AMI_FHDR_END> + +#include <AmiDxeLib.h> +#include "amiusb.h" +#include "amidef.h" +#include <UsbDevDriverElinks.h> //(EIP71750+) +#if USB_RUNTIME_DRIVER_IN_SMM +#include <AmiBufferValidationLib.h> +#include <AmiUsbSmmGlobalDataValidationLib.h> +#endif + +#if USB_DEV_KBD +#include "usbkbd.h" +#endif +#include "UsbMass.h" + + //(EIP54018+)> +#if USB_S5_WAKEUP_SUPPORT +#include <Protocol\SmmSxDispatch.h> +#include <Protocol\SmmPowerButtonDispatch.h> +#endif + //<(EIP54018+) +//#pragma warning (disable: 4152) + +extern UINT8 IsKbcAccessBlocked; //(EIP29733+) +EFI_EMUL6064MSINPUT_PROTOCOL* gMsInput = 0; +EFI_EMUL6064KBDINPUT_PROTOCOL* gKbdInput = 0; +EFI_EMUL6064TRAP_PROTOCOL* gEmulationTrap = 0; + +USB_GLOBAL_DATA *gUsbData; +//USB_BADDEV_STRUC *gUsbBadDeviceTable; //(EIP60706-) + +AMI_USB_SMM_PROTOCOL gUsbSmmProtocol = {0}; + +BOOLEAN gLockSmiHandler = FALSE; +BOOLEAN gLockHwSmiHandler = FALSE; +BOOLEAN gCheckUsbApiParameter = FALSE; + +VOID StopControllerType(UINT8); +VOID StartControllerType(UINT8); +UINT8 USB_StopDevice (HC_STRUC*, UINT8, UINT8); +UINT8 USB_EnumerateRootHubPorts(UINT8); //(EIP57521+) +VOID StopControllerBdf(UINT16); //(EIP74876+) + +VOID FillHcdEntries(); + //(EIP71750+)> +typedef VOID USB_DEV_DELAYED_DRIVER_CHECK (DEV_DRIVER*); +extern USB_DEV_DELAYED_DRIVER_CHECK USB_DEV_DELAYED_DRIVER EndOfUsbDevDelayedDriverList; +USB_DEV_DELAYED_DRIVER_CHECK* UsbDevDelayedDrivers[]= {USB_DEV_DELAYED_DRIVER NULL}; + +typedef VOID USB_DEV_DRIVER_CHECK (DEV_DRIVER*); +extern USB_DEV_DRIVER_CHECK USB_DEV_DRIVER EndOfUsbDevDriverList; +USB_DEV_DRIVER_CHECK* UsbDevDrivers[]= {USB_DEV_DRIVER NULL}; + //<(EIP71750+) + //(EIP54018+)> +#if USB_S5_WAKEUP_SUPPORT +VOID UsbSuspend(VOID); +#endif + +#if USB_S5_WAKEUP_SUPPORT +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Name: UsbS5SmiCallback +// +// Description: +// This function enter usb s5 callback. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID +UsbS5SmiCallback( + IN EFI_HANDLE DispatchHandle, + IN EFI_SMM_SX_DISPATCH_CONTEXT *DispatchContext +) +{ + EFI_STATUS Status = EFI_SUCCESS; +#if defined(PI_SPECIFICATION_VERSION)&&(PI_SPECIFICATION_VERSION>=0x0001000A)&&(CORE_COMBINED_VERSION >= 0x4028B) + Status = AmiUsbSmmGlobalDataValidation(gUsbData); + + ASSERT_EFI_ERROR(Status); + + if (EFI_ERROR(Status)) { + return; + } +#endif + UsbSuspend(); +} +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Name: UsbPowerButtonSmiCallback +// +// Description: +// This function enter s5 callback if press power button. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID +UsbPowerButtonSmiCallback( + IN EFI_HANDLE DispatchHandle, + IN EFI_SMM_POWER_BUTTON_DISPATCH_CONTEXT *DispatchContext +) +{ + EFI_STATUS Status = EFI_SUCCESS; +#if defined(PI_SPECIFICATION_VERSION)&&(PI_SPECIFICATION_VERSION>=0x0001000A)&&(CORE_COMBINED_VERSION >= 0x4028B) + Status = AmiUsbSmmGlobalDataValidation(gUsbData); + + ASSERT_EFI_ERROR(Status); + + if (EFI_ERROR(Status)) { + return; + } +#endif + UsbSuspend(); +} +#endif + //<(EIP54018+) + +//<AMI_THDR_START> +//---------------------------------------------------------------------------- +// Name: aUsbApiTable - USB API Function Dispatch Table +// +// Type: Function Dispatch Table +// +// Description: This is the table of functions used by USB API +// +// Notes: This functions are invoked via software SMI +// +//---------------------------------------------------------------------------- +//<AMI_THDR_END> + +API_FUNC aUsbApiTable[] = { + USBAPI_CheckPresence, + USBAPI_Start, + USBAPI_Stop, + USBAPI_DisableInterrupts, + USBAPI_EnableInterrupts, + USBAPI_MoveDataArea, + USBAPI_GetDeviceInfo, + USBAPI_CheckDevicePresence, + USBAPI_MassDeviceRequest, + USBAPI_PowerManageUSB, + USBAPI_PrepareForOS, + USBAPI_SecureInterface, + USBAPI_LightenKeyboardLEDs, + USBAPI_ChangeOwner, + USBAPI_HC_Proc, + USBAPI_Core_Proc, + USBAPI_LightenKeyboardLEDs_Compatible, + USBAPI_KbcAccessControl, + USBAPI_LegacyControl, + USBAPI_GetDeviceAddress, + USBAPI_ExtDriverRequest, + USBAPI_CCIDRequest, + USBAPI_UsbStopController, //(EIP74876+) + USBAPI_HcStartStop +}; + +//<AMI_THDR_START> +//---------------------------------------------------------------------------- +// Name: USBMassAPITable - USB Mass Storage API Function Dispatch Table +// +// Type: Function Dispatch Table +// +// Description: This is the table of functions used by USB Mass Storage API +// +//---------------------------------------------------------------------------- +//<AMI_THDR_END> + +API_FUNC aUsbMassApiTable[] = { + USBMassAPIGetDeviceInformation, // USB Mass API Sub-Func 00h + USBMassAPIGetDeviceGeometry, // USB Mass API Sub-Func 01h + USBMassAPIResetDevice, // USB Mass API Sub-Func 02h + USBMassAPIReadDevice, // USB Mass API Sub-Func 03h + USBMassAPIWriteDevice, // USB Mass API Sub-Func 04h + USBMassAPIVerifyDevice, // USB Mass API Sub-Func 05h + USBMassAPIFormatDevice, // USB Mass API Sub-Func 06h + USBMassAPICommandPassThru, // USB Mass API Sub-Func 07h + USBMassAPIAssignDriveNumber, // USB BIOS API function 08h + USBMassAPICheckDevStatus, // USB BIOS API function 09h + USBMassAPIGetDevStatus, // USB BIOS API function 0Ah + USBMassAPIGetDeviceParameters // USB BIOS API function 0Bh +}; + +EFI_DRIVER_ENTRY_POINT(USBDriverEntryPoint) + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: USBDriverEntryPoint +// +// Description: USB Driver entry point +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +USBDriverEntryPoint( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable +) +{ + EFI_STATUS Status; + + InitAmiLib(ImageHandle, SystemTable); + +#if USB_RUNTIME_DRIVER_IN_SMM + Status = InitSmmHandler(ImageHandle, SystemTable, InSmmFunction, NULL); +#else + Status = InstallUsbProtocols(); + InitializeUsbGlobalData(); +#endif + ASSERT_EFI_ERROR(Status); + + return Status; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: InitializeUsbGlobalData +// +// Description: This function initializes the USB global data. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +InitializeUsbGlobalData( + VOID +) +{ + EFI_STATUS Status; + UINT8 bDriverIndex; + UINT8 bDelayedIndex; + + // + // Initialize host controller drivers + // + FillHcdEntries(); // This routine is implemented in $(BUILD_DIR)\dummyusbrt.c + + // + // Initialize the device driver pointers + // + bDriverIndex = 0; + bDelayedIndex = 0; + //(EIP71750)> + while(UsbDevDelayedDrivers[bDelayedIndex]) { + UsbDevDelayedDrivers[bDelayedIndex](&gUsbData->aDelayedDrivers[bDelayedIndex]); + if (gUsbData->aDelayedDrivers[bDelayedIndex].pfnDeviceInit) { + (*gUsbData->aDelayedDrivers[bDelayedIndex].pfnDeviceInit)(); + } + if (gUsbData->aDelayedDrivers[bDelayedIndex].bDevType) { + bDelayedIndex++; + } + } + + while(UsbDevDrivers[bDriverIndex]) { + UsbDevDrivers[bDriverIndex](&gUsbData->aDevDriverTable[bDriverIndex]); + if (gUsbData->aDevDriverTable[bDriverIndex].pfnDeviceInit) { + (*gUsbData->aDevDriverTable[bDriverIndex].pfnDeviceInit)(); + } + if (gUsbData->aDevDriverTable[bDriverIndex].bDevType) { + bDriverIndex++; + } + } + + // + // Allocate a block of memory to be used as a temporary + // buffer for USB mass transfer + // + Status = pBS->AllocatePool (EfiRuntimeServicesData, MAX_CONSUME_BUFFER_SIZE, + &gUsbData->fpUSBMassConsumeBuffer); + ASSERT_EFI_ERROR(Status); + pBS->SetMem(gUsbData->fpUSBMassConsumeBuffer, MAX_CONSUME_BUFFER_SIZE, 0); + + // + // Allocate a block of memory for the temporary buffer + // + Status = gBS->AllocatePool (EfiRuntimeServicesData, MAX_TEMP_BUFFER_SIZE, + &gUsbData->fpUSBTempBuffer); + ASSERT_EFI_ERROR(Status); + pBS->SetMem(gUsbData->fpUSBTempBuffer, MAX_TEMP_BUFFER_SIZE, 0); + + // + // Allow to enumerate ports + // + gUsbData->bEnumFlag = FALSE; + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UsbApiHandler +// +// Description: +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UsbApiHandler(VOID* Param) +{ + URP_STRUC *fpURP = (URP_STRUC*)Param; + UINT8 bFuncIndex; + UINT8 bNumberOfFunctions; + + if (fpURP == NULL) { + return; + } + + bFuncIndex = fpURP->bFuncNumber; + bNumberOfFunctions = sizeof aUsbApiTable / sizeof (API_FUNC *); + + // + // Make sure function number is valid; if function number is not zero + // check for valid extended USB API function + // + if (bFuncIndex && ((bFuncIndex < USB_NEW_API_START_FUNC ) || + bFuncIndex > (bNumberOfFunctions + USB_NEW_API_START_FUNC))) { + //fpURP->bRetValue = USBAPI_INVALID_FUNCTION; + USB_DEBUG(3, "UsbApiHandler Invalid function#%x\n", bFuncIndex); + return; + } + + if (bFuncIndex) { + bFuncIndex = (UINT8)(bFuncIndex - USB_NEW_API_START_FUNC + 1); + } + + aUsbApiTable[bFuncIndex](fpURP); // Call the appropriate function + +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: InstallUsbProtocols +// +// Description: This function initializes the USB global data. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +InstallUsbProtocols( + VOID +) +{ + EFI_STATUS Status; + EFI_USB_PROTOCOL *UsbProtocol; + + Status = pBS->LocateProtocol(&gEfiUsbProtocolGuid, NULL, &UsbProtocol); + if (EFI_ERROR(Status)) { + return Status; + } + gUsbData = UsbProtocol->USBDataPtr; + + UsbProtocol->UsbRtKbcAccessControl = UsbKbcAccessControl; + + //Hook USB legacy control function for shutdown/init USB legacy support + UsbProtocol->UsbLegacyControl = USBRT_LegacyControl; + UsbProtocol->UsbStopUnsupportedHc = USB_StopUnsupportedHc; +#if !USB_RUNTIME_DRIVER_IN_SMM + UsbProtocol->UsbInvokeApi = UsbApiHandler; +#endif + + return Status; +} + +#if USB_RUNTIME_DRIVER_IN_SMM +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: InSmmFunction +// +// Description: SMM entry point of AMIUSB driver +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +InSmmFunction( + EFI_HANDLE ImageHandle, + EFI_SYSTEM_TABLE *SystemTable +) +{ + EFI_STATUS Status; + + EFI_SMM_SW_DISPATCH_CONTEXT SwSmiContext; + EFI_HANDLE SwSmiHandle = NULL; + EFI_SMM_SW_DISPATCH_PROTOCOL *SwSmiDispatch; + + UINT32 KbcEmulFeature = 0; + VOID *ProtocolNotifyRegistration; + EFI_EVENT Emul6064Event = NULL; + + //(EIP54018+)> +#if USB_S5_WAKEUP_SUPPORT + EFI_SMM_SX_DISPATCH_CONTEXT S5DispatchContext; + EFI_SMM_SX_DISPATCH_PROTOCOL *SxDispatchProtocol; + EFI_SMM_POWER_BUTTON_DISPATCH_CONTEXT PbDispatchContext; + EFI_SMM_POWER_BUTTON_DISPATCH_PROTOCOL *PbDispatchProtocol; + EFI_HANDLE S5DispatchHandle; + EFI_HANDLE PbDispatchHandle; +#endif + //<(EIP54018+) +#if defined(PI_SPECIFICATION_VERSION)&&(PI_SPECIFICATION_VERSION>=0x0001000A)&&(CORE_COMBINED_VERSION >= 0x4028B) + EFI_HANDLE UsbSmmProtocolHandle = NULL; + + Status = InitAmiSmmLib(ImageHandle, SystemTable); + if (EFI_ERROR(Status)) return Status; +#endif + + InitAmiBufferValidationLib(ImageHandle, SystemTable); + + InstallUsbProtocols(); + InitializeUsbGlobalData(); + + + Status = pBS->LocateProtocol (&gEmul6064TrapProtocolGuid, NULL, &gEmulationTrap); + if (EFI_ERROR(Status)) { + Status = RegisterProtocolCallback(&gEmul6064TrapProtocolGuid, + Emul6064TrapCallback, + NULL, + &Emul6064Event, + &ProtocolNotifyRegistration); + } + + if(!gUsbData->kbc_support) { + Status = gBS->LocateProtocol (&gEmul6064MsInputProtocolGuid, NULL, &gMsInput); + pBS->LocateProtocol (&gEmul6064KbdInputProtocolGuid, NULL, &gKbdInput); + + if (Status == EFI_SUCCESS) { + gUsbData->dUSBStateFlag |= USB_FLAG_6064EMULATION_ON; + if(gEmulationTrap) + KbcEmulFeature = gEmulationTrap->FeatureSupported(gEmulationTrap); + if(KbcEmulFeature & IRQ_SUPPORTED) { + gUsbData->dUSBStateFlag |= USB_FLAG_6064EMULATION_IRQ_SUPPORT; + } + } else { + InitSysKbc( &gKbdInput, &gMsInput ); + } + } else { + // + //Init Fake Emulation interface + // + InitSysKbc( &gKbdInput, &gMsInput ); + } + + Status = USBSB_InstallSmiEventHandlers(); + + USB_DEBUG(DEBUG_LEVEL_3,"AMIUSB global data at 0x%x\n", gUsbData); + + // + // Register the USB SW SMI handler + // + Status = pBS->LocateProtocol (&gEfiSmmSwDispatchProtocolGuid, NULL, &SwSmiDispatch); + + if (EFI_ERROR (Status)) { + USB_DEBUG(DEBUG_LEVEL_0, "SmmSwDispatch protocol: %r\n", Status); + return Status; + } + + SwSmiContext.SwSmiInputValue = USB_SWSMI; + Status = SwSmiDispatch->Register (SwSmiDispatch, USBSWSMIHandler, &SwSmiContext, &SwSmiHandle); + + USB_DEBUG(DEBUG_LEVEL_3, "AMIUSB SW SMI registration:: %r\n", Status); + +#if defined(PI_SPECIFICATION_VERSION)&&(PI_SPECIFICATION_VERSION>=0x0001000A)&&(CORE_COMBINED_VERSION >= 0x4028B) + gUsbSmmProtocol.UsbStopUnsupportedHc = USB_StopUnsupportedHc; + gUsbSmmProtocol.UsbApiTable = aUsbApiTable; + gUsbSmmProtocol.UsbMassApiTable = aUsbMassApiTable; + gUsbSmmProtocol.GlobalDataValidation.ConstantDataCrc32 = 0; + gUsbSmmProtocol.GlobalDataValidation.Crc32Hash = (UINT32)GetCpuTimer(); + + Status = pSmst->SmmInstallProtocolInterface( + &UsbSmmProtocolHandle, + &gAmiUsbSmmProtocolGuid, + EFI_NATIVE_INTERFACE, + &gUsbSmmProtocol + ); + + USB_DEBUG(DEBUG_LEVEL_3, "AMIUSB SMM protocol: %r\n", Status); +#endif + +#if defined(PI_SPECIFICATION_VERSION)&&(PI_SPECIFICATION_VERSION>=0x0001000A)&&(CORE_COMBINED_VERSION >= 0x4028B) + InitAmiUsbSmmGlobalDataValidationLib(ImageHandle, SystemTable); + UpdateAmiUsbSmmGlobalDataCrc32(gUsbData); +#endif + + //(EIP54018+)> +#if USB_S5_WAKEUP_SUPPORT + Status = pBS->LocateProtocol( + &gEfiSmmSxDispatchProtocolGuid, + NULL, + &SxDispatchProtocol + ); + + if (EFI_ERROR(Status)) { + return Status; + } + + S5DispatchContext.Type = SxS5; + S5DispatchContext.Phase = SxEntry; + Status = SxDispatchProtocol->Register( + SxDispatchProtocol, + UsbS5SmiCallback, + &S5DispatchContext, + &S5DispatchHandle + ); + + if (EFI_ERROR(Status)) { + return Status; + } + + // Locate Power Button Dispatch Protocol + Status = pBS->LocateProtocol( + &gEfiSmmPowerButtonDispatchProtocolGuid, + NULL, + &PbDispatchProtocol + ); + + if (EFI_ERROR(Status)) { + return Status; + } + + // Register the handler for power button presses + PbDispatchContext.Phase = PowerButtonEntry; + Status = PbDispatchProtocol->Register( + PbDispatchProtocol, + UsbPowerButtonSmiCallback, + &PbDispatchContext, + &PbDispatchHandle + ); +#endif + //<(EIP54018+) + + return Status; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBSWSMIHandler +// +// Description: Invoked on reads from SW SMI port with value USB_SWSMI. This +// function dispatches the USB Request Packets (URP) to the +// appropriate functions. +// +// Input: EBDA:USB_DATA_EBDA_OFFSET - Pointer to the URP (USB Request +// Packet structure) +// DispatchHandle - EFI Handle +// DispatchContext - Pointer to the EFI_SMM_SW_DISPATCH_CONTEXT +// +// Output: bRetValue Zero on successfull completion +// Non-zero on error +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBSWSMIHandler ( + EFI_HANDLE DispatchHandle, + EFI_SMM_SW_DISPATCH_CONTEXT *DispatchContext +) +{ + URP_STRUC *UsbUrp; + UINT16 EbdaSeg; + EFI_STATUS Status; + + if (gLockSmiHandler == TRUE) { + return; + } +#if defined(PI_SPECIFICATION_VERSION)&&(PI_SPECIFICATION_VERSION>=0x0001000A)&&(CORE_COMBINED_VERSION >= 0x4028B) + Status = AmiUsbSmmGlobalDataValidation(gUsbData); + + ASSERT_EFI_ERROR(Status); + + if (EFI_ERROR(Status)) { + gLockHwSmiHandler = TRUE; + gLockSmiHandler = TRUE; + return; + } +#endif + + if (gUsbData->fpURP) { // Call from AMIUSB C area + Status = AmiValidateMemoryBuffer((VOID*)gUsbData->fpURP, sizeof(URP_STRUC)); + if (EFI_ERROR(Status)) { + USB_DEBUG(3, "UsbApiHandler Invalid Pointer, the address is in SMRAM.\n"); + return; + } + UsbUrp = gUsbData->fpURP; + gUsbData->fpURP = 0; // Clear the switch + } else { + if (gUsbData->dUSBStateFlag & USB_FLAG_RUNNING_UNDER_OS) { + return; + } + // + // Get the fpURP pointer from EBDA + // + EbdaSeg = *((UINT16*)0x40E); + UsbUrp = *(URP_STRUC**)(UINTN)(((UINT32)EbdaSeg << 4) + USB_DATA_EBDA_OFFSET); + UsbUrp = (URP_STRUC*)((UINTN)UsbUrp & 0xFFFFFFFF); + Status = AmiValidateMemoryBuffer((VOID*)UsbUrp, sizeof(URP_STRUC)); + if (EFI_ERROR(Status)) { + USB_DEBUG(3, "UsbApiHandler Invalid Pointer, the address is in SMRAM.\n"); + return; + } + } + + if (UsbUrp == NULL) { + return; + } + + gCheckUsbApiParameter = TRUE; + + UsbApiHandler(UsbUrp); + + gCheckUsbApiParameter = FALSE; + +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: UsbHwSmiHandler +// +// Description: USB Hardware SMI handler. +// +// Input: Host controller type. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UsbHwSmiHandler (UINT8 HcType) +{ + UINT8 Index; + HC_STRUC *HcStruc; + EFI_STATUS Status; + + if (gLockHwSmiHandler == TRUE) { + return; + } + +#if defined(PI_SPECIFICATION_VERSION)&&(PI_SPECIFICATION_VERSION>=0x0001000A)&&(CORE_COMBINED_VERSION >= 0x4028B) + Status = AmiUsbSmmGlobalDataValidation(gUsbData); + + ASSERT_EFI_ERROR(Status); + + if (EFI_ERROR(Status)) { + gLockHwSmiHandler = TRUE; + gLockSmiHandler = TRUE; + return; + } +#endif + + for (Index = 0; Index < gUsbData->HcTableCount; Index++) { + HcStruc = gUsbData->HcTable[Index]; + if (HcStruc == NULL) { + continue; + } + if (!(HcStruc->dHCFlag & HC_STATE_USED)) { + continue; + } + if (HcStruc->bHCType == HcType) { // Process appropriate interrupt + (*gUsbData->aHCDriverTable + [GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDProcessInterrupt)(HcStruc); + } + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: xhciHWSMIHandler +// +// Description: USB Hardware SMI handler. +// +// Input: DispatchHandle - EFI Handle +// DispatchContext - Pointer to the EFI_SMM_SW_DISPATCH_CONTEXT +// +// Output: Nothing +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UhciHWSMIHandler ( + EFI_HANDLE DispatchHandle, + EFI_SMM_USB_DISPATCH_CONTEXT *DispatchContext + ) +{ + UsbHwSmiHandler(USB_HC_UHCI); +} +VOID +OhciHWSMIHandler ( + EFI_HANDLE DispatchHandle, + EFI_SMM_USB_DISPATCH_CONTEXT *DispatchContext + ) +{ + UsbHwSmiHandler(USB_HC_OHCI); +} +VOID +EhciHWSMIHandler ( + EFI_HANDLE DispatchHandle, + EFI_SMM_USB_DISPATCH_CONTEXT *DispatchContext + ) +{ + UsbHwSmiHandler(USB_HC_EHCI); +} + +VOID +XhciHwSmiHandler ( + EFI_HANDLE DispatchHandle, + VOID *DispatchContext + ) +{ + UsbHwSmiHandler(USB_HC_XHCI); +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: USBInstallHwSmiHandler +// +// Description: +// This function registers USB hardware SMI callback function. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +UsbInstallHwSmiHandler( + HC_STRUC *HcStruc +) +{ + EFI_STATUS Status; + EFI_SMM_USB_DISPATCH_CONTEXT UsbContext; + EFI_SMM_USB_DISPATCH_PROTOCOL *UsbDispatch; + EFI_SMM_USB_DISPATCH UsbCallback; + EFI_HANDLE Handle = NULL; + + if (HcStruc->HwSmiHandle != NULL) { + return EFI_SUCCESS; + } + + Status = gBS->LocateProtocol( + &gEfiSmmUsbDispatchProtocolGuid, + NULL, + &UsbDispatch); + ASSERT_EFI_ERROR(Status); + if (EFI_ERROR(Status)) { + return Status; + } + + switch (HcStruc->bHCType) { + case USB_HC_UHCI: + UsbCallback = UhciHWSMIHandler; + break; + + case USB_HC_OHCI: + UsbCallback = OhciHWSMIHandler; + break; + + case USB_HC_EHCI: + UsbCallback = EhciHWSMIHandler; + break; + + case USB_HC_XHCI: + UsbCallback = XhciHwSmiHandler; + break; + + default: + return EFI_UNSUPPORTED; + } + + UsbContext.Type = UsbLegacy; + UsbContext.Device = HcStruc->pHCdp; + + Status = UsbDispatch->Register( + UsbDispatch, + UsbCallback, + &UsbContext, + &Handle); + + USB_DEBUG(DEBUG_LEVEL_3, "AMIUSB HC type %x HW SMI registation status:: %r\n", HcStruc->bHCType, Status); + + if (!EFI_ERROR(Status)) { + HcStruc->HwSmiHandle = Handle; + } + + return Status; +} +#endif + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: Emul6064TrapCallback +// +// Description: +// Update the KbcEmul feature when the Emul6064Trap Protocol becomes available. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +Emul6064TrapCallback ( + EFI_EVENT Event, + VOID *Context +) +{ + EFI_STATUS Status; + UINT32 KbcEmulFeature = 0; + + Status = gBS->LocateProtocol( + &gEmul6064TrapProtocolGuid, + NULL, + &gEmulationTrap); + + if(!gUsbData->kbc_support) { + Status = gBS->LocateProtocol( + &gEmul6064MsInputProtocolGuid, + NULL, + &gMsInput); + + gBS->LocateProtocol( + &gEmul6064KbdInputProtocolGuid, + NULL, + &gKbdInput); + + if (Status == EFI_SUCCESS) { + gUsbData->dUSBStateFlag |= USB_FLAG_6064EMULATION_ON; + if(gEmulationTrap) + KbcEmulFeature = gEmulationTrap->FeatureSupported(gEmulationTrap); + if(KbcEmulFeature & IRQ_SUPPORTED) { + gUsbData->dUSBStateFlag |= USB_FLAG_6064EMULATION_IRQ_SUPPORT; + } + } else { + InitSysKbc( &gKbdInput, &gMsInput ); + } + } else { + // + //Init Fake Emulation interface + // + InitSysKbc( &gKbdInput, &gMsInput ); + } +} + +////////////////////////////////////////////////////////////////////////////// +// +// USB API Functions +// +////////////////////////////////////////////////////////////////////////////// + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_MassDeviceRequest +// +// Description: This routine services the USB API function number 27h. It +// handles all the mass storage related calls from the higher +// layer. Different sub-functions are invoked depending on +// the sub-function number +// +// Input: fpURPPointer Pointer to the URP structure +// fpURPPointer.bSubFunc Subfunction number +// 00 Get Device Information +// 01 Get Device Parameter +// 02 Reset Device +// 03 Read Device +// 04 Write Device +// 05 Verify Device +// 06 Format Device +// 07 Request Sense +// 08 Test Unit Ready +// 09 Start Stop Unit +// 0A Read Capacity +// 0B Mode Sense +// 0C Device Inquiry +// 0D Send Command +// 0E Assign drive number +// +// Output: URP structure is updated with the relevant information +// +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBAPI_MassDeviceRequest (URP_STRUC *fpURP) +{ + UINT8 bMassFuncIndex = fpURP->bSubFunc; + UINT8 bNumberOfMassFunctions = sizeof aUsbMassApiTable / sizeof (API_FUNC *); + + // + // Make sure function number is valid + // + if (bMassFuncIndex >= bNumberOfMassFunctions) { + //fpURP->bRetValue = USBAPI_INVALID_FUNCTION; + USB_DEBUG(3, "UsbApi MassDeviceRequet Invalid function#%x\n", bMassFuncIndex); + return; + } + gUsbData->bUSBKBC_MassStorage = 01; + // + // Function number is valid - call it + // + aUsbMassApiTable[bMassFuncIndex](fpURP); + gUsbData->bUSBKBC_MassStorage = 00; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_CheckPresence +// +// Description: This routine services the USB API function number 0. It +// reports the USB BIOS presence, its version number and +// its current status information +// +// Input: fpURPPointer - Pointer to the URP structure +// +// Output: URP structure is updated with the following information +// CkPresence.wBiosRev USB BIOS revision (0210h means r2.10) +// CkPresence.bBiosActive 0 - if USB BIOS is not running +// CkPresence.bNumBootDev Number of USB boot devices found +// CkPresence.bNumHC Number of host controller present +// CkPresence.bNumPorts Number of root hub ports +// CkPresence.dUsbDataArea Current USB data area +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBAPI_CheckPresence (URP_STRUC *fpURP) +{ + fpURP->bRetValue = USB_SUCCESS; + fpURP->ApiData.CkPresence.bBiosActive = 0; + + fpURP->ApiData.CkPresence.bNumBootDev = 0; // Number of USB boot devices found + fpURP->ApiData.CkPresence.bNumKeyboards = 0; // Number of USB keyboards present + fpURP->ApiData.CkPresence.bNumMice = 0; // Number of USB mice present + fpURP->ApiData.CkPresence.bNumPoint = 0; // Number of USB Point present //(EIP38434+) + fpURP->ApiData.CkPresence.bNumHubs = 0; // Number of USB hubs present + fpURP->ApiData.CkPresence.bNumStorage = 0; // Number of USB storage devices present + + fpURP->ApiData.CkPresence.wBiosRev = (USB_DRIVER_MAJOR_VER << 4) + USB_DRIVER_MINOR_VER; + fpURP->ApiData.CkPresence.bBiosActive = USB_ACTIVE; // Set USB BIOS as active + if (!(gUsbData->dUSBStateFlag & USB_FLAG_DISABLE_LEGACY_SUPPORT)) { + fpURP->ApiData.CkPresence.bBiosActive |= USB_LEGACY_ENABLE; + } + if (gUsbData->dUSBStateFlag & USB_FLAG_6064EMULATION_ON) { + fpURP->ApiData.CkPresence.bBiosActive |= USB_6064_ENABLE; + } + USBWrap_GetDeviceCount(fpURP); // Get active USB devices +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_Start +// +// Description: This API routine configures the USB host controllers and +// enumerate the devices +// +// Input: fpURPPointer URP structure with input parameters +// StartHc.wDataAreaFlag Indicates which data area to use +// +// Output: StartHc.wDataAreaFlag Returns current data area pointer +// bRetValue - USB_SUCCESS on success, USB_ERROR on error. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID USBAPI_Start (URP_STRUC *fpURP) +{ + USB_DEBUG(DEBUG_LEVEL_3, "USBSMI: Start\n"); + USB_DEBUG(DEBUG_LEVEL_3, "\tUSBAPI_HC_Proc:%x\n", &USBAPI_HC_Proc); + USB_DEBUG(DEBUG_LEVEL_3, "\tUSBAPI_Core_Proc:%x\n", &USBAPI_Core_Proc); + USB_DEBUG(DEBUG_LEVEL_3, "\tUSB_ReConfigDevice:%x\n", &USB_ReConfigDevice); + fpURP->bRetValue = USB_StartHostControllers (gUsbData); + USB_DEBUG(DEBUG_LEVEL_3, "USB_StartHostControllers returns %d\n", fpURP->bRetValue); +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_Stop +// +// Description: This routine stops the USB host controllers +// +// Input: fpURPPointer Pointer to the URP structure +// +// Output: bRetValue USB_SUCCESS on success +// USB_ERROR on error +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID USBAPI_Stop (URP_STRUC *fpURP) +{ + gCheckUsbApiParameter = FALSE; + fpURP->bRetValue = USB_StopHostControllers (gUsbData); + USB_DEBUG(DEBUG_LEVEL_3, "USB_StopHostControllers returns %d\n", fpURP->bRetValue); + gUsbData->dUSBStateFlag &= ~(USB_FLAG_DRIVER_STARTED); +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_PowerManageUSB +// +// Description: This routine suspends the USB host controllers +// +// Input: fpURPPointer Pointer to the URP structure +// +// Output: None +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID USBAPI_PowerManageUSB (URP_STRUC *fpURP) +{ + fpURP->bRetValue = USB_NOT_SUPPORTED; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_PrepareForOS +// +// Description: This routine updates data structures to reflect that +// POST is completed +// +// Input: fpURPPointer Pointer to the URP structure +// +// Output: None +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID USBAPI_PrepareForOS (URP_STRUC *fpURP) +{ + fpURP->bRetValue = USB_NOT_SUPPORTED; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_SecureInterface +// +// Description: This routine handles the calls related to security device +// +// Input: fpURPPointer Pointer to the URP structure +// +// Output: None +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID USBAPI_SecureInterface (URP_STRUC *fpURP) +{ + fpURP->bRetValue = USB_NOT_SUPPORTED; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_DisableInterrupts +// +// Description: This routine stops the USB host controllers interrupts +// +// Input: fpURPPointer Pointer to the URP structure +// +// Output: bRetValue USB_SUCCESS on success +// USB_ERROR on error (Like data area not found) +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID USBAPI_DisableInterrupts (URP_STRUC *fpURP) +{ + fpURP->bRetValue = USB_NOT_SUPPORTED; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_EnableInterrupts +// +// Description: This routine re-enable the USB host controller interrupts +// +// Input: fpURPPointer Pointer to the URP structure +// +// Output: bRetValue USB_SUCCESS on success +// USB_ERROR on error (Like data area not found) +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID USBAPI_EnableInterrupts (URP_STRUC *fpURP) +{ + fpURP->bRetValue = USB_NOT_SUPPORTED; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_MoveDataArea +// +// Description: This routine stops the USB host controllers and moves +// the data area used by host controllers to a new area. +// The host controller is started from the new place. +// +// Input: fpURPPointer URP structure with input parameters +// StartHc.wDataAreaFlag Indicates which data area to use +// +// Output: bRetValue USB_SUCCESS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID USBAPI_MoveDataArea(URP_STRUC *fpURP) +{ + fpURP->bRetValue = USB_NOT_SUPPORTED; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_GetDeviceInfo +// +// Description: This routine returns the information regarding +// a USB device like keyboard, mouse, floppy drive etc +// +// Input: fpURPPointer URP structure with input parameters +// GetDevInfo.bDevNumber Device number (1-based) whose +// information is requested +// +// Output: URP structure is updated with the following information +// GetDevInfo.bHCNumber - HC number in which the device is found +// GetDevInfo.bDevType - Type of the device +// bRetValue will be one of the following value +// USB_SUCCESS on successfull completion +// USB_PARAMETER_ERROR if bDevNumber is invalid +// USB_ERROR on error +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID USBAPI_GetDeviceInfo (URP_STRUC *fpURP) +{ + DEV_INFO* fpDevInfo; + + // + // Initialize the return values + // + fpURP->ApiData.GetDevInfo.bHCNumber = 0; + fpURP->ApiData.GetDevInfo.bDevType = 0; + fpURP->bRetValue = USB_ERROR; + + // + // Check for parameter validity + // + if ( !fpURP->ApiData.GetDevInfo.bDevNumber ) return; + + fpURP->bRetValue = USB_PARAMETER_ERROR; + + // + // Get the device information structure for the 'n'th device + // + fpDevInfo = USBWrap_GetnthDeviceInfoStructure(fpURP->ApiData.GetDevInfo.bDevNumber); +// if (!wRetCode) return; // USB_PARAMETER_ERROR + + // + // Return value + // + fpURP->ApiData.GetDevInfo.bDevType = fpDevInfo->bDeviceType; + fpURP->ApiData.GetDevInfo.bHCNumber = fpDevInfo->bHCNumber; + fpURP->bRetValue = USB_SUCCESS; + +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_CheckDevicePresence +// +// Description: This routine checks whether a particular type of USB device +// is installed in the system or not. +// +// Input: fpURPPointer URP structure with input parameters +// ChkDevPrsnc.bDevType Device type to find +// ChkDevPrsnc.fpHCStruc Pointer to HC being checked for device +// connection; if NULL then the total number of devices +// connected to ANY controller is returned. +// ChkDevPrsnc.bNumber Number of devices connected +// +// Output: bRetValue will be one of the following value +// USB_SUCCESS if device type present, ChkDevPrsnc.bNumber <> 0 +// USB_ERROR if device type absent, ChkDevPrsnc.bNumber returns 0 +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBAPI_CheckDevicePresence (URP_STRUC *fpURP) +{ + UINT8 bSearchFlag; + UINTN dData; + + bSearchFlag = USB_SRCH_DEV_NUM; + if (fpURP->bSubFunc == 1) + { + bSearchFlag = USB_SRCH_DEVBASECLASS_NUM; + } + // + // The total number of devices connected to ANY controller has been requested + // + dData = (UINTN) USB_GetDeviceInfoStruc( bSearchFlag, + 0, fpURP->ApiData.ChkDevPrsnc.bDevType, fpURP->ApiData.ChkDevPrsnc.fpHCStruc); + + fpURP->ApiData.ChkDevPrsnc.bNumber = (UINT8)dData; + fpURP->bRetValue = (UINT8)((fpURP->ApiData.ChkDevPrsnc.bNumber)? + USB_SUCCESS : USB_ERROR); +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassAPIGetDeviceInformation +// +// Description: This function is part of the USB BIOS MASS API. This function +// returns the device information of the mass storage device +// +// Input: fpURPPointer Pointer to the URP structure +// bDevAddr USB device address of the device +// +// Output: bRetValue Return value +// fpURPPointer Pointer to the URP structure +// dSenseData Sense data of the last command +// bDevType Device type byte (HDD, CD, Removable) +// bEmuType Emulation type used +// fpDevId Far pointer to the device ID +// dInt13Entry INT 13h entry point +// +// Notes: Initially the bDevAddr should be set to 0 as input. This +// function returns the information regarding the first mass +// storage device (if no device found it returns bDevAddr as +// 0FFh) and also updates bDevAddr to the device address of +// the current mass storage device. If no other mass storage +// device is found then the routine sets the bit7 to 1 +// indicating current information is valid but no more mass +// device found in the system. The caller can get the next +// device info if bDevAddr is not 0FFh and bit7 is not set +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassAPIGetDeviceInformation (URP_STRUC *fpURP) +{ + fpURP->bRetValue = USBMassGetDeviceInfo (&fpURP->ApiData.MassGetDevInfo); +} + +VOID +USBMassAPIGetDeviceParameters (URP_STRUC *fpURP) +{ + DEV_INFO *DevInfo; + EFI_STATUS Status; + + DevInfo = fpURP->ApiData.MassGetDevParms.fpDevInfo; + + Status = UsbDevInfoValidation(DevInfo); + + if (EFI_ERROR(Status)) { + return; + } + +#if USB_RUNTIME_DRIVER_IN_SMM + if (gCheckUsbApiParameter) { + Status = AmiValidateMemoryBuffer((VOID*)fpURP->ApiData.MassGetDevParms.fpInqData, sizeof(MASS_INQUIRY)); + if (EFI_ERROR(Status)) { + return; + } + gCheckUsbApiParameter = FALSE; + } +#endif + + fpURP->ApiData.MassGetDevParms.fpInqData = USBMassGetDeviceParameters(DevInfo); + fpURP->bRetValue = (fpURP->ApiData.MassGetDevParms.fpInqData == NULL)? USB_ERROR : USB_SUCCESS; +} + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBMassAPIGetDevStatus +// +// Description: This function returns the drive status and media presence +// status +// +// Input: fpURPPointer Pointer to the URP structure +// fpURP->ApiData.fpDevInfo - pointer to USB device that is +// requested to be checked +// +// Output: Return code USB_ERROR - Failure, USB_SUCCESS - Success +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> + +VOID +USBMassAPIGetDevStatus(URP_STRUC *fpURP) +{ +#if USB_DEV_MASS + fpURP->bRetValue = USBMassGetDeviceStatus (&fpURP->ApiData.MassGetDevSts); +// USB_DEBUG(DEBUG_LEVEL_3, "USBMassAPIGetDevStatus ... check function call correct?\n"); +#endif +} + + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassAPIGetDeviceGeometry +// +// Description: This function is part of the USB BIOS MASS API. +// +// Input: fpURPPointer Pointer to the URP structure +// bDevAddr USB device address of the device +// +// Output: bRetValue Return value +// fpURPPointer Pointer to the URP structure +// dSenseData Sense data of the last command +// bNumHeads Number of heads +// wNumCylinders Number of cylinders +// bNumSectors Number of sectors +// wBytesPerSector Number of bytes per sector +// bMediaType Media type +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassAPIGetDeviceGeometry(URP_STRUC *fpURP) +{ + fpURP->bRetValue = USBMassGetDeviceGeometry (&fpURP->ApiData.MassGetDevGeo); +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassAPIResetDevice +// +// Description: This function is part of the USB BIOS MASS API. +// +// Input: fpURPPointer Pointer to the URP structure +// +// Output: bRetValue Return value +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassAPIResetDevice (URP_STRUC *fpURP) +{ + UINT8 bDevAddr; + DEV_INFO *fpDevInfo; + UINT16 wResult; + + bDevAddr = fpURP->ApiData.MassReset.bDevAddr; + + // + // Get the device info structure for the matching device address + // + fpDevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_INDX, 0, bDevAddr, 0); + if((fpDevInfo == NULL)|| (!(fpDevInfo->Flag & DEV_INFO_DEV_PRESENT))) { + fpURP->bRetValue = USB_ATA_TIME_OUT_ERR; + return; + } + // + // Send Start/Stop Unit command to UFI class device only + // + fpURP->bRetValue = USB_SUCCESS; + if(fpDevInfo->bSubClass == SUB_CLASS_UFI) { + wResult = USBMassStartUnitCommand (fpDevInfo); + if (wResult) { + fpURP->bRetValue = USBWrapGetATAErrorCode(fpURP->ApiData.MassReset.dSenseData); + } + } +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassAPIReadDevice +// +// Description: This function is part of the USB BIOS MASS API. +// +// Input: fpURPPointer Pointer to the URP structure, it contains the following: +// bDevAddr USB device address of the device +// dStartLBA Starting LBA address +// wNumBlks Number of blocks to read +// wPreSkipSize Number of bytes to skip before +// wPostSkipSize Number of bytes to skip after +// fpBufferPtr Far buffer pointer +// +// Output: fpURPPointer Pointer to the URP structure +// bRetValue Return value +// dSenseData Sense data of the last command +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassAPIReadDevice ( + URP_STRUC *Urp +) +{ + DEV_INFO *DevInfo; + UINT8 DevAddr; + UINT16 Result; + UINT32 Data = 0; + UINT8 OpCode; + + DevAddr = Urp->ApiData.MassRead.DevAddr; + + if (((DevAddr == USB_HOTPLUG_FDD_ADDRESS) && + ((gUsbData->dUSBStateFlag & USB_HOTPLUG_FDD_ENABLED) == FALSE)) || + ((DevAddr == USB_HOTPLUG_HDD_ADDRESS) && + ((gUsbData->dUSBStateFlag & USB_HOTPLUG_HDD_ENABLED) == FALSE)) || + ((DevAddr == USB_HOTPLUG_CDROM_ADDRESS) && + ((gUsbData->dUSBStateFlag & USB_HOTPLUG_CDROM_ENABLED) == FALSE))) { + Urp->bRetValue = USB_ATA_DRIVE_NOT_READY_ERR; + return; + } + + // + // Get the device info structure for the matching device address + // + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_INDX, 0, DevAddr, 0); + if ((DevInfo == NULL)|| (!(DevInfo->Flag & DEV_INFO_DEV_PRESENT))) { + Urp->bRetValue = USB_ATA_TIME_OUT_ERR; + return; + } + + //(EIP15037+)> +#if EXTRA_CHECK_DEVICE_READY + // + // Check device ready + // + Data = USBMassCheckDeviceReady(DevInfo); + if (Data) { + Urp->ApiData.MassRead.dSenseData = Data; + Urp->bRetValue = USBWrapGetATAErrorCode(Urp->ApiData.MassRead.dSenseData); //(EIP31535) + return; + } +#endif + //<(EIP15037+) + + // + // Issue read command + // + if (Shr64(DevInfo->MaxLba, 32)) { + OpCode = COMMON_READ_16_OPCODE; + } else { + OpCode = COMMON_READ_10_OPCODE; + } + Result = USBMassRWVCommand(DevInfo, OpCode, &Urp->ApiData.MassRead); + //USB_DEBUG(DEBUG_LEVEL_3, " wr(%x):%x %x", DevAddr, Result, Urp->ApiData.MassRead.dSenseData); + if (Result) { + Urp->bRetValue = USB_SUCCESS; + return; + } + Urp->bRetValue = USBWrapGetATAErrorCode(Urp->ApiData.MassRead.SenseData); + //USB_DEBUG(DEBUG_LEVEL_3, " er(%x):%x", DevAddr, Urp->bRetValue); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassAPIWriteDevice +// +// Description: This function is part of the USB BIOS MASS API. +// +// Input: fpURPPointer Pointer to the URP structure +// bDevAddr USB device address of the device +// dStartLBA Starting LBA address +// wNumBlks Number of blocks to write +// wPreSkipSize Number of bytes to skip before +// wPostSkipSize Number of bytes to skip after +// fpBufferPtr Far buffer pointer +// +// Output: fpURPPointer Pointer to the URP structure +// bRetValue Return value +// dSenseData Sense data of the last command +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassAPIWriteDevice( + URP_STRUC *Urp +) +{ + DEV_INFO *DevInfo; + UINT8 DevAddr; + UINT16 Result; + UINT32 Data = 0; + UINT8 OpCode; + + DevAddr = Urp->ApiData.MassWrite.DevAddr; + + if (((DevAddr == USB_HOTPLUG_FDD_ADDRESS) && + ((gUsbData->dUSBStateFlag & USB_HOTPLUG_FDD_ENABLED) == FALSE)) || + ((DevAddr == USB_HOTPLUG_HDD_ADDRESS) && + ((gUsbData->dUSBStateFlag & USB_HOTPLUG_HDD_ENABLED) == FALSE)) || + ((DevAddr == USB_HOTPLUG_CDROM_ADDRESS) && + ((gUsbData->dUSBStateFlag & USB_HOTPLUG_CDROM_ENABLED) == FALSE))) { + Urp->bRetValue = USB_ATA_DRIVE_NOT_READY_ERR; + return; + } + + // + // Get the device info structure for the matching device address + // + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_INDX, 0, DevAddr, 0); + if((DevInfo == NULL)|| (!(DevInfo->Flag & DEV_INFO_DEV_PRESENT))) { + Urp->bRetValue = USB_ATA_TIME_OUT_ERR; + return; + } +/* + if (!(DevInfo->bLastStatus & USB_MASS_MEDIA_PRESENT)) { + Urp->bRetValue = USB_ATA_NO_MEDIA_ERR; + return; + } +*/ + //(EIP15037+)> +#if EXTRA_CHECK_DEVICE_READY + // + // Check device ready + // + Data = USBMassCheckDeviceReady(DevInfo); + if (Data) { + Urp->ApiData.MassRead.dSenseData = Data; + Urp->bRetValue = USBWrapGetATAErrorCode(Urp->ApiData.MassWrite.dSenseData); //(EIP31535) + return; + } +#endif + //<(EIP15037+) + + // + // Issue write command + // + if (Shr64(DevInfo->MaxLba, 32)) { + OpCode = COMMON_WRITE_16_OPCODE; + } else { + OpCode = COMMON_WRITE_10_OPCODE; + } + Result = USBMassRWVCommand(DevInfo, OpCode, &Urp->ApiData.MassWrite); + if (Result) { + Urp->bRetValue = USB_SUCCESS; + return; + } + + Urp->bRetValue = USBWrapGetATAErrorCode(Urp->ApiData.MassWrite.SenseData); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassAPIVerifyDevice +// +// Description: This function is part of the USB BIOS MASS API. +// +// Input: fpURPPointer Pointer to the URP structure +// bDevAddr USB device address of the device +// dStartLBA Starting LBA address +// wNumBlks Number of blocks to write +// wPreSkipSize Number of bytes to skip before +// wPostSkipSize Number of bytes to skip after +// fpBufferPtr Far buffer pointer +// +// Output: fpURPPointer Pointer to the URP structure +// bRetValue Return value +// dSenseData Sense data of the last command +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassAPIVerifyDevice( + URP_STRUC *Urp +) +{ + DEV_INFO *DevInfo; + UINT8 DevAddr; + UINT16 Result; + UINT32 Data = 0; + UINT8 OpCode; + + DevAddr = Urp->ApiData.MassVerify.DevAddr; + + if (((DevAddr == USB_HOTPLUG_FDD_ADDRESS) && + ((gUsbData->dUSBStateFlag & USB_HOTPLUG_FDD_ENABLED) == FALSE)) || + ((DevAddr == USB_HOTPLUG_HDD_ADDRESS) && + ((gUsbData->dUSBStateFlag & USB_HOTPLUG_HDD_ENABLED) == FALSE)) || + ((DevAddr == USB_HOTPLUG_CDROM_ADDRESS) && + ((gUsbData->dUSBStateFlag & USB_HOTPLUG_CDROM_ENABLED) == FALSE))) { + Urp->bRetValue = USB_ATA_DRIVE_NOT_READY_ERR; + return; + } + + // + // Get the device info structure for the matching device address + // + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_INDX, 0, DevAddr, 0); + if ((DevInfo == NULL)|| (!(DevInfo->Flag & DEV_INFO_DEV_PRESENT))) { + Urp->bRetValue = USB_ATA_TIME_OUT_ERR; + return; + } + //(EIP15037+)> +#if EXTRA_CHECK_DEVICE_READY + // + // Check device ready + // + Data = USBMassCheckDeviceReady(DevInfo); + if (Data) { + Urp->ApiData.MassRead.dSenseData = Data; + Urp->bRetValue = USBWrapGetATAErrorCode(Urp->ApiData.MassVerify.dSenseData); //(EIP31535) + return; + } +#endif + //<(EIP15037+) + + // + // Issue write command + // + if (Shr64(DevInfo->MaxLba, 32)) { + OpCode = COMMON_VERIFY_16_OPCODE; + } else { + OpCode = COMMON_VERIFY_10_OPCODE; + } + Result = USBMassRWVCommand(DevInfo, OpCode, &Urp->ApiData.MassVerify); + if (Result) { + Urp->bRetValue = USB_SUCCESS; + return; + } + + Urp->bRetValue = USBWrapGetATAErrorCode(Urp->ApiData.MassVerify.SenseData); + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassAPIFormatDevice +// +// Description: This function is part of the USB BIOS MASS API. +// +// Input: fpURPPointer Pointer to the URP structure +// +// Output: bRetValue Return value +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassAPIFormatDevice(URP_STRUC *fpURP) +{ + fpURP->bRetValue = USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassAPICommandPassThru +// +// Description: This function is part of the USB BIOS MASS API. This +// function can be used to pass raw command/data sequence to +// the USB mass storage device +// +// Input: fpURPPointer Pointer to the URP structure +// +// Output: bRetValue Return value +// +// Modified: Nothing +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassAPICommandPassThru (URP_STRUC *fpURP) +{ + UINT8 Result; + MASS_CMD_PASS_THRU *MassCmdPassThru; + EFI_STATUS Status = EFI_SUCCESS; + + MassCmdPassThru = &fpURP->ApiData.MassCmdPassThru; + +#if USB_RUNTIME_DRIVER_IN_SMM + if (gCheckUsbApiParameter) { + Status = AmiValidateMemoryBuffer((VOID*)MassCmdPassThru->fpCmdBuffer, MassCmdPassThru->wCmdLength); + if (EFI_ERROR(Status)) { + return; + } + Status = AmiValidateMemoryBuffer((VOID*)MassCmdPassThru->fpDataBuffer, MassCmdPassThru->wDataLength); + if (EFI_ERROR(Status)) { + return; + } + gCheckUsbApiParameter = FALSE; + } +#endif + + Result = USBMassCmdPassThru(MassCmdPassThru); + + fpURP->bRetValue = Result; +} + + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBMassAPIAssignDriveNumber +// +// Description: This function is part of the USB BIOS MASS API. This function +// assigns the logical drive device according to the information of the +// mass storage device +// +// Input: fpURPPointer Pointer to the URP structure +// bDevAddr USB device address of the device +// bLogDevNum Logical Drive Number to assign to the device +// +// Output: Return code USB_ERROR - Failure, USB_SUCCESS - Success +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> + +VOID +USBMassAPIAssignDriveNumber (URP_STRUC *fpURP) +{ + fpURP->bRetValue = USB_SUCCESS; // No errors expected after this point +} + + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBMassAPICheckDevStatus +// +// Description: This function is part of the USB BIOS MASS API. This function +// invokes USB Mass Storage API handler to check whether device +// is ready. If called for the first time, this function retrieves +// the mass storage device geometry and fills the corresponding +// fpDevInfo fields. +// +// Input: fpURPPointer Pointer to the URP structure +// fpURP->ApiData.fpDevInfo - pointer to USB device that is +// requested to be checked +// +// Output: Return code USB_ERROR - Failure, USB_SUCCESS - Success +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> + +VOID +USBMassAPICheckDevStatus(URP_STRUC *fpURP) +{ +#if USB_DEV_MASS + UINT32 Result; + DEV_INFO *DevInfo; + EFI_STATUS Status; + + DevInfo = fpURP->ApiData.MassChkDevReady.fpDevInfo; + + Status = UsbDevInfoValidation(DevInfo); + + if (EFI_ERROR(Status)) { + return; + } + + gCheckUsbApiParameter = FALSE; + + Result = USBMassCheckDeviceReady(fpURP->ApiData.MassChkDevReady.fpDevInfo); + fpURP->bRetValue = (UINT8)Result; +#endif +} + + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBAPI_LightenKeyboardLEDs +// +// Description: This function is part of the USB BIOS API. This function +// controls LED state on the connected USB keyboards +// +// Input: fpURP Pointer to the URP structure +// +// Output: Return code USB_ERROR - Failure, USB_SUCCESS - Success +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> + +VOID +USBAPI_LightenKeyboardLEDs(URP_STRUC *fpURP) +{ +#if USB_DEV_KBD + + gCheckUsbApiParameter = FALSE; + + if(fpURP->ApiData.KbLedsData.fpLedMap) { + gUsbData->bUSBKBShiftKeyStatus = 0; + if(((LED_MAP*)fpURP->ApiData.KbLedsData.fpLedMap)->NumLock) { + gUsbData->bUSBKBShiftKeyStatus |= KB_NUM_LOCK_BIT_MASK; + } + if(((LED_MAP*)fpURP->ApiData.KbLedsData.fpLedMap)->CapsLock) { + gUsbData->bUSBKBShiftKeyStatus |= KB_CAPS_LOCK_BIT_MASK; + } + if(((LED_MAP*)fpURP->ApiData.KbLedsData.fpLedMap)->ScrLock) { + gUsbData->bUSBKBShiftKeyStatus |= KB_SCROLL_LOCK_BIT_MASK; + } + } + //USB_DEBUG(DEBUG_LEVEL_3," LEDs: %d\n", gUsbData->bUSBKBShiftKeyStatus); + USBKB_LEDOn(); + + fpURP->bRetValue = USB_SUCCESS; + return; +#else + fpURP->bRetValue = USB_NOT_SUPPORTED; +#endif + +} + +VOID +USBAPI_LightenKeyboardLEDs_Compatible(URP_STRUC *fpURP) +{ + USBAPI_LightenKeyboardLEDs(fpURP); +} + + //(EIP29733+)> +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBAPI_KbcAccessControl +// +// Description: This function is part of the USB BIOS API. This function +// is used to control whether KBC access in USB module +// should be blocked or not. +// +// Input: fpURP Pointer to the URP structure +// +// Output: Return code USB_ERROR - Failure, USB_SUCCESS - Success +// +// Notes: +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> + + +VOID +UsbKbcAccessControl( + UINT8 ControlSwitch +) +{ + UINT8 Index; + HC_STRUC *HcStruc; +#if USB_RUNTIME_DRIVER_IN_SMM + EFI_STATUS Status = EFI_SUCCESS; + + Status = AmiUsbSmmGlobalDataValidation(gUsbData); + + ASSERT_EFI_ERROR(Status); + + if (EFI_ERROR(Status)) { + gLockHwSmiHandler = TRUE; + gLockSmiHandler = TRUE; + return; + } +#endif + + gCheckUsbApiParameter = FALSE; + + IsKbcAccessBlocked = (ControlSwitch != 0)? TRUE : FALSE; + + for (Index = 0; Index < gUsbData->HcTableCount; Index++) { + HcStruc = gUsbData->HcTable[Index]; + if (HcStruc == NULL) { + continue; + } + if (HcStruc->dHCFlag & HC_STATE_RUNNING) { + break; + } + } + + if (Index == gUsbData->HcTableCount) { + return; + } +/* + // + // Check if the USB access in Legacy mode. If it's legacy mode enable/disable + // the Kbcemulation based on the ControlSwitch + // + if(!(gUsbData->dUSBStateFlag & USB_FLAG_RUNNING_UNDER_EFI)) { + + if(IsKbcAccessBlocked) { + if(gEmulationTrap) { + // + // Keyboard access blocked. Disable the Emulation + // + gEmulationTrap->TrapDisable(gEmulationTrap); + } + } else { + if(gEmulationTrap) { + // + // Keyboard access enabled. Enable the KbcEmulation + // + gEmulationTrap->TrapEnable(gEmulationTrap); + } + } + } +*/ + //(EIP48323+)> + //Reflush USB data buffer if intend to disable usb keyboard data throughput. + if (IsKbcAccessBlocked) { + USBKeyRepeat(NULL, 1); // Disable Key repeat + gUsbData->RepeatKey = 0; + + // Clear Legacy USB keyboard buffer + MemFill(gUsbData->aKBCCharacterBufferStart, sizeof(gUsbData->aKBCCharacterBufferStart), 0); + gUsbData->fpKBCCharacterBufferHead = gUsbData->aKBCCharacterBufferStart; + gUsbData->fpKBCCharacterBufferTail = gUsbData->aKBCCharacterBufferStart; + + MemFill(gUsbData->aKBCScanCodeBufferStart, sizeof(gUsbData->aKBCScanCodeBufferStart), 0); + gUsbData->fpKBCScanCodeBufferPtr = gUsbData->aKBCScanCodeBufferStart; + + MemFill(gUsbData->aKBCDeviceIDBufferStart, sizeof(gUsbData->aKBCDeviceIDBufferStart), 0); + MemFill(gUsbData->aKBCShiftKeyStatusBufferStart, sizeof(gUsbData->aKBCShiftKeyStatusBufferStart), 0); + + MemFill(gUsbData->aKBInputBuffer, sizeof(gUsbData->aKBInputBuffer), 0); + } + //<(EIP48323+) +} + + +VOID +USBAPI_KbcAccessControl(URP_STRUC *fpURP) +{ + UsbKbcAccessControl(fpURP->ApiData.KbcControlCode); +} + //<(EIP29733+) +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USB_StopLegacy +// +// Description: This function is part of the USB BIOS API. This function init USB +// legacy support. +// +// Input: fpURP Pointer to the URP structure +// +// Output: None +// +// Notes: +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> +VOID +USB_StopLegacy(URP_STRUC *fpURP) +{ + //shutdown device first + UINT8 bIndex; + DEV_INFO *fpDevInfo; + HC_STRUC *fpHCStruc; + + for (bIndex = 1; bIndex < MAX_DEVICES; bIndex ++){ + fpDevInfo = gUsbData->aDevInfoTable +bIndex; + if ((fpDevInfo->Flag & + (DEV_INFO_VALID_STRUC |DEV_INFO_DEV_PRESENT) ) == + (DEV_INFO_VALID_STRUC |DEV_INFO_DEV_PRESENT) ){ + // + fpHCStruc = gUsbData->HcTable[fpDevInfo->bHCNumber - 1]; + // + USB_StopDevice (fpHCStruc, fpDevInfo->bHubDeviceNumber, fpDevInfo->bHubPortNumber); + } + } + + StopControllerType(USB_HC_XHCI); //(EIP57521+) + StopControllerType(USB_HC_EHCI); + StopControllerType(USB_HC_UHCI); + StopControllerType(USB_HC_OHCI); + + //return as success + fpURP->bRetValue = USB_SUCCESS; + +} + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USB_StartLegacy +// +// Description: This function is part of the USB BIOS API. This function init USB +// legacy support. +// +// Input: fpURP Pointer to the URP structure +// +// Output: None +// +// Notes: +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> +VOID +USB_StartLegacy(URP_STRUC *fpURP) +{ + //(EIP57521)> + gUsbData->bHandOverInProgress = FALSE; + //Start XHCI + StartControllerType(USB_HC_XHCI); + USB_EnumerateRootHubPorts(USB_HC_XHCI); + //Start EHCI + StartControllerType(USB_HC_EHCI); + USB_EnumerateRootHubPorts(USB_HC_EHCI); + //Start UHCI + StartControllerType(USB_HC_UHCI); + USB_EnumerateRootHubPorts(USB_HC_UHCI); + //Start OHCI + StartControllerType(USB_HC_OHCI); + USB_EnumerateRootHubPorts(USB_HC_OHCI); + //<(EIP57521) + //return as success + fpURP->bRetValue = USB_SUCCESS; +} + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBAPI_LegacyControl +// +// Description: This function is part of the USB BIOS API. This function +// is used to shutdown/init USB legacy support. +// +// Input: fpURP Pointer to the URP structure +// +// Output: None +// +// Notes: +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> +VOID USBAPI_LegacyControl (URP_STRUC *fpURP) +{ + UINT8 bSubLegacyFunc = fpURP->bSubFunc,i; //(EIP102150+) + UINT8 Count = (UINT8)(gUsbData->fpKBCScanCodeBufferPtr - + (UINT8*)gUsbData->aKBCScanCodeBufferStart); //(EIP102150+) + + gCheckUsbApiParameter = FALSE; + + USB_DEBUG(DEBUG_LEVEL_3, "USBAPI_LegacyControl %d\n", fpURP->bSubFunc); + if(bSubLegacyFunc==STOP_USB_CONTROLLER){ //(EIP43475+)> + USB_StopLegacy (fpURP); + //(EIP102150+)> + for(i = Count; i > 0; i--) + USBKB_DiscardCharacter(&gUsbData->aKBCShiftKeyStatusBufferStart[i-1]); + //<(EIP102150+) + if(gEmulationTrap) + gEmulationTrap->TrapDisable(gEmulationTrap); + } + + if(bSubLegacyFunc==START_USB_CONTROLLER){ + USB_StartLegacy (fpURP); + if(gEmulationTrap) + gEmulationTrap->TrapEnable(gEmulationTrap); + } //<(EIP43475+) + USB_DEBUG(DEBUG_LEVEL_3, "Result %d\n", fpURP->bRetValue); +} + //(EIP74876+)> +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBAPI_UsbStopController +// +// Description: This function is part of the USB BIOS API. This function stops +// the USB host controller. +// +// Input: fpURP Pointer to the URP structure +// +// Output: None +// +// Notes: +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> +VOID USBAPI_UsbStopController (URP_STRUC *fpURP) +{ + gCheckUsbApiParameter = FALSE; + StopControllerBdf(fpURP->ApiData.HcBusDevFuncNum); +} + //<(EIP74876+) +//----------------------------------------------------- +// +//----------------------------------------------------- +EFI_STATUS USBRT_LegacyControl (VOID *fpURP) +{ +#if USB_RUNTIME_DRIVER_IN_SMM + EFI_STATUS Status = EFI_SUCCESS; + + Status = AmiUsbSmmGlobalDataValidation(gUsbData); + + ASSERT_EFI_ERROR(Status); + + if (EFI_ERROR(Status)) { + gLockHwSmiHandler = TRUE; + gLockSmiHandler = TRUE; + return EFI_SUCCESS; + } +#endif + // + USBAPI_LegacyControl ((URP_STRUC *)fpURP); + // + return((EFI_STATUS)(((URP_STRUC *)fpURP)->bRetValue)); +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_GetDeviceAddress +// +// Description: +// +// Input: +// +// Output: +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBAPI_GetDeviceAddress( + URP_STRUC *Urp +) +{ + UINT8 i; + DEV_INFO *DevInfo = NULL; + + for (i = 1; i < MAX_DEVICES; i++) { + if (!(gUsbData->aDevInfoTable[i].Flag & DEV_INFO_VALID_STRUC)) { + continue; + } + if ((gUsbData->aDevInfoTable[i].wVendorId == Urp->ApiData.GetDevAddr.Vid) && + (gUsbData->aDevInfoTable[i].wDeviceId == Urp->ApiData.GetDevAddr.Did)) { + DevInfo = &gUsbData->aDevInfoTable[i]; + } + } + if (DevInfo == NULL) { + Urp->bRetValue = USB_ERROR; + return; + } + + Urp->ApiData.GetDevAddr.DevAddr = DevInfo->bDeviceAddress; + Urp->bRetValue = USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBAPI_ExtDriverRequest +// +// Description: +// +// Input: +// +// Output: +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBAPI_ExtDriverRequest ( + URP_STRUC *Urp +) +{ + DEV_INFO *DevInfo = NULL; + DEV_DRIVER *DevDriver; + + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_ADDR, 0, Urp->ApiData.DevAddr, 0); + if (DevInfo == NULL) { + Urp->bRetValue = USB_ERROR; + return; + } + + DevDriver = UsbFindDeviceDriverEntry(DevInfo->fpDeviceDriver); + + if (DevDriver != NULL) { + DevDriver->pfnDriverRequest(DevInfo, Urp); + } +} + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USB_StopUnsupportedHc +// +// Description: This routine is called, from host controllers that supports +// OS handover functionality, when OS wants the BIOS to hand-over +// the host controllers to the OS. This routine will stop HC that +// does not support this functionality. +// +// Input: None +// +// Output: None +// +// Notes: +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> + +VOID +USB_StopUnsupportedHc() +{ + +#if USB_RUNTIME_DRIVER_IN_SMM + UINT8 Index; + HC_STRUC* HcStruc; + EFI_STATUS Status; + + Status = AmiUsbSmmGlobalDataValidation(gUsbData); + + ASSERT_EFI_ERROR(Status); + + if (EFI_ERROR(Status)) { + gLockHwSmiHandler = TRUE; + gLockSmiHandler = TRUE; + return; + } + + USBSB_UninstallTimerHandlers(); + + USB_DEBUG(DEBUG_LEVEL_3, "Stopping all external HCs"); + for (Index = 0; Index < gUsbData->HcTableCount; Index++) { + HcStruc = gUsbData->HcTable[Index]; + if (HcStruc == NULL) { + continue; + } + if (HcStruc->HwSmiHandle != NULL) { + continue; + } + if (HcStruc->dHCFlag & HC_STATE_RUNNING) { + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDStop)(HcStruc); + USB_DEBUG(DEBUG_LEVEL_3, "."); + } + } + + USB_DEBUG(DEBUG_LEVEL_3, "\n"); + +#endif + + if(gUsbData->UsbXhciHandoff) { + StopControllerType(USB_HC_XHCI); + } + if(gUsbData->UsbEhciHandoff) { + gUsbData->bHandOverInProgress = TRUE; + StopControllerType(USB_HC_EHCI); + } + if(gUsbData->UsbOhciHandoff) { + StopControllerType(USB_HC_OHCI); + } +} + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBAPI_ChangeOwner +// +// Description: This function is part of the USB BIOS API. This function +// updates the global variables according to the new owner +// +// Input: fpURP Pointer to the URP structure +// +// Output: Return code USB_ERROR - Failure, USB_SUCCESS - Success +// +// Notes: It is a caller responsibility to release the keyboard only if it +// was previously acquired. +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> + +VOID +USBAPI_ChangeOwner(URP_STRUC *fpURP) +{ +//USB_DEBUG(DEBUG_LEVEL_3, "USBAPI_ChangeOwner.."); + + if(fpURP->ApiData.Owner) { // Changing to Efi driver +//USB_DEBUG(DEBUG_LEVEL_3, "fpURP->ApiData.Owner=%d\n", fpURP->ApiData.Owner); + if(gEmulationTrap) { + gEmulationTrap->TrapDisable(gEmulationTrap); + } + gUsbData->dUSBStateFlag |= USB_FLAG_RUNNING_UNDER_EFI; + } else { // Acquiring - check the current condition first +//USB_DEBUG(DEBUG_LEVEL_3, "fpURP->ApiData.Owner=%d...", fpURP->ApiData.Owner); + if(gEmulationTrap) { + gEmulationTrap->TrapEnable(gEmulationTrap); + } + + if (gUsbData->dUSBStateFlag & USB_FLAG_RUNNING_UNDER_EFI) { +//USB_DEBUG(DEBUG_LEVEL_3, "USB_FLAG_RUNNING_UNDER_EFI\n"); + gUsbData->dUSBStateFlag &= ~USB_FLAG_RUNNING_UNDER_EFI; + } else { +//USB_DEBUG(DEBUG_LEVEL_3, "not USB_FLAG_RUNNING_UNDER_EFI\n"); + } + } + fpURP->bRetValue = USB_SUCCESS; +} + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBAPI_HcStartStop +// +// Description: This function is part of the USB BIOS API. This function +// starts/stops the USB host controller. +// +// Input: fpURP Pointer to the URP structure +// +// Output: None +// +// Notes: +// +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> + +VOID +USBAPI_HcStartStop(URP_STRUC *Urp) +{ + HC_STRUC* HcStruc; + EFI_STATUS Status; + + HcStruc = Urp->ApiData.HcStartStop.HcStruc; + + Status = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(Status)) { + return; + } + + if ((HcStruc->bHCType != USB_HC_UHCI) && (HcStruc->bHCType != USB_HC_OHCI) && + (HcStruc->bHCType != USB_HC_EHCI) && (HcStruc->bHCType != USB_HC_XHCI)) { + return; + } + + gCheckUsbApiParameter = FALSE; + + if (Urp->ApiData.HcStartStop.Start) { + Urp->bRetValue = UsbHcStart(HcStruc); + } else { + Urp->bRetValue = UsbHcStop(HcStruc); + } +} + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBAPI_invoke_in_frame +// +// Description: Invokes procedure passing parameters supplied in the buffer +// It replicates the stack frame so that target procedure can +// see the parameters passed to the stub. +// +// Output: Returns result of invoked proc +// +//------------------------------------------------------------------------------ +//<AMI_PHDR_END> + +// +// The following typedef corresponds to the min width type that can be passed +// into function call as a parameter without padding +// +typedef UINTN STACKWORD; + +UINTN +USBAPI_invoke_in_frame( + VOID* pProc, + VOID* buffer, + UINT32 paramSize ) +{ + STACKWORD* params = (STACKWORD*)buffer; + + switch(paramSize/sizeof(STACKWORD)){ + case 0: return ((STACKWORD (*)())pProc)(); + case 1: return ((STACKWORD (*)(STACKWORD))pProc)(params[0]); + case 2: return ((STACKWORD (*)(STACKWORD,STACKWORD))pProc)(params[0], + params[1]); + case 3: return ((STACKWORD (*)(STACKWORD,STACKWORD,STACKWORD))pProc)( + params[0],params[1],params[2]); + case 4: return ((STACKWORD (*)(STACKWORD,STACKWORD,STACKWORD, + STACKWORD))pProc)( + params[0],params[1],params[2],params[3]); + case 5: return ((STACKWORD (*)(STACKWORD,STACKWORD,STACKWORD,STACKWORD, + STACKWORD))pProc)( + params[0],params[1],params[2],params[3],params[4]); + case 6: return ((STACKWORD (*)(STACKWORD,STACKWORD,STACKWORD,STACKWORD, + STACKWORD,STACKWORD))pProc)( + params[0],params[1],params[2],params[3],params[4],params[5]); + case 7: return ((STACKWORD (*)(STACKWORD,STACKWORD,STACKWORD,STACKWORD, + STACKWORD,STACKWORD,STACKWORD))pProc)( + params[0],params[1],params[2],params[3],params[4],params[5], + params[6]); + default: + ASSERT(paramSize/sizeof(STACKWORD) < 4); + return 0; + } +/* kept for reference + __asm { + push ecx + push esi + pushf + //Copy stak frame + std + mov esi, buffer + mov ecx, paramSize + add esi, ecx + sub esi, 4 + shr ecx, 2 +loop1: + lodsd //DWORD PTR ds:edi + push eax + loop loop1 + //Call proc + mov eax, pProc + cld + call eax + //Read return value + mov retVal, eax + + //Restore stack and registers + add esp, paramSize + popf + pop esi + pop ecx + } + return retVal;*/ +} + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBAPI_HC_Proc +// +// Description: Bridge to a number of procedures supplied by HC driver +// +// +// Input: fpURP Pointer to the URP structure +// +// Output: Return code USB_ERROR - Failure, USB_SUCCESS - Success) +// +// Notes: +// Assumes that buffer has a correct image of the stack that +// corresponding function reads argument from +// Size of the buffer can be biger than actually used. +// +// Following code copies the buffer (some stack frame) into new +// stack frame such that invoked dirver proc can read parametes +// supplied by buffer +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> + +VOID USBAPI_HC_Proc(URP_STRUC *fpURP) +{ + VOID* buffer = fpURP->ApiData.HcProc.paramBuffer; + UINT32 paramSize = // align size on DWORD + (fpURP->ApiData.HcProc.paramSize + 3) & ~0x3; + UN_HCD_HEADER* pHdr; + + ASSERT( GET_HCD_INDEX(fpURP->ApiData.HcProc.bHCType) < + sizeof(gUsbData->aHCDriverTable)/sizeof(HCD_HEADER)); + ASSERT( fpURP->bSubFunc < sizeof(pHdr->asArray.proc)/sizeof(VOID*)); + + pHdr = (UN_HCD_HEADER*)(gUsbData->aHCDriverTable + + GET_HCD_INDEX(fpURP->ApiData.HcProc.bHCType)); + fpURP->ApiData.HcProc.retVal = USBAPI_invoke_in_frame( + pHdr->asArray.proc[fpURP->bSubFunc],buffer,paramSize); + fpURP->bRetValue = USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//----------------------------------------------------------------------------- +// Procedure: USBAPI_Core_Proc +// +// Description: Bridge to a number of procedures supplied by Core proc table +// +// Input: fpURP Pointer to the URP structure +// +// Output: Return code USB_ERROR - Failure, USB_SUCCESS - Success +// +// Notes: +// Assumes that buffer has a correct image of the stack that +// corresponding function reads argument from +// Size of the buffer can be biger than actually used. +// +// Following code copies the buffer (some stack frame) into new +// stack frame such that invoked proc can read parametes +// supplied by buffer +//------------------------------------------------------------------------------; +//<AMI_PHDR_END> + + +VOID* core_proc_table[] = { + USB_GetDescriptor, + USB_ReConfigDevice, + USB_ReConfigDevice2, + UsbAllocDevInfo, + prepareForLegacyOS, + USB_ResetAndReconfigDev, + USB_DevDriverDisconnect, +// USB_GetDataPtr, +// MemCopy, + }; + +VOID USBAPI_Core_Proc(URP_STRUC *fpURP) +{ + VOID* buffer = fpURP->ApiData.CoreProc.paramBuffer; + UINT32 paramSize = // align size on DWORD + (fpURP->ApiData.CoreProc.paramSize + 3) & ~0x3; + + ASSERT( fpURP->bSubFunc < COUNTOF(core_proc_table)); + + fpURP->ApiData.CoreProc.retVal = USBAPI_invoke_in_frame( + core_proc_table[fpURP->bSubFunc],buffer,paramSize); + + fpURP->bRetValue = USB_SUCCESS; +} + + +//---------------------------------------------------------------------------- +// USB API Procedures Ends +//---------------------------------------------------------------------------- + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBWrapGetATAError +// +// Description: This routine converts the sense data information into +// ATAPI error code +// +// Input: dSenseData Sense data obtained from the device +// +// Output: BYTE - ATAPI error code +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 USBWrapGetATAErrorCode (UINT32 dSenseData) +{ + UINT8 sc = (UINT8)dSenseData; // Sense code + UINT8 asc = (UINT8)(dSenseData >> 16); // Additional Sense Code (ASC) + UINT8 ascq = (UINT8)(dSenseData >> 8); // Additional Sense Code Qualifier (ASCQ) + + if (ascq == 0x28) return USB_ATA_DRIVE_NOT_READY_ERR; + if (sc == 7) return USB_ATA_WRITE_PROTECT_ERR; + if ((asc == 0x80) && (ascq == 0x80)) return USB_ATA_TIME_OUT_ERR; + if (ascq == 0x18) return USB_ATA_DATA_CORRECTED_ERR; + if ((ascq==6) && (asc == 0)) return USB_ATA_MARK_NOT_FOUND_ERR; + if ((ascq==0x3a) && (asc == 0)) return USB_ATA_NO_MEDIA_ERR; + if ((ascq==0x11) && (asc == 0)) return USB_ATA_READ_ERR; + if ((ascq==0x11) && (asc == 6)) return USB_ATA_UNCORRECTABLE_ERR; + if (ascq==0x30) return USB_ATA_BAD_SECTOR_ERR; + if ((ascq<0x20) || (ascq>0x26)) return USB_ATA_GENERAL_FAILURE; + + return USB_ATA_PARAMETER_FAILED; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBWrap_GetnthDeviceInfoStructure +// +// Description: This routine finds the 'n'th device's DeviceInfo entry. +// +// Input: bDevNumber Device number (1-based) +// +// Output: DeviceInfo structure +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +DEV_INFO* +USBWrap_GetnthDeviceInfoStructure(UINT8 bDevNumber) +{ + return &gUsbData->aDevInfoTable[bDevNumber]; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBWrap_GetDeviceCount +// +// Description: This routine searches through the device entry table +// and returns number of active USB devices configured +// by the BIOS. +// +// Input: fpURPPointer Pointer to the URP +// +// Output: Following fields in the URP are modified +// CkPresence.bNumBootDev Number of USB boot devices found +// CkPresence.bNumKeyboards Number of USB keyboards present +// CkPresence.bNumMice Number of USB mice present +// CkPresence.bNumHubs Number of USB hubs present +// CkPresence.bNumStorage Number of USB storage devices present +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBWrap_GetDeviceCount(URP_STRUC *fpURP) +{ + DEV_INFO *fpDevInfo; + UINT8 i; + + for (i=1; i<MAX_DEVICES; i++) { + fpDevInfo = &gUsbData->aDevInfoTable[i]; + + if ( (fpDevInfo->Flag & DEV_INFO_VALID_STRUC) && + (fpDevInfo->Flag & DEV_INFO_DEV_PRESENT)) { + fpURP->ApiData.CkPresence.bNumBootDev++; + + switch (fpDevInfo->bDeviceType) { + case BIOS_DEV_TYPE_HID: + if (fpDevInfo->HidDevType & HID_DEV_TYPE_KEYBOARD) { + fpURP->ApiData.CkPresence.bNumKeyboards++; + } + if (fpDevInfo->HidDevType & HID_DEV_TYPE_MOUSE) { + fpURP->ApiData.CkPresence.bNumMice++; + } + if (fpDevInfo->HidDevType & HID_DEV_TYPE_POINT) { + fpURP->ApiData.CkPresence.bNumPoint++; + } + break; + //<(EIP84455+) + case BIOS_DEV_TYPE_HUB: + fpURP->ApiData.CkPresence.bNumHubs++; + break; + case BIOS_DEV_TYPE_STORAGE: + fpURP->ApiData.CkPresence.bNumStorage++; + break; + case BIOS_DEV_TYPE_SECURITY: + break; + } + } + } +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: MemFill +// +// Description: This routine fills the given memory range with the given value. +// +// Input: +// fpPtr - Pointer to the memory region to fill. +// wSize - Size in bytes of the area to be filled. +// Value - Byte value to fill the given range with. +// +// Output: None +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +MemFill ( + UINT8* fpPtr, + UINT32 dSize, + UINT8 Value) +{ + UINT32 dCount; + + if (fpPtr) { // Check for pointer validity + for(dCount = 0; dCount < dSize; dCount++) { + fpPtr[dCount] = Value; + } + } +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: MemCopy +// +// Description: This routine copies data from source to destination. +// +// Input: +// fpSrc - Pointer to the source. +// fpDest - Pointer to the destination. +// wSize - Number of bytes to copy. +// +// Output: None +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +MemCopy ( + UINT8* fpSrc, + UINT8* fpDest, + UINT32 dSize) +{ + UINT32 dCount; + + // + // Check for pointer validity + // + if ((fpSrc) && (fpDest)) { + for(dCount = 0; dCount < dSize; dCount++) { + fpDest[dCount] = fpSrc[dCount]; + } + } +} + + +UINTN DevicePathSize ( + IN EFI_DEVICE_PATH_PROTOCOL *DevicePath + ) +{ + EFI_DEVICE_PATH_PROTOCOL *Start; + + if (DevicePath == NULL) { + return 0; + } + + // + // Search for the end of the device path structure + // + Start = DevicePath; + while (!EfiIsDevicePathEnd (DevicePath)) { + DevicePath = EfiNextDevicePathNode (DevicePath); + } + + // + // Compute the size and add back in the size of the end device path structure + // + return ((UINTN)DevicePath - (UINTN)Start) + sizeof(EFI_DEVICE_PATH_PROTOCOL); +} + + +EFI_DEVICE_PATH_PROTOCOL * +AppendDevicePath ( + IN EFI_DEVICE_PATH_PROTOCOL *Src1, + IN EFI_DEVICE_PATH_PROTOCOL *Src2 + ) +{ + EFI_STATUS Status; + UINTN Size; + UINTN Size1; + UINTN Size2; + EFI_DEVICE_PATH_PROTOCOL *NewDevicePath; + EFI_DEVICE_PATH_PROTOCOL *SecondDevicePath; + + // + // Allocate space for the combined device path. It only has one end node of + // length EFI_DEVICE_PATH_PROTOCOL + // + Size1 = DevicePathSize (Src1); + Size2 = DevicePathSize (Src2); + Size = Size1 + Size2; + + if (Size1 != 0 && Size2 != 0) { + Size -= sizeof(EFI_DEVICE_PATH_PROTOCOL); + } + + Status = gBS->AllocatePool (EfiBootServicesData, Size, (VOID **)&NewDevicePath); + + if (EFI_ERROR(Status)) { + return NULL; + } + + gBS->CopyMem (NewDevicePath, Src1, Size1); + + // + // Over write Src1 EndNode and do the copy + // + if (Size1 != 0) { + SecondDevicePath = (EFI_DEVICE_PATH_PROTOCOL *)((CHAR8 *)NewDevicePath + (Size1 - sizeof(EFI_DEVICE_PATH_PROTOCOL))); + } + else { + SecondDevicePath = NewDevicePath; + } + gBS->CopyMem (SecondDevicePath, Src2, Size2); + return NewDevicePath; +} + +//**************************************************************************** +//**************************************************************************** +//** ** +//** (C)Copyright 1985-2016, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Pkwy, Norcross, GA 30093 ** +//** ** +//** Phone (770)-246-8600 ** +//** ** +//**************************************************************************** +//**************************************************************************** |