1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
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
65
66#define USBTTY_BUFFER_SIZE 256
67static circbuf_t usbtty_input;
68static circbuf_t usbtty_output;
69
70
71
72
73
74static struct stdio_dev usbttydev;
75static struct usb_device_instance device_instance[1];
76static struct usb_bus_instance bus_instance[1];
77static struct usb_configuration_instance config_instance[NUM_CONFIGS];
78static struct usb_interface_instance interface_instance[MAX_INTERFACES];
79static struct usb_alternate_instance alternate_instance[MAX_INTERFACES];
80
81static struct usb_endpoint_instance endpoint_instance[NUM_ENDPOINTS+1];
82
83
84
85
86int usbtty_configured_flag = 0;
87
88
89
90
91static char serial_number[16];
92
93
94
95
96
97
98
99extern struct usb_string_descriptor **usb_strings;
100
101
102static unsigned short rx_endpoint = 0;
103static unsigned short tx_endpoint = 0;
104static unsigned short interface_count = 0;
105static struct usb_string_descriptor *usbtty_string_table[STR_COUNT];
106
107
108static u8 wstrLang[4] = {4,USB_DT_STRING,0x9,0x4};
109static u8 wstrManufacturer[2 + 2*(sizeof(CONFIG_USBD_MANUFACTURER)-1)];
110static u8 wstrProduct[2 + 2*(sizeof(CONFIG_USBD_PRODUCT_NAME)-1)];
111static u8 wstrSerial[2 + 2*(sizeof(serial_number) - 1)];
112static u8 wstrConfiguration[2 + 2*(sizeof(CONFIG_USBD_CONFIGURATION_STR)-1)];
113static u8 wstrDataInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)];
114static u8 wstrCtrlInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)];
115
116
117static struct usb_interface_descriptor interface_descriptors[MAX_INTERFACES];
118static struct usb_endpoint_descriptor *ep_descriptor_ptrs[NUM_ENDPOINTS];
119static struct usb_configuration_descriptor *configuration_descriptor = 0;
120static 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)
137static 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
151
152
153struct acm_config_desc {
154 struct usb_configuration_descriptor configuration_desc;
155
156
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
166 struct usb_interface_descriptor data_class_interface;
167 struct usb_endpoint_descriptor data_endpoints[NUM_ENDPOINTS-1];
168} __attribute__((packed));
169
170static 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
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
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
280static struct rs232_emu rs232_desc={
281 .dter = 115200,
282 .stop_bits = 0x00,
283 .parity = 0x00,
284 .data_bits = 0x08
285};
286
287
288
289
290
291
292
293struct 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
301static struct gserial_config_desc
302gserial_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
370
371
372static void usbtty_init_strings (void);
373static void usbtty_init_instances (void);
374static void usbtty_init_endpoints (void);
375static void usbtty_init_terminal_type(short type);
376static void usbtty_event_handler (struct usb_device_instance *device,
377 usb_device_event_t event, int data);
378static int usbtty_cdc_setup(struct usb_device_request *request,
379 struct urb *urb);
380static int usbtty_configured (void);
381static int write_buffer (circbuf_t * buf);
382static int fill_buffer (circbuf_t * buf);
383
384void usbtty_poll (void);
385
386
387static 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
403
404
405int usbtty_tstc (void)
406{
407 struct usb_endpoint_instance *endpoint =
408 &endpoint_instance[rx_endpoint];
409
410
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
421
422
423
424
425int 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
444
445void usbtty_putc (const char c)
446{
447 if (!usbtty_configured ())
448 return;
449
450 buf_push (&usbtty_output, &c, 1);
451
452 if (c == '\n')
453 buf_push (&usbtty_output, "\r", 1);
454
455
456 if ((usbtty_output.size + 2) >= usbtty_output.totalsize) {
457 usbtty_poll ();
458 }
459}
460
461
462static 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
475
476
477static void __usbtty_puts (const char *str, int len)
478{
479 int maxlen = usbtty_output.totalsize;
480 int space, n;
481
482
483 while (len > 0) {
484 usbtty_poll ();
485
486 space = maxlen - usbtty_output.size;
487
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
500void 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
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
520 __usbtty_puts (str, n);
521 break;
522 }
523 }
524
525
526 usbtty_poll ();
527}
528
529
530
531
532
533int drv_usbtty_init (void)
534{
535 int rc;
536 char * sn;
537 char * tt;
538 int snlen;
539
540
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
554
555
556 if(!(tt = getenv("usbtty"))) {
557 tt = "generic";
558 }
559 usbtty_init_terminal_type(strcmp(tt,"cdc_acm"));
560
561
562 buf_init (&usbtty_input, USBTTY_BUFFER_SIZE);
563 buf_init (&usbtty_output, USBTTY_BUFFER_SIZE);
564
565
566 udc_init ();
567
568 usbtty_init_strings ();
569 usbtty_init_instances ();
570
571 usbtty_init_endpoints ();
572
573 udc_startup_events (device_instance);
574 udc_connect ();
575
576
577 memset (&usbttydev, 0, sizeof (usbttydev));
578
579 strcpy (usbttydev.name, "usbtty");
580 usbttydev.ext = 0;
581 usbttydev.flags = DEV_FLAGS_INPUT | DEV_FLAGS_OUTPUT;
582 usbttydev.tstc = usbtty_tstc;
583 usbttydev.getc = usbtty_getc;
584 usbttydev.putc = usbtty_putc;
585 usbttydev.puts = usbtty_puts;
586
587 rc = stdio_register (&usbttydev);
588
589 return (rc == 0) ? 1 : rc;
590}
591
592static 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
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
646static void usbtty_init_instances (void)
647{
648 int i;
649
650
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
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
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
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
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
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
737static 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
748
749
750
751static void usbtty_init_terminal_type(short type)
752{
753 switch(type){
754
755 case 0:
756
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
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
775 tx_endpoint = ACM_TX_ENDPOINT;
776 rx_endpoint = ACM_RX_ENDPOINT;
777
778
779 configuration_descriptor =
780 (struct usb_configuration_descriptor*)
781 &acm_configuration_descriptors;
782
783
784 interface_count = NUM_ACM_INTERFACES;
785 break;
786
787
788 case 1:
789 default:
790
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
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
806 tx_endpoint = GSERIAL_TX_ENDPOINT;
807 rx_endpoint = GSERIAL_RX_ENDPOINT;
808
809
810 configuration_descriptor =
811 (struct usb_configuration_descriptor*)
812 &gserial_configuration_descriptors;
813
814
815 interface_count = NUM_GSERIAL_INTERFACES;
816 break;
817 }
818}
819
820
821
822static 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
829 if (!endpoint->tx_queue) {
830 current_urb = endpoint->tx_urb;
831 } else {
832
833 current_urb =
834 p2surround (struct urb, link, endpoint->tx.prev);
835 }
836
837
838 space = current_urb->buffer_length - current_urb->actual_length;
839 if (space > 0) {
840 return current_urb;
841 } else {
842
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
854static 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
866
867 if(endpoint->sent < current_urb->actual_length){
868 if(udc_endpoint_write (endpoint)){
869
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
882
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
909
910
911 if (endpoint->last == 0) {
912 if(udc_endpoint_write (endpoint)){
913
914 return -1;
915 }
916 }
917
918 }
919 return total;
920 }
921
922 return 0;
923}
924
925static 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
947static int usbtty_configured (void)
948{
949 return usbtty_configured_flag;
950}
951
952
953
954static 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
973
974
975
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
1002int usbtty_cdc_setup(struct usb_device_request *request, struct urb *urb)
1003{
1004 switch (request->bRequest){
1005
1006 case ACM_SET_CONTROL_LINE_STATE:
1007 break;
1008 case ACM_SEND_ENCAPSULATED_COMMAND :
1009 break;
1010 case ACM_SET_LINE_ENCODING :
1011
1012 break;
1013 case ACM_GET_ENCAPSULATED_RESPONSE :
1014 break;
1015 case ACM_GET_LINE_ENCODING :
1016
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
1031
1032
1033
1034void usbtty_poll (void)
1035{
1036
1037 udc_irq();
1038
1039
1040
1041
1042 if (usbtty_configured ()) {
1043 write_buffer (&usbtty_output);
1044 }
1045
1046
1047 udc_irq();
1048
1049
1050
1051
1052 if (usbtty_configured ()) {
1053 fill_buffer (&usbtty_input);
1054 }
1055
1056
1057 udc_irq();
1058
1059}
1060
