diff options
Diffstat (limited to 'Core/EM/usb/rt/uhci.c')
| -rw-r--r-- | Core/EM/usb/rt/uhci.c | 3981 |
1 files changed, 3981 insertions, 0 deletions
diff --git a/Core/EM/usb/rt/uhci.c b/Core/EM/usb/rt/uhci.c new file mode 100644 index 0000000..f5f4664 --- /dev/null +++ b/Core/EM/usb/rt/uhci.c @@ -0,0 +1,3981 @@ +//**************************************************************************** +//**************************************************************************** +//** ** +//** (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/uhci.c 114 10/16/16 10:12p Wilsonlee $ +// +// $Revision: 114 $ +// +// $Date: 10/16/16 10:12p $ +//**************************************************************************** +//**************************************************************************** +// Revision History +// ---------------- +// $Log: /Alaska/SOURCE/Modules/USB/ALASKA/RT/uhci.c $ +// +// 114 10/16/16 10:12p Wilsonlee +// [TAG] EIP288158 +// [Category] Improvement +// [Description] Check if gUsbData is integrity. +// [Files] amiusb.cif, usbsb.c, AmiUsbLib.cif, AmiUsbLib.sdl, +// AmiUsbSmmGlobalDataValidationLib.c, +// AmiUsbSmmGlobalDataValidationLib.cif, +// AmiUsbSmmGlobalDataValidationLib.mak, Crc32.c, amiusb.c, amiusb.h, +// ehci.c, elib.c, ohci.c, syskbc.c, uhci.c, usb.c, usbCCID.c, usbdef.h, +// usbhid.c, usbhub.c, usbkbd.c, usbmass.c, usbms.c, usbrt.mak, xhci.c, +// amiusbhc.c, efiusbccid.c, efiusbmass.c, uhcd.c, usbmisc.c, +// AmiUsbController.h, AmiUsbLibInclude.cif, +// AmiUsbSmmGlobalDataValidationLib.h +// +// 113 7/22/16 3:50a 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 +// +// 112 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 +// +// 111 3/14/16 10:21p Wilsonlee +// [TAG] EIP257506 +// [Category] Improvement +// [Description] Add USB_KEYREPEAT_INTERVAL token to change the key +// repeat interval. +// [Files] usb.sdl, xhci.h, usbkbd.h, uhci.c, ohci.c, ehci.c +// +// 110 3/02/16 9:41p Wilsonlee +// [TAG] EIP254309 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] GK-FORCE K83 USB KB function abnormal. +// [RootCause] This device has an interrupt out endpoint and doesn't +// support "Set Report" request. +// [Solution] Use the interrupt out endpoint instead of sending "Set +// Report" request. +// [Files] AmiUsbController.h, xhci.c, usbmass.c, usbkbd.h, usbkbd.c, +// usbhub.c, usbhid.c, usbdef.h, usbCCID.c, usb.c, uhci.c, ohci.c, ehci.c, +// amiusb.h, efiusbms,c, amiusbhc.c +// +// 109 12/03/15 1:48a Wilsonlee +// [TAG] EIP247625 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] USB hot-plug function is failed in external uhci +// controllers. +// [RootCause] We don't install UhciRootHubQhCallBack for external uhci +// controllers. +// [Solution] Handle the hot-plug function in the periodic timer smi +// handler if the uhci controller is external. +// [Files] uhci.c +// +// 108 4/10/15 3:11a 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 +// +// 107 3/08/15 10:49p Wilsonlee +// [TAG] EIP207774 +// [Category] Improvement +// [Description] Set USB_FLAG_DRIVER_STARTED flag when HC is running and +// clear it if we don't start any HC. +// [Files] uhci.c, usb.c, ehci.c, ohci.c, xhci.c, amiusb.h +// +// 106 1/22/15 10:19p Wilsonlee +// [TAG] EIP201434 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Number of connected devices isn't correct if we plug out +// keyboards or mice behind hub in xhci. +// [RootCause] The PortConnectChange bit is cleared when we check port +// status for interrupt endpoint transaction error. +// [Solution] Don't clear change bits if we check port status for +// interrupt endpoint transaction error. +// [Files] xhci.c, usbhub.c, usbdef.h, usb.c, uhci.c, ohci.c, ehci.c, +// amiusbhc.c +// +// 105 6/26/14 1:15a Wilsonlee +// [TAG] EIP173387 +// [Category] Improvement +// [Description] Remove TODO comments. +// [Files] usbsetup.c, xhci.c, usbmass.c, usbCCID.c, usb.c, uhci.c, +// syskbc.c, usbport.c, usbbus.c, uhcd.c, UsbBotPeim.c, PeiXhci.c, +// PeiEhci.c +// +// 104 5/01/14 3:57a Ryanchou +// [TAG] EIP162589 +// [Category] Improvement +// [Description] Do not register external controller as key repeat +// controller. +// [Files] ehci.c, ohci.c, uhci.c +// +// 103 4/30/14 8:56a Ryanchou +// [TAG] EIP160289 +// [Category] Improvement +// [Description] Handle zero length of short packet. +// [Files] uhci.c +// +// 102 4/30/14 6:13a Ryanchou +// [TAG] EIP151374 +// [Category] Improvement +// [Description] Calculates maximum data length to be reported in the +// HID device. +// [Files] ehci.c, ohci.c, uhci.c, usbCCID.c, usbdef.h, usbhid.c, +// usbhub.c, xhci.c +// +// 101 2/26/14 1:55a Wilsonlee +// [TAG] EIP149854 +// [Category] Improvement +// [Description] Add data length parameter to polling callback function. +// [Files] usbkbd.c, uhci.c, usb.c, usbhub.c, usbCCID.c, usbms.c, +// usbhid.c, usbpoint.c, usbkbd.h, ehci.c, ohci.c, xhci.c, usbdef.h +// +// 100 9/24/13 5:39a Ryanchou +// [TAG] EIP132985 +// [Category] Improvement +// [Description] Clear the SMI enable bit if UHCI is not controlled by +// BIOS. +// [Files] uhci.c +// +// 99 8/16/13 2:15a Ryanchou +// +// 98 7/26/13 2:40a Ryanchou +// [TAG] EIP122142 +// [Category] Improvement +// [Description] Improve periodic schedule mechanism +// [Files] ehci.c, ehci.h, ohci.c, ohci.h, uhci.c, uhci.h, usbdef.h, +// amiusbhc.c +// +// 97 7/22/13 10:31p Wilsonlee +// [TAG] EIP125357 +// [Category] Improvement +// [Description] Check if the port releases to a select host controller. +// [Files] uhci.c, usb.c, usbhub.c, ehci.c, ohci.c, xhci.c, usbdef.h +// +// 96 6/02/13 11:42p 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 +// +// 95 4/16/13 6:45a Ryanchou +// [TAG] EIP118912 +// [Category] Improvement +// [Description] Add VIA VT6212 EHCI controller support. +// [Files] ehci.c, uhci.c, usbdef.h, uhcd.c +// +// 94 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 +// +// 93 3/18/13 4:49a Ryanchou +// [TAG] EIP98377 +// [Category] Improvement +// [Description] Optimize USB controller timing. +// [Files] usb.sdl, usbport.c, ehci.c, elib.c, ohci.c, uhci.c, +// usbdef.h, usbhub.c, xhci.c, uhcd.c +// +// 92 2/24/13 9:00p Wilsonlee +// [TAG] EIP113541 +// [Category] Bug Fix +// [Severity] Critical +// [Symptom] System hangs at checkpoint 0xA2 when Win8 resume from S4. +// [RootCause] The "HCHalted" bit and "Port Change Detect" bit are set +// when the system S4 resume to Win8 OS. +// [Solution] We need to clear the interrupt status even if the +// "HCHalted" bit is set. +// [Files] ehci.c, ohci.c, uhci.c +// +// 91 12/06/12 12:39a Wilsonlee +// [TAG] EIP103186 +// [Category] Improvement +// [Description] Handle the error case "MEMIO was disabled" in USB +// driver. +// [Files] uhci.c, ohci.c, ehci.c, xhci.c +// +// 90 11/22/12 9:21p Wilsonlee +// [TAG] EIP106887 +// [Category] New Feature +// [Description] Support usb S5 wake up function for UHCI. +// [Files] usb.c, uhci.c, uhci.h +// +// 89 11/10/12 6:48a Ryanchou +// +// 88 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 +// +// 87 9/28/12 2:37a Wilsonlee +// [TAG] EIP93154 +// [Category] Improvement +// [Description] Change the unit of the FixedDelay from 15 us to 1 us. +// [Files] amiusb.h, xhci.c, ehci.c, ohci.c, uhci.c, usb.c, usbCCID.c, +// usbmass.c, usbhub.c, elib.c +// +// 86 8/29/12 8:17a 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 +// +// 85 5/04/12 6:39a 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 +// +// 84 5/03/12 6:23a 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 +// +// 83 11/08/11 1:56a 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 +// +// 82 9/26/11 11:43p Roberthsu +// [TAG] EIP67230 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Ntrig touch panel can not use on CedarTrail +// [RootCause] Because ntrig report data over than 512 byte.Control +// transfer check if over 512 than set length is 512. +// [Solution] Remove check transfer length. +// [Files] ohci.c,uhci.c,usbhid.c +// +// 81 8/08/11 6:59a Ryanchou +// [TAG] EIP54018 +// [Category] New Feature +// [Description] Added USB S5 wake up support. +// [Files] amiusb.c, ehci.c, ohci.c, uhci.c, usb.c, usb.sdl, usbdef.h, +// usbsb.c xhci.c +// +// 80 8/08/11 5:15a Ryanchou +// [TAG] EIP60561 +// [Category] New Feature +// [Description] Add USB timing policy protocol for timing override. +// [Files] ehci.c, guids.c, ohci.c, uhcd.c, uhci.c usb.c, usbdef.h, +// usbhub.c, usbmass.c, UsbPolicy.h, usbport.c usbsrc.sdl +// +// 79 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 +// +// 78 7/13/11 4:09a Ryanchou +// [TAG] EIP59332 +// [Category] Improvement +// [Description] Modified the Stop function for UHCD and USBBUS to +// properly stop devices and uninstall the protocols. +// [Files] uhcd.c, uhcd.h, uhci.c, usbbus.c, UsbInt13.c, usbmisc.c +// +// 77 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 +// +// 76 7/01/11 3:19a Ryanchou +// [TAG] EIP61385 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] USB devices can't detected. +// [RootCause] This is the side effect of EIP59663, the port status +// doesn't reflect connect status and connect status change. +// [Solution] Add 100 us delay. +// [Files] ehci.c, uhci.c +// +// 75 6/22/11 1:44a Ryanchou +// [TAG] EIP59738 +// [Category] Improvement +// [Description] Support Block size other than 512 bytes USB HDD in UEFI +// mode. +// [Files] efiusbmass.c, uhci.c, usb.c, usbdef.h, usbmass.c +// +// 74 5/03/11 10:09a Ryanchou +// [TAG] EIP54283 +// [Category] Improvement +// [Description] Follow XHCI spec ver 1.0 section 4.6.8 to recovery +// endpoint halt. +// [Files] ehci.c, ohci.c, uhci.c, usbdef.h, usbmass.c, xhci.c +// +// 73 4/06/11 1:33a Ryanchou +// [TAG] EIP54782 +// [Category] Improvement +// [Description] Change polling data size of HID devices to max packet +// size of interrupt endpoint. +// [Files] ehci.c, ohci.c, uhci.c, usb.c, usbdef.h, xhci.c +// +// 72 3/29/11 10:51p Ryanchou +// [TAG] EIP55401 +// [Category] Improvement +// [Description] Improve the USB 3.0 device compatibility. +// [Files] ehci.c, ehci.h, ohci.c, uhci.c, usb.c, usbdef.h, usbhub.c, +// xhci.c +// +// 71 3/29/11 10:08a Ryanchou +// [TAG] EIP53518 +// [Category] Improvement +// [Description] Added chipset xHCI chip support. +// [Files] amiusb.c, amiusb.h, ehci.c, ohci.c, uhcd.c, uhci.c, usb.c, +// usb.sdl, usbdef.h, usbport, usbsb.c, xhci.c +// +// 70 11/11/10 11:35p Ryanchou +// [TAG] EIP45578 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] USB 3.0 device can't be detected. +// [RootCause] Address Device Command fails. +// [Solution] Reset the device and attempt the Address Device Command +// again. +// [Files] ehci.c, ohci.c, uhci.c, usb.c, usbdef.h, usbhub.c, xhci.c +// +// 69 9/24/10 5:38p Olegi +// EIP38221: Added the code that properly initializes +// DEV_INFO.bIntEndpoint field; interrupt endpoint polling is using this +// endpoint number. +// +// 68 9/07/10 4:11a Tonylo +// Remove user tags for coding standard. +// +// 67 8/18/10 4:22p Olegi +// Klockwork related fixes; EIP37978 +// +// 66 4/30/10 3:36p Fredericko +// Fixed EIP : 38028: USB AutoKeyRepeat is not working properly +// +// 65 3/10/10 6:35p Olegi +// +// 64 3/10/10 10:51a Olegi +// Function headers corrected. +// +// 63 3/06/10 1:11p Olegi +// +// 62 2/26/10 4:23p Olegi +// +// 61 2/08/10 10:11a Olegi +// EIP33381: Implement multiple bulk endpoint in UsbIoProtocol. +// +// 60 2/08/10 9:40a Olegi +// EIP34448: Changes in UHCIWaitForTransferComplete and transfer routines. +// +// 59 1/26/10 4:35p Olegi +// +// 55 12/23/09 11:59a Olegi +// +// 54 12/22/09 8:57a Olegi +// +// 53 12/10/09 10:06a Olegi +// Added timeout in UHCI_WaitForBulkTransferComplete, EIP32048. +// +// 52 11/13/09 12:37p Olegi +// +// 51 10/30/09 5:47p Olegi +// +// 50 10/07/09 9:48a Olegi +// USB Hub error handling improvement. EIP#25601. +// +// 49 9/15/09 10:21a Olegi +// Added USB_INCMPT_HID_DATA_OVERFLOW incompatibility type. +// +// 48 8/26/09 11:41a Olegi +// Changes that prevent collision of keyboard activity and mass storage +// access. EIP#22808 +// +// 47 2/23/09 12:56p Olegi +// +// 46 2/20/09 4:43p Olegi +// +// 45 2/17/09 4:01p Olegi +// +// 44 2/17/09 8:58a Olegi +// +// 43 2/06/09 4:06p Olegi +// +// 42 1/16/09 3:50p Olegi +// Optimization in BulkTransfer scheduling. +// +// 41 10/06/08 3:33p Olegi +// EHCI change ownership testing in DOS fix (EIP#14855). +// +// 40 9/02/08 10:29a Olegi +// EIP14855 bugfix: change ownership request is not processed properly in +// case of multiple controllers of the same type. +// +// 39 5/16/08 12:01p Olegi +// Compliance with AMI coding standard. +// +// 38 2/05/08 3:13p Olegi +// Bugfix in BulkTdCallback that showed when data TD returns with stall +// condition. +// +// 37 12/17/07 4:04p Olegi +// KBC emulation support added. +// +// 36 10/15/07 5:13p Olegi +// ControlTransfer cleanup. +// +// 35 9/26/07 9:15a Olegi +// Added USB_FORCE_64BIT_ALIGNMENT flag as well as a call ty sync the LEDs +// between keyboards in DOS. +// +// 34 9/21/07 5:10p Davidd +// Allocation TDs is forced to be 64-bytes aligned. +// +// 33 9/06/07 6:12p Olegi +// +// 32 9/06/07 5:52p Olegi +// Tracker 27603 fix added. +// +// 31 8/14/07 11:56a Olegi +// Reverted buggy BulkTransfer changes to make floppy work. +// +// 30 8/14/07 10:59a Olegi +// +// 29 7/09/07 2:11p Olegi +// Changed the maximum data size of the BulkTransfer from 1kB to 64kB. +// +// 28 4/17/07 6:13p Fredericko +// Modified UHCI_EnableRootHub to preserve the Connect Status Change bit. +// +// 27 4/17/07 8:24a Olegi +// Device detection algorythm update, in sync with Core8. +// +// 26 3/20/07 12:18p Olegi +// +// 25 1/26/07 2:52p Olegi +// Bugfix in UHCI_BulkTDCallback. +// +// 24 1/25/07 4:25p Olegi +// +// 23 1/25/07 10:19a Olegi +// +// 22 1/02/07 2:08p Olegi +// +// 21 12/28/06 5:27p Olegi +// +// 20 12/26/06 10:52a Olegi +// +// 19 12/20/06 2:30p Olegi +// +// 17 10/19/06 5:24p Andriyn +// +// 15 10/12/06 9:37p Andriyn +// Fix: unexpected plug-off hangs with endless TIMEOUTs +// +// 14 7/10/06 2:57p Andriyn +// Fix: double delocation of descriptors used for control transfer +// +// 13 6/29/06 11:54a Andriyn +// Removed commented code +// +// 12 4/14/06 6:39p Olegi +// Conversion to be able to use x64 compiler. +// +// 11 3/20/06 3:37p Olegi +// Version 8.5 - x64 compatible. +// +// 10 3/06/06 6:23p Olegi +// +// 9 11/29/05 12:33p Andriyn +// +// 8 9/23/05 12:01p Olegi +// +// 7 9/23/05 11:58a Olegi +// +// 6 8/27/05 3:43p Andriyn +// Fix: lost mouse click when mouse is not moving +// +// 5 8/11/05 9:53a Olegi +// 60/64 port emulation related fixes for EMU6064 driver. +// +// 4 6/03/05 6:08p Olegi +// HW SMI registration change. +// +// 3 5/19/05 8:07p Olegi +// Aptio changes in driver 8.1 implementation. +// +// 2 5/17/05 7:51p Andriyn +// USB BUS pre-release +// +// 1 3/28/05 6:20p Olegi +// +// 1 3/15/05 9:23a Olegi +// Initial VSS check-in. +// +//**************************************************************************** + +//<AMI_FHDR_START> +//----------------------------------------------------------------------------- +// +// Name: Uhci.c +// +// Description: AMI USB UHCI driver +// +//----------------------------------------------------------------------------- +//<AMI_FHDR_END> + +#include "amidef.h" +#include "usbdef.h" +#include "amiusb.h" +#include "usbkbd.h" +#if USB_RUNTIME_DRIVER_IN_SMM +#include <AmiBufferValidationLib.h> +#endif + +extern VOID* USB_MemAlloc (UINT16); +extern UINT8 USB_MemFree (VOID _FAR_ *, UINT16); +extern UINT8 USBCheckPortChange (HC_STRUC*, UINT8, UINT8); +extern UINT8 USB_InstallCallBackFunction (CALLBACK_FUNC); + +extern UINT32 ReadPCIConfig(UINT16, UINT8); +extern VOID WordWritePCIConfig(UINT16, UINT8, UINT16); +extern UINT8 ByteReadIO(UINT16); +extern VOID ByteWriteIO(UINT16, UINT8); +extern UINT16 WordReadIO(UINT16); +extern VOID WordWriteIO(UINT16, UINT16); +extern UINT32 DwordReadIO(UINT16); +extern VOID DwordWriteIO(UINT16, UINT32); +extern VOID FixedDelay(UINTN); +extern DEV_INFO* USB_GetDeviceInfoStruc(UINT8, DEV_INFO*, UINT8, HC_STRUC*); +extern UINT8 USBLogError(UINT16); +extern VOID USB_InitFrameList (HC_STRUC*, UINT32); +#if USB_DEV_KBD +extern VOID USBKBDPeriodicInterruptHandler(HC_STRUC*); +extern VOID USBKeyRepeat(HC_STRUC*, UINT8); +#endif + +UINT8 USB_DisconnectDevice (HC_STRUC*, UINT8, UINT8); +UINT8 UsbGetDataToggle(DEV_INFO*,UINT8); +VOID UsbUpdateDataToggle(DEV_INFO*, UINT8, UINT8); + +//--------------------------------------------------------------------------- + +// Public function declaration +UINT8 UHCI_Start (HC_STRUC*); +UINT8 UHCI_Stop (HC_STRUC*); +UINT8 UHCI_EnumeratePorts (HC_STRUC*); +UINT8 UHCI_DisableInterrupts (HC_STRUC*); +UINT8 UHCI_EnableInterrupts (HC_STRUC*); +UINT8 UHCI_ProcessInterrupt(HC_STRUC*); +UINT8 UHCI_GetRootHubStatus (HC_STRUC*,UINT8, BOOLEAN); +UINT8 UHCI_DisableRootHub (HC_STRUC*,UINT8); +UINT8 UHCI_EnableRootHub (HC_STRUC*,UINT8); +UINT8 UHCI_ResetRootHub (HC_STRUC*,UINT8); +UINT16 UHCI_ControlTransfer (HC_STRUC*,DEV_INFO*,UINT16,UINT16,UINT16,UINT8*,UINT16); +UINT32 UHCI_BulkTransfer (HC_STRUC*,DEV_INFO*,UINT8,UINT8*,UINT32); +UINT16 UHCI_InterruptTransfer (HC_STRUC*, DEV_INFO*, UINT8, UINT16, UINT8*, UINT16); +UINT8 UHCI_DeactivatePolling (HC_STRUC*,DEV_INFO*); +UINT8 UHCI_ActivatePolling (HC_STRUC*,DEV_INFO*); +UINT8 UHCI_DisableKeyRepeat (HC_STRUC*); +UINT8 UHCI_EnableKeyRepeat (HC_STRUC*); +UINT8 UHCI_GlobalSuspend (HC_STRUC*); //(EIP54018+) + +UINT8 UhciProcessQh (HC_STRUC*, UHCI_QH*); +UINT8 UhciProcessTd (HC_STRUC*, UHCI_TD*); +UINT8 UhciProcessFrameList (HC_STRUC*); + +UINT8 UHCI_DisableHCPorts (HC_STRUC*); +UINT8 UHCI_StartTDSchedule (HC_STRUC*); +UINT8 UHCI_StopTDSchedule (HC_STRUC*); +UINT8 UHCI_InterruptTDCallback (HC_STRUC*, DEV_INFO*, UINT8*, UINT8*); +UINT8 UhciAddQhToFrameList (HC_STRUC*, UHCI_QH*); +UINT8 UhciRemoveQhFromFrameList (HC_STRUC*, UHCI_QH*); +VOID UhciInitQh (UHCI_QH*); +BOOLEAN UhciIsHalted(HC_STRUC*); +UINT8 UhciTranslateInterval(UINT8); + +UHCI_TD* +UhciAllocGeneralTds ( + IN UINT8 DeviceAddr, + IN BOOLEAN LowSpeed, + IN UINT8 PacketId, + IN UINT8 EndpointAddr, + IN UINT16 MaxPacket, + IN BOOLEAN ShortPacket, + IN OUT UINTN *BufferAddr, + IN OUT UINT32 *Length, + IN OUT UINT8 *DataToggle +); + +VOID +UhciFreeTds ( + IN UHCI_TD *FirstTd +); + +VOID +UhciActivateTds ( + IN UHCI_TD *FirstTd, + IN UINT8 DataToggle +); + +extern USB_GLOBAL_DATA *gUsbData; +extern BOOLEAN gCheckUsbApiParameter; + +UINT8 UhciRootHubQhCallBack(HC_STRUC*, DEV_INFO*, UINT8*, UINT8*, UINT16); +UINT8 UhciRepeatQhCallback (HC_STRUC*, DEV_INFO*, UINT8*, UINT8*, UINT16); +UINT8 UhciPollingQhCallback (HC_STRUC*, DEV_INFO*, UINT8*, UINT8*, UINT16); + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_FillHCDEntries +// +// Description: +// This function fills the host controller driver routine pointers +// +// Input: +// fpHCDHeader Ptr to the host controller header structure +// +// Output: +// USB_SUCCESS = Success, USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_FillHCDEntries(HCD_HEADER *fpHCDHeader) +{ + // + // Fill the routines here + // + fpHCDHeader->pfnHCDStart = UHCI_Start; + fpHCDHeader->pfnHCDStop = UHCI_Stop; + fpHCDHeader->pfnHCDEnumeratePorts = UHCI_EnumeratePorts; + fpHCDHeader->pfnHCDDisableInterrupts = UHCI_DisableInterrupts; + fpHCDHeader->pfnHCDEnableInterrupts = UHCI_EnableInterrupts; + fpHCDHeader->pfnHCDProcessInterrupt = UHCI_ProcessInterrupt; + fpHCDHeader->pfnHCDGetRootHubStatus = UHCI_GetRootHubStatus; + fpHCDHeader->pfnHCDDisableRootHub = UHCI_DisableRootHub; + fpHCDHeader->pfnHCDEnableRootHub = UHCI_EnableRootHub; + fpHCDHeader->pfnHCDControlTransfer = UHCI_ControlTransfer; + fpHCDHeader->pfnHCDBulkTransfer = UHCI_BulkTransfer; + fpHCDHeader->pfnHCDInterruptTransfer = UHCI_InterruptTransfer; + fpHCDHeader->pfnHCDDeactivatePolling = UHCI_DeactivatePolling; + fpHCDHeader->pfnHCDActivatePolling = UHCI_ActivatePolling; + fpHCDHeader->pfnHCDDisableKeyRepeat = UHCI_DisableKeyRepeat; + fpHCDHeader->pfnHCDEnableKeyRepeat = UHCI_EnableKeyRepeat; + fpHCDHeader->pfnHCDEnableEndpoints = USB_EnableEndpointsDummy; + fpHCDHeader->pfnHCDInitDeviceData = USB_InitDeviceDataDummy; + fpHCDHeader->pfnHCDDeinitDeviceData = USB_DeinitDeviceDataDummy; + fpHCDHeader->pfnHCDResetRootHub = UHCI_ResetRootHub; + fpHCDHeader->pfnHCDClearEndpointState = 0; //(EIP54283+) + fpHCDHeader->pfnHCDGlobalSuspend = UHCI_GlobalSuspend; //(EIP54018+) + + USB_InstallCallBackFunction(UhciPollingQhCallback); + USB_InstallCallBackFunction(UhciRepeatQhCallback); + USB_InstallCallBackFunction(UhciRootHubQhCallBack); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_Start +// +// Description: +// This API function is called to start a UHCI host controller. The input to the +// routine is the pointer to the HC structure that defines this host controller +// +// Input: +// fpHCStruc Ptr to the host controller structure +// +// Output: +// Status: USB_SUCCESS = Success, USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_Start (HC_STRUC* fpHCStruc) +{ + UINT16 wIOAddr; + UINT16 LegSupReg; + UINT16 Index; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + +#if USB_RUNTIME_DRIVER_IN_SMM + EfiStatus = AmiValidateMmioBuffer((VOID*)fpHCStruc->fpFrameList, 0x1000); + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } +#endif + +/* +USB_DEBUG(DEBUG_LEVEL_3, "Enabling IO/BM for UHCI HC %02X\n", fpHCStruc->wBusDevFuncNum); + // + // Enable IO access and Bus Mastering + // + WordWritePCIConfig((UINT16)fpHCStruc->wBusDevFuncNum, 4, BIT0 + BIT2); +*/ + // + // Set number of root hub ports present + // + fpHCStruc->bNumPorts = 2; + + // + // Get the I/O base address for the host controller + // + wIOAddr = (UINT16)ReadPCIConfig((UINT16)fpHCStruc->wBusDevFuncNum, USB_IO_BASE_ADDRESS); + + // + // Mask the low order two bits and store the value in HCStruc + // + wIOAddr = (UINT16)(wIOAddr & (~(BIT0+BIT1))); + USB_DEBUG(DEBUG_LEVEL_4, "HC I/O Address : %X\n", wIOAddr); + fpHCStruc->BaseAddress = wIOAddr; + + fpHCStruc->wAsyncListSize = UHCI_FRAME_LIST_SIZE; + + // + // Disable hardware interrupt generation by programming legacy registers + // + LegSupReg = (UINT16)ReadPCIConfig((UINT16)fpHCStruc->wBusDevFuncNum, USB_UHCI_REG_LEGSUP); + + // + // Disable generation of SMI/IRQ and clear status bits + // + LegSupReg = (UINT16)(LegSupReg & (~BIT4)); + WordWritePCIConfig((UINT16)fpHCStruc->wBusDevFuncNum, USB_UHCI_REG_LEGSUP, LegSupReg); + + // + // Disable the interrupts (to aVOID spurious interrupts) + // + UHCI_DisableInterrupts(fpHCStruc); + + // + // Disable the host controller root hub ports + // + UHCI_DisableHCPorts(fpHCStruc); + + // + // Check whether HC is already stopped + // + if (!UhciIsHalted(fpHCStruc)) { + // + // HC is still running. Stop it by programming HC run bit + // + ByteWriteIO ((UINT16)(wIOAddr + UHCI_COMMAND_REG), + ByteReadIO((UINT16)(wIOAddr + UHCI_COMMAND_REG)) & ~UHC_HOST_CONTROLLER_RUN); + + // + // Check whether the host controller is halted (check for 50 ms) + // + for (Index = 0; Index < 500; Index++) { + if ((ByteReadIO((UINT16)(wIOAddr + UHCI_STATUS_REG))) & UHC_HC_HALTED) { + break; + } + FixedDelay(100); // 100 us delay + } + } + ASSERT((ByteReadIO((UINT16)(wIOAddr + UHCI_STATUS_REG))) & UHC_HC_HALTED); + if (!((ByteReadIO((UINT16)(wIOAddr + UHCI_STATUS_REG))) & UHC_HC_HALTED)) { + return USB_ERROR; + } + + // + // Reset the host controller + // + ByteWriteIO((UINT16)(wIOAddr + UHCI_COMMAND_REG), UHC_GLOBAL_RESET); + + FixedDelay(10 * 1000); // Recommended 10msec delay, UHCI Spec, p.12, GRESET description + + ByteWriteIO((UINT16)(wIOAddr + UHCI_COMMAND_REG), 0); + + // + // Memory has been allocated in AMIUHCD + // + if (!fpHCStruc->fpFrameList) { + return USB_ERROR; + } + + USB_InitFrameList (fpHCStruc, UHCI_TERMINATE); + + // + // Program frame list pointer to the HC + // + USB_DEBUG(DEBUG_LEVEL_4, "Frame list pointer : %x\n", fpHCStruc->fpFrameList); + DwordWriteIO((UINT16)(wIOAddr + UHCI_FRAME_LIST_BASE), (UINT32)(UINTN)fpHCStruc->fpFrameList); + + USB_DEBUG(DEBUG_LEVEL_6, "UHCI_StartTDSchedule\n"); + + // + // Start the TD schedule + // + if (UHCI_StartTDSchedule(fpHCStruc) != USB_SUCCESS) + return USB_ERROR; + +#if USB_RUNTIME_DRIVER_IN_SMM + // + // Enable hardware interrupt generation by programming legacy registers + // + if (!(fpHCStruc->dHCFlag & HC_STATE_EXTERNAL)) { + LegSupReg = (UINT16)ReadPCIConfig(fpHCStruc->wBusDevFuncNum, USB_UHCI_REG_LEGSUP); + // Enable generation of SMI/IRQ + LegSupReg = (UINT16)(LegSupReg | BIT4) & ~BIT13; + WordWritePCIConfig((UINT16)fpHCStruc->wBusDevFuncNum, USB_UHCI_REG_LEGSUP, LegSupReg); + } +#endif + // + // Start the host controller by setting the run and configure bit + // + WordWriteIO((UINT16)(wIOAddr + UHCI_COMMAND_REG), + UHC_HOST_CONTROLLER_RUN | + UHC_CONFIGURE_FLAG | + UHC_MAX_PACKET_64_BYTE); + + // + // Enable interrupt generation + // +// WordWriteIO((UINT16)(wIOAddr + UHCI_INTERRUPT_ENABLE), (UHC_IOC_ENABLE | UHC_TIMEOUT_CRC_ENABLE)); + WordWriteIO((UINT16)(wIOAddr + UHCI_INTERRUPT_ENABLE), UHC_IOC_ENABLE); + + fpHCStruc->dHCFlag |= HC_STATE_RUNNING; + + // Set USB_FLAG_DRIVER_STARTED flag when HC is running. + if (!(gUsbData->dUSBStateFlag & USB_FLAG_DRIVER_STARTED)) { + gUsbData->dUSBStateFlag |= USB_FLAG_DRIVER_STARTED; + } + +#if USB_RUNTIME_DRIVER_IN_SMM + // + // Register the USB HW SMI handler + // + if (!(fpHCStruc->dHCFlag & HC_STATE_EXTERNAL)) { + UsbInstallHwSmiHandler(fpHCStruc); + } else { + USBSB_InstallUsbIntTimerHandler(); + } +#endif + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_Stop +// +// Description: +// This API function is called to stop the UHCI controller. The input to the +// routine is the pointer to the HC structure that defines this host controller. +// +// Input: +// fpHCStruc Ptr to the host controller structure +// +// Output: +// Status: USB_SUCCESS = Success, USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_Stop (HC_STRUC* fpHCStruc) +{ + UINT16 wIOAddr = (UINT16)fpHCStruc->BaseAddress; + UINT16 LegSupReg; + UINT16 Index; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) { + return USB_ERROR; + } + // + // Disable hardware interrupt generation by programming legacy registers + // + if (!(fpHCStruc->dHCFlag & HC_STATE_EXTERNAL)) { + LegSupReg = (UINT16)ReadPCIConfig((UINT16)fpHCStruc->wBusDevFuncNum, USB_UHCI_REG_LEGSUP); + + // + // Disable generation of SMI/IRQ and clear status bits + // + LegSupReg = (UINT16)(LegSupReg & ~(BIT4)); + WordWritePCIConfig((UINT16)fpHCStruc->wBusDevFuncNum, USB_UHCI_REG_LEGSUP, LegSupReg); + } + + // + // Disable the host controller interrupt generation + // + UHCI_DisableInterrupts (fpHCStruc); + + // Disconnect all devices + USB_DisconnectDevice(fpHCStruc, fpHCStruc->bHCNumber | BIT7, 1); + USB_DisconnectDevice(fpHCStruc, fpHCStruc->bHCNumber | BIT7, 2); + + // + // Stop the host controller + // + if (!UhciIsHalted(fpHCStruc)) { + // + // Clear HC run bit + // + ByteWriteIO ((UINT16)(wIOAddr + UHCI_COMMAND_REG), + ByteReadIO((UINT16)(wIOAddr + UHCI_COMMAND_REG)) & ~(UHC_HOST_CONTROLLER_RUN)); + + // + // Check whether the host controller is halted (check for 50 ms) + // + for (Index = 0; Index < 500; Index++) { + if ((ByteReadIO((UINT16)(wIOAddr + UHCI_STATUS_REG))) & UHC_HC_HALTED) { + break; + } + FixedDelay(100); // 100 us delay + } + } + ASSERT((ByteReadIO((UINT16)(wIOAddr + UHCI_STATUS_REG))) & UHC_HC_HALTED); + + // Reset the host controller + ByteWriteIO((UINT16)(wIOAddr + UHCI_COMMAND_REG), UHC_GLOBAL_RESET); + // Recommended 10msec delay, UHCI Spec, p.12, GRESET description + FixedDelay(10 * 1000); + ByteWriteIO((UINT16)(wIOAddr + UHCI_COMMAND_REG), 0); + + // + // Clear the frame list pointers + // + USB_InitFrameList (fpHCStruc, UHCI_TERMINATE); + + // + // Disable and free the TD schedule data structures + // + UHCI_StopTDSchedule (fpHCStruc); + + // + // Set the HC state to stopped + // + fpHCStruc->dHCFlag &= ~(HC_STATE_RUNNING); + + CheckBiosOwnedHc(); + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_EnumeratePorts +// +// Description: +// This API function is called to enumerate the root hub ports in the UHCI +// controller. The input to the routine is the pointer to the HC structure +// that defines this host controller +// +// Input: +// fpHCStruc Ptr to the host controller structure +// +// Output: +// Status: USB_SUCCESS = Success, USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_EnumeratePorts(HC_STRUC* fpHCStruc) +{ + UINT8 bHCNumber; + UINT16 wIOAddr, wPortAddr; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) { + return USB_ERROR; + } + + if (UhciIsHalted(fpHCStruc)) { + return USB_ERROR; + } + + wIOAddr = (UINT16)fpHCStruc->BaseAddress; + +//(USB0061+)> + // + // Check whether USB host controllers are accessible to aVOID system + // hang in ports enumeration. + // + if (ByteReadIO(wIOAddr) == 0xFF) return USB_ERROR; +//<(USB0061+) + // + // Check whether enumeration is already began + // + if(gUsbData->bEnumFlag == TRUE) return USB_SUCCESS; + + gUsbData->bEnumFlag = TRUE; + bHCNumber = (UINT8)(fpHCStruc->bHCNumber | BIT7); + //(EIP61385)> + // + // Process Port#1 and clear Port#1 status bit + // + wPortAddr = wIOAddr + UHCI_PORT1_CONTROL; + if ((WordReadIO(wPortAddr) & (UHC_CONNECT_STATUS_CHANGE | + UHC_CONNECT_STATUS)) == UHC_CONNECT_STATUS_CHANGE) { + WordWriteIO(wPortAddr, UHC_CONNECT_STATUS_CHANGE); + } + USBCheckPortChange(fpHCStruc, bHCNumber, 1); + WordWriteIO(wPortAddr, WordReadIO(wPortAddr)); + + // + // Process Port#2 and clear Port#2 status bit + // + wPortAddr = wIOAddr + UHCI_PORT2_CONTROL; + if ((WordReadIO(wPortAddr) & (UHC_CONNECT_STATUS_CHANGE | + UHC_CONNECT_STATUS)) == UHC_CONNECT_STATUS_CHANGE) { + WordWriteIO(wPortAddr, UHC_CONNECT_STATUS_CHANGE); + } + USBCheckPortChange(fpHCStruc, bHCNumber, 2); + WordWriteIO(wPortAddr, WordReadIO(wPortAddr)); + //<(EIP61385) + gUsbData->bEnumFlag = FALSE; + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_DisableInterrupts +// +// Description: +// This API function is called to disable the interrupts generated by the UHCI +// host controller. The input to the routine is the pointer to the HC structure +// that defines this host controller. +// +// Input: +// fpHCStruc Ptr to the host controller structure +// +// Output: +// Status: USB_SUCCESS = Success, USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_DisableInterrupts (HC_STRUC* fpHCStruc) +{ + UINT8 IntEnReg; + UINT16 IoAddr = (UINT16)fpHCStruc->BaseAddress; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + IntEnReg = ByteReadIO((UINT16)(IoAddr + UHCI_INTERRUPT_ENABLE)); + IntEnReg &= ~(UHC_IOC_ENABLE); + ByteWriteIO((UINT16)(IoAddr + UHCI_INTERRUPT_ENABLE), IntEnReg); + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_EnableInterrupts +// +// Description: +// This function enables the HC interrupts +// +// Input: +// fpHCStruc Pointer to the HCStruc structure +// +// Output: +// USB_SUCCESS of USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_EnableInterrupts (HC_STRUC* fpHCStruc) +{ + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_ProcessInterrupt +// +// Description: +// This function is called when the USB interrupt bit is set. This function +// will parse through the TDs and QHs to find out completed TDs and call +// their respective callback functions. +// +// Input: +// fpHCStruc Pointer to the HCStruc structure +// +// Output: +// USB_ERROR - Need more Interrupt processing +// USB_SUCCESS - No interrupts pending +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_ProcessInterrupt( + HC_STRUC *HcStruc +) +{ + UINT16 IoPort = (UINT16)HcStruc->BaseAddress; + UINT16 LegSupReg = 0; + UINT16 UsbSts = 0; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + if (!(HcStruc->dHCFlag & HC_STATE_RUNNING)) { + return USB_ERROR; + } + +#if USB_RUNTIME_DRIVER_IN_SMM + if (!(HcStruc->dHCFlag & HC_STATE_EXTERNAL)) { + LegSupReg = (UINT16)ReadPCIConfig(HcStruc->wBusDevFuncNum, USB_UHCI_REG_LEGSUP); + if (!(LegSupReg & BIT4)) { + return USB_ERROR; + } + } +#endif + + // + // Check whether the controller is still under BIOS control + // Read the frame list base address and compare with stored value + // + if (((UINTN)DwordReadIO(IoPort + UHCI_FRAME_LIST_BASE) & 0xFFFFF000) != + (UINTN)HcStruc->fpFrameList) { +#if USB_RUNTIME_DRIVER_IN_SMM + if (!(HcStruc->dHCFlag & HC_STATE_EXTERNAL)) { + // Disable the SMI on IRQ enable bit + WordWritePCIConfig(HcStruc->wBusDevFuncNum, USB_UHCI_REG_LEGSUP, LegSupReg & ~BIT4); + } +#endif + return USB_ERROR; // Control is not with us anymore + } + + UsbSts = WordReadIO(IoPort + UHCI_STATUS_REG); + + if (UsbSts & UHC_HC_HALTED) { + return USB_ERROR; + } + + if (UsbSts & UHC_USB_INTERRUPT) { + WordWriteIO(IoPort + UHCI_STATUS_REG, UsbSts); + UhciProcessFrameList(HcStruc); + } + + if (HcStruc->dHCFlag & HC_STATE_EXTERNAL) { + UhciRootHubQhCallBack(HcStruc, NULL, NULL, NULL, 0); + } + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_GetRootHubStatus +// +// Description: +// This function returns the port connect status for the root hub port +// +// Input: +// pHCStruc Pointer to HCStruc of the host controller +// bPortNum Port in the HC whose status is requested +// +// Output: +// NewPortNum Port in the HC that can possibly replace bPortNum +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_GetRootHubStatus( + HC_STRUC* fpHCStruc, + UINT8 bPortNum, + BOOLEAN ClearChangeBits +) +{ + UINT16 wPortAddr, wPortStatus, wPortTemp; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + wPortStatus = USB_PORT_STAT_DEV_OWNER; + wPortAddr = (UINT16)((bPortNum<<1)+UHCI_PORT1_CONTROL-2+fpHCStruc->BaseAddress); + + // + // Read the port status + // + wPortTemp = WordReadIO(wPortAddr); + USB_DEBUG(3, "UHCI port[%d] status: %04x\n", bPortNum, wPortTemp); + + // + // Check for port connect status + // + if (wPortTemp & UHC_CONNECT_STATUS) { + wPortStatus |= USB_PORT_STAT_DEV_CONNECTED; + + // + // Identify the speed of the device (full or low speed) + // + if (wPortTemp & UHC_LOW_SPEED_ATTACHED) { + wPortStatus |= USB_PORT_STAT_DEV_LOWSPEED; + } + else { + wPortStatus |= USB_PORT_STAT_DEV_FULLSPEED; + } + + if (wPortTemp & UHC_PORT_ENABLE) { + wPortStatus |= USB_PORT_STAT_DEV_ENABLED; + } + } + + // + // Check for connect status change + // + if (wPortTemp & UHC_CONNECT_STATUS_CHANGE) { + wPortStatus |= USB_PORT_STAT_DEV_CONNECT_CHANGED; + if (ClearChangeBits == TRUE) { + WordWriteIO(wPortAddr, UHC_CONNECT_STATUS_CHANGE); //(EIP61385+) + } + } + + return (UINT8)wPortStatus; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_DisableRootHub +// +// Description: +// This function disables the root hub of the UHCI controller. +// +// Input: +// fpHCStruc Pointer to HCStruc of the host controller +// bPortNum Root port to be disabled +// +// Output: +// USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_DisableRootHub (HC_STRUC* fpHCStruc,UINT8 bPortNum) +{ + UINT16 wPortAddr = + (UINT16)(fpHCStruc->BaseAddress + (bPortNum << 1) + UHCI_PORT1_CONTROL - 2); + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + // + // Reset the enable bit + // + WordWriteIO( + wPortAddr, + (UINT16)(WordReadIO(wPortAddr) & (~UHC_PORT_ENABLE))); + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_EnableRootHub +// +// Description: +// This function enables the root hub port specified +// +// Input: +// fpHCStruc Pointer to HCStruc of the host controller +// bPortNum Root port to be enabled +// +// Output: +// USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_EnableRootHub ( + HC_STRUC *HcStruc, + UINT8 PortNum) +{ + UINT16 PortStatus; + UINT16 PortAddr = + (UINT16)(HcStruc->BaseAddress + (PortNum << 1) + UHCI_PORT1_CONTROL - 2); + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + PortStatus = WordReadIO(PortAddr); + + // + // Set the enable & reset bit, preserve Connect Status Change bit + // + PortStatus &= ~(UHC_CONNECT_STATUS_CHANGE | UHC_PORT_ENABLE_CHANGE); + WordWriteIO(PortAddr, PortStatus | UHC_PORT_RESET); + + // + // Wait for 10ms + // + FixedDelay(10 * 1000); // 10msec delay + + // + // Clear the reset bit and set the enable, preserve Connect Status Change bit + // + PortStatus = WordReadIO(PortAddr); + PortStatus &= ~(UHC_CONNECT_STATUS_CHANGE | UHC_PORT_ENABLE_CHANGE); + WordWriteIO(PortAddr, PortStatus & (~UHC_PORT_RESET)); + + // Wait 1 ms for stabilize the port status + FixedDelay(1 * 1000); // 1 ms delay + + // Clear Connect Status Change bit and Port Enable Change bit + WordWriteIO(PortAddr, WordReadIO(PortAddr)); + + // + // Set the enable bit + // + PortStatus = WordReadIO(PortAddr); + PortStatus &= ~(UHC_CONNECT_STATUS_CHANGE | UHC_PORT_ENABLE_CHANGE); + WordWriteIO(PortAddr, PortStatus | UHC_PORT_ENABLE); + + // + // Wait for 100ms + // + //FixedDelay(gUsbData->UsbTimingPolicy.UhciPortEnable * 1000); // 100msec delay + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_ResetRootHub +// +// Description: +// This function resets the UHCI HC root hub port +// +// Input: +// HcStruc Pointer to HCStruc of the host controller +// PortNum Root port to be enabled +// +// Output: +// USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_ResetRootHub ( + HC_STRUC* HcStruc, + UINT8 PortNum) +{ + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Name: UHCI_GlobalSuspend +// +// Description: +// This function suspend the UHCI HC. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_GlobalSuspend( + HC_STRUC* HcStruc +) +{ + + UINT16 IoAddr = (UINT16)HcStruc->BaseAddress; + UINT16 UhciCommand; + UINT16 UhciStatus; + UINT32 i; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + if (!(HcStruc->dHCFlag & HC_STATE_RUNNING)) { + return USB_ERROR; + } + + if (UhciIsHalted(HcStruc)) { + return USB_ERROR; + } + + UhciCommand = WordReadIO(IoAddr + UHCI_COMMAND_REG); + UhciCommand &= ~UHC_HOST_CONTROLLER_RUN; + WordWriteIO(IoAddr + UHCI_COMMAND_REG, UhciCommand); + for (i = 0; i < 1024; i++) { + UhciStatus = WordReadIO(IoAddr + UHCI_STATUS_REG); + if (UhciStatus & UHC_HC_HALTED) { + break; + } + FixedDelay(1 * 1000); + } + + WordWriteIO((UINT16)(IoAddr + UHCI_INTERRUPT_ENABLE), UHC_RESUME_ENABLE); + + UhciStatus = WordReadIO(IoAddr + UHCI_STATUS_REG); + UhciStatus |= 0x1F; + WordWriteIO(IoAddr + UHCI_STATUS_REG, UhciStatus); + + UhciCommand = WordReadIO(IoAddr + UHCI_COMMAND_REG); + UhciCommand |= UHC_ENTER_SUSPEND; + WordWriteIO(IoAddr + UHCI_COMMAND_REG, UhciCommand); + FixedDelay(50 * 1000); + + HcStruc->dHCFlag &= ~(HC_STATE_RUNNING); + HcStruc->dHCFlag |= HC_STATE_SUSPEND; + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UhciExecuteTransfer +// +// Description: +// This function execites a transfer and waits for the completion of +// the transfer, and returns the transfer results. +// +// Input: +// Pointers to the first data TD and last data TD in the TD list +// +// Output: +// Return value is the size of transferred data, Bytes +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 +UhciExecuteTransfer ( + HC_STRUC *HcStruc, + UHCI_QH *TransferQh +) +{ + UINT32 Timeout = gUsbData->wTimeOutValue * 100; // *100, makes it number of 10 usec units + BOOLEAN InfiniteLoop = (Timeout == 0); + + TransferQh->ActiveFlag = TRUE; + UhciAddQhToFrameList(HcStruc, TransferQh); + + while (InfiniteLoop || Timeout--) { + UhciProcessQh(HcStruc, TransferQh); + if (TransferQh->ActiveFlag == FALSE) { + break; + } + + FixedDelay(10); // 10 microseconds + } + + UhciRemoveQhFromFrameList(HcStruc, TransferQh); + UhciProcessQh(HcStruc, TransferQh); + + if (TransferQh->ActiveFlag) { + USB_DEBUG (DEBUG_LEVEL_3, "UHCI Time-Out\n"); + } + + return TransferQh->BytesTransferred; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_ControlTransfer +// +// Description: +// This function executes a device request command transaction on the USB. One +// setup packet is generated containing the device request parameters supplied +// by the caller. The setup packet may be followed by data in or data out packets +// containing data sent from the host to the device or vice-versa. This function +// will not return until the request either completes successfully or completes in +// error (due to time out, etc.) +// +// Input: +// fpHCStruc Pointer to HCStruc of the host controller +// pDevInfo DeviceInfo structure (if available else 0) +// wRequest Request type (low byte) +// Bit 7 : Data direction +// 0 = Host sending data to device +// 1 = Device sending data to host +// Bit 6-5 : Type +// 00 = Standard USB request +// 01 = Class specific +// 10 = Vendor specific +// 11 = Reserved +// Bit 4-0 : Recipient +// 00000 = Device +// 00001 = Interface +// 00010 = Endpoint +// 00100 - 11111 = Reserved +// Request code, a one byte code describing +// the actual device request to be executed +// (ex: Get Configuration, Set Address etc) +// wIndex wIndex request parameter (meaning varies) +// wValue wValue request parameter (meaning varies) +// fpBuffer Buffer containing data to be sent to the +// device or buffer to be used to receive data +// wLength wLength request parameter, number of bytes +// of data to be transferred in or out +// of the host controller +// +// +// Output: +// Number of bytes transferred: 0 - Failure, <>0 - Success +// +// +// Notes: +// Do not use USB_SUCCESS or USB_ERROR as returned values +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 +UHCI_ControlTransfer ( + HC_STRUC *fpHCStruc, + DEV_INFO *fpDevInfo, + UINT16 wRequest, + UINT16 wIndex, + UINT16 wValue, + UINT8 *fpBuffer, + UINT16 wLength) +{ + UINT16 wTemp; + UINT32 dTemp; + UINT32 dValue; + + DEV_REQ *fpDevReq; + UHCI_TD *SetupTd = NULL; + UHCI_TD *DataTDs = NULL; + UHCI_TD *StatusTd = NULL; + UHCI_TD *LastTd = NULL; + UHCI_TD *CurrentTd = NULL; + UHCI_QH *CtrlQh; + UINT16 NumDataTDs = 0; + UINT16 BytesRemaining; + UINT16 BytesTransferred; + UINT8 DataToggle; + EFI_STATUS EfiStatus = EFI_SUCCESS; + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return 0; + } + + EfiStatus = UsbDevInfoValidation(fpDevInfo); + + if (EFI_ERROR(EfiStatus)) { + return 0; + } + +#if USB_RUNTIME_DRIVER_IN_SMM + if (gCheckUsbApiParameter) { + if (wLength != 0) { + EfiStatus = AmiValidateMemoryBuffer((VOID*)fpBuffer, wLength); + if (EFI_ERROR(EfiStatus)) { + USB_DEBUG(3, "Uhci ControlTransfer Invalid Pointer, Buffer is in SMRAM.\n"); + return 0; + } + } + gCheckUsbApiParameter = FALSE; + } +#endif + + if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) { + return 0; + } + + if (UhciIsHalted(fpHCStruc)) { + return 0; + } + + if (!VALID_DEVINFO(fpDevInfo)) return 0; + + gUsbData->bLastCommandStatus &= ~( USB_CONTROL_STALLED ); + gUsbData->dLastCommandStatusExtended = 0; + + // + // Allocate TDs for control setup and control status packets + // + SetupTd = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(UHCI_TD)); + if(SetupTd == NULL) { + return 0; + } + + // + // Build the device request in the data area of the control setup TD + // + fpDevReq = (DEV_REQ*)SetupTd->aDataArea; + fpDevReq->wRequestType = wRequest; + fpDevReq->wValue = wValue; + fpDevReq->wIndex = wIndex; + fpDevReq->wDataLength = wLength; + + // + // dTemp will contain the device address and endpoint shifted and ready to go + // into the TDs' token field. + // 10:0] = Dev. Addr & Endpoint + // [18:8] = Dev. Addr & Endpoint + // + dTemp = ((UINT32)(fpDevInfo->bDeviceAddress)) << 8; + + // + // Fill in various fields in the control setup TD. + // The LinkPointer field will point to the control data TD if data will + // be sent/received or to the control status TD if no data is expected. + // The ControlStatus field will be set to active and interrupt on complete. + // The Token field will contain the packet size (size of DeviceRequest + // struc), the device address, endpoint, and a setup PID. + // The BufferPointer field will point to the TD's DataArea buffer which + // was just initialized to contain a DeviceRequest struc. + // The CSReloadValue field will contain 0 because this is a "one shot" packet. + // The pCallback will be set to point to the UHCI_ControlTDCallback routine. + // The ActiveFlag field will be set to TRUE. + // + + // + // 11/01/10 for HI/LO/FULL + // + dValue = (((UINT32)fpDevInfo->bEndpointSpeed) & 1) << 26; + //(EIP34448)> + dValue |= (UINT32)(UHCI_TD_THREE_ERRORS | UHCI_TD_ACTIVE); + //<(EIP34448) + + SetupTd->dControlStatus = dValue; + + dValue = dTemp | + ((UINT32)UHCI_TD_SETUP_PACKET | + ((UINT32)(sizeof(DEV_REQ) - 1) << 21)); + + // + // Set PID=Setup, and MaxLen + // + SetupTd->dToken = dValue; + SetupTd->pBufferPtr = (UINT32)(UINTN)SetupTd->aDataArea; + SetupTd->dCSReload = 0; + SetupTd->bActiveFlag = 1; + + LastTd = SetupTd; + // + // Fill in various fields in the control data TD. + // Enough control data TDs must be initialized to handle the amount of + // data expected. The length of the data transfer is currently in wLength. + // LinkPointer field will be set to the next data TD or the status TD. + // ControlStatus field will be se to active and interrupt on complete. + // Token field will contain the data transfer size (still in wLength), device + // address (in pDevInfo), endpoint (in dTemp), and an in or out PID + // (in wReqType). + // BufferPointer field will point to the data buffer passed in by the + // caller (currently in fpBuffer). + // CSReloadValue field will contain 0 because this is a "one shot" packet. + // pCallback will be set to point to the UHCI_ControlTDCallback routine. + // ActiveFlag field will be set to TRUE. + // + if(wLength) { + NumDataTDs = wLength / fpDevInfo->wEndp0MaxPacket; + if (wLength % fpDevInfo->wEndp0MaxPacket) { + NumDataTDs++; + } + + DataTDs = USB_MemAlloc(GET_MEM_BLK_COUNT(NumDataTDs * sizeof(UHCI_TD))); + if (DataTDs == NULL) { + USB_MemFree(SetupTd, GET_MEM_BLK_COUNT_STRUC(UHCI_TD)); + return 0; + } + + CurrentTd = DataTDs; + + DataToggle = 1; + BytesRemaining = wLength; + + // + // Allocate one more TD to be used either for more data or for TD Status + // + do { + // + // 11/01/10 for HI/LO/FULL + // + dValue = (((UINT32)(fpDevInfo->bEndpointSpeed) & 1) << 26); + dValue = dValue | + (UINT32)(UHCI_TD_THREE_ERRORS | UHCI_TD_ACTIVE); + if(wRequest & BIT7) { + dValue |= UHCI_TD_SHORT_PACKET_DETECT; + } + CurrentTd->dControlStatus = dValue; + CurrentTd->pBufferPtr = (UINT32)(UINTN)fpBuffer; + wTemp = (UINT16)((BytesRemaining > (fpDevInfo->wEndp0MaxPacket)) ? + fpDevInfo->wEndp0MaxPacket : BytesRemaining); + // + // Packet size is valid + // + BytesRemaining = (UINT16)(BytesRemaining - wTemp); + fpBuffer = fpBuffer + wTemp; + --wTemp; + + // + // [18:8]=Dev. addr & endp + // + dValue = dTemp | (((UINT32)wTemp) << 21); + dValue = (dValue & 0xFFFFFF00) | UHCI_TD_OUT_PACKET; + + if(wRequest & BIT7) + { + dValue = (dValue & 0xFFFFFF00) | UHCI_TD_IN_PACKET; + } + if(DataToggle & 1) + { + dValue = dValue | UHCI_TD_DATA_TOGGLE; // Make packet into a data 1 + } + CurrentTd->dToken = dValue; + CurrentTd->dCSReload = 0; + CurrentTd->bActiveFlag = 1; + + LastTd->pLinkPtr = (UINT32)((UINTN)CurrentTd | UHCI_VERTICAL_FLAG); + LastTd = CurrentTd; + CurrentTd++; + + DataToggle ^= 1; + } while (BytesRemaining); // End the data TD list + } + // + // Fill in various fields in the TD control status. + // LinkPointer field will point to TERMINATE. + // ControlStatus field will be set to active and interrupt on complete. + // Token field will contain the packet size (0), the device address, + // endpoint, and a setup PID with opposite data direction as that defined + // in the request type (wReqType). + // BufferPointer field will point to the TD's DataArea buffer even though + // we are not expecting any data transfer. + // CSReloadValue field will contain 0 because this is a "one shot" packet. + // pCallback will be set to point to the UHCI_ControlTDCallback routine. + // ActiveFlag field will be set to TRUE. + // + StatusTd = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(UHCI_TD)); + if (StatusTd == NULL) { + return 0; + } + + LastTd->pLinkPtr = (UINT32)((UINTN)StatusTd | UHCI_VERTICAL_FLAG); + LastTd = StatusTd; + StatusTd->pLinkPtr = UHCI_TERMINATE; + dValue = (((UINT32)(fpDevInfo->bEndpointSpeed) & 1) << 26); + //(EIP34448)> + dValue = dValue | (UINT32)(UHCI_TD_THREE_ERRORS | UHCI_TD_ACTIVE); + //<(EIP34448) + StatusTd->dControlStatus = dValue; + dValue = dTemp; + dValue = (dValue & 0xFFFFFF00) | (UINT32)UHCI_TD_OUT_PACKET; + if((wRequest & BIT7) == 0) + { + dValue = (dValue & 0xFFFFFF00) | (UINT32)UHCI_TD_IN_PACKET; + } + dValue |= (UHCI_TD_DATA_TOGGLE | ((UINT32)UHCI_TD_ACTUAL_LENGTH << 21)); + StatusTd->dToken = dValue; + dValue = (UINT32)(UINTN)StatusTd->aDataArea; + StatusTd->pBufferPtr = dValue; + StatusTd->dCSReload = 0; + StatusTd->bActiveFlag = 1; + // + // Now put the control setup, data and status into the HC's schedule by + // pointing QhControl's link pointer to control setup TD. + // This will cause the HC to execute the transaction in the next active frame. + + CtrlQh = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(UHCI_QH)); + if (CtrlQh == NULL) { + return 0; + } + + UhciInitQh(CtrlQh); + CtrlQh->pElementPtr = (UINT32)(UINTN)SetupTd; + CtrlQh->CurrentTd = SetupTd; + CtrlQh->Type = Control; + CtrlQh->FirstTd = SetupTd; + + // Wait till transfer complete + BytesTransferred = UhciExecuteTransfer(fpHCStruc, CtrlQh); + + // Calculate the transferred length + BytesTransferred -= (((SetupTd->dControlStatus & UHCI_TD_ACTUAL_LENGTH) + 1) & 0x7FF); + + // Save error information in global variable + gUsbData->dLastCommandStatusExtended = + (CtrlQh->CurrentTd->dControlStatus & UHCI_TD_STATUS_FIELD) >> 17; + + if (CtrlQh->CurrentTd->dControlStatus & UHCI_TD_STALLED ){ + gUsbData->bLastCommandStatus |= USB_CONTROL_STALLED; + BytesTransferred = 0; + } + + USB_MemFree(SetupTd, GET_MEM_BLK_COUNT_STRUC(UHCI_TD)); + if (DataTDs) { + USB_MemFree(DataTDs, GET_MEM_BLK_COUNT(NumDataTDs * sizeof(UHCI_TD))); + } + USB_MemFree(StatusTd, GET_MEM_BLK_COUNT_STRUC(UHCI_TD)); + USB_MemFree(CtrlQh, GET_MEM_BLK_COUNT_STRUC(UHCI_QH)); + + return BytesTransferred; +} // UHCI_ControlTransfer + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_InitBulkTdCommon +// +// Description: +// This function creates a chain of two TDs for bulk data transfer. It fills +// in the following fields in TD: +// pLinkPtr - NextTd address +// dToken - All bits except length and data toggle +// +// Input: +// BulkDataTd0 1st TD in the chain +// BulkDataTd1 2nd TD in the chain +// TokenData Data for dToken +// NumBulkTds # of bulk TDs +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UHCI_InitBulkTdCommon ( + UHCI_TD *BulkDataTd0, + UINT32 TokenData, + UINT16 NumBulkTds +) +{ + UINT16 i; + UHCI_TD *Td0 = BulkDataTd0; + UHCI_TD *Td1 = Td0; + UINT16 NumTd = NumBulkTds*2; + + for (i=0; i<NumTd; i++) + { + Td0 = Td1; + Td0->dToken = TokenData; + Td1 = (UHCI_TD*)((UINTN)Td0 + sizeof(UHCI_TD)); + Td0->pLinkPtr = (UINT32)(UINTN)Td1 | UHCI_VERTICAL_FLAG; + } + // Terminated later in UHCI_InitBulkDataTds +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_InitBulkDataTds +// +// Description: +// This function initializes the fields in bulk data TD list that remain after +// UHCI_InitBulkTdCommon: +// - Data buffer pointer +// - Data length +// - Data toggle (DAT0/DAT1) +// +// Output: +// Pointer to the last TD in the chain +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UHCI_TD* +UHCI_InitBulkDataTds( + IN UHCI_TD *BulkDataTd, + IN UINT16 MaxPkt, + IN UINT32 EndpointSpeed, + IN OUT UINT32 *Address, + IN OUT UINT8 *DatToggle, + IN OUT UINT32 *BytesRemaining, + IN UINT16 NumBulkTds +) +{ + UINT16 i; + UINT32 Length = *BytesRemaining; + UHCI_TD *Td = BulkDataTd; + UINT32 Addr = *Address; + UINT8 Toggle = *DatToggle; + BOOLEAN TheLastTd = FALSE; + + for (i = 0; i < NumBulkTds; i++) + { + Length = *BytesRemaining; + + if (Length > (UINT32)MaxPkt) + { + Length = (UINT32)MaxPkt; + } + else + { + TheLastTd = TRUE; + } + Td->dToken &= 0x1FFFFF; + Td->dToken |= (Length - 1) << 21; + + Td->dToken &= ~UHCI_TD_DATA_TOGGLE; // Make packet go into DAT0 + if (Toggle == 1) + { + Td->dToken |= UHCI_TD_DATA_TOGGLE; // Make packet go into DAT1 + } + + Td->dControlStatus = EndpointSpeed | + (UHCI_TD_THREE_ERRORS | UHCI_TD_ACTIVE); + if ((Td->dToken & UHCI_TD_PACKET_ID) == UHCI_TD_IN_PACKET) { + Td->dControlStatus |= UHCI_TD_SHORT_PACKET_DETECT; + } + + Td->pBufferPtr = Addr; + Addr += MaxPkt; + Toggle ^= 1; + Td = (UHCI_TD*)((UINTN)Td + sizeof(UHCI_TD)); + *BytesRemaining -= Length; + + if (TheLastTd) break; + } + + Td = (UHCI_TD*)((UINTN)Td - sizeof(UHCI_TD)); + Td->pLinkPtr = UHCI_TERMINATE; + + *Address = Addr; + *DatToggle = Toggle; + + return Td; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_BulkTransfer +// +// Description: +// This function executes a bulk transaction on the USB. The transfer may be +// either DATA_IN or DATA_OUT packets containing data sent from the host to +// the device or vice-versa. This function wil not return until the request +// either completes successfully or completes with error (due to time out, etc.) +// +// Input: +// HcStruc Pointer to HCStruc of the host controller +// DevInfo DeviceInfo structure (if available else 0) +// XferDir Transfer direction +// Bit 7: Data direction +// 0 Host sending data to device +// 1 Device sending data to host +// Bit 6-0 : Reserved +// Buffer Buffer containing data to be sent to the device or buffer to be +// used to receive data value in Segment:Offset format +// Length Length request parameter, number of bytes of data to be transferred +// in or out of the host controller +// +// Output: +// Amount of data transferred +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 +UHCI_BulkTransfer ( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo, + UINT8 XferDir, + UINT8 *Buffer, + UINT32 Length +) +{ + UINT16 MaxPkt; + UINT8 Endp; + UINT32 Data; + UINT8 DatToggle; + UINT32 TransferError; + UHCI_QH *BulkQh; + UHCI_TD *BulkDataTd; + UHCI_TD *NextBulkDataTd; + UHCI_TD *BulkDataTd0; + UHCI_TD *BulkDataTd1; + UHCI_TD *LastTd; + UHCI_TD *NextLastTd; + UINT16 NumAllocTDs; + UINT16 NumBulkTDs; + UINT32 BytesRemaining; + UINT32 BytesTransferred; + UINT32 BytesTransferredNow; + UINT32 Address; + UINT32 Eps; + EFI_STATUS EfiStatus = EFI_SUCCESS; + + EfiStatus = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(EfiStatus)) { + return 0; + } + + EfiStatus = UsbDevInfoValidation(DevInfo); + + if (EFI_ERROR(EfiStatus)) { + return 0; + } + +#if USB_RUNTIME_DRIVER_IN_SMM + if (gCheckUsbApiParameter) { + EfiStatus = AmiValidateMemoryBuffer((VOID*)Buffer, Length); + if (EFI_ERROR(EfiStatus)) { + USB_DEBUG(3, "Uhci BulkTransfer Invalid Pointer, Buffer is in SMRAM.\n"); + return 0; + } + gCheckUsbApiParameter = FALSE; + } +#endif + + if (!(HcStruc->dHCFlag & HC_STATE_RUNNING)) { + return 0; + } + + if (UhciIsHalted(HcStruc)) { + return 0; + } + + if ( !VALID_DEVINFO( DevInfo) ) return 0; + + if (Length == 0) return 0; + + // Clear HW source of error + gUsbData->bLastCommandStatus &= ~(USB_BULK_STALLED | USB_BULK_TIMEDOUT ); + gUsbData->dLastCommandStatusExtended = 0; + // + // Get Bulk IN/OUT enpoint number, data sync value & max packet size + // Store the appropriate max packet size and endpoint number + // in the local variables + // + MaxPkt = (XferDir & BIT7)? DevInfo->wBulkInMaxPkt : DevInfo->wBulkOutMaxPkt; + + if (MaxPkt == 0) return 0; + + Endp = (XferDir & BIT7)? DevInfo->bBulkInEndpoint : DevInfo->bBulkOutEndpoint; + + // + // For multiple LUN devices toggle is maintained by LUN0 + // + DatToggle = UsbGetDataToggle(DevInfo, Endp | XferDir); + + // + // Form TD token data, less the transfer length and toggle information + // + Data = (UINT32)Endp << 7; + Data = (Data | DevInfo->bDeviceAddress) << 8; + Data = (XferDir & BIT7)? Data | UHCI_TD_IN_PACKET : Data | UHCI_TD_OUT_PACKET; + + BulkQh = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(UHCI_QH)); + if (BulkQh == NULL) return 0; + + BulkQh->Type = Bulk; + + // Allocate data TDs. + NumBulkTDs = FULLSPEED_MAX_BULK_DATA_SIZE_PER_FRAME/MaxPkt; + ASSERT(NumBulkTDs != 0); + + NumAllocTDs = NumBulkTDs*2; + + BulkDataTd0 = (UHCI_TD*)USB_MemAlloc(GET_MEM_BLK_COUNT(NumAllocTDs * sizeof(UHCI_TD))); + ASSERT(BulkDataTd0 != NULL); + + UHCI_InitBulkTdCommon (BulkDataTd0, Data, NumBulkTDs); + + BulkDataTd1 = (UHCI_TD*)((UINTN)BulkDataTd0 + (NumBulkTDs * sizeof(UHCI_TD))); + + BulkDataTd = BulkDataTd0; + NextBulkDataTd = BulkDataTd1; + BytesRemaining = Length; + BytesTransferred = 0; + BytesTransferredNow = 0; + Address = (UINT32)(UINTN)Buffer; + TransferError = 0; + Eps = ((UINT32)(DevInfo->bEndpointSpeed) & 1) << 26; + + LastTd = UHCI_InitBulkDataTds( + BulkDataTd, MaxPkt, Eps, &Address, &DatToggle, &BytesRemaining, NumBulkTDs); + NextLastTd = LastTd; + + do { + // Start the transfer by adding TD in the bulk queue head + UhciInitQh(BulkQh); + BulkQh->pElementPtr = (UINT32)(UINTN)BulkDataTd; + BulkQh->CurrentTd = BulkDataTd; + BulkQh->FirstTd = BulkDataTd; + + // Initialize the next TD block and wait for the current one to complete. + // In case MaxPkt is 64 Bytes, we have approx. NumBulkTDs*50mcs for this. + if (BytesRemaining != 0) { + NextLastTd = UHCI_InitBulkDataTds( + NextBulkDataTd, MaxPkt, Eps, &Address, &DatToggle, &BytesRemaining, NumBulkTDs); + } + + // Wait til BulkDataTd is complete, check for errors + BytesTransferredNow = UhciExecuteTransfer(HcStruc, BulkQh); + + DatToggle = BulkQh->DataToggle; + TransferError = (BulkQh->CurrentTd->dControlStatus & UHCI_TD_STATUS_FIELD) >> 17; + if (TransferError) { + break; + } + BytesTransferred += BytesTransferredNow; + + NextBulkDataTd = BulkDataTd; + LastTd = NextLastTd; + BulkDataTd = (BulkDataTd == BulkDataTd0)? BulkDataTd1 : BulkDataTd0; + + } while ((BytesTransferred < Length) && !BulkQh->ShortPacketDetected); + + UsbUpdateDataToggle(DevInfo, Endp | XferDir, DatToggle); + gUsbData->dLastCommandStatusExtended = TransferError; + if (BulkQh->CurrentTd->dControlStatus & UHCI_TD_STALLED){ + gUsbData->bLastCommandStatus |= USB_BULK_STALLED; + } + if (BulkQh->CurrentTd->dControlStatus & UHCI_TD_ACTIVE) { + gUsbData->bLastCommandStatus |= USB_BULK_TIMEDOUT; + } + // + // Deallocate memory and return the transferred data size + // + USB_MemFree(BulkDataTd0, GET_MEM_BLK_COUNT(NumAllocTDs * sizeof(UHCI_TD))); + USB_MemFree(BulkQh, GET_MEM_BLK_COUNT_STRUC(UHCI_QH)); + + return BytesTransferred; +} + + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_InterruptTransfer +// +// Description: +// This function executes an interrupt transaction on the USB. The data transfer +// direction is always DATA_IN. This function wil not return until the request +// either completes successfully or completes in error (due to time out, etc.) +// +// Input: +// fpHCStruc Pointer to HCStruc of the host controller +// fpDevInfo DeviceInfo structure (if available else 0) +// EndpointAddress The destination USB device endpoint to which the device request +// is being sent. +// MaxPktSize Indicates the maximum packet size the target endpoint is capable +// of sending or receiving. +// fpBuffer Buffer containing data to be sent to the device or buffer to be +// used to receive data +// wLength wLength request parameter, number of bytes of data to be transferred +// +// Output: +// Number of bytes transferred +// +// +// Notes: +// DO NOT TOUCH THE LINK POINTER OF THE TDInterruptData. It is statically allocated +// and linked with other items in the 1ms schedule +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 +UHCI_InterruptTransfer( + HC_STRUC *fpHCStruc, + DEV_INFO *fpDevInfo, + UINT8 EndpointAddress, + UINT16 MaxPktSize, + UINT8 *fpBuffer, + UINT16 wLength) +{ + UINT8 bEndp; + UINT8 DataToggle; + UINT32 dTemp, dValue; + UHCI_QH *IntQh; + UHCI_TD *IntTd; + UINT32 BytesTransferred; + EFI_STATUS EfiStatus = EFI_SUCCESS; + + EfiStatus = UsbHcStrucValidation(fpHCStruc); + + if (EFI_ERROR(EfiStatus)) { + return 0; + } + + EfiStatus = UsbDevInfoValidation(fpDevInfo); + + if (EFI_ERROR(EfiStatus)) { + return 0; + } + +#if USB_RUNTIME_DRIVER_IN_SMM + if (gCheckUsbApiParameter) { + EfiStatus = AmiValidateMemoryBuffer((VOID*)fpBuffer, wLength); + if (EFI_ERROR(EfiStatus)) { + USB_DEBUG(3, "Uhci InterruptTransfer Invalid Pointer, Buffer is in SMRAM.\n"); + return 0; + } + gCheckUsbApiParameter = FALSE; + } +#endif + + if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) { + return 0; + } + + if (UhciIsHalted(fpHCStruc)) { + return 0; + } + + if( !VALID_DEVINFO( fpDevInfo) ) + return 0; + + gUsbData->dLastCommandStatusExtended = 0; + + // + // Check for 0 length transfer (if so, exit) + // + if(wLength == 0) { + return 0; + } + + // + // Store the descriptor pointer in a local variable + // + IntTd = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(UHCI_TD)); + if (IntTd == NULL) { + return 0; + } + + IntTd->pLinkPtr = UHCI_TERMINATE; + + // + // It is an interrupt IN transaction get appropriate size + // + bEndp = EndpointAddress & 0xF; + DataToggle = UsbGetDataToggle(fpDevInfo, EndpointAddress); + + // + // Form device address and endpoint in proper order and bit position + // + dTemp = (UINT32)bEndp << 7; + dTemp = (dTemp | (fpDevInfo->bDeviceAddress)) << 8; //[10:0] = Dev. Addr & Endpoint + //[18:8] = Dev. Addr & Endpoint + // + // Fill in various fields in the interrupt data TD + // + IntTd->dControlStatus = (((UINT32)(fpDevInfo->bEndpointSpeed) & 1) << 26) | + UHCI_TD_THREE_ERRORS | UHCI_TD_ACTIVE; + // + // Set the buffer pointer. Note that currently UHCI Interrupt Transfer + // implementation assumes IN packet; the direction is not passed here as + // parameter. Should this change in future, make a branch to use + // UHCI_TD_OUT_PACKET while constructing dToken. + // + IntTd->pBufferPtr = (UINT32)(UINTN)fpBuffer; + dValue = (UINT32)(wLength - 1); + dValue = ((dValue << 21) | dTemp) & 0xffffff00; + dValue |= EndpointAddress & BIT7 ? UHCI_TD_IN_PACKET : + UHCI_TD_OUT_PACKET; + + if(DataToggle & 1) { + dValue |= UHCI_TD_DATA_TOGGLE; // Make packet into a data 1 + } + + IntTd->dToken = dValue; + IntTd->dCSReload = 0; + IntTd->bActiveFlag = 1; + + IntQh = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(UHCI_QH)); + if (IntQh == NULL) { + return 0; + } + + UhciInitQh(IntQh); + IntQh->pElementPtr = (UINT32)(UINTN)IntTd; + IntQh->CurrentTd = IntTd; + IntQh->Type = Interrupt; + IntQh->FirstTd = IntTd; + IntQh->Interval = UhciTranslateInterval(fpDevInfo->bPollInterval); + + BytesTransferred = UhciExecuteTransfer(fpHCStruc, IntQh); + + gUsbData->dLastCommandStatusExtended = + (IntQh->CurrentTd->dControlStatus & UHCI_TD_STATUS_FIELD) >> 17; + + UsbUpdateDataToggle(fpDevInfo, EndpointAddress, IntQh->DataToggle); + + USB_MemFree(IntTd, GET_MEM_BLK_COUNT_STRUC(UHCI_TD)); + USB_MemFree(IntQh, GET_MEM_BLK_COUNT_STRUC(UHCI_QH)); + + return (UINT16)BytesTransferred; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_DeactivatePolling +// +// Description: +// This function de-activates the polling TD for the requested device. The +// device may be a USB keyboard or USB hub +// +// Input: +// fpHCStruc Pointer to the HC structure +// fpDevInfo Pointer to the device information structure +// +// Output: +// USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_DeactivatePolling ( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo +) +{ + UHCI_QH *PollQh; + UINT8 DataToggle; + + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + EfiStatus = UsbDevInfoValidation(DevInfo); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + if (!(HcStruc->dHCFlag & HC_STATE_RUNNING)) { + return USB_ERROR; + } + + if (UhciIsHalted(HcStruc)) { + return USB_ERROR; + } + + if (DevInfo->fpPollTDPtr == NULL) { + return USB_ERROR; + } + + PollQh = (UHCI_QH*)DevInfo->fpPollTDPtr; + + UhciRemoveQhFromFrameList(HcStruc, PollQh); + + DataToggle = (PollQh->FirstTd->dToken & UHCI_TD_DATA_TOGGLE)? 1 : 0; + if (!(PollQh->FirstTd->dControlStatus & UHCI_TD_STATUS_FIELD)) { + UsbUpdateDataToggle(DevInfo, DevInfo->IntInEndpoint, DataToggle ^ 1); + } + + UhciFreeTds(PollQh->FirstTd); + USB_MemFree(PollQh, GET_MEM_BLK_COUNT_STRUC(UHCI_QH)); + DevInfo->fpPollTDPtr = NULL; + + if (DevInfo->fpPollDataBuffer) { + USB_MemFree(DevInfo->fpPollDataBuffer, GET_MEM_BLK_COUNT(DevInfo->PollingLength)); + DevInfo->fpPollDataBuffer = NULL; + } + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_ActivatePolling +// +// Description: +// This function activates the polling TD for the requested device. The device +// may be a USB keyboard or USB hub +// +// Input: +// fpHCStruc Pointer to the HC structure +// fpDevInfo Pointer to the device information structure +// +// Output: +// USB_SUCCESS or USB_ERROR +// +// Notes: +// For the keyboard device this routine allocates TDRepeat also, if it is not +// already allocated. This routine allocate a polling TD and schedule it to 8ms +// schedule for keyboards and to 1024ms schedule for hubs. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_ActivatePolling ( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo) +{ + UHCI_TD *PollTd; + UHCI_QH *PollQh; + BOOLEAN LowSpeed; + UINT8 PacketId; + UINTN BufferAddr; + UINT32 DataLen; + UINT8 DataToggle; + EFI_STATUS EfiStatus; + + EfiStatus = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + EfiStatus = UsbDevInfoValidation(DevInfo); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + if (!(HcStruc->dHCFlag & HC_STATE_RUNNING)) { + return USB_ERROR; + } + + if (UhciIsHalted(HcStruc)) { + return USB_ERROR; + } + + if( !VALID_DEVINFO(DevInfo) ) + return USB_ERROR; + + DevInfo->fpPollDataBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT(DevInfo->PollingLength)); + if (DevInfo->fpPollDataBuffer == NULL) { + return USB_ERROR; + } + + LowSpeed = (DevInfo->bEndpointSpeed & 1) != 0; + PacketId = DevInfo->IntInEndpoint & BIT7 ? UHCI_TD_IN_PACKET : UHCI_TD_OUT_PACKET; + BufferAddr = (UINTN)DevInfo->fpPollDataBuffer; + DataLen = DevInfo->PollingLength; + DataToggle = UsbGetDataToggle(DevInfo, DevInfo->IntInEndpoint); + + PollTd = UhciAllocGeneralTds(DevInfo->bDeviceAddress, LowSpeed, PacketId, + DevInfo->IntInEndpoint & 0xF, DevInfo->IntInMaxPkt, TRUE, + &BufferAddr, &DataLen, &DataToggle); + if (PollTd == NULL) { + USB_MemFree(DevInfo->fpPollDataBuffer, GET_MEM_BLK_COUNT(DevInfo->PollingLength)); + return USB_ERROR; + } + + PollQh = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(UHCI_QH)); + if (PollQh == NULL) { + USB_MemFree(DevInfo->fpPollDataBuffer, GET_MEM_BLK_COUNT(DevInfo->PollingLength)); + UhciFreeTds(PollTd); + return USB_ERROR; + } + + DevInfo->fpPollTDPtr = (UINT8*)PollQh; + + UhciInitQh(PollQh); + PollQh->pElementPtr = (UINT32)(UINTN)PollTd; + PollQh->CurrentTd = PollTd; + PollQh->Type = Interrupt; + PollQh->FirstTd = PollTd; + PollQh->Interval = UhciTranslateInterval(DevInfo->bPollInterval); + PollQh->CallBackIndex = USB_InstallCallBackFunction(UhciPollingQhCallback); + PollQh->DevInfoPtr = DevInfo; + PollQh->ActiveFlag = TRUE; + + UhciAddQhToFrameList(HcStruc, PollQh); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_DisableKeyRepeat +// +// Description: +// This function disables the keyboard repeat rate logic +// +// Input: +// fpHCStruc Pointer to the HCStruc structure +// +// Output: +// USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_DisableKeyRepeat ( + HC_STRUC *HcStruc +) +{ + UHCI_DESC_PTRS *UhicDescPtrs; + UHCI_QH *Qh; + EFI_STATUS EfiStatus; + UINT8 *MemBlockEnd = gUsbData->fpMemBlockStart + (gUsbData->MemPages << 12); + + EfiStatus = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + if (!(HcStruc->dHCFlag & HC_STATE_RUNNING)) { + return USB_ERROR; + } + + if (UhciIsHalted(HcStruc)) { + return USB_ERROR; + } + + UhicDescPtrs = HcStruc->stDescPtrs.fpUHCIDescPtrs; + + if (UhicDescPtrs == NULL) { + return USB_ERROR; + } + + if (((UINT8*)UhicDescPtrs < gUsbData->fpMemBlockStart) || + ((UINT8*)(UhicDescPtrs + sizeof(UHCI_DESC_PTRS)) > MemBlockEnd)) { + return USB_ERROR; + } + + Qh = UhicDescPtrs->RepeatQh; + + if (Qh == NULL) { + return USB_ERROR; + } + + if (((UINT8*)Qh < gUsbData->fpMemBlockStart) || + ((UINT8*)(Qh + sizeof(UHCI_DESC_PTRS)) > MemBlockEnd)) { + return USB_ERROR; + } + + if (((UINT8*)Qh->FirstTd < gUsbData->fpMemBlockStart) || + ((UINT8*)(Qh->FirstTd + sizeof(UHCI_TD)) > MemBlockEnd)) { + return USB_ERROR; + } + + Qh->FirstTd->dCSReload = UHCI_TD_ONE_ERROR; + Qh->FirstTd->dControlStatus= UHCI_TD_ONE_ERROR; + Qh->FirstTd->bActiveFlag = 0; + Qh->ActiveFlag = FALSE; + Qh->pElementPtr = UHCI_TERMINATE; + + return USB_SUCCESS; + +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_EnableKeyRepeat +// +// Description: +// This function enables the keyboard repeat rate logic +// +// Input: +// fpHCStruc Pointer to the HCStruc structure +// +// Output: +// USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_EnableKeyRepeat ( + HC_STRUC *HcStruc +) +{ + UHCI_DESC_PTRS *UhicDescPtrs; + UHCI_QH *Qh; + EFI_STATUS EfiStatus; + UINT8 *MemBlockEnd = gUsbData->fpMemBlockStart + (gUsbData->MemPages << 12); + + EfiStatus = UsbHcStrucValidation(HcStruc); + + if (EFI_ERROR(EfiStatus)) { + return USB_ERROR; + } + + if (!(HcStruc->dHCFlag & HC_STATE_RUNNING)) { + return USB_ERROR; + } + + if (UhciIsHalted(HcStruc)) { + return USB_ERROR; + } + + UhicDescPtrs = HcStruc->stDescPtrs.fpUHCIDescPtrs; + + if (UhicDescPtrs == NULL) { + return USB_ERROR; + } + + if (((UINT8*)UhicDescPtrs < gUsbData->fpMemBlockStart) || + ((UINT8*)(UhicDescPtrs + sizeof(UHCI_DESC_PTRS)) > MemBlockEnd)) { + return USB_ERROR; + } + + Qh = UhicDescPtrs->RepeatQh; + + if (((UINT8*)Qh < gUsbData->fpMemBlockStart) || + ((UINT8*)(Qh + sizeof(UHCI_DESC_PTRS)) > MemBlockEnd)) { + return USB_ERROR; + } + + if (((UINT8*)Qh->FirstTd < gUsbData->fpMemBlockStart) || + ((UINT8*)(Qh->FirstTd + sizeof(UHCI_TD)) > MemBlockEnd)) { + return USB_ERROR; + } + + Qh->FirstTd->dCSReload = (UHCI_TD_INTERRUPT_ON_COMPLETE | + UHCI_TD_ONE_ERROR | UHCI_TD_ACTIVE); + Qh->FirstTd->dControlStatus = Qh->FirstTd->dCSReload; + Qh->FirstTd->bActiveFlag = 1; + Qh->pElementPtr = (UINT32)(UINTN)Qh->FirstTd; + Qh->CurrentTd = Qh->FirstTd; + Qh->ActiveFlag = TRUE; + + return USB_SUCCESS; +} + + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_DisableHCPorts (fpHCStruc) +// +// Description: +// This routine disables the UHCI HC root hub ports +// +// Input: +// fpHCStruc Ptr to the host controller structure +// +// Output: +// Status: USB_SUCCESS = Success, USB_ERROR = Failure +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_DisableHCPorts (HC_STRUC* fpHCStruc) +{ + UINT16 wIOAddr = (UINT16)fpHCStruc->BaseAddress; + + // + // Disable the root hub port 1 + // + ByteWriteIO((UINT16)(wIOAddr+UHCI_PORT1_CONTROL), + (UINT8)(ByteReadIO( + (UINT16)(wIOAddr+UHCI_PORT1_CONTROL)) & (~UHC_PORT_ENABLE))); + // + // Disable the root hub port 2 + // + ByteWriteIO((UINT16)(wIOAddr+UHCI_PORT2_CONTROL), + (UINT8)(ByteReadIO( + (UINT16)(wIOAddr+UHCI_PORT2_CONTROL)) & (~UHC_PORT_ENABLE))); + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UhciAddQhToFrameList +// +// Description: +// This routine will add the particular QH into the frame list +// +// Input: +// HcStruc Pointerr to the host controller structure +// NewQh Address of the QH to be linked +// +// Output: +// USB_SUCCESS/USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UhciAddQhToFrameList ( + HC_STRUC *HcStruc, + UHCI_QH *NewQh +) +{ + UINT16 Index; + UINT32 *PrevPtr; + UINT32 LinkPtr; + UHCI_QH *Qh; + BOOLEAN ByInterval = FALSE; + EFI_STATUS Status = EFI_SUCCESS; + + if (NewQh == NULL) { + return USB_ERROR; + } + + switch (NewQh->Type) { + case Control: + case Bulk: + ByInterval = FALSE; + break; + case Interrupt: + ByInterval = TRUE; + break; + case Isochronous: + ASSERT(FALSE); + default: + return USB_ERROR; + } + + if (ByInterval && NewQh->Interval == 0) { + return USB_ERROR; + } + + for (Index = 0; Index < HcStruc->wAsyncListSize; + ByInterval ? Index += NewQh->Interval : Index++) { + PrevPtr = &HcStruc->fpFrameList[Index]; + LinkPtr = *PrevPtr; + + while (!(LinkPtr & UHCI_TERMINATE)) { + Qh = (UHCI_QH*)(LinkPtr & UHCI_POINTER_MASK); +#if USB_RUNTIME_DRIVER_IN_SMM + Status = AmiValidateMemoryBuffer((VOID*)Qh, sizeof(UHCI_QH)); + if (EFI_ERROR(Status)) { + return USB_ERROR; + } +#endif + if (Qh->Type <= NewQh->Type) { + if (ByInterval == FALSE || + Qh->Interval <= NewQh->Interval) { + break; + } + } + PrevPtr = &Qh->pLinkPtr; + LinkPtr = *PrevPtr; + } + if (Qh == NewQh) { + continue; + } +#if USB_RUNTIME_DRIVER_IN_SMM + Status = AmiValidateMemoryBuffer((VOID*)PrevPtr, sizeof(UINT32)); + if (EFI_ERROR(Status)) { + return USB_ERROR; + } +#endif + NewQh->pLinkPtr = *PrevPtr; + *PrevPtr = (UINT32)((UINTN)NewQh | UHCI_QUEUE_HEAD); + } + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UhciRemoveQhFromFrameList +// +// Description: +// This routine will remove a QH from the the frame list +// +// Input: +// HcStruc Pointerr to the host controller structure +// RetiredQh Address of the QH to be removed +// +// Output: +// USB_SUCCESS/USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UhciRemoveQhFromFrameList ( + HC_STRUC *HcStruc, + UHCI_QH *RetiredQh +) +{ + UINT16 Index; + UINT32 *PrevPtr; + UINT32 LinkPtr; + UHCI_QH *Qh; + BOOLEAN ByInterval = FALSE; + EFI_STATUS Status = EFI_SUCCESS; + + if (RetiredQh == NULL) { + return USB_ERROR; + } + + switch (RetiredQh->Type) { + case Control: + case Bulk: + ByInterval = FALSE; + break; + case Interrupt: + ByInterval = TRUE; + break; + case Isochronous: + ASSERT(FALSE); + default: + return USB_ERROR; + } + + if (ByInterval && RetiredQh->Interval == 0) { + return USB_ERROR; + } + + RetiredQh->pElementPtr = UHCI_TERMINATE; + + for (Index = 0; Index < HcStruc->wAsyncListSize; + ByInterval ? Index += RetiredQh->Interval : Index++) { + PrevPtr = &HcStruc->fpFrameList[Index]; + LinkPtr = *PrevPtr; + + while (!(LinkPtr & UHCI_TERMINATE)) { + Qh = (UHCI_QH*)(LinkPtr & UHCI_POINTER_MASK); +#if USB_RUNTIME_DRIVER_IN_SMM + Status = AmiValidateMemoryBuffer((VOID*)Qh, sizeof(UHCI_QH)); + if (EFI_ERROR(Status)) { + return USB_ERROR; + } +#endif + if (Qh == RetiredQh) { + break; + } + PrevPtr = &Qh->pLinkPtr; + LinkPtr = *PrevPtr; + } + + if (LinkPtr & UHCI_TERMINATE) { + continue; + } +#if USB_RUNTIME_DRIVER_IN_SMM + Status = AmiValidateMemoryBuffer((VOID*)PrevPtr, sizeof(UINT32)); + if (EFI_ERROR(Status)) { + return USB_ERROR; + } +#endif + *PrevPtr = RetiredQh->pLinkPtr; + } + + RetiredQh->pLinkPtr = UHCI_TERMINATE; + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_StartTDSchedule (fpHCStruc) +// +// Description: +// This routine will start the TD schedule for the UHCI controller. After this +// routine TD's can be scheduled for execution. +// +// Input: +// fpHCStruc Pointer to the HC information structure +// +// Output: +// USB_SUCCESS/USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_StartTDSchedule ( + HC_STRUC *HcStruc +) +{ + UHCI_DESC_PTRS *DescPtr; + UHCI_TD *Td; + + // + // Allocate the UHCI descriptor pointer structure + // + DescPtr = (UHCI_DESC_PTRS*) USB_MemAlloc (GET_MEM_BLK_COUNT_STRUC(UHCI_DESC_PTRS)); + if (DescPtr == NULL) { + USB_DEBUG(DEBUG_LEVEL_4, "UHCI Descriptor struc alloc failed.\n"); + return USB_ERROR; + } + + // + // Save the value in the HC struc + // + HcStruc->stDescPtrs.fpUHCIDescPtrs = DescPtr; + + DescPtr->StaticQh = USB_MemAlloc(GET_MEM_BLK_COUNT(1 * sizeof(UHCI_QH))); + if (DescPtr->StaticQh == NULL) { + return USB_ERROR; + } + + UhciInitQh(DescPtr->StaticQh); + DescPtr->StaticQh->Type = Interrupt; + DescPtr->StaticQh->Interval = 1; + UhciAddQhToFrameList(HcStruc, DescPtr->StaticQh); + + if (HcStruc->dHCFlag & HC_STATE_EXTERNAL) { + return USB_SUCCESS; + } + + DescPtr->RepeatQh = USB_MemAlloc(GET_MEM_BLK_COUNT(1 * sizeof(UHCI_QH) + + 1 * sizeof(UHCI_TD))); + if(DescPtr->RepeatQh == NULL) { + return USB_ERROR; + } + + Td = (UHCI_TD*)((UINTN)DescPtr->RepeatQh + sizeof (UHCI_QH)); + + // + // Initialize the body of TdRepeat. It will run a interrupt transaction + // to a non-existant dummy device. This will have the effect of generating + // a periodic interrupt used to generate keyboard repeat. This TD is normally + // inactive, and is only activated when a key is pressed. TdRepeat will be + // set to timeout after two attempts. Since the TD is in the schedule + // at 16ms intervals, this will generate an interrupt at intervals of 32ms + // (when the TD is active). This 32ms periodic interrupt may then + // approximate the fastest keyboard repeat rate of 30 characters per second. + // + Td->pLinkPtr = UHCI_TERMINATE; + Td->dControlStatus = UHCI_TD_ONE_ERROR; + Td->dToken = (UHCI_TD_IN_PACKET | + ((UINT32)DUMMY_DEVICE_ADDR << 8) | + ((UINT32)(DEFAULT_PACKET_LENGTH - 1) << 21)); + Td->pBufferPtr = (UINT32)(UINTN)Td->aDataArea; + Td->dCSReload = UHCI_TD_ONE_ERROR; + Td->bActiveFlag = 0; + + UhciInitQh(DescPtr->RepeatQh); + DescPtr->RepeatQh->Type = Interrupt; + DescPtr->RepeatQh->FirstTd = Td; + DescPtr->RepeatQh->Interval = REPEAT_INTERVAL; + DescPtr->RepeatQh->CallBackIndex = USB_InstallCallBackFunction(UhciRepeatQhCallback); + DescPtr->RepeatQh->ActiveFlag = FALSE; + + // + // Schedule the TDRepeat to 8ms schedule + // + UhciAddQhToFrameList(HcStruc, DescPtr->RepeatQh); + + // + // Inform the common code that key repeat is implemented + // + USBKeyRepeat(HcStruc, 0); + + // + // Initialize the body of root hub TD. It will run a interrupt + // transaction to a nonexistent dummy device. This will have the effect + // of generating a periodic interrupt for the purpose of checking for + // attach/detach on the root hub's ports + // This initialization is done only once for the first HC + // + DescPtr->RootHubQh = USB_MemAlloc(GET_MEM_BLK_COUNT(1 * sizeof(UHCI_QH) + + 1 * sizeof(UHCI_TD))); + ASSERT(DescPtr->RootHubQh != NULL); + if (DescPtr->RootHubQh == NULL) { + return USB_ERROR; + } + + Td = (UHCI_TD*)((UINTN)DescPtr->RootHubQh + sizeof (UHCI_QH)); + + Td->pLinkPtr = UHCI_TERMINATE; + Td->dControlStatus = 0; + Td->dToken = + (UHCI_TD_IN_PACKET | ((UINT32)DUMMY_DEVICE_ADDR << 8) | + ((UINT32)(DEFAULT_PACKET_LENGTH - 1) << 21)); + Td->pBufferPtr = (UINT32)(UINTN)Td->aDataArea; + Td->dCSReload = 0; + Td->bActiveFlag = 0; + + UhciInitQh(DescPtr->RootHubQh); + DescPtr->RootHubQh->Type = Interrupt; + DescPtr->RootHubQh->FirstTd = Td; + DescPtr->RootHubQh->Interval = 128; + DescPtr->RootHubQh->CallBackIndex = USB_InstallCallBackFunction(UhciRootHubQhCallBack); + DescPtr->RootHubQh->ActiveFlag = FALSE; + + // + // Schedule the root hub TD to 256ms schedule + // + UhciAddQhToFrameList(HcStruc, DescPtr->RootHubQh); + + if (gUsbData->RootHubHcStruc == NULL) { + Td->dCSReload = + UHCI_TD_INTERRUPT_ON_COMPLETE | + UHCI_TD_ONE_ERROR | + UHCI_TD_ACTIVE; + Td->bActiveFlag = 1; + Td->dControlStatus = Td->dCSReload; + DescPtr->RootHubQh->pElementPtr = (UINT32)(UINTN)Td; + DescPtr->RootHubQh->CurrentTd = Td; + DescPtr->RootHubQh->ActiveFlag = TRUE;; + gUsbData->RootHubHcStruc = HcStruc; + } + + USB_DEBUG(DEBUG_LEVEL_4, "TD's are scheduled\n"); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_StopTDSchedule (fpHCStruc) +// +// Description: +// This routine will stop the TD schedules and frees the data structures +// +// Input: +// fpHCStruc Pointer to the HC information structure +// +// Output: +// USB_SUCCESS/USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UHCI_StopTDSchedule ( + HC_STRUC *HcStruc +) +{ + UINT8 i; + UHCI_DESC_PTRS *DescPtrs = HcStruc->stDescPtrs.fpUHCIDescPtrs; + UINT8 *MemBlockEnd = gUsbData->fpMemBlockStart + (gUsbData->MemPages << 12); + // + // Free all the TD/QH data structures + // + if (DescPtrs == NULL) { + return USB_ERROR; + } + + if (((UINT8*)DescPtrs < gUsbData->fpMemBlockStart) || + ((UINT8*)(DescPtrs + sizeof(UHCI_DESC_PTRS)) > MemBlockEnd)) { + return USB_ERROR; + } + + if (((UINT8*)DescPtrs->StaticQh < gUsbData->fpMemBlockStart) || + ((UINT8*)(DescPtrs->StaticQh + sizeof(UHCI_QH)) > MemBlockEnd)) { + return USB_ERROR; + } + + if (((UINT8*)DescPtrs->RootHubQh < gUsbData->fpMemBlockStart) || + ((UINT8*)(DescPtrs->RootHubQh + sizeof(UHCI_QH)) > MemBlockEnd)) { + return USB_ERROR; + } + + if (((UINT8*)DescPtrs->RepeatQh < gUsbData->fpMemBlockStart) || + ((UINT8*)(DescPtrs->RepeatQh + sizeof(UHCI_QH)) > MemBlockEnd)) { + return USB_ERROR; + } + + USB_MemFree (DescPtrs->StaticQh, GET_MEM_BLK_COUNT(sizeof(UHCI_QH))); + if (DescPtrs->RootHubQh) { + USB_MemFree (DescPtrs->RootHubQh, + GET_MEM_BLK_COUNT(sizeof(UHCI_QH) + sizeof(UHCI_TD))); + } + if (DescPtrs->RepeatQh) { + USB_MemFree (DescPtrs->RepeatQh, + GET_MEM_BLK_COUNT(sizeof(UHCI_QH) + sizeof(UHCI_TD))); + } + + // + // Finally free the descriptor pointer + // + USB_MemFree (DescPtrs, GET_MEM_BLK_COUNT_STRUC(UHCI_DESC_PTRS)); + + USBKeyRepeat(HcStruc, 3); + + if (gUsbData->RootHubHcStruc == HcStruc) { + gUsbData->RootHubHcStruc = NULL; + for (i = 0; i < gUsbData->HcTableCount; i++) { + if (gUsbData->HcTable[i] == NULL) { + continue; + } + if ((gUsbData->HcTable[i]->bHCNumber) && + (gUsbData->HcTable[i]->bHCType == USB_HC_UHCI) && + (gUsbData->HcTable[i]->dHCFlag & HC_STATE_RUNNING) && + (HcStruc != gUsbData->HcTable[i])) { + + DescPtrs = gUsbData->HcTable[i]->stDescPtrs.fpUHCIDescPtrs; + + if (((UINT8*)DescPtrs < gUsbData->fpMemBlockStart) || + ((UINT8*)(DescPtrs + sizeof(UHCI_DESC_PTRS)) > MemBlockEnd)) { + return USB_ERROR; + } + if (((UINT8*)DescPtrs->RootHubQh < gUsbData->fpMemBlockStart) || + ((UINT8*)(DescPtrs->RootHubQh + sizeof(UHCI_QH)) > MemBlockEnd)) { + return USB_ERROR; + } + + if (((UINT8*)DescPtrs->RootHubQh->FirstTd < gUsbData->fpMemBlockStart) || + ((UINT8*)(DescPtrs->RootHubQh->FirstTd + sizeof(UHCI_TD)) > MemBlockEnd)) { + return USB_ERROR; + } + + if (((UINT8*)DescPtrs->RootHubQh->CurrentTd < gUsbData->fpMemBlockStart) || + ((UINT8*)(DescPtrs->RootHubQh->CurrentTd + sizeof(UHCI_TD)) > MemBlockEnd)) { + return USB_ERROR; + } + + DescPtrs->RootHubQh->FirstTd->dCSReload = + UHCI_TD_INTERRUPT_ON_COMPLETE | + UHCI_TD_ONE_ERROR | + UHCI_TD_ACTIVE; + DescPtrs->RootHubQh->FirstTd->bActiveFlag = 1; + DescPtrs->RootHubQh->FirstTd->dControlStatus = + DescPtrs->RootHubQh->FirstTd->dCSReload; + DescPtrs->RootHubQh->pElementPtr = + (UINT32)(UINTN)DescPtrs->RootHubQh->FirstTd; + DescPtrs->RootHubQh->CurrentTd = + DescPtrs->RootHubQh->FirstTd; + DescPtrs->RootHubQh->ActiveFlag = TRUE;; + gUsbData->RootHubHcStruc = gUsbData->HcTable[i]; + } + } + } + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UhciProcessQh +// +// Description: +// This function will check whether the QH is completed if so, it will call +// the call back routine associated with the TDs present in the QH +// +// Input: +// HcStruc HCStruc structure +// Qh Pointer to the QH +// +// Output: +// USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UhciProcessQh( + HC_STRUC *HcStruc, + UHCI_QH *Qh +) +{ + UHCI_TD *Td; + UINT16 Length; + EFI_STATUS Status; + + if (Qh == NULL) { + return USB_ERROR; + } + + if (Qh->ActiveFlag == FALSE) { + return USB_SUCCESS; + } + + if (Qh->FirstTd == NULL) { + return USB_SUCCESS; + } + + if (Qh->CurrentTd == NULL) { + Qh->CurrentTd = Qh->FirstTd; + } + + Td = Qh->CurrentTd; + while (Td) { + Qh->CurrentTd = Td; + Qh->DataToggle = Td->dToken & UHCI_TD_DATA_TOGGLE ? 1 : 0; + + if (Td->dControlStatus & UHCI_TD_ACTIVE) { + return USB_ERROR; + } + + Length = (UINT16)((Td->dControlStatus + 1) & UHCI_TD_ACTUAL_LENGTH); + Qh->BytesTransferred += Length; + + if (Td->dControlStatus & UHCI_TD_STATUS_FIELD) { + break; + } + + Qh->DataToggle ^= 1; + Qh->ShortPacketDetected = (Length < (((Td->dToken >> 21) + 1) & 0x7FF)); + + if (Qh->ShortPacketDetected) { + if (Qh->Type == Control) { + while (!(Td->pLinkPtr & UHCI_TERMINATE)) { + Td = (UHCI_TD*)((UINTN)Td->pLinkPtr & UHCI_POINTER_MASK); + } + Qh->pElementPtr = (UINT32)(UINTN)Td; + continue; + } + break; + } + + Td = Td->pLinkPtr & UHCI_TERMINATE ? + NULL : (UHCI_TD*)(Td->pLinkPtr & UHCI_POINTER_MASK); + } + + Qh->ActiveFlag = FALSE; + if (Qh->CallBackIndex == 0) { + return USB_SUCCESS; + } + + if ((Qh->CallBackIndex) && (Qh->CallBackIndex <= MAX_CALLBACK_FUNCTION)) { + if (gUsbData->aCallBackFunctionTable[Qh->CallBackIndex - 1]) { + if ((gUsbData->aCallBackFunctionTable[Qh->CallBackIndex - 1] != UhciRepeatQhCallback) && + (gUsbData->aCallBackFunctionTable[Qh->CallBackIndex - 1] != UhciRootHubQhCallBack)) { + Status = UsbDevInfoValidation(Qh->DevInfoPtr); + if (EFI_ERROR(Status)) { + return USB_ERROR; + } + } + (*gUsbData->aCallBackFunctionTable[Qh->CallBackIndex - 1])( + HcStruc, + (DEV_INFO*)Qh->DevInfoPtr, + (UINT8*)Qh, + 0, + 0); + } + } + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UhciProcessTd +// +// Description: +// This function will check whether the TD is completed if so, it will call +// the call back routine associated with this TD +// +// Input: +// HcStruc HCStruc structure +// Td Pointer to the TD +// +// Output: +// USB_SUCCESS or USB_ERROR +// +// Notes: +// For any TD whose ActiveFlag is TRUE and its ControlStatus bit 23 is clear +// (completed), process the TD by calling its callback routine, if one is present. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UhciProcessTd( + HC_STRUC *HcStruc, + UHCI_TD *Td +) +{ + UINT8 DevAddr; + DEV_INFO *DevInfo; + + if (Td == NULL) { // Check for NULL + return USB_ERROR; + } + + if (Td->bActiveFlag == 0) { + return USB_SUCCESS; + } + + if (Td->dControlStatus & UHCI_TD_ACTIVE) { + return USB_ERROR; + } + + Td->bActiveFlag = 0; + if ((Td->bCallBackIndex) && (Td->bCallBackIndex <= MAX_CALLBACK_FUNCTION)) { + // + // Get the device address from the completed TD + // + DevAddr = (UINT8)(((Td->dToken) >> 8) & 0x7F); + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_ADDR, 0, + DevAddr, HcStruc); + + if (gUsbData->aCallBackFunctionTable[Td->bCallBackIndex - 1]) { + (*gUsbData->aCallBackFunctionTable[Td->bCallBackIndex - 1])( + HcStruc, + DevInfo, + (UINT8*)Td, + 0, + 0); + } + } + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UhciProcessFrameList +// +// Description: +// This function will parse through frame list to find completed QH/TD +// and invoke corresponding call back routine +// +// Input: +// HcStruc HCStruc structure +// +// Output: +// USB_SUCCESS or USB_ERROR +// +// Notes: +// For any TD whose ActiveFlag is TRUE and its ControlStatus bit 23 is clear +// (completed), process the TD by calling its call back routine, if one is present. +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UhciProcessFrameList ( + HC_STRUC *HcStruc +) +{ + UINT32 ListPtr; + EFI_STATUS Status = EFI_SUCCESS; + + ListPtr = HcStruc->fpFrameList[0]; + + while (!(ListPtr & UHCI_TERMINATE)) { + if (ListPtr & UHCI_QUEUE_HEAD) { +#if USB_RUNTIME_DRIVER_IN_SMM + Status = AmiValidateMemoryBuffer((VOID*)ListPtr, sizeof(UHCI_QH)); + if (EFI_ERROR(Status)) { + return USB_ERROR; + } +#endif + UhciProcessQh(HcStruc, (UHCI_QH*)(ListPtr & UHCI_POINTER_MASK)); + ListPtr = ((UHCI_QH*)(ListPtr & UHCI_POINTER_MASK))->pLinkPtr; + } else { +#if USB_RUNTIME_DRIVER_IN_SMM + Status = AmiValidateMemoryBuffer((VOID*)ListPtr, sizeof(UHCI_TD)); + if (EFI_ERROR(Status)) { + return USB_ERROR; + } +#endif + UhciProcessTd(HcStruc, (UHCI_TD*)(ListPtr & UHCI_POINTER_MASK)); + ListPtr = ((UHCI_TD*)(ListPtr & UHCI_POINTER_MASK))->pLinkPtr; + } + } + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_RootHubTDCallBack +// +// Description: +// This function is called when TD256ms completes a transaction. This TD runs +// a dummy interrupt transaction to a non-existant device address for the +// purpose of generating a periodic timeout interrupt. This periodic interrupt +// may be used to check for new devices on the root hub etc. +// +// Input: +// fpHCStruc Pointer to the HCStruc structure +// fpDevInfo NULL (pDevInfo is not valid) +// fpTD Pointer to the TD that completed +// fpBuffer Not used +// +// Output: +// USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UhciRootHubQhCallBack( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo, + UINT8 *Qh, + UINT8 *Buffer, + UINT16 DataLength +) +{ + UINT8 Index; + HC_STRUC *Hc; + UINT16 IoPort; + UINT16 PortAddr; + UHCI_QH *RootHubQh; + + // + // First deactivate the TDRootHub so this callback function will not get + // reentered. + // + if (Qh != NULL) { + RootHubQh = (UHCI_QH*)Qh; + RootHubQh->FirstTd->bActiveFlag = 0; + } + + for (Index = 0; Index < gUsbData->HcTableCount; Index++) { + Hc = gUsbData->HcTable[Index]; + if (Hc == NULL) { + continue; + } + + if (Hc->bHCType != USB_HC_UHCI) { // Process for UHCI only + continue; + } + + if (!(Hc->dHCFlag & HC_STATE_RUNNING)) { + continue; + } + + // + // Check whether the controller is still under BIOS control + // Read the frame list base address and compare with stored value + // + IoPort = (UINT16)Hc->BaseAddress; + if ((DwordReadIO(IoPort + UHCI_FRAME_LIST_BASE) & 0xFFFFF000) + != (UINT32)Hc->fpFrameList) { + continue; + } + + // + // Check whether USB host controllers are accessible to aVOID system + // hang in ports enumeration. + // + if (ByteReadIO(IoPort) == 0xFF) { + continue; + } + + // + // Check whether enumeration is already began + // + if(gUsbData->bEnumFlag == FALSE) { + gUsbData->bEnumFlag = TRUE; + + // + // Mask the Host Controller interrupt so the ISR does not get re-entered due + // to an IOC interrupt from any TDs that complete in frames while we are + // configuring a new device that has just been plugged in. + // + // Disable IOC, timeout & CRC interrupt + // + WordWriteIO((UINT16)(IoPort + UHCI_INTERRUPT_ENABLE), 0); + + // + // Process Port#1 and clear Port#1 status bit + // + PortAddr = IoPort + UHCI_PORT1_CONTROL; + if (WordReadIO(PortAddr) & UHC_CONNECT_STATUS_CHANGE) { + USBCheckPortChange(Hc, Hc->bHCNumber | BIT7, 1); + WordWriteIO(PortAddr, WordReadIO(PortAddr)); + } + + // + // Process Port#2 and clear Port#2 status bit + // + PortAddr = IoPort + UHCI_PORT2_CONTROL; + if (WordReadIO(PortAddr) & UHC_CONNECT_STATUS_CHANGE) { + USBCheckPortChange(Hc, Hc->bHCNumber | BIT7, 2); + WordWriteIO(PortAddr, WordReadIO(PortAddr)); + } + + // + // Renable interrupts from the host controller + // Enable IOC, timeout & CRC interrupt + // + WordWriteIO((UINT16)(IoPort + UHCI_INTERRUPT_ENABLE), (UINT16)(UHC_IOC_ENABLE)); + + gUsbData->bEnumFlag = FALSE; + } + } + + // + // Reactivate the TdRootHub + // + if (Qh != NULL) { + RootHubQh->FirstTd->dControlStatus = RootHubQh->FirstTd->dCSReload; + RootHubQh->FirstTd->bActiveFlag = 1; + RootHubQh->pElementPtr = (UINT32)(UINTN)RootHubQh->FirstTd; + RootHubQh->CurrentTd = RootHubQh->FirstTd; + RootHubQh->ActiveFlag = TRUE; + } + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_RepeatTDCallback +// +// Description: +// This function is called when TdRepeat completes a transaction. This TD +// runs a dummy interrupt transaction to a non-existant device address for +// the purpose of generating a periodic timeout interrupt which in turn is +// used to generate keyboard repeat. +// +// Input: +// fpHCStruc Pointer to the HCStruc structure +// fpDevInfo NULL (pDevInfo is not valid) +// fpTD Pointer to the TD that completed +// fpBuffer Not used +// +// Output: +// USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UhciRepeatQhCallback( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo, + UINT8 *Qh, + UINT8 *Buffer, + UINT16 DataLength +) +{ + UHCI_QH *RepeatQh = (UHCI_QH*)Qh; + + USB_DEBUG(DEBUG_LEVEL_8, "Processing Repeat TD ...\n"); + // + // First deactivate the TdRepeat so this callback function will not get + // re-entered. + // + RepeatQh->FirstTd->bActiveFlag = 0; + +#if USB_DEV_KBD + USBKBDPeriodicInterruptHandler(HcStruc); +#endif + // + // Reactivate the TdRepeat + // + if (RepeatQh->FirstTd->dCSReload & UHCI_TD_ACTIVE) { + RepeatQh->FirstTd->dControlStatus = RepeatQh->FirstTd->dCSReload; + RepeatQh->FirstTd->bActiveFlag = 1; + RepeatQh->pElementPtr = (UINT32)(UINTN)RepeatQh->FirstTd; + RepeatQh->CurrentTd = RepeatQh->FirstTd; + RepeatQh->ActiveFlag = TRUE; + } + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// Name: UHCI_PollingTDCallback +// +// Description: +// This function is called when a polling TD from the TD pool completes an +// interrupt transaction to its assigned device. +// This routine should process any data in the TD's data buffer, handle any +// errors, and then copy the TD's CSReloadValue field into its control status +// field to put the TD back into service. +// +// Input: +// fpHCStruc Pointer to the HCStruc structure +// fpDevInfo NULL (pDevInfo is not valid) +// fpTD Pointer to the TD that completed +// +// Output: +// USB_SUCCESS or USB_ERROR +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UhciPollingQhCallback( + HC_STRUC *HcStruc, + DEV_INFO *DevInfo, + UINT8 *Qh, + UINT8 *Buffer, + UINT16 DataLength +) +{ + UHCI_QH *PollQh = (UHCI_QH*)Qh; + + USB_DEBUG(DEBUG_LEVEL_8, "Processing polling TD ...\n"); + + UsbUpdateDataToggle(DevInfo, DevInfo->IntInEndpoint, + PollQh->DataToggle); + + if ((PollQh->CurrentTd->dControlStatus & UHCI_TD_STATUS_FIELD) == 0) { + if ((DevInfo->bCallBackIndex) && (DevInfo->bCallBackIndex <= MAX_CALLBACK_FUNCTION)) { + if (gUsbData->aCallBackFunctionTable[DevInfo->bCallBackIndex - 1]) { + (*gUsbData->aCallBackFunctionTable[DevInfo->bCallBackIndex-1])( + HcStruc, + DevInfo, + Qh, + DevInfo->fpPollDataBuffer, + PollQh->BytesTransferred); + } + } + } + + UhciActivateTds(PollQh->FirstTd, PollQh->DataToggle); + + PollQh->pElementPtr = (UINT32)(UINTN)PollQh->FirstTd; + PollQh->CurrentTd = PollQh->FirstTd; + PollQh->BytesTransferred = 0; + PollQh->ActiveFlag = TRUE; + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: UhciInitQh +// +// Description: This function check whether HC is halted. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UhciInitQh ( + UHCI_QH *Qh +) +{ + Qh->pLinkPtr = UHCI_TERMINATE; + Qh->pElementPtr = UHCI_TERMINATE; + Qh->CurrentTd = NULL; + Qh->DataToggle = 0; + Qh->BytesTransferred = 0; + Qh->ShortPacketDetected = FALSE; + Qh->FirstTd = NULL; + Qh->Interval = 0; + Qh->CallBackIndex = 0; + Qh->ActiveFlag = FALSE; + Qh->DevInfoPtr = NULL; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: UhciIsHalted +// +// Description: This function check whether HC is halted. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +BOOLEAN +UhciIsHalted ( + HC_STRUC *HcStruc +) +{ + return (ByteReadIO((UINT16)(HcStruc->BaseAddress + UHCI_STATUS_REG)) & UHC_HC_HALTED) == UHC_HC_HALTED; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: UhciTranslateInterval +// +// Description: This function calculates the polling rate. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +UhciTranslateInterval( + UINT8 Interval +) +{ + UINT8 BitCount = 0; + + // The Interval value should be from 1 to 255 + ASSERT(Interval >= 1 && Interval <= 255); + + for (BitCount = 0; Interval != 0; BitCount++) { + Interval >>= 1; + } + return (1 << (BitCount - 1)); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: UhciAllocGeneralTds +// +// Description: +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UHCI_TD* +UhciAllocGeneralTds ( + IN UINT8 DeviceAddr, + IN BOOLEAN LowSpeed, + IN UINT8 PacketId, + IN UINT8 EndpointAddr, + IN UINT16 MaxPacket, + IN BOOLEAN ShortPacket, + IN OUT UINTN *BufferAddr, + IN OUT UINT32 *Length, + IN OUT UINT8 *DataToggle +) +{ + UINT16 NumTds = 0; + UHCI_TD *FirstTd = NULL; + UHCI_TD *Td = NULL; + UINTN Address = *BufferAddr; + UINT32 BytesRemaining = *Length; + UINT8 Toggle = *DataToggle; + UINT16 MaxLen = 0; + + if (BytesRemaining == 0) { + return NULL; + } + + NumTds = BytesRemaining / MaxPacket; + if (BytesRemaining % MaxPacket) { + NumTds++; + } + + FirstTd = USB_MemAlloc(GET_MEM_BLK_COUNT(NumTds * sizeof(UHCI_TD))); + if (FirstTd == NULL) { + return NULL; + } + + for (Td = FirstTd;;) { + MaxLen = BytesRemaining > MaxPacket ? MaxPacket : BytesRemaining; + + Td->pLinkPtr = UHCI_TERMINATE; + Td->dToken = (UINT32)PacketId | ((UINT32)DeviceAddr << 8) | + ((UINT32)EndpointAddr << 15) | ((MaxLen - 1) << 21); + if (Toggle) { + Td->dToken |= UHCI_TD_DATA_TOGGLE; + } + + Td->pBufferPtr = (UINT32)Address; + Td->dCSReload = UHCI_TD_THREE_ERRORS | UHCI_TD_ACTIVE; + if (LowSpeed) { + Td->dCSReload |= UHCI_TD_LOW_SPEED_DEVICE; + } + if (ShortPacket) { + Td->dCSReload |= UHCI_TD_SHORT_PACKET_DETECT; + } + Td->dControlStatus = Td->dCSReload; + Td->bActiveFlag = 1; + + BytesRemaining -= MaxLen; + Address += MaxLen; + Toggle ^= 1; + + if (BytesRemaining == 0) { + break; + } + + Td->pLinkPtr = (UINT32)(((UINTN)Td + sizeof(UHCI_TD)) | UHCI_VERTICAL_FLAG); + Td = (UHCI_TD*)((UINTN)Td->pLinkPtr & UHCI_POINTER_MASK); + } + + Td->dCSReload |= UHCI_TD_INTERRUPT_ON_COMPLETE; + Td->dControlStatus = Td->dCSReload; + + *Length = BytesRemaining; + *BufferAddr = Address; + *DataToggle = Toggle; + + return FirstTd; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: UhciFreeTds +// +// Description: +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UhciFreeTds ( + IN UHCI_TD *FirstTd +) +{ + UHCI_TD *Td = FirstTd; + UINT16 NumTds = 0; + + if (FirstTd == NULL) { + return; + } + + while (Td) { + NumTds++; + Td = Td->pLinkPtr & UHCI_TERMINATE ? + NULL : (UHCI_TD*)((UINTN)Td->pLinkPtr & UHCI_POINTER_MASK); + } + + USB_MemFree(FirstTd, GET_MEM_BLK_COUNT(NumTds * sizeof(UHCI_TD))); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// +// Procedure: UhciActivateTds +// +// Description: +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +UhciActivateTds ( + IN UHCI_TD *FirstTd, + IN UINT8 DataToggle +) +{ + UHCI_TD *Td = FirstTd; + UINT8 Toogle = DataToggle; + + if (FirstTd == NULL) { + return; + } + + while (Td) { + Td->dToken &= ~UHCI_TD_DATA_TOGGLE; + if (Toogle) { + Td->dToken |= UHCI_TD_DATA_TOGGLE; + } + Td->dControlStatus = Td->dCSReload; + Td->bActiveFlag = 1; + + Toogle ^= 1; + Td = Td->pLinkPtr & UHCI_TERMINATE ? + NULL : (UHCI_TD*)((UINTN)Td->pLinkPtr & UHCI_POINTER_MASK); + } +} + +//**************************************************************************** +//**************************************************************************** +//** ** +//** (C)Copyright 1985-2016, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Pkwy, Norcross, GA 30093 ** +//** ** +//** Phone (770)-246-8600 ** +//** ** +//**************************************************************************** +//**************************************************************************** |