path: root/Core/EM/usb/rt/ohci.c

//****************************************************************************
//****************************************************************************
//**                                                                        **
//**             (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/ohci.c 98    10/16/16 10:12p Wilsonlee $
//
// $Revision: 98 $
//
// $Date: 10/16/16 10:12p $
//****************************************************************************
// Revision History
// ----------------
// $Log: /Alaska/SOURCE/Modules/USB/ALASKA/RT/ohci.c $
// 
// 98    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
// 
// 97    7/28/16 4:56a Wilsonlee
// [TAG]  		EIP264662
// [Category]  	Improvement
// [Description]  	Don't install usb hw smi after reconnecting usb
// controllers.
// [Files]  		uhcd.c, usb.c, ohci.c, amiusb.c, amiusbhc.c
// 
// 96    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
// 
// 95    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
// 
// 94    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
// 
// 93    3/02/16 9:42p 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
// 
// 92    9/01/15 10:46p Wilsonlee
// [TAG]  		EIP235977
// [Category]  	Improvement
// [Description]  	Break the loop which we check list processing TD if
// NextTd is the same as Td.
// [Files]  		ohci.c
// 
// 91    3/08/15 10:50p 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
// 
// 90    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
// 
// 89    5/01/14 3:56a Ryanchou
// [TAG]  		EIP162589
// [Category]  	Improvement
// [Description]  	Do not register external controller as key repeat
// controller.
// [Files]  		ehci.c, ohci.c, uhci.c
// 
// 88    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
// 
// 87    4/30/14 5:25a Wilsonlee
// [TAG]  		EIP164842
// [Category]  	Improvement
// [Description]  	Check if the devices have put into to our queue before
// we put them.
// [Files]  		UsbInt13.c, amiusb.c, ehci.c, ohci.c, usb.c, usbdef.h,
// usbmass.c, xhci.c, amiusbhc.c, efiusbmass.c, uhcd.c, usbbus.c, usbsb.c
// 
// 86    2/26/14 1:56a 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
// 
// 85    7/26/13 2:36a 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
// 
// 84    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
// 
// 83    6/28/13 2:29a Roberthsu
// [TAG]           EIP124581 
// [Category]      Improvement
// [Description]   Controller driver always return the length passed in
// parameter, devices may return zero length data, it should be corrected.
// [Files]         ohci.c
// 
// 82    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
// 
// 81    4/18/13 1:02p Ryanchou
// Add Teradici USB controller support.
// 
// 80    4/10/13 11:23p Ryanchou
// [TAG]  		EIP111483
// [Category]  	Improvement
// [Description]  	Increase the delay when OHCI port reset complete.
// [Files]  		ohci.c
// 
// 79    3/19/13 3:59a 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
// 
// 78    3/18/13 4:48a 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
// 
// 77    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
// 
// 76    1/11/13 4:16a Ryanchou
// [TAG]  		EIP102491
// [Category]  	Improvement
// [Description]  	Synchronized with Aptio V USB module
// [Files]  		usbport.c, usbsb.c, ehci.c, ehci.h, ohci.c, ohci.h, uhci.h,
// usb.c, usbdef.h, usbhid.c, usbhub.c, usbkbd.c, usbkbd.h, usbmass.c.
// usbms.c, usbpoint.c, xhci.h, usb.sd, amiusbhc.c, componentname.c,
// efiusbkc.c, efiusbmass.c, uhcd.c, uhcd.h, usbbus.c, usbbus.h, usbmisc.c
// 
// 75    12/24/12 5:06a Ryanchou
// [TAG]  		EIP103031
// [Category]  	Bug Fix
// [Severity]  	Normal
// [Symptom]  	System hans when loading QNX 6.5.0
// [RootCause]  	The EHCI port detect change SMI is generated after
// ownership change to OS.
// [Solution]  	Clear the SMI enable bits and status bits even the
// controller is OS owned.
// [Files]  		ehci.c, ohci.c
// 
// 74    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
// 
// 73    11/13/12 7:12a Wilsonlee
// [TAG]  		EIP82553
// [Category]  	New Feature
// [Description]  	Support usb S5 wake up function for XHCI.
// [Files]  		usb.c, ehci.c, ohci.c, xhci.c, xhci.h
// 
// 72    11/10/12 6:40a 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
// 
// 71    10/25/12 4:16a Wilsonlee
// [TAG]  		EIP82354
// [Category]  	New Feature
// [Description]  	Support usb S5 wake up function for OHCI.
// [Files]  		usb.c, ehci.c, ohci.c
// 
// 70    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
// 
// 69    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
// 
// 68    8/28/12 5:19a Ryanchou
// [TAG]  		EIP98857
// [Category]  	Improvement
// [Description]  	WriteBackDoneHead status bit shall be cleared even
// HccaDoneHead is zero.
// [Files]  		ohci.c
// 
// 67    7/25/12 4:44a Wilsonlee
// [TAG]  		EIP95959
// [Category]  	Improvement
// [Description]  	Don't set INTERRUPT_ROUTING if the ohci is external usb
// pci controller card.
// [Files]  		ohci.c
// 
// 66    5/04/12 6:38a 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
// 
// 65    5/04/12 5:25a Wilsonlee
// [TAG]  		EIP89307
// [Category]  	Improvement
// [Description]  	Modify incorrect #pragma pack directive.
// [Files]  		amidef.h, amiusb.c, ehci.h, ohci.c, ohci.h, uhci.h, usb.c,
// usbdef.h, xhci.h, efiusbmass.c, uhcd.c, uhcd.h, usbbus.c, usbbus.h,
// UsbIo.h
// 
// 64    5/03/12 6:01a 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
// 
// 63    11/08/11 1:57a 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
// 
// 62    9/26/11 11:40p 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
// 
// 61    8/24/11 2:14a Ryanchou
// [TAG]  		EIP66448
// [Category]  	New Feature
// [Description]  	Clear connect status change and port enable status
// change.
// [Files]  		ohci.c
// 
// 60    8/08/11 6:58a 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
// 
// 59    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
// 
// 58    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
// 
// 57    7/12/11 8:10a 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
// 
// 56    7/12/11 6:17a Ryanchou
// [TAG]  		EIP59707
// [Category]  	Bug Fix
// [Severity]  	Normal
// [Symptom]  	The wireless USB keyboard does not work after boot into
// windows loader.
// [RootCause]  	The amount of data returned by the device exceeded the
// size of the maximum data packet allowed, that causes babble error, and
// BIOS does not re-init the polling TD.
// [Solution]  	Re-init polling TD even the last transaction get error.
// [Files]  		ohci.c
// 
// 55    6/21/11 9:56a Ryanchou
// [TAG]  		EIP59663
// [Category]  	Bug Fix
// [Severity]  	Normal
// [Symptom]  	Plug USB WLAN device may causes OHCI malfunction.
// [RootCause]  	The devices have to connect to OHCI first, or it can't be
// configured.
// [Solution]  	Port routing route to EHCI after OHCI initialization.
// [Files]  		ehci.c, ohci.c
// 
// 54    5/03/11 10:10a 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
// 
// 53    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
// 
// 52    3/30/11 9:04a Ryanchou
// 
// 51    3/29/11 10:50p 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
// 
// 50    3/29/11 10:11a 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
// 
// 49    3/16/11 8:51a Ryanchou
// [TAG]  		EIP55025
// [Category]  	Bug Fix
// [Severity]  	Normal
// [Symptom]  	Finger Print function fail
// [RootCause]  	Wrong tranferred data size on short packet condition.
// [Files]  		ohci.c
// 
// 48    11/11/10 11:34p 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
// 
// 47    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.
// 
// 46    6/07/10 8:55a Ryanchou
// EIP38547: Fixed system halt when installing FreeBSD.
// 
// 45    3/10/10 6:35p Olegi
// 
// 44    3/06/10 1:11p Olegi
// 
// 43    2/26/10 4:23p Olegi
// 
// 42    2/23/10 1:21p Olegi
// Work around Klockwork issues. EIP34370
// 
// 41    2/08/10 10:00a Olegi
// EIP33381: Implement multiple bulk endpoint in UsbIoProtocol.
// 
// 40    1/04/10 9:20a Olegi
// EIP32956: Polling rate for the keyboards has been changed from 8 ms to
// 32 ms.
// 
// 39    12/23/09 11:59a Olegi
// 
// 38    12/08/09 3:33p Olegi
// EIP32387: Bugfix in OHCI_FreeAllStruc; memory was not released properly
// when USB_FORCE_64BIT_ALIGNMENT is set.
// 
// 37    11/24/09 12:43p Olegi
// EIP#26693: fixed OHCI_DISABLE_32MS_POLLING implementation.
// 
// 36    10/30/09 5:47p Olegi
// 
// 35    10/13/09 9:11a Olegi
// EIP28707: OHCI ownership change modifications.
// 
// 34    10/07/09 9:48a Olegi
// USB Hub error handling improvement. EIP#25601.
// 
// 33    9/15/09 10:21a Olegi
// Added USB_INCMPT_HID_DATA_OVERFLOW incompatibility type.
// 
// 32    2/17/09 4:01p Olegi
// 
// 31    2/17/09 8:59a Olegi
// Additional modifications in BulkTransfer routine to maximize the
// bandwidth.
// 
// 30    1/30/09 10:08a Olegi
// MAX_BULK_DATA_SIZE limitation moved to individual HC drivers.
// 
// 29    10/06/08 3:33p Olegi
// EHCI change ownership testing in DOS fix (EIP#14855).
// 
// 28    9/24/08 3:58p Olegi
// Bugfix in the memory allocation in OHCI_ActivatePolling.
// 
// 27    6/16/08 10:07a Olegi
// Bugfix in OHCI_Start.
// 
// 26    5/16/08 12:01p Olegi
// Compliance with AMI coding standard.
// 
// 25    7/09/07 2:11p Olegi
// Changed the maximum data size of the BulkTransfer from 1kB to 64kB.
// 
// 24    4/17/07 8:24a Olegi
// Device detection algorythm update, in sync with Core8.
// 
// 23    3/20/07 12:22p Olegi
//
// 22    1/16/07 3:24p Olegi
// Change in OHCI_ControlTransfer: return 0 if transfer stalled.
//
// 21    1/02/07 12:17p Olegi
//
// 20    1/02/07 11:13a Olegi
//
// 19    12/28/06 4:32p Olegi
// OHCI_ProcessRootHubStatusChange is modified to properly clear the
// connect change status bit
//
// 18    12/22/06 4:05p Olegi
// Timeout implementation.
//
// 17    12/20/06 2:30p Olegi
//
// 16    12/13/06 5:40p Olegi
// X64 build update
//
// 14    11/09/06 10:16a Olegi
//
// 13    10/18/06 9:43a Andriyn
// Fix: race condition on hot-plug in / plug-off
//
// 12    10/12/06 9:37p Andriyn
// Fix: unexpected plug-off hangs with endless TIMEOUTs
//
// 11    6/09/06 10:29a Olegi
// USB_FLAG_ENABLE_BEEP_MESSAGE flag is reset while handling change of the
// controller ownership.
//
// 10    5/16/06 11:22a Olegi
//
// 9     4/14/06 6:39p Olegi
// Conversion to be able to use x64 compiler.
//
// 8     3/20/06 3:37p Olegi
// Version 8.5 - x64 compatible.
//
// 7     3/06/06 6:26p Olegi
//
// 6     1/11/06 11:53a Olegi
//
// 5     12/01/05 5:48p Olegi
//
// 4     11/29/05 12:33p Andriyn
//
// 3     6/20/05 8:55a Olegi
// .NET compiler with highest warning level and warning-as-error
// modification.
//
// 2     6/03/05 6:09p Olegi
// HW SMI registration change.
//
// 1     3/28/05 6:20p Olegi
//
// 1     3/15/05 9:23a Olegi
// Initial VSS check-in.
//
//****************************************************************************

//<AMI_FHDR_START>
//-----------------------------------------------------------------------------
//
//  Name:           Ohci.c
//
//  Description:    AMI USB OHCI driver source file
//
//-----------------------------------------------------------------------------
//<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

#pragma warning (disable :4213)
#pragma warning (disable :4706)

UINT8   OHCI_FillHCDEntries(HCD_HEADER*);
UINT8   OHCI_Start (HC_STRUC*);
UINT8   OHCI_Stop (HC_STRUC*);
UINT8   OHCI_DisableInterrupts (HC_STRUC*);
UINT8   OHCI_EnableInterrupts (HC_STRUC*);
UINT8   OHCI_ProcessInterrupt(HC_STRUC*);
UINT8   OHCI_GetRootHubStatus (HC_STRUC*,UINT8, BOOLEAN);
UINT8   OHCI_DisableRootHub (HC_STRUC*,UINT8);
UINT8   OHCI_EnableRootHub (HC_STRUC*,UINT8);
UINT16  OHCI_ControlTransfer (HC_STRUC*,DEV_INFO*,UINT16,UINT16,UINT16,UINT8*,UINT16);
UINT32  OHCI_BulkTransfer (HC_STRUC*,DEV_INFO*,UINT8,UINT8*,UINT32);
UINT16  OHCI_InterruptTransfer (HC_STRUC*, DEV_INFO*, UINT8, UINT16, UINT8*, UINT16);
UINT8   OHCI_DeactivatePolling (HC_STRUC*,DEV_INFO*);
UINT8   OHCI_ActivatePolling (HC_STRUC*,DEV_INFO*);
UINT8   OHCI_DisableKeyRepeat (HC_STRUC*);
UINT8   OHCI_EnableKeyRepeat (HC_STRUC*);
UINT8   OHCI_ResetRootHub (HC_STRUC*,UINT8);
UINT8   OHCI_GlobalSuspend (HC_STRUC*);	//(EIP54018+)

