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