audk/EdkModulePkg/Bus/Usb/UsbCbi/Dxe/Cbi1/cbi1.c

852 lines
21 KiB
C

/*++
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
cbi1.c
Abstract:
cbi1 transportation protocol implementation files
--*/
#include "cbi.h"
EFI_STATUS
EFIAPI
UsbCBI1DriverEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
);
//
// CBI Function prototypes
//
STATIC
EFI_STATUS
CBI1CommandPhase (
IN USB_CBI_DEVICE *UsbCbiDev,
IN VOID *Command,
IN UINT8 CommandSize,
OUT UINT32 *Result
);
STATIC
EFI_STATUS
CBI1DataPhase (
IN USB_CBI_DEVICE *UsbCbiDev,
IN UINT32 DataSize,
IN OUT VOID *DataBuffer,
IN EFI_USB_DATA_DIRECTION Direction,
IN UINT16 Timeout,
OUT UINT32 *Result
);
//
// USB Atapi implementation
//
STATIC
EFI_STATUS
EFIAPI
CBI1AtapiCommand (
IN EFI_USB_ATAPI_PROTOCOL *This,
IN VOID *Command,
IN UINT8 CommandSize,
IN VOID *DataBuffer,
IN UINT32 BufferLength,
IN EFI_USB_DATA_DIRECTION Direction,
IN UINT16 TimeOutInMilliSeconds
);
STATIC
EFI_STATUS
EFIAPI
CBI1MassStorageReset (
IN EFI_USB_ATAPI_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
);
//
// CBI1 Driver Binding Protocol
//
STATIC
EFI_STATUS
EFIAPI
CBI1DriverBindingSupported (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
);
STATIC
EFI_STATUS
EFIAPI
CBI1DriverBindingStart (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
);
STATIC
EFI_STATUS
EFIAPI
CBI1DriverBindingStop (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN UINTN NumberOfChildren,
IN EFI_HANDLE *ChildHandleBuffer
);
VOID
Cbi1ReportStatusCode (
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
IN EFI_STATUS_CODE_TYPE CodeType,
IN EFI_STATUS_CODE_VALUE Value
);
EFI_DRIVER_BINDING_PROTOCOL gCBI1DriverBinding = {
CBI1DriverBindingSupported,
CBI1DriverBindingStart,
CBI1DriverBindingStop,
0x10,
NULL,
NULL
};
STATIC EFI_USB_ATAPI_PROTOCOL CBI1AtapiProtocol = {
CBI1AtapiCommand,
CBI1MassStorageReset,
0
};
//
// CBI1 Driver Binding implementation
//
STATIC
EFI_STATUS
EFIAPI
CBI1DriverBindingSupported (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
)
/*++
Routine Description:
Test to see if this driver supports ControllerHandle. Any ControllerHandle
than contains a BlockIo and DiskIo protocol can be supported.
Arguments:
This - Protocol instance pointer.
ControllerHandle - Handle of device to test
RemainingDevicePath - Not used
Returns:
EFI_SUCCESS - This driver supports this device
EFI_ALREADY_STARTED - This driver is already running on this device
other - This driver does not support this device
--*/
{
EFI_STATUS Status;
EFI_USB_IO_PROTOCOL *UsbIo;
EFI_USB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
//
// Check if the Controller supports USB IO protocol
//
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiUsbIoProtocolGuid,
(VOID **) &UsbIo,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get the Controller interface descriptor
//
Status = UsbIo->UsbGetInterfaceDescriptor (
UsbIo,
&InterfaceDescriptor
);
if (EFI_ERROR (Status)) {
goto Exit;
}
//
// Bug here: just let Vendor specific CBI protocol get supported
//
if (!((InterfaceDescriptor.InterfaceClass == 0xFF) &&
(InterfaceDescriptor.InterfaceProtocol == 0))) {
Status = EFI_UNSUPPORTED;
goto Exit;
}
Exit:
gBS->CloseProtocol (
ControllerHandle,
&gEfiUsbIoProtocolGuid,
This->DriverBindingHandle,
ControllerHandle
);
return Status;
}
STATIC
EFI_STATUS
EFIAPI
CBI1DriverBindingStart (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
)
/*++
Routine Description:
Start this driver on ControllerHandle by opening a Block IO and Disk IO
protocol, reading Device Path, and creating a child handle with a
Disk IO and device path protocol.
Arguments:
This - Protocol instance pointer.
ControllerHandle - Handle of device to bind driver to
RemainingDevicePath - Not used
Returns:
EFI_SUCCESS - This driver is added to DeviceHandle
EFI_ALREADY_STARTED - This driver is already running on DeviceHandle
other - This driver does not support this device
--*/
{
USB_CBI_DEVICE *UsbCbiDev;
UINT8 Index;
EFI_USB_ENDPOINT_DESCRIPTOR EndpointDescriptor;
EFI_USB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
EFI_STATUS Status;
EFI_USB_IO_PROTOCOL *UsbIo;
BOOLEAN Found;
Found = FALSE;
//
// Check if the Controller supports USB IO protocol
//
UsbCbiDev = NULL;
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiUsbIoProtocolGuid,
(VOID **) &UsbIo,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get the controller interface descriptor
//
Status = UsbIo->UsbGetInterfaceDescriptor (
UsbIo,
&InterfaceDescriptor
);
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
CBI1AtapiProtocol.CommandProtocol = InterfaceDescriptor.InterfaceSubClass;
UsbCbiDev = AllocateZeroPool (sizeof (USB_CBI_DEVICE));
if (UsbCbiDev == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto ErrorExit;
}
UsbCbiDev->Signature = USB_CBI_DEVICE_SIGNATURE;
UsbCbiDev->UsbIo = UsbIo;
CopyMem (&UsbCbiDev->InterfaceDescriptor, &InterfaceDescriptor, sizeof (InterfaceDescriptor));
CopyMem (&UsbCbiDev->UsbAtapiProtocol , &CBI1AtapiProtocol, sizeof (CBI1AtapiProtocol));
//
// Get the Device Path Protocol on Controller's handle
//
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiDevicePathProtocolGuid,
(VOID **) &UsbCbiDev->DevicePath,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
for (Index = 0; Index < InterfaceDescriptor.NumEndpoints; Index++) {
UsbIo->UsbGetEndpointDescriptor (
UsbIo,
Index,
&EndpointDescriptor
);
//
// We parse bulk endpoint
//
if (EndpointDescriptor.Attributes == 0x02) {
if (EndpointDescriptor.EndpointAddress & 0x80) {
CopyMem (&UsbCbiDev->BulkInEndpointDescriptor, &EndpointDescriptor, sizeof (EndpointDescriptor));
} else {
CopyMem (&UsbCbiDev->BulkOutEndpointDescriptor, &EndpointDescriptor, sizeof (EndpointDescriptor));
}
Found = TRUE;
}
//
// We parse interrupt endpoint
//
if (EndpointDescriptor.Attributes == 0x03) {
CopyMem (&UsbCbiDev->InterruptEndpointDescriptor, &EndpointDescriptor, sizeof (EndpointDescriptor));
Found = TRUE;
}
}
//
// Double check we have these
//
if (!Found) {
goto ErrorExit;
}
//
// After installing Usb-Atapi protocol onto this handle
// it will be called by upper layer drivers such as Fat
//
Cbi1ReportStatusCode (
UsbCbiDev->DevicePath,
EFI_PROGRESS_CODE,
(EFI_PERIPHERAL_REMOVABLE_MEDIA | EFI_P_PC_ENABLE)
);
Status = gBS->InstallProtocolInterface (
&ControllerHandle,
&gEfiUsbAtapiProtocolGuid,
EFI_NATIVE_INTERFACE,
&UsbCbiDev->UsbAtapiProtocol
);
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
return EFI_SUCCESS;
ErrorExit:
gBS->CloseProtocol (
ControllerHandle,
&gEfiUsbIoProtocolGuid,
This->DriverBindingHandle,
ControllerHandle
);
if (UsbCbiDev != NULL) {
gBS->FreePool (UsbCbiDev);
}
return Status;
}
STATIC
EFI_STATUS
EFIAPI
CBI1DriverBindingStop (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN UINTN NumberOfChildren,
IN EFI_HANDLE *ChildHandleBuffer
)
/*++
Routine Description:
Stop this driver on ControllerHandle. Support stoping any child handles
created by this driver.
Arguments:
This - Protocol instance pointer.
ControllerHandle - Handle of device to stop driver on
NumberOfChildren - Number of Children in the ChildHandleBuffer
ChildHandleBuffer - List of handles for the children we need to stop.
Returns:
EFI_SUCCESS - This driver is removed DeviceHandle
EFI_UNSUPPORTED - Can't open the gEfiUsbAtapiProtocolGuid protocol
other - This driver was not removed from this device
--*/
{
EFI_STATUS Status;
EFI_USB_ATAPI_PROTOCOL *CBI1AtapiProtocol;
USB_CBI_DEVICE *UsbCbiDev;
EFI_USB_IO_PROTOCOL *UsbIo;
//
// Get our context back.
//
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiUsbAtapiProtocolGuid,
(VOID **) &CBI1AtapiProtocol,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
UsbCbiDev = USB_CBI_DEVICE_FROM_THIS (CBI1AtapiProtocol);
UsbIo = UsbCbiDev->UsbIo;
Cbi1ReportStatusCode (
UsbCbiDev->DevicePath,
EFI_PROGRESS_CODE,
(EFI_PERIPHERAL_REMOVABLE_MEDIA | EFI_P_PC_DISABLE)
);
Status = gBS->UninstallProtocolInterface (
ControllerHandle,
&gEfiUsbAtapiProtocolGuid,
&UsbCbiDev->UsbAtapiProtocol
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = gBS->CloseProtocol (
ControllerHandle,
&gEfiUsbIoProtocolGuid,
This->DriverBindingHandle,
ControllerHandle
);
gBS->FreePool (UsbCbiDev);
return Status;
}
//
// CBI1 command
//
STATIC
EFI_STATUS
CBI1CommandPhase (
IN USB_CBI_DEVICE *UsbCbiDev,
IN VOID *Command,
IN UINT8 CommandSize,
OUT UINT32 *Result
)
/*++
Routine Description:
In order to make consistence, CBI transportation protocol does only use
the first 3 parameters. Other parameters are not used here.
Arguments:
UsbCbiDev - USB_CBI_DEVICE
Command - Command to send
CommandSize - Command Size
Result - Result to return
Returns:
EFI_SUCCESS - This driver is removed DeviceHandle
other - This driver was not removed from this device
--*/
{
EFI_STATUS Status;
EFI_USB_IO_PROTOCOL *UsbIo;
EFI_USB_DEVICE_REQUEST Request;
UINT32 TimeOutInMilliSeconds;
UsbIo = UsbCbiDev->UsbIo;
ZeroMem (&Request, sizeof (EFI_USB_DEVICE_REQUEST));
//
// Device request see CBI specification
//
Request.RequestType = 0x21;
Request.Length = CommandSize;
TimeOutInMilliSeconds = 1000;
Status = UsbIo->UsbControlTransfer (
UsbIo,
&Request,
EfiUsbDataOut,
TimeOutInMilliSeconds,
Command,
CommandSize,
Result
);
return Status;
}
STATIC
EFI_STATUS
CBI1DataPhase (
IN USB_CBI_DEVICE *UsbCbiDev,
IN UINT32 DataSize,
IN OUT VOID *DataBuffer,
IN EFI_USB_DATA_DIRECTION Direction,
IN UINT16 Timeout,
OUT UINT32 *Result
)
/*++
Routine Description:
CBI1 Data Phase
Arguments:
UsbCbiDev - USB_CBI_DEVICE
DataSize - Data Size
DataBuffer - Data Buffer
Direction - IN/OUT/NODATA
Timeout - Time out value in milliseconds
Result - Transfer result
Returns:
EFI_SUCCESS - Success
--*/
{
EFI_STATUS Status;
EFI_USB_IO_PROTOCOL *UsbIo;
UINT8 EndpointAddr;
UINTN Remain;
UINTN Increment;
UINT32 MaxPacketLen;
UINT8 *BufferPtr;
UsbIo = UsbCbiDev->UsbIo;
Remain = DataSize;
BufferPtr = (UINT8 *) DataBuffer;
//
// retrieve the the max packet length of the given endpoint
//
if (Direction == EfiUsbDataIn) {
MaxPacketLen = (UsbCbiDev->BulkInEndpointDescriptor).MaxPacketSize;
EndpointAddr = (UsbCbiDev->BulkInEndpointDescriptor).EndpointAddress;
} else {
MaxPacketLen = (UsbCbiDev->BulkOutEndpointDescriptor).MaxPacketSize;
EndpointAddr = (UsbCbiDev->BulkOutEndpointDescriptor).EndpointAddress;
}
while (Remain > 0) {
//
// Using 15 packets to aVOID Bitstuff error
//
if (Remain > 15 * MaxPacketLen) {
Increment = 15 * MaxPacketLen;
} else {
Increment = Remain;
}
Status = UsbIo->UsbBulkTransfer (
UsbIo,
EndpointAddr,
BufferPtr,
&Increment,
Timeout,
Result
);
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
BufferPtr += Increment;
Remain -= Increment;
}
return EFI_SUCCESS;
ErrorExit:
if (Direction == EfiUsbDataIn) {
Cbi1ReportStatusCode (
UsbCbiDev->DevicePath,
EFI_ERROR_CODE | EFI_ERROR_MINOR,
(EFI_PERIPHERAL_REMOVABLE_MEDIA | EFI_P_EC_INPUT_ERROR)
);
} else {
Cbi1ReportStatusCode (
UsbCbiDev->DevicePath,
EFI_ERROR_CODE | EFI_ERROR_MINOR,
(EFI_PERIPHERAL_REMOVABLE_MEDIA | EFI_P_EC_OUTPUT_ERROR)
);
}
if (((*Result) & EFI_USB_ERR_STALL) == EFI_USB_ERR_STALL) {
//
// just endpoint stall happens
//
UsbClearEndpointHalt (
UsbIo,
EndpointAddr,
Result
);
}
return Status;
}
//
// CBI1 USB ATAPI Protocol
//
STATIC
EFI_STATUS
EFIAPI
CBI1MassStorageReset (
IN EFI_USB_ATAPI_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
)
/*++
Routine Description:
Reset CBI Devices
Arguments:
This - Protocol instance pointer.
ExtendedVerification - TRUE if we need to do strictly reset.
Returns:
EFI_SUCCESS - Command succeeded.
EFI_DEVICE_ERROR - Command failed.
--*/
{
UINT8 ResetCommand[12];
EFI_STATUS Status;
EFI_USB_IO_PROTOCOL *UsbIo;
USB_CBI_DEVICE *UsbCbiDev;
UINT8 EndpointAddr;
UINT32 Result;
UsbCbiDev = USB_CBI_DEVICE_FROM_THIS (This);
UsbIo = UsbCbiDev->UsbIo;
Cbi1ReportStatusCode (
UsbCbiDev->DevicePath,
EFI_PROGRESS_CODE,
(EFI_PERIPHERAL_REMOVABLE_MEDIA | EFI_P_PC_RESET)
);
if (ExtendedVerification) {
UsbIo->UsbPortReset (UsbIo);
}
//
// CBI reset command protocol
//
SetMem (ResetCommand, sizeof (ResetCommand), 0xff);
ResetCommand[0] = 0x1d;
ResetCommand[1] = 0x04;
Status = CBI1CommandPhase (
UsbCbiDev,
ResetCommand,
12,
&Result
);
//
// clear bulk in endpoint stall feature
//
EndpointAddr = UsbCbiDev->BulkInEndpointDescriptor.EndpointAddress;
UsbClearEndpointHalt (
UsbIo,
EndpointAddr,
&Result
);
//
// clear bulk out endpoint stall feature
//
EndpointAddr = UsbCbiDev->BulkOutEndpointDescriptor.EndpointAddress;
UsbClearEndpointHalt (
UsbIo,
EndpointAddr,
&Result
);
return EFI_SUCCESS;
}
STATIC
EFI_STATUS
EFIAPI
CBI1AtapiCommand (
IN EFI_USB_ATAPI_PROTOCOL *This,
IN VOID *Command,
IN UINT8 CommandSize,
IN VOID *DataBuffer,
IN UINT32 BufferLength,
IN EFI_USB_DATA_DIRECTION Direction,
IN UINT16 TimeOutInMilliSeconds
)
/*++
Routine Description:
Send ATAPI command using CBI1 protocol.
Arguments:
This - Protocol instance pointer.
Command - Command buffer
CommandSize - Size of Command Buffer
DataBuffer - Data buffer
BufferLength - Length of Data buffer
Direction - Data direction of this command
TimeOutInMilliSeconds - Timeout value in ms
Returns:
EFI_SUCCESS - Command succeeded.
EFI_DEVICE_ERROR - Command failed.
--*/
{
EFI_STATUS Status;
USB_CBI_DEVICE *UsbCbiDev;
UINT32 Result;
UINT8 Index;
UINT8 MaxRetryNum;
UsbCbiDev = USB_CBI_DEVICE_FROM_THIS (This);
MaxRetryNum = 3;
for (Index = 0; Index < MaxRetryNum; Index++) {
//
// First send ATAPI command through CBI1
//
Status = CBI1CommandPhase (
UsbCbiDev,
Command,
CommandSize,
&Result
);
if (EFI_ERROR (Status)) {
switch (Result) {
case EFI_USB_NOERROR:
case EFI_USB_ERR_STALL:
case EFI_USB_ERR_SYSTEM:
return EFI_DEVICE_ERROR;
default:
continue;
break;
}
} else {
break;
}
}
if (Index == MaxRetryNum) {
return EFI_DEVICE_ERROR;
}
for (Index = 0; Index < MaxRetryNum; Index++) {
//
// Send/Get Data if there is a Data Stage
//
switch (Direction) {
case EfiUsbDataIn:
case EfiUsbDataOut:
Status = CBI1DataPhase (
UsbCbiDev,
BufferLength,
DataBuffer,
Direction,
TimeOutInMilliSeconds,
&Result
);
if (EFI_ERROR (Status)) {
switch (Result) {
case EFI_USB_NOERROR:
case EFI_USB_ERR_STALL:
case EFI_USB_ERR_SYSTEM:
return EFI_DEVICE_ERROR;
default:
continue;
break;
}
} else {
return EFI_SUCCESS;
}
break;
case EfiUsbNoData:
return EFI_SUCCESS;
}
}
//
// If goes here, means met error.
//
return EFI_DEVICE_ERROR;
}
VOID
Cbi1ReportStatusCode (
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
IN EFI_STATUS_CODE_TYPE CodeType,
IN EFI_STATUS_CODE_VALUE Value
)
/*++
Routine Description:
Report Status Code in Usb Cbi1 Driver
Arguments:
DevicePath - Use this to get Device Path
CodeType - Status Code Type
CodeValue - Status Code Value
Returns:
None
--*/
{
REPORT_STATUS_CODE_WITH_DEVICE_PATH (
CodeType,
Value,
DevicePath
);
}