UINT8   OHCI_EnumeratePorts(HC_STRUC*);
UINT8   OHCI_StartEDSchedule(HC_STRUC*);
UINT8   OhciAddPeriodicEd (HC_STRUC*, OHCI_ED*);
UINT8   OhciRemovePeriodicEd (HC_STRUC*, OHCI_ED*);
UINT8   OHCI_RepeatTDCallBack(HC_STRUC*, DEV_INFO*, UINT8*, UINT8*, UINT16);
UINT8   OHCI_ResetHC(HC_STRUC*);
UINT8   OHCI_StopUnsupportedHC(HC_STRUC*);
UINT32  OHCI_ProcessRootHubStatusChange(HC_STRUC*);
UINT8   OHCIWaitForTransferComplete(HC_STRUC*, OHCI_ED*, OHCI_TD*,DEV_INFO*);
UINT8   OHCI_ControlTDCallback(HC_STRUC*, DEV_INFO*, UINT8*, UINT8*, UINT16);
VOID    OHCI_ProcessTD(HC_STRUC*, OHCI_TD*);
UINT8   OHCI_GeneralTDCallback(HC_STRUC*, DEV_INFO*, UINT8*, UINT8*, UINT16);
UINT8   OHCI_PollingTDCallback(HC_STRUC*, DEV_INFO*, UINT8*, UINT8*, UINT16);
VOID    StopControllerType(UINT8);
UINT8   USBCheckPortChange (HC_STRUC*, UINT8, UINT8);
VOID	OHCI_FreeAllStruc(HC_STRUC* fpHCStruc);			//(EIP28707+)
BOOLEAN OhciIsHalted(HC_STRUC*);
UINT8   OhciTranslateInterval(UINT8);

UINT8	UsbGetDataToggle(DEV_INFO*,UINT8);
VOID	UsbUpdateDataToggle(DEV_INFO*, UINT8, UINT8);

extern  USB_GLOBAL_DATA     *gUsbData;
extern  BOOLEAN  gCheckUsbApiParameter;

extern  void        USB_InitFrameList (HC_STRUC*, UINT32);
extern  UINT32      ReadPCIConfig(UINT16, UINT8);
extern  void        WordWritePCIConfig(UINT16, UINT8, UINT16);
extern  void        DwordWritePCIConfig(UINT16, UINT8, UINT32);
extern  UINT32      DwordReadMem(UINT32, UINT16);
extern  void        DwordWriteMem(UINT32, UINT16, UINT32);
extern  void        DwordSetMem(UINT32, UINT16, UINT32);
extern  void        DwordResetMem(UINT32, UINT16, UINT32);
extern  void        FixedDelay(UINTN);
extern  void*       USB_MemAlloc (UINT16);
extern  UINT8       USB_InstallCallBackFunction (CALLBACK_FUNC);
extern  DEV_INFO*   USB_GetDeviceInfoStruc(UINT8, DEV_INFO*, UINT8, HC_STRUC*);
extern  UINT8       USB_MemFree(void _FAR_*, UINT16);
extern	UINT8		USB_DisconnectDevice(HC_STRUC*, UINT8, UINT8);	//(EIP28707+)
#if USB_DEV_KBD
extern  void        USBKBDPeriodicInterruptHandler(HC_STRUC*);
extern  void        USBKeyRepeat(HC_STRUC*, UINT8);
#endif

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_FillHCDEntries
//
// DESCRIPTION: This function fills the host controller driver
//              routine pointers
//
// PARAMETERS:  fpHCDHeader     Ptr to the host controller header structure
//
// RETURN:      Status: USB_SUCCESS = Success
//                      USB_ERROR = Failure
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_FillHCDEntries(HCD_HEADER *fpHCDHeader)
{
    //
    // Fill the routines here
    //
    fpHCDHeader->pfnHCDStart                = OHCI_Start;
    fpHCDHeader->pfnHCDStop                 = OHCI_Stop;
    fpHCDHeader->pfnHCDEnumeratePorts       = OHCI_EnumeratePorts;
    fpHCDHeader->pfnHCDDisableInterrupts    = OHCI_DisableInterrupts;
    fpHCDHeader->pfnHCDEnableInterrupts     = OHCI_EnableInterrupts;
    fpHCDHeader->pfnHCDProcessInterrupt     = OHCI_ProcessInterrupt;
    fpHCDHeader->pfnHCDGetRootHubStatus     = OHCI_GetRootHubStatus;
    fpHCDHeader->pfnHCDDisableRootHub       = OHCI_DisableRootHub;
    fpHCDHeader->pfnHCDEnableRootHub        = OHCI_EnableRootHub;
    fpHCDHeader->pfnHCDControlTransfer      = OHCI_ControlTransfer;
    fpHCDHeader->pfnHCDBulkTransfer         = OHCI_BulkTransfer;
    fpHCDHeader->pfnHCDInterruptTransfer    = OHCI_InterruptTransfer;
    fpHCDHeader->pfnHCDDeactivatePolling    = OHCI_DeactivatePolling;
    fpHCDHeader->pfnHCDActivatePolling      = OHCI_ActivatePolling;
    fpHCDHeader->pfnHCDDisableKeyRepeat     = OHCI_DisableKeyRepeat;
    fpHCDHeader->pfnHCDEnableKeyRepeat      = OHCI_EnableKeyRepeat;
    fpHCDHeader->pfnHCDEnableEndpoints      = USB_EnableEndpointsDummy;
    fpHCDHeader->pfnHCDInitDeviceData       = USB_InitDeviceDataDummy;
    fpHCDHeader->pfnHCDDeinitDeviceData     = USB_DeinitDeviceDataDummy;
	fpHCDHeader->pfnHCDResetRootHub         = OHCI_ResetRootHub;
	fpHCDHeader->pfnHCDClearEndpointState	= 0;	//(EIP54283+)
	fpHCDHeader->pfnHCDGlobalSuspend        = OHCI_GlobalSuspend;	//(EIP54018+)

    USB_InstallCallBackFunction(OHCI_ControlTDCallback);
    USB_InstallCallBackFunction(OHCI_GeneralTDCallback);
    USB_InstallCallBackFunction(OHCI_PollingTDCallback);
    USB_InstallCallBackFunction(OHCI_RepeatTDCallBack);

    return  USB_SUCCESS;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:     OHCI_Start
//
// DESCRIPTION: This API function is called to start a OHCI host controller.
//              The input to the routine is the pointer to the HC structure
//              that defines this host controller
//
// PARAMETERS:  fpHCStruc   Ptr to the host controller structure
//
// RETURN:      Status: USB_SUCCESS = Success
//                      USB_ERROR = Failure
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_Start (HC_STRUC*   fpHCStruc)
{
    UINT32          OhciControlReg = 0;
	UINT32			BaseAddr;
	UINT32			HcFmInterval;
    EFI_STATUS      EfiStatus = EFI_SUCCESS;

    EfiStatus = UsbHcStrucValidation(fpHCStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }

    fpHCStruc->wAsyncListSize = OHCI_FRAME_LIST_SIZE;
    fpHCStruc->dMaxBulkDataSize = MAX_OHCI_BULK_DATA_SIZE;

    //
    // Get memory base address of the HC and store it in the HCStruc
    //
    BaseAddr = ReadPCIConfig(fpHCStruc->wBusDevFuncNum, USB_MEM_BASE_ADDRESS);
    BaseAddr &= 0xFFFFFFF0;    // Mask lower bits

#if USB_RUNTIME_DRIVER_IN_SMM
    EfiStatus = AmiValidateMmioBuffer((VOID*)BaseAddr, fpHCStruc->BaseAddressSize);
    if (EFI_ERROR(EfiStatus)) {
        USB_DEBUG(3, "Usb Mmio address is invalid, it is in SMRAM\n");
        return USB_ERROR;
    }
    EfiStatus = AmiValidateMmioBuffer((VOID*)fpHCStruc->fpFrameList, 0x100);
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }
#endif

    fpHCStruc->BaseAddress = BaseAddr;

    //
    // Get the number of ports supported by the host controller (Offset 48h)
    //
    fpHCStruc->bNumPorts = (UINT8)DwordReadMem(BaseAddr, OHCI_RH_DESCRIPTOR_A);

	USB_InitFrameList (fpHCStruc, 0);

    //
    // Enable the ED schedules
    //
    if (OHCI_StartEDSchedule(fpHCStruc) == USB_ERROR) return USB_ERROR;

    //
    // First stop the host controller if it is at all active
    //
    if (OHCI_DisableInterrupts(fpHCStruc) == USB_ERROR) return USB_ERROR;

	// Save the contents of the HcFmInterval register
	HcFmInterval = DwordReadMem(BaseAddr, OHCI_FRAME_INTERVAL);
	HcFmInterval &= 0x3FFF;
	if (HcFmInterval != 0x2EDF) {
		USB_DEBUG(3, "OHCI: HcFmInterval %x\n", HcFmInterval);
	}
	HcFmInterval |= (((6 * (HcFmInterval - 210)) / 7) & 0x7FFF) << 16;

	// Issue a controller reset
	if (OHCI_ResetHC(fpHCStruc) != USB_SUCCESS) {
		return USB_ERROR;
	}
	
	// Restore the value of the HcFmInterval register
	DwordWriteMem(BaseAddr, OHCI_FRAME_INTERVAL, HcFmInterval);

    //
    // Program the frame list base address register
    //
    DwordWriteMem(BaseAddr, OHCI_HCCA_REG, (UINT32)(UINTN)fpHCStruc->fpFrameList);

    //
    // Set the periodic start time = 2A27h (10% off from HcFmInterval-2EDFh)
    //
    DwordWriteMem(BaseAddr, OHCI_PERIODIC_START, (((HcFmInterval & 0x3FFF) * 9) / 10) & 0x3FFF);

	//
	// Start the host controller for periodic list and control list.
	//
    OhciControlReg = (PERIODIC_LIST_ENABLE | CONTROL_LIST_ENABLE |
        BULK_LIST_ENABLE | USBOPERATIONAL);
#if USB_RUNTIME_DRIVER_IN_SMM
    if (!(fpHCStruc->dHCFlag & HC_STATE_EXTERNAL)) {
        OhciControlReg |= INTERRUPT_ROUTING;
    }
#endif
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_CONTROL_REG,
        OhciControlReg);

    //
    // Enable interrupts from the host controller, enable SOF, WDH, RHSC interrupts
    //
    DwordWriteMem(BaseAddr, OHCI_INTERRUPT_ENABLE,
        MASTER_INTERRUPT_ENABLE | WRITEBACK_DONEHEAD_ENABLE |
        RH_STATUS_CHANGE_ENABLE | OWNERSHIP_CHANGE_ENABLE);

	//
    // Set the HC state to running
    //
    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>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_Stop
//
// DESCRIPTION: This API function is called to stop the OHCI controller.
//              The input to the routine is the pointer to the HC structure
//              that defines this host controller.
//
// PARAMETERS:  fpHCStruc   Ptr to the host controller structure
//
// RETURN:      Status: USB_SUCCESS = Success
//                      USB_ERROR = Failure
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_Stop (HC_STRUC* fpHCStruc)
{
    UINT8 Port;
    EFI_STATUS  EfiStatus;

    EfiStatus = UsbHcStrucValidation(fpHCStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }


    if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) {
        return USB_ERROR;
    }

    for (Port = 1; Port <= fpHCStruc->bNumPorts; Port++) {
        USB_DisconnectDevice(fpHCStruc, (UINT8)(fpHCStruc->bHCNumber | BIT7), Port); 
    }

    //
    // Reset Host Controller
    //
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_CONTROL_REG, USBRESET);
    FixedDelay(gUsbData->UsbTimingPolicy.OhciHcResetDelay * 1000);   // Wait 10ms for assertion of reset

    //
    // Disable interrupts
    //
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_DISABLE, 0xffffffff);

    //
    // Disable OHCI KBC Emulation
    //
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_HCE_CONTROL, 0);

    USB_InitFrameList (fpHCStruc, 0);
	OHCI_FreeAllStruc(fpHCStruc);		//(EIP28707+)

	USBKeyRepeat(fpHCStruc, 3);

    fpHCStruc->dHCFlag &= ~HC_STATE_RUNNING;

    CheckBiosOwnedHc();

    return  USB_SUCCESS;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_RepeatTDCallBack
