diff options
Diffstat (limited to 'Core/EM/usb/rt/usbmass.c')
| -rw-r--r-- | Core/EM/usb/rt/usbmass.c | 5506 |
1 files changed, 5506 insertions, 0 deletions
diff --git a/Core/EM/usb/rt/usbmass.c b/Core/EM/usb/rt/usbmass.c new file mode 100644 index 0000000..0bdb683 --- /dev/null +++ b/Core/EM/usb/rt/usbmass.c @@ -0,0 +1,5506 @@ +//**************************************************************************** +//**************************************************************************** +//** ** +//** (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/usbmass.c 174 10/20/16 11:19p Wilsonlee $ +// +// $Revision: 174 $ +// +// $Date: 10/20/16 11:19p $ +//**************************************************************************** +//**************************************************************************** +// Revision History +// ---------------- +// +// $Log: /Alaska/SOURCE/Modules/USB/ALASKA/RT/usbmass.c $ +// +// 174 10/20/16 11:19p Wilsonlee +// [TAG] EIP297268 +// [Category] Improvement +// [Description] Update Media information only in EfiUsbMass driver when +// Media is changed. +// [Files] usbmass.c, efiusbmass.c +// +// 173 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 +// +// 172 7/22/16 3:51a 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 +// +// 171 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 +// +// 170 4/08/16 3:54a Wilsonlee +// [TAG] EIP260113 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] We return success for writing data to to the +// write-protected device. +// [RootCause] Command Block Status is Command Failed when we send the +// write command to the write-protected device. +// [Solution] When CSW isn't Valid, we should issue a REQUEST SENSE +// command to receive the sense data describing what caused the error +// condition. +// [Files] usbmass.c +// +// 169 3/02/16 9:41p Wilsonlee +// [TAG] EIP254309 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] GK-FORCE K83 USB KB function abnormal. +// [RootCause] This device has an interrupt out endpoint and doesn't +// support "Set Report" request. +// [Solution] Use the interrupt out endpoint instead of sending "Set +// Report" request. +// [Files] AmiUsbController.h, xhci.c, usbmass.c, usbkbd.h, usbkbd.c, +// usbhub.c, usbhid.c, usbdef.h, usbCCID.c, usb.c, uhci.c, ohci.c, ehci.c, +// amiusb.h, efiusbms,c, amiusbhc.c +// +// 168 2/14/16 9:46p Wilsonlee +// [TAG] EIP254924 +// [Category] Improvement +// [Description] Issue a Set TR Dequeue Pointer Command after issuing +// for a ClearFeature(ENDPOINT_HALT) request to device. +// [Files] usbmass.c, xhci.c +// +// 167 7/24/15 4:41a Wilsonlee +// [TAG] EIP226493 +// [Category] Improvement +// [Description] Block to process periodic list to prevent that we might +// send the wrong command sequences to the same device. +// [Files] usbmass.c, ehci.c, xhci.h, xhci.c, usbdef.h, uhcd.c +// +// 166 5/27/15 2:13a Wilsonlee +// [TAG] EIP220162 +// [Category] Improvement +// [Description] The read / write request contain the latest LBA that +// are valid. +// [Files] usbmass.c, efiusbmass.c +// +// 165 4/29/15 11:26p Wilsonlee +// [TAG] EIP215031 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Transcend USB 3.0 HDD is disappeared in the setup menu by +// cold boot. +// [RootCause] We only can get SerialNumber string descriptor before +// setting configuration for this device, otherwise it is failed at +// getting this descriptor and inquiry command is also failed. +// [Solution] Retry inquiry command. +// [Files] usb.c, usbmass.c, efiusbmass.c, usbbus.c, usbdef.h +// +// 164 1/15/15 9:54p Wilsonlee +// [TAG] EIP198806 +// [Category] Improvement +// [Description] Send "RequestSense" command only if "TestUnitReady" +// command is failed. +// [Files] usbmass.c +// +// 163 12/24/14 1:08a Wilsonlee +// [TAG] EIP192517 +// [Category] Improvement +// [Description] SB Driver handles 0x100 NumHeads as a valid value. +// [Files] usbmass.c, usbdef.h, UsbInt13.c, UsbInt13.h, UI13.bin, +// Bfiusb.equ, Bfiusb.asm +// +// 162 11/30/14 10:30p Wilsonlee +// [TAG] EIP193829 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Ghost on multiple USB dvd rom span (Legacy Dos )fails if +// boot disk is smaller than second disk. +// [RootCause] RWVCommand gets one byte data after we change Media, but +// data isn't correct. +// [Solution] Check if data length processed is correct. +// [Files] usbmass.c +// +// 161 11/24/14 12:56a Wilsonlee +// [TAG] EIP192326 +// [Category] Improvement +// [Description] Check that division by zero exception doesn't occur. +// [Files] usbmass.c +// +// 160 11/23/14 10:53p Wilsonlee +// [TAG] EIP186754 +// [Category] Improvement +// [Description] The minimum of sector should be 1. +// [Files] usbmass.c +// +// 159 11/23/14 10:36p Wilsonlee +// [TAG] EIP188492 +// [Category] Improvement +// [Description] Create a token to keep usb mass storage devices are +// RemovableMedia. +// [Files] usbmass.c, usb.sdl +// +// 158 9/02/14 4:09a Wilsonlee +// [TAG] EIP183522 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Heads, Sectors and Cylinders aren't correct if usb mass +// storages report media change. +// [RootCause] We update CHS from read capacity parameters if media +// change. +// [Solution] We already update CHS from boot record and legacy boot +// doesn't support dynamic media insertion, we should not update it from +// read capacity parameters. +// [Files] usbmass.c +// +// 157 8/07/14 5:35a Wilsonlee +// [TAG] EIP180686 +// [Category] Improvement +// [Description] Right shifts 64bit values that should be using Shr64(). +// [Files] usbmass.c +// +// 156 7/04/14 5:23a Wilsonlee +// [TAG] EIP175485 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] USB key can't be save during secure boot key. +// [RootCause] The usb key, MSI 8G Team, has two luns. One is CD-ROM, it +// always reports there is no media until we send "Get_Configuration" +// command to it, then it causes the other lun will report media change +// when we read/write data later. +// [Solution] Send "Get_Configuration" command for CD/DVD devices. +// [Files] usbmass.c +// +// 155 6/26/14 1:16a Wilsonlee +// [TAG] EIP173387 +// [Category] Improvement +// [Description] Remove TODO comments. +// [Files] usbsetup.c, xhci.c, usbmass.c, usbCCID.c, usb.c, uhci.c, +// syskbc.c, usbport.c, usbbus.c, uhcd.c, UsbBotPeim.c, PeiXhci.c, +// PeiEhci.c +// +// 154 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 +// +// 153 4/30/14 1:59a Wilsonlee +// [TAG] EIP162993 +// [Category] Improvement +// [Description] We need to return success on INT 13 func 2 even if +// there is no media. +// [Files] usbmass.c, UI13.bin, Bfiusb.asm +// +// 152 4/29/14 8:55p Wilsonlee +// [TAG] EIP165610 +// [Category] Improvement +// [Description] We still need to try readformatcapacity command even if +// the subclass isn't UFI. +// [Files] usbmass.c +// +// 151 4/29/14 8:47p Wilsonlee +// [TAG] EIP152539 +// [Category] Improvement +// [Description] If the pervious device status is that media not present +// and current device status comes as media present, modified the code to +// report as media changed along with current status in the usbmass.c. +// [Files] usbmass.c +// +// 150 4/07/14 2:07a Wilsonlee +// [TAG] EIP156126 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] The power Format of UEFI can not be identified when we +// install OS from USB CD-ROM. +// [RootCause] The media information is incorrect when we install +// BlockIoProtocol for usb CD / DVD devices. +// [Solution] Get the media status before we install BlockIoProtocol. +// [Files] usbmass.c, usbdef.h, efiusbmass.c +// +// 149 4/03/14 3:32a Wilsonlee +// [TAG] EIP161240 +// [Category] Improvement +// [Description] Use Div64 if variables is UINT64. +// [Files] usbmass.c +// +// 148 2/25/14 10:15p Wilsonlee +// [TAG] EIP155805 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] WinCE loader can't boot. +// [RootCause] It can't boot if the mass storage doesn't have validate +// partition table. +// [Solution] We should set the type to FORCED_FDD if it's not a Floppy +// and doesn't have validate partition table. +// [Files] usbmass.c +// +// 147 12/23/13 1:56a Ryanchou +// [TAG] EIP147532 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Dynamic DVD Insertion failed to Read the files +// [RootCause] The Last Block is not updated properly when the new CD is +// inserted. +// [Solution] Update geometry if media is changed. +// [Files] usbmass.c +// +// 146 12/15/13 10:16p Wilsonlee +// [TAG] EIP136594 +// [Category] New Feature +// [Description] Support 64 bits LBA of usb mass storages. +// [Files] Bfiusb.asm, Bfiusb.equ, UsbInt13.c, UsbInt13.h, amiusb.c, +// usbdef.h, usbmass.c, UsbMass.h, efiusbmass.c, UI13.bin +// +// 145 10/20/13 11:32p Wilsonlee +// [TAG] EIP139719 +// [Category] Improvement +// [Description] Ignore the bulk data if the status transport causes +// time out. +// [Files] usbmass.c +// +// 144 9/04/13 5:35a Wilsonlee +// [TAG] EIP135036 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] MultilUN deviices don't install successfully after hotplug +// in shell. +// [RootCause] We skip to get maximum LUN if this mass storage is +// already registered. +// [Solution] Get maximum LUN even if this mass storage is already +// registered. +// [Files] usbmass.c +// +// 143 9/04/13 4:49a Wilsonlee +// [TAG] EIP133270 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Sony MS card reader sometimes cause system hang at 0xD5. +// [RootCause] This device may return the wrong data when we send "read +// format capacities" command. +// [Solution] Return error if capacity list header is wrong. +// [Files] usbmass.c +// +// 142 8/23/13 5:41a Ryanchou +// [TAG] EIP131624 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] USB mass storage configured fails +// [RootCause] USB Mass Storage driver canot find the correct DeviccInfo +// structure if it is a multiple interface device and the first interface +// is not mass storage class +// [Solution] Compare the DeviceInfo pointer to find the correct one, +// not device address +// [Files] usbmass.c +// +// 141 8/02/13 6:17a Ryanchou +// +// 140 7/29/13 5:21a Roberthsu +// [TAG] EIP126741 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Cannot boot to uefi usb device with Sophos software. +// [RootCause] When boot into tool. Ownership to os event occur.Usb +// will disconnect device.And record this disconnect event. Then ownership +// to bios,bios will connect all device.Run legacy to efi function. Bios +// run disconnect event first.Then reconnect device.Because usb key behind +// hub. So usb key disconnect also. +// [Solution] Check device when device reconnect.If device and port +// number the same.Use the same device info. +// [Files] usb.c,usbmass.c,efiusbmass.c,uhcd.c +// +// 139 7/23/13 11:50a Pats +// [TAG] EIP128964 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Int 13 Function 08 doesn't work right for USB mass storage +// devices. +// [RootCause] The default Head and Sector values for USB mass storage +// devices are fixed, resulting in a Cylinder value that is too large for +// the CHS format, when the device is over 2095104 sectors in size. +// [Solution] Modify function USBMassSetDefaultGeometry() to use Head and +// Sector values based ot total size. +// [Files] usbmass.c +// +// 138 7/23/13 2:14a Wilsonlee +// [TAG] EIP127941 +// [Category] Improvement +// [Description] Replace UI13HDDFunc08 with UI13FDDFunc08 if the media +// descriptor is a fixed disk. +// [Files] UsbInt13.h, UsbInt13.c, usbmass.c, usbdef.h, Bfiusb.asm, +// Bfiusb.equ +// +// 137 7/03/13 4:48a Ryanchou +// [TAG] EIP127800 +// [Category] Improvement +// [Description] Add non-bootable device type handing +// [Files] usbmass.c, efiusbmass.c +// +// 136 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 +// +// 135 3/08/13 4:04a Roberthsu +// [TAG] EIP113379 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] USB MBR data read with 125MB USB key will get wrong +// value +// [RootCause] When device emu force floppy.Read command will clear +// some information when read mbr. +// [Solution] If device emu force floppy.Only change mbr data when +// legacy. +// [Files] usbmass.c +// +// 134 1/22/13 5:10a Wilsonlee +// [TAG] EIP110635 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] ReadOnly attribute is not properly updated for USB FDD. +// [RootCause] The Media change status never gets refelected in +// AmiUsbBlkIoReadWrite function. +// [Solution] We should pass this information if the media has changed. +// [Files] usbmass.c +// +// 133 1/22/13 3:09a Wilsonlee +// [TAG] EIP112938 +// [Category] Improvement +// [Description] Create a header file for usb mass storage driver. +// [Files] UsbMass.h, usbmass.c, usbdef.h, amiusb.c, efiusbmass.c +// +// 132 1/22/13 2:38a Wilsonlee +// [TAG] EIP110305 +// [Category] Improvement +// [Description] Set the device address after we send the first +// get-device-descriptor command. +// [Files] usbmass.c, usb.c, usbdef.h, usbbus.c, efiusbmass.c, uhcd.c, +// usbport.c +// +// 131 1/11/13 4:15a Ryanchou +// [TAG] EIP102491 +// [Category] Improvement +// [Description] Synchronized with Aptio V USB module +// [Files] usbport.c, usbsb.c, ehci.c, ehci.h, ohci.c, ohci.h, uhci.h, +// usb.c, usbdef.h, usbhid.c, usbhub.c, usbkbd.c, usbkbd.h, usbmass.c. +// usbms.c, usbpoint.c, xhci.h, usb.sd, amiusbhc.c, componentname.c, +// efiusbkc.c, efiusbmass.c, uhcd.c, uhcd.h, usbbus.c, usbbus.h, usbmisc.c +// +// 130 12/24/12 1:43a Roberthsu +// [TAG] EIP107198 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Run gdisk.exe fail +// [RootCause] Device no media, gdisk call int13 get worng geometry. +// [Solution] If device no present.Do not return geometry. +// [Files] usbmass.c +// +// 129 11/10/12 6:39a Ryanchou +// [TAG] EIP99431 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Cannot use the UsbIo's UsbAsyncInterruptTransfer for +// keyboard input +// [RootCause] Stopping EFI USB keyboard driver does not stop the +// endpoint polling, then application calls UsbAsyncInterruptTransfer, +// error will be returned. +// [Solution] Stops endpoint polling and release resource when +// disconnecting the device driver. And improve the +// UsbSyncInterruptTransfer. +// [Files] amiusb.c, amiusb.h, ehci.c, ohci.c, uhci.c, usb.c, +// usbCCID.c, usbdef.h, usbhub.c, usbkbd.c, usbmass.c, usbms.c, +// usbpoint.c, amiusbhc.c, efiusbhid.c, usbbus.c, usbbus.h +// +// 128 10/03/12 5:40a Wilsonlee +// [TAG] EIP101623 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Fingerprint reader causes system waiting a long period at +// PC B4. +// [RootCause] The fingerprint reader returns sense key 0x02 instead of +// 0x00 if it doesn't have error sense key for request sense command. +// Which causes our code to repeatly wait for correct sense key. +// [Solution] We should send the request sense command only if the CSW +// is failed. However, current architecture has side-effect with this +// method. So we skip the sense key 0x02 as a workaround here. +// [Files] usbmass.c +// +// 127 9/28/12 2:38a Wilsonlee +// [TAG] EIP93154 +// [Category] Improvement +// [Description] Change the unit of the FixedDelay from 15 us to 1 us. +// [Files] amiusb.h, xhci.c, ehci.c, ohci.c, uhci.c, usb.c, usbCCID.c, +// usbmass.c, usbhub.c, elib.c +// +// 126 9/04/12 8:03a Wilsonlee +// [TAG] EIP99882 +// [Category] New Feature +// [Description] Add the usb setup item and usbpolicyprotocol to enable +// or disable the usb mass storage driver. +// [Files] UsbPolicy.h, usb.uni, usb.sd, usbmass.c, usbdef.h, +// efiusbmass.c, usbport.c, uhcd.c +// +// 125 8/13/12 2:10a Roberthsu +// [TAG] EIP94060 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] USB key can not boot to DOS after Ctrl+Alt+Del +// [RootCause] Because some device does not support mode sense +// command. +// [Solution] Send mode sense command when device type is UFI . +// [Files] usbmass.c +// +// 124 7/12/12 2:39a Roberthsu +// [TAG] EIP93460 +// [Category] Improvement +// [Description] Add token decide mass available under efi application +// when legacy support disabled. +// [Files] usb.sd,usb.uni,usbmass.c,usbsrc.sdl +// +// 123 6/28/12 10:21p Wilsonlee +// [TAG] EIP90503 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Plug USB card reader cause time too long to boot +// [RootCause] t sometimes happens "STALL" when data transport, then the +// next command will causes device timeout (20 seconds). +// [Solution] We perform reset recovery if there is the second "STALL" +// when we attempt to read CSW from Bulk-in endpoint. +// [Files] usbmass.c +// +// 122 6/14/12 2:59a Ryanchou +// [TAG] EIP91363 +// [Category] Improvement +// [Description] Correct the initial value of variable "bRetValue" in +// USBMassReadSector. +// [Files] usbmass.c +// +// 121 5/03/12 4:36a Ryanchou +// [TAG] EIP88240 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Disconnect and Connect USB Mass Driver will cause system +// hang up. +// [RootCause] The data toggle is not sync with device. +// [Solution] Remove the code that reset data toggle in +// USBMassConfigureStorageDevice. +// [Files] usbmass.c +// +// 120 5/02/12 8:12a Wilsonlee +// [TAG] EIP86793 +// [Category] New Feature +// [Description] Add the SDL token "USB_MASS_EMULATION_FOR_NO_MEDIA" for +// determine the USB mass storage device emulation type without media. +// [Files] usbmass.c, usbport.c, uhcd.c, usbdef.h, usbsrc.sdl +// +// 119 4/10/12 9:51p Wilsonlee +// [TAG] EIP84684 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Access SD Card In Auto Mode Test Fail - 1APUY012 BQA (F1) +// [RootCause] Usb module token MAX_SIZE_FOR_FLOPPY_EMULATION +// redefinition. +// [Solution] Change the token name to +// MAX_SIZE_FOR_USB_FLOPPY_EMULATION. +// [Files] usbmass.c, usbsrc.sdl +// +// 118 4/06/12 5:01a Ryanchou +// [TAG] EIP83321 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] System hangs at checkpoint 0xBd with specific USB key. +// [RootCause] The device report itself as floppy after reset, the +// subclass is UFI device and protocol is CBI with command completion +// interrupt, but there is the interrupt endpoint in the configuration +// descriptor. +// [Solution] Check if the interrupt is invalid, if it is invalid, skip +// the status transport. +// [Files] usbmass.c +// +// 116 4/05/12 7:28a Wilsonlee +// [TAG] EIP86125 +// [Category] Improvement +// [Description] Clear the flag ¡§USB_MASS_MEDIA_CHANGED¡¨when the +// sensekey is 0. +// [Files] usbmass.c +// +// 115 3/20/12 10:34p Wilsonlee +// [TAG] EIP83295 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] System will hang at B2 when do S3/S4 long run test or DOS +// reboot test. +// [RootCause] It causes the stack problem when we call +// IsUSBKeyboardBufferEmpty function. +// [Solution] Change to use pointer as parameter to +// IsUSBKeyboardBufferEmpty function. +// [Files] efiusbkb.c, efisubkb.h, usbmass.c, ehci.c +// +// 114 1/14/12 6:39a Wilsonlee +// [TAG] EIP80382 +// [Category] New Feature +// [Description] Add the SDL token "USB_MASS_EMULATION_BY_SIZE" for +// determine the USB mass storage device emulation type by size only. +// [Files] usbmass.c, usbport.c, uhcd.c, usbdef.h, usbsrc.sdl +// +// 113 1/13/12 4:25a Ryanchou +// [TAG] EIP47348 +// [Category] New Feature +// [Description] Support for USB Port Reset function. +// [Files] amiusb.c, amiusb.h, amiusbhc.c, uhci.c, usb.c, usbbus.c, +// usbbus.h, usbmass.c +// +// 112 1/06/12 12:58a Rajeshms +// [TAG] EIP62737 +// [Category] Improvement +// [Description] Added USB Device number into USB mass device name +// string based on SDL Token. +// [Files] Usb.sdl, usbport.c, usbmass.c, UsbInt13.h, UsbInt13.c, +// usbbus.c, Bfiusb.equ +// +// 111 11/08/11 7:39a Ryanchou +// [TAG] EIP71262 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] Sanyo ICR-PS401RM cause system hang at PC B4 +// [RootCause] The data length of Read Format Capacity command returned +// exceed allocation length. +// [Solution] Increase the allocation length to avoid this issue. +// [Files] usbmass.c +// +// 110 11/08/11 2:23a Ryanchou +// [TAG] EIP63706 +// [Category] Improvement +// [Description] Filter out the character if it is invisible. +// [Files] usbmass.c +// +// 109 11/05/11 7:36a Wilsonlee +// [TAG] EIP64781 +// [Category] New Feature +// [Description] Added SDL token +// SKIP_CARD_READER_CONNECT_BEEP_IF_NO_MEDIA that skip the connect beep if +// no media present in USB card reader. +// [Files] usbport.c, usbmass.c, usb.c, usbdef.h, uhcd.c, usbsrc.sdl +// +// 108 10/24/11 4:55a Ryanchou +// [TAG] EIP70814 +// [Category] Improvement +// [Description] Read a block size each time to avoid out of memory +// problem. +// [Files] usbmass.c +// +// 107 8/08/11 5:18a 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 +// +// 106 7/12/11 11:34p Ryanchou +// [TAG] EIP61388 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] FreeDOS will hang at USB storage device while selecting Force +// FDD. +// [RootCause] Hidden sector is not 0. +// [Solution] Force #of hidden sectors to 0 +// [Files] usbmass.c +// +// 105 7/12/11 6:32a Ryanchou +// [TAG] EIP63308 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] POST hang with USB WiMAX Dongle plugged on USB3.0 port +// [RootCause] The device always return invalid Command Status Wrapper. +// [Solution] Do nothing if CSW is invalid. +// [Files] usbmass.c +// +// 104 6/27/11 12:33a Ryanchou +// Correct EIP51158 changes. +// +// 103 6/22/11 1:45a Ryanchou +// [TAG] EIP59738 +// [Category] Improvement +// [Description] Support Block size other than 512 bytes USB HDD in UEFI +// mode. +// [Files] efiusbmass.c, uhci.c, usb.c, usbdef.h, usbmass.c +// +// 102 6/22/11 12:43a Ryanchou +// [TAG] EIP51158 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Samsung i7500 mobile phone can't be recognized +// [RootCause] The data packet length of UFI command is not same as SCSI +// command, the device stalls the UFI command. +// [Solution] Use SCSI command if the subclass code indicate the device +// support SCSI command set. +// [Files] usbmass.c +// +// 101 6/21/11 11:02a Ryanchou +// [TAG] EIP59579 +// [Category] Improvement +// [Description] USB device information structure should be reserved for +// the UsbIO to use even install driver fail. +// [Files] usbmass.c, usbkbd.c, usbms.c +// +// 100 6/21/11 10:54a Ryanchou +// [TAG] EIP60588 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] MS-DOS 7.1 boot by USB 2.0 Flash Drive will crash system at +// black screen. +// [RootCause] The LBA that will be read is greater than the max LBA. +// [Solution] Set the the starting LBA address to (the last LBA - number +// of blocks to process) if dStartLBA is greater than (dMaxLba - +// wNumBlks). +// [Files] usbmass.c +// +// 99 5/03/11 10:11a 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 +// +// 98 5/03/11 8:29a Ryanchou +// [TAG] EIP43711 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] USB-FDD will be recognized as USB-HDD in BIOS Setup. +// [RootCause] The media reports valid partition which is same as HDD. +// [Solution] Check the device class to fix this issue. +// [Files] usbmass.c +// +// 97 5/03/11 7:51a Ryanchou +// [TAG] EIP53416 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Iomega Zip250 hang at StatusCode 0xB4 +// [RootCause] Fail to calculate CHS values from max LBA if device is +// not ready. +// [Solution] Should not get device geometry if device is not ready. +// [Files] usbmass.c +// +// 96 4/06/11 4:29a Ryanchou +// [TAG] EIP57573 +// [Category] Bug Fix +// [Severity] Important +// [Symptom] Can't boot to USB 3.0 device +// [RootCause] Some device haven't indicate Test Unit Ready command +// failure in the CSW status. +// [Solution] Undo the EIP55440 changes and send Test Unit Ready command +// again if the Sense key is MEDIUM ERROR. +// [Files] usbmass.c +// +// 95 3/30/11 8:15a Ryanchou +// [TAG] EIP54126 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] Sometimes system hangs at checkpoint 0xB4. +// [RootCause] The bLength field of configuration descriptor is zero. +// [Solution] Check wether bLength field is zero before paring next +// descriptor. +// [Files] usb.c, usbbus.c, usbhub.c, usbkbd.c, usbmass.c, usbms.c +// +// 94 3/26/11 4:13a Ryanchou +// [TAG] EIP55440 +// [Category] Improvement +// [Description] Request Sense command should be sent only if the CSW of +// the storage command isn't Success. +// [Files] usbmass.c +// +// 93 3/16/11 11:45p Ryanchou +// [TAG] EIP52719 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] USB 3.0 HDD is detected as USB FDD +// [RootCause] Fail to read MBR while configure the device. +// [Solution] Retry 10 times. +// [Files] usbmass.c +// +// 92 1/25/11 5:30p Olegi +// [TAG] EIP52205 +// [Category] Improvement +// [Description] System can not boot from a certain FD image. Changed +// MBR validation routine to check the valid partition(s) size. +// [Files] usbmass.c +// +// 91 12/28/10 4:45a Ryanchou +// [TAG] EIP50968 +// [Category] Bug Fix +// [Severity] Normal +// [Symptom] BIOS can't boot to WD My Book 3.0. +// [RootCause] The USB 3.0 device returns sense data 0x800000 when +// device is ready. +// [Solution] Ignore the ASC and ASCQ, check the Sense key only. +// [Files] usbmass.c, xhci.h +// +// 90 12/27/10 12:44a Ryanchou +// [TAG] EIP50458 +// [Category] Improvement +// [Description] If pre skip and post skip is not zero, allocate a +// buffer for data transfer. +// [Files] usbmass.c +// +// 89 12/12/10 11:14p Ryanchou +// [TAG] EIP48166 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] POST takes a long time if USB ODD is connected. +// [RootCause] USB driver determines media not present when Sense Data +// is 0x003A02. the USB ODD returns 0x013A02 for no media condition. +// [Solution] Check Sense key and ASC only for no media condition. +// +// 88 11/11/10 8:50a Ryanchou +// [TAG] EIP47638 +// [Category] Bug Fix +// [Severity] Minor +// [Symptom] The command block of read command is invalid +// [RootCause] The command block is destoyed in USBMassSendBOTCommand. +// [Solution] Reinitialize the command block. +// [Files] usbmass.c +// +// 87 10/28/10 12:25a Ryanchou +// EIP45643: Fixed system hangs when hot plug USB mass storage quickly on +// USB 3.0 port. +// +// 86 10/21/10 10:13a Ryanchou +// EIP45121: Added xHCI Supported Protocol Capability and fix the problem +// that USB 3.0 device can't be detected. +// +// 85 10/20/10 9:16a Ryanchou +// EIP44239: Delay for the device to get ready if sense key is 0x06. +// +// 84 10/20/10 12:56a Ryanchou +// EIP45828: If the flag DEV_INFO_MASS_DEV_REGD is set, check if the +// controller type is difference between old DevInfo and new one. +// +// 83 10/12/10 2:13a Rameshr +// [TAG]- EIP 44585 +// [Category]-IMPROVEMENT +// [Description]- Number of maximum supported USB Mass Storage device +// increased from 8 to 16. +// [Files]- Uin13.bin, UsbPort.c, UsbInt13.h, Usb.c, Usbdef.h, Uasbmass.c, +// Usb.sd, usb.uni, UsbSetup.c, UsbSrc.sdl, UsbPolicy.h +// +// 82 9/07/10 4:34a Tonylo +// Remove user tags for coding standard. +// +// 81 9/01/10 8:32a Ryanchou +// EIP42297: Fixed boot to hot plug USB HDD fail. +// +// 80 8/18/10 4:23p Olegi +// Klockwork related fixes; EIP37978 +// +// 79 7/15/10 4:40a Tonylo +// EIP21649 - USB mass storage device still appear in BBS menu when USB +// legacy support is disabled. +// +// 78 6/22/10 9:31a Ryanchou +// EIP39374: Fixed USB key hot plug issue. +// +// 77 6/10/10 11:27p Ryanchou +// The USB0089 patch is for card reader, floppy doesn't need. +// +// 76 5/05/10 12:02p Olegi +// Send Start Unit command to the device when sense data is 0x020402. +// EIP36909 +// +// 75 4/12/10 4:17p Olegi +// Slow MSD may return invalid block size and max lba when device is not +// ready. Check the value of block Size and max lba returned by Read +// Capacity Command. EIP37167. +// +// 74 3/02/10 9:52a Olegi +// Bugfix in USBMassUpdateCHSFromBootRecord, EIP34794. +// +// 73 2/08/10 10:03a Olegi +// EIP33381: Implement multiple bulk endpoint in UsbIoProtocol. +// +// 72 12/18/09 12:12p Olegi +// Added SDL token USB_START_UNIT_BEFORE_MSD_ENUMERATION that controls the +// execution of bugfix for EIP25229. Disable by default. +// +// 71 11/30/09 11:33a Olegi +// Change in USBMassGetFreeMassDeviceInfoStruc, zero device info structure +// can not be returned. EIP27635. +// +// 70 10/02/09 10:49a Olegi +// Code cleanup. +// +// 69 9/09/09 11:28a Olegi +// Increased R/W command timeout delay from 10 to 20 swconds. EIP#24326 +// +// 68 8/26/09 11:52a Olegi +// xUbuntu on USB fix: Start unit command before access it. EIP#25229 +// (Core8 EIP#23581) +// +// 67 6/05/09 2:34p Olegi +// Do not enumerate device if it is not a CD-ROM and has the block size +// different from 512 Bytes. EIP#15595, iPod nano makes POST hang. +// +// 66 6/04/09 3:46p Olegi +// EIP21970: support for hotplug drives, re-inserting them to a different +// controller/port. +// +// 65 6/01/09 10:02a Olegi +// Fix for EIP#21681: The problem is in the Read Format Capacities command +// (0x23), the DataTransferLength is 0x40 in the CBW, but the Allocation +// Length is 0x80 in the CDB. Thus, the driver return Status = Phase +// Error. +// +// 64 5/21/09 5:12p Olegi +// Added HDD hotplug support. +// +// 63 5/15/09 5:50p Olegi +// EIP#21179 - failure of Transcend Card reader configuration fix. +// +// 62 4/24/09 9:32a Olegi +// Bugfix for EIP#20863. +// +// 61 2/17/09 9:18a Olegi +// +// 60 1/29/09 2:40p Olegi +// Added a check for Mass Storage device limit before creating a new LUN +// device. +// +// 59 1/23/09 10:17a Olegi +// Modified the resolution of EIP#18553 +// +// 58 1/16/09 4:04p Olegi +// - Removed the limitation of MAX_BULK_DATA_SIZE in +// USBMassIssueBulkTransfer. +// - Modified USBMassCheckDeviceReady, EIP18553. +// +// 57 11/20/08 1:12p Olegi +// EIP#17634 fix: added StartStopUnit command if TestUnitReady returns the +// value of 0x020402. +// Note: current fix is done only for the device VID 0x0DC4 DID 0x0207; in +// future we may want to extend this fix for other devices. This will +// require additional testing. +// +// 56 11/06/08 11:40a Olegi +// Fixed device configuration for multi-LUN devices. +// +// 55 9/05/08 5:39p Olegi +// +// 54 9/05/08 4:22p Olegi +// fpCallbackNotify4 is replaced with the call within SMI. +// +// 53 8/25/08 12:09p Olegi +// +// 52 8/25/08 12:00p Olegi +// Added USBMassReadCapacityBlockSizePatch function. +// +// 51 8/21/08 12:28p Olegi +// Modification in CreateLogicalUnits function: +// - At the point of the new unit creation, the Lun0 device might be +// locked by the bus driver (USBBUS.usbhc_on_timer); clear the lock +// indicator for the new LUN. +// +// 50 8/13/08 5:32p Olegi +// +// 49 8/13/08 5:27p Olegi +// Bugfix in USBMassGetFormatType. +// +// 48 7/04/08 1:08p Olegi +// Added REQUEST_SENSE command in the sequence of failed MODE_SENSE. +// +// 47 6/27/08 5:54p Olegi +// Mass Device name field is populated in DEV_INFO structure. +// +// 46 6/13/08 3:54p Olegi +// Additions related to 720KB floppy support. +// +// 45 5/16/08 12:01p Olegi +// Compliance with AMI coding standard. +// +// 44 1/30/08 12:43p Olegi +// - change in USBMassGetDeviceGeometry that returns default geometry for +// those devices with BlockSize reported as 0. +// - change in USBMassGetDeviceInfo that reports PCI bus/dev/function. +// +// 43 10/15/07 5:15p Olegi +// - Modification in USBMassCreateLogicalUnits that allows different +// emulation type for different LUNs +// - Bugfix in USBMassGetFormatType that clears bHiddenSectors field in +// multiple-LUN device +// +// 42 9/17/07 3:33p Olegi +// +// 41 7/10/07 10:25a Olegi +// +// 40 7/09/07 2:11p Olegi +// Changed the maximum data size of the BulkTransfer from 1kB to 64kB. +// +// 39 6/14/07 12:28p Olegi +// +// 38 5/29/07 6:11p Olegi +// +// 37 5/24/07 4:09p Olegi +// +// 36 5/18/07 10:53a Olegi +// Bugfix in USBMassGetDeviceGeometry that used the device ID instead of +// DEV_INFO index for USBMassGetDeviceStatus call. +// +// 35 5/05/07 1:54p Olegi +// Persistent DOS drives. +// +// 34 4/18/07 2:51p Fredericko +// Bugfix in USBMassUpdateDeviceGeometry, removed redundant code that +// corrupted memory. +// +// 32 4/17/07 11:05a Olegi +// +// 30 3/29/07 6:40p Olegi +// Modified USBMassUpdateDeviceGeometry to take care of USB floppy drive +// with no floppy in it. +// +// 29 3/20/07 12:19p Olegi +// +// 28 2/27/07 10:45a Olegi +// +// 27 12/22/06 4:05p Olegi +// Timeout implementation. +// +// 26 12/20/06 3:38p Olegi +// +// 25 12/20/06 2:30p Olegi +// +// 24 12/12/06 12:32p Olegi +// +// 22 11/09/06 4:57p Olegi +// +// 18 4/14/06 6:39p Olegi +// Conversion to be able to use x64 compiler. +// +// 17 3/21/06 12:01p Olegi +// +// 16 3/20/06 3:37p Olegi +// Version 8.5 - x64 compatible. +// +// 15 3/16/06 2:33p Olegi +// +// 14 3/06/06 6:25p Olegi +// Lun devices support modifications: supported using the index in +// DEV_INFO table, not through dedicated massLun table. +// +// 13 1/11/06 11:52a Olegi +// Setup related modifications. +// +// 12 12/19/05 10:17a Olegi +// DeviceDelayCount is Setup driven. +// +// 11 12/01/05 5:49p Olegi +// +// 10 11/10/05 11:11a Olegi +// +// 9 11/04/05 6:22p Olegi +// Multiple LUN support. +// +// 8 10/17/05 5:12p Olegi +// +// 7 9/22/05 6:28p Olegi +// +// 6 9/15/05 6:10p Andriyn +// Fix: Mass Storage name gets corrupted in setup +// +// 5 8/23/05 5:53p Olegi +// Latest USB mass storage updates from AMIBIOS USB module are applied. +// +// 4 6/03/05 9:31a Olegi +// MediaId update moved to EFI mass strorage driver. +// +// 3 5/17/05 7:51p Andriyn +// USB BUS pre-release +// +// 2 4/26/05 5:09p Olegi +// Modifications in USBMassRWVCommand, USBMassCheckDeviceReady to properly +// handle USB FDDs with no media in them. +// +// 1 3/28/05 6:20p Olegi +// +// 1 3/15/05 9:23a Olegi +// Initial VSS check-in. +// +//**************************************************************************** + +//<AMI_FHDR_START> +//----------------------------------------------------------------------------- +// +// Name: UsbMass.c +// +// Description: AMI USB Mass Storage support implementation +// +//----------------------------------------------------------------------------- +//<AMI_FHDR_END> + +#include "amidef.h" +#include "usbdef.h" +#include "amiusb.h" +#include "UsbMass.h" +#if USB_RUNTIME_DRIVER_IN_SMM +#include <AmiBufferValidationLib.h> +#endif + +extern USB_GLOBAL_DATA *gUsbData; +extern BOOLEAN gCheckUsbApiParameter; + +VOID USBMassInitialize(VOID); +UINT8 USBMassCheckForStorageDevice(DEV_INFO*, UINT8, UINT8, UINT8); +DEV_INFO* USBMassConfigureStorageDevice(HC_STRUC*, DEV_INFO*, + UINT8*, UINT16, UINT16); +UINT8 USBMassDisconnectStorageDevice(DEV_INFO*); +UINT16 USBMassSendCBICommand(DEV_INFO*, MASS_XACT_STRUC*); +UINT32 USBMassProcessBulkData(DEV_INFO*, MASS_XACT_STRUC*); +UINT8 USBMassConsumeBulkData(DEV_INFO*,UINT8,UINT16); +UINT32 USBMassIssueBOTTransaction(DEV_INFO*, MASS_XACT_STRUC*); +VOID USBMassClearBulkEndpointStall(DEV_INFO*, UINT8); +VOID USBMassBOTResetRecovery(DEV_INFO*); +UINT16 USBMassSendBOTCommand(DEV_INFO*, MASS_XACT_STRUC*); +UINT8 USBMassGetBOTStatus(DEV_INFO*, MASS_XACT_STRUC*); +UINT16 USBMassCBIGetStatus(DEV_INFO*); +UINT32 USBMassIssueCBITransaction(DEV_INFO*, MASS_XACT_STRUC*); +UINT8 USBMassReadCapacity10Command(DEV_INFO*); +UINT32 USBMassCheckDeviceReady(DEV_INFO*); +UINT32 USBMassRequestSense(DEV_INFO* fpDevInfo); +VOID USBMassSenseKeyParsing(DEV_INFO* , UINT32); +MASS_INQUIRY *USBMassInquiryCommand(DEV_INFO*); +UINT8 USBMassUpdateDeviceGeometry( DEV_INFO* fpDevInfo ); +UINT16 USBMassBOTGetMaxLUN(DEV_INFO*); +VOID USBMassIdentifyDeviceType(DEV_INFO*, UINT8*); +UINT32 USBMassIssueBulkTransfer(DEV_INFO*, UINT8, UINT8*, UINT32); +VOID iPodShufflePatch(MASS_GET_DEV_INFO*); +VOID USBMassUpdateCylinderInfo(DEV_INFO*, UINT64); +UINT8 USBMassSetDefaultGeometry(DEV_INFO*, UINT64); +UINT8 USBMassValidatePartitionTable(MASTER_BOOT_RECORD*, UINT64, MBR_PARTITION*); +UINT16 USBMassSetDefaultType(DEV_INFO*, UINT64); +VOID USBMassGetPhysicalDeviceType(DEV_INFO*, UINT8*); +UINT8 USB_SetAddress(HC_STRUC*, DEV_INFO*, UINT8); +UINT32 dabc_to_abcd(UINT32); +DEV_INFO* USBGetProperDeviceInfoStructure(DEV_INFO*, UINT8); +UINT32 USBMassTestUnitReady(DEV_INFO*); +VOID StoreUsbMassDeviceName(DEV_INFO*, UINT8*); +extern VOID AddPortNumbertoDeviceString(DEV_INFO*); +UINT8 USBMassGetConfiguration(DEV_INFO*); + +VOID MemFill (UINT8*, UINT32, UINT8); +VOID MemCopy (UINT8*, UINT8*, UINT32); +VOID* USB_MemAlloc (UINT16); +DEV_INFO* USB_GetDeviceInfoStruc(UINT8, DEV_INFO*, UINT8, HC_STRUC*); +MASS_INQUIRY* USBMassGetDeviceParameters(DEV_INFO*); + +UINT8 USB_MemFree (VOID*, UINT16); +VOID FixedDelay(UINTN); +VOID SpeakerBeep (UINT8, UINT16, HC_STRUC*); //(EIP64781+) + +static char* IOMegaZIPString = "IOMEGA ZIP"; +#define IOMegaZIPStringLength 11 + +static char* MSysDiskOnKeyString = "M-Sys DiskOnKey"; +#define MSysDiskOnKeyStringLength 17 + +BOOLEAN CheckDeviceLimit(UINT8); + +VOID +USBMassFillDriverEntries (DEV_DRIVER *fpDevDriver) +{ + fpDevDriver->bDevType = BIOS_DEV_TYPE_STORAGE; + fpDevDriver->bProtocol = 0; + fpDevDriver->pfnDeviceInit = USBMassInitialize; + fpDevDriver->pfnCheckDeviceType = USBMassCheckForStorageDevice; + fpDevDriver->pfnConfigureDevice = USBMassConfigureStorageDevice; + fpDevDriver->pfnDisconnectDevice = USBMassDisconnectStorageDevice; +} + +//<AMI_PHDR_START> +//--------------------------------------------------------------------------- +// +// FUNCTION: USBMassInitialize +// +// DESCRIPTION: This function initializes mass storage device related data +// +//--------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassInitialize () +{ + // + // Set default value for the delay. Selections are: 20,40,60,80 for 10,20,30,40 sec. + // + gUsbData->bUSBStorageDeviceDelayCount = (gUsbData->UsbMassResetDelay + 1)*10; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassCheckForStorageDevice +// +// DESCRIPTION: This routine checks for hub type device from the +// interface data provided +// +// PARAMETERS: bBaseClass USB base class code +// bSubClass USB sub-class code +// bProtocol USB protocol code +// +// RETURN: BIOS_DEV_TYPE_STORAGE type on success or 0FFH on error +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassCheckForStorageDevice ( + DEV_INFO* DevInfo, + UINT8 BaseClass, + UINT8 SubClass, + UINT8 Protocol +) +{ + if (BaseClass != BASE_CLASS_MASS_STORAGE) { + return USB_ERROR; + } + //(EIP99882+)> + if (!gUsbData->UsbSetupData.UsbMassDriverSupport) { + return USB_ERROR; + } + //<(EIP99882+) +//Skip USB mass storage devices enumeration when legacy is disabled + if (gUsbData->dUSBStateFlag & USB_FLAG_DISABLE_LEGACY_SUPPORT) { + if (LEGACY_USB_DISABLE_FOR_USB_MASS) { //(EIP93469) + return USB_ERROR; + } + } + // + // Base class is okay. Check the protocol field for supported protocols. + // Currently we support CBI, CB and BOT protocols. + // + if ((Protocol != PROTOCOL_CBI) && + (Protocol != PROTOCOL_CBI_NO_INT) && + (Protocol != PROTOCOL_BOT)) { + return USB_ERROR; + } + + return BIOS_DEV_TYPE_STORAGE; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassGetFreeMassDeviceInfoStruc +// +// Description: This function finds a free mass device info structure and +// returns the pointer to it +// +// Input: None +// +// Output: Pointer to the Mass Device Info (0 on failure) +// The number mass storage DeviceInfo structure (0-based) +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +DEV_INFO* +USBMassGetFreeMassDeviceInfoStruc( + DEV_INFO *DevInfo, + UINT8 *Indx +) +{ + DEV_INFO* Dev = &gUsbData->aDevInfoTable[1]; + UINT8 Count; + UINT8 MassDevIndx = 0; + + for (Count = 0; Count < (MAX_DEVICES-1); Count++, Dev++) { + if (!(Dev->Flag & DEV_INFO_VALID_STRUC)) { + continue; + } + if (Dev->bDeviceType == BIOS_DEV_TYPE_STORAGE) { + MassDevIndx++; + } + if (Dev == DevInfo) { + break; + } + } + if (Count == (MAX_DEVICES-1)) { + return NULL; + } + *Indx = MassDevIndx; + + return Dev; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassFindFreeMassDeviceInfo +// +// Description: This function finds a free mass device info structure and +// copies the current mass device info structure into it +// +// Input: Current mass device info structure +// +// Output: New mass device info +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +DEV_INFO* +USBMassFindFreeMassDeviceInfo( + DEV_INFO* Dev, + UINT8 *EmulIndex +) +{ + UINT8 Indx = 0; + DEV_INFO *NewDev; + + // Get the free mass device info structure pointer + NewDev = USBMassGetFreeMassDeviceInfoStruc(Dev, &Indx); + + if (NewDev == NULL) { + return NULL; // No free entry found. + } + + // Get the emulation type setup question associated with this device + ASSERT(Indx>0 && Indx<17); + if ((Indx == 0) || (Indx > 16)) { + return NULL; + } + + Dev->wEmulationOption = gUsbData->USBMassEmulationOptionTable[Indx-1]; + USB_DEBUG(DEBUG_LEVEL_3, "USBMassFindFreeMassDeviceInfo-------- indx %d, emu %d\n", Indx, Dev->wEmulationOption); + + // Set default device type and emulation type to 0 + Dev->bStorageType = 0; + Dev->fpLUN0DevInfoPtr = 0; + Dev->Flag |= DEV_INFO_DEV_PRESENT; + + *EmulIndex = Indx-1; + + return Dev; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassCreateLogicalUnits +// +// Description: This function verifies the presence of logical units (LUN) +// in the USB mass device and creates appropriate device info +// structures for them +// +// Input: fpDevInfo - Device information structure pointer +// bMaxLun - Maximum number of logical units present (non-ZERO) +// +// Output: USB_ERROR On error +// USB_SUCCESS On successfull completion +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassCreateLogicalUnits( + DEV_INFO* DevInfo, + UINT8 MaxLun, + UINT8 EmulIndex +) +{ + UINT8 Lun; + DEV_INFO* NewDevInfo; + MASS_INQUIRY *Inq; + + for (Lun = 1; Lun <= MaxLun; Lun++) { + + if (CheckDeviceLimit(BASE_CLASS_MASS_STORAGE) == TRUE) { + break; + } + // + // Get the proper device info structure + // + NewDevInfo = USBGetProperDeviceInfoStructure(DevInfo, Lun); + if (!NewDevInfo) { + return USB_ERROR; + } + // + // Check whether this device is reconnected by checking the + // valid structure flag + // + if ((NewDevInfo->Flag & DEV_INFO_MASS_DEV_REGD)) { + // + // Indicate device as connected + // + NewDevInfo->Flag |= DEV_INFO_DEV_PRESENT; + + // Change the parent HC number and port number in the existing DEV_INFO + NewDevInfo->bHCNumber = DevInfo->bHCNumber; + NewDevInfo->bHubDeviceNumber = DevInfo->bHubDeviceNumber; + NewDevInfo->bHubPortNumber = DevInfo->bHubPortNumber; + NewDevInfo->bEndpointSpeed = DevInfo->bEndpointSpeed; + NewDevInfo->wEndp0MaxPacket = DevInfo->wEndp0MaxPacket; + NewDevInfo->DevMiscInfo = DevInfo->DevMiscInfo; + NewDevInfo->bDeviceAddress = DevInfo->bDeviceAddress; + NewDevInfo->bBulkInEndpoint = DevInfo->bBulkInEndpoint; + NewDevInfo->wBulkInMaxPkt = DevInfo->wBulkInMaxPkt; + NewDevInfo->bBulkOutEndpoint = DevInfo->bBulkOutEndpoint; + NewDevInfo->wBulkOutMaxPkt = DevInfo->wBulkOutMaxPkt; + NewDevInfo->IntInEndpoint = DevInfo->IntInEndpoint; + NewDevInfo->IntInMaxPkt = DevInfo->IntInMaxPkt; + NewDevInfo->bPollInterval = DevInfo->bPollInterval; + NewDevInfo->fpLUN0DevInfoPtr = DevInfo; + } else { // This is different device, it was not reconnected + // + // Copy the old device info structure into the new one + // + MemCopy((UINT8*)DevInfo, + (UINT8*)NewDevInfo, + sizeof (DEV_INFO)); + NewDevInfo->bLUN = Lun; // Change LUN number + NewDevInfo->wEmulationOption = gUsbData->USBMassEmulationOptionTable[EmulIndex + Lun]; + MemFill(NewDevInfo->DevNameString, 64, 0); + // + // Save the Lun0 device info pointer in the current LUN + // + NewDevInfo->fpLUN0DevInfoPtr = DevInfo; + + // + // The Lun0 device might have been already locked by the + // bus (USBBUS.usbhc_on_timer), clear it for current LUN. + // + NewDevInfo->Flag &= ~DEV_INFO_DEV_BUS; + + Inq = USBMassGetDeviceParameters(NewDevInfo); + ASSERT(Inq); + StoreUsbMassDeviceName(NewDevInfo, (UINT8*)Inq + 8); + if (NewDevInfo->bStorageType == USB_MASS_DEV_CDROM) { + USBMassGetConfiguration(NewDevInfo); + } + } + + if (gUsbData->dUSBStateFlag & USB_FLAG_RUNNING_UNDER_EFI) { + if (!(NewDevInfo->Flag & DEV_INFO_IN_QUEUE)) { + USB_SmiQueuePut(NewDevInfo); + NewDevInfo->Flag |= DEV_INFO_IN_QUEUE; + } + } + } + + return USB_SUCCESS; +} + + +VOID +StoreUsbMassDeviceName( + DEV_INFO *Device, + UINT8 *Str +) +{ + UINT8 i; + UINT8 j; + + for (i = 0; i < 64; i++) { + if (Device->DevNameString[i] != 0) { + return; + } + } + + for (i = 0, j = 0; i < 32; i++) { + if (*Str == 0) { + Str++; j++; // supress leading zeroes + } + } + + for (i = 0; i < (32-j); i++, Str++) { + // supress spaces if more than one + if ((i>0) && (Device->DevNameString[i-1]==' ') && (*Str==' ')) { + i--; + continue; + } + //(EIP63706+)> + // Filter out the character if it is invisible. + if (((*Str != 0) && (*Str < 0x20)) || (*Str > 0x7E)) { + i--; + continue; + } + //<(EIP63706+) + + Device->DevNameString[i] = *Str; + } + + // + // Add Device number to the USB device string + // +#if USB_DIFFERENTIATE_IDENTICAL_DEVICE_NAME + AddPortNumbertoDeviceString(Device); +#endif +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassConfigureStorageDevice +// +// DESCRIPTION: This function checks an interface descriptor of a device +// to see if it describes a USB mass device. If the device +// is a mass storage device, then it is configured +// and initialized. +// +// PARAMETERS: pHCStruc HCStruc pointer +// pDevInfo Device information structure pointer +// pDesc Pointer to the descriptor structure +// wEnd End offset of the device descriptor +// +// RETURN: New device info structure, NULL on error +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +DEV_INFO* +USBMassConfigureStorageDevice ( + HC_STRUC* fpHCStruc, + DEV_INFO* fpDevInfo, + UINT8* fpDesc, + UINT16 wStart, + UINT16 wEnd) +{ + UINT8 bTemp; + UINT16 wRetValue; + ENDP_DESC *fpEndpDesc; + INTRF_DESC *fpIntrfDesc; + UINT8 bMaxLUN; + DEV_INFO* newDev; + MASS_INQUIRY *inq; + BOOLEAN checkFDDhotplug, checkCDROMhotplug, checkHDDhotplug; + UINT8 EmulIndex; + UINT8 i; //(EIP64781+) + + wRetValue = 0; + bMaxLUN = 0; + +// +// Set fpDevInfo->bDeviceType. This serves as a flag +// that indicates a usable interface has been found in the current +// configuration. This is needed so we can check for other usable interfaces +// in the current configuration (composite device) without trying to search +// in other configurations. +// + fpDevInfo->bDeviceType = BIOS_DEV_TYPE_STORAGE; + fpDevInfo->fpPollTDPtr = 0; + + USB_DEBUG (DEBUG_LEVEL_3, "USBMassConfigureDevice ....\n"); + + bTemp = 0x03; // bit 1 = Bulk In, bit 0 = Bulk Out + + fpDevInfo->bBulkOutEndpoint = 0; + fpDevInfo->bBulkInEndpoint = 0; + fpDevInfo->IntInEndpoint = 0; + + fpIntrfDesc = (INTRF_DESC*)(fpDesc + wStart); + fpDesc+=((CNFG_DESC*)fpDesc)->wTotalLength; // Calculate the end of descriptor block + fpEndpDesc = (ENDP_DESC*)((char*)fpIntrfDesc + fpIntrfDesc->bDescLength); + for( ;(fpEndpDesc->bDescType != DESC_TYPE_INTERFACE) && ((UINT8*)fpEndpDesc < fpDesc); + fpEndpDesc = (ENDP_DESC*)((char*)fpEndpDesc + fpEndpDesc->bDescLength)){ + + if(!(fpEndpDesc->bDescLength)) { + break; // Br if 0 length desc (should never happen, but...) + } + + if( fpEndpDesc->bDescType != DESC_TYPE_ENDPOINT ) { + continue; + } + + if ((fpEndpDesc->bEndpointFlags & EP_DESC_FLAG_TYPE_BITS) == + EP_DESC_FLAG_TYPE_BULK) { // Bit 1-0: 10 = Endpoint does bulk transfers + if(!(fpEndpDesc->bEndpointAddr & EP_DESC_ADDR_DIR_BIT)) { + // + // Bit 7: Dir. of the endpoint: 1/0 = In/Out + // If Bulk-Out endpoint already found then skip subsequent ones + // on the interface. + // + if (bTemp & 1) { + fpDevInfo->bBulkOutEndpoint = (UINT8)(fpEndpDesc->bEndpointAddr + & EP_DESC_ADDR_EP_NUM); + fpDevInfo->wBulkOutMaxPkt = fpEndpDesc->wMaxPacketSize; + bTemp &= 0xFE; + USB_DEBUG(3, "bulk out endpoint addr: %x, max packet size: %x\n", + fpDevInfo->bBulkOutEndpoint, fpDevInfo->wBulkOutMaxPkt); + } + } else { + // + // If Bulk-In endpoint already found then skip subsequent ones + // on the interface + // + if (bTemp & 2) { + fpDevInfo->bBulkInEndpoint = (UINT8)(fpEndpDesc->bEndpointAddr + & EP_DESC_ADDR_EP_NUM); + fpDevInfo->wBulkInMaxPkt = fpEndpDesc->wMaxPacketSize; + bTemp &= 0xFD; + USB_DEBUG(3, "bulk in endpoint addr: %x, max packet size: %x\n", + fpDevInfo->bBulkInEndpoint, fpDevInfo->wBulkInMaxPkt); + } + } + } + + // + // Check for and configure Interrupt endpoint if present + // + if ((fpEndpDesc->bEndpointFlags & EP_DESC_FLAG_TYPE_BITS) != + EP_DESC_FLAG_TYPE_INT) { // Bit 1-0: 10 = Endpoint does interrupt transfers + continue; + } + + if (fpEndpDesc->bEndpointAddr & EP_DESC_ADDR_DIR_BIT ) { + fpDevInfo->IntInEndpoint = fpEndpDesc->bEndpointAddr; + fpDevInfo->IntInMaxPkt = fpEndpDesc->wMaxPacketSize; + fpDevInfo->bPollInterval = fpEndpDesc->bPollInterval; + USB_DEBUG(3, "interrupt in endpoint addr: %x, max packet size: %x\n", + fpDevInfo->IntInEndpoint, fpDevInfo->IntInMaxPkt); + } + } + + // + // Check the compatibility flag for LUN support + // + if (!(fpDevInfo->wIncompatFlags & USB_INCMPT_SINGLE_LUN_DEVICE)) { + // + // If it is a BOT device, get maximum LUN supported + // + if (fpDevInfo->bProtocol == PROTOCOL_BOT) { + bMaxLUN = (UINT8)USBMassBOTGetMaxLUN(fpDevInfo); + } + } + + // + // Check whether the device is already registered. If so, proceed with current + // mass info structure + // + if (fpDevInfo->Flag & DEV_INFO_MASS_DEV_REGD) { + newDev = fpDevInfo; + + goto UMCM_MassDeviceOkay; + } + + // Find a new mass device info structure and copy the old one into the new one + // Note: this is called before GetDeviceParameters because it sets up dev->wEmulationOption + newDev = USBMassFindFreeMassDeviceInfo(fpDevInfo, &EmulIndex); + + if (newDev == NULL) goto UMCM_Error; + fpDevInfo = newDev; + + inq = USBMassGetDeviceParameters(fpDevInfo); + if (inq == NULL) goto UMCM_Error; + + // + // Do not enumerate device if it is not a CD-ROM and has the block size different from 512 Bytes + // EIP#15595, iPod nano makes POST hang. + // + //(EIP59738-)> + //if ( fpDevInfo->bPhyDevType!=USB_MASS_DEV_CDROM ) { + // if( fpDevInfo->wBlockSize!=0x200 && fpDevInfo->wBlockSize!=0xFFFF && fpDevInfo->wBlockSize!=0 ) + // goto UMCM_Error; + //} + //<(EIP59738-) + StoreUsbMassDeviceName(fpDevInfo, (UINT8*)inq+8); + + // Check for the hotplug devices current status, install the new one if needed + if ( !(gUsbData->dUSBStateFlag & USB_FLAG_RUNNING_UNDER_EFI) ) { + // Find out if FDD/HDD/CDROM hotplugging is a valid option + checkFDDhotplug = ((gUsbData->fdd_hotplug_support == SETUP_DATA_HOTPLUG_ENABLED) || + ((gUsbData->fdd_hotplug_support == SETUP_DATA_HOTPLUG_AUTO) && + (gUsbData->NumberOfFDDs == 0))) && + !(BOOLEAN)(gUsbData->dUSBStateFlag & USB_HOTPLUG_FDD_ENABLED); + + checkHDDhotplug = ((gUsbData->hdd_hotplug_support == SETUP_DATA_HOTPLUG_ENABLED) || + ((gUsbData->hdd_hotplug_support == SETUP_DATA_HOTPLUG_AUTO) && + (gUsbData->NumberOfHDDs == 0))) && + !(BOOLEAN)(gUsbData->dUSBStateFlag & USB_HOTPLUG_HDD_ENABLED); + + checkCDROMhotplug = ((gUsbData->cdrom_hotplug_support == SETUP_DATA_HOTPLUG_ENABLED) || + ((gUsbData->cdrom_hotplug_support == SETUP_DATA_HOTPLUG_AUTO) && + (gUsbData->NumberOfCDROMs == 0))) && + !(BOOLEAN)(gUsbData->dUSBStateFlag & USB_HOTPLUG_CDROM_ENABLED); + + if ( checkFDDhotplug || checkCDROMhotplug || checkHDDhotplug ) { + USB_DEBUG(DEBUG_LEVEL_3, "connecting hotplug..."); +// inq = USBMassGetDeviceParameters(fpDevInfo); +// if (inq == NULL) goto UMCM_Error; + USB_DEBUG(DEBUG_LEVEL_3, "devtype phy %d, emu %d...", fpDevInfo->bPhyDevType, fpDevInfo->bEmuType); + + if ( checkFDDhotplug && + (fpDevInfo->bStorageType == USB_MASS_DEV_ARMD) ) { + newDev = &gUsbData->FddHotplugDev; + gUsbData->dUSBStateFlag |= USB_HOTPLUG_FDD_ENABLED; + } + + if ( checkHDDhotplug && (fpDevInfo->bEmuType == USB_EMU_HDD_ONLY) ) { + newDev = &gUsbData->HddHotplugDev; + gUsbData->dUSBStateFlag |= USB_HOTPLUG_HDD_ENABLED; + } + + if ( checkCDROMhotplug && (fpDevInfo->bPhyDevType == USB_MASS_DEV_CDROM) ) { + newDev = &gUsbData->CdromHotplugDev; + gUsbData->dUSBStateFlag |= USB_HOTPLUG_CDROM_ENABLED; + } + + fpDevInfo->Flag |= DEV_INFO_HOTPLUG; + *newDev = *fpDevInfo; // Copy device into DevInfo dedicated to hotplug + fpDevInfo->Flag &= ~DEV_INFO_VALIDPRESENT; // Release fpDevInfo + fpDevInfo = newDev; + } + } + +UMCM_MassDeviceOkay: + if ( (newDev->bEmuType == USB_EMU_FLOPPY_ONLY) || + (newDev->bEmuType == USB_EMU_FORCED_FDD) ) { + gUsbData->NumberOfFDDs++; + } + + if ( newDev->bEmuType == USB_EMU_HDD_ONLY ) { + gUsbData->NumberOfHDDs++; + } + +// if ( newDev->bPhyDevType == USB_EMU_HDD_OR_FDD ) { + if ( newDev->bPhyDevType == USB_MASS_DEV_CDROM ) { + gUsbData->NumberOfCDROMs++; + USBMassGetConfiguration(newDev); + } + + if (bMaxLUN) { + USBMassCreateLogicalUnits(newDev, bMaxLUN, EmulIndex); + } + + //(EIP64781+)> + if (gUsbData->dUSBStateFlag & USB_FLAG_SKIP_CARD_READER_CONNECT_BEEP) { + if ((newDev->bLastStatus & USB_MASS_MEDIA_PRESENT) || + newDev->bPhyDevType == USB_MASS_DEV_CDROM || + newDev->bPhyDevType == USB_MASS_DEV_FDD) { + SpeakerBeep(4, 0x1000, fpHCStruc); + } else if (bMaxLUN) { + for(i = 1; i < MAX_DEVICES; i++) { + if (gUsbData->aDevInfoTable[i].fpLUN0DevInfoPtr == newDev) { + if (gUsbData->aDevInfoTable[i].bLastStatus & USB_MASS_MEDIA_PRESENT) { + SpeakerBeep(4, 0x1000, fpHCStruc); + break; + } + } + } + } + } + //<(EIP64781+) + + return newDev; + +UMCM_Error: + //USB_AbortConnectDev(fpDevInfo); //(EIP59579-) + return NULL; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassDisconnectStorageDevice +// +// DESCRIPTION: This function disconnects the storage device +// +// PARAMETERS: pDevInfo Device info structure pointer +// +// RETURN: Nothing +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassDisconnectStorageDevice ( + DEV_INFO* DevInfo +) +{ +// USB_DEBUG (DEBUG_LEVEL_5, "USBMassDisconnectDevice .... \n"); + + DevInfo->bBulkOutEndpoint = 0; + DevInfo->bBulkInEndpoint = 0; + DevInfo->IntInEndpoint = 0; + + if ((DevInfo->bEmuType == USB_EMU_FLOPPY_ONLY) || + (DevInfo->bEmuType == USB_EMU_FORCED_FDD)) { + gUsbData->NumberOfFDDs--; + } + + if (DevInfo->bEmuType == USB_EMU_HDD_ONLY) { + gUsbData->NumberOfHDDs--; + } + +// if ( newDev->bPhyDevType == USB_EMU_HDD_OR_FDD ) { + if ( DevInfo->bPhyDevType == USB_MASS_DEV_CDROM ) { + gUsbData->NumberOfCDROMs--; + } + + if (DevInfo->Flag & DEV_INFO_HOTPLUG) { + DevInfo->Flag &= ~DEV_INFO_HOTPLUG; + if (DevInfo == &gUsbData->FddHotplugDev) { + gUsbData->dUSBStateFlag &= ~USB_HOTPLUG_FDD_ENABLED; + } else if (DevInfo == &gUsbData->HddHotplugDev) { + gUsbData->dUSBStateFlag &= ~USB_HOTPLUG_HDD_ENABLED; + } else if (DevInfo == &gUsbData->CdromHotplugDev) { + gUsbData->dUSBStateFlag &= ~USB_HOTPLUG_CDROM_ENABLED; + } + } + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassClearMassXactStruc +// +// Description: This function clears the mass transaction structure +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassClearMassXactStruc( + MASS_XACT_STRUC *MassXactStruc +) +{ + UINT8 i; + UINT8* Cleaner = (UINT8*)MassXactStruc; + + for (i = 0; i < sizeof (MASS_XACT_STRUC); i++ ) { + *Cleaner++ = 0; + } +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassClearBulkEndpointStall +// +// Description: This function clears the bulk endpoint stall by sending +// CLEAR_FEATURE command to bulk endpoints +// +// Input: fpDevInfo Pointer to DeviceInfo structure +// bDirec Endpoint direction +// +// Output: Nothing +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassClearBulkEndpointStall( + DEV_INFO* DevInfo, + UINT8 Direc +) +{ + UINT8 Shift; + UINT16 EndPoint; + HC_STRUC *HcStruc; + HCD_HEADER *HcdDriver; + + HcStruc = gUsbData->HcTable[DevInfo->bHCNumber - 1]; + HcdDriver = &gUsbData->aHCDriverTable[GET_HCD_INDEX(HcStruc->bHCType)]; + + EndPoint = (UINT16)((DevInfo->bBulkInEndpoint) | BIT7); + + if (!(Direc & BIT7)) { + EndPoint = DevInfo->bBulkOutEndpoint; + } + // + // Issue clear port feature command + // + HcdDriver->pfnHCDControlTransfer(HcStruc, DevInfo, (UINT16)ENDPOINT_CLEAR_PORT_FEATURE, + EndPoint,(UINT16)ENDPOINT_HALT, 0, 0); + + //if (HcdDriver->pfnHCDClearEndpointState) { + // HcdDriver->pfnHCDClearEndpointState(HcStruc, DevInfo, (UINT8)EndPoint); + //} else { + + // + // Reset the toggle bit + // + Shift = (EndPoint & 0xF) - 1; + + if (Direc & BIT7) { + DevInfo->wDataInSync &= ~((UINT16)(1 << Shift)); + } else { + DevInfo->wDataOutSync &= ~((UINT16)(1 << Shift)); + } + + if (DevInfo->fpLUN0DevInfoPtr == NULL) { + return; + } + + if (Direc & BIT7) { + DevInfo->fpLUN0DevInfoPtr->wDataInSync &= ~((UINT16)(1 << Shift)); + } else { + DevInfo->fpLUN0DevInfoPtr->wDataOutSync &= ~((UINT16)(1 << Shift)); + } + //} + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassIssueMassTransaction +// +// Description: This function performs a mass storage transaction by +// invoking proper transaction protocol. +// +// Input: Pointer to DeviceInfo structure +// stMassXactStruc +// pCmdBuffer Pointer to command buffer +// bCmdSize Size of command block +// bXferDir Transfer direction +// fpBuffer Data buffer far pointer +// dwLength Amount of data to be transferred +// wPreSkip Number of bytes to skip before data +// wPostSkip Number of bytes to skip after data +// +// Output: Amount of data actually transferred +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +UINT32 +USBMassIssueMassTransaction( + DEV_INFO* DevInfo, + MASS_XACT_STRUC* MassXactStruc +) +{ + UINT32 DataLength; + HC_STRUC *HcStruc; + + if ((DevInfo->bProtocol == PROTOCOL_CBI) || + (DevInfo->bProtocol == PROTOCOL_CBI_NO_INT)) { + return USBMassIssueCBITransaction(DevInfo, MassXactStruc); + } + + if (DevInfo->bProtocol == PROTOCOL_BOT) { + + // Block to process periodic list to prevent that we might send the wrong + // command sequences to the same device. + gUsbData->ProcessingPeriodicList = FALSE; + + DataLength = USBMassIssueBOTTransaction(DevInfo, MassXactStruc); + + // To process any pending periodic list. + gUsbData->ProcessingPeriodicList = TRUE; + HcStruc = gUsbData->HcTable[DevInfo->bHCNumber - 1]; + (*gUsbData->aHCDriverTable + [GET_HCD_INDEX(HcStruc->bHCType)].pfnHCDProcessInterrupt)(HcStruc); + + return DataLength; + } + + return 0; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassGetDeviceParameters +// +// Description: This function gets the USB mass device parameters such as +// max cylinder, head, sector, block size and +// +// Input: Pointer to DeviceInfo structure +// +// Output: Pointer to the temp buffer, NULL on error +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +MASS_INQUIRY* +USBMassGetDeviceParameters( + DEV_INFO* DevInfo +) +{ + MASS_INQUIRY *Inq; + UINT8 i; + + for (i = 0; i < 2; i++) { + Inq = USBMassInquiryCommand(DevInfo); + if (Inq) { + break; + } + if (!(gUsbData->bLastCommandStatus & USB_BULK_STALLED)) { + break; + } + } + + //USB_DEBUG(DEBUG_LEVEL_3, "fpMassInquiry = %x\n", Inq); + + if (!Inq) { + return NULL; + } + + DevInfo->wBlockSize = 0xFFFF; // Clear the cached block size + + // + // Find the device type and update the device type structure accordingly + // + USBMassIdentifyDeviceType(DevInfo, (UINT8*)Inq); + + return Inq; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ValidateDeviceName +// +// Description: This procedure check whether device return valid device name +// if no valid device name returned, assign default name for it +// +// Input: Inquiry Data +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID ValidateDeviceName ( + MASS_INQUIRY *InqData +) +{ + static UINT8 DefaultName[] = "USB Storage Device"; + UINT8 *Name = ((UINT8*)InqData) + 8; + UINT8 *DefName = DefaultName; + UINT8 Count; + + // check for a blank name + if (*Name) return; + +// for (Count = 0; Count < 28; Count++) { +// if (*(Name + Count)) return; // Not blank +// } + + // copy default name + for (Count = 0; Count < sizeof(DefaultName); Count++) { + *(Name + Count) = *(DefName + Count); + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassGetDeviceInfo +// +// Description: This function fills and returns the mass get device info +// structure +// +// Input: fpMassGetDevInfo Pointer to the mass get info struc +// bDevAddr USB device address of the device +// +// Output: USB_SUCCESS or USB_ERROR +// fpMassGetDevInfo Pointer to the mass get info struc +// dSenseData Sense data of the last command +// bDevType Device type byte (HDD, CD, Removable) +// bEmuType Emulation type used +// fpDevId Far pointer to the device ID +// +// Notes: Initially the bDevAddr should be set to 0 as input. This +// function returns the information regarding the first mass +// storage device (if no device found it returns bDevAddr as +// 0FFh) and also updates bDevAddr to the device address of +// the current mass storage device. If no other mass storage +// device is found then the routine sets the bit7 to 1 +// indicating current information is valid but no more mass +// device found in the system. The caller can get the next +// device info if bDevAddr is not 0FFh and bit7 is not set +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassGetDeviceInfo ( + MASS_GET_DEV_INFO *MassGetDevInfo +) +{ + DEV_INFO *DevInfo; + MASS_INQUIRY *MassInq; + UINT8 Dev = MassGetDevInfo->bDevAddr; + + // + // Get the total number of Mass Storage Devices + // + MassGetDevInfo->bTotalMassDev = (UINT8)(UINTN)USB_GetDeviceInfoStruc(USB_SRCH_DEV_NUM, + 0, BIOS_DEV_TYPE_STORAGE, 0); + + if (Dev == 0) { + iPodShufflePatch(MassGetDevInfo); + } + + if (Dev & BIT7) { + return USB_ERROR; // Check for device address validity + } + + // + // If bDev = 0 then get information about first mass storage device + // + if (!Dev) { + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_TYPE, 0, BIOS_DEV_TYPE_STORAGE, 0); + //USB_DEBUG(DEBUG_LEVEL_3, "Get Mass0 info: %x\n", DevInfo); + + if (!DevInfo) { // Set as no more device found + MassGetDevInfo->bDevAddr = 0xFF; + return USB_SUCCESS; + } + } else { // Not the first mass device + // + // Get the device info structure for the matching device index + // + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_INDX, 0, Dev, 0); + ASSERT(DevInfo); + if ( (!DevInfo) || (!(DevInfo->Flag & DEV_INFO_DEV_PRESENT)) ) { // Error + return USB_ERROR; + } + // + // Get device info structure for next device + // + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_TYPE, DevInfo, BIOS_DEV_TYPE_STORAGE, 0); + ASSERT(DevInfo); + if (!DevInfo) { // Error. Exit ! + return USB_ERROR; + } + } + MassInq = USBMassGetDeviceParameters(DevInfo); + + if (!MassInq) { + return USB_ERROR; + } + + MassGetDevInfo->bDevType = DevInfo->bPhyDevType; +// MassGetDevInfo->bPhyDevType = fpDevInfo->bPhyDevType; + MassGetDevInfo->bEmuType = DevInfo->bEmuType; + MassGetDevInfo->wPciInfo = + gUsbData->HcTable[DevInfo->bHCNumber - 1]->wBusDevFuncNum; + MassGetDevInfo->fpDevId = (UINT32)(UINTN)((UINT8*)MassInq + 8); +// MassGetDevInfo->fpDevId = USBMassAdjustIdString((UINT32)MassInq + 8); + + Dev = (UINT8)(UINTN)USB_GetDeviceInfoStruc(USB_SRCH_DEV_INDX, DevInfo, 0, 0); + ASSERT(Dev); + + Dev |= BIT7; // Assume that no more mass device present + + // + // Check whether more mass device is present + // + if (USB_GetDeviceInfoStruc(USB_SRCH_DEV_TYPE, DevInfo, BIOS_DEV_TYPE_STORAGE, 0)) { + Dev &= ~BIT7; + } + + DevInfo->Flag |= DEV_INFO_MASS_DEV_REGD; + MassGetDevInfo->bDevAddr = Dev; + + *(UINTN*)MassGetDevInfo->Handle = *(UINTN*)DevInfo->Handle; + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: iPodShufflePatch +// +// Description: This check whether iPod shuffle attached to system and move +// iPod shuffle to first initial device. +// +// Input: Pointer to the mass get info struc +// +// Output: None +// +// Notes: Attaching iPod shuffle and iPod mini to system causes BIOS POST +// stop. iPod shuffle must be initialized as early as possible. +// iPod mini cosumes about 2 seconds to complete initialization, +// init iPod shuffle first to fix problem. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +iPodShufflePatch( + MASS_GET_DEV_INFO *MassGetDevInfo +) +{ + //TO BE IMPLEMENTED +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassGetDeviceStatus +// +// Description: Get USB MassStorage device status. Include Media Informarion. +// Refer to USB_MASS_MEDIA_XXX in USBDEF.H +// +// Input: Pointer to DeviceInfo structure +// +// Output: USB_ERROR or USB_SUCCESS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassGetDeviceStatus ( + MASS_GET_DEV_STATUS *MassGetDevSts +) +{ + DEV_INFO* DevInfo; + UINT8 DevAddr = MassGetDevSts->bDevAddr; + UINT8 LastStatus; + + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_INDX, 0, DevAddr, 0); + + ASSERT(DevInfo != NULL); + if (DevInfo == NULL) { + return USB_ERROR; + } + + LastStatus= DevInfo->bLastStatus; + + USBMassCheckDeviceReady(DevInfo); + + // When the Media is not present in the drive and insert the Media + // it's just sends the status as Media Present. So check the last status + // and if the media not present and current stauts is media present + // report it as Media changed + if ((LastStatus ^ DevInfo->bLastStatus) & USB_MASS_MEDIA_PRESENT) { + // Report the Last Status along with Media Changed status + DevInfo->bLastStatus |= USB_MASS_MEDIA_CHANGED; + } + + MassGetDevSts->bDeviceStatus = DevInfo->bLastStatus; + + if (DevInfo->bLastStatus & USB_MASS_MEDIA_CHANGED) { + // + // Clear Media Change Status. + // + DevInfo->bLastStatus &= (UINT8)(~USB_MASS_MEDIA_CHANGED); + } + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassCmdPassThru +// +// Description: This function issues the command/data sequence provided +// as input. This function can be used to send raw data +// to the USB mass storage device +// +// Input: fpDevInfo Pointer to Device Info structure +// fpMassCmdPassThru Pointer to the mass command pass +// through structure +// bDevAddr USB device address of the device +// dSenseData Sense data of the last command +// fpCmdBuffer Far pointer to the command buffer +// wCmdLength Command length +// fpDataBuffer Far pointer for data buffer +// wDataLength Data length +// bXferDir Data transfer direction +// +// Output: USB_SUCCESS or USB_ERROR +// dSenseData Sense data of the last command +// fpDataBuffer Updated with returned data if the transfer +// is an IN transaction +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassCmdPassThru ( + MASS_CMD_PASS_THRU *MassCmdPassThru +) +{ + UINT8 *CmdBuffer; + UINT8 *Src; + UINT8 *Dst; + DEV_INFO *DevInfo; +// UINT8 CommandRetried = FALSE; + UINT8 CmdBlkSize; + UINT8 Count; + UINT16 Data16; + UINT32 Data32; + UINT8 DevAddr = MassCmdPassThru->bDevAddr; + MASS_XACT_STRUC MassXactStruc; + + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_INDX, 0, DevAddr, 0); + if ( (!DevInfo) || (!(DevInfo->Flag & DEV_INFO_DEV_PRESENT)) ) { // Error + return USB_ERROR; + } + + CmdBlkSize = (UINT8)((MassCmdPassThru->wCmdLength + + USB_MEM_BLK_SIZE - 1) >> USB_MEM_BLK_SIZE_SHIFT); + + // + // Check whether the drive is ready for read TOC command + // + USBMassCheckDeviceReady(DevInfo); + + // + // Allocate memory for the command buffer + // + CmdBuffer = USB_MemAlloc((UINT8)GET_MEM_BLK_COUNT(CmdBlkSize)); + if (!CmdBuffer) { + return USB_ERROR; + } + + // + // Copy the command into (just allocated) mass command buffer + // + Src = (UINT8*)(UINTN)MassCmdPassThru->fpCmdBuffer; + Dst = CmdBuffer; + for (Count = 0; Count < MassCmdPassThru->wCmdLength; Count++) { + *Dst++ = *Src++; + } + + // + // Clear the common bulk transaction structure + // + USBMassClearMassXactStruc(&MassXactStruc); + + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = CmdBuffer; + MassXactStruc.bCmdSize = (UINT8)MassCmdPassThru->wCmdLength; + MassXactStruc.bXferDir = MassCmdPassThru->bXferDir; + MassXactStruc.fpBuffer = (UINT8*)(UINTN)MassCmdPassThru->fpDataBuffer; + MassXactStruc.dLength = (UINT32)MassCmdPassThru->wDataLength; + + Data16 = (UINT16)USBMassIssueMassTransaction(DevInfo, &MassXactStruc); + + // + // Update the actual data length processed/returned + // + MassCmdPassThru->wDataLength = Data16; + + Data32 = USBMassRequestSense (DevInfo); + + MassCmdPassThru->dSenseData = Data32; + + // + // Check and free command buffer + // + if (!CmdBuffer) { + return USB_ERROR; + } + + USB_MemFree(CmdBuffer, (UINT16)GET_MEM_BLK_COUNT(CmdBlkSize)); + + return USB_SUCCESS; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassReadCapacity16Command +// +// Description: This function issues read capacity of the mass storage +// +// Input: Pointer to DeviceInfo structure +// +// Output: USB_ERROR or USB_SUCCESS +// +// Notes: This routine will update the MassDeviceInfo structure +// with the block size & last LBA values obtained from the +// device +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassReadCapacity16Command ( + DEV_INFO* DevInfo +) +{ + UINT32 Data; + COMN_READ_CAPACITY_16_CMD *CmdBuffer; + MASS_XACT_STRUC MassXactStruc; + + if (!VALID_DEVINFO(DevInfo)) { + return USB_ERROR; + } + // + // Allocate memory for the command buffer + // + CmdBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(COMN_READ_CAPACITY_16_CMD)); + + if (!CmdBuffer) { + return USB_ERROR; + } + + CmdBuffer->OpCode = COMMON_READ_CAPACITY_16_OPCODE; + CmdBuffer->ServiceAction = 0x10; + CmdBuffer->AllocLength = 0x0C000000; + + // + // Clear the common bulk transaction structure + // + USBMassClearMassXactStruc(&MassXactStruc); + + // + // Change the bulk transfer delay to 10 seconds (For CDROM drives) + // + gUsbData->wBulkDataXferDelay = 10000; + + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = (UINT8*)CmdBuffer; + + MassXactStruc.bCmdSize = sizeof(COMN_RWV_16_CMD); + MassXactStruc.bXferDir = BIT7; // IN + MassXactStruc.fpBuffer = gUsbData->fpUSBTempBuffer; + MassXactStruc.dLength = 0xC; + + USB_DEBUG (DEBUG_LEVEL_3, "rcc.."); + Data = USBMassIssueMassTransaction(DevInfo, &MassXactStruc); + + // + // Reset the delay back + // + gUsbData->wBulkDataXferDelay = 0; + + if (!Data) { + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_CAPACITY_16_CMD)); + + USB_DEBUG (DEBUG_LEVEL_3, "err "); + return USB_ERROR; + } + + Data = *((UINT32*)(gUsbData->fpUSBTempBuffer + 8)); + + // + // Change little endian format to big endian(INTEL) format + // + Data = dabc_to_abcd(Data); + //(EIP37167+)> + if (!Data) { + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_CAPACITY_16_CMD)); + USB_DEBUG (DEBUG_LEVEL_3, "err "); + return USB_ERROR; + } + + DevInfo->wBlockSize = (UINT16)Data; + + USB_DEBUG(3,"BlockSize %x\n", DevInfo->wBlockSize); + + // + // Store the last LBA number in the mass info structure + // + Data = *((UINT32*)(gUsbData->fpUSBTempBuffer)); + + Data = dabc_to_abcd(Data); + + DevInfo->MaxLba = Shl64(Data, 32); + + Data = *((UINT32*)(gUsbData->fpUSBTempBuffer + 4)); + + Data = dabc_to_abcd(Data); + + DevInfo->MaxLba |= Data; + + USB_DEBUG(3,"MaxLba %lx\n", DevInfo->MaxLba); + + return USB_SUCCESS; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassReadCapacity10Command +// +// Description: This function issues read capacity of the mass storage +// +// Input: Pointer to DeviceInfo structure +// +// Output: USB_ERROR or USB_SUCCESS +// +// Notes: This routine will update the MassDeviceInfo structure +// with the block size & last LBA values obtained from the +// device +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassReadCapacity10Command ( + DEV_INFO* DevInfo +) +{ + UINT32 Data; + COMN_READ_CAPACITY_10_CMD *CmdBuffer; + MASS_XACT_STRUC MassXactStruc; + + if (!VALID_DEVINFO(DevInfo)) { + return USB_ERROR; + } + + if (Shr64(DevInfo->MaxLba, 32)) { + USBMassReadCapacity16Command(DevInfo); + return USB_SUCCESS; + } + // + // Allocate memory for the command buffer + // + CmdBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(COMN_READ_CAPACITY_10_CMD)); + + if (!CmdBuffer) { + return USB_ERROR; + } + + CmdBuffer->bOpCode = COMMON_READ_CAPACITY_10_OPCODE; + + // + // Clear the common bulk transaction structure + // + USBMassClearMassXactStruc(&MassXactStruc); + + // + // Change the bulk transfer delay to 10 seconds (For CDROM drives) + // + gUsbData->wBulkDataXferDelay = 10000; + + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = (UINT8*)CmdBuffer; + //(EIP51158+)> + if (DevInfo->bSubClass == SUB_CLASS_SCSI) { + MassXactStruc.bCmdSize = 0x0A; //SBC-3_66 + } else { + MassXactStruc.bCmdSize = sizeof (COMN_READ_CAPACITY_10_CMD); + } + //<(EIP51158+) + MassXactStruc.bXferDir = BIT7; // IN + MassXactStruc.fpBuffer = gUsbData->fpUSBTempBuffer; + MassXactStruc.dLength = 8; + + USB_DEBUG (DEBUG_LEVEL_3, "rcc.."); + Data = USBMassIssueMassTransaction(DevInfo, &MassXactStruc); + + // + // Reset the delay back + // + gUsbData->wBulkDataXferDelay = 0; + + if (!Data) { + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_CAPACITY_10_CMD)); + USB_DEBUG (DEBUG_LEVEL_3, "err "); + return USB_ERROR; + } + + USB_DEBUG(3,"Read Capacity 10 LBA %x\n", *(UINT32*)gUsbData->fpUSBTempBuffer); + + if (*(UINT32*)gUsbData->fpUSBTempBuffer == 0xFFFFFFFF) { + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_CAPACITY_10_CMD)); + USBMassReadCapacity16Command(DevInfo); + return USB_SUCCESS; + } + + Data = *((UINT32*)(gUsbData->fpUSBTempBuffer + 4)); + + // + // Change little endian format to big endian(INTEL) format + // + Data = dabc_to_abcd(Data); + //(EIP37167+)> + if (!Data) { + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_CAPACITY_10_CMD)); + USB_DEBUG(DEBUG_LEVEL_3, "err "); + return USB_ERROR; + } + //<(EIP37167+) + + DevInfo->wBlockSize = (UINT16)Data; +//USB_DEBUG(DEBUG_LEVEL_3, "succ: %x, %x\n", dData, fpDevInfo); + // + // Store the last LBA number in the mass info structure + // + Data = *((UINT32*)(gUsbData->fpUSBTempBuffer)); + + Data = dabc_to_abcd(Data); + + if (!Data) { + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_CAPACITY_10_CMD)); + USB_DEBUG (DEBUG_LEVEL_3, "err "); + return USB_ERROR; + } + + DevInfo->MaxLba = Data + 1; // 1-based value + + USB_DEBUG(DEBUG_LEVEL_3, "%x ", DevInfo->MaxLba); + + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_CAPACITY_10_CMD)); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassReadFormatCapacity +// +// Description: This function sends read format capacity command to the USB +// mass storage device +// +// Input: Pointer to DeviceInfo structure +// +// Output: USB_ERROR or USB_SUCCESS +// +// Notes: This routine will update the MassDeviceInfo structure +// with the block size & last LBA values obtained from the +// device +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassReadFormatCapacity (DEV_INFO* fpDevInfo) +{ + COMN_READ_FMT_CAPACITY *fpCmdBuffer; + UINT32 dData; + UINT16 wData; + UINT8* DataBuffer; + UINT16 DataBufferSize = 0xFC; + MASS_XACT_STRUC MassXactStruc; + + // + // Allocate memory for the command buffer + // + fpCmdBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(COMN_READ_FMT_CAPACITY)); + + if(!fpCmdBuffer) { + return USB_ERROR; + } + + DataBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT(DataBufferSize)); + if (DataBuffer == NULL) { + return USB_ERROR; + } + + fpCmdBuffer->bOpCode = COMMON_READ_FORMAT_CAPACITY_OPCODE; + fpCmdBuffer->wAllocLength = (UINT16)((DataBufferSize << 8) + (DataBufferSize >> 8)); + + USBMassClearMassXactStruc(&MassXactStruc); // Clear the common bulk transaction structure + + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = (UINT8*)fpCmdBuffer; + //(EIP51158+)> + if (fpDevInfo->bSubClass == SUB_CLASS_SCSI) { + MassXactStruc.bCmdSize = 0x0A; + } else { + MassXactStruc.bCmdSize = sizeof (COMN_READ_FMT_CAPACITY); + } + //<(EIP51158+) + MassXactStruc.bXferDir = BIT7; // IN + MassXactStruc.fpBuffer = DataBuffer; +// MassXactStruc.dLength = MAX_TEMP_BUFFER_SIZE; +// +// Temp buffer 40h-64h was used as device name string buffer. +// Limit Transaction size to 40h to prevent name string display problem. +// + MassXactStruc.dLength = DataBufferSize; + +USB_DEBUG (DEBUG_LEVEL_5, "Issue ReadFormatCapacityCommand .... \n"); + + dData = USBMassIssueMassTransaction(fpDevInfo, &MassXactStruc); + + // + // The amount of data obtained should be atleast of read format capacity structure size + // + if (dData < sizeof (COMN_READ_FMT_CAPACITY)) { + USB_MemFree(DataBuffer, GET_MEM_BLK_COUNT(DataBufferSize)); + USB_MemFree(fpCmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_FMT_CAPACITY)); + return USB_ERROR; + } + + + if ((DataBuffer[0] != 0) || (DataBuffer[1] != 0) || (DataBuffer[2] != 0) || (DataBuffer[3] < 0x08)) { + USB_MemFree(DataBuffer, GET_MEM_BLK_COUNT(DataBufferSize)); + USB_MemFree(fpCmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_FMT_CAPACITY)); + return USB_ERROR; + } + + wData = *((UINT16*)(DataBuffer + 10)); // Offset 10 + if (wData == 0) { + USB_MemFree(DataBuffer, GET_MEM_BLK_COUNT(DataBufferSize)); + USB_MemFree(fpCmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_FMT_CAPACITY)); + return USB_ERROR; + } + fpDevInfo->wBlockSize = (UINT16)((wData << 8) + (wData >> 8)); + + dData = *((UINT32*)(DataBuffer + 4)); // Offset 4 + if (dData == 0) { + USB_MemFree(DataBuffer, GET_MEM_BLK_COUNT(DataBufferSize)); + USB_MemFree(fpCmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_FMT_CAPACITY)); + return USB_ERROR; + } + dData = dabc_to_abcd(dData); + fpDevInfo->MaxLba = dData; + + if (dData == USB_144MB_FDD_MAX_LBA) { + // + // Return parameters for 1.44MB floppy + // + fpDevInfo->Heads = USB_144MB_FDD_MAX_HEADS; + fpDevInfo->NonLBAHeads = USB_144MB_FDD_MAX_HEADS; + fpDevInfo->bSectors = USB_144MB_FDD_MAX_SECTORS; + fpDevInfo->bNonLBASectors = USB_144MB_FDD_MAX_SECTORS; + fpDevInfo->wCylinders = USB_144MB_FDD_MAX_CYLINDERS; + fpDevInfo->wNonLBACylinders = USB_144MB_FDD_MAX_CYLINDERS; + fpDevInfo->bMediaType = USB_144MB_FDD_MEDIA_TYPE; + } + + USB_MemFree(DataBuffer, GET_MEM_BLK_COUNT(DataBufferSize)); + USB_MemFree(fpCmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_READ_FMT_CAPACITY)); + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassGetConfiguration +// +// Description: This function sends get configuration command to the USB +// mass storage device +// +// Input: Pointer to DeviceInfo structure +// +// Output: USB_ERROR or USB_SUCCESS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassGetConfiguration( + DEV_INFO* DevInfo +) +{ + COMMON_GET_CONFIGURATION *CmdBuffer; + UINT32 Data; + UINT8 *DataBuffer; + UINT16 DataBufferSize = 0x8; + MASS_XACT_STRUC MassXactStruc; + + // + // Allocate memory for the command buffer + // + CmdBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(COMMON_GET_CONFIGURATION)); + + if (!CmdBuffer) { + return USB_ERROR; + } + + DataBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT(DataBufferSize)); + if (DataBuffer == NULL) { + return USB_ERROR; + } + + CmdBuffer->OpCode = COMMON_GET_CONFIGURATION_OPCODE; + CmdBuffer->AllocLength = (UINT16)((DataBufferSize << 8) + (DataBufferSize >> 8)); + + USBMassClearMassXactStruc(&MassXactStruc); // Clear the common bulk transaction structure + + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = (UINT8*)CmdBuffer; + MassXactStruc.bCmdSize = sizeof (COMMON_GET_CONFIGURATION); + MassXactStruc.bXferDir = BIT7; // IN + MassXactStruc.fpBuffer = DataBuffer; + + MassXactStruc.dLength = DataBufferSize; + + USB_DEBUG(DEBUG_LEVEL_5, "Issue GetConfigurationCommand .... \n"); + + Data = USBMassIssueMassTransaction(DevInfo, &MassXactStruc); + + USB_MemFree(DataBuffer, GET_MEM_BLK_COUNT(DataBufferSize)); + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMMON_GET_CONFIGURATION)); + + if (Data) { + return USB_SUCCESS; + } else { + return USB_ERROR; + } + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassReadSector +// +// Description: This function a sector at the LBA specified +// +// Input: Pointer to DeviceInfo structure +// LBA to read +// DS:DI Data buffer pointer +// +// Output: USB_SUCCESS or USB_ERROR +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassReadSector( + DEV_INFO* DevInfo, + UINT32 Lba, + UINT8* Buffer +) +{ + COMN_RWV_10_CMD *CmdBuffer; + UINT32 Data; + UINT8 Counter; + UINT8 RetValue = USB_ERROR; + MASS_XACT_STRUC MassXactStruc; + + // + // Allocate memory for the command buffer + // + CmdBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(COMN_RWV_10_CMD)); + + if (!CmdBuffer) { + return USB_ERROR; + } + + USBMassClearMassXactStruc(&MassXactStruc); + + Counter = 10; + do { + // + // Set opcode to read command + // + CmdBuffer->bOpCode = COMMON_READ_10_OPCODE; + CmdBuffer->wTransferLength = 0x100; // Big endian to little endian: 0x0001 -> 0x0100 + Data = Lba; + // + // Change LBA from big endian to little endian + // + Data = dabc_to_abcd(Data); + + CmdBuffer->dLba = Data; + + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = (UINT8*)CmdBuffer; + //(EIP51158+)> + if (DevInfo->bSubClass == SUB_CLASS_SCSI) { + MassXactStruc.bCmdSize = 0x0A; //SBC-3_60 + } else { + MassXactStruc.bCmdSize = sizeof (COMN_RWV_10_CMD); + } + //<(EIP51158+) + MassXactStruc.bXferDir = BIT7; // IN + MassXactStruc.fpBuffer = Buffer; + MassXactStruc.dLength = DevInfo->wBlockSize; //(EIP59738) + MassXactStruc.wPreSkip = 0; + MassXactStruc.wPostSkip= 0; + + USB_DEBUG (DEBUG_LEVEL_5, "Read Sector .... \n"); + + Data = USBMassIssueMassTransaction(DevInfo, &MassXactStruc); + if(Data) { + RetValue = USB_SUCCESS; + break; // Success + } + // + // May be drive error. Try to correct from it ! + // Check whether the drive is ready for read/write/verify command + // + Data = USBMassCheckDeviceReady(DevInfo); + if (Data) { // Device is not ready. + RetValue = USB_ERROR; + break; + } + MemFill((UINT8*)CmdBuffer, sizeof(COMN_RWV_10_CMD), 0); + } while (Counter--); + + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_RWV_10_CMD)); + + return RetValue; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassUpdateCHSFromBootRecord +// +// Description: This function parses the boot record and extract the CHS +// information of the formatted media from the boot record. +// This routine checks for DOS & NTFS formats only +// +// Input: Pointer to DeviceInfo structure +// Maximum LBA in the device +// Boot record of the device +// +// Output: USB_ERROR If the boot record is un-recognizable and CHS info +// is not extracted +// USB_SUCCESS If the boot record is recognizable and CHS info +// is extracted. CHS information is updated in the +// mass device info structure +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassUpdateCHSFromBootRecord( + DEV_INFO *DevInfo, + UINT64 MaxLba, + BOOT_SECTOR *BootSetor +) +{ + UINT32 OemName = 0; + UINT32 Fat16SysType = 0; + UINT32 Fat32SysType = 0; + + if (BootSetor->Signature != 0xAA55) { + return USB_ERROR; + } + + // + // Check for valid MSDOS/MSWIN/NTFS boot record + // + MemCopy((UINT8*)BootSetor->OEMName, (UINT8*)&OemName, sizeof(OemName)); + if ((OemName != 0x4F44534D) && // "ODSM", MSDO... + (OemName != 0x4957534D) && // "IWSM", MSWI... + (OemName != 0x5346544E)) { // "SFTN", NTFS + // + // Check for valid FAT,FAT16 or FAT32 boot records + // + BootSetor->Fat.Fat16.FilSysType[3] = 0x20; + MemCopy((UINT8*)BootSetor->Fat.Fat16.FilSysType, (UINT8*)&Fat16SysType, + sizeof(Fat16SysType)); + MemCopy((UINT8*)BootSetor->Fat.Fat32.FilSysType, (UINT8*)&Fat32SysType, + sizeof(Fat32SysType)); + if ((Fat16SysType != 0x20544146) && // " TAF", FAT + (Fat32SysType != 0x33544146)) { // "3TAF", FAT3 + + // + // None of the conditions met - boot record is invalid. Return with error + // + return USB_ERROR; + } + } + + // zero check added to prevent invalid sector/head information in BPB + if (BootSetor->SecPerTrk == 0) { + return USB_ERROR; + } + + DevInfo->bSectors = (UINT8)BootSetor->SecPerTrk; + DevInfo->bNonLBASectors = (UINT8)BootSetor->SecPerTrk; + + // Wrong BPB in MSI MegaStick 128; this is preformat usility issue, wrong BPB + // information built in device. + if (BootSetor->NumHeads == 0) { + return USB_ERROR; + } + + DevInfo->Heads = BootSetor->NumHeads; + DevInfo->NonLBAHeads = BootSetor->NumHeads; + DevInfo->BpbMediaDesc = BootSetor->Media; + + USBMassUpdateCylinderInfo(DevInfo, MaxLba); + + USB_DEBUG (DEBUG_LEVEL_4, "CHS: %x %x %x\n", + DevInfo->bSectors, + DevInfo->Heads, + DevInfo->wCylinders); + + return USB_SUCCESS; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassUpdateCylinderInfo +// +// Description: This procedure update cylinder parameter for device geometry. +// head and sector paramaters are required before invoke this +// function. +// +// Input: Pointer to DeviceInfo structure +// Maximum LBA in the device +// dev->bHeads +// dev->bSectors +// +// Output: None +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassUpdateCylinderInfo( + DEV_INFO* Dev, + UINT64 Lba +) +{ + UINT64 Data; + + if ((Dev->bSectors != 0) && (Dev->Heads != 0)) { + Data = Div64(Lba, (Dev->bSectors * Dev->Heads), NULL); + } else { + Data = 0; + } + + if (Data <= 1) { + Data++; + } + if (Data > 0xFFFF) { + Data = 0xFFFF; // DOS workaround + } + Dev->wCylinders = (UINT16)Data; + Dev->wNonLBACylinders = (UINT16)Data; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassGetFormatType +// +// Description: This function reads the first sector from the mass storage +// device and identifies the formatted type. +// +// Input: Pointer to DeviceInfo structure +// Maximum LBA of the device +// +// Output: USB_ERROR If could not identify the formatted type +// USB_SUCCESS If formatted type is identified +// MSB of emu - Emulation type +// LSB of emu - Device type (Floppy, Harddisk or CDROM) +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassGetFormatType( + DEV_INFO* DevInfo, + UINT64 MaxLba, + UINT16 *Emu +) +{ + + MBR_PARTITION Partition = {0}; + + // + // Read the first sector of the device + // + if (USBMassReadSector(DevInfo, 0, gUsbData->fpUSBMassConsumeBuffer) == USB_ERROR) { + return USB_ERROR; + } + + DevInfo->bHiddenSectors = 0; + + // + // Check for validity of the partition table/boot record + // + if (*((UINT16*)(gUsbData->fpUSBMassConsumeBuffer + 0x1FE)) != 0xAA55) { + USBMassSetDefaultGeometry(DevInfo, MaxLba); + return USB_ERROR; + } + + if (USBMassValidatePartitionTable((MASTER_BOOT_RECORD*)gUsbData->fpUSBMassConsumeBuffer, + MaxLba, &Partition) == USB_SUCCESS) { + // + // Only one partition present, check the device size, if the device size + // is less than 530 MB assume FDD or else assume the emulation as HDD + // + + //if (((MaxLba >> 11) < MAX_SIZE_FOR_USB_FLOPPY_EMULATION) && //(EIP80382) + // !(gUsbData->dUSBStateFlag & USB_FLAG_MASS_NATIVE_EMULATION)) { + // emu_ = (UINT16)(USB_EMU_FORCED_FDD << 8) + USB_MASS_DEV_ARMD; + //}else { + // emu_ = (UINT16)(USB_EMU_HDD_ONLY << 8) + USB_MASS_DEV_HDD; + //} + // + // Read boot sector, set the LBA number to boot record LBA number + // + DevInfo->bHiddenSectors = Partition.StartingLba; + + if (USBMassReadSector(DevInfo, Partition.StartingLba, + gUsbData->fpUSBMassConsumeBuffer) == USB_ERROR) { + return USB_ERROR; + } + + if (USBMassUpdateCHSFromBootRecord(DevInfo, MaxLba, + (BOOT_SECTOR*)gUsbData->fpUSBMassConsumeBuffer) == USB_SUCCESS) { + if (((Shr64(MaxLba, 11)) < MAX_SIZE_FOR_USB_FLOPPY_EMULATION) && + !(gUsbData->dUSBStateFlag & USB_FLAG_MASS_NATIVE_EMULATION)) { + if (DevInfo->bSubClass != SUB_CLASS_UFI) { + *Emu = (UINT16)(USB_EMU_FORCED_FDD << 8) + USB_MASS_DEV_ARMD; + } + } + return USB_SUCCESS; + } else { // Reset hidden sector value and return HDD emulation + USBMassSetDefaultGeometry(DevInfo, MaxLba); + DevInfo->bHiddenSectors = 0; + //(EIP43711)> + //don't emulate as HDD for UFI class even media has valid partition like HDD + if (gUsbData->dUSBStateFlag & USB_FLAG_MASS_SIZE_EMULATION) { + if (DevInfo->bSubClass != SUB_CLASS_UFI) { + if ((Shr64(MaxLba, 11)) < MAX_SIZE_FOR_USB_FLOPPY_EMULATION) { + *Emu = (UINT16)(USB_EMU_FORCED_FDD << 8) + USB_MASS_DEV_ARMD; + } + } + } + //<(EIP43711) + return USB_SUCCESS; + } + } + + *Emu = USBMassSetDefaultType(DevInfo, MaxLba); + + if (USBMassUpdateCHSFromBootRecord(DevInfo, MaxLba, + (BOOT_SECTOR*)gUsbData->fpUSBMassConsumeBuffer) == USB_SUCCESS) { + //*emu = USBMassSetDefaultType(fpDevInfo, MaxLba); + if (gUsbData->dUSBStateFlag & USB_FLAG_MASS_SIZE_EMULATION) { + if (DevInfo->bSubClass != SUB_CLASS_UFI) { + if ((Shr64(MaxLba, 11)) >= MAX_SIZE_FOR_USB_FLOPPY_EMULATION) { + *Emu = (UINT16)(USB_EMU_HDD_ONLY << 8) + USB_MASS_DEV_HDD; + } + } + } + return USB_SUCCESS; + } + USBMassSetDefaultGeometry(DevInfo, MaxLba); + + //*emu = USBMassSetDefaultType(fpDevInfo, MaxLba); + + if (((Shr64(MaxLba, 11)) >= MAX_SIZE_FOR_USB_FLOPPY_EMULATION) && + !(gUsbData->dUSBStateFlag & USB_FLAG_MASS_NATIVE_EMULATION)) { + if (DevInfo->bSubClass != SUB_CLASS_UFI) { + *Emu = (UINT16)(USB_EMU_HDD_ONLY << 8) + USB_MASS_DEV_HDD; + } + DevInfo->bHiddenSectors = 0; + } + //*emu = emu_; + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassSetDefaultType +// +// Description: This procedure set device type depend on device class. +// +// Input: Pointer to DeviceInfo structure +// Maximum LBA in the device (DWORD) +// +// Output: Device Type (WORD) +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 +USBMassSetDefaultType( + DEV_INFO* Dev, + UINT64 Lba +) +{ + UINT16 DevType = (UINT16)(USB_EMU_FLOPPY_ONLY << 8) + USB_MASS_DEV_ARMD; + + if (Dev->bSubClass != SUB_CLASS_UFI) { // Check whether UFI class device + // Assume force FDD emulation for non-UFI class device + DevType = (UINT16)(USB_EMU_FORCED_FDD << 8) + USB_MASS_DEV_ARMD; + } + return DevType; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassValidatePartitionTable +// +// Description: This procedure check whether partition table valid. +// +// Input: Partition table content +// Maximum LBA in the device +// +// Output: USB_SUCCESS - partion table is valid: +// Possible valid entry count(1-based) +// Table entry counts(0-based, 4 means all entries scaned) +// Activate entry offset(Absolute offset) +// USB_ERROR - Invalid partition table +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassValidatePartitionTable( + IN MASTER_BOOT_RECORD *Mbr, + IN UINT64 Lba, + OUT MBR_PARTITION *Partition) +{ + UINT8 Index = 0; + UINT8 ActivateIndex = 0; + + // The partition table area could be all 0's, and it would pass the below tests, + // So test for that here (test sector count for all partitions). + if ((Mbr->PartRec[0].SizeInLba == 0) && + (Mbr->PartRec[1].SizeInLba == 0) && + (Mbr->PartRec[2].SizeInLba == 0) && + (Mbr->PartRec[3].SizeInLba == 0)) { + return USB_ERROR; + } + + for (Index = 0; Index < 4; Index++) { + // Boot flag check added to ensure that boot sector will not be treated as + // a valid partation table. + if (Mbr->PartRec[Index].BootIndicator & 0x7F) { + return USB_ERROR; // BootFlag should be 0x0 or 0x80 + } + + // Check whether beginning LBA is reasonable + if (Mbr->PartRec[Index].StartingLba > Lba) { + return USB_ERROR; + } + + // Check whether the size is reasonable +#if HDD_PART_SIZE_CHECK + if (Mbr->PartRec[Index].SizeInLba > Lba) { + return USB_ERROR; + } +#endif + // Update activate entry offset + if (!(Mbr->PartRec[Index].BootIndicator & 0x80)) { + continue; + } + + ActivateIndex = Index; + } + + // If no activate partition table entry found use first entry + MemCopy((UINT8*)&Mbr->PartRec[ActivateIndex], (UINT8*)Partition, + sizeof(MBR_PARTITION)); + + return USB_SUCCESS; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassSetDefaultGeometry +// +// Description: This procedure set default geometry for mass storage devices. +// +// Input: Pointer to DeviceInfo structure +// Maximum LBA in the device +// +// Output: USB_ERROR If could not identify the formatted type +// USB_SUCCESS If formatted type is identified +// Emulation type - bits 8..15 +// Device type (Floppy, Harddisk or CDROM) - bits 0..7 +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 USBMassSetDefaultGeometry(DEV_INFO* dev, UINT64 lba) +{ + if (dev->bSubClass == SUB_CLASS_UFI) { + dev->Heads = 0x02; + dev->NonLBAHeads = 0x02; + dev->bSectors = 0x12; + dev->bNonLBASectors = 0x12; + } + else { + dev->bSectors = 0x3F; + dev->bNonLBASectors = 0x3F; +// Use default heads that results in 1023 (3FF) cylinders or less for CHS + if (lba <= 0x1F7820) { + dev->Heads = 0x20; + dev->NonLBAHeads = 0x20; + } + else if ( (lba > 0x1F7820) && (lba <= 0x3EF040) ) { + dev->Heads = 0x40; + dev->NonLBAHeads = 0x40; + } + else if ( (lba > 0x3EF040) && (lba <= 0x7DE080) ) { + dev->Heads = 0x80; + dev->NonLBAHeads = 0x80; + } + else if (lba > 0x7DE080) { + dev->Heads = 0xFF; + dev->NonLBAHeads = 0xFF; + } + } + + USBMassUpdateCylinderInfo(dev, lba); + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassIdentifyDeviceType +// +// Description: This function identifies the type of the USB mass storage +// device attached from the INQUIRY data obtained from the drive +// +// Input: Pointer to DeviceInfo structure +// Pointer to the inquiry data (read from device) +// +// Output: Nothing +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassIdentifyDeviceType( + DEV_INFO* DevInfo, + UINT8* InqData +) +{ + UINT16 EmulationType; + UINT16 ForceEmulationType = 0; + UINT32 Data = 0; + UINT8 Count; + static UINT16 UsbMassEmulationTypeTable[5] = { + 0, // Auto + (USB_EMU_FLOPPY_ONLY << 8) + USB_MASS_DEV_ARMD, // Floppy + (USB_EMU_FORCED_FDD << 8) + USB_MASS_DEV_ARMD, // Forced floppy + (USB_EMU_HDD_ONLY << 8) + USB_MASS_DEV_HDD, // HDD + (USB_EMU_HDD_OR_FDD << 8) + USB_MASS_DEV_CDROM }; // CDROM + + USBMassGetPhysicalDeviceType(DevInfo, InqData); + + // Note: at this point we assume that dev->wEmulationOption is filled in + // according to the setup question selection. + if (!(DevInfo->Flag & DEV_INFO_HOTPLUG) || DevInfo->wEmulationOption) { // not auto + EmulationType = UsbMassEmulationTypeTable[DevInfo->wEmulationOption]; + ForceEmulationType = UsbMassEmulationTypeTable[DevInfo->wEmulationOption]; + } + + //USB_DEBUG(DEBUG_LEVEL_3, ">>-- IdentifyDeviceType:: Device #%d, Emul#: %d, Emul: %x\n", + // DevInfo->bDeviceAddress, DevInfo->wEmulationOption, EmulationType); +#if USB_STORAGE_DEVICE_RMB_CHECK + if (*(InqData + 1) & 0x80) { // Check RMB status + DevInfo->bLastStatus |= USB_MASS_MEDIA_REMOVEABLE; + } +#else + DevInfo->bLastStatus |= USB_MASS_MEDIA_REMOVEABLE; +#endif + DevInfo->bLastStatus |= USB_MASS_MEDIA_PRESENT; // Assume Media Present + + if (*InqData == 5) { // CDROM + // Set the type as CDROM and emulation as HDD or FDD + DevInfo->wBlockSize = 0x800; + EmulationType = (UINT16)(USB_EMU_HDD_OR_FDD << 8) + USB_MASS_DEV_CDROM; + goto UMIDT_DeviceTypeOver; + } +// ;(EIP25229+)> +#if USB_START_UNIT_BEFORE_MSD_ENUMERATION +// Start unit command before access it + USBMassStartUnitCommand(DevInfo); +#endif +// ;<(EIP25229+) + //(EIP80382)> + if (DevInfo->bSubClass == SUB_CLASS_UFI) { + EmulationType = (UINT16)(USB_EMU_FLOPPY_ONLY << 8) + USB_MASS_DEV_ARMD; + } else { + EmulationType = (UINT16)(USB_EMU_HDD_ONLY << 8) + USB_MASS_DEV_HDD; + } + //<(EIP80382) + + FixedDelay(gUsbData->UsbTimingPolicy.MassDeviceComeUp * 1000); // Device is coming up give 500ms delay + // + // Some USB mass storage devces are not fast enough to accept mass storage + // commands for parsing geometry, issue read capacity command to make sure device + // is ready for further access. (USB0089+)> + // + if (DevInfo->bSubClass != SUB_CLASS_UFI) { + for (Count = 0; Count < 30 && VALID_DEVINFO(DevInfo); Count++) { + if (USBMassReadCapacity10Command(DevInfo) == USB_SUCCESS) { + break; + } + if ((UINT16)USBMassRequestSense(DevInfo) == 0x3A02 ) { //(EIP86793) + break; // No media + } + } + } + // + // Get the block size & last LBA number + // + Data = USBMassCheckDeviceReady(DevInfo); + //(EIP86793)> + if ((UINT16)Data == 0x3A02) { // Check for media presence status + // + // Media not present. Try to get disk geometry from Format + // capacity command + // + if (!(DevInfo->wIncompatFlags & USB_INCMPT_FORMAT_CAPACITY_NOT_SUPPORTED)) { + USBMassReadFormatCapacity(DevInfo); + if ((DevInfo->MaxLba != 0) && (DevInfo->MaxLba <= USB_144MB_FDD_MAX_LBA)) { + EmulationType = (UINT16)(USB_EMU_FLOPPY_ONLY << 8) + USB_MASS_DEV_ARMD; + } else { + if (!(gUsbData->dUSBStateFlag & USB_FLAG_MASS_EMULATION_FOR_NO_MEDIA)) { + EmulationType = (UINT16)(USB_EMU_FORCED_FDD << 8) + USB_MASS_DEV_ARMD; + } + } + goto UMIDT_DeviceTypeOver; + } + } + + // + // Proceed with normal checking + // + if (!Data) { + //(EIP59738-)> + // + // Get the max LBA & block size; if block size is other than + // 512 bytes assume emulation as CDROM + // + //if ( dev->wBlockSize > 0x200 ) { + // wEmulationType = (UINT16)(USB_EMU_HDD_OR_FDD << 8) + USB_MASS_DEV_CDROM; + // goto UMIDT_DeviceTypeOver; + //} + //(<EIP59738-) + //(EIP80382)> + if (USBMassGetFormatType(DevInfo, DevInfo->MaxLba, &EmulationType) == USB_ERROR) { + // + // Find the device type by size + // + if (((Shr64(DevInfo->MaxLba, 11)) < MAX_SIZE_FOR_USB_FLOPPY_EMULATION) || + (gUsbData->dUSBStateFlag & USB_FLAG_MASS_NATIVE_EMULATION)) { + if (DevInfo->bSubClass != SUB_CLASS_UFI) { + EmulationType = (USB_EMU_FORCED_FDD << 8) + USB_MASS_DEV_ARMD; + } + } + } + } + //<(EIP80382) + //<(EIP86793) + +UMIDT_DeviceTypeOver: + + if (ForceEmulationType) { + EmulationType = ForceEmulationType; + } + DevInfo->bStorageType = (UINT8)EmulationType; + DevInfo->bEmuType = (UINT8)(EmulationType >> 8); + + USB_DEBUG(DEBUG_LEVEL_3, "<<-- IdentifyDeviceType:: Emul: %x\n", EmulationType); + + return; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassGetPhysicalDeviceType +// +// Description: This procedure classify USB mass storage devices according to +// inquiry command return data. +// +// Input: Pointer to DeviceInfo structure +// Pointer to the inquiry data (read from device) +// +// Output: Nothing +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassGetPhysicalDeviceType( + DEV_INFO* Dev, + UINT8 *Buf +) +{ + + switch (*Buf) { + case 0x0: + if (Dev->bSubClass == SUB_CLASS_UFI) { + Dev->bPhyDevType = USB_MASS_DEV_FDD; + break; + } + Dev->bPhyDevType = (*(Buf+1) & 0x80) ? + USB_MASS_DEV_ARMD : USB_MASS_DEV_HDD; + break; + case 0x5: + Dev->bPhyDevType = USB_MASS_DEV_CDROM; + break; + case 0x7: + Dev->bPhyDevType = USB_MASS_DEV_MO; + break; + case 0xE: + Dev->bPhyDevType = USB_MASS_DEV_ARMD; + break; + default: + Dev->bPhyDevType = USB_MASS_DEV_UNKNOWN; + break; + } + +} + +/* //(EIP59738-)> +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassConsumeBulkData +// +// DESCRIPTION: This function reads unwanted amount of data specified in +// the size +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// bXferDir Transfer direction +// wLength Size of data to consume +// +// RETURN: USB_ERROR or USB_SUCCESS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassConsumeBulkData( + DEV_INFO* fpDevInfo, + UINT8 bXferDir, + UINT16 wLength) +{ + UINT16 wBytesToTransfer, wBytesRemaining; + UINT32 dData; + +// +// Need to process only maximum amount of data that pUSBMassConsumeBuffer can +// handle, i.e. MAX_CONTROL_DATA_SIZE +// + wBytesRemaining = wLength; + do { + wBytesToTransfer = (UINT16)((wBytesRemaining < MAX_CONTROL_DATA_SIZE)? + wBytesRemaining : MAX_CONTROL_DATA_SIZE); + + dData = USBMassIssueBulkTransfer(fpDevInfo, bXferDir, + gUsbData->fpUSBMassConsumeBuffer, (UINT32)wBytesToTransfer); + + if ((UINT16)dData != wBytesToTransfer) { // Comparing word should be sufficient + return USB_ERROR; + } + wBytesRemaining = (UINT16)(wBytesRemaining - dData); + + } while (wBytesRemaining); + + return USB_SUCCESS; +} +*/ //<(EIP59738-) + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassProcessBulkData +// +// DESCRIPTION: This function reads/writes the data to the mass storage +// device using bulk transfer. It also takes care of pre and +// post skip bytes. +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// stMassXactStruc (given for reference) +// bXferDir Transfer direction +// fpBuffer Data buffer far pointer +// dLength Amount of data to be transferred +// wPreSkip Number of bytes to skip before data +// wPostSkip Number of bytes to skip after data +// +// RETURN: Amount of data actually transferred +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + //(EIP70814)> +UINT32 +USBMassProcessBulkData( + DEV_INFO* DevInfo, + MASS_XACT_STRUC* MassXactStruc +) + +{ + UINT32 dData; + UINT16 wTemp; + UINT8 *Buffer; + UINT8 *SrcBuffer; + UINT8 *DestBuffer; + UINT16 PreSkip; + UINT32 XferSize; + UINT32 XferedSize; + UINT32 RemainingSize; + +//USB_DEBUG (DEBUG_LEVEL_3, "Pre,%x;Post,%x\n", MassXactStruc->wPreSkip, +// MassXactStruc->wPostSkip); + // + // Check whether something we have to transfer + // + if (!MassXactStruc->dLength) { + return 0; + } + + + wTemp = gUsbData->wTimeOutValue; // Save original value + if (gUsbData->wBulkDataXferDelay) { // Check the bulk data delay specified + gUsbData->wTimeOutValue = gUsbData->wBulkDataXferDelay; + } + + if ((MassXactStruc->wPreSkip == 0) && + (MassXactStruc->wPostSkip == 0)) { + + dData = USBMassIssueBulkTransfer( + DevInfo, + MassXactStruc->bXferDir, + MassXactStruc->fpBuffer, + MassXactStruc->dLength); + } else { + // Allocate a data buffer + Buffer = USB_MemAlloc((UINT16)GET_MEM_BLK_COUNT(DevInfo->wBlockSize)); + PreSkip = MassXactStruc->wPreSkip; + RemainingSize = MassXactStruc->dLength - + (PreSkip + MassXactStruc->wPostSkip); + DestBuffer = MassXactStruc->fpBuffer; + + for (XferedSize = 0; XferedSize < MassXactStruc->dLength;) { + XferSize = MassXactStruc->dLength >= DevInfo->wBlockSize ? + DevInfo->wBlockSize : MassXactStruc->dLength; + + dData = USBMassIssueBulkTransfer( + DevInfo, + MassXactStruc->bXferDir, + Buffer, + XferSize); + if (dData == 0) { + //(EIP83295)> + //return 0; + XferedSize = 0; + break; + //<(EIP83295) + } + + XferedSize += XferSize; + if (RemainingSize == 0) { + continue; + } + + SrcBuffer = Buffer; + + if (PreSkip != 0) { + if (PreSkip >= XferSize) { + PreSkip -= XferSize; + continue; + } + + SrcBuffer += PreSkip; + XferSize -= (UINT32)PreSkip; + PreSkip = 0; + } + + XferSize = RemainingSize < XferSize ? RemainingSize : XferSize; + MemCopy(SrcBuffer, DestBuffer, XferSize); + + // Update the destination buffer pointer + DestBuffer += XferSize; + RemainingSize -= XferSize; + } + + USB_MemFree(Buffer, (UINT16)GET_MEM_BLK_COUNT(DevInfo->wBlockSize)); + + dData = XferedSize; + } + + gUsbData->wTimeOutValue = wTemp; // Restore original timeout value + gUsbData->wBulkDataXferDelay = 0; + + return dData; +} + //<(EIP70814) + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassInquiryCommand +// +// DESCRIPTION: This function sends inquiry command to the USB mass storage +// device +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// +// RETURN: Pointer to the inquiry data +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +MASS_INQUIRY* +USBMassInquiryCommand (DEV_INFO* fpDevInfo) +{ + COMMON_INQ_CMD *fpCmdBuffer; + UINT32 dData; + MASS_XACT_STRUC MassXactStruc; + + // + // Allocate memory for the command buffer + // + fpCmdBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(COMMON_INQ_CMD)); + if(!fpCmdBuffer) { + return NULL; + } + + fpCmdBuffer->bOpCode = COMMON_INQUIRY_OPCODE; + fpCmdBuffer->bAllocLength = 0x24; + + // + // Clear the common bulk transaction structure + // + USBMassClearMassXactStruc(&MassXactStruc); + + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = (UINT8*)fpCmdBuffer; + //(EIP51158+)> + if (fpDevInfo->bSubClass == SUB_CLASS_SCSI) { + MassXactStruc.bCmdSize = 0x06; //SPC-4_246 + } else { + MassXactStruc.bCmdSize = sizeof (COMMON_INQ_CMD); + } + //<(EIP51158+) + MassXactStruc.bXferDir = BIT7; // IN + MassXactStruc.fpBuffer = gUsbData->fpUSBTempBuffer + 0x40; + MassXactStruc.dLength = 0x24; + +USB_DEBUG (DEBUG_LEVEL_5, "Issue Inquiry Command .... \n"); + + dData = USBMassIssueMassTransaction(fpDevInfo, &MassXactStruc); + + USB_MemFree(fpCmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMMON_INQ_CMD)); + + + if (dData) { + return (MASS_INQUIRY*)(gUsbData->fpUSBTempBuffer + 0x40); + } + else { + return NULL; + } +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassRWVCommand +// +// Description: This function reads/writes/verifies blocks of data from the +// USB mass device specified by its device address +// +// Input: fpDevInfo Pointer to DeviceInfo structure +// bOpCode Read/Write/Verify +// fpReadData Pointer to the read command structure +// bDevAddr USB device address of the device +// dStartLBA Starting LBA address +// wNumBlks Number of blocks to process +// wPreSkipSize Number of bytes to skip before +// wPostSkipSize Number of bytes to skip after +// fpBufferPtr Far buffer pointer +// +// Output: Return code (0 - Failure, <>0 - Size read) +// fpReadData Pointer to the mass read command structure +// dSenseData Sense data of the last command +// fpBufferPtr Far buffer pointer +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 +USBMassRWVCommand( + DEV_INFO *DevInfo, + UINT8 OpCode, + VOID *DataStruc +) +{ + MASS_READ *MassDataStruc = (MASS_READ*)DataStruc; + COMN_RWV_16_CMD *CmdBuffer; + UINT64 StartLba; + UINT32 BytesToRw; + UINT32 Data; + UINT32 SenseData; + UINT8 Dir; // BIT7 0/1 - R/W + UINT8 RetryNum; + UINT16 RetCode = 0; + UINT8 CmdSize; + MASS_XACT_STRUC MassXactStruc; + + EFI_STATUS EfiStatus = EFI_SUCCESS; + +#if USB_RUNTIME_DRIVER_IN_SMM + if (gCheckUsbApiParameter) { + EfiStatus = AmiValidateMemoryBuffer((VOID*)MassDataStruc->BufferPtr, + (UINT32)MassDataStruc->NumBlks * (UINT32)DevInfo->wBlockSize); + if (EFI_ERROR(EfiStatus)) { + USB_DEBUG(3, "UsbMassRWVCommand Invalid Pointer, Buffer is in SMRAM.\n"); + return 0; + } + gCheckUsbApiParameter = TRUE; + } +#endif + + // + // Set the sense code as 0 + // + MassDataStruc->SenseData = 0; + + // + // Allocate memory for the command buffer + // + CmdBuffer = (COMN_RWV_16_CMD*)USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(COMN_RWV_16_CMD)); + if (!CmdBuffer) { + return 0; + } + + for (RetryNum = 0; RetryNum < 2; RetryNum++) { + // + // Load command into (just allocated) mass command buffer + // + CmdBuffer->OpCode = OpCode; + StartLba = MassDataStruc->StartLba; + //(EIP60588+)> + if (StartLba > (DevInfo->MaxLba - MassDataStruc->NumBlks)) { + StartLba = DevInfo->MaxLba - MassDataStruc->NumBlks; + } + //<(EIP60588+) + // + // If the "Forced FDD" option is selected that means the device has + // to be emulated as a floppy drive even though it has a HDD emulated + // image. This is accomplished by hiding the first cylinder totally. + // The partition table is in the first cylinder. LBA value for all + // the requests to the device will be offset with the number of sectors + // in the cylinder. + // + + // + // Check for forced floppy emulated device and change LBA accordingly + // + if (DevInfo->bEmuType == USB_EMU_FORCED_FDD) { + if (!(gUsbData->dUSBStateFlag & USB_FLAG_RUNNING_UNDER_EFI)) //(EIP113379+) + // + // Skip first track in case of floppy emulation + // + StartLba += DevInfo->bHiddenSectors; + } + + // + // Check the validity of the block size + // + if (DevInfo->wBlockSize != 0xFFFF) { + // + // Change big endian format (INTEL) to little endian format + // + if ((OpCode == COMMON_READ_10_OPCODE) || + (OpCode == COMMON_WRITE_10_OPCODE) || + (OpCode == COMMON_VERIFY_10_OPCODE)) { + ((COMN_RWV_10_CMD*)CmdBuffer)->dLba = dabc_to_abcd((UINT32)StartLba); + ((COMN_RWV_10_CMD*)CmdBuffer)->wTransferLength = + (UINT16)((MassDataStruc->NumBlks << 8) + (MassDataStruc->NumBlks >> 8)); + if (DevInfo->bSubClass == SUB_CLASS_SCSI) { + CmdSize = 0x0A; //SBC-3_60 + } else { + CmdSize = sizeof (COMN_RWV_10_CMD); + } + } else { + CmdBuffer->Lba = Shl64(dabc_to_abcd((UINT32)StartLba), 32); + CmdBuffer->Lba |= dabc_to_abcd((UINT32)Shr64(StartLba, 32)); + CmdBuffer->TransferLength = dabc_to_abcd(MassDataStruc->NumBlks); + CmdSize = sizeof(COMN_RWV_16_CMD); + } + // + // Verify command does not need delay + // + gUsbData->wBulkDataXferDelay = 0; + + // + // Calculate number of bytes to transfer (for verify command nothing + // to read/write. + // + BytesToRw = 0; + if ((OpCode != COMMON_VERIFY_10_OPCODE) && + (OpCode != COMMON_VERIFY_16_OPCODE)){ + // + // Read/write command may need long time delay + // + gUsbData->wBulkDataXferDelay = 20000; + BytesToRw = (UINT32)MassDataStruc->NumBlks * (UINT32)DevInfo->wBlockSize; + } + + // + // Set the direction properly + // + if ((OpCode == COMMON_WRITE_10_OPCODE) || + (OpCode == COMMON_WRITE_16_OPCODE)) { + Dir = 0; + } else { + Dir = BIT7; + } + + // + // Fill the common bulk transaction structure + // Fill Command buffer address & size + // + MassXactStruc.fpCmdBuffer = (UINT8*)CmdBuffer; + MassXactStruc.bCmdSize = CmdSize; + MassXactStruc.bXferDir = Dir; + MassXactStruc.fpBuffer = (UINT8*)(UINTN)MassDataStruc->BufferPtr; + MassXactStruc.wPreSkip = MassDataStruc->PreSkipSize; + MassXactStruc.wPostSkip = MassDataStruc->PostSkipSize; + MassXactStruc.dLength = BytesToRw; + + Data = USBMassIssueMassTransaction(DevInfo, &MassXactStruc); + + if ((Data) && ((RetryNum != 0) || (Data == BytesToRw))) { // Some data processed. Set return value + + // + // Bug fix for installing Linux from USB CD-ROM. + // Linux64Bit Boot + // If data read is 64K or higher return 0FFFFh + // + if (Data >= 0x010000) { + Data = 0xFFFF; + } + + RetCode = (UINT16)Data; + // + // Check for forced floppy emulated device + // + if ((DevInfo->bEmuType == USB_EMU_FORCED_FDD) && + (OpCode == COMMON_READ_10_OPCODE) && + (MassDataStruc->StartLba == 0) && + !(gUsbData->dUSBStateFlag & USB_FLAG_RUNNING_UNDER_EFI) ) { //(EIP113379+) + // + // This is a floppy emulated ZIP drive, with read to + // first sector. Update the boot record so that floppy + // emulation is okay. + // + // Force #of hidden sectors to 0 + // + *(UINT32*)((UINTN)MassDataStruc->BufferPtr + 0xB + 0x11) = 0; + + // + // FreeDOS workaround + // + if ((*(UINT32*)((UINTN)MassDataStruc->BufferPtr + 3)==0x65657246) && // 'eerF' + (*(UINT32*)((UINTN)MassDataStruc->BufferPtr + 7)==0x20534F44) && // ' SOD' + (*(UINT32*)((UINTN)MassDataStruc->BufferPtr + 0x3A)!=0x20202032)) { //(EIP61388) + *(UINT16*)((UINTN)MassDataStruc->BufferPtr + 0x42) = + *(UINT16*)((UINTN)MassDataStruc->BufferPtr + 0x42)-(UINT16)DevInfo->bHiddenSectors; + *(UINT16*)((UINTN)MassDataStruc->BufferPtr + 0x46) = + *(UINT16*)((UINTN)MassDataStruc->BufferPtr + 0x46)-(UINT16)DevInfo->bHiddenSectors; + *(UINT16*)((UINTN)MassDataStruc->BufferPtr + 0x4A) = + *(UINT16*)((UINTN)MassDataStruc->BufferPtr + 0x4A)-(UINT16)DevInfo->bHiddenSectors; + } + // + // Force physical drive# to 0 + // For FAT32, physical drive number is present in offset 40h + // + if ((*(UINT32*)((UINTN)MassDataStruc->BufferPtr + 0x52)) == + 0x33544146) { // "3TAF", FAT3 + *(UINT8*)((UINTN)MassDataStruc->BufferPtr + 0x40) = 0; + } + else { + *(UINT8*)((UINTN)MassDataStruc->BufferPtr + 0x24) = 0; + } + } + break; // dData ready + + } + else { // Error condition: dData = 0, RetCode = 0 + // + // Check for error + // + SenseData = USBMassRequestSense(DevInfo); + MassDataStruc->SenseData = SenseData; + Data = SenseData; + + // + // Check for write protect error code + // + if ((UINT8)SenseData == 7) { + break; + } + + if (((OpCode == COMMON_VERIFY_10_OPCODE) || + (OpCode == COMMON_VERIFY_16_OPCODE)) && (!SenseData)) { + // + // This is verify command so no data to send or read and + // also sense data is 0. So set return value to success. + // + RetCode = 0xFFFF; + break; + } + } + } // fpDevInfo->wBlockSize != 0xFFFF + + // + // UPRCC_ProceedIfRW + // May be drive error, try to correct it + // Check whether the drive is ready for read/write/verify command + // + Data = USBMassCheckDeviceReady(DevInfo); + MassDataStruc->SenseData = Data; + + if (Data) { + break; // Return error + } + + MemFill((UINT8*)CmdBuffer, sizeof(COMN_RWV_16_CMD), 0); + } // Fof loop + + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_RWV_16_CMD)); + + return RetCode; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassStartUnitCommand +// +// DESCRIPTION: This function sends the start unit command to the mass device +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// +// RETURN: Sense data: 0 - Success, <>0 - Error +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 +USBMassStartUnitCommand (DEV_INFO* fpDevInfo) +{ + COMMON_START_STOP_UNIT_CMD *fpCmdBuffer; + MASS_XACT_STRUC MassXactStruc; +// MASS_START_STOP_UNIT *fpStartData; + + USB_DEBUG (DEBUG_LEVEL_5, "USBMProStartUnitCommand .... \n"); + + // + // Check the compatibility flag for start unit command not supported + // + if (fpDevInfo->wIncompatFlags & USB_INCMPT_START_UNIT_NOT_SUPPORTED) { + return USB_SUCCESS; + } + + // + // Allocate memory for the command buffer + // + fpCmdBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(COMMON_START_STOP_UNIT_CMD)); + if (!fpCmdBuffer) { + return USB_ERROR; + } + + // + // Load command into (just allocated) mass command buffer + // + fpCmdBuffer->bOpCode = COMMON_START_STOP_UNIT_OPCODE; + fpCmdBuffer->bStart = 1; + + // + // Clear the common bulk transaction structure + // + USBMassClearMassXactStruc(&MassXactStruc); + gUsbData->wBulkDataXferDelay = 10000; // Start unit command may need long time delay + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = (UINT8*)fpCmdBuffer; + //(EIP51158+)> + if (fpDevInfo->bSubClass == SUB_CLASS_SCSI) { + MassXactStruc.bCmdSize = 0x06; //SBC-3_77 + } else { + MassXactStruc.bCmdSize = sizeof (COMMON_START_STOP_UNIT_CMD); + } + //<(EIP51158+) + USBMassIssueMassTransaction(fpDevInfo, &MassXactStruc); + + // + // No data to read/write. So do not process return code. + // Check and free command buffer + // + USB_MemFree(fpCmdBuffer,GET_MEM_BLK_COUNT_STRUC(COMMON_START_STOP_UNIT_CMD)); + + return USBMassRequestSense(fpDevInfo); +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassModeSense +// +// DESCRIPTION: This function requests the mode sense data page number 5 from +// the USB mass storage device +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// +// RETURN: USB_SUCCESS/USB_ERROR on Success/Failure +// fpModeSenseData Pointer to the mode sense data +// dSenseData Sense data +// bNumHeads Number of heads +// wNumCylinders Number of cylinders +// bNumSectors Number of sectors +// wBytesPerSector Number of bytes per sector +// bMediaType Media type +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassModeSense( + DEV_INFO *fpDevInfo, + MASS_MODE_SENSE *fpModeSenseData) +{ + UINT32 dData; + UINT8 bRetCode; + COMN_MODE_SENSE_10CMD *fpCmdBuffer; + MODE_SENSE_10_HEADER *fpModeSense10_Header; + PAGE_CODE_5 *fpPageCode5; + MASS_XACT_STRUC MassXactStruc; + + dData = 0; + bRetCode = USB_ERROR; + + fpCmdBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(COMN_MODE_SENSE_10CMD)); + if (!fpCmdBuffer) { + return USB_ERROR; + } + + // + // Load command into (just allocated) mass command buffer + // + fpCmdBuffer->bOpCode = COMMON_MODE_SENSE_10_OPCODE; + fpCmdBuffer->wAllocLength = 0x2800; // Allocation Length = 40 bytes (0x28) + fpCmdBuffer->bPageCode = 5; // Page code + + // + // Clear the common bulk transaction structure + // + USBMassClearMassXactStruc(&MassXactStruc); + + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = (UINT8*)fpCmdBuffer; + //(EIP51158+)> + if (fpDevInfo->bSubClass == SUB_CLASS_SCSI) { + MassXactStruc.bCmdSize = 0x0A; //SPC-4_280 + } else { + MassXactStruc.bCmdSize = sizeof (COMN_MODE_SENSE_10CMD); + } + //<(EIP51158+) + MassXactStruc.bXferDir = BIT7; // IN + MassXactStruc.fpBuffer = gUsbData->fpUSBTempBuffer; + MassXactStruc.dLength = 0x28; + + // + // Bulk in, with temp buffer & 40 bytes of data to read + // + dData = USBMassIssueMassTransaction(fpDevInfo, &MassXactStruc); + + if (!dData) { + USBMassRequestSense( fpDevInfo ); + USB_MemFree(fpCmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_MODE_SENSE_10CMD)); + return USB_ERROR; + } + + // + // Fill in the output data + // + fpModeSense10_Header = (MODE_SENSE_10_HEADER*)gUsbData->fpUSBTempBuffer; + + // + // Process media type + // + fpModeSenseData->bMediaType = fpModeSense10_Header->bMediaType; + + // + // Position to the correct page code starting location + // + fpPageCode5 = (PAGE_CODE_5*)((UINT8*)fpModeSense10_Header + + fpModeSense10_Header->wBlkDescSize + + sizeof (MODE_SENSE_10_HEADER)); +// USB_DEBUG (DEBUG_LEVEL_3, "USBMassModeSense .... fpPageCode5->bPageCode %x\n",fpPageCode5->bPageCode); + + bRetCode = USB_ERROR; + if(fpPageCode5->bPageCode == 5) { + // + // Process number of bytes per sector (the block size) + // + fpModeSenseData->wBytesPerSector = (UINT16)((fpPageCode5->wBlockSize << 8) + + (fpPageCode5->wBlockSize >>8)); + // + // Process number of heads and number of sectors/track + // + fpModeSenseData->bNumHeads = fpPageCode5->bHeads; + fpModeSenseData->bNumSectors = fpPageCode5->bSectors; + + // + // Process number of cylinders + // + fpModeSenseData->wNumCylinders = (UINT16)((fpPageCode5->wCylinders << 8) + + (fpPageCode5->wCylinders >> 8)); + bRetCode = USB_SUCCESS; + } + + fpModeSenseData->dSenseData = USBMassRequestSense( fpDevInfo ); + + USB_MemFree(fpCmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_MODE_SENSE_10CMD)); +// USB_DEBUG (DEBUG_LEVEL_5, "USBMProModeSense .... wRetCode %x\n",wRetCode); + + return bRetCode; + +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassRequestSense +// +// DESCRIPTION: This function sends request sense command and returns +// the sense key information +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// +// RETURN: Sense data +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 +USBMassRequestSense(DEV_INFO* fpDevInfo) +{ + UINT32 dData; + UINT8 *fpDataBuffer; + COMMON_REQ_SENSE_CMD *fpCmdBuffer; + MASS_XACT_STRUC MassXactStruc; + + // + // Allocate memory for the command buffer + // + fpCmdBuffer = (COMMON_REQ_SENSE_CMD*)USB_MemAlloc(GET_MEM_BLK_COUNT_STRUC(COMMON_REQ_SENSE_CMD)); + if(!fpCmdBuffer) { + return USB_ERROR; // Error - return no sense data <>0 + } + + fpDataBuffer = USB_MemAlloc(GET_MEM_BLK_COUNT(1)); + if(!fpDataBuffer) { + return USB_ERROR; // Error - return no sense data <>0 + } + + // + // Load command into (just allocated) mass command buffer + // + fpCmdBuffer->bOpCode = COMMON_REQUEST_SENSE_OPCODE; + fpCmdBuffer->bAllocLength = 0x12; // Length of transfer + + USBMassClearMassXactStruc(&MassXactStruc); // Clear the common bulk transaction structure + + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = (UINT8*)fpCmdBuffer; + //(EIP51158+)> + if (fpDevInfo->bSubClass == SUB_CLASS_SCSI) { + MassXactStruc.bCmdSize = 0x06; //SPC-4_350 + } else { + MassXactStruc.bCmdSize = sizeof (COMMON_REQ_SENSE_CMD); + } + //<(EIP51158+) + MassXactStruc.bXferDir = BIT7; // IN + MassXactStruc.fpBuffer = fpDataBuffer; + MassXactStruc.dLength = 0x12; + + // + // Bulk in, with locally allocated temp buffer & 12h bytes of data to read + // + dData = USBMassIssueMassTransaction(fpDevInfo, &MassXactStruc); + + if(dData) { + // + // Form the return value: + // Bit 0..7 - Sense key (offset 002d) + // Bit 8..15 - ASC code (offset 012d) + // Bit 16..23 - ASCQ code (offset 013d) + // + dData = (UINT32)(fpDataBuffer[2] + + (fpDataBuffer[12] << 8) + + (fpDataBuffer[13] << 16)); + USBMassSenseKeyParsing(fpDevInfo, dData); + } + //(EIP20863+)> + else + dData = USB_ERROR; + //<(EIP20863+) + + USB_MemFree(fpCmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMMON_REQ_SENSE_CMD)); + USB_MemFree(fpDataBuffer, GET_MEM_BLK_COUNT(1)); + + return dData; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassSenseKeyParsing +// +// DESCRIPTION: Translate USB sense key to USB MassStorage status. +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// dCode[23..16] ASCQ +// dCode[15..08] ASC +// dCode[07..00] Sense Code + +// +// RETURN: Sense data +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassSenseKeyParsing(DEV_INFO* fpDevInfo, UINT32 dCode) +{ + if ((UINT16)dCode == 0x3A02) { //(EIP86793) + fpDevInfo->bLastStatus &= ~USB_MASS_MEDIA_PRESENT; + } + if((UINT16)dCode == 0x2806) { + fpDevInfo->bLastStatus |= (USB_MASS_MEDIA_PRESENT | USB_MASS_MEDIA_CHANGED); + } + //(EIP86125+)> + if(dCode == 0) { + fpDevInfo->bLastStatus |= USB_MASS_MEDIA_PRESENT; + } + //<(EIP86125+) +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassTestUnitReady +// +// DESCRIPTION: This function sends test unit ready command +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// +// RETURN: Sense data +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 +USBMassTestUnitReady( + DEV_INFO* DevInfo +) +{ + COMN_TEST_UNIT_READY_CMD *CmdBuffer; + UINT32 Data; + MASS_XACT_STRUC MassXactStruc; + + CmdBuffer = (COMN_TEST_UNIT_READY_CMD*)USB_MemAlloc( + GET_MEM_BLK_COUNT_STRUC(COMN_TEST_UNIT_READY_CMD)); + if (!CmdBuffer) { + return USB_ERROR; // Error - return no sense data + } + + CmdBuffer->bOpCode = COMMON_TEST_UNIT_READY_OPCODE; + USB_DEBUG (DEBUG_LEVEL_5, "USBMassTestUnitReady .... \n"); + + USBMassClearMassXactStruc(&MassXactStruc); // Clear the common bulk transaction structure + + // + // Fill the common bulk transaction structure + // + MassXactStruc.fpCmdBuffer = (UINT8*)CmdBuffer; + //(EIP51158+)> + if (DevInfo->bSubClass == SUB_CLASS_SCSI) { + MassXactStruc.bCmdSize = 0x06; //SPC-4_368 + } else { + MassXactStruc.bCmdSize = sizeof (COMN_TEST_UNIT_READY_CMD); + } + //<(EIP51158+) + Data = USBMassIssueMassTransaction(DevInfo, &MassXactStruc); + + USB_MemFree(CmdBuffer, GET_MEM_BLK_COUNT_STRUC(COMN_TEST_UNIT_READY_CMD)); + + if ((Data == USB_ERROR) || (DevInfo->bProtocol == PROTOCOL_CBI) || + (DevInfo->bProtocol == PROTOCOL_CBI_NO_INT)) { + Data = USBMassRequestSense(DevInfo); + } + return Data; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassCheckDeviceReady +// +// Description: This function makes sure the device is ready for next +// command +// +// Input: fpDevInfo Pointer to DeviceInfo structure +// +// Output: Sense code +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 +USBMassCheckDeviceReady (DEV_INFO* fpDevInfo) +{ + UINT8 count, nomedia_count; + UINT8 NotReadyCount; //(EIP101623+) + UINT32 dData = 0; + + count = gUsbData->bUSBStorageDeviceDelayCount; + nomedia_count = 3; + NotReadyCount = 3; //(EIP101623+) + while (count) { + if (fpDevInfo->wIncompatFlags & USB_INCMPT_TEST_UNIT_READY_FAILED) { + break; // consider device is ready + } + + // + // Issue test unit ready command and check the return value + // + dData = USBMassTestUnitReady( fpDevInfo ); +//USB_DEBUG(DEBUG_LEVEL_3, "(%d)tur..%x ", fpDevInfo->bDeviceAddress, dData); + if ((UINT8)dData == 0) { // Device ready + break; + } + // + // Device is not ready. + // Check for getting ready/reset command occurence in dData: + // Bit 0..7 - Sense Code + // Bit 8..15 - Additional Sense Code (ASC) + // Bit 16..23 - Additional Sense Code Qualifier (ASCQ) + // + if ((UINT16)dData == 0x2806) { + // + // Send Start/Stop Unit command to UFI class device only + // + if (fpDevInfo->bSubClass == SUB_CLASS_UFI) { + USBMassStartUnitCommand (fpDevInfo); + } + FixedDelay(100 * 1000); // 100 msec delay + count--; + continue; + } + if ((UINT16)dData == 0x3A02) { // Media is not present + nomedia_count--; + if (nomedia_count == 0) return dData; // No media + FixedDelay(20 * 1000); // 20 msec delay + count--; + continue; + } + + if (dData == 0x020402) + { + USBMassStartUnitCommand (fpDevInfo); + FixedDelay(100 * 1000); + count--; + continue; + } + + if ((UINT16)dData == 0x1103) { + FixedDelay(100 * 1000); + count--; + continue; + } + + // + // Check whether we can recover from this error condition + // Currently only recoverable error condition are + // 1. Device is getting ready (010402) + // 2. Device reset occurred (002906) + // + if (dData != 0x010402) { + // + // Check for write protected command + // + if ( (UINT8)dData == 7 ) { + break; + } + if (((UINT8)dData != 0x06) && ((UINT8)dData != 0x02)) { + return dData; + } + } + + //(EIP101623+)> + if (dData == 0x02) { + NotReadyCount--; + if (NotReadyCount == 0) return dData; + FixedDelay(20 * 1000); // 20 msec delay + count--; + continue; + } + //<(EIP101623+) + + // + // Prepare for the next itaration + // Delay for the device to get ready + // + FixedDelay(1000 * 1000); // 1 sec delay + count--; + } // while + //(EIP53416+)> + if (count == 0) { + return dData; + } + //<(EIP53416+) + return USBMassUpdateDeviceGeometry(fpDevInfo); +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassUpdateParamUsingModeSense +// +// Description: This function obtains the device geometry from the device +// using mode sense command and updates the global variables +// +// Input: Pointer to DeviceInfo structure +// +// Output: USB_ERROR On error +// USB_SUCCESS On success +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassUpdateParamUsingModeSense(DEV_INFO* fpDevInfo) +{ + MASS_MODE_SENSE ModeSenseData; + + gUsbData->wModeSenseCylinders = gUsbData->bModeSenseHeads = + gUsbData->bModeSenseSectors = 0; + // + // Check the compatibility flag for mode sense support + // + if (fpDevInfo->wIncompatFlags & USB_INCMPT_MODE_SENSE_NOT_SUPPORTED) { + return USB_SUCCESS; + } + + // + // CDROM devices never support mode sense page code 5 (Flexible disk page) + // so skip it + // + if (fpDevInfo->bStorageType == USB_MASS_DEV_CDROM) { + return USB_ERROR; + } + + // + // Issue mode sense command + // + if (USBMassModeSense(fpDevInfo, &ModeSenseData)) { +USB_DEBUG(DEBUG_LEVEL_3, "ms..err "); + return USB_ERROR; + } + + // + // Mode sense is supported. Update the local structure. + // + gUsbData->wModeSenseCylinders = ModeSenseData.wNumCylinders; // Number of cylinders + gUsbData->bModeSenseHeads = ModeSenseData.bNumHeads; // Number of heads + gUsbData->bModeSenseSectors = ModeSenseData.bNumSectors; // Number of sectors + gUsbData->wModeSenseBlockSize = ModeSenseData.wBytesPerSector;// Number of bytes per sector + gUsbData->bDiskMediaType = ModeSenseData.bMediaType; // Media type + + +USB_DEBUG(DEBUG_LEVEL_4, "ms..%x %x %x %x %x ", + gUsbData->wModeSenseCylinders, + gUsbData->bModeSenseHeads, + gUsbData->bModeSenseSectors, + gUsbData->wModeSenseBlockSize, + gUsbData->bDiskMediaType +); + + if (fpDevInfo->bStorageType == USB_MASS_DEV_HDD) { + gUsbData->bDiskMediaType = USB_UNKNOWN_MEDIA_TYPE; + } + + // + // Calculate and update Max LBA + // + gUsbData->dModeSenseMaxLBA = + (UINT32)(ModeSenseData.wNumCylinders * + ModeSenseData.bNumHeads * ModeSenseData.bNumSectors); + // + // Set the flag indicating mode sense is executed + // + gUsbData->bGeometryCommandStatus |= MODE_SENSE_COMMAND_EXECUTED; + + return USB_SUCCESS; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassUpdateParamUsingReadCapacity +// +// Description: This function obtains the device geometry from the device +// using read capacity command and updates the global variables +// +// Input: Pointer to DeviceInfo structure +// +// Output: USB_ERROR On error +// USB_SUCCESS On success +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassUpdateParamUsingReadCapacity( + DEV_INFO* DevInfo +) +{ + UINT8 Sectors; + UINT8 Heads; + + // + // Either mode sense not supported or failed. Try read capacity + // Issue read capacity command + // + if (USBMassReadCapacity10Command(DevInfo)) { + return USB_ERROR; + } + + // + // Set the flag indicating read capacity is executed + // + gUsbData->bGeometryCommandStatus |= READ_CAPACITY_COMMAND_EXECUTED; + + // + // Max LBA & block size are updated in MassDeviceInfo structure + // + if (DevInfo->MaxLba < 0x4000) { // last LBA < 16MB + switch (DevInfo->MaxLba) { + case USB_144MB_FDD_MAX_LBA: + gUsbData->bReadCapHeads = USB_144MB_FDD_MAX_HEADS; + gUsbData->bReadCapSectors = USB_144MB_FDD_MAX_SECTORS; + gUsbData->wReadCapCylinders= USB_144MB_FDD_MAX_CYLINDERS; + gUsbData->bDiskMediaType = USB_144MB_FDD_MEDIA_TYPE; + return USB_SUCCESS; + + case USB_720KB_FDD_MAX_LBA: + gUsbData->bReadCapHeads = USB_720KB_FDD_MAX_HEADS; + gUsbData->bReadCapSectors = USB_720KB_FDD_MAX_SECTORS; + gUsbData->wReadCapCylinders= USB_720KB_FDD_MAX_CYLINDERS; + gUsbData->bDiskMediaType = USB_720KB_FDD_MEDIA_TYPE; + return USB_SUCCESS; + } + } + + // + // Convert to CHS + // + gUsbData->wReadCapBlockSize = DevInfo->wBlockSize; + + // + // Do CHS conversion + // Use fixed sectors/track & heads for CHS conversion + // + if (DevInfo->MaxLba < 0x400) { // < 512 KB + Sectors = 1; + Heads = 1; + } + else { + if (DevInfo->MaxLba < 0x200000) { // < 1GB + Sectors = USB_FIXED_LBA_SPT_BELOW_1GB; + Heads = USB_FIXED_LBA_HPT_BELOW_1GB; + } + else { // > 1GB + Sectors = USB_FIXED_LBA_SPT_ABOVE_1GB; + Heads = USB_FIXED_LBA_HPT_ABOVE_1GB; + } + } + + gUsbData->bReadCapSectors = Sectors; + gUsbData->bReadCapHeads = Heads; + + // + // Calculate number of cylinders Cyl = LBA/(Head*Sec) + // + if ((Sectors != 0) && (Heads != 0)) { + gUsbData->wReadCapCylinders = (UINT16)Div64(DevInfo->MaxLba, (Sectors * Heads), NULL); + } else { + gUsbData->wReadCapCylinders = 0; + } + + return USB_SUCCESS; + +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassUpdateDeviceGeometry +// +// Description: This function updates the device geometry information +// +// Input: Pointer to device info structure +// +// Output: USB_SUCCESS or USB_ERROR +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassUpdateDeviceGeometry ( + DEV_INFO* DevInfo +) +{ + UINT64 MaxLba; + UINT8 Heads; + UINT8 Sectors; + UINT16 Cylinders; + UINT8 Status; + + // + // Try to update geometry if it is not valid + // "Valid" block size is 1...FFFE + // Additional check added to ensure the head, sector, and cylinder values are non-zero. + // + //(EIP13457+)> + if ((DevInfo->Heads != 0) && + (DevInfo->bSectors != 0) && + (DevInfo->wCylinders != 0) && + !(DevInfo->bLastStatus & USB_MASS_MEDIA_CHANGED) && + (!((DevInfo->bLastStatus & USB_MASS_GET_MEDIA_FORMAT) && + (DevInfo->bSubClass == SUB_CLASS_UFI)))) { + + DevInfo->bLastStatus &= ~USB_MASS_GET_MEDIA_FORMAT; + + if (DevInfo->wBlockSize && (DevInfo->wBlockSize != 0xFFFF)) { + return USB_SUCCESS; + } + } + + DevInfo->bLastStatus &= ~USB_MASS_GET_MEDIA_FORMAT; + + // + // Set default values for the global variables + // + gUsbData->bDiskMediaType = USB_UNKNOWN_MEDIA_TYPE; + gUsbData->bGeometryCommandStatus &= ~(MODE_SENSE_COMMAND_EXECUTED | + READ_CAPACITY_COMMAND_EXECUTED); + + // + // Get disk geometry using Mode Sense + // + if (DevInfo->bSubClass == SUB_CLASS_UFI) { //(EIP94060) + USBMassUpdateParamUsingModeSense(DevInfo); + } + + // + // Get disk geometry using Read Capacity + // + Status = USBMassUpdateParamUsingReadCapacity(DevInfo); + + // + // Parameters are obtained and stored in respective global variables; + // check whether any of the commands executed. + // + if (!(gUsbData->bGeometryCommandStatus & (READ_CAPACITY_COMMAND_EXECUTED | + MODE_SENSE_COMMAND_EXECUTED))) { + USB_DEBUG(DEBUG_LEVEL_3, "-error\n"); + return USB_ERROR; + } + + // + // Check whether read capacity is executed. If so, then max LBA & block size + // are already updated in the MassDeviceInfo structure. If not update it using + // mode sense parameters + // + if (!(gUsbData->bGeometryCommandStatus & READ_CAPACITY_COMMAND_EXECUTED)) { + // + // At this point we made sure atleast one of the command (Mode sense or Read + // Capacity) was executed. So if one command is not executed then other + // command is surely executed. + // + + // + // Update the max LBA & block size using mode sense parameters + // + DevInfo->wBlockSize = gUsbData->wModeSenseBlockSize; + DevInfo->MaxLba = gUsbData->dModeSenseMaxLBA; + USB_DEBUG(DEBUG_LEVEL_4, "size %x lba %lx\n", DevInfo->wBlockSize, DevInfo->MaxLba); + } + + //Some usb mass storages report media change even if they don't, we already + //update CHS from boot record and legacy boot doesn't support dynamic + //media insertion, we should not update it from read capacity parameters. + + if ((DevInfo->Heads != 0) && (DevInfo->bSectors != 0) && (DevInfo->wCylinders !=0)) { + return USB_SUCCESS; + } + + // + // Update the media type byte + // + DevInfo->bMediaType = gUsbData->bDiskMediaType; + + // + // Check whether mode sense is executed. If so, then update CHS from mode + // sense value or else update from read capacity values. + // + + // + // Update the CHS values using mode sense parameters + // + Heads = gUsbData->bModeSenseHeads; + Sectors = gUsbData->bModeSenseSectors; + Cylinders = gUsbData->wModeSenseCylinders; + +// if ((gUsbData->bGeometryCommandStatus & MODE_SENSE_COMMAND_EXECUTED) && + if ((Heads * Sectors * Cylinders) == 0) { + // + // Update the CHS values using read capacity parameters + // + Heads = gUsbData->bReadCapHeads; + Sectors = gUsbData->bReadCapSectors; + Cylinders = gUsbData->wReadCapCylinders; + } + + USB_DEBUG (DEBUG_LEVEL_4, "Cyl-%x, Hds-%x, Sec-%x", Cylinders, Heads, Sectors); + + DevInfo->Heads = Heads; + DevInfo->bSectors = Sectors; + DevInfo->wCylinders = Cylinders; + + // + // Calculate non-LBA CHS values from max LBA + // + MaxLba = DevInfo->MaxLba; + + // + // Do not translate sectors for non HDD devices + // + if ((!DevInfo->bStorageType) || (DevInfo->bStorageType == USB_MASS_DEV_HDD)) { + // + // If Total number of sectors < 1032192(0FC000h) CHS translation is not + // needed + // + if (MaxLba >= 0xFC000) { + Sectors = 63; + Heads = 32; + // + // If Total number of sectors < 2064384(01F8000h) then use + // 63 Sec/track and 32 head for translation + // + if (MaxLba >= 0x01F8000) { + Heads = 64; + // + // If Total number of sectors < 4128768(03F0000h) then use + // 63 Sec/track and 64 head for translation + // + if (MaxLba >= 0x03F0000) { + Heads = 128; + // + // If Total number of sectors < 8257536(07E0000h) then use + // 63 Sec/track and 128 head for translation else use 255 heads + // + if (MaxLba >= 0x7E0000) { + Heads = 255; + MaxLba = DevInfo->MaxLba; + } + } + } + } + + // + // In any case, check the parameters for maximum values allowed by BIOS and + // ATA specs (that is, 1024 cylinders, 16 heads and 63 sectors per track) + // + for (;;) { + // + // Calculate translated number of cylinders + // + if ((Sectors != 0) && (Heads != 0)) { + Cylinders = (UINT16)Div64(MaxLba, (Heads * Sectors), NULL); + } else { + Cylinders = 0; + } + + // + // Check whether number of cylinders is less than or equal to 1024 + // + if (Cylinders <= 1024) break; + + // + // Cylinders are getting larger than usually supported try increasing + // head count keeping cylinders within safe limit + // + Cylinders = 1024; + if (Heads == 0xFF) { + break; // Heads limit reached + } + // + // Double number of heads + // + Heads <<= 1; + if (!Heads) { + Heads = 0xFF; + } + } + } + + // + // Save the parameters + // + DevInfo->NonLBAHeads = Heads; + DevInfo->bNonLBASectors = Sectors; + DevInfo->wNonLBACylinders = Cylinders; + + USB_DEBUG(DEBUG_LEVEL_5, "BPS %d H %d S %d C %d MT %d\n", + DevInfo->wBlockSize, + DevInfo->Heads, + DevInfo->bSectors, + DevInfo->wCylinders, + DevInfo->bMediaType); + + return USB_SUCCESS; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassIssueBOTTransaction +// +// Description: This function performs a mass storage transaction using bulk +// only transport (BOT) protocol. +// +// Input: Pointer to DeviceInfo structure +// stMassXactStruc +// pCmdBuffer Pointer to command buffer +// bCmdSize Size of command block +// bXferDir Transfer direction +// fpBuffer Data buffer far pointer +// dwLength Amount of data to be transferred +// wPreSkip Number of bytes to skip before data +// wPostSkip Number of bytes to skip after data +// +// Output: Amount of data actually transferred +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 +USBMassIssueBOTTransaction( + DEV_INFO* DevInfo, + MASS_XACT_STRUC* MassXactStruc +) +{ + UINT32 Data; + UINT8 Status; + + Data = USBMassSendBOTCommand(DevInfo, MassXactStruc); // Send the command control transfer + + if (!Data) { + // + // Check for stall/timedout condition + // + if (gUsbData->bLastCommandStatus & (USB_BULK_STALLED + USB_BULK_TIMEDOUT)) { + // + // Perform USB BOT reset recovery + // + USBMassBOTResetRecovery(DevInfo); + return 0; + } + else { + return 0; // Unknown error exit + } + } + + if (!MassXactStruc->dLength) { // No data + if (gUsbData->wBulkDataXferDelay) { + // + // Issue some delay + // + FixedDelay(100 * 1000); + gUsbData->wBulkDataXferDelay = 0; + } + // + // Get the status for the last transfer + // + Data = USBMassGetBOTStatus(DevInfo, MassXactStruc); + return Data; + } + + // + // Tranfer the bulk data + // + Data = USBMassProcessBulkData(DevInfo, MassXactStruc); // Actual data size + + // + // Check for stall/timeout condition + // + if (!(gUsbData->bLastCommandStatus & (USB_BULK_STALLED + USB_BULK_TIMEDOUT))) { + // + // Get the status for the last transfer + // + Status = USBMassGetBOTStatus(DevInfo, MassXactStruc); + if ((Status == USB_ERROR) || (gUsbData->bLastCommandStatus & USB_BULK_TIMEDOUT)) { + return 0; + } else { + return Data; + } + } + + // + // Check for time out condition + // + if (gUsbData->bLastCommandStatus & USB_BULK_TIMEDOUT) { + // + // Perform USB BOT reset recovery + // + USBMassBOTResetRecovery(DevInfo); + return 0; + } + + // + // Clear endpoint stall + // + USBMassClearBulkEndpointStall(DevInfo, MassXactStruc->bXferDir); + + // + // Get the status for the last transfer + // + USBMassGetBOTStatus(DevInfo, MassXactStruc); + + return Data; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBBOTSendCommand +// +// DESCRIPTION: This function performs a mass storage transaction using bulk +// only transport (BOT) protocol. +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// bXferDir Transfer direction +// dwDataSize Amount of data to be transferred +// fpCmdBuffer Pointer to the command buffer +// bCmdSize Size of command block + +// RETURN: Amount of data actually transferred +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 +USBMassSendBOTCommand( + DEV_INFO* DevInfo, + MASS_XACT_STRUC* MassXactStruc +) +{ + UINT8 Count; + UINT8 *Src; + UINT8 *Dest; + BOT_CMD_BLK *BotCmdBlk; + UINT8 CmdSize; + + BotCmdBlk = (BOT_CMD_BLK*)MassXactStruc->fpCmdBuffer; + + CmdSize = MassXactStruc->bCmdSize; + +// if( !VALID_DEVINFO2( fpDevInfo) ) +// return 0; + // + // Make enough space for BOT command block wrapper + // Move backwards + // + Src = MassXactStruc->fpCmdBuffer + CmdSize - 1; + + // + // BOT_COMMAND_BLOCK + end of command + // + Dest = Src + ((UINT8*)BotCmdBlk->aCBWCB - (UINT8*)BotCmdBlk); + + for (Count = 0; Count < CmdSize; Count++) { + *Dest = *Src; + --Dest; + --Src; + } + + //fpDest = gUsbData->stMassXactStruc.fpCmdBuffer; + + // + // Clear the BOT command block + // + //for (bCount = 0; bCount < bCmdSize; bCount++) { + // *fpDest = 0x00; + // ++fpDest; + //} + + BotCmdBlk->dCbwSignature = BOT_CBW_SIGNATURE; + BotCmdBlk->dCbwTag = ++(gUsbData->dBOTCommandTag); + BotCmdBlk->dCbwDataLength = MassXactStruc->dLength; + BotCmdBlk->bmCbwFlags = MassXactStruc->bXferDir; + BotCmdBlk->bCbwLun = DevInfo->bLUN; + BotCmdBlk->bCbwLength = CmdSize; + + return (UINT16)USBMassIssueBulkTransfer( + DevInfo, + 0, + (UINT8*)BotCmdBlk, + sizeof (BOT_CMD_BLK)); + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBBOTGetStatus +// +// Description: This function gets the BOT status sequence using +// bulk IN transfer +// +// Input: fpDevInfo Pointer to DeviceInfo structure +// +// Output: Nothing +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassGetBOTStatus( + DEV_INFO* DevInfo, + MASS_XACT_STRUC* MassXactStruc +) +{ + //(EIP90503)> + UINT8* CmdBuffer; + UINT16 Data; + + CmdBuffer = MassXactStruc->fpCmdBuffer; + + Data = (UINT16)USBMassIssueBulkTransfer(DevInfo, BIT7, + CmdBuffer, sizeof (BOT_STATUS_BLOCK)); + if ((Data != sizeof (BOT_STATUS_BLOCK))) { + if (gUsbData->bLastCommandStatus & USB_BULK_STALLED) { + USBMassClearBulkEndpointStall(DevInfo, BIT7); + } + Data = (UINT16)USBMassIssueBulkTransfer(DevInfo, BIT7, + CmdBuffer, sizeof (BOT_STATUS_BLOCK)); + if (gUsbData->bLastCommandStatus & USB_BULK_STALLED) { + USBMassBOTResetRecovery(DevInfo); + return USB_ERROR; + } + } + + // + // Check for valid CSW + // + if ((Data != sizeof (BOT_STATUS_BLOCK)) || + (((BOT_STATUS_BLOCK*)CmdBuffer)->dCswSignature != BOT_CSW_SIGNATURE) || + (((BOT_STATUS_BLOCK*)CmdBuffer)->dCswTag != gUsbData->dBOTCommandTag)) { + //USBMassClearBulkEndpointStall(fpDevInfo, BIT7); //(EIP63308-) + //USBMassClearBulkEndpointStall(fpDevInfo, BIT0); //(EIP63308-) + return USB_ERROR; + } + //<(EIP90503) + // + // Check for meaningful CSW + // + if (((BOT_STATUS_BLOCK*)CmdBuffer)->bmCswStatus) { + if (((BOT_STATUS_BLOCK*)CmdBuffer)->bmCswStatus > 1) { + // + // Perform reset recovery if BOT status is phase error + // + USBMassBOTResetRecovery(DevInfo); + } + return USB_ERROR; + } + + return USB_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassBOTResetRecovery +// +// DESCRIPTION: This function performs the BOT reset recovery +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +VOID +USBMassBOTResetRecovery(DEV_INFO* fpDevInfo) +{ + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(gUsbData->HcTable + [fpDevInfo->bHCNumber - 1]->bHCType)].pfnHCDControlTransfer) + (gUsbData->HcTable[fpDevInfo->bHCNumber - 1], + //(EIP20863)> + //fpDevInfo, ADSC_OUT_REQUEST_TYPE, + //(UINT16)fpDevInfo->bInterfaceNum,BOT_RESET_REQUEST_CODE, 0, 0); + fpDevInfo, ADSC_OUT_REQUEST_TYPE + (BOT_RESET_REQUEST_CODE << 8), + (UINT16)fpDevInfo->bInterfaceNum, 0, 0, 0); + //<(EIP20863) + USBMassClearBulkEndpointStall(fpDevInfo, BIT7); + USBMassClearBulkEndpointStall(fpDevInfo, BIT0); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassBOTGetMaxLUN +// +// Description: This function gets the maximum logical unit number(LUN) +// supported by the device. It is zero based value. +// +// Input: Pointer to DeviceInfo structure +// +// Output: Max LUN supported +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 +USBMassBOTGetMaxLUN( + DEV_INFO* DevInfo +) +{ + UINT8 *Buffer = NULL; + UINT8 MaxLun = 0; + UINT16 Status; + + if (DevInfo->wIncompatFlags & USB_INCMPT_GETMAXLUN_NOT_SUPPORTED) { + return 0; + } + + Buffer = USB_MemAlloc(1); + ASSERT(Buffer); + if (Buffer == NULL) { + return 0; + } + + Status = (*gUsbData->aHCDriverTable[GET_HCD_INDEX(gUsbData->HcTable + [DevInfo->bHCNumber - 1]->bHCType)].pfnHCDControlTransfer) + (gUsbData->HcTable[DevInfo->bHCNumber - 1], + DevInfo, ADSC_IN_REQUEST_TYPE + (BOT_GET_MAX_LUN_REQUEST_CODE << 8), + DevInfo->bInterfaceNum, 0, Buffer, 1); + if (Status) { + MaxLun = *Buffer; + } + USB_MemFree(Buffer, 1); + + return MaxLun; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassIssueCBITransaction +// +// DESCRIPTION: This function performs a mass storage transaction using CBI +// or CB protocol. +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// fpCmdBuffer Pointer to command buffer +// bCmdSize Size of command block +// bXferDir Transfer direction +// fpBuffer Data buffer far pointer +// dwLength Amount of data to be transferred +// wPreSkip Number of bytes to skip before data +// wPostSkip Number of bytes to skip after data +// +// RETURN: Amount of data actually transferred +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 +USBMassIssueCBITransaction( + DEV_INFO* DevInfo, + MASS_XACT_STRUC* MassXactStruc +) +{ + UINT32 Data = 0; + + if (!(USBMassSendCBICommand(DevInfo, MassXactStruc))) { // Returns 0 on error + return 0; + } + + if (MassXactStruc->dLength) { + Data = USBMassProcessBulkData(DevInfo, MassXactStruc); + if (!Data) { + if(gUsbData->bLastCommandStatus & USB_BULK_STALLED) { + USBMassClearBulkEndpointStall(DevInfo, MassXactStruc->bXferDir); + return Data; + } + } + } + + if(DevInfo->bProtocol != PROTOCOL_CBI_NO_INT && DevInfo->IntInEndpoint != 0) { + // + // Bypass interrupt transaction if it is CB protocol + // + USBMassCBIGetStatus(DevInfo); + } + + return Data; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// PROCEDURE: USBMassSendCBICommand +// +// DESCRIPTION: This function performs a mass storage transaction using CBI +// or CB protocol. +// +// PARAMETERS: fpDevInfo Pointer to DeviceInfo structure +// fpCmdBuffer Pointer to the command buffer +// bCmdSize Size of command block +// +// RETURN: 0xFFFF SUCCESS +// 0x00 ERROR +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 +USBMassSendCBICommand( + DEV_INFO* DevInfo, + MASS_XACT_STRUC* MassXactStruc +) +{ + UINT16 RetValue; + + RetValue = (*gUsbData->aHCDriverTable[GET_HCD_INDEX(gUsbData->HcTable + [DevInfo->bHCNumber - 1]->bHCType)].pfnHCDControlTransfer) + (gUsbData->HcTable[DevInfo->bHCNumber - 1], + DevInfo, ADSC_OUT_REQUEST_TYPE, + (UINT16)DevInfo->bInterfaceNum, 0, + MassXactStruc->fpCmdBuffer, + (UINT16)MassXactStruc->bCmdSize); + + return RetValue; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassCBIGetStatus +// +// Description: This function gets the status of the mass transaction +// through an interrupt transfer +// +// Input: pDevInfo Pointer to DeviceInfo structure +// +// Output: Return value from the interrupt transfer +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT16 +USBMassCBIGetStatus(DEV_INFO* fpDevInfo) +{ + (*gUsbData->aHCDriverTable[GET_HCD_INDEX(gUsbData->HcTable + [fpDevInfo->bHCNumber - 1]->bHCType)].pfnHCDInterruptTransfer) + (gUsbData->HcTable[fpDevInfo->bHCNumber - 1], + fpDevInfo, fpDevInfo->IntInEndpoint, + fpDevInfo->IntInMaxPkt, (UINT8*)&gUsbData->wInterruptStatus, 2); + + return ((UINT16)gUsbData->wInterruptStatus); + +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMiscIssueBulkTransfer +// +// 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 +// +// Input: - DeviceInfo structure (if available else 0) +// - Transfer direction +// Bit 7 : Data direction +// 0 Host sending data to device +// 1 Device sending data to host +// Bit 6-0 : Reserved +// - Buffer containing data to be sent to the device or +// buffer to be used to receive data. Value in +// - Length request parameter, number of bytes of data +// to be transferred in or out of the host controller +// +// Output: Amount of data transferred +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 +USBMassIssueBulkTransfer(DEV_INFO* fpDevInfo, UINT8 bXferDir, + UINT8* fpCmdBuffer, UINT32 dSize) +{ + return (*gUsbData->aHCDriverTable[GET_HCD_INDEX(gUsbData->HcTable + [fpDevInfo->bHCNumber - 1]->bHCType)].pfnHCDBulkTransfer) + (gUsbData->HcTable[fpDevInfo->bHCNumber -1], + fpDevInfo, bXferDir, + fpCmdBuffer, dSize); +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassGetDeviceGeometry +// +// Description: This function fills and returns the mass get device geometry +// structure +// +// Input: fpMassGetDevGeo Pointer to mass get geometry struc +// +// Output: Return value +// fpMassGetDevGeo Pointer to mass get geometry struc +// dSenseData Sense data of the last command +// bNumHeads Number of heads +// wNumCylinders Number of cylinders +// bNumSectors Number of sectors +// wBytesPerSector Number of bytes per sector +// bMediaType Media type +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassGetDeviceGeometry( + MASS_GET_DEV_GEO *GetDevGeometry + ) +{ + DEV_INFO *DevInfo; + UINT8 DevAddr = GetDevGeometry->bDevAddr; + BOOLEAN ValidGeo; + MASS_GET_DEV_STATUS MassGetDevSts; + + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_INDX, 0, DevAddr, 0); + + if ((!DevInfo) || (!(DevInfo->Flag & DEV_INFO_DEV_PRESENT))) { // Error + return USB_ERROR; + } + + MassGetDevSts.bDevAddr = DevAddr; + //(EIP13457+)> + if (GetDevGeometry->bInt13FuncNum == 0x20){ + DevInfo->bLastStatus |= USB_MASS_GET_MEDIA_FORMAT; + } + if ((!DevInfo->wBlockSize) || (DevInfo->wBlockSize == 0xFFFF) || + (!(DevInfo->bLastStatus & USB_MASS_MEDIA_PRESENT) || + (GetDevGeometry->bInt13FuncNum == 0x20)) ) { +// USBMassCheckDeviceReady(fpDevInfo); + USBMassGetDeviceStatus(&MassGetDevSts); + } //<(EIP13457+) + ValidGeo = (BOOLEAN)((DevInfo->wBlockSize != 0xFFFF) && (DevInfo->wBlockSize != 0)); + ValidGeo &= (DevInfo->bLastStatus & USB_MASS_MEDIA_PRESENT); + //(EIP107198+)> + GetDevGeometry->wBytesPerSector = ValidGeo? DevInfo->wBlockSize : 0; + GetDevGeometry->LBANumHeads = ValidGeo? DevInfo->Heads : 0; + GetDevGeometry->bLBANumSectors = ValidGeo? DevInfo->bSectors : 1; + GetDevGeometry->wLBANumCyls = ValidGeo? DevInfo->wCylinders : 0; + GetDevGeometry->NumHeads = ValidGeo? DevInfo->NonLBAHeads : 0; + GetDevGeometry->bNumSectors = ValidGeo? DevInfo->bNonLBASectors : 1; + GetDevGeometry->wNumCylinders = ValidGeo? DevInfo->wNonLBACylinders : 0; + GetDevGeometry->bMediaType = DevInfo->bMediaType; + GetDevGeometry->LastLBA = ValidGeo? DevInfo->MaxLba : 0; + GetDevGeometry->BpbMediaDesc = ValidGeo? DevInfo->BpbMediaDesc : 0; + + //<(EIP107198+) + + USB_DEBUG(DEBUG_LEVEL_4, "BPS %d H %d S %d C %d MT %d\n", + DevInfo->wBlockSize, + DevInfo->Heads, + DevInfo->bSectors, + DevInfo->wCylinders, + DevInfo->bMediaType); + + return USB_SUCCESS; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: USBMassReadCapacity +// +// Description: This function issues read capacity command to the mass +// device and returns the value obtained +// +// Input: fpReadCapacity Pointer to the read capacity structure +// bDevAddr USB device address of the device +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT8 +USBMassReadCapacity( + MASS_READ_CAPACITY *ReadCapacity +) +{ + DEV_INFO *DevInfo; + UINT8 DevAddr = ReadCapacity->bDevAddr; + + DevInfo = USB_GetDeviceInfoStruc(USB_SRCH_DEV_INDX, 0, DevAddr, 0); + + if ((!DevInfo) || (!(DevInfo->Flag & DEV_INFO_DEV_PRESENT))) { // Error + return USB_ERROR; + } + + return USBMassReadCapacity10Command(DevInfo); +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: dabc_to_abcd +// +// Description: This function swaps the bytes in dword: 0-3,1-2,2-1,3-0. Can be +// used for example in little endian->big endian conversions. +// +// Input: DWORD to swap +// +// Output: Input value with the swapped bytes in it. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> + +UINT32 dabc_to_abcd(UINT32 dData) +{ + return (((dData & 0x000000FF) << 24) + | ((dData & 0x0000FF00) << 8) + | ((dData & 0x00FF0000) >> 8) + | ((dData & 0xFF000000) >> 24)); +} + +//**************************************************************************** +//**************************************************************************** +//** ** +//** (C)Copyright 1985-2016, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Pkwy, Norcross, GA 30093 ** +//** ** +//** Phone (770)-246-8600 ** +//** ** +//**************************************************************************** +//**************************************************************************** |