• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3  * (C) Copyright 2003
4  * Gerry Hamel, geh@ti.com, Texas Instruments
5  *
6  * Based on linux/drivers/usbd/usbd.h
7  *
8  * Copyright (c) 2000, 2001, 2002 Lineo
9  * Copyright (c) 2001 Hewlett Packard
10  *
11  * By:
12  *	Stuart Lynne <sl@lineo.com>,
13  *	Tom Rushworth <tbr@lineo.com>,
14  *	Bruce Balden <balden@lineo.com>
15  */
16 
17 #ifndef __USBDCORE_H__
18 #define __USBDCORE_H__
19 
20 #include <common.h>
21 #include "usbdescriptors.h"
22 
23 
24 #define MAX_URBS_QUEUED 5
25 
26 
27 #if 1
28 #define usberr(fmt,args...) serial_printf("ERROR: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args)
29 #else
30 #define usberr(fmt,args...) do{}while(0)
31 #endif
32 
33 #if 0
34 #define usbdbg(fmt,args...) serial_printf("debug: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args)
35 #else
36 #define usbdbg(fmt,args...) do{}while(0)
37 #endif
38 
39 #if 0
40 #define usbinfo(fmt,args...) serial_printf("info: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args)
41 #else
42 #define usbinfo(fmt,args...) do{}while(0)
43 #endif
44 
45 #ifndef le16_to_cpu
46 #define le16_to_cpu(x)	(x)
47 #endif
48 
49 #ifndef inb
50 #define inb(p)	     (*(volatile u8*)(p))
51 #endif
52 
53 #ifndef outb
54 #define outb(val,p)  (*(volatile u8*)(p) = (val))
55 #endif
56 
57 #ifndef inw
58 #define inw(p)	     (*(volatile u16*)(p))
59 #endif
60 
61 #ifndef outw
62 #define outw(val,p)  (*(volatile u16*)(p) = (val))
63 #endif
64 
65 #ifndef inl
66 #define inl(p)	     (*(volatile u32*)(p))
67 #endif
68 
69 #ifndef outl
70 #define outl(val,p)  (*(volatile u32*)(p) = (val))
71 #endif
72 
73 #ifndef insw
74 #define insw(p,to,len)	   mmio_insw(p,to,len)
75 #endif
76 
77 #ifndef outsw
78 #define outsw(p,from,len)  mmio_outsw(p,from,len)
79 #endif
80 
81 #ifndef insb
82 #define insb(p,to,len)	   mmio_insb(p,to,len)
83 #endif
84 
85 #ifndef mmio_insw
86 #define mmio_insw(r,b,l)	({	int __i ;  \
87 					u16 *__b2;  \
88 					__b2 = (u16 *) b;  \
89 					for (__i = 0; __i < l; __i++) {	 \
90 					  *(__b2 + __i) = inw(r);  \
91 					};  \
92 				})
93 #endif
94 
95 #ifndef mmio_outsw
96 #define mmio_outsw(r,b,l)	({	int __i; \
97 					u16 *__b2; \
98 					__b2 = (u16 *) b; \
99 					for (__i = 0; __i < l; __i++) { \
100 					    outw( *(__b2 + __i), r); \
101 					} \
102 				})
103 #endif
104 
105 #ifndef mmio_insb
106 #define mmio_insb(r,b,l)	({	int __i ;  \
107 					u8 *__b2;  \
108 					__b2 = (u8 *) b;  \
109 					for (__i = 0; __i < l; __i++) {	 \
110 					  *(__b2 + __i) = inb(r);  \
111 					};  \
112 				})
113 #endif
114 
115 /*
116  * Structure member address manipulation macros.
117  * These are used by client code (code using the urb_link routines), since
118  * the urb_link structure is embedded in the client data structures.
119  *
120  * Note: a macro offsetof equivalent to member_offset is defined in stddef.h
121  *	 but this is kept here for the sake of portability.
122  *
123  * p2surround returns a pointer to the surrounding structure given
124  * type of the surrounding structure, the name memb of the structure
125  * member pointed at by ptr.  For example, if you have:
126  *
127  *	struct foo {
128  *	    int x;
129  *	    float y;
130  *	    char z;
131  *	} thingy;
132  *
133  *	char *cp = &thingy.z;
134  *
135  * then
136  *
137  *	&thingy == p2surround(struct foo, z, cp)
138  *
139  * Clear?
140  */
141 #define _cv_(ptr)		  ((char*)(void*)(ptr))
142 #define member_offset(type,memb)  (_cv_(&(((type*)0)->memb))-(char*)0)
143 #define p2surround(type,memb,ptr) ((type*)(void*)(_cv_(ptr)-member_offset(type,memb)))
144 
145 struct urb;
146 
147 struct usb_endpoint_instance;
148 struct usb_interface_instance;
149 struct usb_configuration_instance;
150 struct usb_device_instance;
151 struct usb_bus_instance;
152 
153 /*
154  * Device and/or Interface Class codes
155  */
156 #define USB_CLASS_PER_INTERFACE		0	/* for DeviceClass */
157 #define USB_CLASS_AUDIO			1
158 #define USB_CLASS_COMM			2
159 #define USB_CLASS_HID			3
160 #define USB_CLASS_PHYSICAL		5
161 #define USB_CLASS_PRINTER		7
162 #define USB_CLASS_MASS_STORAGE		8
163 #define USB_CLASS_HUB			9
164 #define USB_CLASS_DATA			10
165 #define USB_CLASS_APP_SPEC		0xfe
166 #define USB_CLASS_VENDOR_SPEC		0xff
167 
168 /*
169  * USB types
170  */
171 #define USB_TYPE_STANDARD		(0x00 << 5)
172 #define USB_TYPE_CLASS			(0x01 << 5)
173 #define USB_TYPE_VENDOR			(0x02 << 5)
174 #define USB_TYPE_RESERVED		(0x03 << 5)
175 
176 /*
177  * USB recipients
178  */
179 #define USB_RECIP_DEVICE		0x00
180 #define USB_RECIP_INTERFACE		0x01
181 #define USB_RECIP_ENDPOINT		0x02
182 #define USB_RECIP_OTHER			0x03
183 
184 /*
185  * USB directions
186  */
187 #define USB_DIR_OUT			0
188 #define USB_DIR_IN			0x80
189 
190 /*
191  * Descriptor types
192  */
193 #define USB_DT_DEVICE			0x01
194 #define USB_DT_CONFIG			0x02
195 #define USB_DT_STRING			0x03
196 #define USB_DT_INTERFACE		0x04
197 #define USB_DT_ENDPOINT			0x05
198 
199 #if defined(CONFIG_USBD_HS)
200 #define USB_DT_QUAL			0x06
201 #endif
202 
203 #define USB_DT_HID			(USB_TYPE_CLASS | 0x01)
204 #define USB_DT_REPORT			(USB_TYPE_CLASS | 0x02)
205 #define USB_DT_PHYSICAL			(USB_TYPE_CLASS | 0x03)
206 #define USB_DT_HUB			(USB_TYPE_CLASS | 0x09)
207 
208 /*
209  * Descriptor sizes per descriptor type
210  */
211 #define USB_DT_DEVICE_SIZE		18
212 #define USB_DT_CONFIG_SIZE		9
213 #define USB_DT_INTERFACE_SIZE		9
214 #define USB_DT_ENDPOINT_SIZE		7
215 #define USB_DT_ENDPOINT_AUDIO_SIZE	9	/* Audio extension */
216 #define USB_DT_HUB_NONVAR_SIZE		7
217 #define USB_DT_HID_SIZE			9
218 
219 /*
220  * Endpoints
221  */
222 #define USB_ENDPOINT_NUMBER_MASK	0x0f	/* in bEndpointAddress */
223 #define USB_ENDPOINT_DIR_MASK		0x80
224 
225 #define USB_ENDPOINT_XFERTYPE_MASK	0x03	/* in bmAttributes */
226 #define USB_ENDPOINT_XFER_CONTROL	0
227 #define USB_ENDPOINT_XFER_ISOC		1
228 #define USB_ENDPOINT_XFER_BULK		2
229 #define USB_ENDPOINT_XFER_INT		3
230 
231 /*
232  * USB Packet IDs (PIDs)
233  */
234 #define USB_PID_UNDEF_0			       0xf0
235 #define USB_PID_OUT			       0xe1
236 #define USB_PID_ACK			       0xd2
237 #define USB_PID_DATA0			       0xc3
238 #define USB_PID_PING			       0xb4	/* USB 2.0 */
239 #define USB_PID_SOF			       0xa5
240 #define USB_PID_NYET			       0x96	/* USB 2.0 */
241 #define USB_PID_DATA2			       0x87	/* USB 2.0 */
242 #define USB_PID_SPLIT			       0x78	/* USB 2.0 */
243 #define USB_PID_IN			       0x69
244 #define USB_PID_NAK			       0x5a
245 #define USB_PID_DATA1			       0x4b
246 #define USB_PID_PREAMBLE		       0x3c	/* Token mode */
247 #define USB_PID_ERR			       0x3c	/* USB 2.0: handshake mode */
248 #define USB_PID_SETUP			       0x2d
249 #define USB_PID_STALL			       0x1e
250 #define USB_PID_MDATA			       0x0f	/* USB 2.0 */
251 
252 /*
253  * Standard requests
254  */
255 #define USB_REQ_GET_STATUS		0x00
256 #define USB_REQ_CLEAR_FEATURE		0x01
257 #define USB_REQ_SET_FEATURE		0x03
258 #define USB_REQ_SET_ADDRESS		0x05
259 #define USB_REQ_GET_DESCRIPTOR		0x06
260 #define USB_REQ_SET_DESCRIPTOR		0x07
261 #define USB_REQ_GET_CONFIGURATION	0x08
262 #define USB_REQ_SET_CONFIGURATION	0x09
263 #define USB_REQ_GET_INTERFACE		0x0A
264 #define USB_REQ_SET_INTERFACE		0x0B
265 #define USB_REQ_SYNCH_FRAME		0x0C
266 
267 #define USBD_DEVICE_REQUESTS(x) (((unsigned int)x <= USB_REQ_SYNCH_FRAME) ? usbd_device_requests[x] : "UNKNOWN")
268 
269 /*
270  * HID requests
271  */
272 #define USB_REQ_GET_REPORT		0x01
273 #define USB_REQ_GET_IDLE		0x02
274 #define USB_REQ_GET_PROTOCOL		0x03
275 #define USB_REQ_SET_REPORT		0x09
276 #define USB_REQ_SET_IDLE		0x0A
277 #define USB_REQ_SET_PROTOCOL		0x0B
278 
279 
280 /*
281  * USB Spec Release number
282  */
283 
284 #if defined(CONFIG_USBD_HS)
285 #define USB_BCD_VERSION			0x0200
286 #else
287 #define USB_BCD_VERSION			0x0110
288 #endif
289 
290 
291 /*
292  * Device Requests	(c.f Table 9-2)
293  */
294 
295 #define USB_REQ_DIRECTION_MASK		0x80
296 #define USB_REQ_TYPE_MASK		0x60
297 #define USB_REQ_RECIPIENT_MASK		0x1f
298 
299 #define USB_REQ_DEVICE2HOST		0x80
300 #define USB_REQ_HOST2DEVICE		0x00
301 
302 #define USB_REQ_TYPE_STANDARD		0x00
303 #define USB_REQ_TYPE_CLASS		0x20
304 #define USB_REQ_TYPE_VENDOR		0x40
305 
306 #define USB_REQ_RECIPIENT_DEVICE	0x00
307 #define USB_REQ_RECIPIENT_INTERFACE	0x01
308 #define USB_REQ_RECIPIENT_ENDPOINT	0x02
309 #define USB_REQ_RECIPIENT_OTHER		0x03
310 
311 /*
312  * get status bits
313  */
314 
315 #define USB_STATUS_SELFPOWERED		0x01
316 #define USB_STATUS_REMOTEWAKEUP		0x02
317 
318 #define USB_STATUS_HALT			0x01
319 
320 /*
321  * descriptor types
322  */
323 
324 #define USB_DESCRIPTOR_TYPE_DEVICE			0x01
325 #define USB_DESCRIPTOR_TYPE_CONFIGURATION		0x02
326 #define USB_DESCRIPTOR_TYPE_STRING			0x03
327 #define USB_DESCRIPTOR_TYPE_INTERFACE			0x04
328 #define USB_DESCRIPTOR_TYPE_ENDPOINT			0x05
329 #define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER		0x06
330 #define USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION	0x07
331 #define USB_DESCRIPTOR_TYPE_INTERFACE_POWER		0x08
332 #define USB_DESCRIPTOR_TYPE_HID				0x21
333 #define USB_DESCRIPTOR_TYPE_REPORT			0x22
334 
335 #define USBD_DEVICE_DESCRIPTORS(x) (((unsigned int)x <= USB_DESCRIPTOR_TYPE_INTERFACE_POWER) ? \
336 		usbd_device_descriptors[x] : "UNKNOWN")
337 
338 /*
339  * standard feature selectors
340  */
341 #define USB_ENDPOINT_HALT		0x00
342 #define USB_DEVICE_REMOTE_WAKEUP	0x01
343 #define USB_TEST_MODE			0x02
344 
345 
346 /* USB Requests
347  *
348  */
349 
350 struct usb_device_request {
351 	u8 bmRequestType;
352 	u8 bRequest;
353 	u16 wValue;
354 	u16 wIndex;
355 	u16 wLength;
356 } __attribute__ ((packed));
357 
358 
359 /* USB Status
360  *
361  */
362 typedef enum urb_send_status {
363 	SEND_IN_PROGRESS,
364 	SEND_FINISHED_OK,
365 	SEND_FINISHED_ERROR,
366 	RECV_READY,
367 	RECV_OK,
368 	RECV_ERROR
369 } urb_send_status_t;
370 
371 /*
372  * Device State (c.f USB Spec 2.0 Figure 9-1)
373  *
374  * What state the usb device is in.
375  *
376  * Note the state does not change if the device is suspended, we simply set a
377  * flag to show that it is suspended.
378  *
379  */
380 typedef enum usb_device_state {
381 	STATE_INIT,		/* just initialized */
382 	STATE_CREATED,		/* just created */
383 	STATE_ATTACHED,		/* we are attached */
384 	STATE_POWERED,		/* we have seen power indication (electrical bus signal) */
385 	STATE_DEFAULT,		/* we been reset */
386 	STATE_ADDRESSED,	/* we have been addressed (in default configuration) */
387 	STATE_CONFIGURED,	/* we have seen a set configuration device command */
388 	STATE_UNKNOWN,		/* destroyed */
389 } usb_device_state_t;
390 
391 #define USBD_DEVICE_STATE(x) (((unsigned int)x <= STATE_UNKNOWN) ? usbd_device_states[x] : "UNKNOWN")
392 
393 /*
394  * Device status
395  *
396  * Overall state
397  */
398 typedef enum usb_device_status {
399 	USBD_OPENING,		/* we are currently opening */
400 	USBD_OK,		/* ok to use */
401 	USBD_SUSPENDED,		/* we are currently suspended */
402 	USBD_CLOSING,		/* we are currently closing */
403 } usb_device_status_t;
404 
405 #define USBD_DEVICE_STATUS(x) (((unsigned int)x <= USBD_CLOSING) ? usbd_device_status[x] : "UNKNOWN")
406 
407 /*
408  * Device Events
409  *
410  * These are defined in the USB Spec (c.f USB Spec 2.0 Figure 9-1).
411  *
412  * There are additional events defined to handle some extra actions we need
413  * to have handled.
414  *
415  */
416 typedef enum usb_device_event {
417 
418 	DEVICE_UNKNOWN,		/* bi - unknown event */
419 	DEVICE_INIT,		/* bi  - initialize */
420 	DEVICE_CREATE,		/* bi  - */
421 	DEVICE_HUB_CONFIGURED,	/* bi  - bus has been plugged int */
422 	DEVICE_RESET,		/* bi  - hub has powered our port */
423 
424 	DEVICE_ADDRESS_ASSIGNED,	/* ep0 - set address setup received */
425 	DEVICE_CONFIGURED,	/* ep0 - set configure setup received */
426 	DEVICE_SET_INTERFACE,	/* ep0 - set interface setup received */
427 
428 	DEVICE_SET_FEATURE,	/* ep0 - set feature setup received */
429 	DEVICE_CLEAR_FEATURE,	/* ep0 - clear feature setup received */
430 
431 	DEVICE_DE_CONFIGURED,	/* ep0 - set configure setup received for ?? */
432 
433 	DEVICE_BUS_INACTIVE,	/* bi  - bus in inactive (no SOF packets) */
434 	DEVICE_BUS_ACTIVITY,	/* bi  - bus is active again */
435 
436 	DEVICE_POWER_INTERRUPTION,	/* bi  - hub has depowered our port */
437 	DEVICE_HUB_RESET,	/* bi  - bus has been unplugged */
438 	DEVICE_DESTROY,		/* bi  - device instance should be destroyed */
439 
440 	DEVICE_HOTPLUG,		/* bi  - a hotplug event has occurred */
441 
442 	DEVICE_FUNCTION_PRIVATE,	/* function - private */
443 
444 } usb_device_event_t;
445 
446 
447 typedef struct urb_link {
448 	struct urb_link *next;
449 	struct urb_link *prev;
450 } urb_link;
451 
452 /* USB Data structure - for passing data around.
453  *
454  * This is used for both sending and receiving data.
455  *
456  * The callback function is used to let the function driver know when
457  * transmitted data has been sent.
458  *
459  * The callback function is set by the alloc_recv function when an urb is
460  * allocated for receiving data for an endpoint and used to call the
461  * function driver to inform it that data has arrived.
462  */
463 
464 /* in linux we'd malloc this, but in u-boot we prefer static data */
465 #define URB_BUF_SIZE 512
466 
467 struct urb {
468 
469 	struct usb_endpoint_instance *endpoint;
470 	struct usb_device_instance *device;
471 
472 	struct usb_device_request device_request;	/* contents of received SETUP packet */
473 
474 	struct urb_link link;	/* embedded struct for circular doubly linked list of urbs */
475 
476 	u8* buffer;
477 	unsigned int buffer_length;
478 	unsigned int actual_length;
479 
480 	urb_send_status_t status;
481 	int data;
482 
483 	u16 buffer_data[URB_BUF_SIZE];	/* data received (OUT) or being sent (IN) */
484 };
485 
486 /* Endpoint configuration
487  *
488  * Per endpoint configuration data. Used to track which function driver owns
489  * an endpoint.
490  *
491  */
492 struct usb_endpoint_instance {
493 	int endpoint_address;	/* logical endpoint address */
494 
495 	/* control */
496 	int status;		/* halted */
497 	int state;		/* available for use by bus interface driver */
498 
499 	/* receive side */
500 	struct urb_link rcv;	/* received urbs */
501 	struct urb_link rdy;	/* empty urbs ready to receive */
502 	struct urb *rcv_urb;	/* active urb */
503 	int rcv_attributes;	/* copy of bmAttributes from endpoint descriptor */
504 	int rcv_packetSize;	/* maximum packet size from endpoint descriptor */
505 	int rcv_transferSize;	/* maximum transfer size from function driver */
506 	int rcv_queue;
507 
508 	/* transmit side */
509 	struct urb_link tx;	/* urbs ready to transmit */
510 	struct urb_link done;	/* transmitted urbs */
511 	struct urb *tx_urb;	/* active urb */
512 	int tx_attributes;	/* copy of bmAttributes from endpoint descriptor */
513 	int tx_packetSize;	/* maximum packet size from endpoint descriptor */
514 	int tx_transferSize;	/* maximum transfer size from function driver */
515 	int tx_queue;
516 
517 	int sent;		/* data already sent */
518 	int last;		/* data sent in last packet XXX do we need this */
519 };
520 
521 struct usb_alternate_instance {
522 	struct usb_interface_descriptor *interface_descriptor;
523 
524 	int endpoints;
525 	int *endpoint_transfersize_array;
526 	struct usb_endpoint_descriptor **endpoints_descriptor_array;
527 };
528 
529 struct usb_interface_instance {
530 	int alternates;
531 	struct usb_alternate_instance *alternates_instance_array;
532 };
533 
534 struct usb_configuration_instance {
535 	int interfaces;
536 	struct usb_configuration_descriptor *configuration_descriptor;
537 	struct usb_interface_instance *interface_instance_array;
538 };
539 
540 
541 /* USB Device Instance
542  *
543  * For each physical bus interface we create a logical device structure. This
544  * tracks all of the required state to track the USB HOST's view of the device.
545  *
546  * Keep track of the device configuration for a real physical bus interface,
547  * this includes the bus interface, multiple function drivers, the current
548  * configuration and the current state.
549  *
550  * This will show:
551  *	the specific bus interface driver
552  *	the default endpoint 0 driver
553  *	the configured function driver
554  *	device state
555  *	device status
556  *	endpoint list
557  */
558 
559 struct usb_device_instance {
560 
561 	/* generic */
562 	char *name;
563 	struct usb_device_descriptor *device_descriptor;	/* per device descriptor */
564 #if defined(CONFIG_USBD_HS)
565 	struct usb_qualifier_descriptor *qualifier_descriptor;
566 #endif
567 
568 	void (*event) (struct usb_device_instance *device, usb_device_event_t event, int data);
569 
570 	/* Do cdc device specific control requests */
571 	int (*cdc_recv_setup)(struct usb_device_request *request, struct urb *urb);
572 
573 	/* bus interface */
574 	struct usb_bus_instance *bus;	/* which bus interface driver */
575 
576 	/* configuration descriptors */
577 	int configurations;
578 	struct usb_configuration_instance *configuration_instance_array;
579 
580 	/* device state */
581 	usb_device_state_t device_state;	/* current USB Device state */
582 	usb_device_state_t device_previous_state;	/* current USB Device state */
583 
584 	u8 address;		/* current address (zero is default) */
585 	u8 configuration;	/* current show configuration (zero is default) */
586 	u8 interface;		/* current interface (zero is default) */
587 	u8 alternate;		/* alternate flag */
588 
589 	usb_device_status_t status;	/* device status */
590 
591 	int urbs_queued;	/* number of submitted urbs */
592 
593 	/* Shouldn't need to make this atomic, all we need is a change indicator */
594 	unsigned long usbd_rxtx_timestamp;
595 	unsigned long usbd_last_rxtx_timestamp;
596 
597 };
598 
599 /* Bus Interface configuration structure
600  *
601  * This is allocated for each configured instance of a bus interface driver.
602  *
603  * The privdata pointer may be used by the bus interface driver to store private
604  * per instance state information.
605  */
606 struct usb_bus_instance {
607 
608 	struct usb_device_instance *device;
609 	struct usb_endpoint_instance *endpoint_array;	/* array of available configured endpoints */
610 
611 	int max_endpoints;	/* maximimum number of rx enpoints */
612 	unsigned char			maxpacketsize;
613 
614 	unsigned int serial_number;
615 	char *serial_number_str;
616 	void *privdata;		/* private data for the bus interface */
617 
618 };
619 
620 extern char *usbd_device_events[];
621 extern char *usbd_device_states[];
622 extern char *usbd_device_status[];
623 extern char *usbd_device_requests[];
624 extern char *usbd_device_descriptors[];
625 
626 void urb_link_init (urb_link * ul);
627 void urb_detach (struct urb *urb);
628 urb_link *first_urb_link (urb_link * hd);
629 struct urb *first_urb (urb_link * hd);
630 struct urb *first_urb_detached (urb_link * hd);
631 void urb_append (urb_link * hd, struct urb *urb);
632 
633 struct urb *usbd_alloc_urb (struct usb_device_instance *device, struct usb_endpoint_instance *endpoint);
634 void	    usbd_dealloc_urb (struct urb *urb);
635 
636 /*
637  * usbd_device_event is used by bus interface drivers to tell the higher layers that
638  * certain events have taken place.
639  */
640 void usbd_device_event_irq (struct usb_device_instance *conf, usb_device_event_t, int);
641 void usbd_device_event (struct usb_device_instance *conf, usb_device_event_t, int);
642 
643 /* descriptors
644  *
645  * Various ways of finding descriptors based on the current device and any
646  * possible configuration / interface / endpoint for it.
647  */
648 struct usb_configuration_descriptor *usbd_device_configuration_descriptor (struct usb_device_instance *, int, int);
649 struct usb_function_instance *usbd_device_function_instance (struct usb_device_instance *, unsigned int);
650 struct usb_interface_instance *usbd_device_interface_instance (struct usb_device_instance *, int, int, int);
651 struct usb_alternate_instance *usbd_device_alternate_instance (struct usb_device_instance *, int, int, int, int);
652 struct usb_interface_descriptor *usbd_device_interface_descriptor (struct usb_device_instance *, int, int, int, int);
653 struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor_index (struct usb_device_instance *, int, int, int, int, int);
654 struct usb_class_descriptor *usbd_device_class_descriptor_index (struct usb_device_instance *, int, int, int, int, int);
655 struct usb_class_report_descriptor *usbd_device_class_report_descriptor_index( struct usb_device_instance *, int , int , int , int , int );
656 struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor (struct usb_device_instance *, int, int, int, int, int);
657 int				usbd_device_endpoint_transfersize (struct usb_device_instance *, int, int, int, int, int);
658 struct usb_string_descriptor *usbd_get_string (u8);
659 struct usb_device_descriptor *usbd_device_device_descriptor(struct
660 		usb_device_instance *, int);
661 
662 #if defined(CONFIG_USBD_HS)
663 /*
664  * is_usbd_high_speed routine needs to be defined by specific gadget driver
665  * It returns true if device enumerates at High speed
666  * Retuns false otherwise
667  */
668 int is_usbd_high_speed(void);
669 #endif
670 int usbd_endpoint_halted (struct usb_device_instance *device, int endpoint);
671 void usbd_rcv_complete(struct usb_endpoint_instance *endpoint, int len, int urb_bad);
672 void usbd_tx_complete (struct usb_endpoint_instance *endpoint);
673 
674 /* These are macros used in debugging */
675 #ifdef DEBUG
print_urb(struct urb * u)676 static inline void print_urb(struct urb *u)
677 {
678 	serial_printf("urb %p\n", (u));
679 	serial_printf("\tendpoint %p\n", u->endpoint);
680 	serial_printf("\tdevice %p\n", u->device);
681 	serial_printf("\tbuffer %p\n", u->buffer);
682 	serial_printf("\tbuffer_length %d\n", u->buffer_length);
683 	serial_printf("\tactual_length %d\n", u->actual_length);
684 	serial_printf("\tstatus %d\n", u->status);
685 	serial_printf("\tdata %d\n", u->data);
686 }
687 
print_usb_device_request(struct usb_device_request * r)688 static inline void print_usb_device_request(struct usb_device_request *r)
689 {
690 	serial_printf("usb request\n");
691 	serial_printf("\tbmRequestType 0x%2.2x\n", r->bmRequestType);
692 	if ((r->bmRequestType & USB_REQ_DIRECTION_MASK) == 0)
693 		serial_printf("\t\tDirection : To device\n");
694 	else
695 		serial_printf("\t\tDirection : To host\n");
696 	if ((r->bmRequestType & USB_TYPE_STANDARD) == USB_TYPE_STANDARD)
697 		serial_printf("\t\tType      : Standard\n");
698 	if ((r->bmRequestType & USB_TYPE_CLASS) == USB_TYPE_CLASS)
699 		serial_printf("\t\tType      : Standard\n");
700 	if ((r->bmRequestType & USB_TYPE_VENDOR) == USB_TYPE_VENDOR)
701 		serial_printf("\t\tType      : Standard\n");
702 	if ((r->bmRequestType & USB_TYPE_RESERVED) == USB_TYPE_RESERVED)
703 		serial_printf("\t\tType      : Standard\n");
704 	if ((r->bmRequestType & USB_REQ_RECIPIENT_MASK) ==
705 	    USB_REQ_RECIPIENT_DEVICE)
706 		serial_printf("\t\tRecipient : Device\n");
707 	if ((r->bmRequestType & USB_REQ_RECIPIENT_MASK) ==
708 	    USB_REQ_RECIPIENT_INTERFACE)
709 		serial_printf("\t\tRecipient : Interface\n");
710 	if ((r->bmRequestType & USB_REQ_RECIPIENT_MASK) ==
711 	    USB_REQ_RECIPIENT_ENDPOINT)
712 		serial_printf("\t\tRecipient : Endpoint\n");
713 	if ((r->bmRequestType & USB_REQ_RECIPIENT_MASK) ==
714 	    USB_REQ_RECIPIENT_OTHER)
715 		serial_printf("\t\tRecipient : Other\n");
716 	serial_printf("\tbRequest      0x%2.2x\n", r->bRequest);
717 	if (r->bRequest == USB_REQ_GET_STATUS)
718 		serial_printf("\t\tGET_STATUS\n");
719 	else if (r->bRequest == USB_REQ_SET_ADDRESS)
720 		serial_printf("\t\tSET_ADDRESS\n");
721 	else if (r->bRequest == USB_REQ_SET_FEATURE)
722 		serial_printf("\t\tSET_FEATURE\n");
723 	else if (r->bRequest == USB_REQ_GET_DESCRIPTOR)
724 		serial_printf("\t\tGET_DESCRIPTOR\n");
725 	else if (r->bRequest == USB_REQ_SET_CONFIGURATION)
726 		serial_printf("\t\tSET_CONFIGURATION\n");
727 	else if (r->bRequest == USB_REQ_SET_INTERFACE)
728 		serial_printf("\t\tUSB_REQ_SET_INTERFACE\n");
729 	else
730 		serial_printf("\tUNKNOWN %d\n", r->bRequest);
731 	serial_printf("\twValue        0x%4.4x\n", r->wValue);
732 	if (r->bRequest == USB_REQ_GET_DESCRIPTOR) {
733 		switch (r->wValue >> 8) {
734 		case USB_DESCRIPTOR_TYPE_DEVICE:
735 			serial_printf("\tDEVICE\n");
736 			break;
737 		case USB_DESCRIPTOR_TYPE_CONFIGURATION:
738 			serial_printf("\tCONFIGURATION\n");
739 			break;
740 		case USB_DESCRIPTOR_TYPE_STRING:
741 			serial_printf("\tSTRING\n");
742 			break;
743 		case USB_DESCRIPTOR_TYPE_INTERFACE:
744 			serial_printf("\tINTERFACE\n");
745 			break;
746 		case USB_DESCRIPTOR_TYPE_ENDPOINT:
747 			serial_printf("\tENDPOINT\n");
748 			break;
749 		case USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER:
750 			serial_printf("\tDEVICE_QUALIFIER\n");
751 			break;
752 		case USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION:
753 			serial_printf("\tOTHER_SPEED_CONFIGURATION\n");
754 			break;
755 		case USB_DESCRIPTOR_TYPE_INTERFACE_POWER:
756 			serial_printf("\tINTERFACE_POWER\n");
757 			break;
758 		case USB_DESCRIPTOR_TYPE_HID:
759 			serial_printf("\tHID\n");
760 			break;
761 		case USB_DESCRIPTOR_TYPE_REPORT:
762 			serial_printf("\tREPORT\n");
763 			break;
764 		default:
765 			serial_printf("\tUNKNOWN TYPE\n");
766 			break;
767 		}
768 	}
769 	serial_printf("\twIndex        0x%4.4x\n", r->wIndex);
770 	serial_printf("\twLength       0x%4.4x\n", r->wLength);
771 }
772 #else
773 /* stubs */
774 #define print_urb(u)
775 #define print_usb_device_request(r)
776 #endif /* DEBUG */
777 #endif
778