//
// DESCRIPTION: This function is called when TdRepeat/TD32ms 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 or update LED status.
//
// PARAMETERS:  fpHCStruc   Pointer to the HCStruc structure
//              fpDevInfo   NULL (pDevInfo is not valid)
//              fpTD        Pointer to the TD that completed
//              fpBuffer    Not used
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_RepeatTDCallBack(
    HC_STRUC	*HcStruc,
    DEV_INFO	*DevInfo,
    UINT8		*Td,
    UINT8		*Buffer,
    UINT16      DataLength
)
{
    OHCI_DESC_PTRS  *DescPtrs = HcStruc->stDescPtrs.fpOHCIDescPtrs;
    UINT8           *MemBlockEnd = gUsbData->fpMemBlockStart + (gUsbData->MemPages << 12);

    if (((UINT8*)DescPtrs < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(DescPtrs + sizeof(OHCI_DESC_PTRS)) > MemBlockEnd)) {
        return USB_ERROR;
    }

    if (((UINT8*)DescPtrs->fpTDRepeat < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(DescPtrs->fpTDRepeat + sizeof(OHCI_TD)) > MemBlockEnd)) {
        return USB_ERROR;
    }

    DescPtrs->fpTDRepeat->bActiveFlag = FALSE;

#if USB_DEV_KBD
    USBKBDPeriodicInterruptHandler(HcStruc);
#endif

    if (((UINT8*)DescPtrs->fpEDRepeat < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(DescPtrs->fpEDRepeat + sizeof(OHCI_ED)) > MemBlockEnd)) {
        return USB_ERROR;
    }

	if (!(DescPtrs->fpEDRepeat->dControl & ED_SKIP_TDQ)) {
	    //
	    // Rebind the TD to its parent ED
	    //
	    DescPtrs->fpEDRepeat->fpHeadPointer = (UINT32)(UINTN)DescPtrs->fpTDRepeat;

	    //
	    // Clear the link pointer. It may point to some other TD
	    //
	    DescPtrs->fpTDRepeat->fpLinkPointer = OHCI_TERMINATE;

	    //
	    // Reactivate the TD
	    //
	    DescPtrs->fpTDRepeat->dControlStatus = DescPtrs->fpTDRepeat->dCSReloadValue;
	    DescPtrs->fpTDRepeat->bActiveFlag = TRUE;
	}

    return USB_SUCCESS;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_DisableInterrupts
//
// DESCRIPTION: This API function is called to disable the interrupts
//              generated by the OHCI host controller. The input to the
//              routine is the pointer to the HC structure that defines this
//              host controller.  This routine will stop the HC to avoid
//              further interrupts.
//
// PARAMETERS:  fpHCStruc   Ptr to the host controller structure
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_DisableInterrupts (HC_STRUC* fpHCStruc)
{
    EFI_STATUS  EfiStatus;

    EfiStatus = UsbHcStrucValidation(fpHCStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }
    //
    // Disable interrupt generation (global) bit (Set bit31)
    //
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_DISABLE, MASTER_INTERRUPT_ENABLE);
    //
    // Disable periodic, isochronous, control and bulk list processing, reset bits 2 to 5
    //
    DwordResetMem((UINT32)fpHCStruc->BaseAddress, OHCI_CONTROL_REG, BIT2 + BIT3 + BIT4 + BIT5);

    return  USB_SUCCESS;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_EnableInterrupts
//
// DESCRIPTION: This function enables the HC interrupts
//
// PARAMETERS:  fpHCStruc   Pointer to the HCStruc structure
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_EnableInterrupts (HC_STRUC* fpHCStruc)
{
    EFI_STATUS  EfiStatus;

    EfiStatus = UsbHcStrucValidation(fpHCStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }
    //
    // Enable periodic, control and bulk list processing
    // Set bit 2, 4 & 5
    //
    DwordSetMem((UINT32)fpHCStruc->BaseAddress, OHCI_CONTROL_REG, BIT2 + BIT4 + BIT5);
    //
    // Enable interrupt generation (global) bit
    //
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_ENABLE, MASTER_INTERRUPT_ENABLE);

    return  USB_SUCCESS;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_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 call
//              back functions
//
// PARAMETERS:  fpHCStruc   Pointer to the HCStruc structure
//
// RETURN:      USB_ERROR - Interrupt not processed
//              USB_SUCCESS - Interrupt processed
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_ProcessInterrupt(HC_STRUC* fpHCStruc)
{
    OHCI_TD *fpTD, *fpTD1;
    UINT8 bIntProcessFlag = USB_ERROR;  // Set as interrupt not processed
    EFI_STATUS  EfiStatus;

    EfiStatus = UsbHcStrucValidation(fpHCStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }

    // Make sure MEMIO & Bus mastering are enabled
    if (((UINT8)ReadPCIConfig(fpHCStruc->wBusDevFuncNum, USB_REG_COMMAND) & 0x6) != 0x6) {
        return bIntProcessFlag;
    }

    if ((ReadPCIConfig(fpHCStruc->wBusDevFuncNum, USB_MEM_BASE_ADDRESS) & ~(0x7F)) != 
        (UINT32)fpHCStruc->BaseAddress) {
        return bIntProcessFlag;
    }
    //
    // Check the interrupt status register for an ownership change.  If this bit
    // is set, it means that the O/S USB device driver is attempting to takeover
    // control of the host controller. In this case the host controller is
    // shut down and the interrupt routing bit in the control register is cleared
    // (this disables SMI generation and enebles standard IRQ generation from
    // the USB host controller.
    //
    if (DwordReadMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_STATUS) & OWNERSHIP_CHANGE) {
        DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_STATUS, OWNERSHIP_CHANGE);
        if (DwordReadMem((UINT32)fpHCStruc->BaseAddress, OHCI_HCCA_REG) == (UINT32)(UINTN)fpHCStruc->fpFrameList) {
            //
            // OS tries to take the control over HC
            //
            gUsbData->dUSBStateFlag  &= (~USB_FLAG_ENABLE_BEEP_MESSAGE);

			OHCI_StopUnsupportedHC(fpHCStruc);

            OHCI_Stop(fpHCStruc);
            return USB_SUCCESS; // Set interrupt as processed
        } else {    // Ownership comes back to the driver - reinit
            gUsbData->bHandOverInProgress = FALSE;
            gUsbData->dUSBStateFlag  |= (USB_FLAG_ENABLE_BEEP_MESSAGE);
            OHCI_Start(fpHCStruc);
            return USB_SUCCESS; // Set interrupt as processed
        }
    }   // ownership change

	if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) return USB_ERROR;

	if (OhciIsHalted(fpHCStruc)) {
        // Clear All bits of the interrupt status
        DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_STATUS, 
            DwordReadMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_STATUS));
		return bIntProcessFlag;
	}
    //
    // Check whether the controller is still under BIOS control
    // Read the base address of the Periodic Frame List to the OHCI HCCA
    // register and compare with stored value
    //
    if ((DwordReadMem((UINT32)fpHCStruc->BaseAddress, OHCI_HCCA_REG) & 0xFFFFFF00) !=
            (UINT32)(UINTN)fpHCStruc->fpFrameList) {
        return bIntProcessFlag;
    }
    //
    // Check the interrupt status register for a root hub status change.  If
    // this bit is set, then a device has been attached or removed from one of
    // the ports on the root hub.
    //
    if (DwordReadMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_STATUS) & RH_STATUS_CHANGE) {
        //
        // Stop the periodic list processing to avoid more interrupts from HC
        //
        DwordResetMem((UINT32)fpHCStruc->BaseAddress, OHCI_CONTROL_REG, PERIODIC_LIST_ENABLE);
//        USB_DEBUG(3, "before OHCI_ProcessRootHubStatusChange\n");
        // Handle root hub change
        bIntProcessFlag = (UINT8)OHCI_ProcessRootHubStatusChange(fpHCStruc);
//        USB_DEBUG(3, "after OHCI_ProcessRootHubStatusChange\n");
        //
        // Re-enable the periodic list processing
        //
        DwordSetMem((UINT32)fpHCStruc->BaseAddress, OHCI_CONTROL_REG, PERIODIC_LIST_ENABLE);
    }

    //
    // Check the interrupt status register for a one or more TDs completing.
    //
    if (!(DwordReadMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_STATUS) & WRITEBACK_DONEHEAD)) {
        return USB_SUCCESS;
    }
    bIntProcessFlag = USB_SUCCESS;  // Set interrupt as processed

    //
    // The memory dword at HCCADONEHEAD has been updated to contain the head
    // pointer of the linked list of TDs that have completed.  Walk through
    // this list processing TDs as we go.
    //
    for (;;) {
        fpTD = (OHCI_TD*)(UINTN)(((OHCI_HCCA_PTRS*)fpHCStruc->fpFrameList)->dHccaDoneHead);
#if USB_RUNTIME_DRIVER_IN_SMM
        EfiStatus = AmiValidateMemoryBuffer((VOID*)fpTD, sizeof(OHCI_TD));
        if (EFI_ERROR(EfiStatus)) {
            return USB_ERROR;
        }
#endif
        ((OHCI_HCCA_PTRS*)fpHCStruc->fpFrameList)->dHccaDoneHead = 0;

        //
        // Clear the WRITEBACK_DONEHEAD bit of the interrupt status register
        // in the host controller
        //
        DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_STATUS, WRITEBACK_DONEHEAD);

        if (!fpTD) break;   // no TDs in the list

        do {
            fpTD = (OHCI_TD*)((UINTN)fpTD & 0xfffffff0);
#if USB_RUNTIME_DRIVER_IN_SMM
            EfiStatus = AmiValidateMemoryBuffer((VOID*)fpTD, sizeof(OHCI_TD));
            if (EFI_ERROR(EfiStatus)) {
                return USB_ERROR;
            }
#endif
            fpTD1 = (OHCI_TD*)fpTD->fpLinkPointer;
            OHCI_ProcessTD(fpHCStruc, fpTD);
            // Host controllers might change NextTD pointer to Td, then it causes
            // infinite loop in this routing. Break this loop if NextTd is the same as Td.
            if (fpTD == fpTD1) {
                break;
            }
            fpTD = fpTD1;
        } while (fpTD);
    }   // Check if any TDs completed while processing

    return  bIntProcessFlag;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_GetRootHubStatus
//
// DESCRIPTION: This function returns the port connect status for the
//              root hub port
//
// PARAMETERS:  pHCStruc    Pointer to HCStruc of the host controller
//              bPortNum    Port in the HC whose status is requested
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_GetRootHubStatus(
    HC_STRUC*   fpHCStruc,
    UINT8       bPortNum,
    BOOLEAN     ClearChangeBits
)
{
    UINT8 bRHStatus = USB_PORT_STAT_DEV_OWNER;
    UINT32 dPortStatus;
    UINT16 wPortReg = ((UINT16)bPortNum << 2) + (OHCI_RH_PORT1_STATUS - 4); 
    EFI_STATUS  EfiStatus;

    EfiStatus = UsbHcStrucValidation(fpHCStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }

    dPortStatus = DwordReadMem((UINT32)fpHCStruc->BaseAddress, wPortReg);
	USB_DEBUG(3, "Ohci port[%d] status: %08x\n", bPortNum, dPortStatus);

    if (dPortStatus & CURRENT_CONNECT_STATUS) {
        bRHStatus |= USB_PORT_STAT_DEV_CONNECTED;
		if (dPortStatus & PORT_ENABLE_STATUS) {
			bRHStatus |= USB_PORT_STAT_DEV_ENABLED;
		}
    }

    bRHStatus |= USB_PORT_STAT_DEV_FULLSPEED;   // Assume full speed and set the flag
    if (dPortStatus & LOW_SPEED_DEVICE_ATTACHED) {
        bRHStatus &= ~USB_PORT_STAT_DEV_FULLSPEED;  // Reset full speed
        bRHStatus |= USB_PORT_STAT_DEV_LOWSPEED;    // Set low speed flag
    }

    if (dPortStatus & CONNECT_STATUS_CHANGE) {
        if (ClearChangeBits == TRUE)
		DwordWriteMem((UINT32)fpHCStruc->BaseAddress, wPortReg, CONNECT_STATUS_CHANGE);	//(EIP66448+)
        bRHStatus |= USB_PORT_STAT_DEV_CONNECT_CHANGED; // Set connect status change flag
    }
										//(EIP66448+)>
	if (dPortStatus & PORT_ENABLE_STATUS_CHANGE) {
        if (ClearChangeBits == TRUE) {
		    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, wPortReg, PORT_ENABLE_STATUS_CHANGE);
        }
	}
										//<(EIP66448+)
    return  bRHStatus;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_DisableRootHub
