?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added support for the Hynix HY27US08121A 64MB Flash chip.
[u-boot-openmoko/mini2440.git] / drivers / serial / usbtty.c
blob7ef7eb5cee512d8d83a59f80c68d8f4c91bbdf7e
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
26 #ifdef CONFIG_USB_TTY
27
28 #include <asm/io.h>
29 #include <asm/proc/system.h>
30 #include <circbuf.h>
31 #include <devices.h>
32 #include "usbtty.h"
33 #include "usb_cdc_acm.h"
34 #include "usbdescriptors.h"
35 #include <usb_dfu_descriptors.h>
36 #include <usb_dfu.h>
37 #include <config.h> /* If defined, override Linux identifiers with
38 * vendor specific ones */
39
40 #if 0
41 #define TTYDBG(fmt,args...)\
42 serial_printf("[%s] %s %d: "fmt, __FILE__,__FUNCTION__,__LINE__,##args)
43 #else
44 #define TTYDBG(fmt,args...) do{}while(0)
45 #endif
46
47 #if 1
48 #define TTYERR(fmt,args...)\
49 serial_printf("ERROR![%s] %s %d: "fmt, __FILE__,__FUNCTION__,\
50 __LINE__,##args)
51 #else
52 #define TTYERR(fmt,args...) do{}while(0)
53 #endif
54
55 /*
56 * Defines
57 */
58 #define NUM_CONFIGS 2
59 #define MAX_INTERFACES 2
60 #define NUM_ENDPOINTS 3
61 #define ACM_TX_ENDPOINT 3
62 #define ACM_RX_ENDPOINT 2
63 #define GSERIAL_TX_ENDPOINT 2
64 #define GSERIAL_RX_ENDPOINT 1
65 #define NUM_ACM_INTERFACES 2
66 #define NUM_GSERIAL_INTERFACES 1
67 #define CONFIG_USBD_DATA_INTERFACE_STR "Bulk Data Interface"
68 #define CONFIG_USBD_CTRL_INTERFACE_STR "Control Interface"
69
70 /*
71 * Buffers to hold input and output data
72 */
73 #define USBTTY_BUFFER_SIZE 256
74 static circbuf_t usbtty_input;
75 static circbuf_t usbtty_output;
76
77
78 /*
79 * Instance variables
80 */
81 static device_t usbttydev;
82 static struct usb_device_instance device_instance[1];
83 static struct usb_bus_instance bus_instance[1];
84 static struct usb_configuration_instance config_instance[NUM_CONFIGS];
85 static struct usb_interface_instance interface_instance[MAX_INTERFACES];
86 static struct usb_alternate_instance alternate_instance[MAX_INTERFACES];
87 /* one extra for control endpoint */
88 static struct usb_endpoint_instance endpoint_instance[NUM_ENDPOINTS+1];
89
90 /*
91 * Global flag
92 */
93 int usbtty_configured_flag = 0;
94
95 /*
96 * Serial number
97 */
98 static char serial_number[16];
99
100
101 /*
102 * Descriptors, Strings, Local variables.
103 */
104
105 /* defined and used by usbdcore_ep0.c */
106 extern struct usb_string_descriptor **usb_strings;
107
108 /* Indicies, References */
109 static unsigned short rx_endpoint = 0;
110 static unsigned short tx_endpoint = 0;
111 static unsigned short interface_count = 0;
112 static struct usb_string_descriptor *usbtty_string_table[NUM_STRINGS];
113
114 /* USB Descriptor Strings */
115 static u8 wstrLang[4] = {4,USB_DT_STRING,0x9,0x4};
116 static u8 wstrManufacturer[2 + 2*(sizeof(CONFIG_USBD_MANUFACTURER)-1)];
117 static u8 wstrProduct[2 + 2*(sizeof(CONFIG_USBD_PRODUCT_NAME)-1)];
118 static u8 wstrSerial[2 + 2*(sizeof(serial_number) - 1)];
119 static u8 wstrConfiguration[2 + 2*(sizeof(CONFIG_USBD_CONFIGURATION_STR)-1)];
120 static u8 wstrDataInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)];
121 static u8 wstrCtrlInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)];
122
123 /* Standard USB Data Structures */
124 static struct usb_interface_descriptor interface_descriptors[MAX_INTERFACES];
125 static struct usb_endpoint_descriptor *ep_descriptor_ptrs[NUM_ENDPOINTS];
126 static struct usb_configuration_descriptor *configuration_descriptor = 0;
127 static struct usb_device_descriptor device_descriptor = {
128 .bLength = sizeof(struct usb_device_descriptor),
129 .bDescriptorType = USB_DT_DEVICE,
130 .bcdUSB = cpu_to_le16(USB_BCD_VERSION),
131 .bDeviceSubClass = 0x00,
132 .bDeviceProtocol = 0x00,
133 .bMaxPacketSize0 = EP0_MAX_PACKET_SIZE,
134 .idVendor = cpu_to_le16(CONFIG_USBD_VENDORID),
135 .bcdDevice = cpu_to_le16(USBTTY_BCD_DEVICE),
136 .iManufacturer = STR_MANUFACTURER,
137 .iProduct = STR_PRODUCT,
138 .iSerialNumber = STR_SERIAL,
139 .bNumConfigurations = NUM_CONFIGS
140 };
141
142
143 /*
144 * Static CDC ACM specific descriptors
145 */
146
147 struct acm_config_desc {
148 struct usb_configuration_descriptor configuration_desc;
149
150 /* Master Interface */
151 struct usb_interface_descriptor interface_desc;
152
153 struct usb_class_header_function_descriptor usb_class_header;
154 struct usb_class_call_management_descriptor usb_class_call_mgt;
155 struct usb_class_abstract_control_descriptor usb_class_acm;
156 struct usb_class_union_function_descriptor usb_class_union;
157 struct usb_endpoint_descriptor notification_endpoint;
158
159 /* Slave Interface */
160 struct usb_interface_descriptor data_class_interface;
161 struct usb_endpoint_descriptor
162 data_endpoints[NUM_ENDPOINTS-1] __attribute__((packed));
163 #ifdef CONFIG_USBD_DFU
164 struct usb_interface_descriptor uif_dfu;
165 struct usb_dfu_func_descriptor func_dfu;
166 #endif
167 } __attribute__((packed));
168
169 static struct acm_config_desc acm_configuration_descriptors[NUM_CONFIGS] = {
170 {
171 .configuration_desc ={
172 .bLength =
173 sizeof(struct usb_configuration_descriptor),
174 .bDescriptorType = USB_DT_CONFIG,
175 .wTotalLength =
176 cpu_to_le16(sizeof(struct acm_config_desc)),
177 #ifdef CONFIG_USBD_DFU
178 .bNumInterfaces = NUM_ACM_INTERFACES +1,
179 #else
180 .bNumInterfaces = NUM_ACM_INTERFACES,
181 #endif
182 .bConfigurationValue = 1,
183 .iConfiguration = STR_CONFIG,
184 .bmAttributes = BMATTRIBUTE_RESERVED,
185 .bMaxPower = USBTTY_MAXPOWER
186 },
187 /* Interface 1 */
188 .interface_desc = {
189 .bLength = sizeof(struct usb_interface_descriptor),
190 .bDescriptorType = USB_DT_INTERFACE,
191 .bInterfaceNumber = 0,
192 .bAlternateSetting = 0,
193 .bNumEndpoints = 0x01,
194 .bInterfaceClass =
195 COMMUNICATIONS_INTERFACE_CLASS_CONTROL,
196 .bInterfaceSubClass = COMMUNICATIONS_ACM_SUBCLASS,
197 .bInterfaceProtocol = COMMUNICATIONS_V25TER_PROTOCOL,
198 .iInterface = STR_CTRL_INTERFACE,
199 },
200 .usb_class_header = {
201 .bFunctionLength =
202 sizeof(struct usb_class_header_function_descriptor),
203 .bDescriptorType = CS_INTERFACE,
204 .bDescriptorSubtype = USB_ST_HEADER,
205 .bcdCDC = cpu_to_le16(110),
206 },
207 .usb_class_call_mgt = {
208 .bFunctionLength =
209 sizeof(struct usb_class_call_management_descriptor),
210 .bDescriptorType = CS_INTERFACE,
211 .bDescriptorSubtype = USB_ST_CMF,
212 .bmCapabilities = 0x00,
213 .bDataInterface = 0x01,
214 },
215 .usb_class_acm = {
216 .bFunctionLength =
217 sizeof(struct usb_class_abstract_control_descriptor),
218 .bDescriptorType = CS_INTERFACE,
219 .bDescriptorSubtype = USB_ST_ACMF,
220 .bmCapabilities = 0x00,
221 },
222 .usb_class_union = {
223 .bFunctionLength =
224 sizeof(struct usb_class_union_function_descriptor),
225 .bDescriptorType = CS_INTERFACE,
226 .bDescriptorSubtype = USB_ST_UF,
227 .bMasterInterface = 0x00,
228 .bSlaveInterface0 = 0x01,
229 },
230 .notification_endpoint = {
231 .bLength =
232 sizeof(struct usb_endpoint_descriptor),
233 .bDescriptorType = USB_DT_ENDPOINT,
234 .bEndpointAddress = 0x01 | USB_DIR_IN,
235 .bmAttributes = USB_ENDPOINT_XFER_INT,
236 .wMaxPacketSize
237 = cpu_to_le16(CONFIG_USBD_SERIAL_INT_PKTSIZE),
238 .bInterval = 0xFF,
239 },
240
241 /* Interface 2 */
242 .data_class_interface = {
243 .bLength =
244 sizeof(struct usb_interface_descriptor),
245 .bDescriptorType = USB_DT_INTERFACE,
246 .bInterfaceNumber = 0x01,
247 .bAlternateSetting = 0x00,
248 .bNumEndpoints = 0x02,
249 .bInterfaceClass =
250 COMMUNICATIONS_INTERFACE_CLASS_DATA,
251 .bInterfaceSubClass = DATA_INTERFACE_SUBCLASS_NONE,
252 .bInterfaceProtocol = DATA_INTERFACE_PROTOCOL_NONE,
253 .iInterface = STR_DATA_INTERFACE,
254 },
255 .data_endpoints = {
256 {
257 .bLength =
258 sizeof(struct usb_endpoint_descriptor),
259 .bDescriptorType = USB_DT_ENDPOINT,
260 .bEndpointAddress = 0x02 | USB_DIR_OUT,
261 .bmAttributes =
262 USB_ENDPOINT_XFER_BULK,
263 .wMaxPacketSize =
264 cpu_to_le16(CONFIG_USBD_SERIAL_BULK_PKTSIZE),
265 .bInterval = 0xFF,
266 },
267 {
268 .bLength =
269 sizeof(struct usb_endpoint_descriptor),
270 .bDescriptorType = USB_DT_ENDPOINT,
271 .bEndpointAddress = 0x03 | USB_DIR_IN,
272 .bmAttributes =
273 USB_ENDPOINT_XFER_BULK,
274 .wMaxPacketSize =
275 cpu_to_le16(CONFIG_USBD_SERIAL_BULK_PKTSIZE),
276 .bInterval = 0xFF,
277 },
278 },
279 #ifdef CONFIG_USBD_DFU
280 /* Interface 3 */
281 .uif_dfu = DFU_RT_IF_DESC,
282 .func_dfu = DFU_FUNC_DESC,
283 #endif
284 },
285 {
286 .configuration_desc ={
287 .bLength =
288 sizeof(struct usb_configuration_descriptor),
289 .bDescriptorType = USB_DT_CONFIG,
290 .wTotalLength =
291 cpu_to_le16(sizeof(struct acm_config_desc)
292 #ifdef CONFIG_USBD_DFU
293 - sizeof(struct usb_interface_descriptor)
294 - sizeof(struct usb_dfu_func_descriptor)
295 #endif
296 ),
297 .bNumInterfaces = NUM_ACM_INTERFACES,
298 .bConfigurationValue = 2,
299 .iConfiguration = STR_CONFIG,
300 .bmAttributes = BMATTRIBUTE_RESERVED,
301 .bMaxPower = 50, /* 100mA */
302 },
303 /* Interface 1 */
304 .interface_desc = {
305 .bLength = sizeof(struct usb_interface_descriptor),
306 .bDescriptorType = USB_DT_INTERFACE,
307 .bInterfaceNumber = 0,
308 .bAlternateSetting = 0,
309 .bNumEndpoints = 0x01,
310 .bInterfaceClass =
311 COMMUNICATIONS_INTERFACE_CLASS_CONTROL,
312 .bInterfaceSubClass = COMMUNICATIONS_ACM_SUBCLASS,
313 .bInterfaceProtocol = COMMUNICATIONS_V25TER_PROTOCOL,
314 .iInterface = STR_CTRL_INTERFACE,
315 },
316 .usb_class_header = {
317 .bFunctionLength =
318 sizeof(struct usb_class_header_function_descriptor),
319 .bDescriptorType = CS_INTERFACE,
320 .bDescriptorSubtype = USB_ST_HEADER,
321 .bcdCDC = cpu_to_le16(110),
322 },
323 .usb_class_call_mgt = {
324 .bFunctionLength =
325 sizeof(struct usb_class_call_management_descriptor),
326 .bDescriptorType = CS_INTERFACE,
327 .bDescriptorSubtype = USB_ST_CMF,
328 .bmCapabilities = 0x00,
329 .bDataInterface = 0x01,
330 },
331 .usb_class_acm = {
332 .bFunctionLength =
333 sizeof(struct usb_class_abstract_control_descriptor),
334 .bDescriptorType = CS_INTERFACE,
335 .bDescriptorSubtype = USB_ST_ACMF,
336 .bmCapabilities = 0x00,
337 },
338 .usb_class_union = {
339 .bFunctionLength =
340 sizeof(struct usb_class_union_function_descriptor),
341 .bDescriptorType = CS_INTERFACE,
342 .bDescriptorSubtype = USB_ST_UF,
343 .bMasterInterface = 0x00,
344 .bSlaveInterface0 = 0x01,
345 },
346 .notification_endpoint = {
347 .bLength =
348 sizeof(struct usb_endpoint_descriptor),
349 .bDescriptorType = USB_DT_ENDPOINT,
350 .bEndpointAddress = 0x01 | USB_DIR_IN,
351 .bmAttributes = USB_ENDPOINT_XFER_INT,
352 .wMaxPacketSize
353 = cpu_to_le16(CONFIG_USBD_SERIAL_INT_PKTSIZE),
354 .bInterval = 0xFF,
355 },
356
357 /* Interface 2 */
358 .data_class_interface = {
359 .bLength =
360 sizeof(struct usb_interface_descriptor),
361 .bDescriptorType = USB_DT_INTERFACE,
362 .bInterfaceNumber = 0x01,
363 .bAlternateSetting = 0x00,
364 .bNumEndpoints = 0x02,
365 .bInterfaceClass =
366 COMMUNICATIONS_INTERFACE_CLASS_DATA,
367 .bInterfaceSubClass = DATA_INTERFACE_SUBCLASS_NONE,
368 .bInterfaceProtocol = DATA_INTERFACE_PROTOCOL_NONE,
369 .iInterface = STR_DATA_INTERFACE,
370 },
371 .data_endpoints = {
372 {
373 .bLength =
374 sizeof(struct usb_endpoint_descriptor),
375 .bDescriptorType = USB_DT_ENDPOINT,
376 .bEndpointAddress = 0x02 | USB_DIR_OUT,
377 .bmAttributes =
378 USB_ENDPOINT_XFER_BULK,
379 .wMaxPacketSize =
380 cpu_to_le16(CONFIG_USBD_SERIAL_BULK_PKTSIZE),
381 .bInterval = 0xFF,
382 },
383 {
384 .bLength =
385 sizeof(struct usb_endpoint_descriptor),
386 .bDescriptorType = USB_DT_ENDPOINT,
387 .bEndpointAddress = 0x03 | USB_DIR_IN,
388 .bmAttributes =
389 USB_ENDPOINT_XFER_BULK,
390 .wMaxPacketSize =
391 cpu_to_le16(CONFIG_USBD_SERIAL_BULK_PKTSIZE),
392 .bInterval = 0xFF,
393 },
394 },
395 /* We don't add the DFU functional descriptor here since we only
396 * want to do DFU in the high-current charging mode for safety reasons */
397 },
398
399 };
400
401 static struct rs232_emu rs232_desc={
402 .dter = 115200,
403 .stop_bits = 0x00,
404 .parity = 0x00,
405 .data_bits = 0x08
406 };
407
408
409 /*
410 * Static Generic Serial specific data
411 */
412
413
414 struct gserial_config_desc {
415
416 struct usb_configuration_descriptor configuration_desc;
417 struct usb_interface_descriptor
418 interface_desc[NUM_GSERIAL_INTERFACES] __attribute__((packed));
419 struct usb_endpoint_descriptor
420 data_endpoints[NUM_ENDPOINTS] __attribute__((packed));
421
422 } __attribute__((packed));
423
424 static struct gserial_config_desc
425 gserial_configuration_descriptors[NUM_CONFIGS] ={
426 {
427 .configuration_desc ={
428 .bLength = sizeof(struct usb_configuration_descriptor),
429 .bDescriptorType = USB_DT_CONFIG,
430 .wTotalLength =
431 cpu_to_le16(sizeof(struct gserial_config_desc)),
432 .bNumInterfaces = NUM_GSERIAL_INTERFACES,
433 .bConfigurationValue = 1,
434 .iConfiguration = STR_CONFIG,
435 .bmAttributes = BMATTRIBUTE_RESERVED,
436 .bMaxPower = USBTTY_MAXPOWER
437 },
438 .interface_desc = {
439 {
440 .bLength =
441 sizeof(struct usb_interface_descriptor),
442 .bDescriptorType = USB_DT_INTERFACE,
443 .bInterfaceNumber = 0,
444 .bAlternateSetting = 0,
445 .bNumEndpoints = NUM_ENDPOINTS,
446 .bInterfaceClass =
447 COMMUNICATIONS_INTERFACE_CLASS_VENDOR,
448 .bInterfaceSubClass =
449 COMMUNICATIONS_NO_SUBCLASS,
450 .bInterfaceProtocol =
451 COMMUNICATIONS_NO_PROTOCOL,
452 .iInterface = STR_DATA_INTERFACE
453 },
454 },
455 .data_endpoints = {
456 {
457 .bLength =
458 sizeof(struct usb_endpoint_descriptor),
459 .bDescriptorType = USB_DT_ENDPOINT,
460 .bEndpointAddress = 0x01 | USB_DIR_OUT,
461 .bmAttributes = USB_ENDPOINT_XFER_BULK,
462 .wMaxPacketSize =
463 cpu_to_le16(CONFIG_USBD_SERIAL_OUT_PKTSIZE),
464 .bInterval= 0xFF,
465 },
466 {
467 .bLength =
468 sizeof(struct usb_endpoint_descriptor),
469 .bDescriptorType = USB_DT_ENDPOINT,
470 .bEndpointAddress = 0x02 | USB_DIR_IN,
471 .bmAttributes = USB_ENDPOINT_XFER_BULK,
472 .wMaxPacketSize =
473 cpu_to_le16(CONFIG_USBD_SERIAL_IN_PKTSIZE),
474 .bInterval = 0xFF,
475 },
476 {
477 .bLength =
478 sizeof(struct usb_endpoint_descriptor),
479 .bDescriptorType = USB_DT_ENDPOINT,
480 .bEndpointAddress = 0x03 | USB_DIR_IN,
481 .bmAttributes = USB_ENDPOINT_XFER_INT,
482 .wMaxPacketSize =
483 cpu_to_le16(CONFIG_USBD_SERIAL_INT_PKTSIZE),
484 .bInterval = 0xFF,
485 },
486 },
487 },
488 {
489 .configuration_desc ={
490 .bLength = sizeof(struct usb_configuration_descriptor),
491 .bDescriptorType = USB_DT_CONFIG,
492 .wTotalLength =
493 cpu_to_le16(sizeof(struct gserial_config_desc)),
494 .bNumInterfaces = NUM_GSERIAL_INTERFACES,
495 .bConfigurationValue = 1,
496 .iConfiguration = STR_CONFIG,
497 .bmAttributes = BMATTRIBUTE_RESERVED,
498 .bMaxPower = 50
499 },
500 .interface_desc = {
501 {
502 .bLength =
503 sizeof(struct usb_interface_descriptor),
504 .bDescriptorType = USB_DT_INTERFACE,
505 .bInterfaceNumber = 0,
506 .bAlternateSetting = 0,
507 .bNumEndpoints = NUM_ENDPOINTS,
508 .bInterfaceClass =
509 COMMUNICATIONS_INTERFACE_CLASS_VENDOR,
510 .bInterfaceSubClass =
511 COMMUNICATIONS_NO_SUBCLASS,
512 .bInterfaceProtocol =
513 COMMUNICATIONS_NO_PROTOCOL,
514 .iInterface = STR_DATA_INTERFACE
515 },
516 },
517 .data_endpoints = {
518 {
519 .bLength =
520 sizeof(struct usb_endpoint_descriptor),
521 .bDescriptorType = USB_DT_ENDPOINT,
522 .bEndpointAddress = 0x01 | USB_DIR_OUT,
523 .bmAttributes = USB_ENDPOINT_XFER_BULK,
524 .wMaxPacketSize =
525 cpu_to_le16(CONFIG_USBD_SERIAL_OUT_PKTSIZE),
526 .bInterval= 0xFF,
527 },
528 {
529 .bLength =
530 sizeof(struct usb_endpoint_descriptor),
531 .bDescriptorType = USB_DT_ENDPOINT,
532 .bEndpointAddress = 0x02 | USB_DIR_IN,
533 .bmAttributes = USB_ENDPOINT_XFER_BULK,
534 .wMaxPacketSize =
535 cpu_to_le16(CONFIG_USBD_SERIAL_IN_PKTSIZE),
536 .bInterval = 0xFF,
537 },
538 {
539 .bLength =
540 sizeof(struct usb_endpoint_descriptor),
541 .bDescriptorType = USB_DT_ENDPOINT,
542 .bEndpointAddress = 0x03 | USB_DIR_IN,
543 .bmAttributes = USB_ENDPOINT_XFER_INT,
544 .wMaxPacketSize =
545 cpu_to_le16(CONFIG_USBD_SERIAL_INT_PKTSIZE),
546 .bInterval = 0xFF,
547 },
548 },
549 },
550 };
551
552 /*
553 * Static Function Prototypes
554 */
555
556 static void usbtty_init_strings (void);
557 static void usbtty_init_instances (void);
558 static void usbtty_init_endpoints (void);
559 static void usbtty_init_terminal_type(short type);
560 static void usbtty_event_handler (struct usb_device_instance *device,
561 usb_device_event_t event, int data);
562 static int usbtty_cdc_setup(struct usb_device_request *request,
563 struct urb *urb);
564 static int usbtty_configured (void);
565 static int write_buffer (circbuf_t * buf);
566 static int fill_buffer (circbuf_t * buf);
567
568 void usbtty_poll (void);
569
570 /* utility function for converting char* to wide string used by USB */
571 void str2wide (char *str, u16 * wide)
572 {
573 int i;
574 for (i = 0; i < strlen (str) && str[i]; i++){
575 #if defined(__LITTLE_ENDIAN)
576 wide[i] = (u16) str[i];
577 #elif defined(__BIG_ENDIAN)
578 wide[i] = ((u16)(str[i])<<8);
579 #else
580 #error "__LITTLE_ENDIAN or __BIG_ENDIAN undefined"
581 #endif
582 }
583 }
584
585 /*
586 * Test whether a character is in the RX buffer
587 */
588
589 int usbtty_tstc (void)
590 {
591 struct usb_endpoint_instance *endpoint =
592 &endpoint_instance[rx_endpoint];
593
594 /* If no input data exists, allow more RX to be accepted */
595 if(usbtty_input.size <= 0){
596 udc_unset_nak(endpoint->endpoint_address&0x03);
597 }
598
599 usbtty_poll ();
600 return (usbtty_input.size > 0);
601 }
602
603 /*
604 * Read a single byte from the usb client port. Returns 1 on success, 0
605 * otherwise. When the function is succesfull, the character read is
606 * written into its argument c.
607 */
608
609 int usbtty_getc (void)
610 {
611 char c;
612 struct usb_endpoint_instance *endpoint =
613 &endpoint_instance[rx_endpoint];
614
615 while (usbtty_input.size <= 0) {
616 udc_unset_nak(endpoint->endpoint_address&0x03);
617 usbtty_poll ();
618 }
619
620 buf_pop (&usbtty_input, &c, 1);
621 udc_set_nak(endpoint->endpoint_address&0x03);
622
623 return c;
624 }
625
626 /*
627 * Output a single byte to the usb client port.
628 */
629 void usbtty_putc (const char c)
630 {
631 buf_push (&usbtty_output, &c, 1);
632 /* If \n, also do \r */
633 if (c == '\n')
634 buf_push (&usbtty_output, "\r", 1);
635
636 /* Poll at end to handle new data... */
637 if ((usbtty_output.size + 2) >= usbtty_output.totalsize) {
638 usbtty_poll ();
639 }
640 }
641
642 /* usbtty_puts() helper function for finding the next '\n' in a string */
643 static int next_nl_pos (const char *s)
644 {
645 int i;
646
647 for (i = 0; s[i] != '\0'; i++) {
648 if (s[i] == '\n')
649 return i;
650 }
651 return i;
652 }
653
654 /*
655 * Output a string to the usb client port - implementing flow control
656 */
657
658 static void __usbtty_puts (const char *str, int len)
659 {
660 int maxlen = usbtty_output.totalsize;
661 int space, n;
662
663 /* break str into chunks < buffer size, if needed */
664 while (len > 0) {
665 usbtty_poll ();
666
667 space = maxlen - usbtty_output.size;
668
669 /* If the USB is not configured, allow the circular buffer to
670 be overwritten. Otherwise this while() will loop forever. */
671 if (!usbtty_configured())
672 space = maxlen;
673
674 /* Empty buffer here, if needed, to ensure space... */
675 if (space) {
676 write_buffer (&usbtty_output);
677
678 n = MIN (space, MIN (len, maxlen));
679 buf_push (&usbtty_output, str, n);
680
681 str += n;
682 len -= n;
683 }
684 }
685 }
686
687 void usbtty_puts (const char *str)
688 {
689 int n;
690 int len = strlen (str);
691
692 /* add '\r' for each '\n' */
693 while (len > 0) {
694 n = next_nl_pos (str);
695
696 if (str[n] == '\n') {
697 __usbtty_puts (str, n + 1);
698 __usbtty_puts ("\r", 1);
699 str += (n + 1);
700 len -= (n + 1);
701 } else {
702 /* No \n found. All done. */
703 __usbtty_puts (str, n);
704 break;
705 }
706 }
707
708 /* Poll at end to handle new data... */
709 usbtty_poll ();
710 }
711
712 /*
713 * Initialize the usb client port.
714 *
715 */
716 int drv_usbtty_init (void)
717 {
718 int rc;
719 char * sn;
720 char * tt;
721 int snlen;
722
723 /* Ger seiral number */
724 if (!(sn = getenv("serial#"))) {
725 sn = "000000000000";
726 }
727 snlen = strlen(sn);
728 if (snlen > sizeof(serial_number) - 1) {
729 printf ("Warning: serial number %s is too long (%d > %d)\n",
730 sn, snlen, sizeof(serial_number) - 1);
731 snlen = sizeof(serial_number) - 1;
732 }
733 memcpy (serial_number, sn, snlen);
734 serial_number[snlen] = '\0';
735
736 /* Decide on which type of UDC device to be.
737 */
738
739 if(!(tt = getenv("usbtty"))) {
740 tt = "generic";
741 }
742 usbtty_init_terminal_type(strcmp(tt,"cdc_acm"));
743
744 /* Decide on which type of UDC device to be.
745 */
746
747 if(!(tt = getenv("usbtty"))) {
748 tt = "generic";
749 }
750 usbtty_init_terminal_type(strcmp(tt,"cdc_acm"));
751
752 /* prepare buffers... */
753 buf_init (&usbtty_input, USBTTY_BUFFER_SIZE);
754 buf_init (&usbtty_output, USBTTY_BUFFER_SIZE);
755
756 /* Now, set up USB controller and infrastructure */
757 udc_init (); /* Basic USB initialization */
758
759 usbtty_init_strings ();
760 usbtty_init_instances ();
761
762 udc_startup_events (device_instance);/* Enable dev, init udc pointers */
763 udc_connect (); /* Enable pullup for host detection */
764
765 usbtty_init_endpoints ();
766
767 /* Device initialization */
768 memset (&usbttydev, 0, sizeof (usbttydev));
769
770 strcpy (usbttydev.name, "usbtty");
771 usbttydev.ext = 0; /* No extensions */
772 usbttydev.flags = DEV_FLAGS_INPUT | DEV_FLAGS_OUTPUT;
773 usbttydev.tstc = usbtty_tstc; /* 'tstc' function */
774 usbttydev.getc = usbtty_getc; /* 'getc' function */
775 usbttydev.putc = usbtty_putc; /* 'putc' function */
776 usbttydev.puts = usbtty_puts; /* 'puts' function */
777
778 rc = device_register (&usbttydev);
779
780 return (rc == 0) ? 1 : rc;
781 }
782
783 static void usbtty_init_strings (void)
784 {
785 struct usb_string_descriptor *string;
786
787 usbtty_string_table[STR_LANG] =
788 (struct usb_string_descriptor*)wstrLang;
789
790 string = (struct usb_string_descriptor *) wstrManufacturer;
791 string->bLength = sizeof(wstrManufacturer);
792 string->bDescriptorType = USB_DT_STRING;
793 str2wide (CONFIG_USBD_MANUFACTURER, string->wData);
794 usbtty_string_table[STR_MANUFACTURER]=string;
795
796
797 string = (struct usb_string_descriptor *) wstrProduct;
798 string->bLength = sizeof(wstrProduct);
799 string->bDescriptorType = USB_DT_STRING;
800 str2wide (CONFIG_USBD_PRODUCT_NAME, string->wData);
801 usbtty_string_table[STR_PRODUCT]=string;
802
803
804 string = (struct usb_string_descriptor *) wstrSerial;
805 string->bLength = sizeof(serial_number);
806 string->bDescriptorType = USB_DT_STRING;
807 str2wide (serial_number, string->wData);
808 usbtty_string_table[STR_SERIAL]=string;
809
810
811 string = (struct usb_string_descriptor *) wstrConfiguration;
812 string->bLength = sizeof(wstrConfiguration);
813 string->bDescriptorType = USB_DT_STRING;
814 str2wide (CONFIG_USBD_CONFIGURATION_STR, string->wData);
815 usbtty_string_table[STR_CONFIG]=string;
816
817
818 string = (struct usb_string_descriptor *) wstrDataInterface;
819 string->bLength = sizeof(wstrDataInterface);
820 string->bDescriptorType = USB_DT_STRING;
821 str2wide (CONFIG_USBD_DATA_INTERFACE_STR, string->wData);
822 usbtty_string_table[STR_DATA_INTERFACE]=string;
823
824 string = (struct usb_string_descriptor *) wstrCtrlInterface;
825 string->bLength = sizeof(wstrCtrlInterface);
826 string->bDescriptorType = USB_DT_STRING;
827 str2wide (CONFIG_USBD_CTRL_INTERFACE_STR, string->wData);
828 usbtty_string_table[STR_CTRL_INTERFACE]=string;
829
830 /* Now, initialize the string table for ep0 handling */
831 usb_strings = usbtty_string_table;
832 }
833
834 static void usbtty_init_instances (void)
835 {
836 int i;
837
838 /* initialize device instance */
839 memset (device_instance, 0, sizeof (struct usb_device_instance));
840 device_instance->device_state = STATE_INIT;
841 device_instance->device_descriptor = &device_descriptor;
842 device_instance->event = usbtty_event_handler;
843 device_instance->cdc_recv_setup = usbtty_cdc_setup;
844 device_instance->bus = bus_instance;
845 device_instance->configurations = NUM_CONFIGS;
846 device_instance->configuration_instance_array = config_instance;
847 #ifdef CONFIG_USBD_DFU
848 dfu_init_instance(device_instance);
849 #endif
850
851 /* initialize bus instance */
852 memset (bus_instance, 0, sizeof (struct usb_bus_instance));
853 bus_instance->device = device_instance;
854 bus_instance->endpoint_array = endpoint_instance;
855 bus_instance->max_endpoints = 1;
856 bus_instance->maxpacketsize = 64;
857 bus_instance->serial_number_str = serial_number;
858
859 /* configuration instances */
860 for (i = 0; i < NUM_CONFIGS; i++) {
861 memset(&config_instance[i], 0, sizeof(config_instance));
862 config_instance[i].interfaces = interface_count;
863 /* FIXME: this breaks for the non-ACM case */
864 config_instance[i].configuration_descriptor = &acm_configuration_descriptors[i];
865 config_instance[i].interface_instance_array = interface_instance;
866 }
867
868 /* interface instance */
869 memset (interface_instance, 0,
870 sizeof (struct usb_interface_instance));
871 interface_instance->alternates = 1;
872 interface_instance->alternates_instance_array = alternate_instance;
873
874 /* alternates instance */
875 memset (alternate_instance, 0,
876 sizeof (struct usb_alternate_instance));
877 alternate_instance->interface_descriptor = interface_descriptors;
878 alternate_instance->endpoints = NUM_ENDPOINTS;
879 alternate_instance->endpoints_descriptor_array = ep_descriptor_ptrs;
880
881 /* endpoint instances */
882 memset (&endpoint_instance[0], 0,
883 sizeof (struct usb_endpoint_instance));
884 endpoint_instance[0].endpoint_address = 0;
885 endpoint_instance[0].rcv_packetSize = EP0_MAX_PACKET_SIZE;
886 endpoint_instance[0].rcv_attributes = USB_ENDPOINT_XFER_CONTROL;
887 endpoint_instance[0].tx_packetSize = EP0_MAX_PACKET_SIZE;
888 endpoint_instance[0].tx_attributes = USB_ENDPOINT_XFER_CONTROL;
889 udc_setup_ep (device_instance, 0, &endpoint_instance[0]);
890
891 for (i = 1; i <= NUM_ENDPOINTS; i++) {
892 memset (&endpoint_instance[i], 0,
893 sizeof (struct usb_endpoint_instance));
894
895 endpoint_instance[i].endpoint_address =
896 ep_descriptor_ptrs[i - 1]->bEndpointAddress;
897
898 endpoint_instance[i].rcv_attributes =
899 ep_descriptor_ptrs[i - 1]->bmAttributes;
900
901 endpoint_instance[i].rcv_packetSize =
902 le16_to_cpu(ep_descriptor_ptrs[i - 1]->wMaxPacketSize);
903
904 endpoint_instance[i].tx_attributes =
905 ep_descriptor_ptrs[i - 1]->bmAttributes;
906
907 endpoint_instance[i].tx_packetSize =
908 le16_to_cpu(ep_descriptor_ptrs[i - 1]->wMaxPacketSize);
909
910 endpoint_instance[i].tx_attributes =
911 ep_descriptor_ptrs[i - 1]->bmAttributes;
912
913 urb_link_init (&endpoint_instance[i].rcv);
914 urb_link_init (&endpoint_instance[i].rdy);
915 urb_link_init (&endpoint_instance[i].tx);
916 urb_link_init (&endpoint_instance[i].done);
917
918 if (endpoint_instance[i].endpoint_address & USB_DIR_IN)
919 endpoint_instance[i].tx_urb =
920 usbd_alloc_urb (device_instance,
921 &endpoint_instance[i]);
922 else
923 endpoint_instance[i].rcv_urb =
924 usbd_alloc_urb (device_instance,
925 &endpoint_instance[i]);
926 }
927 }
928
929 static void usbtty_init_endpoints (void)
930 {
931 int i;
932
933 bus_instance->max_endpoints = NUM_ENDPOINTS + 1;
934 for (i = 1; i <= NUM_ENDPOINTS; i++) {
935 udc_setup_ep (device_instance, i, &endpoint_instance[i]);
936 }
937 }
938
939 /* usbtty_init_terminal_type
940 *
941 * Do some late binding for our device type.
942 */
943 static void usbtty_init_terminal_type(short type)
944 {
945 switch(type){
946 /* CDC ACM */
947 case 0:
948 /* Assign endpoint descriptors */
949 ep_descriptor_ptrs[0] =
950 &acm_configuration_descriptors[0].notification_endpoint;
951 ep_descriptor_ptrs[1] =
952 &acm_configuration_descriptors[0].data_endpoints[0];
953 ep_descriptor_ptrs[2] =
954 &acm_configuration_descriptors[0].data_endpoints[1];
955
956 /* Enumerate Device Descriptor */
957 device_descriptor.bDeviceClass =
958 COMMUNICATIONS_DEVICE_CLASS;
959 device_descriptor.idProduct =
960 cpu_to_le16(CONFIG_USBD_PRODUCTID_CDCACM);
961
962 /* Assign endpoint indices */
963 tx_endpoint = ACM_TX_ENDPOINT;
964 rx_endpoint = ACM_RX_ENDPOINT;
965
966 /* Configuration Descriptor */
967 configuration_descriptor =
968 (struct usb_configuration_descriptor*)
969 &acm_configuration_descriptors;
970
971 /* Interface count */
972 interface_count = NUM_ACM_INTERFACES;
973 break;
974
975 /* BULK IN/OUT & Default */
976 case 1:
977 default:
978 /* Assign endpoint descriptors */
979 ep_descriptor_ptrs[0] =
980 &gserial_configuration_descriptors[0].data_endpoints[0];
981 ep_descriptor_ptrs[1] =
982 &gserial_configuration_descriptors[0].data_endpoints[1];
983 ep_descriptor_ptrs[2] =
984 &gserial_configuration_descriptors[0].data_endpoints[2];
985
986 /* Enumerate Device Descriptor */
987 device_descriptor.bDeviceClass = 0xFF;
988 device_descriptor.idProduct =
989 cpu_to_le16(CONFIG_USBD_PRODUCTID_GSERIAL);
990
991 /* Assign endpoint indices */
992 tx_endpoint = GSERIAL_TX_ENDPOINT;
993 rx_endpoint = GSERIAL_RX_ENDPOINT;
994
995 /* Configuration Descriptor */
996 configuration_descriptor =
997 (struct usb_configuration_descriptor*)
998 &gserial_configuration_descriptors;
999
1000 /* Interface count */
1001 interface_count = NUM_GSERIAL_INTERFACES;
1002 break;
1003 }
1004 }
1005
1006 /******************************************************************************/
1007
1008 static struct urb *next_urb (struct usb_device_instance *device,
1009 struct usb_endpoint_instance *endpoint)
1010 {
1011 struct urb *current_urb = NULL;
1012 int space;
1013
1014 /* If there's a queue, then we should add to the last urb */
1015 if (!endpoint->tx_queue) {
1016 current_urb = endpoint->tx_urb;
1017 } else {
1018 /* Last urb from tx chain */
1019 current_urb =
1020 p2surround (struct urb, link, endpoint->tx.prev);
1021 }
1022
1023 /* Make sure this one has enough room */
1024 space = current_urb->buffer_length - current_urb->actual_length;
1025 if (space > 0) {
1026 return current_urb;
1027 } else { /* No space here */
1028 /* First look at done list */
1029 current_urb = first_urb_detached (&endpoint->done);
1030 if (!current_urb) {
1031 current_urb = usbd_alloc_urb (device, endpoint);
1032 }
1033
1034 urb_append (&endpoint->tx, current_urb);
1035 endpoint->tx_queue++;
1036 }
1037 return current_urb;
1038 }
1039
1040 static int write_buffer (circbuf_t * buf)
1041 {
1042 if (!usbtty_configured ()) {
1043 return 0;
1044 }
1045
1046 struct usb_endpoint_instance *endpoint =
1047 &endpoint_instance[tx_endpoint];
1048 struct urb *current_urb = NULL;
1049 unsigned long flags;
1050
1051 local_irq_save(flags);
1052 current_urb = next_urb (device_instance, endpoint);
1053 /* TX data still exists - send it now
1054 */
1055
1056 /* I don't really understand what this logic is supposed to do,
1057 * at least on the s3c24xx usb driver it causes all data to be
1058 * transmitted twice !?! - Harald Welte */
1059 #if !(defined(CONFIG_S3C2410) || defined(CONFIG_S3C2440) || \
1060 defined(CONFIG_S3C2442) || defined(CONFIG_S3C2443))
1061 if(endpoint->sent < current_urb->actual_length){
1062 if(udc_endpoint_write (endpoint)){
1063 /* Write pre-empted by RX */
1064 local_irq_restore(flags);
1065 return -1;
1066 }
1067 }
1068 #endif
1069
1070 if (buf->size) {
1071 char *dest;
1072
1073 int space_avail;
1074 int popnum, popped;
1075 int total = 0;
1076
1077 /* Break buffer into urb sized pieces,
1078 * and link each to the endpoint
1079 */
1080 while (buf->size > 0) {
1081
1082 if (!current_urb) {
1083 TTYERR ("current_urb is NULL, buf->size %d\n",
1084 buf->size);
1085 local_irq_restore(flags);
1086 return total;
1087 }
1088
1089 dest = (char*)current_urb->buffer +
1090 current_urb->actual_length;
1091
1092 space_avail =
1093 current_urb->buffer_length -
1094 current_urb->actual_length;
1095 popnum = MIN (space_avail, buf->size);
1096 if (popnum == 0)
1097 break;
1098
1099 popped = buf_pop (buf, dest, popnum);
1100 if (popped == 0)
1101 break;
1102 current_urb->actual_length += popped;
1103 total += popped;
1104
1105 /* If endpoint->last == 0, then transfers have
1106 * not started on this endpoint
1107 */
1108 if (endpoint->last == 0) {
1109 if(udc_endpoint_write (endpoint)){
1110 /* Write pre-empted by RX */
1111 local_irq_restore(flags);
1112 return -1;
1113 }
1114 }
1115
1116 }/* end while */
1117 local_irq_restore(flags);
1118 return total;
1119 }
1120
1121 local_irq_restore(flags);
1122 return 0;
1123 }
1124
1125 static int fill_buffer (circbuf_t * buf)
1126 {
1127 struct usb_endpoint_instance *endpoint =
1128 &endpoint_instance[rx_endpoint];
1129 unsigned int nb = 0;
1130 unsigned long flags;
1131
1132 local_irq_save(flags);
1133 if (endpoint->rcv_urb && endpoint->rcv_urb->actual_length) {
1134 char *src = (char *) endpoint->rcv_urb->buffer;
1135 unsigned int rx_avail = buf->totalsize - buf->size;
1136
1137 if(rx_avail >= endpoint->rcv_urb->actual_length){
1138
1139 nb = endpoint->rcv_urb->actual_length;
1140 buf_push (buf, src, nb);
1141 endpoint->rcv_urb->actual_length = 0;
1142
1143 }
1144 }
1145 local_irq_restore(flags);
1146 return nb;
1147 }
1148
1149 static int usbtty_configured (void)
1150 {
1151 return usbtty_configured_flag;
1152 }
1153
1154 /******************************************************************************/
1155
1156 static void usbtty_event_handler (struct usb_device_instance *device,
1157 usb_device_event_t event, int data)
1158 {
1159 switch (event) {
1160 case DEVICE_RESET:
1161 case DEVICE_BUS_INACTIVE:
1162 usbtty_configured_flag = 0;
1163 break;
1164 case DEVICE_CONFIGURED:
1165 #if 0
1166 /* we can't afford sitting here and printing stuff. This code runs
1167 * in a time-critical context and printing stuff is a synchronous
1168 * serial activity... bad things can happen to USB peripheral
1169 */
1170 printf("DEVICE_CONFIGURED: %u\n", device->configuration);
1171 #endif
1172 if (device->configuration == 1)
1173 udc_ctrl(UDC_CTRL_500mA_ENABLE, 1);
1174 else
1175 udc_ctrl(UDC_CTRL_500mA_ENABLE, 0);
1176 usbtty_configured_flag = 1;
1177 break;
1178 case DEVICE_DE_CONFIGURED:
1179 #if 0
1180 /* we can't afford sitting here and printing stuff. This code runs
1181 * in a time-critical context and printing stuff is a synchronous
1182 * serial activity... bad things can happen to USB peripheral
1183 */
1184 printf("DEVICE_DECONFIGURED: %u\n", device->configuration);
1185 #endif
1186 udc_ctrl(UDC_CTRL_500mA_ENABLE, 0);
1187 break;
1188 case DEVICE_ADDRESS_ASSIGNED:
1189 usbtty_init_endpoints ();
1190
1191 default:
1192 break;
1193 }
1194 }
1195
1196 /******************************************************************************/
1197
1198 int usbtty_cdc_setup(struct usb_device_request *request, struct urb *urb)
1199 {
1200 switch (request->bRequest){
1201
1202 case ACM_SET_CONTROL_LINE_STATE: /* Implies DTE ready */
1203 break;
1204 case ACM_SEND_ENCAPSULATED_COMMAND : /* Required */
1205 break;
1206 case ACM_SET_LINE_ENCODING : /* DTE stop/parity bits
1207 * per character */
1208 break;
1209 case ACM_GET_ENCAPSULATED_RESPONSE : /* request response */
1210 break;
1211 case ACM_GET_LINE_ENCODING : /* request DTE rate,
1212 * stop/parity bits */
1213 memcpy (urb->buffer , &rs232_desc, sizeof(rs232_desc));
1214 urb->actual_length = sizeof(rs232_desc);
1215
1216 break;
1217 default:
1218 return 1;
1219 }
1220 return 0;
1221 }
1222
1223 /******************************************************************************/
1224
1225 /*
1226 * Since interrupt handling has not yet been implemented, we use this function
1227 * to handle polling. This is called by the tstc,getc,putc,puts routines to
1228 * update the USB state.
1229 */
1230 void usbtty_poll (void)
1231 {
1232 /* New interrupts? */
1233 udc_irq();
1234
1235 /* Write any output data to host buffer
1236 * (do this before checking interrupts to avoid missing one)
1237 */
1238 if (usbtty_configured ()) {
1239 write_buffer (&usbtty_output);
1240 }
1241
1242 /* New interrupts? */
1243 udc_irq();
1244
1245 /* Check for new data from host..
1246 * (do this after checking interrupts to get latest data)
1247 */
1248 if (usbtty_configured ()) {
1249 fill_buffer (&usbtty_input);
1250 }
1251
1252 /* New interrupts? */
1253 udc_irq();
1254
1255 }
1256
1257
1258 #endif
Fork of the u-boot for for Samsung based MINI2440 board