• 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
7  * linux/drivers/usbd/usbd.c.c - USB Device Core Layer
8  *
9  * Copyright (c) 2000, 2001, 2002 Lineo
10  * Copyright (c) 2001 Hewlett Packard
11  *
12  * By:
13  *	Stuart Lynne <sl@lineo.com>,
14  *	Tom Rushworth <tbr@lineo.com>,
15  *	Bruce Balden <balden@lineo.com>
16  */
17 
18 #include <malloc.h>
19 #include <usbdevice.h>
20 
21 #define MAX_INTERFACES 2
22 
23 
24 int maxstrings = 20;
25 
26 /* Global variables ************************************************************************** */
27 
28 struct usb_string_descriptor **usb_strings;
29 
30 int usb_devices;
31 
32 extern struct usb_function_driver ep0_driver;
33 
34 int registered_functions;
35 int registered_devices;
36 
37 char *usbd_device_events[] = {
38 	"DEVICE_UNKNOWN",
39 	"DEVICE_INIT",
40 	"DEVICE_CREATE",
41 	"DEVICE_HUB_CONFIGURED",
42 	"DEVICE_RESET",
43 	"DEVICE_ADDRESS_ASSIGNED",
44 	"DEVICE_CONFIGURED",
45 	"DEVICE_SET_INTERFACE",
46 	"DEVICE_SET_FEATURE",
47 	"DEVICE_CLEAR_FEATURE",
48 	"DEVICE_DE_CONFIGURED",
49 	"DEVICE_BUS_INACTIVE",
50 	"DEVICE_BUS_ACTIVITY",
51 	"DEVICE_POWER_INTERRUPTION",
52 	"DEVICE_HUB_RESET",
53 	"DEVICE_DESTROY",
54 	"DEVICE_FUNCTION_PRIVATE",
55 };
56 
57 char *usbd_device_states[] = {
58 	"STATE_INIT",
59 	"STATE_CREATED",
60 	"STATE_ATTACHED",
61 	"STATE_POWERED",
62 	"STATE_DEFAULT",
63 	"STATE_ADDRESSED",
64 	"STATE_CONFIGURED",
65 	"STATE_UNKNOWN",
66 };
67 
68 char *usbd_device_requests[] = {
69 	"GET STATUS",		/* 0 */
70 	"CLEAR FEATURE",	/* 1 */
71 	"RESERVED",		/* 2 */
72 	"SET FEATURE",		/* 3 */
73 	"RESERVED",		/* 4 */
74 	"SET ADDRESS",		/* 5 */
75 	"GET DESCRIPTOR",	/* 6 */
76 	"SET DESCRIPTOR",	/* 7 */
77 	"GET CONFIGURATION",	/* 8 */
78 	"SET CONFIGURATION",	/* 9 */
79 	"GET INTERFACE",	/* 10 */
80 	"SET INTERFACE",	/* 11 */
81 	"SYNC FRAME",		/* 12 */
82 };
83 
84 char *usbd_device_descriptors[] = {
85 	"UNKNOWN",		/* 0 */
86 	"DEVICE",		/* 1 */
87 	"CONFIG",		/* 2 */
88 	"STRING",		/* 3 */
89 	"INTERFACE",		/* 4 */
90 	"ENDPOINT",		/* 5 */
91 	"DEVICE QUALIFIER",	/* 6 */
92 	"OTHER SPEED",		/* 7 */
93 	"INTERFACE POWER",	/* 8 */
94 };
95 
96 char *usbd_device_status[] = {
97 	"USBD_OPENING",
98 	"USBD_OK",
99 	"USBD_SUSPENDED",
100 	"USBD_CLOSING",
101 };
102 
103 
104 /* Descriptor support functions ************************************************************** */
105 
106 
107 /**
108  * usbd_get_string - find and return a string descriptor
109  * @index: string index to return
110  *
111  * Find an indexed string and return a pointer to a it.
112  */
usbd_get_string(__u8 index)113 struct usb_string_descriptor *usbd_get_string (__u8 index)
114 {
115 	if (index >= maxstrings) {
116 		return NULL;
117 	}
118 	return usb_strings[index];
119 }
120 
121 
122 /* Access to device descriptor functions ***************************************************** */
123 
124 
125 /* *
126  * usbd_device_configuration_instance - find a configuration instance for this device
127  * @device:
128  * @configuration: index to configuration, 0 - N-1
129  *
130  * Get specifed device configuration. Index should be bConfigurationValue-1.
131  */
usbd_device_configuration_instance(struct usb_device_instance * device,unsigned int port,unsigned int configuration)132 static struct usb_configuration_instance *usbd_device_configuration_instance (struct usb_device_instance *device,
133 		unsigned int port, unsigned int configuration)
134 {
135 	if (configuration >= device->configurations)
136 		return NULL;
137 
138 	return device->configuration_instance_array + configuration;
139 }
140 
141 
142 /* *
143  * usbd_device_interface_instance
144  * @device:
145  * @configuration: index to configuration, 0 - N-1
146  * @interface: index to interface
147  *
148  * Return the specified interface descriptor for the specified device.
149  */
usbd_device_interface_instance(struct usb_device_instance * device,int port,int configuration,int interface)150 struct usb_interface_instance *usbd_device_interface_instance (struct usb_device_instance *device, int port, int configuration, int interface)
151 {
152 	struct usb_configuration_instance *configuration_instance;
153 
154 	if ((configuration_instance = usbd_device_configuration_instance (device, port, configuration)) == NULL) {
155 		return NULL;
156 	}
157 	if (interface >= configuration_instance->interfaces) {
158 		return NULL;
159 	}
160 	return configuration_instance->interface_instance_array + interface;
161 }
162 
163 /* *
164  * usbd_device_alternate_descriptor_list
165  * @device:
166  * @configuration: index to configuration, 0 - N-1
167  * @interface: index to interface
168  * @alternate: alternate setting
169  *
170  * Return the specified alternate descriptor for the specified device.
171  */
usbd_device_alternate_instance(struct usb_device_instance * device,int port,int configuration,int interface,int alternate)172 struct usb_alternate_instance *usbd_device_alternate_instance (struct usb_device_instance *device, int port, int configuration, int interface, int alternate)
173 {
174 	struct usb_interface_instance *interface_instance;
175 
176 	if ((interface_instance = usbd_device_interface_instance (device, port, configuration, interface)) == NULL) {
177 		return NULL;
178 	}
179 
180 	if (alternate >= interface_instance->alternates) {
181 		return NULL;
182 	}
183 
184 	return interface_instance->alternates_instance_array + alternate;
185 }
186 
187 
188 /* *
189  * usbd_device_device_descriptor
190  * @device: which device
191  * @configuration: index to configuration, 0 - N-1
192  * @port: which port
193  *
194  * Return the specified configuration descriptor for the specified device.
195  */
usbd_device_device_descriptor(struct usb_device_instance * device,int port)196 struct usb_device_descriptor *usbd_device_device_descriptor (struct usb_device_instance *device, int port)
197 {
198 	return (device->device_descriptor);
199 }
200 
201 /**
202  * usbd_device_configuration_descriptor
203  * @device: which device
204  * @port: which port
205  * @configuration: index to configuration, 0 - N-1
206  *
207  * Return the specified configuration descriptor for the specified device.
208  */
usbd_device_configuration_descriptor(struct usb_device_instance * device,int port,int configuration)209 struct usb_configuration_descriptor *usbd_device_configuration_descriptor (struct
210 									   usb_device_instance
211 									   *device, int port, int configuration)
212 {
213 	struct usb_configuration_instance *configuration_instance;
214 	if (!(configuration_instance = usbd_device_configuration_instance (device, port, configuration))) {
215 		return NULL;
216 	}
217 	return (configuration_instance->configuration_descriptor);
218 }
219 
220 
221 /**
222  * usbd_device_interface_descriptor
223  * @device: which device
224  * @port: which port
225  * @configuration: index to configuration, 0 - N-1
226  * @interface: index to interface
227  * @alternate: alternate setting
228  *
229  * Return the specified interface descriptor for the specified device.
230  */
usbd_device_interface_descriptor(struct usb_device_instance * device,int port,int configuration,int interface,int alternate)231 struct usb_interface_descriptor *usbd_device_interface_descriptor (struct usb_device_instance
232 								   *device, int port, int configuration, int interface, int alternate)
233 {
234 	struct usb_interface_instance *interface_instance;
235 	if (!(interface_instance = usbd_device_interface_instance (device, port, configuration, interface))) {
236 		return NULL;
237 	}
238 	if ((alternate < 0) || (alternate >= interface_instance->alternates)) {
239 		return NULL;
240 	}
241 	return (interface_instance->alternates_instance_array[alternate].interface_descriptor);
242 }
243 
244 /**
245  * usbd_device_endpoint_descriptor_index
246  * @device: which device
247  * @port: which port
248  * @configuration: index to configuration, 0 - N-1
249  * @interface: index to interface
250  * @alternate: index setting
251  * @index: which index
252  *
253  * Return the specified endpoint descriptor for the specified device.
254  */
usbd_device_endpoint_descriptor_index(struct usb_device_instance * device,int port,int configuration,int interface,int alternate,int index)255 struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor_index (struct usb_device_instance
256 								       *device, int port, int configuration, int interface, int alternate, int index)
257 {
258 	struct usb_alternate_instance *alternate_instance;
259 
260 	if (!(alternate_instance = usbd_device_alternate_instance (device, port, configuration, interface, alternate))) {
261 		return NULL;
262 	}
263 	if (index >= alternate_instance->endpoints) {
264 		return NULL;
265 	}
266 	return *(alternate_instance->endpoints_descriptor_array + index);
267 }
268 
269 
270 /**
271  * usbd_device_endpoint_transfersize
272  * @device: which device
273  * @port: which port
274  * @configuration: index to configuration, 0 - N-1
275  * @interface: index to interface
276  * @index: which index
277  *
278  * Return the specified endpoint transfer size;
279  */
usbd_device_endpoint_transfersize(struct usb_device_instance * device,int port,int configuration,int interface,int alternate,int index)280 int usbd_device_endpoint_transfersize (struct usb_device_instance *device, int port, int configuration, int interface, int alternate, int index)
281 {
282 	struct usb_alternate_instance *alternate_instance;
283 
284 	if (!(alternate_instance = usbd_device_alternate_instance (device, port, configuration, interface, alternate))) {
285 		return 0;
286 	}
287 	if (index >= alternate_instance->endpoints) {
288 		return 0;
289 	}
290 	return *(alternate_instance->endpoint_transfersize_array + index);
291 }
292 
293 
294 /**
295  * usbd_device_endpoint_descriptor
296  * @device: which device
297  * @port: which port
298  * @configuration: index to configuration, 0 - N-1
299  * @interface: index to interface
300  * @alternate: alternate setting
301  * @endpoint: which endpoint
302  *
303  * Return the specified endpoint descriptor for the specified device.
304  */
usbd_device_endpoint_descriptor(struct usb_device_instance * device,int port,int configuration,int interface,int alternate,int endpoint)305 struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor (struct usb_device_instance *device, int port, int configuration, int interface, int alternate, int endpoint)
306 {
307 	struct usb_endpoint_descriptor *endpoint_descriptor;
308 	int i;
309 
310 	for (i = 0; !(endpoint_descriptor = usbd_device_endpoint_descriptor_index (device, port, configuration, interface, alternate, i)); i++) {
311 		if (endpoint_descriptor->bEndpointAddress == endpoint) {
312 			return endpoint_descriptor;
313 		}
314 	}
315 	return NULL;
316 }
317 
318 /**
319  * usbd_endpoint_halted
320  * @device: point to struct usb_device_instance
321  * @endpoint: endpoint to check
322  *
323  * Return non-zero if endpoint is halted.
324  */
usbd_endpoint_halted(struct usb_device_instance * device,int endpoint)325 int usbd_endpoint_halted (struct usb_device_instance *device, int endpoint)
326 {
327 	return (device->status == USB_STATUS_HALT);
328 }
329 
330 
331 /**
332  * usbd_rcv_complete - complete a receive
333  * @endpoint:
334  * @len:
335  * @urb_bad:
336  *
337  * Called from rcv interrupt to complete.
338  */
usbd_rcv_complete(struct usb_endpoint_instance * endpoint,int len,int urb_bad)339 void usbd_rcv_complete(struct usb_endpoint_instance *endpoint, int len, int urb_bad)
340 {
341 	if (endpoint) {
342 		struct urb *rcv_urb;
343 
344 		/*usbdbg("len: %d urb: %p\n", len, endpoint->rcv_urb); */
345 
346 		/* if we had an urb then update actual_length, dispatch if neccessary */
347 		if ((rcv_urb = endpoint->rcv_urb)) {
348 
349 			/*usbdbg("actual: %d buffer: %d\n", */
350 			/*rcv_urb->actual_length, rcv_urb->buffer_length); */
351 
352 			/* check the urb is ok, are we adding data less than the packetsize */
353 			if (!urb_bad && (len <= endpoint->rcv_packetSize)) {
354 			  /*usbdbg("updating actual_length by %d\n",len); */
355 
356 				/* increment the received data size */
357 				rcv_urb->actual_length += len;
358 
359 			} else {
360 				usberr(" RECV_ERROR actual: %d buffer: %d urb_bad: %d\n",
361 				       rcv_urb->actual_length, rcv_urb->buffer_length, urb_bad);
362 
363 				rcv_urb->actual_length = 0;
364 				rcv_urb->status = RECV_ERROR;
365 			}
366 		} else {
367 			usberr("no rcv_urb!");
368 		}
369 	} else {
370 		usberr("no endpoint!");
371 	}
372 
373 }
374 
375 /**
376  * usbd_tx_complete - complete a transmit
377  * @endpoint:
378  * @resetart:
379  *
380  * Called from tx interrupt to complete.
381  */
usbd_tx_complete(struct usb_endpoint_instance * endpoint)382 void usbd_tx_complete (struct usb_endpoint_instance *endpoint)
383 {
384 	if (endpoint) {
385 		struct urb *tx_urb;
386 
387 		/* if we have a tx_urb advance or reset, finish if complete */
388 		if ((tx_urb = endpoint->tx_urb)) {
389 			int sent = endpoint->last;
390 			endpoint->sent += sent;
391 			endpoint->last -= sent;
392 
393 			if( (endpoint->tx_urb->actual_length - endpoint->sent) <= 0 ) {
394 				tx_urb->actual_length = 0;
395 				endpoint->sent = 0;
396 				endpoint->last = 0;
397 
398 				/* Remove from active, save for re-use */
399 				urb_detach(tx_urb);
400 				urb_append(&endpoint->done, tx_urb);
401 				/*usbdbg("done->next %p, tx_urb %p, done %p", */
402 				/*	 endpoint->done.next, tx_urb, &endpoint->done); */
403 
404 				endpoint->tx_urb = first_urb_detached(&endpoint->tx);
405 				if( endpoint->tx_urb ) {
406 					endpoint->tx_queue--;
407 					usbdbg("got urb from tx list");
408 				}
409 				if( !endpoint->tx_urb ) {
410 					/*usbdbg("taking urb from done list"); */
411 					endpoint->tx_urb = first_urb_detached(&endpoint->done);
412 				}
413 				if( !endpoint->tx_urb ) {
414 					usbdbg("allocating new urb for tx_urb");
415 					endpoint->tx_urb = usbd_alloc_urb(tx_urb->device, endpoint);
416 				}
417 			}
418 		}
419 	}
420 }
421 
422 /* URB linked list functions ***************************************************** */
423 
424 /*
425  * Initialize an urb_link to be a single element list.
426  * If the urb_link is being used as a distinguished list head
427  * the list is empty when the head is the only link in the list.
428  */
urb_link_init(urb_link * ul)429 void urb_link_init (urb_link * ul)
430 {
431 	if (ul) {
432 		ul->prev = ul->next = ul;
433 	}
434 }
435 
436 /*
437  * Detach an urb_link from a list, and set it
438  * up as a single element list, so no dangling
439  * pointers can be followed, and so it can be
440  * joined to another list if so desired.
441  */
urb_detach(struct urb * urb)442 void urb_detach (struct urb *urb)
443 {
444 	if (urb) {
445 		urb_link *ul = &urb->link;
446 		ul->next->prev = ul->prev;
447 		ul->prev->next = ul->next;
448 		urb_link_init (ul);
449 	}
450 }
451 
452 /*
453  * Return the first urb_link in a list with a distinguished
454  * head "hd", or NULL if the list is empty.  This will also
455  * work as a predicate, returning NULL if empty, and non-NULL
456  * otherwise.
457  */
first_urb_link(urb_link * hd)458 urb_link *first_urb_link (urb_link * hd)
459 {
460 	urb_link *nx;
461 	if (NULL != hd && NULL != (nx = hd->next) && nx != hd) {
462 		/* There is at least one element in the list */
463 		/* (besides the distinguished head). */
464 		return (nx);
465 	}
466 	/* The list is empty */
467 	return (NULL);
468 }
469 
470 /*
471  * Return the first urb in a list with a distinguished
472  * head "hd", or NULL if the list is empty.
473  */
first_urb(urb_link * hd)474 struct urb *first_urb (urb_link * hd)
475 {
476 	urb_link *nx;
477 	if (NULL == (nx = first_urb_link (hd))) {
478 		/* The list is empty */
479 		return (NULL);
480 	}
481 	return (p2surround (struct urb, link, nx));
482 }
483 
484 /*
485  * Detach and return the first urb in a list with a distinguished
486  * head "hd", or NULL if the list is empty.
487  *
488  */
first_urb_detached(urb_link * hd)489 struct urb *first_urb_detached (urb_link * hd)
490 {
491 	struct urb *urb;
492 	if ((urb = first_urb (hd))) {
493 		urb_detach (urb);
494 	}
495 	return urb;
496 }
497 
498 
499 /*
500  * Append an urb_link (or a whole list of
501  * urb_links) to the tail of another list
502  * of urb_links.
503  */
urb_append(urb_link * hd,struct urb * urb)504 void urb_append (urb_link * hd, struct urb *urb)
505 {
506 	if (hd && urb) {
507 		urb_link *new = &urb->link;
508 
509 		/* This allows the new urb to be a list of urbs, */
510 		/* with new pointing at the first, but the link */
511 		/* must be initialized. */
512 		/* Order is important here... */
513 		urb_link *pul = hd->prev;
514 		new->prev->next = hd;
515 		hd->prev = new->prev;
516 		new->prev = pul;
517 		pul->next = new;
518 	}
519 }
520 
521 /* URB create/destroy functions ***************************************************** */
522 
523 /**
524  * usbd_alloc_urb - allocate an URB appropriate for specified endpoint
525  * @device: device instance
526  * @endpoint: endpoint
527  *
528  * Allocate an urb structure. The usb device urb structure is used to
529  * contain all data associated with a transfer, including a setup packet for
530  * control transfers.
531  *
532  * NOTE: endpoint_address MUST contain a direction flag.
533  */
usbd_alloc_urb(struct usb_device_instance * device,struct usb_endpoint_instance * endpoint)534 struct urb *usbd_alloc_urb (struct usb_device_instance *device,
535 			    struct usb_endpoint_instance *endpoint)
536 {
537 	struct urb *urb;
538 
539 	if (!(urb = (struct urb *) malloc (sizeof (struct urb)))) {
540 		usberr (" F A T A L:  malloc(%zu) FAILED!!!!",
541 			sizeof (struct urb));
542 		return NULL;
543 	}
544 
545 	/* Fill in known fields */
546 	memset (urb, 0, sizeof (struct urb));
547 	urb->endpoint = endpoint;
548 	urb->device = device;
549 	urb->buffer = (u8 *) urb->buffer_data;
550 	urb->buffer_length = sizeof (urb->buffer_data);
551 
552 	urb_link_init (&urb->link);
553 
554 	return urb;
555 }
556 
557 /**
558  * usbd_dealloc_urb - deallocate an URB and associated buffer
559  * @urb: pointer to an urb structure
560  *
561  * Deallocate an urb structure and associated data.
562  */
usbd_dealloc_urb(struct urb * urb)563 void usbd_dealloc_urb (struct urb *urb)
564 {
565 	if (urb) {
566 		free (urb);
567 	}
568 }
569 
570 /* Event signaling functions ***************************************************** */
571 
572 /**
573  * usbd_device_event - called to respond to various usb events
574  * @device: pointer to struct device
575  * @event: event to respond to
576  *
577  * Used by a Bus driver to indicate an event.
578  */
usbd_device_event_irq(struct usb_device_instance * device,usb_device_event_t event,int data)579 void usbd_device_event_irq (struct usb_device_instance *device, usb_device_event_t event, int data)
580 {
581 	usb_device_state_t state;
582 
583 	if (!device || !device->bus) {
584 		usberr("(%p,%d) NULL device or device->bus", device, event);
585 		return;
586 	}
587 
588 	state = device->device_state;
589 
590 	usbinfo("%s", usbd_device_events[event]);
591 
592 	switch (event) {
593 	case DEVICE_UNKNOWN:
594 		break;
595 	case DEVICE_INIT:
596 		device->device_state = STATE_INIT;
597 		break;
598 
599 	case DEVICE_CREATE:
600 		device->device_state = STATE_ATTACHED;
601 		break;
602 
603 	case DEVICE_HUB_CONFIGURED:
604 		device->device_state = STATE_POWERED;
605 		break;
606 
607 	case DEVICE_RESET:
608 		device->device_state = STATE_DEFAULT;
609 		device->address = 0;
610 		break;
611 
612 	case DEVICE_ADDRESS_ASSIGNED:
613 		device->device_state = STATE_ADDRESSED;
614 		break;
615 
616 	case DEVICE_CONFIGURED:
617 		device->device_state = STATE_CONFIGURED;
618 		break;
619 
620 	case DEVICE_DE_CONFIGURED:
621 		device->device_state = STATE_ADDRESSED;
622 		break;
623 
624 	case DEVICE_BUS_INACTIVE:
625 		if (device->status != USBD_CLOSING) {
626 			device->status = USBD_SUSPENDED;
627 		}
628 		break;
629 	case DEVICE_BUS_ACTIVITY:
630 		if (device->status != USBD_CLOSING) {
631 			device->status = USBD_OK;
632 		}
633 		break;
634 
635 	case DEVICE_SET_INTERFACE:
636 		break;
637 	case DEVICE_SET_FEATURE:
638 		break;
639 	case DEVICE_CLEAR_FEATURE:
640 		break;
641 
642 	case DEVICE_POWER_INTERRUPTION:
643 		device->device_state = STATE_POWERED;
644 		break;
645 	case DEVICE_HUB_RESET:
646 		device->device_state = STATE_ATTACHED;
647 		break;
648 	case DEVICE_DESTROY:
649 		device->device_state = STATE_UNKNOWN;
650 		break;
651 
652 	case DEVICE_FUNCTION_PRIVATE:
653 		break;
654 
655 	default:
656 		usbdbg("event %d - not handled",event);
657 		break;
658 	}
659 	debug("%s event: %d oldstate: %d newstate: %d status: %d address: %d",
660 		device->name, event, state,
661 		device->device_state, device->status, device->address);
662 
663 	/* tell the bus interface driver */
664 	if( device->event ) {
665 		/* usbdbg("calling device->event"); */
666 		device->event(device, event, data);
667 	}
668 }
669