//
// DESCRIPTION: This function disables the specified root hub port.
//
// PARAMETERS:  fpHCStruc   Pointer to HCStruc of the host controller
//              bPortNum    Port in the HC to be disabled.
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_DisableRootHub (HC_STRUC* fpHCStruc, UINT8 bPortNum)
{
    UINT32 dPortReg = ((UINT32)bPortNum << 2) + (OHCI_RH_PORT1_STATUS - 4);
    EFI_STATUS  EfiStatus;

    EfiStatus = UsbHcStrucValidation(fpHCStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, (UINT16)dPortReg, CLEAR_PORT_ENABLE);
    return  USB_SUCCESS;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_EnableRootHub
//
// DESCRIPTION: This function enables the specified root hub port.
//
// PARAMETERS:  fpHCStruc   Pointer to HCStruc of the host controller
//              bPortNum    Port in the HC to be enabled.
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_EnableRootHub (HC_STRUC* fpHCStruc,UINT8 bPortNum)
{
    return  USB_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_ResetRootHub
//
// DESCRIPTION: This function resets the specified root hub port.
//
// PARAMETERS:  HcStruc   Pointer to HCStruc of the host controller
//              PortNum    Port in the HC to be disabled.
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_ResetRootHub (HC_STRUC* HcStruc, UINT8 PortNum)
{
	UINT32	BaseAddr = (UINT32)HcStruc->BaseAddress;
	UINT16	PortReg = ((UINT16)PortNum << 2) + (OHCI_RH_PORT1_STATUS - 4);
	UINT32	i;
    EFI_STATUS EfiStatus;

    EfiStatus = UsbHcStrucValidation(HcStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }
	
    DwordWriteMem(BaseAddr, PortReg, SET_PORT_RESET);    // Reset the port

    // The reset signaling must be driven for a minimum of 10ms
    FixedDelay(10 * 1000);

    //
    // Wait for reset to complete
    //
    for (i = 0; i < 500; i++) {
		if (DwordReadMem(BaseAddr, PortReg) & PORT_RESET_STATUS_CHANGE) {
			break;
		}
        FixedDelay(100);       // 100 us delay
    }

	if (!(DwordReadMem(BaseAddr, PortReg) & PORT_RESET_STATUS_CHANGE)) {
		USB_DEBUG(3, "OHCI: port reset timeout, status: %08x\n", 
			DwordReadMem(BaseAddr, PortReg));
		return USB_ERROR;
	}

    //
    // Clear the reset status change status
    //
    DwordWriteMem(BaseAddr, PortReg, PORT_RESET_STATUS_CHANGE);

    // Some devices need a delay here
	FixedDelay(3 * 1000);  // 3 ms delay

    return  USB_SUCCESS;
}

										//(EIP54018+)>
//<AMI_PHDR_START>
//----------------------------------------------------------------------------
//
// Name:        OHCI_GlobalSuspend
//
// Description: 
//  This function suspend the OHCI HC.
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_GlobalSuspend(
    HC_STRUC*	HcStruc
)
{
    EFI_STATUS EfiStatus;

    EfiStatus = UsbHcStrucValidation(HcStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }

    if (!(HcStruc->dHCFlag & HC_STATE_RUNNING)) {
        return USB_ERROR;
    }

	if (OhciIsHalted(HcStruc)) {
		return USB_ERROR;
	}

    DwordWriteMem((UINT32)HcStruc->BaseAddress, OHCI_INTERRUPT_ENABLE,
                    RESUME_DETECTED_ENABLE);
    FixedDelay(40 * 1000);
    DwordWriteMem((UINT32)HcStruc->BaseAddress, OHCI_CONTROL_REG,
                    USBSUSPEND | REMOTE_WAKEUP_ENABLE);
    FixedDelay(20 * 1000);

    HcStruc->dHCFlag &= ~(HC_STATE_RUNNING);
    HcStruc->dHCFlag |= HC_STATE_SUSPEND;

    return  USB_SUCCESS;
}
										//<(EIP54018+)

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_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.)
//
// PARAMETERS:  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
//
//
// RETURN:  Number of bytes transferred
//
//
// NOTES:   Do not use USB_SUCCESS or USB_ERROR as returned values
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT16
OHCI_ControlTransfer (
    HC_STRUC*   fpHCStruc,
    DEV_INFO*   fpDevInfo,
    UINT16      wRequest,
    UINT16      wIndex,
    UINT16      wValue,
    UINT8       *fpBuffer,
    UINT16      wLength)
{
    UINT16  *fpData;
    OHCI_DESC_PTRS *fpDescPtrs = fpHCStruc->stDescPtrs.fpOHCIDescPtrs;
    OHCI_ED *fpED;
    OHCI_TD *fpTD;
    UINT32 dData;
    UINT16 wData;
	UINT8 CompletionCode;
    UINT32 TransferLength;
    UINT8   *MemBlockEnd = gUsbData->fpMemBlockStart + (gUsbData->MemPages << 12);
    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, "Ohci ControlTransfer Invalid Pointer, Buffer is in SMRAM.\n");
                return 0;
            }
        }
        gCheckUsbApiParameter = FALSE;
    }
#endif

    if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) {
        return 0;
    }

	if (OhciIsHalted(fpHCStruc)) {
		return 0;
	}
    //FixedDelay(5 * 1000);    // 5 ms delay is necessary for OHCI host controllers

    if( !VALID_DEVINFO( fpDevInfo) )
        return 0;
    if (((UINT8*)fpDescPtrs < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(fpDescPtrs + sizeof(OHCI_DESC_PTRS)) > MemBlockEnd)) {
        return 0;
    }
    if (((UINT8*)fpDescPtrs->fpEDControl < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(fpDescPtrs->fpEDControl + sizeof(OHCI_ED)) > MemBlockEnd)) {
        return 0;
    }
    if (((UINT8*)fpDescPtrs->fpTDControlSetup < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(fpDescPtrs->fpTDControlSetup + sizeof(OHCI_TD)) > MemBlockEnd)) {
        return 0;
    }
    if (((UINT8*)fpDescPtrs->fpTDControlData < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(fpDescPtrs->fpTDControlData + sizeof(OHCI_TD)) > MemBlockEnd)) {
        return 0;
    }
    if (((UINT8*)fpDescPtrs->fpTDControlStatus < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(fpDescPtrs->fpTDControlStatus + sizeof(OHCI_TD)) > MemBlockEnd)) {
        return 0;
    }
	gUsbData->dLastCommandStatusExtended = 0;

    //
    // Build the device request in the data area of the control setup qTD
    //
    fpData = (UINT16*)fpDescPtrs->fpTDControlSetup->aSetupData;
    *fpData++ = wRequest;
    *fpData++ = wValue;
    *fpData++ = wIndex;
    *fpData++ = wLength;
    *(UINTN*)fpData = (UINTN)fpBuffer;
    //
    // Prepare some registers that will be used in building the TDs below.
    // wLength  contains the data length.
    // fpBuffer contains the absolute address of the data buffer.
    // wRequest contains the request type (bit 7 = 0/1 for Out/In).
    // fpDevInfo will contain a pointer to the DeviceInfo structure for the given device.
    //
    // Ready the EDControl for the control transfer.
    //
    fpED = fpDescPtrs->fpEDControl;
    //
    // The ED control field will be set so
    //   Function address & Endpoint number = ESI,
    //   Direction = From TD,
    //   Speed = DeviceInfo.bEndpointSpeed,
    //   Skip = 1, Format = 0,
    //   Max packet size  = DeviceInfo.wEndp0MaxPacket
    // The HeadPointer field will be set to TDControlSetup
    // The TailPointer field will be set to OHCI_TERMINATE
    // The LinkPointer field will be set to OHCI_TERMINATE
    //
    dData = (UINT32)fpDevInfo->wEndp0MaxPacket;
    if (dData > 0x40) dData = 0x40; // Force the max packet size to 64 bytes
    dData <<= 16;                   // dData[26:16] = device's packet size
    wData = (UINT16)fpDevInfo->bEndpointSpeed;  // 00/01/10 for HI/LO/FULL
    wData = (wData & 1) << 13;      // wData[13] = full/low speed flag
    wData |= fpDevInfo->bDeviceAddress | ED_SKIP_TDQ;
    fpED->dControl = dData | wData;
    fpED->fpTailPointer = 0;
    fpED->fpEDLinkPointer = 0;

    fpTD = fpDescPtrs->fpTDControlSetup;
    //
    // The ControlStatus field will be set so
    //   Buffer Rounding = 1,
    //   Direction PID = GTD_SETUP_PACKET,
    //   Delay Interrupt = GTD_IntD,
    //   Data Toggle = GTD_SETUP_TOGGLE,
    //   Error Count = GTD_NO_ERRORS,
    //   Condition Code = GTD_NOT_ACCESSED
    // The CurrentBufferPointer field will point to the TD's SetupData buffer
    //   which was before initialized to contain a DeviceRequest struc.
    // The BufferEnd field will point to the last byte of the TD's SetupData
    //   buffer.
    // The LinkPointer field will point to the TDControlData if data will
    //   be sent/received or to the TDControlStatus if no data is expected.
    // The CSReloadValue field will contain 0 because this is a "one shot" packet.
    // The pCallback will be set to point to the OHCI_ControlTDCallback routine.
    // The ActiveFlag field will be set to TRUE.
    // The DeviceAddress field does not need to be set since the Control TDs do
    //   not need rebinding to the EDControl.
    //
    fpTD->dControlStatus = (UINT32)(GTD_BUFFER_ROUNDING | GTD_SETUP_PACKET | GTD_SETUP_TOGGLE |
                GTD_NO_ERRORS | (GTD_NOT_ACCESSED << 28));

    fpTD->fpCurrentBufferPointer = (UINT32)(UINTN)fpTD->aSetupData;
    fpTD->fpBufferEnd = (UINT32)(UINTN)fpTD->aSetupData + 7; // size of aSetupData - 1

    wData = wLength ;                   //(EIP67230)

    if (wLength) {  // some data to transfer
        fpTD = fpDescPtrs->fpTDControlData;     // Fill in various fields in the TDControlData.
        //
        // The ControlStatus field will be set so
        //   Buffer Rounding = 1,
        //   Direction PID = GTD_OUT_PACKET/GTD_IN_PACKET,
        //   Delay Interrupt = GTD_IntD,
        //   Data Toggle = GTD_DATA1_TOGGLE,
        //   Error Count = GTD_NO_ERRORS,
        //   Condition Code = GTD_NOT_ACCESSED
        // The CurrentBufferPointer field will point to the caller's buffer
        //   which is now in EBP.
        // The BufferEnd field will point to the last byte of the caller's buffer.
        // The LinkPointer field will point to the TDControlStatus.
        // The CSReloadValue field will contain 0 because this is a "one shot" packet.
        // The pCallback will be set to point to the OHCI_ControlTDCallback routine.
        // The ActiveFlag field will be set to TRUE.
        // The DeviceAddress field does not need to be set since the Control TDs do
        //   not need rebinding to the EDControl.
        // The CSReloadValue field will contain 0 because this is a "one shot" packet.
        // The pCallback will be set to point to the OHCI_ControlTDCallback routine.
        // The ActiveFlag field will be set to TRUE.    return  USB_SUCCESS;
        // The DeviceAddress field does not need to be set since the Control TDs do}
        //   not need rebinding to the EDControl.
        //
        dData = (UINT32)(GTD_BUFFER_ROUNDING | GTD_DATA1_TOGGLE | GTD_NO_ERRORS | (GTD_NOT_ACCESSED << 28));
        dData = (wRequest & BIT7)? (dData | GTD_IN_PACKET | GTD_IntD) : (dData | GTD_OUT_PACKET);
        fpTD->dControlStatus = dData;
        fpTD->fpCurrentBufferPointer = (UINT32)(UINTN)fpBuffer;
        fpTD->fpBufferEnd = (UINT32)((UINTN)fpBuffer + wData - 1);
    }
    fpTD = fpDescPtrs->fpTDControlStatus;   // Fill in various fields in the TDControlStatus.
    //
    // The ControlStaus field will be set so
    //   Buffer Rounding = 1,
    //   Direction PID = GTD_OUT_PACKET/GTD_IN_PACKET,
    //   Delay Interrupt = GTD_IntD,
    //   Data Toggle = GTD_DATA1_TOGGLE,
    //   Error Count = GTD_NO_ERRORS,
    //   Condition Code = GTD_NOT_ACCESSED
    // The CurrentBufferPointer field will point to NULL
    // The BufferEnd field will point to NULL.
    // The LinkPointer field will point to OHCI_TERMINATE.
    // The CSReloadValue field will contain 0 because this is a "one shot" packet.
    // The pCallback will be set to point to the OHCI_ControlTdCallback routine.
    // The ActiveFlag field will be set to TRUE.
    // The DeviceAddress field does not need to be set since the Control TDs do
    //   not need rebinding to the EdControl.
    //
    // Note: For OUT control transfer status should be IN and
    //       for IN cotrol transfer, status should be OUT.
    //
    dData = (UINT32)(GTD_BUFFER_ROUNDING | GTD_DATA1_TOGGLE | GTD_NO_ERRORS | (GTD_NOT_ACCESSED << 28));
    dData = (wRequest & BIT7)? (dData | GTD_OUT_PACKET) : (dData | GTD_IN_PACKET | GTD_IntD);
    fpTD->dControlStatus = dData;
    fpTD->fpCurrentBufferPointer = 0;
    fpTD->fpBufferEnd = 0;
    fpTD->fpLinkPointer = 0;
    //
    // Link all the pointers together
    //
    fpTD = fpDescPtrs->fpTDControlSetup;
    fpED->fpHeadPointer = (UINT32)(UINTN)fpTD;
    if (wLength) {  // chain in data TD
        fpTD->fpLinkPointer = (UINT32)(UINTN)fpDescPtrs->fpTDControlData;
        fpTD = fpDescPtrs->fpTDControlData;
    }
    fpTD->fpLinkPointer = (UINT32)(UINTN)fpDescPtrs->fpTDControlStatus;

    fpDescPtrs->fpTDControlStatus->fpLinkPointer = 0;

    fpTD = fpDescPtrs->fpTDControlSetup;
    do {
        fpTD->dCSReloadValue = 0;
        fpTD->bCallBackIndex = USB_InstallCallBackFunction(OHCI_ControlTDCallback);
        fpTD->bActiveFlag = TRUE;
        fpTD = (OHCI_TD*)fpTD->fpLinkPointer;
    } while (fpTD);
    //
    // Now control queue is complete, so set ED_SKIP_TDQ=0
    //
    fpED->dControl &= ~ED_SKIP_TDQ;
    //
    // Set the HcControlHeadED register to point to the EDControl.
    //
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_CONTROL_HEAD_ED, (UINT32)(UINTN)fpED);
    //
    // Now put the control setup, data and status into the HC's schedule by
    // setting the ControllListFilled field of HcCommandStatus reg.
    // This will cause the HC to execute the transaction in the next active frame.
    //
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_COMMAND_STATUS, CONTROL_LIST_FILLED);
    //
    // Now wait for the control status TD to complete.  When it has completed,
    // the OHCI_ControlTDCallback will set its active flag to FALSE.
    //
    OHCIWaitForTransferComplete(fpHCStruc, fpED, fpDescPtrs->fpTDControlStatus,fpDevInfo);
    //
    // Stop the HC from processing the EDControl by setting its Skip bit.
    //
    fpED->dControl |= ED_SKIP_TDQ;

    //
    // Finally check for any error bits set in both the TDControlStatus.
    // If the TD did not complete successfully, return STC.
    //
    CompletionCode = (UINT8)(fpDescPtrs->fpTDControlStatus->dControlStatus >> 28);    // dData[3:0] = Completion status
    gUsbData->bLastCommandStatus &= ~USB_CONTROL_STALLED;

    fpTD = fpDescPtrs->fpTDControlData;
    TransferLength = wLength ; 
    if(fpTD->fpCurrentBufferPointer != 0){
        TransferLength = fpTD->fpCurrentBufferPointer - (UINT32)(UINTN)fpBuffer;
    }


	wData = 0;
	switch (CompletionCode) {
        case GTD_NO_ERROR:
            wData = TransferLength;
			break;
		case GTD_STALL:
			gUsbData->bLastCommandStatus |= USB_CONTROL_STALLED;
			gUsbData->dLastCommandStatusExtended |= USB_TRSFR_STALLED;
			break;
		case GTD_NOT_ACCESSED:
			gUsbData->dLastCommandStatusExtended |= USB_TRNSFR_TIMEOUT;
			break;
		default:
			break;
	}

    return wData;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_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.)
