1 /*
2 * Driver for USB ported from CoreBoot
3 *
4 * Copyright (C) 2014 BALATON Zoltan
5 *
6 * This file was part of the libpayload project.
7 *
8 * Copyright (C) 2008 coresystems GmbH
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. The name of the author may not be used to endorse or promote products
19 * derived from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 #ifndef __USB_H
35 #define __USB_H
36 #include <drivers/pci.h>
37
38 typedef enum { host_to_device = 0, device_to_host = 1 } dev_req_dir;
39 typedef enum { standard_type = 0, class_type = 1, vendor_type =
40 2, reserved_type = 3
41 } dev_req_type;
42 typedef enum { dev_recp = 0, iface_recp = 1, endp_recp = 2, other_recp = 3
43 } dev_req_recp;
44
45 typedef enum {
46 GET_STATUS = 0,
47 CLEAR_FEATURE = 1,
48 SET_FEATURE = 3,
49 SET_ADDRESS = 5,
50 GET_DESCRIPTOR = 6,
51 SET_DESCRIPTOR = 7,
52 GET_CONFIGURATION = 8,
53 SET_CONFIGURATION = 9,
54 GET_INTERFACE = 10,
55 SET_INTERFACE = 11,
56 SYNCH_FRAME = 12
57 } bRequest_Codes;
58
59 typedef enum {
60 ENDPOINT_HALT = 0,
61 DEVICE_REMOTE_WAKEUP = 1,
62 TEST_MODE = 2
63 } feature_selectors;
64
65 enum {
66 audio_device = 0x01,
67 comm_device = 0x02,
68 hid_device = 0x03,
69 physical_device = 0x05,
70 imaging_device = 0x06,
71 printer_device = 0x07,
72 msc_device = 0x08,
73 hub_device = 0x09,
74 cdc_device = 0x0a,
75 ccid_device = 0x0b,
76 security_device = 0x0d,
77 video_device = 0x0e,
78 healthcare_device = 0x0f,
79 diagnostic_device = 0xdc,
80 wireless_device = 0xe0,
81 misc_device = 0xef,
82 };
83
84 enum { hid_subclass_none = 0, hid_subclass_boot = 1 };
85
86 enum {
87 hid_boot_proto_none = 0,
88 hid_boot_proto_keyboard = 1,
89 hid_boot_proto_mouse = 2
90 };
91
92 typedef struct {
93 union {
94 struct {
95 #ifdef CONFIG_BIG_ENDIAN
96 dev_req_dir data_dir:1;
97 dev_req_type req_type:2;
98 dev_req_recp req_recp:5;
99 #else
100 dev_req_recp req_recp:5;
101 dev_req_type req_type:2;
102 dev_req_dir data_dir:1;
103 #endif
104 } __attribute__ ((packed));
105 unsigned char bmRequestType;
106 } __attribute__ ((packed));
107 unsigned char bRequest;
108 unsigned short wValue;
109 unsigned short wIndex;
110 unsigned short wLength;
111 } __attribute__ ((packed)) dev_req_t;
112
113 struct usbdev_hc;
114 typedef struct usbdev_hc hci_t;
115
116 struct usbdev;
117 typedef struct usbdev usbdev_t;
118
119 typedef enum { SETUP, IN, OUT } direction_t;
120 typedef enum { CONTROL = 0, ISOCHRONOUS = 1, BULK = 2, INTERRUPT = 3
121 } endpoint_type;
122
123 typedef struct {
124 usbdev_t *dev;
125 int endpoint;
126 direction_t direction;
127 int toggle;
128 int maxpacketsize;
129 endpoint_type type;
130 int interval; /* expressed as binary logarithm of the number
131 of microframes (i.e. t = 125us * 2^interval) */
132 } endpoint_t;
133
134 enum { FULL_SPEED = 0, LOW_SPEED = 1, HIGH_SPEED = 2, SUPER_SPEED = 3 };
135
136 struct usbdev {
137 hci_t *controller;
138 endpoint_t endpoints[32];
139 int num_endp;
140 int address; // usb address
141 int hub; // hub, device is attached to
142 int port; // port where device is attached
143 int speed; // 1: lowspeed, 0: fullspeed, 2: highspeed
144 u32 quirks; // quirks field. got to love usb
145 void *data;
146 u8 *descriptor;
147 u8 *configuration;
148 void (*init) (usbdev_t *dev);
149 void (*destroy) (usbdev_t *dev);
150 void (*poll) (usbdev_t *dev);
151 };
152
153 typedef enum { OHCI = 0, UHCI = 1, EHCI = 2, XHCI = 3} hc_type;
154
155 struct usbdev_hc {
156 hci_t *next;
157 u32 reg_base;
158 hc_type type;
159 usbdev_t *devices[128]; // dev 0 is root hub, 127 is last addressable
160
161 /* start(): Resume operation. */
162 void (*start) (hci_t *controller);
163 /* stop(): Stop operation but keep controller initialized. */
164 void (*stop) (hci_t *controller);
165 /* reset(): Perform a controller reset. The controller needs to
166 be (re)initialized afterwards to work (again). */
167 void (*reset) (hci_t *controller);
168 /* init(): Initialize a (previously reset) controller
169 to a working state. */
170 void (*init) (hci_t *controller);
171 /* shutdown(): Stop operation, detach host controller and shutdown
172 this driver instance. After calling shutdown() any
173 other usage of this hci_t* is invalid. */
174 void (*shutdown) (hci_t *controller);
175
176 int (*bulk) (endpoint_t *ep, int size, u8 *data, int finalize);
177 int (*control) (usbdev_t *dev, direction_t pid, int dr_length,
178 void *devreq, int data_length, u8 *data);
179 void* (*create_intr_queue) (endpoint_t *ep, int reqsize, int reqcount, int reqtiming);
180 void (*destroy_intr_queue) (endpoint_t *ep, void *queue);
181 u8* (*poll_intr_queue) (void *queue);
182 void *instance;
183
184 /* set_address(): Tell the usb device its address and
185 return it. xHCI controllers want to
186 do this by themself. Also, the usbdev
187 structure has to be allocated and
188 initialized. */
189 int (*set_address) (hci_t *controller, int speed, int hubport, int hubaddr);
190 /* finish_device_config(): Another hook for xHCI,
191 returns 0 on success. */
192 int (*finish_device_config) (usbdev_t *dev);
193 /* destroy_device(): Finally, destroy all structures that
194 were allocated during set_address()
195 and finish_device_config(). */
196 void (*destroy_device) (hci_t *controller, int devaddr);
197 };
198
199 typedef struct {
200 unsigned char bDescLength;
201 unsigned char bDescriptorType;
202 unsigned char bNbrPorts;
203 union {
204 struct {
205 #ifdef CONFIG_BIG_ENDIAN
206 unsigned long:8;
207 unsigned long arePortIndicatorsSupported:1;
208 unsigned long ttThinkTime:2;
209 unsigned long overcurrentProtectionMode:2;
210 unsigned long isCompoundDevice:1;
211 unsigned long logicalPowerSwitchingMode:2;
212 #else
213 unsigned long logicalPowerSwitchingMode:2;
214 unsigned long isCompoundDevice:1;
215 unsigned long overcurrentProtectionMode:2;
216 unsigned long ttThinkTime:2;
217 unsigned long arePortIndicatorsSupported:1;
218 unsigned long:8;
219 #endif
220 } __attribute__ ((packed));
221 unsigned short wHubCharacteristics;
222 } __attribute__ ((packed));
223 unsigned char bPowerOn2PwrGood;
224 unsigned char bHubContrCurrent;
225 char DeviceRemovable[];
226 } __attribute__ ((packed)) hub_descriptor_t;
227
228 typedef struct {
229 unsigned char bLength;
230 unsigned char bDescriptorType;
231 unsigned short bcdUSB;
232 unsigned char bDeviceClass;
233 unsigned char bDeviceSubClass;
234 unsigned char bDeviceProtocol;
235 unsigned char bMaxPacketSize0;
236 unsigned short idVendor;
237 unsigned short idProduct;
238 unsigned short bcdDevice;
239 unsigned char iManufacturer;
240 unsigned char iProduct;
241 unsigned char iSerialNumber;
242 unsigned char bNumConfigurations;
243 } __attribute__ ((packed)) device_descriptor_t;
244
245 typedef struct {
246 unsigned char bLength;
247 unsigned char bDescriptorType;
248 unsigned short wTotalLength;
249 unsigned char bNumInterfaces;
250 unsigned char bConfigurationValue;
251 unsigned char iConfiguration;
252 unsigned char bmAttributes;
253 unsigned char bMaxPower;
254 } __attribute__ ((packed)) configuration_descriptor_t;
255
256 typedef struct {
257 unsigned char bLength;
258 unsigned char bDescriptorType;
259 unsigned char bInterfaceNumber;
260 unsigned char bAlternateSetting;
261 unsigned char bNumEndpoints;
262 unsigned char bInterfaceClass;
263 unsigned char bInterfaceSubClass;
264 unsigned char bInterfaceProtocol;
265 unsigned char iInterface;
266 } __attribute__ ((packed)) interface_descriptor_t;
267
268 typedef struct {
269 unsigned char bLength;
270 unsigned char bDescriptorType;
271 unsigned char bEndpointAddress;
272 unsigned char bmAttributes;
273 unsigned short wMaxPacketSize;
274 unsigned char bInterval;
275 } __attribute__ ((packed)) endpoint_descriptor_t;
276
277 typedef struct {
278 unsigned char bLength;
279 unsigned char bDescriptorType;
280 unsigned short bcdHID;
281 unsigned char bCountryCode;
282 unsigned char bNumDescriptors;
283 unsigned char bReportDescriptorType;
284 unsigned short wReportDescriptorLength;
285 } __attribute__ ((packed)) hid_descriptor_t;
286
287 hci_t *new_controller (void);
288 void detach_controller (hci_t *controller);
289 void usb_poll (void);
290 void init_device_entry (hci_t *controller, int num);
291
292 void set_feature (usbdev_t *dev, int endp, int feature, int rtype);
293 void get_status (usbdev_t *dev, int endp, int rtype, int len, void *data);
294 void set_configuration (usbdev_t *dev);
295 int clear_feature (usbdev_t *dev, int endp, int feature, int rtype);
296 int clear_stall (endpoint_t *ep);
297
298 void usb_hub_init (usbdev_t *dev);
299 void usb_hid_init (usbdev_t *dev);
300 void usb_msc_init (usbdev_t *dev);
301 void usb_generic_init (usbdev_t *dev);
302
303 u8 *get_descriptor (usbdev_t *dev, unsigned char bmRequestType,
304 int descType, int descIdx, int langID);
305
306 static inline unsigned char
gen_bmRequestType(dev_req_dir dir,dev_req_type type,dev_req_recp recp)307 gen_bmRequestType (dev_req_dir dir, dev_req_type type, dev_req_recp recp)
308 {
309 return (dir << 7) | (type << 5) | recp;
310 }
311
312 /* default "set address" handler */
313 int generic_set_address (hci_t *controller, int speed, int hubport, int hubaddr);
314
315 void usb_detach_device(hci_t *controller, int devno);
316 int usb_attach_device(hci_t *controller, int hubaddress, int port, int speed);
317
318 u32 usb_quirk_check(u16 vendor, u16 device);
319 int usb_interface_check(u16 vendor, u16 device);
320
321 #define USB_QUIRK_MSC_FORCE_PROTO_SCSI (1 << 0)
322 #define USB_QUIRK_MSC_FORCE_PROTO_ATAPI (1 << 1)
323 #define USB_QUIRK_MSC_FORCE_PROTO_UFI (1 << 2)
324 #define USB_QUIRK_MSC_FORCE_PROTO_RBC (1 << 3)
325 #define USB_QUIRK_MSC_FORCE_TRANS_BBB (1 << 4)
326 #define USB_QUIRK_MSC_FORCE_TRANS_CBI (1 << 5)
327 #define USB_QUIRK_MSC_FORCE_TRANS_CBI_I (1 << 6)
328 #define USB_QUIRK_MSC_NO_TEST_UNIT_READY (1 << 7)
329 #define USB_QUIRK_MSC_SHORT_INQUIRY (1 << 8)
330 #define USB_QUIRK_TEST (1 << 31)
331 #define USB_QUIRK_NONE 0
332
333 #ifdef CONFIG_DEBUG_USB
334 #define usb_debug(fmt, args...) do { printk(fmt , ##args); } while (0)
335 #else
336 #define usb_debug(fmt, args...)
337 #endif
338
339 /**
340 * To be implemented by libpayload-client. It's called by the USB stack
341 * when a new USB device is found which isn't claimed by a built in driver,
342 * so the client has the chance to know about it.
343 *
344 * @param dev descriptor for the USB device
345 */
346 void __attribute__((weak)) usb_generic_create (usbdev_t *dev);
347
348 /**
349 * To be implemented by libpayload-client. It's called by the USB stack
350 * when it finds out that a USB device is removed which wasn't claimed by a
351 * built in driver.
352 *
353 * @param dev descriptor for the USB device
354 */
355 void __attribute__((weak)) usb_generic_remove (usbdev_t *dev);
356
357 #endif
358