serial.c revision 9454a57ab5922e5cd25321cae9d1a8cbeb3e2e85
1/* 2 * g_serial.c -- USB gadget serial driver 3 * 4 * Copyright 2003 (C) Al Borchers (alborchers@steinerpoint.com) 5 * 6 * This code is based in part on the Gadget Zero driver, which 7 * is Copyright (C) 2003 by David Brownell, all rights reserved. 8 * 9 * This code also borrows from usbserial.c, which is 10 * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com) 11 * Copyright (C) 2000 Peter Berger (pberger@brimson.com) 12 * Copyright (C) 2000 Al Borchers (alborchers@steinerpoint.com) 13 * 14 * This software is distributed under the terms of the GNU General 15 * Public License ("GPL") as published by the Free Software Foundation, 16 * either version 2 of that License or (at your option) any later version. 17 * 18 */ 19 20#include <linux/kernel.h> 21#include <linux/utsname.h> 22#include <linux/device.h> 23#include <linux/tty.h> 24#include <linux/tty_flip.h> 25 26#include <linux/usb/ch9.h> 27#include <linux/usb/cdc.h> 28#include <linux/usb/gadget.h> 29 30#include "gadget_chips.h" 31 32 33/* Defines */ 34 35#define GS_VERSION_STR "v2.2" 36#define GS_VERSION_NUM 0x0202 37 38#define GS_LONG_NAME "Gadget Serial" 39#define GS_SHORT_NAME "g_serial" 40 41#define GS_MAJOR 127 42#define GS_MINOR_START 0 43 44#define GS_NUM_PORTS 16 45 46#define GS_NUM_CONFIGS 1 47#define GS_NO_CONFIG_ID 0 48#define GS_BULK_CONFIG_ID 1 49#define GS_ACM_CONFIG_ID 2 50 51#define GS_MAX_NUM_INTERFACES 2 52#define GS_BULK_INTERFACE_ID 0 53#define GS_CONTROL_INTERFACE_ID 0 54#define GS_DATA_INTERFACE_ID 1 55 56#define GS_MAX_DESC_LEN 256 57 58#define GS_DEFAULT_READ_Q_SIZE 32 59#define GS_DEFAULT_WRITE_Q_SIZE 32 60 61#define GS_DEFAULT_WRITE_BUF_SIZE 8192 62#define GS_TMP_BUF_SIZE 8192 63 64#define GS_CLOSE_TIMEOUT 15 65 66#define GS_DEFAULT_USE_ACM 0 67 68#define GS_DEFAULT_DTE_RATE 9600 69#define GS_DEFAULT_DATA_BITS 8 70#define GS_DEFAULT_PARITY USB_CDC_NO_PARITY 71#define GS_DEFAULT_CHAR_FORMAT USB_CDC_1_STOP_BITS 72 73/* maxpacket and other transfer characteristics vary by speed. */ 74static inline struct usb_endpoint_descriptor * 75choose_ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs, 76 struct usb_endpoint_descriptor *fs) 77{ 78 if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH) 79 return hs; 80 return fs; 81} 82 83 84/* debug settings */ 85#ifdef DEBUG 86static int debug = 1; 87#else 88#define debug 0 89#endif 90 91#define gs_debug(format, arg...) \ 92 do { if (debug) printk(KERN_DEBUG format, ## arg); } while(0) 93#define gs_debug_level(level, format, arg...) \ 94 do { if (debug>=level) printk(KERN_DEBUG format, ## arg); } while(0) 95 96 97/* Thanks to NetChip Technologies for donating this product ID. 98 * 99 * DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!! 100 * Instead: allocate your own, using normal USB-IF procedures. 101 */ 102#define GS_VENDOR_ID 0x0525 /* NetChip */ 103#define GS_PRODUCT_ID 0xa4a6 /* Linux-USB Serial Gadget */ 104#define GS_CDC_PRODUCT_ID 0xa4a7 /* ... as CDC-ACM */ 105 106#define GS_LOG2_NOTIFY_INTERVAL 5 /* 1 << 5 == 32 msec */ 107#define GS_NOTIFY_MAXPACKET 8 108 109 110/* Structures */ 111 112struct gs_dev; 113 114/* circular buffer */ 115struct gs_buf { 116 unsigned int buf_size; 117 char *buf_buf; 118 char *buf_get; 119 char *buf_put; 120}; 121 122/* list of requests */ 123struct gs_req_entry { 124 struct list_head re_entry; 125 struct usb_request *re_req; 126}; 127 128/* the port structure holds info for each port, one for each minor number */ 129struct gs_port { 130 struct gs_dev *port_dev; /* pointer to device struct */ 131 struct tty_struct *port_tty; /* pointer to tty struct */ 132 spinlock_t port_lock; 133 int port_num; 134 int port_open_count; 135 int port_in_use; /* open/close in progress */ 136 wait_queue_head_t port_write_wait;/* waiting to write */ 137 struct gs_buf *port_write_buf; 138 struct usb_cdc_line_coding port_line_coding; 139}; 140 141/* the device structure holds info for the USB device */ 142struct gs_dev { 143 struct usb_gadget *dev_gadget; /* gadget device pointer */ 144 spinlock_t dev_lock; /* lock for set/reset config */ 145 int dev_config; /* configuration number */ 146 struct usb_ep *dev_notify_ep; /* address of notify endpoint */ 147 struct usb_ep *dev_in_ep; /* address of in endpoint */ 148 struct usb_ep *dev_out_ep; /* address of out endpoint */ 149 struct usb_endpoint_descriptor /* descriptor of notify ep */ 150 *dev_notify_ep_desc; 151 struct usb_endpoint_descriptor /* descriptor of in endpoint */ 152 *dev_in_ep_desc; 153 struct usb_endpoint_descriptor /* descriptor of out endpoint */ 154 *dev_out_ep_desc; 155 struct usb_request *dev_ctrl_req; /* control request */ 156 struct list_head dev_req_list; /* list of write requests */ 157 int dev_sched_port; /* round robin port scheduled */ 158 struct gs_port *dev_port[GS_NUM_PORTS]; /* the ports */ 159}; 160 161 162/* Functions */ 163 164/* module */ 165static int __init gs_module_init(void); 166static void __exit gs_module_exit(void); 167 168/* tty driver */ 169static int gs_open(struct tty_struct *tty, struct file *file); 170static void gs_close(struct tty_struct *tty, struct file *file); 171static int gs_write(struct tty_struct *tty, 172 const unsigned char *buf, int count); 173static void gs_put_char(struct tty_struct *tty, unsigned char ch); 174static void gs_flush_chars(struct tty_struct *tty); 175static int gs_write_room(struct tty_struct *tty); 176static int gs_chars_in_buffer(struct tty_struct *tty); 177static void gs_throttle(struct tty_struct * tty); 178static void gs_unthrottle(struct tty_struct * tty); 179static void gs_break(struct tty_struct *tty, int break_state); 180static int gs_ioctl(struct tty_struct *tty, struct file *file, 181 unsigned int cmd, unsigned long arg); 182static void gs_set_termios(struct tty_struct *tty, struct ktermios *old); 183 184static int gs_send(struct gs_dev *dev); 185static int gs_send_packet(struct gs_dev *dev, char *packet, 186 unsigned int size); 187static int gs_recv_packet(struct gs_dev *dev, char *packet, 188 unsigned int size); 189static void gs_read_complete(struct usb_ep *ep, struct usb_request *req); 190static void gs_write_complete(struct usb_ep *ep, struct usb_request *req); 191 192/* gadget driver */ 193static int gs_bind(struct usb_gadget *gadget); 194static void gs_unbind(struct usb_gadget *gadget); 195static int gs_setup(struct usb_gadget *gadget, 196 const struct usb_ctrlrequest *ctrl); 197static int gs_setup_standard(struct usb_gadget *gadget, 198 const struct usb_ctrlrequest *ctrl); 199static int gs_setup_class(struct usb_gadget *gadget, 200 const struct usb_ctrlrequest *ctrl); 201static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req); 202static void gs_disconnect(struct usb_gadget *gadget); 203static int gs_set_config(struct gs_dev *dev, unsigned config); 204static void gs_reset_config(struct gs_dev *dev); 205static int gs_build_config_buf(u8 *buf, struct usb_gadget *g, 206 u8 type, unsigned int index, int is_otg); 207 208static struct usb_request *gs_alloc_req(struct usb_ep *ep, unsigned int len, 209 gfp_t kmalloc_flags); 210static void gs_free_req(struct usb_ep *ep, struct usb_request *req); 211 212static struct gs_req_entry *gs_alloc_req_entry(struct usb_ep *ep, unsigned len, 213 gfp_t kmalloc_flags); 214static void gs_free_req_entry(struct usb_ep *ep, struct gs_req_entry *req); 215 216static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags); 217static void gs_free_ports(struct gs_dev *dev); 218 219/* circular buffer */ 220static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags); 221static void gs_buf_free(struct gs_buf *gb); 222static void gs_buf_clear(struct gs_buf *gb); 223static unsigned int gs_buf_data_avail(struct gs_buf *gb); 224static unsigned int gs_buf_space_avail(struct gs_buf *gb); 225static unsigned int gs_buf_put(struct gs_buf *gb, const char *buf, 226 unsigned int count); 227static unsigned int gs_buf_get(struct gs_buf *gb, char *buf, 228 unsigned int count); 229 230/* external functions */ 231extern int net2280_set_fifo_mode(struct usb_gadget *gadget, int mode); 232 233 234/* Globals */ 235 236static struct gs_dev *gs_device; 237 238static const char *EP_IN_NAME; 239static const char *EP_OUT_NAME; 240static const char *EP_NOTIFY_NAME; 241 242static struct mutex gs_open_close_lock[GS_NUM_PORTS]; 243 244static unsigned int read_q_size = GS_DEFAULT_READ_Q_SIZE; 245static unsigned int write_q_size = GS_DEFAULT_WRITE_Q_SIZE; 246 247static unsigned int write_buf_size = GS_DEFAULT_WRITE_BUF_SIZE; 248 249static unsigned int use_acm = GS_DEFAULT_USE_ACM; 250 251 252/* tty driver struct */ 253static const struct tty_operations gs_tty_ops = { 254 .open = gs_open, 255 .close = gs_close, 256 .write = gs_write, 257 .put_char = gs_put_char, 258 .flush_chars = gs_flush_chars, 259 .write_room = gs_write_room, 260 .ioctl = gs_ioctl, 261 .set_termios = gs_set_termios, 262 .throttle = gs_throttle, 263 .unthrottle = gs_unthrottle, 264 .break_ctl = gs_break, 265 .chars_in_buffer = gs_chars_in_buffer, 266}; 267static struct tty_driver *gs_tty_driver; 268 269/* gadget driver struct */ 270static struct usb_gadget_driver gs_gadget_driver = { 271#ifdef CONFIG_USB_GADGET_DUALSPEED 272 .speed = USB_SPEED_HIGH, 273#else 274 .speed = USB_SPEED_FULL, 275#endif /* CONFIG_USB_GADGET_DUALSPEED */ 276 .function = GS_LONG_NAME, 277 .bind = gs_bind, 278 .unbind = gs_unbind, 279 .setup = gs_setup, 280 .disconnect = gs_disconnect, 281 .driver = { 282 .name = GS_SHORT_NAME, 283 }, 284}; 285 286 287/* USB descriptors */ 288 289#define GS_MANUFACTURER_STR_ID 1 290#define GS_PRODUCT_STR_ID 2 291#define GS_SERIAL_STR_ID 3 292#define GS_BULK_CONFIG_STR_ID 4 293#define GS_ACM_CONFIG_STR_ID 5 294#define GS_CONTROL_STR_ID 6 295#define GS_DATA_STR_ID 7 296 297/* static strings, in UTF-8 */ 298static char manufacturer[50]; 299static struct usb_string gs_strings[] = { 300 { GS_MANUFACTURER_STR_ID, manufacturer }, 301 { GS_PRODUCT_STR_ID, GS_LONG_NAME }, 302 { GS_SERIAL_STR_ID, "0" }, 303 { GS_BULK_CONFIG_STR_ID, "Gadget Serial Bulk" }, 304 { GS_ACM_CONFIG_STR_ID, "Gadget Serial CDC ACM" }, 305 { GS_CONTROL_STR_ID, "Gadget Serial Control" }, 306 { GS_DATA_STR_ID, "Gadget Serial Data" }, 307 { } /* end of list */ 308}; 309 310static struct usb_gadget_strings gs_string_table = { 311 .language = 0x0409, /* en-us */ 312 .strings = gs_strings, 313}; 314 315static struct usb_device_descriptor gs_device_desc = { 316 .bLength = USB_DT_DEVICE_SIZE, 317 .bDescriptorType = USB_DT_DEVICE, 318 .bcdUSB = __constant_cpu_to_le16(0x0200), 319 .bDeviceSubClass = 0, 320 .bDeviceProtocol = 0, 321 .idVendor = __constant_cpu_to_le16(GS_VENDOR_ID), 322 .idProduct = __constant_cpu_to_le16(GS_PRODUCT_ID), 323 .iManufacturer = GS_MANUFACTURER_STR_ID, 324 .iProduct = GS_PRODUCT_STR_ID, 325 .iSerialNumber = GS_SERIAL_STR_ID, 326 .bNumConfigurations = GS_NUM_CONFIGS, 327}; 328 329static struct usb_otg_descriptor gs_otg_descriptor = { 330 .bLength = sizeof(gs_otg_descriptor), 331 .bDescriptorType = USB_DT_OTG, 332 .bmAttributes = USB_OTG_SRP, 333}; 334 335static struct usb_config_descriptor gs_bulk_config_desc = { 336 .bLength = USB_DT_CONFIG_SIZE, 337 .bDescriptorType = USB_DT_CONFIG, 338 /* .wTotalLength computed dynamically */ 339 .bNumInterfaces = 1, 340 .bConfigurationValue = GS_BULK_CONFIG_ID, 341 .iConfiguration = GS_BULK_CONFIG_STR_ID, 342 .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER, 343 .bMaxPower = 1, 344}; 345 346static struct usb_config_descriptor gs_acm_config_desc = { 347 .bLength = USB_DT_CONFIG_SIZE, 348 .bDescriptorType = USB_DT_CONFIG, 349 /* .wTotalLength computed dynamically */ 350 .bNumInterfaces = 2, 351 .bConfigurationValue = GS_ACM_CONFIG_ID, 352 .iConfiguration = GS_ACM_CONFIG_STR_ID, 353 .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER, 354 .bMaxPower = 1, 355}; 356 357static const struct usb_interface_descriptor gs_bulk_interface_desc = { 358 .bLength = USB_DT_INTERFACE_SIZE, 359 .bDescriptorType = USB_DT_INTERFACE, 360 .bInterfaceNumber = GS_BULK_INTERFACE_ID, 361 .bNumEndpoints = 2, 362 .bInterfaceClass = USB_CLASS_CDC_DATA, 363 .bInterfaceSubClass = 0, 364 .bInterfaceProtocol = 0, 365 .iInterface = GS_DATA_STR_ID, 366}; 367 368static const struct usb_interface_descriptor gs_control_interface_desc = { 369 .bLength = USB_DT_INTERFACE_SIZE, 370 .bDescriptorType = USB_DT_INTERFACE, 371 .bInterfaceNumber = GS_CONTROL_INTERFACE_ID, 372 .bNumEndpoints = 1, 373 .bInterfaceClass = USB_CLASS_COMM, 374 .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM, 375 .bInterfaceProtocol = USB_CDC_ACM_PROTO_AT_V25TER, 376 .iInterface = GS_CONTROL_STR_ID, 377}; 378 379static const struct usb_interface_descriptor gs_data_interface_desc = { 380 .bLength = USB_DT_INTERFACE_SIZE, 381 .bDescriptorType = USB_DT_INTERFACE, 382 .bInterfaceNumber = GS_DATA_INTERFACE_ID, 383 .bNumEndpoints = 2, 384 .bInterfaceClass = USB_CLASS_CDC_DATA, 385 .bInterfaceSubClass = 0, 386 .bInterfaceProtocol = 0, 387 .iInterface = GS_DATA_STR_ID, 388}; 389 390static const struct usb_cdc_header_desc gs_header_desc = { 391 .bLength = sizeof(gs_header_desc), 392 .bDescriptorType = USB_DT_CS_INTERFACE, 393 .bDescriptorSubType = USB_CDC_HEADER_TYPE, 394 .bcdCDC = __constant_cpu_to_le16(0x0110), 395}; 396 397static const struct usb_cdc_call_mgmt_descriptor gs_call_mgmt_descriptor = { 398 .bLength = sizeof(gs_call_mgmt_descriptor), 399 .bDescriptorType = USB_DT_CS_INTERFACE, 400 .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE, 401 .bmCapabilities = 0, 402 .bDataInterface = 1, /* index of data interface */ 403}; 404 405static struct usb_cdc_acm_descriptor gs_acm_descriptor = { 406 .bLength = sizeof(gs_acm_descriptor), 407 .bDescriptorType = USB_DT_CS_INTERFACE, 408 .bDescriptorSubType = USB_CDC_ACM_TYPE, 409 .bmCapabilities = 0, 410}; 411 412static const struct usb_cdc_union_desc gs_union_desc = { 413 .bLength = sizeof(gs_union_desc), 414 .bDescriptorType = USB_DT_CS_INTERFACE, 415 .bDescriptorSubType = USB_CDC_UNION_TYPE, 416 .bMasterInterface0 = 0, /* index of control interface */ 417 .bSlaveInterface0 = 1, /* index of data interface */ 418}; 419 420static struct usb_endpoint_descriptor gs_fullspeed_notify_desc = { 421 .bLength = USB_DT_ENDPOINT_SIZE, 422 .bDescriptorType = USB_DT_ENDPOINT, 423 .bEndpointAddress = USB_DIR_IN, 424 .bmAttributes = USB_ENDPOINT_XFER_INT, 425 .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET), 426 .bInterval = 1 << GS_LOG2_NOTIFY_INTERVAL, 427}; 428 429static struct usb_endpoint_descriptor gs_fullspeed_in_desc = { 430 .bLength = USB_DT_ENDPOINT_SIZE, 431 .bDescriptorType = USB_DT_ENDPOINT, 432 .bEndpointAddress = USB_DIR_IN, 433 .bmAttributes = USB_ENDPOINT_XFER_BULK, 434}; 435 436static struct usb_endpoint_descriptor gs_fullspeed_out_desc = { 437 .bLength = USB_DT_ENDPOINT_SIZE, 438 .bDescriptorType = USB_DT_ENDPOINT, 439 .bEndpointAddress = USB_DIR_OUT, 440 .bmAttributes = USB_ENDPOINT_XFER_BULK, 441}; 442 443static const struct usb_descriptor_header *gs_bulk_fullspeed_function[] = { 444 (struct usb_descriptor_header *) &gs_otg_descriptor, 445 (struct usb_descriptor_header *) &gs_bulk_interface_desc, 446 (struct usb_descriptor_header *) &gs_fullspeed_in_desc, 447 (struct usb_descriptor_header *) &gs_fullspeed_out_desc, 448 NULL, 449}; 450 451static const struct usb_descriptor_header *gs_acm_fullspeed_function[] = { 452 (struct usb_descriptor_header *) &gs_otg_descriptor, 453 (struct usb_descriptor_header *) &gs_control_interface_desc, 454 (struct usb_descriptor_header *) &gs_header_desc, 455 (struct usb_descriptor_header *) &gs_call_mgmt_descriptor, 456 (struct usb_descriptor_header *) &gs_acm_descriptor, 457 (struct usb_descriptor_header *) &gs_union_desc, 458 (struct usb_descriptor_header *) &gs_fullspeed_notify_desc, 459 (struct usb_descriptor_header *) &gs_data_interface_desc, 460 (struct usb_descriptor_header *) &gs_fullspeed_in_desc, 461 (struct usb_descriptor_header *) &gs_fullspeed_out_desc, 462 NULL, 463}; 464 465static struct usb_endpoint_descriptor gs_highspeed_notify_desc = { 466 .bLength = USB_DT_ENDPOINT_SIZE, 467 .bDescriptorType = USB_DT_ENDPOINT, 468 .bEndpointAddress = USB_DIR_IN, 469 .bmAttributes = USB_ENDPOINT_XFER_INT, 470 .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET), 471 .bInterval = GS_LOG2_NOTIFY_INTERVAL+4, 472}; 473 474static struct usb_endpoint_descriptor gs_highspeed_in_desc = { 475 .bLength = USB_DT_ENDPOINT_SIZE, 476 .bDescriptorType = USB_DT_ENDPOINT, 477 .bmAttributes = USB_ENDPOINT_XFER_BULK, 478 .wMaxPacketSize = __constant_cpu_to_le16(512), 479}; 480 481static struct usb_endpoint_descriptor gs_highspeed_out_desc = { 482 .bLength = USB_DT_ENDPOINT_SIZE, 483 .bDescriptorType = USB_DT_ENDPOINT, 484 .bmAttributes = USB_ENDPOINT_XFER_BULK, 485 .wMaxPacketSize = __constant_cpu_to_le16(512), 486}; 487 488static struct usb_qualifier_descriptor gs_qualifier_desc = { 489 .bLength = sizeof(struct usb_qualifier_descriptor), 490 .bDescriptorType = USB_DT_DEVICE_QUALIFIER, 491 .bcdUSB = __constant_cpu_to_le16 (0x0200), 492 /* assumes ep0 uses the same value for both speeds ... */ 493 .bNumConfigurations = GS_NUM_CONFIGS, 494}; 495 496static const struct usb_descriptor_header *gs_bulk_highspeed_function[] = { 497 (struct usb_descriptor_header *) &gs_otg_descriptor, 498 (struct usb_descriptor_header *) &gs_bulk_interface_desc, 499 (struct usb_descriptor_header *) &gs_highspeed_in_desc, 500 (struct usb_descriptor_header *) &gs_highspeed_out_desc, 501 NULL, 502}; 503 504static const struct usb_descriptor_header *gs_acm_highspeed_function[] = { 505 (struct usb_descriptor_header *) &gs_otg_descriptor, 506 (struct usb_descriptor_header *) &gs_control_interface_desc, 507 (struct usb_descriptor_header *) &gs_header_desc, 508 (struct usb_descriptor_header *) &gs_call_mgmt_descriptor, 509 (struct usb_descriptor_header *) &gs_acm_descriptor, 510 (struct usb_descriptor_header *) &gs_union_desc, 511 (struct usb_descriptor_header *) &gs_highspeed_notify_desc, 512 (struct usb_descriptor_header *) &gs_data_interface_desc, 513 (struct usb_descriptor_header *) &gs_highspeed_in_desc, 514 (struct usb_descriptor_header *) &gs_highspeed_out_desc, 515 NULL, 516}; 517 518 519/* Module */ 520MODULE_DESCRIPTION(GS_LONG_NAME); 521MODULE_AUTHOR("Al Borchers"); 522MODULE_LICENSE("GPL"); 523 524#ifdef DEBUG 525module_param(debug, int, S_IRUGO|S_IWUSR); 526MODULE_PARM_DESC(debug, "Enable debugging, 0=off, 1=on"); 527#endif 528 529module_param(read_q_size, uint, S_IRUGO); 530MODULE_PARM_DESC(read_q_size, "Read request queue size, default=32"); 531 532module_param(write_q_size, uint, S_IRUGO); 533MODULE_PARM_DESC(write_q_size, "Write request queue size, default=32"); 534 535module_param(write_buf_size, uint, S_IRUGO); 536MODULE_PARM_DESC(write_buf_size, "Write buffer size, default=8192"); 537 538module_param(use_acm, uint, S_IRUGO); 539MODULE_PARM_DESC(use_acm, "Use CDC ACM, 0=no, 1=yes, default=no"); 540 541module_init(gs_module_init); 542module_exit(gs_module_exit); 543 544/* 545* gs_module_init 546* 547* Register as a USB gadget driver and a tty driver. 548*/ 549static int __init gs_module_init(void) 550{ 551 int i; 552 int retval; 553 554 retval = usb_gadget_register_driver(&gs_gadget_driver); 555 if (retval) { 556 printk(KERN_ERR "gs_module_init: cannot register gadget driver, ret=%d\n", retval); 557 return retval; 558 } 559 560 gs_tty_driver = alloc_tty_driver(GS_NUM_PORTS); 561 if (!gs_tty_driver) 562 return -ENOMEM; 563 gs_tty_driver->owner = THIS_MODULE; 564 gs_tty_driver->driver_name = GS_SHORT_NAME; 565 gs_tty_driver->name = "ttygs"; 566 gs_tty_driver->major = GS_MAJOR; 567 gs_tty_driver->minor_start = GS_MINOR_START; 568 gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 569 gs_tty_driver->subtype = SERIAL_TYPE_NORMAL; 570 gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 571 gs_tty_driver->init_termios = tty_std_termios; 572 gs_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 573 tty_set_operations(gs_tty_driver, &gs_tty_ops); 574 575 for (i=0; i < GS_NUM_PORTS; i++) 576 mutex_init(&gs_open_close_lock[i]); 577 578 retval = tty_register_driver(gs_tty_driver); 579 if (retval) { 580 usb_gadget_unregister_driver(&gs_gadget_driver); 581 put_tty_driver(gs_tty_driver); 582 printk(KERN_ERR "gs_module_init: cannot register tty driver, ret=%d\n", retval); 583 return retval; 584 } 585 586 printk(KERN_INFO "gs_module_init: %s %s loaded\n", GS_LONG_NAME, GS_VERSION_STR); 587 return 0; 588} 589 590/* 591* gs_module_exit 592* 593* Unregister as a tty driver and a USB gadget driver. 594*/ 595static void __exit gs_module_exit(void) 596{ 597 tty_unregister_driver(gs_tty_driver); 598 put_tty_driver(gs_tty_driver); 599 usb_gadget_unregister_driver(&gs_gadget_driver); 600 601 printk(KERN_INFO "gs_module_exit: %s %s unloaded\n", GS_LONG_NAME, GS_VERSION_STR); 602} 603 604/* TTY Driver */ 605 606/* 607 * gs_open 608 */ 609static int gs_open(struct tty_struct *tty, struct file *file) 610{ 611 int port_num; 612 unsigned long flags; 613 struct gs_port *port; 614 struct gs_dev *dev; 615 struct gs_buf *buf; 616 struct mutex *mtx; 617 int ret; 618 619 port_num = tty->index; 620 621 gs_debug("gs_open: (%d,%p,%p)\n", port_num, tty, file); 622 623 if (port_num < 0 || port_num >= GS_NUM_PORTS) { 624 printk(KERN_ERR "gs_open: (%d,%p,%p) invalid port number\n", 625 port_num, tty, file); 626 return -ENODEV; 627 } 628 629 dev = gs_device; 630 631 if (dev == NULL) { 632 printk(KERN_ERR "gs_open: (%d,%p,%p) NULL device pointer\n", 633 port_num, tty, file); 634 return -ENODEV; 635 } 636 637 mtx = &gs_open_close_lock[port_num]; 638 if (mutex_lock_interruptible(mtx)) { 639 printk(KERN_ERR 640 "gs_open: (%d,%p,%p) interrupted waiting for mutex\n", 641 port_num, tty, file); 642 return -ERESTARTSYS; 643 } 644 645 spin_lock_irqsave(&dev->dev_lock, flags); 646 647 if (dev->dev_config == GS_NO_CONFIG_ID) { 648 printk(KERN_ERR 649 "gs_open: (%d,%p,%p) device is not connected\n", 650 port_num, tty, file); 651 ret = -ENODEV; 652 goto exit_unlock_dev; 653 } 654 655 port = dev->dev_port[port_num]; 656 657 if (port == NULL) { 658 printk(KERN_ERR "gs_open: (%d,%p,%p) NULL port pointer\n", 659 port_num, tty, file); 660 ret = -ENODEV; 661 goto exit_unlock_dev; 662 } 663 664 spin_lock(&port->port_lock); 665 spin_unlock(&dev->dev_lock); 666 667 if (port->port_dev == NULL) { 668 printk(KERN_ERR "gs_open: (%d,%p,%p) port disconnected (1)\n", 669 port_num, tty, file); 670 ret = -EIO; 671 goto exit_unlock_port; 672 } 673 674 if (port->port_open_count > 0) { 675 ++port->port_open_count; 676 gs_debug("gs_open: (%d,%p,%p) already open\n", 677 port_num, tty, file); 678 ret = 0; 679 goto exit_unlock_port; 680 } 681 682 tty->driver_data = NULL; 683 684 /* mark port as in use, we can drop port lock and sleep if necessary */ 685 port->port_in_use = 1; 686 687 /* allocate write buffer on first open */ 688 if (port->port_write_buf == NULL) { 689 spin_unlock_irqrestore(&port->port_lock, flags); 690 buf = gs_buf_alloc(write_buf_size, GFP_KERNEL); 691 spin_lock_irqsave(&port->port_lock, flags); 692 693 /* might have been disconnected while asleep, check */ 694 if (port->port_dev == NULL) { 695 printk(KERN_ERR 696 "gs_open: (%d,%p,%p) port disconnected (2)\n", 697 port_num, tty, file); 698 port->port_in_use = 0; 699 ret = -EIO; 700 goto exit_unlock_port; 701 } 702 703 if ((port->port_write_buf=buf) == NULL) { 704 printk(KERN_ERR "gs_open: (%d,%p,%p) cannot allocate port write buffer\n", 705 port_num, tty, file); 706 port->port_in_use = 0; 707 ret = -ENOMEM; 708 goto exit_unlock_port; 709 } 710 711 } 712 713 /* wait for carrier detect (not implemented) */ 714 715 /* might have been disconnected while asleep, check */ 716 if (port->port_dev == NULL) { 717 printk(KERN_ERR "gs_open: (%d,%p,%p) port disconnected (3)\n", 718 port_num, tty, file); 719 port->port_in_use = 0; 720 ret = -EIO; 721 goto exit_unlock_port; 722 } 723 724 tty->driver_data = port; 725 port->port_tty = tty; 726 port->port_open_count = 1; 727 port->port_in_use = 0; 728 729 gs_debug("gs_open: (%d,%p,%p) completed\n", port_num, tty, file); 730 731 ret = 0; 732 733exit_unlock_port: 734 spin_unlock_irqrestore(&port->port_lock, flags); 735 mutex_unlock(mtx); 736 return ret; 737 738exit_unlock_dev: 739 spin_unlock_irqrestore(&dev->dev_lock, flags); 740 mutex_unlock(mtx); 741 return ret; 742 743} 744 745/* 746 * gs_close 747 */ 748 749#define GS_WRITE_FINISHED_EVENT_SAFELY(p) \ 750({ \ 751 int cond; \ 752 \ 753 spin_lock_irq(&(p)->port_lock); \ 754 cond = !(p)->port_dev || !gs_buf_data_avail((p)->port_write_buf); \ 755 spin_unlock_irq(&(p)->port_lock); \ 756 cond; \ 757}) 758 759static void gs_close(struct tty_struct *tty, struct file *file) 760{ 761 struct gs_port *port = tty->driver_data; 762 struct mutex *mtx; 763 764 if (port == NULL) { 765 printk(KERN_ERR "gs_close: NULL port pointer\n"); 766 return; 767 } 768 769 gs_debug("gs_close: (%d,%p,%p)\n", port->port_num, tty, file); 770 771 mtx = &gs_open_close_lock[port->port_num]; 772 mutex_lock(mtx); 773 774 spin_lock_irq(&port->port_lock); 775 776 if (port->port_open_count == 0) { 777 printk(KERN_ERR 778 "gs_close: (%d,%p,%p) port is already closed\n", 779 port->port_num, tty, file); 780 goto exit; 781 } 782 783 if (port->port_open_count > 1) { 784 --port->port_open_count; 785 goto exit; 786 } 787 788 /* free disconnected port on final close */ 789 if (port->port_dev == NULL) { 790 kfree(port); 791 goto exit; 792 } 793 794 /* mark port as closed but in use, we can drop port lock */ 795 /* and sleep if necessary */ 796 port->port_in_use = 1; 797 port->port_open_count = 0; 798 799 /* wait for write buffer to drain, or */ 800 /* at most GS_CLOSE_TIMEOUT seconds */ 801 if (gs_buf_data_avail(port->port_write_buf) > 0) { 802 spin_unlock_irq(&port->port_lock); 803 wait_event_interruptible_timeout(port->port_write_wait, 804 GS_WRITE_FINISHED_EVENT_SAFELY(port), 805 GS_CLOSE_TIMEOUT * HZ); 806 spin_lock_irq(&port->port_lock); 807 } 808 809 /* free disconnected port on final close */ 810 /* (might have happened during the above sleep) */ 811 if (port->port_dev == NULL) { 812 kfree(port); 813 goto exit; 814 } 815 816 gs_buf_clear(port->port_write_buf); 817 818 tty->driver_data = NULL; 819 port->port_tty = NULL; 820 port->port_in_use = 0; 821 822 gs_debug("gs_close: (%d,%p,%p) completed\n", 823 port->port_num, tty, file); 824 825exit: 826 spin_unlock_irq(&port->port_lock); 827 mutex_unlock(mtx); 828} 829 830/* 831 * gs_write 832 */ 833static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count) 834{ 835 unsigned long flags; 836 struct gs_port *port = tty->driver_data; 837 int ret; 838 839 if (port == NULL) { 840 printk(KERN_ERR "gs_write: NULL port pointer\n"); 841 return -EIO; 842 } 843 844 gs_debug("gs_write: (%d,%p) writing %d bytes\n", port->port_num, tty, 845 count); 846 847 if (count == 0) 848 return 0; 849 850 spin_lock_irqsave(&port->port_lock, flags); 851 852 if (port->port_dev == NULL) { 853 printk(KERN_ERR "gs_write: (%d,%p) port is not connected\n", 854 port->port_num, tty); 855 ret = -EIO; 856 goto exit; 857 } 858 859 if (port->port_open_count == 0) { 860 printk(KERN_ERR "gs_write: (%d,%p) port is closed\n", 861 port->port_num, tty); 862 ret = -EBADF; 863 goto exit; 864 } 865 866 count = gs_buf_put(port->port_write_buf, buf, count); 867 868 spin_unlock_irqrestore(&port->port_lock, flags); 869 870 gs_send(gs_device); 871 872 gs_debug("gs_write: (%d,%p) wrote %d bytes\n", port->port_num, tty, 873 count); 874 875 return count; 876 877exit: 878 spin_unlock_irqrestore(&port->port_lock, flags); 879 return ret; 880} 881 882/* 883 * gs_put_char 884 */ 885static void gs_put_char(struct tty_struct *tty, unsigned char ch) 886{ 887 unsigned long flags; 888 struct gs_port *port = tty->driver_data; 889 890 if (port == NULL) { 891 printk(KERN_ERR "gs_put_char: NULL port pointer\n"); 892 return; 893 } 894 895 gs_debug("gs_put_char: (%d,%p) char=0x%x, called from %p\n", 896 port->port_num, tty, ch, __builtin_return_address(0)); 897 898 spin_lock_irqsave(&port->port_lock, flags); 899 900 if (port->port_dev == NULL) { 901 printk(KERN_ERR "gs_put_char: (%d,%p) port is not connected\n", 902 port->port_num, tty); 903 goto exit; 904 } 905 906 if (port->port_open_count == 0) { 907 printk(KERN_ERR "gs_put_char: (%d,%p) port is closed\n", 908 port->port_num, tty); 909 goto exit; 910 } 911 912 gs_buf_put(port->port_write_buf, &ch, 1); 913 914exit: 915 spin_unlock_irqrestore(&port->port_lock, flags); 916} 917 918/* 919 * gs_flush_chars 920 */ 921static void gs_flush_chars(struct tty_struct *tty) 922{ 923 unsigned long flags; 924 struct gs_port *port = tty->driver_data; 925 926 if (port == NULL) { 927 printk(KERN_ERR "gs_flush_chars: NULL port pointer\n"); 928 return; 929 } 930 931 gs_debug("gs_flush_chars: (%d,%p)\n", port->port_num, tty); 932 933 spin_lock_irqsave(&port->port_lock, flags); 934 935 if (port->port_dev == NULL) { 936 printk(KERN_ERR 937 "gs_flush_chars: (%d,%p) port is not connected\n", 938 port->port_num, tty); 939 goto exit; 940 } 941 942 if (port->port_open_count == 0) { 943 printk(KERN_ERR "gs_flush_chars: (%d,%p) port is closed\n", 944 port->port_num, tty); 945 goto exit; 946 } 947 948 spin_unlock_irqrestore(&port->port_lock, flags); 949 950 gs_send(gs_device); 951 952 return; 953 954exit: 955 spin_unlock_irqrestore(&port->port_lock, flags); 956} 957 958/* 959 * gs_write_room 960 */ 961static int gs_write_room(struct tty_struct *tty) 962{ 963 964 int room = 0; 965 unsigned long flags; 966 struct gs_port *port = tty->driver_data; 967 968 969 if (port == NULL) 970 return 0; 971 972 spin_lock_irqsave(&port->port_lock, flags); 973 974 if (port->port_dev != NULL && port->port_open_count > 0 975 && port->port_write_buf != NULL) 976 room = gs_buf_space_avail(port->port_write_buf); 977 978 spin_unlock_irqrestore(&port->port_lock, flags); 979 980 gs_debug("gs_write_room: (%d,%p) room=%d\n", 981 port->port_num, tty, room); 982 983 return room; 984} 985 986/* 987 * gs_chars_in_buffer 988 */ 989static int gs_chars_in_buffer(struct tty_struct *tty) 990{ 991 int chars = 0; 992 unsigned long flags; 993 struct gs_port *port = tty->driver_data; 994 995 if (port == NULL) 996 return 0; 997 998 spin_lock_irqsave(&port->port_lock, flags); 999 1000 if (port->port_dev != NULL && port->port_open_count > 0 1001 && port->port_write_buf != NULL) 1002 chars = gs_buf_data_avail(port->port_write_buf); 1003 1004 spin_unlock_irqrestore(&port->port_lock, flags); 1005 1006 gs_debug("gs_chars_in_buffer: (%d,%p) chars=%d\n", 1007 port->port_num, tty, chars); 1008 1009 return chars; 1010} 1011 1012/* 1013 * gs_throttle 1014 */ 1015static void gs_throttle(struct tty_struct *tty) 1016{ 1017} 1018 1019/* 1020 * gs_unthrottle 1021 */ 1022static void gs_unthrottle(struct tty_struct *tty) 1023{ 1024} 1025 1026/* 1027 * gs_break 1028 */ 1029static void gs_break(struct tty_struct *tty, int break_state) 1030{ 1031} 1032 1033/* 1034 * gs_ioctl 1035 */ 1036static int gs_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg) 1037{ 1038 struct gs_port *port = tty->driver_data; 1039 1040 if (port == NULL) { 1041 printk(KERN_ERR "gs_ioctl: NULL port pointer\n"); 1042 return -EIO; 1043 } 1044 1045 gs_debug("gs_ioctl: (%d,%p,%p) cmd=0x%4.4x, arg=%lu\n", 1046 port->port_num, tty, file, cmd, arg); 1047 1048 /* handle ioctls */ 1049 1050 /* could not handle ioctl */ 1051 return -ENOIOCTLCMD; 1052} 1053 1054/* 1055 * gs_set_termios 1056 */ 1057static void gs_set_termios(struct tty_struct *tty, struct ktermios *old) 1058{ 1059} 1060 1061/* 1062* gs_send 1063* 1064* This function finds available write requests, calls 1065* gs_send_packet to fill these packets with data, and 1066* continues until either there are no more write requests 1067* available or no more data to send. This function is 1068* run whenever data arrives or write requests are available. 1069*/ 1070static int gs_send(struct gs_dev *dev) 1071{ 1072 int ret,len; 1073 unsigned long flags; 1074 struct usb_ep *ep; 1075 struct usb_request *req; 1076 struct gs_req_entry *req_entry; 1077 1078 if (dev == NULL) { 1079 printk(KERN_ERR "gs_send: NULL device pointer\n"); 1080 return -ENODEV; 1081 } 1082 1083 spin_lock_irqsave(&dev->dev_lock, flags); 1084 1085 ep = dev->dev_in_ep; 1086 1087 while(!list_empty(&dev->dev_req_list)) { 1088 1089 req_entry = list_entry(dev->dev_req_list.next, 1090 struct gs_req_entry, re_entry); 1091 1092 req = req_entry->re_req; 1093 1094 len = gs_send_packet(dev, req->buf, ep->maxpacket); 1095 1096 if (len > 0) { 1097 gs_debug_level(3, "gs_send: len=%d, 0x%2.2x " 1098 "0x%2.2x 0x%2.2x ...\n", len, 1099 *((unsigned char *)req->buf), 1100 *((unsigned char *)req->buf+1), 1101 *((unsigned char *)req->buf+2)); 1102 list_del(&req_entry->re_entry); 1103 req->length = len; 1104 spin_unlock_irqrestore(&dev->dev_lock, flags); 1105 if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) { 1106 printk(KERN_ERR 1107 "gs_send: cannot queue read request, ret=%d\n", 1108 ret); 1109 spin_lock_irqsave(&dev->dev_lock, flags); 1110 break; 1111 } 1112 spin_lock_irqsave(&dev->dev_lock, flags); 1113 } else { 1114 break; 1115 } 1116 1117 } 1118 1119 spin_unlock_irqrestore(&dev->dev_lock, flags); 1120 1121 return 0; 1122} 1123 1124/* 1125 * gs_send_packet 1126 * 1127 * If there is data to send, a packet is built in the given 1128 * buffer and the size is returned. If there is no data to 1129 * send, 0 is returned. If there is any error a negative 1130 * error number is returned. 1131 * 1132 * Called during USB completion routine, on interrupt time. 1133 * 1134 * We assume that disconnect will not happen until all completion 1135 * routines have completed, so we can assume that the dev_port 1136 * array does not change during the lifetime of this function. 1137 */ 1138static int gs_send_packet(struct gs_dev *dev, char *packet, unsigned int size) 1139{ 1140 unsigned int len; 1141 struct gs_port *port; 1142 1143 /* TEMPORARY -- only port 0 is supported right now */ 1144 port = dev->dev_port[0]; 1145 1146 if (port == NULL) { 1147 printk(KERN_ERR 1148 "gs_send_packet: port=%d, NULL port pointer\n", 1149 0); 1150 return -EIO; 1151 } 1152 1153 spin_lock(&port->port_lock); 1154 1155 len = gs_buf_data_avail(port->port_write_buf); 1156 if (len < size) 1157 size = len; 1158 1159 if (size == 0) 1160 goto exit; 1161 1162 size = gs_buf_get(port->port_write_buf, packet, size); 1163 1164 if (port->port_tty) 1165 wake_up_interruptible(&port->port_tty->write_wait); 1166 1167exit: 1168 spin_unlock(&port->port_lock); 1169 return size; 1170} 1171 1172/* 1173 * gs_recv_packet 1174 * 1175 * Called for each USB packet received. Reads the packet 1176 * header and stuffs the data in the appropriate tty buffer. 1177 * Returns 0 if successful, or a negative error number. 1178 * 1179 * Called during USB completion routine, on interrupt time. 1180 * 1181 * We assume that disconnect will not happen until all completion 1182 * routines have completed, so we can assume that the dev_port 1183 * array does not change during the lifetime of this function. 1184 */ 1185static int gs_recv_packet(struct gs_dev *dev, char *packet, unsigned int size) 1186{ 1187 unsigned int len; 1188 struct gs_port *port; 1189 int ret; 1190 struct tty_struct *tty; 1191 1192 /* TEMPORARY -- only port 0 is supported right now */ 1193 port = dev->dev_port[0]; 1194 1195 if (port == NULL) { 1196 printk(KERN_ERR "gs_recv_packet: port=%d, NULL port pointer\n", 1197 port->port_num); 1198 return -EIO; 1199 } 1200 1201 spin_lock(&port->port_lock); 1202 1203 if (port->port_open_count == 0) { 1204 printk(KERN_ERR "gs_recv_packet: port=%d, port is closed\n", 1205 port->port_num); 1206 ret = -EIO; 1207 goto exit; 1208 } 1209 1210 1211 tty = port->port_tty; 1212 1213 if (tty == NULL) { 1214 printk(KERN_ERR "gs_recv_packet: port=%d, NULL tty pointer\n", 1215 port->port_num); 1216 ret = -EIO; 1217 goto exit; 1218 } 1219 1220 if (port->port_tty->magic != TTY_MAGIC) { 1221 printk(KERN_ERR "gs_recv_packet: port=%d, bad tty magic\n", 1222 port->port_num); 1223 ret = -EIO; 1224 goto exit; 1225 } 1226 1227 len = tty_buffer_request_room(tty, size); 1228 if (len > 0) { 1229 tty_insert_flip_string(tty, packet, len); 1230 tty_flip_buffer_push(port->port_tty); 1231 wake_up_interruptible(&port->port_tty->read_wait); 1232 } 1233 ret = 0; 1234exit: 1235 spin_unlock(&port->port_lock); 1236 return ret; 1237} 1238 1239/* 1240* gs_read_complete 1241*/ 1242static void gs_read_complete(struct usb_ep *ep, struct usb_request *req) 1243{ 1244 int ret; 1245 struct gs_dev *dev = ep->driver_data; 1246 1247 if (dev == NULL) { 1248 printk(KERN_ERR "gs_read_complete: NULL device pointer\n"); 1249 return; 1250 } 1251 1252 switch(req->status) { 1253 case 0: 1254 /* normal completion */ 1255 gs_recv_packet(dev, req->buf, req->actual); 1256requeue: 1257 req->length = ep->maxpacket; 1258 if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) { 1259 printk(KERN_ERR 1260 "gs_read_complete: cannot queue read request, ret=%d\n", 1261 ret); 1262 } 1263 break; 1264 1265 case -ESHUTDOWN: 1266 /* disconnect */ 1267 gs_debug("gs_read_complete: shutdown\n"); 1268 gs_free_req(ep, req); 1269 break; 1270 1271 default: 1272 /* unexpected */ 1273 printk(KERN_ERR 1274 "gs_read_complete: unexpected status error, status=%d\n", 1275 req->status); 1276 goto requeue; 1277 break; 1278 } 1279} 1280 1281/* 1282* gs_write_complete 1283*/ 1284static void gs_write_complete(struct usb_ep *ep, struct usb_request *req) 1285{ 1286 struct gs_dev *dev = ep->driver_data; 1287 struct gs_req_entry *gs_req = req->context; 1288 1289 if (dev == NULL) { 1290 printk(KERN_ERR "gs_write_complete: NULL device pointer\n"); 1291 return; 1292 } 1293 1294 switch(req->status) { 1295 case 0: 1296 /* normal completion */ 1297requeue: 1298 if (gs_req == NULL) { 1299 printk(KERN_ERR 1300 "gs_write_complete: NULL request pointer\n"); 1301 return; 1302 } 1303 1304 spin_lock(&dev->dev_lock); 1305 list_add(&gs_req->re_entry, &dev->dev_req_list); 1306 spin_unlock(&dev->dev_lock); 1307 1308 gs_send(dev); 1309 1310 break; 1311 1312 case -ESHUTDOWN: 1313 /* disconnect */ 1314 gs_debug("gs_write_complete: shutdown\n"); 1315 gs_free_req(ep, req); 1316 break; 1317 1318 default: 1319 printk(KERN_ERR 1320 "gs_write_complete: unexpected status error, status=%d\n", 1321 req->status); 1322 goto requeue; 1323 break; 1324 } 1325} 1326 1327/* Gadget Driver */ 1328 1329/* 1330 * gs_bind 1331 * 1332 * Called on module load. Allocates and initializes the device 1333 * structure and a control request. 1334 */ 1335static int __init gs_bind(struct usb_gadget *gadget) 1336{ 1337 int ret; 1338 struct usb_ep *ep; 1339 struct gs_dev *dev; 1340 int gcnum; 1341 1342 /* Some controllers can't support CDC ACM: 1343 * - sh doesn't support multiple interfaces or configs; 1344 * - sa1100 doesn't have a third interrupt endpoint 1345 */ 1346 if (gadget_is_sh(gadget) || gadget_is_sa1100(gadget)) 1347 use_acm = 0; 1348 1349 gcnum = usb_gadget_controller_number(gadget); 1350 if (gcnum >= 0) 1351 gs_device_desc.bcdDevice = 1352 cpu_to_le16(GS_VERSION_NUM | gcnum); 1353 else { 1354 printk(KERN_WARNING "gs_bind: controller '%s' not recognized\n", 1355 gadget->name); 1356 /* unrecognized, but safe unless bulk is REALLY quirky */ 1357 gs_device_desc.bcdDevice = 1358 __constant_cpu_to_le16(GS_VERSION_NUM|0x0099); 1359 } 1360 1361 usb_ep_autoconfig_reset(gadget); 1362 1363 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_in_desc); 1364 if (!ep) 1365 goto autoconf_fail; 1366 EP_IN_NAME = ep->name; 1367 ep->driver_data = ep; /* claim the endpoint */ 1368 1369 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_out_desc); 1370 if (!ep) 1371 goto autoconf_fail; 1372 EP_OUT_NAME = ep->name; 1373 ep->driver_data = ep; /* claim the endpoint */ 1374 1375 if (use_acm) { 1376 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_notify_desc); 1377 if (!ep) { 1378 printk(KERN_ERR "gs_bind: cannot run ACM on %s\n", gadget->name); 1379 goto autoconf_fail; 1380 } 1381 gs_device_desc.idProduct = __constant_cpu_to_le16( 1382 GS_CDC_PRODUCT_ID), 1383 EP_NOTIFY_NAME = ep->name; 1384 ep->driver_data = ep; /* claim the endpoint */ 1385 } 1386 1387 gs_device_desc.bDeviceClass = use_acm 1388 ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC; 1389 gs_device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket; 1390 1391 if (gadget_is_dualspeed(gadget)) { 1392 gs_qualifier_desc.bDeviceClass = use_acm 1393 ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC; 1394 /* assume ep0 uses the same packet size for both speeds */ 1395 gs_qualifier_desc.bMaxPacketSize0 = 1396 gs_device_desc.bMaxPacketSize0; 1397 /* assume endpoints are dual-speed */ 1398 gs_highspeed_notify_desc.bEndpointAddress = 1399 gs_fullspeed_notify_desc.bEndpointAddress; 1400 gs_highspeed_in_desc.bEndpointAddress = 1401 gs_fullspeed_in_desc.bEndpointAddress; 1402 gs_highspeed_out_desc.bEndpointAddress = 1403 gs_fullspeed_out_desc.bEndpointAddress; 1404 } 1405 1406 usb_gadget_set_selfpowered(gadget); 1407 1408 if (gadget_is_otg(gadget)) { 1409 gs_otg_descriptor.bmAttributes |= USB_OTG_HNP, 1410 gs_bulk_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP; 1411 gs_acm_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP; 1412 } 1413 1414 gs_device = dev = kzalloc(sizeof(struct gs_dev), GFP_KERNEL); 1415 if (dev == NULL) 1416 return -ENOMEM; 1417 1418 snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s", 1419 init_utsname()->sysname, init_utsname()->release, 1420 gadget->name); 1421 1422 dev->dev_gadget = gadget; 1423 spin_lock_init(&dev->dev_lock); 1424 INIT_LIST_HEAD(&dev->dev_req_list); 1425 set_gadget_data(gadget, dev); 1426 1427 if ((ret=gs_alloc_ports(dev, GFP_KERNEL)) != 0) { 1428 printk(KERN_ERR "gs_bind: cannot allocate ports\n"); 1429 gs_unbind(gadget); 1430 return ret; 1431 } 1432 1433 /* preallocate control response and buffer */ 1434 dev->dev_ctrl_req = gs_alloc_req(gadget->ep0, GS_MAX_DESC_LEN, 1435 GFP_KERNEL); 1436 if (dev->dev_ctrl_req == NULL) { 1437 gs_unbind(gadget); 1438 return -ENOMEM; 1439 } 1440 dev->dev_ctrl_req->complete = gs_setup_complete; 1441 1442 gadget->ep0->driver_data = dev; 1443 1444 printk(KERN_INFO "gs_bind: %s %s bound\n", 1445 GS_LONG_NAME, GS_VERSION_STR); 1446 1447 return 0; 1448 1449autoconf_fail: 1450 printk(KERN_ERR "gs_bind: cannot autoconfigure on %s\n", gadget->name); 1451 return -ENODEV; 1452} 1453 1454/* 1455 * gs_unbind 1456 * 1457 * Called on module unload. Frees the control request and device 1458 * structure. 1459 */ 1460static void /* __init_or_exit */ gs_unbind(struct usb_gadget *gadget) 1461{ 1462 struct gs_dev *dev = get_gadget_data(gadget); 1463 1464 gs_device = NULL; 1465 1466 /* read/write requests already freed, only control request remains */ 1467 if (dev != NULL) { 1468 if (dev->dev_ctrl_req != NULL) { 1469 gs_free_req(gadget->ep0, dev->dev_ctrl_req); 1470 dev->dev_ctrl_req = NULL; 1471 } 1472 gs_free_ports(dev); 1473 if (dev->dev_notify_ep) 1474 usb_ep_disable(dev->dev_notify_ep); 1475 if (dev->dev_in_ep) 1476 usb_ep_disable(dev->dev_in_ep); 1477 if (dev->dev_out_ep) 1478 usb_ep_disable(dev->dev_out_ep); 1479 kfree(dev); 1480 set_gadget_data(gadget, NULL); 1481 } 1482 1483 printk(KERN_INFO "gs_unbind: %s %s unbound\n", GS_LONG_NAME, 1484 GS_VERSION_STR); 1485} 1486 1487/* 1488 * gs_setup 1489 * 1490 * Implements all the control endpoint functionality that's not 1491 * handled in hardware or the hardware driver. 1492 * 1493 * Returns the size of the data sent to the host, or a negative 1494 * error number. 1495 */ 1496static int gs_setup(struct usb_gadget *gadget, 1497 const struct usb_ctrlrequest *ctrl) 1498{ 1499 int ret = -EOPNOTSUPP; 1500 struct gs_dev *dev = get_gadget_data(gadget); 1501 struct usb_request *req = dev->dev_ctrl_req; 1502 u16 wIndex = le16_to_cpu(ctrl->wIndex); 1503 u16 wValue = le16_to_cpu(ctrl->wValue); 1504 u16 wLength = le16_to_cpu(ctrl->wLength); 1505 1506 switch (ctrl->bRequestType & USB_TYPE_MASK) { 1507 case USB_TYPE_STANDARD: 1508 ret = gs_setup_standard(gadget,ctrl); 1509 break; 1510 1511 case USB_TYPE_CLASS: 1512 ret = gs_setup_class(gadget,ctrl); 1513 break; 1514 1515 default: 1516 printk(KERN_ERR "gs_setup: unknown request, type=%02x, request=%02x, value=%04x, index=%04x, length=%d\n", 1517 ctrl->bRequestType, ctrl->bRequest, 1518 wValue, wIndex, wLength); 1519 break; 1520 } 1521 1522 /* respond with data transfer before status phase? */ 1523 if (ret >= 0) { 1524 req->length = ret; 1525 req->zero = ret < wLength 1526 && (ret % gadget->ep0->maxpacket) == 0; 1527 ret = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC); 1528 if (ret < 0) { 1529 printk(KERN_ERR "gs_setup: cannot queue response, ret=%d\n", 1530 ret); 1531 req->status = 0; 1532 gs_setup_complete(gadget->ep0, req); 1533 } 1534 } 1535 1536 /* device either stalls (ret < 0) or reports success */ 1537 return ret; 1538} 1539 1540static int gs_setup_standard(struct usb_gadget *gadget, 1541 const struct usb_ctrlrequest *ctrl) 1542{ 1543 int ret = -EOPNOTSUPP; 1544 struct gs_dev *dev = get_gadget_data(gadget); 1545 struct usb_request *req = dev->dev_ctrl_req; 1546 u16 wIndex = le16_to_cpu(ctrl->wIndex); 1547 u16 wValue = le16_to_cpu(ctrl->wValue); 1548 u16 wLength = le16_to_cpu(ctrl->wLength); 1549 1550 switch (ctrl->bRequest) { 1551 case USB_REQ_GET_DESCRIPTOR: 1552 if (ctrl->bRequestType != USB_DIR_IN) 1553 break; 1554 1555 switch (wValue >> 8) { 1556 case USB_DT_DEVICE: 1557 ret = min(wLength, 1558 (u16)sizeof(struct usb_device_descriptor)); 1559 memcpy(req->buf, &gs_device_desc, ret); 1560 break; 1561 1562 case USB_DT_DEVICE_QUALIFIER: 1563 if (!gadget_is_dualspeed(gadget)) 1564 break; 1565 ret = min(wLength, 1566 (u16)sizeof(struct usb_qualifier_descriptor)); 1567 memcpy(req->buf, &gs_qualifier_desc, ret); 1568 break; 1569 1570 case USB_DT_OTHER_SPEED_CONFIG: 1571 if (!gadget_is_dualspeed(gadget)) 1572 break; 1573 /* fall through */ 1574 case USB_DT_CONFIG: 1575 ret = gs_build_config_buf(req->buf, gadget, 1576 wValue >> 8, wValue & 0xff, 1577 gadget_is_otg(gadget)); 1578 if (ret >= 0) 1579 ret = min(wLength, (u16)ret); 1580 break; 1581 1582 case USB_DT_STRING: 1583 /* wIndex == language code. */ 1584 ret = usb_gadget_get_string(&gs_string_table, 1585 wValue & 0xff, req->buf); 1586 if (ret >= 0) 1587 ret = min(wLength, (u16)ret); 1588 break; 1589 } 1590 break; 1591 1592 case USB_REQ_SET_CONFIGURATION: 1593 if (ctrl->bRequestType != 0) 1594 break; 1595 spin_lock(&dev->dev_lock); 1596 ret = gs_set_config(dev, wValue); 1597 spin_unlock(&dev->dev_lock); 1598 break; 1599 1600 case USB_REQ_GET_CONFIGURATION: 1601 if (ctrl->bRequestType != USB_DIR_IN) 1602 break; 1603 *(u8 *)req->buf = dev->dev_config; 1604 ret = min(wLength, (u16)1); 1605 break; 1606 1607 case USB_REQ_SET_INTERFACE: 1608 if (ctrl->bRequestType != USB_RECIP_INTERFACE 1609 || !dev->dev_config 1610 || wIndex >= GS_MAX_NUM_INTERFACES) 1611 break; 1612 if (dev->dev_config == GS_BULK_CONFIG_ID 1613 && wIndex != GS_BULK_INTERFACE_ID) 1614 break; 1615 /* no alternate interface settings */ 1616 if (wValue != 0) 1617 break; 1618 spin_lock(&dev->dev_lock); 1619 /* PXA hardware partially handles SET_INTERFACE; 1620 * we need to kluge around that interference. */ 1621 if (gadget_is_pxa(gadget)) { 1622 ret = gs_set_config(dev, use_acm ? 1623 GS_ACM_CONFIG_ID : GS_BULK_CONFIG_ID); 1624 goto set_interface_done; 1625 } 1626 if (dev->dev_config != GS_BULK_CONFIG_ID 1627 && wIndex == GS_CONTROL_INTERFACE_ID) { 1628 if (dev->dev_notify_ep) { 1629 usb_ep_disable(dev->dev_notify_ep); 1630 usb_ep_enable(dev->dev_notify_ep, dev->dev_notify_ep_desc); 1631 } 1632 } else { 1633 usb_ep_disable(dev->dev_in_ep); 1634 usb_ep_disable(dev->dev_out_ep); 1635 usb_ep_enable(dev->dev_in_ep, dev->dev_in_ep_desc); 1636 usb_ep_enable(dev->dev_out_ep, dev->dev_out_ep_desc); 1637 } 1638 ret = 0; 1639set_interface_done: 1640 spin_unlock(&dev->dev_lock); 1641 break; 1642 1643 case USB_REQ_GET_INTERFACE: 1644 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE) 1645 || dev->dev_config == GS_NO_CONFIG_ID) 1646 break; 1647 if (wIndex >= GS_MAX_NUM_INTERFACES 1648 || (dev->dev_config == GS_BULK_CONFIG_ID 1649 && wIndex != GS_BULK_INTERFACE_ID)) { 1650 ret = -EDOM; 1651 break; 1652 } 1653 /* no alternate interface settings */ 1654 *(u8 *)req->buf = 0; 1655 ret = min(wLength, (u16)1); 1656 break; 1657 1658 default: 1659 printk(KERN_ERR "gs_setup: unknown standard request, type=%02x, request=%02x, value=%04x, index=%04x, length=%d\n", 1660 ctrl->bRequestType, ctrl->bRequest, 1661 wValue, wIndex, wLength); 1662 break; 1663 } 1664 1665 return ret; 1666} 1667 1668static int gs_setup_class(struct usb_gadget *gadget, 1669 const struct usb_ctrlrequest *ctrl) 1670{ 1671 int ret = -EOPNOTSUPP; 1672 struct gs_dev *dev = get_gadget_data(gadget); 1673 struct gs_port *port = dev->dev_port[0]; /* ACM only has one port */ 1674 struct usb_request *req = dev->dev_ctrl_req; 1675 u16 wIndex = le16_to_cpu(ctrl->wIndex); 1676 u16 wValue = le16_to_cpu(ctrl->wValue); 1677 u16 wLength = le16_to_cpu(ctrl->wLength); 1678 1679 switch (ctrl->bRequest) { 1680 case USB_CDC_REQ_SET_LINE_CODING: 1681 /* FIXME Submit req to read the data; have its completion 1682 * handler copy that data to port->port_line_coding (iff 1683 * it's valid) and maybe pass it on. Until then, fail. 1684 */ 1685 printk(KERN_WARNING "gs_setup: set_line_coding " 1686 "unuspported\n"); 1687 break; 1688 1689 case USB_CDC_REQ_GET_LINE_CODING: 1690 port = dev->dev_port[0]; /* ACM only has one port */ 1691 ret = min(wLength, 1692 (u16)sizeof(struct usb_cdc_line_coding)); 1693 if (port) { 1694 spin_lock(&port->port_lock); 1695 memcpy(req->buf, &port->port_line_coding, ret); 1696 spin_unlock(&port->port_lock); 1697 } 1698 break; 1699 1700 case USB_CDC_REQ_SET_CONTROL_LINE_STATE: 1701 /* FIXME Submit req to read the data; have its completion 1702 * handler use that to set the state (iff it's valid) and 1703 * maybe pass it on. Until then, fail. 1704 */ 1705 printk(KERN_WARNING "gs_setup: set_control_line_state " 1706 "unuspported\n"); 1707 break; 1708 1709 default: 1710 printk(KERN_ERR "gs_setup: unknown class request, " 1711 "type=%02x, request=%02x, value=%04x, " 1712 "index=%04x, length=%d\n", 1713 ctrl->bRequestType, ctrl->bRequest, 1714 wValue, wIndex, wLength); 1715 break; 1716 } 1717 1718 return ret; 1719} 1720 1721/* 1722 * gs_setup_complete 1723 */ 1724static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req) 1725{ 1726 if (req->status || req->actual != req->length) { 1727 printk(KERN_ERR "gs_setup_complete: status error, status=%d, actual=%d, length=%d\n", 1728 req->status, req->actual, req->length); 1729 } 1730} 1731 1732/* 1733 * gs_disconnect 1734 * 1735 * Called when the device is disconnected. Frees the closed 1736 * ports and disconnects open ports. Open ports will be freed 1737 * on close. Then reallocates the ports for the next connection. 1738 */ 1739static void gs_disconnect(struct usb_gadget *gadget) 1740{ 1741 unsigned long flags; 1742 struct gs_dev *dev = get_gadget_data(gadget); 1743 1744 spin_lock_irqsave(&dev->dev_lock, flags); 1745 1746 gs_reset_config(dev); 1747 1748 /* free closed ports and disconnect open ports */ 1749 /* (open ports will be freed when closed) */ 1750 gs_free_ports(dev); 1751 1752 /* re-allocate ports for the next connection */ 1753 if (gs_alloc_ports(dev, GFP_ATOMIC) != 0) 1754 printk(KERN_ERR "gs_disconnect: cannot re-allocate ports\n"); 1755 1756 spin_unlock_irqrestore(&dev->dev_lock, flags); 1757 1758 printk(KERN_INFO "gs_disconnect: %s disconnected\n", GS_LONG_NAME); 1759} 1760 1761/* 1762 * gs_set_config 1763 * 1764 * Configures the device by enabling device specific 1765 * optimizations, setting up the endpoints, allocating 1766 * read and write requests and queuing read requests. 1767 * 1768 * The device lock must be held when calling this function. 1769 */ 1770static int gs_set_config(struct gs_dev *dev, unsigned config) 1771{ 1772 int i; 1773 int ret = 0; 1774 struct usb_gadget *gadget = dev->dev_gadget; 1775 struct usb_ep *ep; 1776 struct usb_endpoint_descriptor *ep_desc; 1777 struct usb_request *req; 1778 struct gs_req_entry *req_entry; 1779 1780 if (dev == NULL) { 1781 printk(KERN_ERR "gs_set_config: NULL device pointer\n"); 1782 return 0; 1783 } 1784 1785 if (config == dev->dev_config) 1786 return 0; 1787 1788 gs_reset_config(dev); 1789 1790 switch (config) { 1791 case GS_NO_CONFIG_ID: 1792 return 0; 1793 case GS_BULK_CONFIG_ID: 1794 if (use_acm) 1795 return -EINVAL; 1796 /* device specific optimizations */ 1797 if (gadget_is_net2280(gadget)) 1798 net2280_set_fifo_mode(gadget, 1); 1799 break; 1800 case GS_ACM_CONFIG_ID: 1801 if (!use_acm) 1802 return -EINVAL; 1803 /* device specific optimizations */ 1804 if (gadget_is_net2280(gadget)) 1805 net2280_set_fifo_mode(gadget, 1); 1806 break; 1807 default: 1808 return -EINVAL; 1809 } 1810 1811 dev->dev_config = config; 1812 1813 gadget_for_each_ep(ep, gadget) { 1814 1815 if (EP_NOTIFY_NAME 1816 && strcmp(ep->name, EP_NOTIFY_NAME) == 0) { 1817 ep_desc = choose_ep_desc(gadget, 1818 &gs_highspeed_notify_desc, 1819 &gs_fullspeed_notify_desc); 1820 ret = usb_ep_enable(ep,ep_desc); 1821 if (ret == 0) { 1822 ep->driver_data = dev; 1823 dev->dev_notify_ep = ep; 1824 dev->dev_notify_ep_desc = ep_desc; 1825 } else { 1826 printk(KERN_ERR "gs_set_config: cannot enable notify endpoint %s, ret=%d\n", 1827 ep->name, ret); 1828 goto exit_reset_config; 1829 } 1830 } 1831 1832 else if (strcmp(ep->name, EP_IN_NAME) == 0) { 1833 ep_desc = choose_ep_desc(gadget, 1834 &gs_highspeed_in_desc, 1835 &gs_fullspeed_in_desc); 1836 ret = usb_ep_enable(ep,ep_desc); 1837 if (ret == 0) { 1838 ep->driver_data = dev; 1839 dev->dev_in_ep = ep; 1840 dev->dev_in_ep_desc = ep_desc; 1841 } else { 1842 printk(KERN_ERR "gs_set_config: cannot enable in endpoint %s, ret=%d\n", 1843 ep->name, ret); 1844 goto exit_reset_config; 1845 } 1846 } 1847 1848 else if (strcmp(ep->name, EP_OUT_NAME) == 0) { 1849 ep_desc = choose_ep_desc(gadget, 1850 &gs_highspeed_out_desc, 1851 &gs_fullspeed_out_desc); 1852 ret = usb_ep_enable(ep,ep_desc); 1853 if (ret == 0) { 1854 ep->driver_data = dev; 1855 dev->dev_out_ep = ep; 1856 dev->dev_out_ep_desc = ep_desc; 1857 } else { 1858 printk(KERN_ERR "gs_set_config: cannot enable out endpoint %s, ret=%d\n", 1859 ep->name, ret); 1860 goto exit_reset_config; 1861 } 1862 } 1863 1864 } 1865 1866 if (dev->dev_in_ep == NULL || dev->dev_out_ep == NULL 1867 || (config != GS_BULK_CONFIG_ID && dev->dev_notify_ep == NULL)) { 1868 printk(KERN_ERR "gs_set_config: cannot find endpoints\n"); 1869 ret = -ENODEV; 1870 goto exit_reset_config; 1871 } 1872 1873 /* allocate and queue read requests */ 1874 ep = dev->dev_out_ep; 1875 for (i=0; i<read_q_size && ret == 0; i++) { 1876 if ((req=gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC))) { 1877 req->complete = gs_read_complete; 1878 if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) { 1879 printk(KERN_ERR "gs_set_config: cannot queue read request, ret=%d\n", 1880 ret); 1881 } 1882 } else { 1883 printk(KERN_ERR "gs_set_config: cannot allocate read requests\n"); 1884 ret = -ENOMEM; 1885 goto exit_reset_config; 1886 } 1887 } 1888 1889 /* allocate write requests, and put on free list */ 1890 ep = dev->dev_in_ep; 1891 for (i=0; i<write_q_size; i++) { 1892 if ((req_entry=gs_alloc_req_entry(ep, ep->maxpacket, GFP_ATOMIC))) { 1893 req_entry->re_req->complete = gs_write_complete; 1894 list_add(&req_entry->re_entry, &dev->dev_req_list); 1895 } else { 1896 printk(KERN_ERR "gs_set_config: cannot allocate write requests\n"); 1897 ret = -ENOMEM; 1898 goto exit_reset_config; 1899 } 1900 } 1901 1902 printk(KERN_INFO "gs_set_config: %s configured, %s speed %s config\n", 1903 GS_LONG_NAME, 1904 gadget->speed == USB_SPEED_HIGH ? "high" : "full", 1905 config == GS_BULK_CONFIG_ID ? "BULK" : "CDC-ACM"); 1906 1907 return 0; 1908 1909exit_reset_config: 1910 gs_reset_config(dev); 1911 return ret; 1912} 1913 1914/* 1915 * gs_reset_config 1916 * 1917 * Mark the device as not configured, disable all endpoints, 1918 * which forces completion of pending I/O and frees queued 1919 * requests, and free the remaining write requests on the 1920 * free list. 1921 * 1922 * The device lock must be held when calling this function. 1923 */ 1924static void gs_reset_config(struct gs_dev *dev) 1925{ 1926 struct gs_req_entry *req_entry; 1927 1928 if (dev == NULL) { 1929 printk(KERN_ERR "gs_reset_config: NULL device pointer\n"); 1930 return; 1931 } 1932 1933 if (dev->dev_config == GS_NO_CONFIG_ID) 1934 return; 1935 1936 dev->dev_config = GS_NO_CONFIG_ID; 1937 1938 /* free write requests on the free list */ 1939 while(!list_empty(&dev->dev_req_list)) { 1940 req_entry = list_entry(dev->dev_req_list.next, 1941 struct gs_req_entry, re_entry); 1942 list_del(&req_entry->re_entry); 1943 gs_free_req_entry(dev->dev_in_ep, req_entry); 1944 } 1945 1946 /* disable endpoints, forcing completion of pending i/o; */ 1947 /* completion handlers free their requests in this case */ 1948 if (dev->dev_notify_ep) { 1949 usb_ep_disable(dev->dev_notify_ep); 1950 dev->dev_notify_ep = NULL; 1951 } 1952 if (dev->dev_in_ep) { 1953 usb_ep_disable(dev->dev_in_ep); 1954 dev->dev_in_ep = NULL; 1955 } 1956 if (dev->dev_out_ep) { 1957 usb_ep_disable(dev->dev_out_ep); 1958 dev->dev_out_ep = NULL; 1959 } 1960} 1961 1962/* 1963 * gs_build_config_buf 1964 * 1965 * Builds the config descriptors in the given buffer and returns the 1966 * length, or a negative error number. 1967 */ 1968static int gs_build_config_buf(u8 *buf, struct usb_gadget *g, 1969 u8 type, unsigned int index, int is_otg) 1970{ 1971 int len; 1972 int high_speed = 0; 1973 const struct usb_config_descriptor *config_desc; 1974 const struct usb_descriptor_header **function; 1975 1976 if (index >= gs_device_desc.bNumConfigurations) 1977 return -EINVAL; 1978 1979 /* other speed switches high and full speed */ 1980 if (gadget_is_dualspeed(g)) { 1981 high_speed = (g->speed == USB_SPEED_HIGH); 1982 if (type == USB_DT_OTHER_SPEED_CONFIG) 1983 high_speed = !high_speed; 1984 } 1985 1986 if (use_acm) { 1987 config_desc = &gs_acm_config_desc; 1988 function = high_speed 1989 ? gs_acm_highspeed_function 1990 : gs_acm_fullspeed_function; 1991 } else { 1992 config_desc = &gs_bulk_config_desc; 1993 function = high_speed 1994 ? gs_bulk_highspeed_function 1995 : gs_bulk_fullspeed_function; 1996 } 1997 1998 /* for now, don't advertise srp-only devices */ 1999 if (!is_otg) 2000 function++; 2001 2002 len = usb_gadget_config_buf(config_desc, buf, GS_MAX_DESC_LEN, function); 2003 if (len < 0) 2004 return len; 2005 2006 ((struct usb_config_descriptor *)buf)->bDescriptorType = type; 2007 2008 return len; 2009} 2010 2011/* 2012 * gs_alloc_req 2013 * 2014 * Allocate a usb_request and its buffer. Returns a pointer to the 2015 * usb_request or NULL if there is an error. 2016 */ 2017static struct usb_request * 2018gs_alloc_req(struct usb_ep *ep, unsigned int len, gfp_t kmalloc_flags) 2019{ 2020 struct usb_request *req; 2021 2022 if (ep == NULL) 2023 return NULL; 2024 2025 req = usb_ep_alloc_request(ep, kmalloc_flags); 2026 2027 if (req != NULL) { 2028 req->length = len; 2029 req->buf = kmalloc(len, kmalloc_flags); 2030 if (req->buf == NULL) { 2031 usb_ep_free_request(ep, req); 2032 return NULL; 2033 } 2034 } 2035 2036 return req; 2037} 2038 2039/* 2040 * gs_free_req 2041 * 2042 * Free a usb_request and its buffer. 2043 */ 2044static void gs_free_req(struct usb_ep *ep, struct usb_request *req) 2045{ 2046 if (ep != NULL && req != NULL) { 2047 kfree(req->buf); 2048 usb_ep_free_request(ep, req); 2049 } 2050} 2051 2052/* 2053 * gs_alloc_req_entry 2054 * 2055 * Allocates a request and its buffer, using the given 2056 * endpoint, buffer len, and kmalloc flags. 2057 */ 2058static struct gs_req_entry * 2059gs_alloc_req_entry(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags) 2060{ 2061 struct gs_req_entry *req; 2062 2063 req = kmalloc(sizeof(struct gs_req_entry), kmalloc_flags); 2064 if (req == NULL) 2065 return NULL; 2066 2067 req->re_req = gs_alloc_req(ep, len, kmalloc_flags); 2068 if (req->re_req == NULL) { 2069 kfree(req); 2070 return NULL; 2071 } 2072 2073 req->re_req->context = req; 2074 2075 return req; 2076} 2077 2078/* 2079 * gs_free_req_entry 2080 * 2081 * Frees a request and its buffer. 2082 */ 2083static void gs_free_req_entry(struct usb_ep *ep, struct gs_req_entry *req) 2084{ 2085 if (ep != NULL && req != NULL) { 2086 if (req->re_req != NULL) 2087 gs_free_req(ep, req->re_req); 2088 kfree(req); 2089 } 2090} 2091 2092/* 2093 * gs_alloc_ports 2094 * 2095 * Allocate all ports and set the gs_dev struct to point to them. 2096 * Return 0 if successful, or a negative error number. 2097 * 2098 * The device lock is normally held when calling this function. 2099 */ 2100static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags) 2101{ 2102 int i; 2103 struct gs_port *port; 2104 2105 if (dev == NULL) 2106 return -EIO; 2107 2108 for (i=0; i<GS_NUM_PORTS; i++) { 2109 if ((port=kzalloc(sizeof(struct gs_port), kmalloc_flags)) == NULL) 2110 return -ENOMEM; 2111 2112 port->port_dev = dev; 2113 port->port_num = i; 2114 port->port_line_coding.dwDTERate = cpu_to_le32(GS_DEFAULT_DTE_RATE); 2115 port->port_line_coding.bCharFormat = GS_DEFAULT_CHAR_FORMAT; 2116 port->port_line_coding.bParityType = GS_DEFAULT_PARITY; 2117 port->port_line_coding.bDataBits = GS_DEFAULT_DATA_BITS; 2118 spin_lock_init(&port->port_lock); 2119 init_waitqueue_head(&port->port_write_wait); 2120 2121 dev->dev_port[i] = port; 2122 } 2123 2124 return 0; 2125} 2126 2127/* 2128 * gs_free_ports 2129 * 2130 * Free all closed ports. Open ports are disconnected by 2131 * freeing their write buffers, setting their device pointers 2132 * and the pointers to them in the device to NULL. These 2133 * ports will be freed when closed. 2134 * 2135 * The device lock is normally held when calling this function. 2136 */ 2137static void gs_free_ports(struct gs_dev *dev) 2138{ 2139 int i; 2140 unsigned long flags; 2141 struct gs_port *port; 2142 2143 if (dev == NULL) 2144 return; 2145 2146 for (i=0; i<GS_NUM_PORTS; i++) { 2147 if ((port=dev->dev_port[i]) != NULL) { 2148 dev->dev_port[i] = NULL; 2149 2150 spin_lock_irqsave(&port->port_lock, flags); 2151 2152 if (port->port_write_buf != NULL) { 2153 gs_buf_free(port->port_write_buf); 2154 port->port_write_buf = NULL; 2155 } 2156 2157 if (port->port_open_count > 0 || port->port_in_use) { 2158 port->port_dev = NULL; 2159 wake_up_interruptible(&port->port_write_wait); 2160 if (port->port_tty) { 2161 wake_up_interruptible(&port->port_tty->read_wait); 2162 wake_up_interruptible(&port->port_tty->write_wait); 2163 } 2164 spin_unlock_irqrestore(&port->port_lock, flags); 2165 } else { 2166 spin_unlock_irqrestore(&port->port_lock, flags); 2167 kfree(port); 2168 } 2169 2170 } 2171 } 2172} 2173 2174/* Circular Buffer */ 2175 2176/* 2177 * gs_buf_alloc 2178 * 2179 * Allocate a circular buffer and all associated memory. 2180 */ 2181static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags) 2182{ 2183 struct gs_buf *gb; 2184 2185 if (size == 0) 2186 return NULL; 2187 2188 gb = kmalloc(sizeof(struct gs_buf), kmalloc_flags); 2189 if (gb == NULL) 2190 return NULL; 2191 2192 gb->buf_buf = kmalloc(size, kmalloc_flags); 2193 if (gb->buf_buf == NULL) { 2194 kfree(gb); 2195 return NULL; 2196 } 2197 2198 gb->buf_size = size; 2199 gb->buf_get = gb->buf_put = gb->buf_buf; 2200 2201 return gb; 2202} 2203 2204/* 2205 * gs_buf_free 2206 * 2207 * Free the buffer and all associated memory. 2208 */ 2209static void gs_buf_free(struct gs_buf *gb) 2210{ 2211 if (gb) { 2212 kfree(gb->buf_buf); 2213 kfree(gb); 2214 } 2215} 2216 2217/* 2218 * gs_buf_clear 2219 * 2220 * Clear out all data in the circular buffer. 2221 */ 2222static void gs_buf_clear(struct gs_buf *gb) 2223{ 2224 if (gb != NULL) 2225 gb->buf_get = gb->buf_put; 2226 /* equivalent to a get of all data available */ 2227} 2228 2229/* 2230 * gs_buf_data_avail 2231 * 2232 * Return the number of bytes of data available in the circular 2233 * buffer. 2234 */ 2235static unsigned int gs_buf_data_avail(struct gs_buf *gb) 2236{ 2237 if (gb != NULL) 2238 return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size; 2239 else 2240 return 0; 2241} 2242 2243/* 2244 * gs_buf_space_avail 2245 * 2246 * Return the number of bytes of space available in the circular 2247 * buffer. 2248 */ 2249static unsigned int gs_buf_space_avail(struct gs_buf *gb) 2250{ 2251 if (gb != NULL) 2252 return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size; 2253 else 2254 return 0; 2255} 2256 2257/* 2258 * gs_buf_put 2259 * 2260 * Copy data data from a user buffer and put it into the circular buffer. 2261 * Restrict to the amount of space available. 2262 * 2263 * Return the number of bytes copied. 2264 */ 2265static unsigned int 2266gs_buf_put(struct gs_buf *gb, const char *buf, unsigned int count) 2267{ 2268 unsigned int len; 2269 2270 if (gb == NULL) 2271 return 0; 2272 2273 len = gs_buf_space_avail(gb); 2274 if (count > len) 2275 count = len; 2276 2277 if (count == 0) 2278 return 0; 2279 2280 len = gb->buf_buf + gb->buf_size - gb->buf_put; 2281 if (count > len) { 2282 memcpy(gb->buf_put, buf, len); 2283 memcpy(gb->buf_buf, buf+len, count - len); 2284 gb->buf_put = gb->buf_buf + count - len; 2285 } else { 2286 memcpy(gb->buf_put, buf, count); 2287 if (count < len) 2288 gb->buf_put += count; 2289 else /* count == len */ 2290 gb->buf_put = gb->buf_buf; 2291 } 2292 2293 return count; 2294} 2295 2296/* 2297 * gs_buf_get 2298 * 2299 * Get data from the circular buffer and copy to the given buffer. 2300 * Restrict to the amount of data available. 2301 * 2302 * Return the number of bytes copied. 2303 */ 2304static unsigned int 2305gs_buf_get(struct gs_buf *gb, char *buf, unsigned int count) 2306{ 2307 unsigned int len; 2308 2309 if (gb == NULL) 2310 return 0; 2311 2312 len = gs_buf_data_avail(gb); 2313 if (count > len) 2314 count = len; 2315 2316 if (count == 0) 2317 return 0; 2318 2319 len = gb->buf_buf + gb->buf_size - gb->buf_get; 2320 if (count > len) { 2321 memcpy(buf, gb->buf_get, len); 2322 memcpy(buf+len, gb->buf_buf, count - len); 2323 gb->buf_get = gb->buf_buf + count - len; 2324 } else { 2325 memcpy(buf, gb->buf_get, count); 2326 if (count < len) 2327 gb->buf_get += count; 2328 else /* count == len */ 2329 gb->buf_get = gb->buf_buf; 2330 } 2331 2332 return count; 2333} 2334