//              Size of data can be upto 64K
//
// PARAMETERS:  pHCStruc    Pointer to HCStruc of the host controller
//              pDevInfo    DeviceInfo structure (if available else 0)
//              bXferDir    Transfer direction
//                  Bit 7: Data direction
//                          0 Host sending data to device
//                          1 Device sending data to host
//                  Bit 6-0 : Reserved
//              fpBuffer    Buffer containing data to be sent to the
//                          device or buffer to be used to receive data
//                          value in Segment:Offset format
//              dwLength    dwLength request parameter, number of bytes
//                          of data to be transferred in or out
//                          of the host controller
//
// RETURN:      Amount of data transferred
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT32
OHCI_BulkTransfer (
    HC_STRUC    *fpHCStruc,
    DEV_INFO    *fpDevInfo,
    UINT8       bXferDir,
    UINT8       *fpBuffer,
    UINT32      dwLength)
{
    UINT32      dData;
    UINT8   bData;
    OHCI_DESC_PTRS *fpDescPtrs;
    UINT16      wMaxPkt;
    UINT8       bEndp;
    UINT8       bDatToggle;
    UINT32      dBytesToTransfer, dBytesRemaining;
    UINT32      dBytesTransferred;
    UINT32      Buffer;
    UINT8       *MemBlockEnd = gUsbData->fpMemBlockStart + (gUsbData->MemPages << 12);
    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, dwLength);
        if (EFI_ERROR(EfiStatus)) {
            USB_DEBUG(3, "Ohci BulkTransfer Invalid Pointer, Buffer is in SMRAM.\n");
            return 0;
        }
        gCheckUsbApiParameter = FALSE;
    }
#endif

    if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) {
        return 0;
    }

	if (OhciIsHalted(fpHCStruc)) {
		return 0;
	}
    
    if( !VALID_DEVINFO( fpDevInfo) )
        return 0;

	gUsbData->dLastCommandStatusExtended = 0;

    fpDescPtrs = fpHCStruc->stDescPtrs.fpOHCIDescPtrs;

    if (((UINT8*)fpDescPtrs < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(fpDescPtrs + sizeof(OHCI_DESC_PTRS)) > MemBlockEnd)) {
        return 0;
    }

    if (((UINT8*)fpDescPtrs->fpEDBulk < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(fpDescPtrs->fpEDBulk + sizeof(OHCI_ED)) > MemBlockEnd)) {
        return 0;
    } 

    if (((UINT8*)fpDescPtrs->fpTDBulkData < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(fpDescPtrs->fpTDBulkData + sizeof(OHCI_TD)) > MemBlockEnd)) {
        return 0;
    } 
    
    wMaxPkt = (bXferDir & 0x80)? fpDevInfo->wBulkInMaxPkt : fpDevInfo->wBulkOutMaxPkt;
    bEndp = (bXferDir & 0x80)? fpDevInfo->bBulkInEndpoint : fpDevInfo->bBulkOutEndpoint;
	bDatToggle = UsbGetDataToggle(fpDevInfo, bEndp | bXferDir);

    if( wMaxPkt == 0){
        return 0;
    }

    dBytesRemaining = dwLength;
    dBytesTransferred = 0;
    dBytesToTransfer = 0;

    for (;dBytesRemaining != 0; dBytesRemaining -= dBytesToTransfer) {
        dBytesToTransfer = 
             (dBytesRemaining < FULLSPEED_MAX_BULK_DATA_SIZE_PER_FRAME)?
                    dBytesRemaining : FULLSPEED_MAX_BULK_DATA_SIZE_PER_FRAME;

        Buffer = (UINT32)(UINTN)fpBuffer + dBytesTransferred;

        //
        //  Set the SKIP bit in the EdBulk to avoid accidental scheduling
        //
        fpDescPtrs->fpEDBulk->dControl = ED_SKIP_TDQ;
        //
        // Set the ED's head pointer field to bulk data TD and tail pointer field to
        // OHCI_TERMINATE. Also set ED's link pointer to OHCI_TERMINATE.
        //
        fpDescPtrs->fpEDBulk->fpHeadPointer = (UINT32)(UINTN)fpDescPtrs->fpTDBulkData;
        fpDescPtrs->fpEDBulk->fpTailPointer = OHCI_TERMINATE;
        fpDescPtrs->fpEDBulk->fpEDLinkPointer = OHCI_TERMINATE;
        //
        // Form the data needed for ED's control field with the available information
        //
        dData = (bXferDir & 0x80)? ED_IN_PACKET : ED_OUT_PACKET;
        dData |= fpDevInfo->bDeviceAddress;
        dData |= (UINT16)bEndp << 7;
        dData |= (UINT32)wMaxPkt << 16;
        //
        // Update the ED's control field with the data formed
        // ASSUME ALL MASS DEVICES ARE FULL SPEED DEVICES.
        //
        fpDescPtrs->fpEDBulk->dControl = dData;
        //
        // Fill the general bulk data TD with relevant information.  Set the
        //  TD's control field with buffer rounding set to 1, direction PID to
        //  don't care, delay interrupt to INTD, data toggle to the latest data
        //  toggle value, error count to no errors and condition code to not accessed.
        //
        // Set the data toggle to DATA0 (SETUP_TOGGLE)
        fpDescPtrs->fpTDBulkData->dControlStatus = (UINT32)(GTD_BUFFER_ROUNDING | GTD_IN_PACKET |
            GTD_IntD | GTD_SETUP_TOGGLE | GTD_NO_ERRORS | (GTD_NOT_ACCESSED << 28));
        fpDescPtrs->fpTDBulkData->dControlStatus |= (UINT32)bDatToggle << 24;
        //
        // GTD current buffer pointer field will point to the caller's buffer which
        // now in the variable fpBuffer
        //
        fpDescPtrs->fpTDBulkData->fpCurrentBufferPointer = Buffer;
        fpDescPtrs->fpTDBulkData->fpBufferEnd = Buffer + dBytesToTransfer - 1;
        fpDescPtrs->fpTDBulkData->fpLinkPointer = OHCI_TERMINATE;
        //
        // GTD's CSReloadValue field will contain 0 because this is a "one shot" packet
        //
        fpDescPtrs->fpTDBulkData->dCSReloadValue = 0;
        fpDescPtrs->fpTDBulkData->bCallBackIndex = USB_InstallCallBackFunction(OHCI_GeneralTDCallback);
        fpDescPtrs->fpTDBulkData->bActiveFlag = TRUE;
    
        fpDescPtrs->fpEDBulk->dControl &= ~ED_SKIP_TDQ;
        //
        // Set the HCBulkHeadED register to point to the bulk ED
        //
        DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_BULK_HEAD_ED, (UINT32)(UINTN)fpDescPtrs->fpEDBulk);
        //
        // Clear bulk stall/time out condition flag
        //
        gUsbData->bLastCommandStatus &= ~(USB_BULK_STALLED + USB_BULK_TIMEDOUT);
        //
        // Enable the bulk list processing
        //
        DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_COMMAND_STATUS, BULK_LIST_FILLED);
    
        OHCIWaitForTransferComplete(fpHCStruc, fpDescPtrs->fpEDBulk, fpDescPtrs->fpTDBulkData,fpDevInfo);
        //
        // Stop the HC from processing the EDBulk by setting its Skip bit.
        //
        fpDescPtrs->fpEDBulk->dControl |= ED_SKIP_TDQ;
        //
        // Update the data toggle value into the mass info structure
        //
		UsbUpdateDataToggle(fpDevInfo, bEndp | bXferDir, 
			(UINT8)(((fpDescPtrs->fpTDBulkData->dControlStatus & GTD_DATA_TOGGLE) >> 24) & 1));
        //
        // Check for the error conditions - if possible recover from them
        //
        bData = (UINT8)(fpDescPtrs->fpTDBulkData->dControlStatus >> 28);
		switch (bData) {
			case GTD_STALL:
				gUsbData->bLastCommandStatus |= USB_BULK_STALLED;
				gUsbData->dLastCommandStatusExtended |= USB_TRSFR_STALLED;
				break;
			case GTD_NOT_ACCESSED:
				gUsbData->bLastCommandStatus |= USB_BULK_TIMEDOUT;
				gUsbData->dLastCommandStatusExtended |= USB_TRNSFR_TIMEOUT;
				break;
			default:
				break;
		}

		if (bData != GTD_NO_ERROR) {
			break;
		}

        //
        // Get the size of data transferred
        //
        dData = fpDescPtrs->fpTDBulkData->fpCurrentBufferPointer;
        if (dData != 0)
        {
            //
            // Device sent less data than requested, calculate the
            // transferred size and exit
            //
            //dBytesTransferred += (UINT32)(UINTN)fpDescPtrs->fpTDBulkData->fpBufferEnd - dData; //(EIP55025-)
     	    dBytesTransferred += dData - Buffer;   //Short Packet (OHCI Spec 4.3.1.3.5  Transfer Completion, Pg.23) //<(EIP55025)+    
            break;
        }

        //
        // CurrentBufferPointer equals 0. This indicates the successfull TD completion,
        // all data is transferred. Adjust the total amount and continue.
        //
        dBytesTransferred += dBytesToTransfer;
    }

    return  dBytesTransferred;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_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.)
//
// PARAMETERS:  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 in
//
// RETURN:      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
OHCI_InterruptTransfer (
    HC_STRUC    *fpHCStruc,
    DEV_INFO    *fpDevInfo,
    UINT8       EndpointAddress,
    UINT16      MaxPktSize,
    UINT8       *fpBuffer,
    UINT16      wLength)
{
    UINT8 bEndp, bDatToggle;
    UINT32 dData;
    OHCI_ED	*IntEd;
	OHCI_TD	*IntTd;
	UINT8	CompletionCode;
	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, "Ohci InterruptTransfer Invalid Pointer, Buffer is in SMRAM.\n");
            return 0;
        }
        gCheckUsbApiParameter = FALSE;
    }
