1 /** @file 2 3 Copyright (c) 2014, ARM Ltd. All rights reserved.<BR> 4 5 This program and the accompanying materials 6 are licensed and made available under the terms and conditions of the BSD License 7 which accompanies this distribution. The full text of the license may be found at 8 http://opensource.org/licenses/bsd-license.php 9 10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13 **/ 14 15 /* 16 * Implementation of the FASTBOOT_TRANSPORT_PROTOCOL using the USB_DEVICE_PROTOCOL 17 */ 18 19 #include <Protocol/UsbDevice.h> 20 #include <Protocol/AndroidFastbootTransport.h> 21 #include <Protocol/SimpleTextOut.h> 22 23 #include <Library/BaseLib.h> 24 #include <Library/BaseMemoryLib.h> 25 #include <Library/DebugLib.h> 26 #include <Library/MemoryAllocationLib.h> 27 #include <Library/UefiBootServicesTableLib.h> 28 #include <Library/UefiDriverEntryPoint.h> 29 30 STATIC USB_DEVICE_PROTOCOL *mUsbDevice; 31 32 // Configuration attributes: 33 // bit 7 reserved and must be 1, bit 6 means self-powered. 34 #define CONFIG_DESC_ATTRIBUTES (BIT7 | BIT6) 35 36 #define MAX_PACKET_SIZE_BULK 512 37 38 STATIC USB_DEVICE_PROTOCOL *mUsbDevice; 39 STATIC EFI_EVENT mReceiveEvent = NULL; 40 STATIC LIST_ENTRY mPacketList; 41 42 // List type for queued received packets 43 typedef struct _FASTBOOT_USB_PACKET_LIST { 44 LIST_ENTRY Link; 45 VOID *Buffer; 46 UINTN BufferSize; 47 } FASTBOOT_USB_PACKET_LIST; 48 49 50 /* 51 No string descriptors - all string descriptor members are set to 0 52 */ 53 54 STATIC USB_DEVICE_DESCRIPTOR mDeviceDescriptor = { 55 sizeof (USB_DEVICE_DESCRIPTOR), //Length 56 USB_DESC_TYPE_DEVICE, //DescriptorType 57 0x0200, //BcdUSB 58 0xFF, //DeviceClass 59 0, //DeviceSubClass 60 0, //DeviceProtocol 61 64, //MaxPacketSize0 62 FixedPcdGet32 (PcdAndroidFastbootUsbVendorId), //IdVendor 63 FixedPcdGet32 (PcdAndroidFastbootUsbProductId), //IdProduct 64 0, //BcdDevice 65 0, //StrManufacturer 66 0, //StrProduct 67 0, //StrSerialNumber 68 1 //NumConfigurations 69 }; 70 71 /* 72 We have one configuration, one interface, and two endpoints (one IN, one OUT) 73 */ 74 75 // Lazy (compile-time) way to concatenate descriptors to pass to the USB device 76 // protocol 77 78 #pragma pack(1) 79 typedef struct { 80 USB_CONFIG_DESCRIPTOR ConfigDescriptor; 81 USB_INTERFACE_DESCRIPTOR InterfaceDescriptor; 82 USB_ENDPOINT_DESCRIPTOR EndpointDescriptor1; 83 USB_ENDPOINT_DESCRIPTOR EndpointDescriptor2; 84 } GET_CONFIG_DESCRIPTOR_RESPONSE; 85 #pragma pack() 86 87 STATIC GET_CONFIG_DESCRIPTOR_RESPONSE mGetConfigDescriptorResponse = { 88 { // USB_CONFIG_DESCRIPTOR 89 sizeof (USB_CONFIG_DESCRIPTOR), //Length; 90 USB_DESC_TYPE_CONFIG, //DescriptorType; 91 sizeof (GET_CONFIG_DESCRIPTOR_RESPONSE), //TotalLength; 92 1, //NumInterfaces; 93 1, //ConfigurationValue; 94 0, //Configuration; 95 CONFIG_DESC_ATTRIBUTES, //Attributes; 96 0 //MaxPower; 97 }, 98 { // USB_INTERFACE_DESCRIPTOR 99 sizeof (USB_INTERFACE_DESCRIPTOR), //Length; 100 USB_DESC_TYPE_INTERFACE, //DescriptorType; 101 0, //InterfaceNumber; 102 0, //AlternateSetting; 103 2, //NumEndpoints; 104 0xFF, //InterfaceClass; 105 // Vendor specific interface subclass and protocol codes. 106 // I found these values in the Fastboot code 107 // (in match_fastboot_with_serial in fastboot.c). 108 0x42, //InterfaceSubClass; 109 0x03, //InterfaceProtocol; 110 0 //Interface; 111 }, 112 { // USB_ENDPOINT_DESCRIPTOR (In Endpoint) 113 sizeof (USB_ENDPOINT_DESCRIPTOR), //Length; 114 USB_DESC_TYPE_ENDPOINT, //DescriptorType; 115 1 | BIT7, //EndpointAddress; 116 0x2, //Attributes; 117 MAX_PACKET_SIZE_BULK, //MaxPacketSize; 118 16 //Interval; 119 }, 120 { // STATIC USB_ENDPOINT_DESCRIPTOR (Out Endpoint) 121 sizeof (USB_ENDPOINT_DESCRIPTOR), //Length; 122 USB_DESC_TYPE_ENDPOINT, //DescriptorType; 123 1, //EndpointAddress; 124 0x2, //Attributes; 125 MAX_PACKET_SIZE_BULK, //MaxPacketSize; 126 16 //Interval; 127 } 128 }; 129 130 STATIC 131 VOID 132 DataReceived ( 133 IN UINTN Size, 134 IN VOID *Buffer 135 ) 136 { 137 FASTBOOT_USB_PACKET_LIST *NewEntry; 138 139 NewEntry = AllocatePool (sizeof (*NewEntry)); 140 ASSERT (NewEntry != NULL); 141 142 NewEntry->Buffer = Buffer; 143 NewEntry->BufferSize = Size; 144 145 InsertTailList (&mPacketList, &NewEntry->Link); 146 147 if (mReceiveEvent) { 148 gBS->SignalEvent (mReceiveEvent); 149 } 150 } 151 152 STATIC 153 VOID 154 DataSent ( 155 IN UINT8 EndpointIndex 156 ) 157 { 158 // Don't care. 159 } 160 161 /* 162 Set up the transport system for use by Fastboot. 163 e.g. For USB this probably means making the device enumerable. 164 */ 165 EFI_STATUS 166 FastbootTransportUsbStart ( 167 EFI_EVENT ReceiveEvent 168 ) 169 { 170 GET_CONFIG_DESCRIPTOR_RESPONSE *Responses; 171 172 mReceiveEvent = ReceiveEvent; 173 174 mGetConfigDescriptorResponse.ConfigDescriptor.TotalLength = sizeof (GET_CONFIG_DESCRIPTOR_RESPONSE); 175 Responses = &mGetConfigDescriptorResponse; 176 177 InitializeListHead (&mPacketList); 178 179 return mUsbDevice->Start (&mDeviceDescriptor, (VOID **) &Responses, DataReceived, DataSent); 180 } 181 182 /* 183 Function to be called when all Fastboot transactions are finished, to 184 de-initialise the transport system. 185 e.g. A USB OTG system might want to get out of peripheral mode so it can be 186 a USB host. 187 */ 188 EFI_STATUS 189 FastbootTransportUsbStop ( 190 VOID 191 ) 192 { 193 // not yet implemented in USB 194 return EFI_SUCCESS; 195 } 196 197 /* 198 Send data. This function can be used both for command responses like "OKAY" 199 and for the data phase (the protocol doesn't describe any situation when the 200 latter might be necessary, but does allow it) 201 */ 202 EFI_STATUS 203 FastbootTransportUsbSend ( 204 IN UINTN BufferSize, 205 IN CONST VOID *Buffer, 206 IN EFI_EVENT *FatalErrorEvent 207 ) 208 { 209 // Current USB protocol is blocking, so ignore FatalErrorEvent 210 return mUsbDevice->Send(1, BufferSize, Buffer); 211 } 212 213 /* 214 When the event has been Signalled to say data is available from the host, 215 this function is used to get data. In order to handle the case where several 216 packets are received before ReceiveEvent's notify function is called, packets 217 received are queued, and each call to this function returns the next packet in 218 the queue. It should therefore be called in a loop, the exit condition being a 219 return of EFI_NOT_READY. 220 221 Parameters: 222 Buffer - The buffer in which to place data 223 BufferSize - The size of Buffer in bytes 224 225 Return EFI_NOT_READY if there is no data available 226 */ 227 EFI_STATUS 228 FastbootTransportUsbReceive ( 229 OUT UINTN *BufferSize, 230 OUT VOID **Buffer 231 ) 232 { 233 FASTBOOT_USB_PACKET_LIST *Entry; 234 235 if (IsListEmpty (&mPacketList)) { 236 return EFI_NOT_READY; 237 } 238 239 Entry = (FASTBOOT_USB_PACKET_LIST *) GetFirstNode (&mPacketList); 240 241 *BufferSize = Entry->BufferSize; 242 *Buffer = Entry->Buffer; 243 244 RemoveEntryList (&Entry->Link); 245 FreePool (Entry); 246 247 return EFI_SUCCESS; 248 } 249 250 STATIC FASTBOOT_TRANSPORT_PROTOCOL mTransportProtocol = { 251 FastbootTransportUsbStart, 252 FastbootTransportUsbStop, 253 FastbootTransportUsbSend, 254 FastbootTransportUsbReceive 255 }; 256 257 EFI_STATUS 258 FastbootTransportUsbEntryPoint ( 259 IN EFI_HANDLE ImageHandle, 260 IN EFI_SYSTEM_TABLE *SystemTable 261 ) 262 { 263 EFI_STATUS Status; 264 265 // Assume there's only one USB peripheral controller. 266 Status = gBS->LocateProtocol (&gUsbDeviceProtocolGuid, NULL, (VOID **) &mUsbDevice); 267 if (EFI_ERROR (Status)) { 268 return Status; 269 } 270 271 Status = gBS->InstallProtocolInterface ( 272 &ImageHandle, 273 &gAndroidFastbootTransportProtocolGuid, 274 EFI_NATIVE_INTERFACE, 275 &mTransportProtocol 276 ); 277 return Status; 278 } 279
