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