#endif

    if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) {
        return 0;
    }
	
	if (OhciIsHalted(fpHCStruc)) {
		return 0;
	}

    if(!VALID_DEVINFO( fpDevInfo)) {
        return 0;
    }

	gUsbData->dLastCommandStatusExtended = 0;

	IntEd = USB_MemAlloc(GET_MEM_BLK_COUNT(sizeof(OHCI_ED) + sizeof(OHCI_TD)));

	if (IntEd == NULL) {
		return 0;
	}

	IntTd = (OHCI_TD*)((UINTN)IntEd + sizeof(OHCI_ED));

    //
    // Set the SKIP bit to avoid accidental scheduling
    //
    IntEd->dControl = ED_SKIP_TDQ;
    //
    // Set the ED's head pointer field to interrupt data TD and tail pointer
    // field to OHCI_TERMINATE. Also set ED's link pointer to OHCI_TERMINATE.
    //
    IntEd->fpHeadPointer = (UINT32)(UINTN)IntTd;
    IntEd->fpTailPointer = OHCI_TERMINATE;
    IntEd->fpEDLinkPointer = OHCI_TERMINATE;
    IntEd->Interval = OhciTranslateInterval(fpDevInfo->bPollInterval);

    //
    // Get maximum packet size from device info structure
    //
    bEndp = EndpointAddress & 0xF;
	bDatToggle = UsbGetDataToggle(fpDevInfo, EndpointAddress);
	
    //
    // Form the data needed for ED's control field with the available information
    //
    dData = (EndpointAddress & BIT7)? ED_IN_PACKET : ED_OUT_PACKET;
    dData |= fpDevInfo->bDeviceAddress | ((UINT16)bEndp << 7);
    dData |= ((UINT32)MaxPktSize << 16);
	dData |= (UINT32)(fpDevInfo->bEndpointSpeed & 1) << 13;
    //
    // Update the ED's control field with the data formed
    // ASSUME ALL MASS DEVICES ARE FULL SPEED DEVICES.
    //
    IntEd->dControl = dData;
    //
    // Fill the general interrupt data TD with relevant information.  Set the
    //  TD's control field with buffer rounding set to 1, direction PID to
    //  don't care, delay interrupt to INTD, data toggle to the latest data
    //  toggle value, error count to no errors and condition code to not accessed.
    //
    // Set the data toggle to DATA0 (SETUP_TOGGLE)
    //
    dData = (UINT32)(GTD_BUFFER_ROUNDING | GTD_IN_PACKET  | GTD_IntD | GTD_SETUP_TOGGLE |
        GTD_NO_ERRORS | (GTD_NOT_ACCESSED << 28));
    IntTd->dControlStatus = dData;
    //
    // Set the data toggle depending on the bDatToggle value
    //
    IntTd->dControlStatus |= ((UINT32)bDatToggle << 24);
    //
    // GTD current buffer pointer field will point to the caller's buffer
    //
    IntTd->fpCurrentBufferPointer = (UINT32)(UINTN)fpBuffer;
    //
    // GTD's buffer end field will point to the last byte of the caller's buffer
    //
    IntTd->fpBufferEnd = (UINT32)(UINTN)(fpBuffer + wLength - 1);
    //
    // GTD's link pointer field will be set to OHCI_TERMINATE
    //
    IntTd->fpLinkPointer = OHCI_TERMINATE;
    //
    // GTD's CSReloadValue field will contain 0 because this is a "one shot" packet
    //
    IntTd->dCSReloadValue = 0;
    //
    // GTD's pCallback will point to the OHCI_GeneralTDCallback routine
    //
    IntTd->bCallBackIndex = USB_InstallCallBackFunction(OHCI_GeneralTDCallback);
    //
    // GTD's ActiveFlag field will be set to TRUE.
    //
	OhciAddPeriodicEd(fpHCStruc, IntEd);

	IntTd->bActiveFlag = TRUE;
    IntEd->dControl &= ~ED_SKIP_TDQ;

    //
    // Now wait for the interrupt data TD to complete.
    //
    OHCIWaitForTransferComplete(fpHCStruc, IntEd, IntTd, fpDevInfo);
    //
    // Stop the HC from processing the EDInterrupt by setting its Skip bit.
    //
    OhciRemovePeriodicEd(fpHCStruc, IntEd);
    //
    // Get appropriate data sync shift value
    //
    bDatToggle = (UINT8)((IntTd->dControlStatus & GTD_DATA_TOGGLE) >> 24) & 1;
	UsbUpdateDataToggle(fpDevInfo, EndpointAddress, bDatToggle);
	
    //
    // Check for the error conditions - if possible recover from them
    //
	CompletionCode = (UINT8)(IntTd->dControlStatus >> 28);
	switch (CompletionCode) {
		case GTD_STALL:
			gUsbData->dLastCommandStatusExtended |= USB_TRSFR_STALLED;
			break;
		case GTD_NOT_ACCESSED:
			gUsbData->dLastCommandStatusExtended |= USB_TRNSFR_TIMEOUT;
			break;
		default:
			break;
	}

	BytesTransferred = IntTd->fpCurrentBufferPointer == 0 ? wLength :
		IntTd->fpCurrentBufferPointer - (UINT32)fpBuffer;

	USB_MemFree(IntEd, GET_MEM_BLK_COUNT(sizeof(OHCI_ED) + sizeof(OHCI_TD)));

    return (UINT16)BytesTransferred;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_ActivatePolling
//
// DESCRIPTION: This function activates the polling TD for the requested
//              device. The device may be a USB keyboard or USB hub
//
// PARAMETERS:  fpHCStruc   Pointer to the HC structure
//              fpDevInfo   Pointer to the device information structure
//
// RETURN:      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
OHCI_ActivatePolling (
    HC_STRUC* fpHCStruc,
    DEV_INFO* fpDevInfo)
{
    UINT32 dData;
    UINT8   *fpPtr;
	UINT8	bDatToggle;

    EFI_STATUS EfiStatus;

    EfiStatus = UsbHcStrucValidation(fpHCStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }

    EfiStatus = UsbDevInfoValidation(fpDevInfo);

    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }

    if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) {
        return USB_ERROR;
    }

	if (OhciIsHalted(fpHCStruc)) {
		return USB_ERROR;
	}
    
    if (!VALID_DEVINFO(fpDevInfo)) {
        return USB_ERROR;
    }

	bDatToggle = UsbGetDataToggle(fpDevInfo, fpDevInfo->IntInEndpoint);

    fpPtr = USB_MemAlloc(1);
    ASSERT(fpPtr);
    fpDevInfo->fpPollEDPtr  = fpPtr;
    fpPtr = USB_MemAlloc(1);
    ASSERT(fpPtr);
    fpDevInfo->fpPollTDPtr  = fpPtr;

    dData = (fpDevInfo->IntInEndpoint & BIT7)? ED_IN_PACKET : ED_OUT_PACKET;
    dData |= (UINT32)fpDevInfo->bDeviceAddress | ((fpDevInfo->IntInEndpoint & 0xF) << 7);
    dData |= ((UINT32)fpDevInfo->IntInMaxPkt << 16);
	dData |= (UINT32)(fpDevInfo->bEndpointSpeed & 1) << 13;
	dData |= ED_SKIP_TDQ;

    ((OHCI_ED*)fpDevInfo->fpPollEDPtr)->dControl = dData;
    ((OHCI_ED*)fpDevInfo->fpPollEDPtr)->fpHeadPointer = (UINT32)(UINTN)fpDevInfo->fpPollTDPtr;
	((OHCI_ED*)fpDevInfo->fpPollEDPtr)->fpHeadPointer |= bDatToggle << 1;
    ((OHCI_ED*)fpDevInfo->fpPollEDPtr)->fpEDLinkPointer = OHCI_TERMINATE;
    ((OHCI_ED*)fpDevInfo->fpPollEDPtr)->fpTailPointer = OHCI_TERMINATE;
    ((OHCI_ED*)fpDevInfo->fpPollEDPtr)->Interval = OhciTranslateInterval(fpDevInfo->bPollInterval);

	fpDevInfo->fpPollDataBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT(fpDevInfo->PollingLength));  
	ASSERT(fpDevInfo->fpPollDataBuffer);

    ((OHCI_TD*)fpDevInfo->fpPollTDPtr)->dControlStatus = (UINT32)(GTD_BUFFER_ROUNDING | GTD_IN_PACKET | GTD_IntD |
                GTD_NO_ERRORS | (GTD_NOT_ACCESSED << 28));
    ((OHCI_TD*)fpDevInfo->fpPollTDPtr)->dCSReloadValue = (UINT32)(GTD_BUFFER_ROUNDING | GTD_IN_PACKET | GTD_IntD |
                GTD_NO_ERRORS | (GTD_NOT_ACCESSED << 28));
    ((OHCI_TD*)fpDevInfo->fpPollTDPtr)->fpCurrentBufferPointer =
    			(UINT32)(fpDevInfo->fpPollDataBuffer); 					//(EIP54782)
    ((OHCI_TD*)fpDevInfo->fpPollTDPtr)->fpBufferEnd =
    			(UINT32)(fpDevInfo->fpPollDataBuffer + fpDevInfo->PollingLength - 1);
    ((OHCI_TD*)fpDevInfo->fpPollTDPtr)->fpLinkPointer = OHCI_TERMINATE;
    ((OHCI_TD*)fpDevInfo->fpPollTDPtr)->bCallBackIndex = USB_InstallCallBackFunction(OHCI_PollingTDCallback);

    OhciAddPeriodicEd(fpHCStruc, (OHCI_ED*)fpDevInfo->fpPollEDPtr);

    ((OHCI_TD*)fpDevInfo->fpPollTDPtr)->bActiveFlag = TRUE;
    ((OHCI_ED*)fpDevInfo->fpPollEDPtr)->dControl &= ~ED_SKIP_TDQ;
    return  USB_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_DeactivatePolling
//
// DESCRIPTION: This function de-activates the polling TD for the requested
//              device. The device may be a USB keyboard or USB hub
//
// PARAMETERS:  fpHCStruc   Pointer to the HC structure
//              fpDevInfo   Pointer to the device information structure
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_DeactivatePolling (
    HC_STRUC* fpHCStruc,
    DEV_INFO* fpDevInfo)
{
    OHCI_ED *fpOHCIED = (OHCI_ED*)fpDevInfo->fpPollEDPtr;
    OHCI_TD *fpOHCITD = (OHCI_TD*)fpDevInfo->fpPollTDPtr;

    EFI_STATUS  EfiStatus;
    
    EfiStatus = UsbHcStrucValidation(fpHCStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }

    EfiStatus = UsbDevInfoValidation(fpDevInfo);

    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }

    if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) {
        return USB_ERROR;
    }

	if (OhciIsHalted(fpHCStruc)) {
		return USB_ERROR;
	}
	
    if(!fpOHCIED) {
        return USB_SUCCESS;
    }

    fpOHCITD->dControlStatus = 0;
    fpOHCITD->dCSReloadValue = 0;
    fpOHCITD->bActiveFlag    = FALSE;

    OhciRemovePeriodicEd(fpHCStruc, fpOHCIED);

	UsbUpdateDataToggle(fpDevInfo, fpDevInfo->IntInEndpoint, 
			(UINT8)((fpOHCIED->fpHeadPointer & ED_TOGGLE_CARRY) >> 1));

    USB_MemFree(fpOHCITD, GET_MEM_BLK_COUNT_STRUC(OHCI_TD));
    fpDevInfo->fpPollTDPtr = NULL;

    USB_MemFree(fpOHCIED, GET_MEM_BLK_COUNT_STRUC(OHCI_ED));
    fpDevInfo->fpPollEDPtr = NULL;

	if(fpDevInfo->fpPollDataBuffer) {
		USB_MemFree(fpDevInfo->fpPollDataBuffer, 
			GET_MEM_BLK_COUNT(fpDevInfo->PollingLength)); 
    	fpDevInfo->fpPollDataBuffer = 0;
	} 

    return  USB_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_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.
