]> git.ipfire.org Git - people/ms/u-boot.git/blob - drivers/serial/usbtty.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Enable high speed support for USB device framework and usbtty
[people/ms/u-boot.git] / drivers / serial / usbtty.c
1 /*
2 * (C) Copyright 2003
3 * Gerry Hamel, geh@ti.com, Texas Instruments
4 *
5 * (C) Copyright 2006
6 * Bryan O'Donoghue, bodonoghue@codehermit.ie
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23
24 #include <common.h>
25 #include <config.h>
26 #include <circbuf.h>
27 #include <stdio_dev.h>
28 #include <asm/unaligned.h>
29 #include "usbtty.h"
30 #include "usb_cdc_acm.h"
31 #include "usbdescriptors.h"
32
33 #ifdef DEBUG
34 #define TTYDBG(fmt,args...)\
35 serial_printf("[%s] %s %d: "fmt, __FILE__,__FUNCTION__,__LINE__,##args)
36 #else
37 #define TTYDBG(fmt,args...) do{}while(0)
38 #endif
39
40 #if 1
41 #define TTYERR(fmt,args...)\
42 serial_printf("ERROR![%s] %s %d: "fmt, __FILE__,__FUNCTION__,\
43 __LINE__,##args)
44 #else
45 #define TTYERR(fmt,args...) do{}while(0)
46 #endif
47
48 /*
49 * Defines
50 */
51 #define NUM_CONFIGS 1
52 #define MAX_INTERFACES 2
53 #define NUM_ENDPOINTS 3
54 #define ACM_TX_ENDPOINT 3
55 #define ACM_RX_ENDPOINT 2
56 #define GSERIAL_TX_ENDPOINT 2
57 #define GSERIAL_RX_ENDPOINT 1
58 #define NUM_ACM_INTERFACES 2
59 #define NUM_GSERIAL_INTERFACES 1
60 #define CONFIG_USBD_DATA_INTERFACE_STR "Bulk Data Interface"
61 #define CONFIG_USBD_CTRL_INTERFACE_STR "Control Interface"
62
63 /*
64 * Buffers to hold input and output data
65 */
66 #define USBTTY_BUFFER_SIZE 256
67 static circbuf_t usbtty_input;
68 static circbuf_t usbtty_output;
69
70
71 /*
72 * Instance variables
73 */
74 static struct stdio_dev usbttydev;
75 static struct usb_device_instance device_instance[1];
76 static struct usb_bus_instance bus_instance[1];
77 static struct usb_configuration_instance config_instance[NUM_CONFIGS];
78 static struct usb_interface_instance interface_instance[MAX_INTERFACES];
79 static struct usb_alternate_instance alternate_instance[MAX_INTERFACES];
80 /* one extra for control endpoint */
81 static struct usb_endpoint_instance endpoint_instance[NUM_ENDPOINTS+1];
82
83 /*
84 * Global flag
85 */
86 int usbtty_configured_flag = 0;
87
88 /*
89 * Serial number
90 */
91 static char serial_number[16];
92
93
94 /*
95 * Descriptors, Strings, Local variables.
96 */
97
98 /* defined and used by gadget/ep0.c */
99 extern struct usb_string_descriptor **usb_strings;
100
101 /* Indicies, References */
102 static unsigned short rx_endpoint = 0;
103 static unsigned short tx_endpoint = 0;
104 static unsigned short interface_count = 0;
105 static struct usb_string_descriptor *usbtty_string_table[STR_COUNT];
106
107 /* USB Descriptor Strings */
108 static u8 wstrLang[4] = {4,USB_DT_STRING,0x9,0x4};
109 static u8 wstrManufacturer[2 + 2*(sizeof(CONFIG_USBD_MANUFACTURER)-1)];
110 static u8 wstrProduct[2 + 2*(sizeof(CONFIG_USBD_PRODUCT_NAME)-1)];
111 static u8 wstrSerial[2 + 2*(sizeof(serial_number) - 1)];
112 static u8 wstrConfiguration[2 + 2*(sizeof(CONFIG_USBD_CONFIGURATION_STR)-1)];
113 static u8 wstrDataInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)];
114 static u8 wstrCtrlInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)];
115
116 /* Standard USB Data Structures */
117 static struct usb_interface_descriptor interface_descriptors[MAX_INTERFACES];
118 static struct usb_endpoint_descriptor *ep_descriptor_ptrs[NUM_ENDPOINTS];
119 static struct usb_configuration_descriptor *configuration_descriptor = 0;
120 static struct usb_device_descriptor device_descriptor = {
121 .bLength = sizeof(struct usb_device_descriptor),
122 .bDescriptorType = USB_DT_DEVICE,
123 .bcdUSB = cpu_to_le16(USB_BCD_VERSION),
124 .bDeviceSubClass = 0x00,
125 .bDeviceProtocol = 0x00,
126 .bMaxPacketSize0 = EP0_MAX_PACKET_SIZE,
127 .idVendor = cpu_to_le16(CONFIG_USBD_VENDORID),
128 .bcdDevice = cpu_to_le16(USBTTY_BCD_DEVICE),
129 .iManufacturer = STR_MANUFACTURER,
130 .iProduct = STR_PRODUCT,
131 .iSerialNumber = STR_SERIAL,
132 .bNumConfigurations = NUM_CONFIGS
133 };
134
135
136 #if defined(CONFIG_USBD_HS)
137 static struct usb_qualifier_descriptor qualifier_descriptor = {
138 .bLength = sizeof(struct usb_qualifier_descriptor),
139 .bDescriptorType = USB_DT_QUAL,
140 .bcdUSB = cpu_to_le16(USB_BCD_VERSION),
141 .bDeviceClass = COMMUNICATIONS_DEVICE_CLASS,
142 .bDeviceSubClass = 0x00,
143 .bDeviceProtocol = 0x00,
144 .bMaxPacketSize0 = EP0_MAX_PACKET_SIZE,
145 .bNumConfigurations = NUM_CONFIGS
146 };
147 #endif
148
149 /*
150 * Static CDC ACM specific descriptors
151 */
152
153 struct acm_config_desc {
154 struct usb_configuration_descriptor configuration_desc;
155
156 /* Master Interface */
157 struct usb_interface_descriptor interface_desc;
158
159 struct usb_class_header_function_descriptor usb_class_header;
160 struct usb_class_call_management_descriptor usb_class_call_mgt;
161 struct usb_class_abstract_control_descriptor usb_class_acm;
162 struct usb_class_union_function_descriptor usb_class_union;
163 struct usb_endpoint_descriptor notification_endpoint;
164
165 /* Slave Interface */
166 struct usb_interface_descriptor data_class_interface;
167 struct usb_endpoint_descriptor data_endpoints[NUM_ENDPOINTS-1];
168 } __attribute__((packed));
169
170 static struct acm_config_desc acm_configuration_descriptors[NUM_CONFIGS] = {
171 {
172 .configuration_desc ={
173 .bLength =
174 sizeof(struct usb_configuration_descriptor),
175 .bDescriptorType = USB_DT_CONFIG,
176 .wTotalLength =
177 cpu_to_le16(sizeof(struct acm_config_desc)),
178 .bNumInterfaces = NUM_ACM_INTERFACES,
179 .bConfigurationValue = 1,
180 .iConfiguration = STR_CONFIG,
181 .bmAttributes =
182 BMATTRIBUTE_SELF_POWERED|BMATTRIBUTE_RESERVED,
183 .bMaxPower = USBTTY_MAXPOWER
184 },
185 /* Interface 1 */
186 .interface_desc = {
187 .bLength = sizeof(struct usb_interface_descriptor),
188 .bDescriptorType = USB_DT_INTERFACE,
189 .bInterfaceNumber = 0,
190 .bAlternateSetting = 0,
191 .bNumEndpoints = 0x01,
192 .bInterfaceClass =
193 COMMUNICATIONS_INTERFACE_CLASS_CONTROL,
194 .bInterfaceSubClass = COMMUNICATIONS_ACM_SUBCLASS,
195 .bInterfaceProtocol = COMMUNICATIONS_V25TER_PROTOCOL,
196 .iInterface = STR_CTRL_INTERFACE,
197 },
198 .usb_class_header = {
199 .bFunctionLength =
200 sizeof(struct usb_class_header_function_descriptor),
201 .bDescriptorType = CS_INTERFACE,
202 .bDescriptorSubtype = USB_ST_HEADER,
203 .bcdCDC = cpu_to_le16(110),
204 },
205 .usb_class_call_mgt = {
206 .bFunctionLength =
207 sizeof(struct usb_class_call_management_descriptor),
208 .bDescriptorType = CS_INTERFACE,
209 .bDescriptorSubtype = USB_ST_CMF,
210 .bmCapabilities = 0x00,
211 .bDataInterface = 0x01,
212 },
213 .usb_class_acm = {
214 .bFunctionLength =
215 sizeof(struct usb_class_abstract_control_descriptor),
216 .bDescriptorType = CS_INTERFACE,
217 .bDescriptorSubtype = USB_ST_ACMF,
218 .bmCapabilities = 0x00,
219 },
220 .usb_class_union = {
221 .bFunctionLength =
222 sizeof(struct usb_class_union_function_descriptor),
223 .bDescriptorType = CS_INTERFACE,
224 .bDescriptorSubtype = USB_ST_UF,
225 .bMasterInterface = 0x00,
226 .bSlaveInterface0 = 0x01,
227 },
228 .notification_endpoint = {
229 .bLength =
230 sizeof(struct usb_endpoint_descriptor),
231 .bDescriptorType = USB_DT_ENDPOINT,
232 .bEndpointAddress = UDC_INT_ENDPOINT | USB_DIR_IN,
233 .bmAttributes = USB_ENDPOINT_XFER_INT,
234 .wMaxPacketSize
235 = cpu_to_le16(CONFIG_USBD_SERIAL_INT_PKTSIZE),
236 .bInterval = 0xFF,
237 },
238
239 /* Interface 2 */
240 .data_class_interface = {
241 .bLength =
242 sizeof(struct usb_interface_descriptor),
243 .bDescriptorType = USB_DT_INTERFACE,
244 .bInterfaceNumber = 0x01,
245 .bAlternateSetting = 0x00,
246 .bNumEndpoints = 0x02,
247 .bInterfaceClass =
248 COMMUNICATIONS_INTERFACE_CLASS_DATA,
249 .bInterfaceSubClass = DATA_INTERFACE_SUBCLASS_NONE,
250 .bInterfaceProtocol = DATA_INTERFACE_PROTOCOL_NONE,
251 .iInterface = STR_DATA_INTERFACE,
252 },
253 .data_endpoints = {
254 {
255 .bLength =
256 sizeof(struct usb_endpoint_descriptor),
257 .bDescriptorType = USB_DT_ENDPOINT,
258 .bEndpointAddress = UDC_OUT_ENDPOINT | USB_DIR_OUT,
259 .bmAttributes =
260 USB_ENDPOINT_XFER_BULK,
261 .wMaxPacketSize =
262 cpu_to_le16(CONFIG_USBD_SERIAL_BULK_PKTSIZE),
263 .bInterval = 0xFF,
264 },
265 {
266 .bLength =
267 sizeof(struct usb_endpoint_descriptor),
268 .bDescriptorType = USB_DT_ENDPOINT,
269 .bEndpointAddress = UDC_IN_ENDPOINT | USB_DIR_IN,
270 .bmAttributes =
271 USB_ENDPOINT_XFER_BULK,
272 .wMaxPacketSize =
273 cpu_to_le16(CONFIG_USBD_SERIAL_BULK_PKTSIZE),
274 .bInterval = 0xFF,
275 },
276 },
277 },
278 };
279
280 static struct rs232_emu rs232_desc={
281 .dter = 115200,
282 .stop_bits = 0x00,
283 .parity = 0x00,
284 .data_bits = 0x08
285 };
286
287
288 /*
289 * Static Generic Serial specific data
290 */
291
292
293 struct gserial_config_desc {
294
295 struct usb_configuration_descriptor configuration_desc;
296 struct usb_interface_descriptor interface_desc[NUM_GSERIAL_INTERFACES];
297 struct usb_endpoint_descriptor data_endpoints[NUM_ENDPOINTS];
298
299 } __attribute__((packed));
300
301 static struct gserial_config_desc
302 gserial_configuration_descriptors[NUM_CONFIGS] ={
303 {
304 .configuration_desc ={
305 .bLength = sizeof(struct usb_configuration_descriptor),
306 .bDescriptorType = USB_DT_CONFIG,
307 .wTotalLength =
308 cpu_to_le16(sizeof(struct gserial_config_desc)),
309 .bNumInterfaces = NUM_GSERIAL_INTERFACES,
310 .bConfigurationValue = 1,
311 .iConfiguration = STR_CONFIG,
312 .bmAttributes =
313 BMATTRIBUTE_SELF_POWERED|BMATTRIBUTE_RESERVED,
314 .bMaxPower = USBTTY_MAXPOWER
315 },
316 .interface_desc = {
317 {
318 .bLength =
319 sizeof(struct usb_interface_descriptor),
320 .bDescriptorType = USB_DT_INTERFACE,
321 .bInterfaceNumber = 0,
322 .bAlternateSetting = 0,
323 .bNumEndpoints = NUM_ENDPOINTS,
324 .bInterfaceClass =
325 COMMUNICATIONS_INTERFACE_CLASS_VENDOR,
326 .bInterfaceSubClass =
327 COMMUNICATIONS_NO_SUBCLASS,
328 .bInterfaceProtocol =
329 COMMUNICATIONS_NO_PROTOCOL,
330 .iInterface = STR_DATA_INTERFACE
331 },
332 },
333 .data_endpoints = {
334 {
335 .bLength =
336 sizeof(struct usb_endpoint_descriptor),
337 .bDescriptorType = USB_DT_ENDPOINT,
338 .bEndpointAddress = UDC_OUT_ENDPOINT | USB_DIR_OUT,
339 .bmAttributes = USB_ENDPOINT_XFER_BULK,
340 .wMaxPacketSize =
341 cpu_to_le16(CONFIG_USBD_SERIAL_OUT_PKTSIZE),
342 .bInterval= 0xFF,
343 },
344 {
345 .bLength =
346 sizeof(struct usb_endpoint_descriptor),
347 .bDescriptorType = USB_DT_ENDPOINT,
348 .bEndpointAddress = UDC_IN_ENDPOINT | USB_DIR_IN,
349 .bmAttributes = USB_ENDPOINT_XFER_BULK,
350 .wMaxPacketSize =
351 cpu_to_le16(CONFIG_USBD_SERIAL_IN_PKTSIZE),
352 .bInterval = 0xFF,
353 },
354 {
355 .bLength =
356 sizeof(struct usb_endpoint_descriptor),
357 .bDescriptorType = USB_DT_ENDPOINT,
358 .bEndpointAddress = UDC_INT_ENDPOINT | USB_DIR_IN,
359 .bmAttributes = USB_ENDPOINT_XFER_INT,
360 .wMaxPacketSize =
361 cpu_to_le16(CONFIG_USBD_SERIAL_INT_PKTSIZE),
362 .bInterval = 0xFF,
363 },
364 },
365 },
366 };
367
368 /*
369 * Static Function Prototypes
370 */
371
372 static void usbtty_init_strings (void);
373 static void usbtty_init_instances (void);
374 static void usbtty_init_endpoints (void);
375 static void usbtty_init_terminal_type(short type);
376 static void usbtty_event_handler (struct usb_device_instance *device,
377 usb_device_event_t event, int data);
378 static int usbtty_cdc_setup(struct usb_device_request *request,
379 struct urb *urb);
380 static int usbtty_configured (void);
381 static int write_buffer (circbuf_t * buf);
382 static int fill_buffer (circbuf_t * buf);
383
384 void usbtty_poll (void);
385
386 /* utility function for converting char* to wide string used by USB */
387 static void str2wide (char *str, u16 * wide)
388 {
389 int i;
390 for (i = 0; i < strlen (str) && str[i]; i++){
391 #if defined(__LITTLE_ENDIAN)
392 wide[i] = (u16) str[i];
393 #elif defined(__BIG_ENDIAN)
394 wide[i] = ((u16)(str[i])<<8);
395 #else
396 #error "__LITTLE_ENDIAN or __BIG_ENDIAN undefined"
397 #endif
398 }
399 }
400
401 /*
402 * Test whether a character is in the RX buffer
403 */
404
405 int usbtty_tstc (void)
406 {
407 struct usb_endpoint_instance *endpoint =
408 &endpoint_instance[rx_endpoint];
409
410 /* If no input data exists, allow more RX to be accepted */
411 if(usbtty_input.size <= 0){
412 udc_unset_nak(endpoint->endpoint_address&0x03);
413 }
414
415 usbtty_poll ();
416 return (usbtty_input.size > 0);
417 }
418
419 /*
420 * Read a single byte from the usb client port. Returns 1 on success, 0
421 * otherwise. When the function is succesfull, the character read is
422 * written into its argument c.
423 */
424
425 int usbtty_getc (void)
426 {
427 char c;
428 struct usb_endpoint_instance *endpoint =
429 &endpoint_instance[rx_endpoint];
430
431 while (usbtty_input.size <= 0) {
432 udc_unset_nak(endpoint->endpoint_address&0x03);
433 usbtty_poll ();
434 }
435
436 buf_pop (&usbtty_input, &c, 1);
437 udc_set_nak(endpoint->endpoint_address&0x03);
438
439 return c;
440 }
441
442 /*
443 * Output a single byte to the usb client port.
444 */
445 void usbtty_putc (const char c)
446 {
447 if (!usbtty_configured ())
448 return;
449
450 buf_push (&usbtty_output, &c, 1);
451 /* If \n, also do \r */
452 if (c == '\n')
453 buf_push (&usbtty_output, "\r", 1);
454
455 /* Poll at end to handle new data... */
456 if ((usbtty_output.size + 2) >= usbtty_output.totalsize) {
457 usbtty_poll ();
458 }
459 }
460
461 /* usbtty_puts() helper function for finding the next '\n' in a string */
462 static int next_nl_pos (const char *s)
463 {
464 int i;
465
466 for (i = 0; s[i] != '\0'; i++) {
467 if (s[i] == '\n')
468 return i;
469 }
470 return i;
471 }
472
473 /*
474 * Output a string to the usb client port - implementing flow control
475 */
476
477 static void __usbtty_puts (const char *str, int len)
478 {
479 int maxlen = usbtty_output.totalsize;
480 int space, n;
481
482 /* break str into chunks < buffer size, if needed */
483 while (len > 0) {
484 usbtty_poll ();
485
486 space = maxlen - usbtty_output.size;
487 /* Empty buffer here, if needed, to ensure space... */
488 if (space) {
489 write_buffer (&usbtty_output);
490
491 n = MIN (space, MIN (len, maxlen));
492 buf_push (&usbtty_output, str, n);
493
494 str += n;
495 len -= n;
496 }
497 }
498 }
499
500 void usbtty_puts (const char *str)
501 {
502 int n;
503 int len;
504
505 if (!usbtty_configured ())
506 return;
507
508 len = strlen (str);
509 /* add '\r' for each '\n' */
510 while (len > 0) {
511 n = next_nl_pos (str);
512
513 if (str[n] == '\n') {
514 __usbtty_puts (str, n + 1);
515 __usbtty_puts ("\r", 1);
516 str += (n + 1);
517 len -= (n + 1);
518 } else {
519 /* No \n found. All done. */
520 __usbtty_puts (str, n);
521 break;
522 }
523 }
524
525 /* Poll at end to handle new data... */
526 usbtty_poll ();
527 }
528
529 /*
530 * Initialize the usb client port.
531 *
532 */
533 int drv_usbtty_init (void)
534 {
535 int rc;
536 char * sn;
537 char * tt;
538 int snlen;
539
540 /* Ger seiral number */
541 if (!(sn = getenv("serial#"))) {
542 sn = "000000000000";
543 }
544 snlen = strlen(sn);
545 if (snlen > sizeof(serial_number) - 1) {
546 printf ("Warning: serial number %s is too long (%d > %lu)\n",
547 sn, snlen, (ulong)(sizeof(serial_number) - 1));
548 snlen = sizeof(serial_number) - 1;
549 }
550 memcpy (serial_number, sn, snlen);
551 serial_number[snlen] = '\0';
552
553 /* Decide on which type of UDC device to be.
554 */
555
556 if(!(tt = getenv("usbtty"))) {
557 tt = "generic";
558 }
559 usbtty_init_terminal_type(strcmp(tt,"cdc_acm"));
560
561 /* prepare buffers... */
562 buf_init (&usbtty_input, USBTTY_BUFFER_SIZE);
563 buf_init (&usbtty_output, USBTTY_BUFFER_SIZE);
564
565 /* Now, set up USB controller and infrastructure */
566 udc_init (); /* Basic USB initialization */
567
568 usbtty_init_strings ();
569 usbtty_init_instances ();
570
571 usbtty_init_endpoints ();
572
573 udc_startup_events (device_instance);/* Enable dev, init udc pointers */
574 udc_connect (); /* Enable pullup for host detection */
575
576 /* Device initialization */
577 memset (&usbttydev, 0, sizeof (usbttydev));
578
579 strcpy (usbttydev.name, "usbtty");
580 usbttydev.ext = 0; /* No extensions */
581 usbttydev.flags = DEV_FLAGS_INPUT | DEV_FLAGS_OUTPUT;
582 usbttydev.tstc = usbtty_tstc; /* 'tstc' function */
583 usbttydev.getc = usbtty_getc; /* 'getc' function */
584 usbttydev.putc = usbtty_putc; /* 'putc' function */
585 usbttydev.puts = usbtty_puts; /* 'puts' function */
586
587 rc = stdio_register (&usbttydev);
588
589 return (rc == 0) ? 1 : rc;
590 }
591
592 static void usbtty_init_strings (void)
593 {
594 struct usb_string_descriptor *string;
595
596 usbtty_string_table[STR_LANG] =
597 (struct usb_string_descriptor*)wstrLang;
598
599 string = (struct usb_string_descriptor *) wstrManufacturer;
600 string->bLength = sizeof(wstrManufacturer);
601 string->bDescriptorType = USB_DT_STRING;
602 str2wide (CONFIG_USBD_MANUFACTURER, string->wData);
603 usbtty_string_table[STR_MANUFACTURER]=string;
604
605
606 string = (struct usb_string_descriptor *) wstrProduct;
607 string->bLength = sizeof(wstrProduct);
608 string->bDescriptorType = USB_DT_STRING;
609 str2wide (CONFIG_USBD_PRODUCT_NAME, string->wData);
610 usbtty_string_table[STR_PRODUCT]=string;
611
612
613 string = (struct usb_string_descriptor *) wstrSerial;
614 string->bLength = sizeof(serial_number);
615 string->bDescriptorType = USB_DT_STRING;
616 str2wide (serial_number, string->wData);
617 usbtty_string_table[STR_SERIAL]=string;
618
619
620 string = (struct usb_string_descriptor *) wstrConfiguration;
621 string->bLength = sizeof(wstrConfiguration);
622 string->bDescriptorType = USB_DT_STRING;
623 str2wide (CONFIG_USBD_CONFIGURATION_STR, string->wData);
624 usbtty_string_table[STR_CONFIG]=string;
625
626
627 string = (struct usb_string_descriptor *) wstrDataInterface;
628 string->bLength = sizeof(wstrDataInterface);
629 string->bDescriptorType = USB_DT_STRING;
630 str2wide (CONFIG_USBD_DATA_INTERFACE_STR, string->wData);
631 usbtty_string_table[STR_DATA_INTERFACE]=string;
632
633 string = (struct usb_string_descriptor *) wstrCtrlInterface;
634 string->bLength = sizeof(wstrCtrlInterface);
635 string->bDescriptorType = USB_DT_STRING;
636 str2wide (CONFIG_USBD_CTRL_INTERFACE_STR, string->wData);
637 usbtty_string_table[STR_CTRL_INTERFACE]=string;
638
639 /* Now, initialize the string table for ep0 handling */
640 usb_strings = usbtty_string_table;
641 }
642
643 #define init_wMaxPacketSize(x) le16_to_cpu(get_unaligned(\
644 &ep_descriptor_ptrs[(x) - 1]->wMaxPacketSize));
645
646 static void usbtty_init_instances (void)
647 {
648 int i;
649
650 /* initialize device instance */
651 memset (device_instance, 0, sizeof (struct usb_device_instance));
652 device_instance->device_state = STATE_INIT;
653 device_instance->device_descriptor = &device_descriptor;
654 #if defined(CONFIG_USBD_HS)
655 device_instance->qualifier_descriptor = &qualifier_descriptor;
656 #endif
657 device_instance->event = usbtty_event_handler;
658 device_instance->cdc_recv_setup = usbtty_cdc_setup;
659 device_instance->bus = bus_instance;
660 device_instance->configurations = NUM_CONFIGS;
661 device_instance->configuration_instance_array = config_instance;
662
663 /* initialize bus instance */
664 memset (bus_instance, 0, sizeof (struct usb_bus_instance));
665 bus_instance->device = device_instance;
666 bus_instance->endpoint_array = endpoint_instance;
667 bus_instance->max_endpoints = 1;
668 bus_instance->maxpacketsize = 64;
669 bus_instance->serial_number_str = serial_number;
670
671 /* configuration instance */
672 memset (config_instance, 0,
673 sizeof (struct usb_configuration_instance));
674 config_instance->interfaces = interface_count;
675 config_instance->configuration_descriptor = configuration_descriptor;
676 config_instance->interface_instance_array = interface_instance;
677
678 /* interface instance */
679 memset (interface_instance, 0,
680 sizeof (struct usb_interface_instance));
681 interface_instance->alternates = 1;
682 interface_instance->alternates_instance_array = alternate_instance;
683
684 /* alternates instance */
685 memset (alternate_instance, 0,
686 sizeof (struct usb_alternate_instance));
687 alternate_instance->interface_descriptor = interface_descriptors;
688 alternate_instance->endpoints = NUM_ENDPOINTS;
689 alternate_instance->endpoints_descriptor_array = ep_descriptor_ptrs;
690
691 /* endpoint instances */
692 memset (&endpoint_instance[0], 0,
693 sizeof (struct usb_endpoint_instance));
694 endpoint_instance[0].endpoint_address = 0;
695 endpoint_instance[0].rcv_packetSize = EP0_MAX_PACKET_SIZE;
696 endpoint_instance[0].rcv_attributes = USB_ENDPOINT_XFER_CONTROL;
697 endpoint_instance[0].tx_packetSize = EP0_MAX_PACKET_SIZE;
698 endpoint_instance[0].tx_attributes = USB_ENDPOINT_XFER_CONTROL;
699 udc_setup_ep (device_instance, 0, &endpoint_instance[0]);
700
701 for (i = 1; i <= NUM_ENDPOINTS; i++) {
702 memset (&endpoint_instance[i], 0,
703 sizeof (struct usb_endpoint_instance));
704
705 endpoint_instance[i].endpoint_address =
706 ep_descriptor_ptrs[i - 1]->bEndpointAddress;
707
708 endpoint_instance[i].rcv_attributes =
709 ep_descriptor_ptrs[i - 1]->bmAttributes;
710
711 endpoint_instance[i].rcv_packetSize = init_wMaxPacketSize(i);
712
713 endpoint_instance[i].tx_attributes =
714 ep_descriptor_ptrs[i - 1]->bmAttributes;
715
716 endpoint_instance[i].tx_packetSize = init_wMaxPacketSize(i);
717
718 endpoint_instance[i].tx_attributes =
719 ep_descriptor_ptrs[i - 1]->bmAttributes;
720
721 urb_link_init (&endpoint_instance[i].rcv);
722 urb_link_init (&endpoint_instance[i].rdy);
723 urb_link_init (&endpoint_instance[i].tx);
724 urb_link_init (&endpoint_instance[i].done);
725
726 if (endpoint_instance[i].endpoint_address & USB_DIR_IN)
727 endpoint_instance[i].tx_urb =
728 usbd_alloc_urb (device_instance,
729 &endpoint_instance[i]);
730 else
731 endpoint_instance[i].rcv_urb =
732 usbd_alloc_urb (device_instance,
733 &endpoint_instance[i]);
734 }
735 }
736
737 static void usbtty_init_endpoints (void)
738 {
739 int i;
740
741 bus_instance->max_endpoints = NUM_ENDPOINTS + 1;
742 for (i = 1; i <= NUM_ENDPOINTS; i++) {
743 udc_setup_ep (device_instance, i, &endpoint_instance[i]);
744 }
745 }
746
747 /* usbtty_init_terminal_type
748 *
749 * Do some late binding for our device type.
750 */
751 static void usbtty_init_terminal_type(short type)
752 {
753 switch(type){
754 /* CDC ACM */
755 case 0:
756 /* Assign endpoint descriptors */
757 ep_descriptor_ptrs[0] =
758 &acm_configuration_descriptors[0].notification_endpoint;
759 ep_descriptor_ptrs[1] =
760 &acm_configuration_descriptors[0].data_endpoints[0];
761 ep_descriptor_ptrs[2] =
762 &acm_configuration_descriptors[0].data_endpoints[1];
763
764 /* Enumerate Device Descriptor */
765 device_descriptor.bDeviceClass =
766 COMMUNICATIONS_DEVICE_CLASS;
767 device_descriptor.idProduct =
768 cpu_to_le16(CONFIG_USBD_PRODUCTID_CDCACM);
769
770 #if defined(CONFIG_USBD_HS)
771 qualifier_descriptor.bDeviceClass =
772 COMMUNICATIONS_DEVICE_CLASS;
773 #endif
774 /* Assign endpoint indices */
775 tx_endpoint = ACM_TX_ENDPOINT;
776 rx_endpoint = ACM_RX_ENDPOINT;
777
778 /* Configuration Descriptor */
779 configuration_descriptor =
780 (struct usb_configuration_descriptor*)
781 &acm_configuration_descriptors;
782
783 /* Interface count */
784 interface_count = NUM_ACM_INTERFACES;
785 break;
786
787 /* BULK IN/OUT & Default */
788 case 1:
789 default:
790 /* Assign endpoint descriptors */
791 ep_descriptor_ptrs[0] =
792 &gserial_configuration_descriptors[0].data_endpoints[0];
793 ep_descriptor_ptrs[1] =
794 &gserial_configuration_descriptors[0].data_endpoints[1];
795 ep_descriptor_ptrs[2] =
796 &gserial_configuration_descriptors[0].data_endpoints[2];
797
798 /* Enumerate Device Descriptor */
799 device_descriptor.bDeviceClass = 0xFF;
800 device_descriptor.idProduct =
801 cpu_to_le16(CONFIG_USBD_PRODUCTID_GSERIAL);
802 #if defined(CONFIG_USBD_HS)
803 qualifier_descriptor.bDeviceClass = 0xFF;
804 #endif
805 /* Assign endpoint indices */
806 tx_endpoint = GSERIAL_TX_ENDPOINT;
807 rx_endpoint = GSERIAL_RX_ENDPOINT;
808
809 /* Configuration Descriptor */
810 configuration_descriptor =
811 (struct usb_configuration_descriptor*)
812 &gserial_configuration_descriptors;
813
814 /* Interface count */
815 interface_count = NUM_GSERIAL_INTERFACES;
816 break;
817 }
818 }
819
820 /******************************************************************************/
821
822 static struct urb *next_urb (struct usb_device_instance *device,
823 struct usb_endpoint_instance *endpoint)
824 {
825 struct urb *current_urb = NULL;
826 int space;
827
828 /* If there's a queue, then we should add to the last urb */
829 if (!endpoint->tx_queue) {
830 current_urb = endpoint->tx_urb;
831 } else {
832 /* Last urb from tx chain */
833 current_urb =
834 p2surround (struct urb, link, endpoint->tx.prev);
835 }
836
837 /* Make sure this one has enough room */
838 space = current_urb->buffer_length - current_urb->actual_length;
839 if (space > 0) {
840 return current_urb;
841 } else { /* No space here */
842 /* First look at done list */
843 current_urb = first_urb_detached (&endpoint->done);
844 if (!current_urb) {
845 current_urb = usbd_alloc_urb (device, endpoint);
846 }
847
848 urb_append (&endpoint->tx, current_urb);
849 endpoint->tx_queue++;
850 }
851 return current_urb;
852 }
853
854 static int write_buffer (circbuf_t * buf)
855 {
856 if (!usbtty_configured ()) {
857 return 0;
858 }
859
860 struct usb_endpoint_instance *endpoint =
861 &endpoint_instance[tx_endpoint];
862 struct urb *current_urb = NULL;
863
864 current_urb = next_urb (device_instance, endpoint);
865 /* TX data still exists - send it now
866 */
867 if(endpoint->sent < current_urb->actual_length){
868 if(udc_endpoint_write (endpoint)){
869 /* Write pre-empted by RX */
870 return -1;
871 }
872 }
873
874 if (buf->size) {
875 char *dest;
876
877 int space_avail;
878 int popnum, popped;
879 int total = 0;
880
881 /* Break buffer into urb sized pieces,
882 * and link each to the endpoint
883 */
884 while (buf->size > 0) {
885
886 if (!current_urb) {
887 TTYERR ("current_urb is NULL, buf->size %d\n",
888 buf->size);
889 return total;
890 }
891
892 dest = (char*)current_urb->buffer +
893 current_urb->actual_length;
894
895 space_avail =
896 current_urb->buffer_length -
897 current_urb->actual_length;
898 popnum = MIN (space_avail, buf->size);
899 if (popnum == 0)
900 break;
901
902 popped = buf_pop (buf, dest, popnum);
903 if (popped == 0)
904 break;
905 current_urb->actual_length += popped;
906 total += popped;
907
908 /* If endpoint->last == 0, then transfers have
909 * not started on this endpoint
910 */
911 if (endpoint->last == 0) {
912 if(udc_endpoint_write (endpoint)){
913 /* Write pre-empted by RX */
914 return -1;
915 }
916 }
917
918 }/* end while */
919 return total;
920 }
921
922 return 0;
923 }
924
925 static int fill_buffer (circbuf_t * buf)
926 {
927 struct usb_endpoint_instance *endpoint =
928 &endpoint_instance[rx_endpoint];
929
930 if (endpoint->rcv_urb && endpoint->rcv_urb->actual_length) {
931 unsigned int nb = 0;
932 char *src = (char *) endpoint->rcv_urb->buffer;
933 unsigned int rx_avail = buf->totalsize - buf->size;
934
935 if(rx_avail >= endpoint->rcv_urb->actual_length){
936
937 nb = endpoint->rcv_urb->actual_length;
938 buf_push (buf, src, nb);
939 endpoint->rcv_urb->actual_length = 0;
940
941 }
942 return nb;
943 }
944 return 0;
945 }
946
947 static int usbtty_configured (void)
948 {
949 return usbtty_configured_flag;
950 }
951
952 /******************************************************************************/
953
954 static void usbtty_event_handler (struct usb_device_instance *device,
955 usb_device_event_t event, int data)
956 {
957 #if defined(CONFIG_USBD_HS)
958 int i;
959 #endif
960 switch (event) {
961 case DEVICE_RESET:
962 case DEVICE_BUS_INACTIVE:
963 usbtty_configured_flag = 0;
964 break;
965 case DEVICE_CONFIGURED:
966 usbtty_configured_flag = 1;
967 break;
968
969 case DEVICE_ADDRESS_ASSIGNED:
970 #if defined(CONFIG_USBD_HS)
971 /*
972 * is_usbd_high_speed routine needs to be defined by
973 * specific gadget driver
974 * It returns TRUE if device enumerates at High speed
975 * Retuns FALSE otherwise
976 */
977 for (i = 0; i < NUM_ENDPOINTS; i++) {
978 if (((ep_descriptor_ptrs[i]->bmAttributes &
979 USB_ENDPOINT_XFERTYPE_MASK) ==
980 USB_ENDPOINT_XFER_BULK)
981 && is_usbd_high_speed()) {
982
983 ep_descriptor_ptrs[i]->wMaxPacketSize =
984 CONFIG_USBD_SERIAL_BULK_HS_PKTSIZE;
985 }
986
987 endpoint_instance[i + 1].tx_packetSize =
988 ep_descriptor_ptrs[i]->wMaxPacketSize;
989 endpoint_instance[i + 1].rcv_packetSize =
990 ep_descriptor_ptrs[i]->wMaxPacketSize;
991 }
992 #endif
993 usbtty_init_endpoints ();
994
995 default:
996 break;
997 }
998 }
999
1000 /******************************************************************************/
1001
1002 int usbtty_cdc_setup(struct usb_device_request *request, struct urb *urb)
1003 {
1004 switch (request->bRequest){
1005
1006 case ACM_SET_CONTROL_LINE_STATE: /* Implies DTE ready */
1007 break;
1008 case ACM_SEND_ENCAPSULATED_COMMAND : /* Required */
1009 break;
1010 case ACM_SET_LINE_ENCODING : /* DTE stop/parity bits
1011 * per character */
1012 break;
1013 case ACM_GET_ENCAPSULATED_RESPONSE : /* request response */
1014 break;
1015 case ACM_GET_LINE_ENCODING : /* request DTE rate,
1016 * stop/parity bits */
1017 memcpy (urb->buffer , &rs232_desc, sizeof(rs232_desc));
1018 urb->actual_length = sizeof(rs232_desc);
1019
1020 break;
1021 default:
1022 return 1;
1023 }
1024 return 0;
1025 }
1026
1027 /******************************************************************************/
1028
1029 /*
1030 * Since interrupt handling has not yet been implemented, we use this function
1031 * to handle polling. This is called by the tstc,getc,putc,puts routines to
1032 * update the USB state.
1033 */
1034 void usbtty_poll (void)
1035 {
1036 /* New interrupts? */
1037 udc_irq();
1038
1039 /* Write any output data to host buffer
1040 * (do this before checking interrupts to avoid missing one)
1041 */
1042 if (usbtty_configured ()) {
1043 write_buffer (&usbtty_output);
1044 }
1045
1046 /* New interrupts? */
1047 udc_irq();
1048
1049 /* Check for new data from host..
1050 * (do this after checking interrupts to get latest data)
1051 */
1052 if (usbtty_configured ()) {
1053 fill_buffer (&usbtty_input);
1054 }
1055
1056 /* New interrupts? */
1057 udc_irq();
1058
1059 }
"Das U-Boot" Source Tree