//
//
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_PollingTDCallback(
    HC_STRUC*   HcStruc,
    DEV_INFO*   DevInfo,
    UINT8*      Td,
    UINT8*      Buffer,
    UINT16      DataLength
)
{
    UINT8   i;
    UINT16  BytesTransferred;

    if (((OHCI_TD*)Td)->bActiveFlag == FALSE) {
        return USB_SUCCESS;
    }

	((OHCI_TD*)Td)->bActiveFlag = FALSE;
	DwordResetMem((UINT32)HcStruc->BaseAddress, OHCI_CONTROL_REG, PERIODIC_LIST_ENABLE);

    for (i = 1; i < MAX_DEVICES; i++) {
        DevInfo = &gUsbData->aDevInfoTable[i];
        if (DevInfo->Flag & DEV_INFO_DEV_PRESENT) {
            if (DevInfo->fpPollTDPtr == Td) {
                break;
            }
        }
    }

    if (i == MAX_DEVICES) {
        return USB_ERROR;
    }

	UsbUpdateDataToggle(DevInfo, DevInfo->IntInEndpoint, 
			(UINT8)((((OHCI_ED*)DevInfo->fpPollEDPtr)->fpHeadPointer & ED_TOGGLE_CARRY) >> 1));

										//(EIP59707)>
	if ((((OHCI_TD*)Td)->dControlStatus & GTD_STATUS_FIELD) == GTD_NO_ERROR) {
        //
        // Get the size of data transferred
        //
        if (((OHCI_TD*)Td)->fpCurrentBufferPointer != 0) {
            BytesTransferred = ((OHCI_TD*)Td)->fpCurrentBufferPointer -
                (UINT32)(UINTN)(DevInfo->fpPollDataBuffer);
        } else {
            BytesTransferred = DevInfo->PollingLength;
        }
        if ((DevInfo->bCallBackIndex) && (DevInfo->bCallBackIndex <= MAX_CALLBACK_FUNCTION)) {
    	    (*gUsbData->aCallBackFunctionTable[DevInfo->bCallBackIndex-1])(
    	                HcStruc,
    	                DevInfo,
    	                (UINT8*)Td,
    	                DevInfo->fpPollDataBuffer,
    	                BytesTransferred);
        }
	}
										//<(EIP59707)
    DwordSetMem((UINT32)HcStruc->BaseAddress, OHCI_CONTROL_REG, PERIODIC_LIST_ENABLE);

    // Clear the link pointer. It may point to some other TD
    ((OHCI_TD*)Td)->fpLinkPointer = OHCI_TERMINATE;
    ((OHCI_TD*)Td)->dControlStatus = ((OHCI_TD*)Td)->dCSReloadValue;
    ((OHCI_TD*)Td)->fpCurrentBufferPointer = (UINT32)(UINTN)(DevInfo->fpPollDataBuffer);		//(EIP54782)
    ((OHCI_ED*)DevInfo->fpPollEDPtr)->fpHeadPointer &= ED_TOGGLE_CARRY;
    ((OHCI_ED*)DevInfo->fpPollEDPtr)->fpHeadPointer |= (UINTN)((OHCI_TD*)Td);
    ((OHCI_TD*)Td)->bActiveFlag = TRUE;
    // Reset the TD's control and buffer pointer fields to their original values.
    return USB_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_DisableKeyRepeat
//
// DESCRIPTION: This function disables the keyboard repeat rate logic by
//              enabling the repeat TD
//
// PARAMETERS:  fpHCStruc   Pointer to the HCStruc structure
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_DisableKeyRepeat (
	HC_STRUC	*HcStruc
)
{
    OHCI_DESC_PTRS      *DescPtrs;
    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 (OhciIsHalted(HcStruc)) {
		return USB_ERROR;
	}
    
    DescPtrs = HcStruc->stDescPtrs.fpOHCIDescPtrs;

    if (DescPtrs == NULL) {
        return USB_ERROR;
    }

    if (((UINT8*)DescPtrs < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(DescPtrs + sizeof(OHCI_DESC_PTRS)) > MemBlockEnd)) {
        return USB_ERROR;
    }
    
    if (DescPtrs->fpEDRepeat == NULL) {
		return USB_ERROR;
    }

    if (((UINT8*)DescPtrs->fpEDRepeat < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(DescPtrs->fpEDRepeat + sizeof(OHCI_ED)) > MemBlockEnd)) {
        return USB_ERROR;
    }

    DescPtrs->fpEDRepeat->dControl |= ED_SKIP_TDQ;    // Inactive
	DescPtrs->fpTDRepeat->bActiveFlag = FALSE;

    return  USB_SUCCESS;

}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_EnableKeyRepeat
//
// DESCRIPTION: This function enables the keyboard repeat rate logic by
//              enabling the repeat TD
//
// PARAMETERS:  fpHCStruc   Pointer to the HCStruc structure
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_EnableKeyRepeat (
	HC_STRUC	*HcStruc
)
{
    OHCI_DESC_PTRS      *DescPtrs;
    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 (OhciIsHalted(HcStruc)) {
		return USB_ERROR;
	}

    DescPtrs = HcStruc->stDescPtrs.fpOHCIDescPtrs;

    if (DescPtrs == NULL) {
        return USB_ERROR;
    }

    if (((UINT8*)DescPtrs < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(DescPtrs + sizeof(OHCI_DESC_PTRS)) > MemBlockEnd)) {
        return USB_ERROR;
    }

    if (DescPtrs->fpEDRepeat == NULL) {
		return USB_ERROR;
    }

    if (((UINT8*)DescPtrs->fpEDRepeat < gUsbData->fpMemBlockStart) ||
        ((UINT8*)(DescPtrs->fpEDRepeat + sizeof(OHCI_ED)) > MemBlockEnd)) {
        return USB_ERROR;
    }

	DescPtrs->fpTDRepeat->fpLinkPointer = OHCI_TERMINATE;
	DescPtrs->fpEDRepeat->fpHeadPointer = (UINT32)(UINTN)DescPtrs->fpTDRepeat;
	DescPtrs->fpTDRepeat->dControlStatus = 
						DescPtrs->fpTDRepeat->dCSReloadValue;
	DescPtrs->fpTDRepeat->bActiveFlag = TRUE;
	DescPtrs->fpEDRepeat->dControl &= (~ED_SKIP_TDQ); // Active

    return  USB_SUCCESS;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_EnumeratePorts
//
// DESCRIPTION: This API function is called to enumerate the root hub ports
//              in the OHCI controller. The input to the routine is the
//              pointer to the HC structure  that defines this host controller
//
// PARAMETERS:  fpHCStruc   Ptr to the host controller structure
//
// RETURN:      Status: USB_SUCCESS = Success
//                      USB_ERROR = Failure
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_EnumeratePorts(HC_STRUC* fpHCStruc)
{
	UINT32	BaseAddr = (UINT32)fpHCStruc->BaseAddress;
	UINT32  RhDescriptorA = 0;
	UINT8	PowerOnDelay = 0;
	UINT8	Index = 0;
	UINT16	PortReg = OHCI_RH_PORT1_STATUS;
    EFI_STATUS  EfiStatus;

    EfiStatus = UsbHcStrucValidation(fpHCStruc);
    
    if (EFI_ERROR(EfiStatus)) {
        return USB_ERROR;
    }

    if (!(fpHCStruc->dHCFlag & HC_STATE_RUNNING)) {
        return USB_ERROR;
    }

	if (OhciIsHalted(fpHCStruc)) {
		return USB_ERROR;
	}

	RhDescriptorA = DwordReadMem(BaseAddr, OHCI_RH_DESCRIPTOR_A);
	if (!(RhDescriptorA & NO_POWER_SWITCH)) {
		if (!(RhDescriptorA & POWER_SWITCH_MODE)) {
			// All ports are powered at the same time, enable global port power
	    	DwordWriteMem(BaseAddr, OHCI_RH_STATUS, SET_GLOBAL_POWER);
		} else {
			// Each port is powered individually, enable individual port's power
			for (Index = 0; Index < fpHCStruc->bNumPorts; PortReg+=4, Index++) {
                // Set PortPowerControlMask bit 
                DwordSetMem(BaseAddr, OHCI_RH_DESCRIPTOR_B, ((1 << (Index + 1)) << 16));
                // Set PortPower bit
				DwordWriteMem(BaseAddr, PortReg, SET_PORT_POWER);
			}
		}
		PowerOnDelay = ((RhDescriptorA & POWERON2POWERGOOD_TIME) >> 24) << 1;
		FixedDelay(PowerOnDelay * 1000);
	}

    OHCI_ProcessRootHubStatusChange(fpHCStruc);

    return  USB_SUCCESS;
}


//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// FUNCTION:    OhciAddPeriodicEd
//
// DESCRIPTION: This function adds a ED to the frame list
//
// PARAMETERS:  HcStruc - Ptr to the host controller structure
//              Ed - ED will be added in periodic schedule
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OhciAddPeriodicEd (
    HC_STRUC    *HcStruc,
    OHCI_ED     *Ed
)
{
    UINT16  Index;
    UINT32  *PrevPtr;
    OHCI_ED *Current;
    EFI_STATUS  Status = EFI_SUCCESS;

    if (Ed == NULL || Ed->Interval == 0) {
        return USB_ERROR;
    }

    for (Index = 0; Index < HcStruc->wAsyncListSize; Index += Ed->Interval) {
        PrevPtr = &HcStruc->fpFrameList[Index]; 
        Current = (OHCI_ED*)(*PrevPtr);

        while (Current != NULL) {
#if USB_RUNTIME_DRIVER_IN_SMM
            Status = AmiValidateMemoryBuffer((VOID*)Current, sizeof(OHCI_ED));
            if (EFI_ERROR(Status)) {
                return USB_ERROR;
            }
#endif
            if (Current->Interval <= Ed->Interval) {
                break;
            }

            PrevPtr = &Current->fpEDLinkPointer; 
            Current = (OHCI_ED*)Current->fpEDLinkPointer;
        }

        if (Current == Ed) {
            continue;
        }
        Ed->fpEDLinkPointer = (UINT32)(UINTN)Current;
#if USB_RUNTIME_DRIVER_IN_SMM
         Status = AmiValidateMemoryBuffer((VOID*)PrevPtr, sizeof(UINT32));
         if (EFI_ERROR(Status)) {
            return USB_ERROR;
         }
#endif
        *PrevPtr = (UINT32)(UINTN)Ed;
    }

    return USB_SUCCESS;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// FUNCTION:    OhciRemovePeriodicEd
//
// DESCRIPTION: This function removes a ED from the frame list
//
// PARAMETERS:  HcStruc - Ptr to the host controller structure
//              Ed - ED will be removed from periodic schedule
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OhciRemovePeriodicEd (
    HC_STRUC    *HcStruc,
    OHCI_ED     *Ed
)
{
    UINT16  Index;
    UINT32  *PrevPtr;
    OHCI_ED *Current;
    EFI_STATUS  Status = EFI_SUCCESS;

    if (Ed == NULL || Ed->Interval == 0) {
        return USB_ERROR;
    }

    Ed->dControl |= ED_SKIP_TDQ;

    for (Index = 0; Index < HcStruc->wAsyncListSize; Index += Ed->Interval) {
        PrevPtr = &HcStruc->fpFrameList[Index]; 
        Current = (OHCI_ED*)(*PrevPtr);

        while (Current != NULL) {
#if USB_RUNTIME_DRIVER_IN_SMM
            Status = AmiValidateMemoryBuffer((VOID*)Current, sizeof(OHCI_ED));
            if (EFI_ERROR(Status)) {
                return USB_ERROR;
            }
#endif
            if (Current == Ed) {
                break;
            }

            PrevPtr = &Current->fpEDLinkPointer; 
            Current = (OHCI_ED*)Current->fpEDLinkPointer;
        }

        if (Current == NULL) {
            continue;
        }
#if USB_RUNTIME_DRIVER_IN_SMM
         Status = AmiValidateMemoryBuffer((VOID*)PrevPtr, sizeof(UINT32));
         if (EFI_ERROR(Status)) {
            return USB_ERROR;
         }
#endif
        *PrevPtr = Ed->fpEDLinkPointer;
    }

    DwordWriteMem((UINT32)HcStruc->BaseAddress, OHCI_INTERRUPT_STATUS, START_OF_FRAME);
    DwordWriteMem((UINT32)HcStruc->BaseAddress, OHCI_INTERRUPT_ENABLE, START_OF_FRAME_ENABLE);

    for (Index = 0; Index < 100; Index++) {
        if (DwordReadMem((UINT32)HcStruc->BaseAddress, 
                OHCI_INTERRUPT_STATUS) & START_OF_FRAME) {
            break;
        }
        FixedDelay(10);   // 10 us delay
    }
    ASSERT(Index < 100);
    ASSERT(DwordReadMem((UINT32)HcStruc->BaseAddress, OHCI_INTERRUPT_STATUS) & START_OF_FRAME);
    DwordWriteMem((UINT32)HcStruc->BaseAddress, OHCI_INTERRUPT_DISABLE, START_OF_FRAME_DISABLE);

    return USB_SUCCESS;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// FUNCTION:    OHCI_StartEDSchedule
//
// DESCRIPTION: This function starts the standard TD schedules for the
//              USB host controller
//
// PARAMETERS:  HCStruc for the controller
//
// RETURN:      USB_ERROR on error, USB_SUCCESS on success
//
// NOTES:   This routine creates 1, 2, 8, 32 and 1024ms schedules
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_StartEDSchedule(
    HC_STRUC    *HcStruc
)
{
    OHCI_DESC_PTRS  *DescPtrs;
    UINT8           *Ptr;

    //
    // Allocate descriptor structure and fill it in HCStruc
    //
    DescPtrs = (OHCI_DESC_PTRS*)USB_MemAlloc (GET_MEM_BLK_COUNT_STRUC(OHCI_DESC_PTRS));
    ASSERT(DescPtrs);
    if (!DescPtrs) return USB_ERROR;

    //
    // Save the value in the HC struc
    //
    HcStruc->stDescPtrs.fpOHCIDescPtrs = DescPtrs;

    //
    // Allocate 4 EDs + 1 TDs and put them in Descriptor list
    //
    Ptr = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(OHCI_ED));
    ASSERT(Ptr);
    if (!Ptr) return USB_ERROR;

    DescPtrs->PeriodicEd = (OHCI_ED*)Ptr;
    DescPtrs->PeriodicEd->dControl = ED_SKIP_TDQ;
    DescPtrs->PeriodicEd->fpEDLinkPointer = 0;
    DescPtrs->PeriodicEd->Interval = 1;

    // Initialize each entry of Interrupt Table as statically disable ED
    OhciAddPeriodicEd(HcStruc, DescPtrs->PeriodicEd);

    //
    // Allocate ED/TD for EDControl, TDControlSetup, TDControlData,
    // TDControlStatus, EDBulk, TDBulkData, EDInterrupt and TDInterruptData
    //
    Ptr = USB_MemAlloc(GET_MEM_BLK_COUNT(2 * sizeof(OHCI_ED) + 4 * sizeof(OHCI_TD)));
    ASSERT(Ptr);
    if (!Ptr) return USB_ERROR;

    //
    // Save the 8 ED/TD in their proper position. Note: fpHCStruc->stDescPtrs.fpEHCIDescPtrs
    // is initialized earlier in OHCI_StartEDSchedule.
    //
    DescPtrs->fpEDControl = (OHCI_ED*)Ptr;
    Ptr += sizeof (OHCI_ED);

    DescPtrs->fpTDControlSetup = (OHCI_TD*)Ptr;
    Ptr += sizeof (OHCI_TD);

    DescPtrs->fpTDControlData = (OHCI_TD*)Ptr;
    Ptr += sizeof (OHCI_TD);

    DescPtrs->fpTDControlStatus = (OHCI_TD*)Ptr;
    Ptr += sizeof (OHCI_TD);

    DescPtrs->fpEDBulk = (OHCI_ED*)Ptr;
    Ptr += sizeof (OHCI_ED);

    DescPtrs->fpTDBulkData = (OHCI_TD*)Ptr;

	if (HcStruc->dHCFlag & HC_STATE_EXTERNAL) {
		return USB_SUCCESS;
	}

    // Allocate a ED/TD for EDRepeat/TDRepeat
    Ptr = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(OHCI_ED));
    ASSERT(Ptr);
    DescPtrs->fpEDRepeat  = (OHCI_ED*)Ptr;
 
    Ptr = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(OHCI_TD));
    ASSERT(Ptr);
    DescPtrs->fpTDRepeat  = (OHCI_TD*)Ptr;

    DescPtrs->fpEDRepeat->dControl = (DUMMY_DEVICE_ADDR |
            ED_IN_PACKET | ED_SKIP_TDQ | (DEFAULT_PACKET_LENGTH << 16));
    DescPtrs->fpEDRepeat->fpHeadPointer = (UINT32)(UINTN)DescPtrs->fpTDRepeat;
    DescPtrs->fpEDRepeat->fpEDLinkPointer = OHCI_TERMINATE;
    DescPtrs->fpEDRepeat->fpTailPointer = OHCI_TERMINATE;
    DescPtrs->fpEDRepeat->Interval = REPEAT_INTERVAL;

    DescPtrs->fpTDRepeat->dControlStatus = (UINT32)(GTD_BUFFER_ROUNDING | GTD_IN_PACKET | GTD_IntD |
        GTD_TWO_ERRORS | (GTD_NOT_ACCESSED << 28));
    DescPtrs->fpTDRepeat->dCSReloadValue = (UINT32)(GTD_BUFFER_ROUNDING | GTD_IN_PACKET | GTD_IntD |
        GTD_TWO_ERRORS | (GTD_NOT_ACCESSED << 28));

    DescPtrs->fpTDRepeat->fpCurrentBufferPointer =
                (UINT32)(UINTN)DescPtrs->fpTDRepeat->aSetupData;
    DescPtrs->fpTDRepeat->fpBufferEnd =
                (UINT32)(UINTN)DescPtrs->fpTDRepeat->aSetupData;
    DescPtrs->fpTDRepeat->fpLinkPointer = OHCI_TERMINATE;
    DescPtrs->fpTDRepeat->bCallBackIndex = USB_InstallCallBackFunction(OHCI_RepeatTDCallBack);
    DescPtrs->fpTDRepeat->bActiveFlag = FALSE;

    OhciAddPeriodicEd(HcStruc, DescPtrs->fpEDRepeat);
	
	USBKeyRepeat(HcStruc, 0);

    return USB_SUCCESS;
}


//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// FUNCTION:    OHCI_ResetHC
//
// DESCRIPTION: This function resets the OHCI controller
//
// PARAMETERS:  Pointer to the HCStruc structure
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8 OHCI_ResetHC(HC_STRUC* fpHCStruc)
{
	UINT32	BaseAddr = (UINT32)fpHCStruc->BaseAddress;
	UINT8	i;
    //
    // Issue a software reset and HC go to UsbSuspend state
    //
    DwordWriteMem(BaseAddr, OHCI_COMMAND_STATUS, HC_RESET);

    // The reset operation must be completed within 10 us
	for (i = 0; i < 100; i++) {
		FixedDelay(1);   // 1 us delay
		if (!(DwordReadMem(BaseAddr, OHCI_COMMAND_STATUS) & HC_RESET)) {
			return USB_SUCCESS;
		}
	}

	return USB_ERROR;
}


//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// FUNCTION:    OHCI_ProcessRootHubStatusChange
//
// DESCRIPTION: This function is called when TD1024ms 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.
//
// PARAMETERS:  Pointer to HC Struc
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT32 OHCI_ProcessRootHubStatusChange(HC_STRUC* fpHCStruc)
{
    UINT8   bHCNumber, bPort;//, bPortStatus;	//(EIP59663)

    //
    // Check bEnumFlag before enumerating devices behind root hub
    //
    if (gUsbData->bEnumFlag == TRUE) return USB_ERROR;
    gUsbData->bEnumFlag = TRUE;    // Set enumeration flag and avoid hub port enumeration
    //
    // 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.
    //
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_DISABLE, 0x80000000);
    //
    // Check all the ports on the root hub for any change in connect status.
    // If the connect status has been changed on either or both of these ports,
    // then call the  routine UsbHubPortChange for each changed port.
    //
    bHCNumber = fpHCStruc->bHCNumber | BIT7;

    for (bPort = 1; bPort <= fpHCStruc->bNumPorts; bPort++) {
										//(EIP59663)>
        //bPortStatus = OHCI_GetRootHubStatus (fpHCStruc, bPort+1);
      	//DwordResetMem((UINT32)fpHCStruc->BaseAddress, OHCI_RH_PORT1_STATUS+bPort*4, 0xFFFF);
        //if (bPortStatus & USB_PORT_STAT_DEV_CONNECT_CHANGED) {
		USBCheckPortChange(fpHCStruc, bHCNumber, bPort);
        //}
        //DwordResetMem((UINT32)fpHCStruc->BaseAddress, OHCI_RH_PORT1_STATUS+bPort*4, 0xFFFF);
										//<(EIP59663)
    }
    //
    // Clear the RH_STATUS_CHANGE bit of the interrupt status register
    // in the host controller: write 1 to bit to clear it
    //
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_STATUS, RH_STATUS_CHANGE);

    //
    // Renable interrupts from the host controller
    //
    DwordWriteMem((UINT32)fpHCStruc->BaseAddress, OHCI_INTERRUPT_ENABLE, MASTER_INTERRUPT_ENABLE);

    gUsbData->bEnumFlag    = FALSE;
    return USB_SUCCESS;
}



//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCIWaitForTransferComplete
//
// DESCRIPTION: This function executes a device request command transaction
//
// PARAMETERS:  fpHCStruc   Pointer to HCStruc of the host controller
//              fpTD        Pointer to the TD which has to be completed
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCIWaitForTransferComplete(
	HC_STRUC	*fpHCStruc, 
	OHCI_ED		*XferED,
	OHCI_TD		*LastTD,
    DEV_INFO*	fpDevInfo
)
{
    UINT32 Count ;
    UINT32 Timeout = gUsbData->wTimeOutValue << 4; // *16, makes it number of 60mcs units

    //
    // Check status change loop iteration
    //
    for(Count = 0; !Timeout || Count < Timeout; Count++) {
        OHCI_ProcessInterrupt(fpHCStruc);
        if(!LastTD->bActiveFlag )
           return   USB_SUCCESS;
        else if(!VALID_DEVINFO(fpDevInfo)){
            USB_DEBUG (DEBUG_LEVEL_3, "OHCI Abort: devinfo: %x\n",fpDevInfo );
            return USB_ERROR;
        }
        FixedDelay(60);  // 60 microseconds
    }

	XferED->dControl |= ED_SKIP_TDQ;
	OHCI_ProcessInterrupt(fpHCStruc);

	if(!LastTD->bActiveFlag) {
		return USB_SUCCESS;
	}

    USB_DEBUG (DEBUG_LEVEL_3, "OHCI Time-Out\n");

    return USB_ERROR;
}


//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// FUNCTION:    OHCI__StopUnsupportedHC
//
// DESCRIPTION: This routine is called, from host controllers that supports
//      OS handover functionality (currently from OHCI driver only), when OS
//      wants the BIOS to hand-over the host controllers to the OS.  This routine
//      will stop HC that does not support this functionality.
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_StopUnsupportedHC(
	HC_STRUC*	HcStruc
)
{
    UINT8	i;

	if (!gUsbData->UsbEhciHandoff) {
		return USB_SUCCESS;
	}

//
// Currently this host controller stops only the EHCI host controllers
// Find the EHCI host controller HCStruc
//
    for (i = 0; i < gUsbData->HcTableCount; i++ ) {
        if (gUsbData->HcTable[i] == NULL) {
            continue;
        }
        if (!(gUsbData->HcTable[i]->dHCFlag & HC_STATE_USED)) {
        	continue;
        }
		if (!(gUsbData->HcTable[i]->dHCFlag & HC_STATE_RUNNING) ||
			(gUsbData->HcTable[i]->bHCType != USB_HC_EHCI) ||
			((gUsbData->HcTable[i]->wBusDevFuncNum & ~0x7) != 
			(HcStruc->wBusDevFuncNum & ~0x7))) {
			continue;
		}

		gUsbData->bHandOverInProgress = TRUE;
		(*gUsbData->aHCDriverTable[GET_HCD_INDEX(
			gUsbData->HcTable[i]->bHCType)].pfnHCDStop)(gUsbData->HcTable[i]);
    }

	return USB_SUCCESS;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// FUNCTION:    OHCI_GeneralTDCallback
//
// DESCRIPTION: This function is called when bulk data or interrupt data TD
//              is completed. This routine just deactivates the TD.
//
// PARAMETERS:  Pointer to the HCStruc structure
//              Pointer to the TD that completed
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_GeneralTDCallback(
    HC_STRUC*   HcStruc,
    DEV_INFO*   DevInfo,
    UINT8*      Td,
    UINT8*      Buffer,
    UINT16      DataLength
 )
{
    ((OHCI_TD*)Td)->bActiveFlag = FALSE;
    return USB_SUCCESS;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// FUNCTION:    OHCI_ControlTDCallback
//
// DESCRIPTION: This function is called when the control transfer scheduled
//              is completed.
//
// PARAMETERS:  fpHCStruc   Pointer to the HCStruc structure
//              fpDevInfo   NULL (pDevInfo is not valid)
//              fpTD        Pointer to the TD that completed
//              fpBuffer    Not used
//
// RETURN:      USB_SUCCESS or USB_ERROR
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OHCI_ControlTDCallback(
    HC_STRUC*   HcStruc,
    DEV_INFO*   DevInfo,
    UINT8*      Td,
    UINT8*      Buffer,
    UINT16      DataLength
)
{
    OHCI_DESC_PTRS *DescPtrs;
    UINT8           *MemBlockEnd = gUsbData->fpMemBlockStart + (gUsbData->MemPages << 12);
    
    //
    // Check to see if the TD that just completed has any error bits set.  If
    // any of the control TDs (Setup, Data, or Status) complete with an error, set
    // ActiveFlag of the control status TD and copy the error information from the
    // TD that just completed into the control status TD.
    //
    if ((UINT8)(((OHCI_TD*)Td)->dControlStatus >> 28)) {
        DescPtrs = HcStruc->stDescPtrs.fpOHCIDescPtrs;
        if (((UINT8*)DescPtrs < gUsbData->fpMemBlockStart) ||
            ((UINT8*)(DescPtrs + sizeof(OHCI_DESC_PTRS)) > MemBlockEnd)) {
            return USB_ERROR;
        }
        if (((UINT8*)DescPtrs->fpTDControlStatus < gUsbData->fpMemBlockStart) ||
            ((UINT8*)(DescPtrs->fpTDControlStatus + sizeof(OHCI_TD)) > MemBlockEnd)) {
            return USB_ERROR;
        }
        if (DescPtrs->fpTDControlStatus != (OHCI_TD*)Td) {
            DescPtrs->fpTDControlStatus->dControlStatus = ((OHCI_TD*)Td)->dControlStatus;
            DescPtrs->fpTDControlStatus->bActiveFlag = FALSE;
        }
    }
    //
    // Make the TD that just completed inactive.  It may be the control setup TD,
    // one of the control data TDs, or the control status TD.
    //
    ((OHCI_TD*)Td)->bActiveFlag = FALSE;

    return USB_SUCCESS;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// FUNCTION:    OHCI_ProcessTD
//
// DESCRIPTION: This function will check whether the TD is completed
//              if so, it will call the call back routine associated with
//              this TD.
//
// PARAMETERS:  HCStruc structure, Pointer to the TD
//
// 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>

void OHCI_ProcessTD(
    HC_STRUC    *HcStruc,
    OHCI_TD     *Td
)
{
    if (!Td) {
        return;  // Check for NULL
    }
    if (Td->bActiveFlag != TRUE) {
        return;  // TD is not active
    }
    if ((Td->bCallBackIndex) && (Td->bCallBackIndex <= MAX_CALLBACK_FUNCTION)) {
        if (gUsbData->aCallBackFunctionTable[Td->bCallBackIndex-1]) {
            (*gUsbData->aCallBackFunctionTable[Td->bCallBackIndex-1])(
                HcStruc,
                0,
                (UINT8*)Td,
                0,
                0);
        }
    }
}

										//(EIP28707+)>
//<AMI_PHDR_START>
//----------------------------------------------------------------------------
// FUNCTION:    OHCI_FreeAllStruc
//
// DESCRIPTION: This function is used to free the all the allocated TDs,
//				QH and DescriptorPtr structure. This function only frees
//				the entries in the DescriptorPtr and the descriptor pointer
//				only.
//                                                                              ;
// PARAMETERS:  fpHCStruc   Pointer to the HCStruc structure
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

VOID OHCI_FreeAllStruc(HC_STRUC* fpHCStruc)
{
	OHCI_DESC_PTRS  *fpDescPtrs;

	fpDescPtrs = fpHCStruc->stDescPtrs.fpOHCIDescPtrs;

// Free the EDs & TDs
	USB_MemFree(fpDescPtrs->PeriodicEd, GET_MEM_BLK_COUNT_STRUC(OHCI_ED));
	if (fpDescPtrs->fpEDRepeat) {
		USB_MemFree(fpDescPtrs->fpEDRepeat, GET_MEM_BLK_COUNT_STRUC(OHCI_ED));
	}
	if (fpDescPtrs->fpTDRepeat) {
		USB_MemFree(fpDescPtrs->fpTDRepeat, GET_MEM_BLK_COUNT_STRUC(OHCI_TD));
	}

	USB_MemFree(fpDescPtrs->fpEDControl, 
        GET_MEM_BLK_COUNT(2 * sizeof(OHCI_ED) + 4 * sizeof(OHCI_TD)));
	
// Free descriptor structure (in BX)
	USB_MemFree(fpDescPtrs, GET_MEM_BLK_COUNT_STRUC(OHCI_DESC_PTRS));
}
										//<(EIP28707+)

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
//
// Procedure:   OhciIsHalted
//
// Description: This function check whether HC is halted.
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

BOOLEAN
OhciIsHalted (
	HC_STRUC	*HcStruc
)
{
	return (DwordReadMem((UINT32)HcStruc->BaseAddress, OHCI_CONTROL_REG) & HC_FUNCTION_STATE) != USBOPERATIONAL;
}

//<AMI_PHDR_START>
//----------------------------------------------------------------------------
//
// Procedure:   OhciTranslateInterval
//
// Description: This function calculates the polling rate.
//
//----------------------------------------------------------------------------
//<AMI_PHDR_END>

UINT8
OhciTranslateInterval(
    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));
}

//****************************************************************************
//****************************************************************************
//**                                                                        **
//**             (C)Copyright 1985-2016, American Megatrends, Inc.          **
//**                                                                        **
//**                          All Rights Reserved.                          **
//**                                                                        **
//**                 5555 Oakbrook Pkwy, Norcross, GA 30093                 **
//**                                                                        **
//**                          Phone (770)-246-8600                          **
//**                                                                        **
//****************************************************************************
//****************************************************************************