option.c revision 02b2ac5b0370b1157a5a99f2fdf006644b9b86d5
1/* 2 USB Driver for GSM modems 3 4 Copyright (C) 2005 Matthias Urlichs <smurf@smurf.noris.de> 5 6 This driver is free software; you can redistribute it and/or modify 7 it under the terms of Version 2 of the GNU General Public License as 8 published by the Free Software Foundation. 9 10 Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org> 11 12 History: see the git log. 13 14 Work sponsored by: Sigos GmbH, Germany <info@sigos.de> 15 16 This driver exists because the "normal" serial driver doesn't work too well 17 with GSM modems. Issues: 18 - data loss -- one single Receive URB is not nearly enough 19 - nonstandard flow (Option devices) and multiplex (Sierra) control 20 - controlling the baud rate doesn't make sense 21 22 This driver is named "option" because the most common device it's 23 used for is a PC-Card (with an internal OHCI-USB interface, behind 24 which the GSM interface sits), made by Option Inc. 25 26 Some of the "one port" devices actually exhibit multiple USB instances 27 on the USB bus. This is not a bug, these ports are used for different 28 device features. 29*/ 30 31#define DRIVER_VERSION "v0.7.1" 32#define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>" 33#define DRIVER_DESC "USB Driver for GSM modems" 34 35#include <linux/kernel.h> 36#include <linux/jiffies.h> 37#include <linux/errno.h> 38#include <linux/tty.h> 39#include <linux/tty_flip.h> 40#include <linux/module.h> 41#include <linux/usb.h> 42#include <linux/usb/serial.h> 43 44/* Function prototypes */ 45static int option_open(struct usb_serial_port *port, struct file *filp); 46static void option_close(struct usb_serial_port *port, struct file *filp); 47static int option_startup(struct usb_serial *serial); 48static void option_shutdown(struct usb_serial *serial); 49static void option_rx_throttle(struct usb_serial_port *port); 50static void option_rx_unthrottle(struct usb_serial_port *port); 51static int option_write_room(struct usb_serial_port *port); 52 53static void option_instat_callback(struct urb *urb, struct pt_regs *regs); 54 55static int option_write(struct usb_serial_port *port, 56 const unsigned char *buf, int count); 57 58static int option_chars_in_buffer(struct usb_serial_port *port); 59static int option_ioctl(struct usb_serial_port *port, struct file *file, 60 unsigned int cmd, unsigned long arg); 61static void option_set_termios(struct usb_serial_port *port, 62 struct termios *old); 63static void option_break_ctl(struct usb_serial_port *port, int break_state); 64static int option_tiocmget(struct usb_serial_port *port, struct file *file); 65static int option_tiocmset(struct usb_serial_port *port, struct file *file, 66 unsigned int set, unsigned int clear); 67static int option_send_setup(struct usb_serial_port *port); 68 69/* Vendor and product IDs */ 70#define OPTION_VENDOR_ID 0x0AF0 71#define HUAWEI_VENDOR_ID 0x12D1 72#define AUDIOVOX_VENDOR_ID 0x0F3D 73#define SIERRAWIRELESS_VENDOR_ID 0x1199 74#define NOVATELWIRELESS_VENDOR_ID 0x1410 75 76#define OPTION_PRODUCT_OLD 0x5000 77#define OPTION_PRODUCT_FUSION 0x6000 78#define OPTION_PRODUCT_FUSION2 0x6300 79#define OPTION_PRODUCT_COBRA 0x6500 80#define OPTION_PRODUCT_COBRA2 0x6600 81#define HUAWEI_PRODUCT_E600 0x1001 82#define AUDIOVOX_PRODUCT_AIRCARD 0x0112 83#define SIERRAWIRELESS_PRODUCT_MC8755 0x6802 84#define NOVATELWIRELESS_PRODUCT_U740 0x1400 85 86static struct usb_device_id option_ids[] = { 87 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) }, 88 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) }, 89 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) }, 90 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) }, 91 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA2) }, 92 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) }, 93 { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) }, 94 { USB_DEVICE(SIERRAWIRELESS_VENDOR_ID, SIERRAWIRELESS_PRODUCT_MC8755) }, 95 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) }, 96 { } /* Terminating entry */ 97}; 98 99static struct usb_device_id option_ids1[] = { 100 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) }, 101 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) }, 102 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION2) }, 103 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA) }, 104 { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COBRA2) }, 105 { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E600) }, 106 { USB_DEVICE(AUDIOVOX_VENDOR_ID, AUDIOVOX_PRODUCT_AIRCARD) }, 107 { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID,NOVATELWIRELESS_PRODUCT_U740) }, 108 { } /* Terminating entry */ 109}; 110static struct usb_device_id option_ids3[] = { 111 { USB_DEVICE(SIERRAWIRELESS_VENDOR_ID, SIERRAWIRELESS_PRODUCT_MC8755) }, 112 { } /* Terminating entry */ 113}; 114 115MODULE_DEVICE_TABLE(usb, option_ids); 116 117static struct usb_driver option_driver = { 118 .name = "option", 119 .probe = usb_serial_probe, 120 .disconnect = usb_serial_disconnect, 121 .id_table = option_ids, 122 .no_dynamic_id = 1, 123}; 124 125/* The card has three separate interfaces, which the serial driver 126 * recognizes separately, thus num_port=1. 127 */ 128static struct usb_serial_driver option_3port_device = { 129 .driver = { 130 .owner = THIS_MODULE, 131 .name = "option3", 132 }, 133 .description = "GSM modem (3-port)", 134 .id_table = option_ids3, 135 .num_interrupt_in = NUM_DONT_CARE, 136 .num_bulk_in = NUM_DONT_CARE, 137 .num_bulk_out = NUM_DONT_CARE, 138 .num_ports = 3, 139 .open = option_open, 140 .close = option_close, 141 .write = option_write, 142 .write_room = option_write_room, 143 .chars_in_buffer = option_chars_in_buffer, 144 .throttle = option_rx_throttle, 145 .unthrottle = option_rx_unthrottle, 146 .ioctl = option_ioctl, 147 .set_termios = option_set_termios, 148 .break_ctl = option_break_ctl, 149 .tiocmget = option_tiocmget, 150 .tiocmset = option_tiocmset, 151 .attach = option_startup, 152 .shutdown = option_shutdown, 153 .read_int_callback = option_instat_callback, 154}; 155 156static struct usb_serial_driver option_1port_device = { 157 .driver = { 158 .owner = THIS_MODULE, 159 .name = "option1", 160 }, 161 .description = "GSM modem (1-port)", 162 .id_table = option_ids1, 163 .num_interrupt_in = NUM_DONT_CARE, 164 .num_bulk_in = NUM_DONT_CARE, 165 .num_bulk_out = NUM_DONT_CARE, 166 .num_ports = 1, 167 .open = option_open, 168 .close = option_close, 169 .write = option_write, 170 .write_room = option_write_room, 171 .chars_in_buffer = option_chars_in_buffer, 172 .throttle = option_rx_throttle, 173 .unthrottle = option_rx_unthrottle, 174 .ioctl = option_ioctl, 175 .set_termios = option_set_termios, 176 .break_ctl = option_break_ctl, 177 .tiocmget = option_tiocmget, 178 .tiocmset = option_tiocmset, 179 .attach = option_startup, 180 .shutdown = option_shutdown, 181 .read_int_callback = option_instat_callback, 182}; 183 184#ifdef CONFIG_USB_DEBUG 185static int debug; 186#else 187#define debug 0 188#endif 189 190/* per port private data */ 191 192#define N_IN_URB 4 193#define N_OUT_URB 1 194#define IN_BUFLEN 4096 195#define OUT_BUFLEN 128 196 197struct option_port_private { 198 /* Input endpoints and buffer for this port */ 199 struct urb *in_urbs[N_IN_URB]; 200 char in_buffer[N_IN_URB][IN_BUFLEN]; 201 /* Output endpoints and buffer for this port */ 202 struct urb *out_urbs[N_OUT_URB]; 203 char out_buffer[N_OUT_URB][OUT_BUFLEN]; 204 205 /* Settings for the port */ 206 int rts_state; /* Handshaking pins (outputs) */ 207 int dtr_state; 208 int cts_state; /* Handshaking pins (inputs) */ 209 int dsr_state; 210 int dcd_state; 211 int ri_state; 212 213 unsigned long tx_start_time[N_OUT_URB]; 214}; 215 216/* Functions used by new usb-serial code. */ 217static int __init option_init(void) 218{ 219 int retval; 220 retval = usb_serial_register(&option_1port_device); 221 if (retval) 222 goto failed_1port_device_register; 223 retval = usb_serial_register(&option_3port_device); 224 if (retval) 225 goto failed_3port_device_register; 226 retval = usb_register(&option_driver); 227 if (retval) 228 goto failed_driver_register; 229 230 info(DRIVER_DESC ": " DRIVER_VERSION); 231 232 return 0; 233 234failed_driver_register: 235 usb_serial_deregister (&option_3port_device); 236failed_3port_device_register: 237 usb_serial_deregister (&option_1port_device); 238failed_1port_device_register: 239 return retval; 240} 241 242static void __exit option_exit(void) 243{ 244 usb_deregister (&option_driver); 245 usb_serial_deregister (&option_3port_device); 246 usb_serial_deregister (&option_1port_device); 247} 248 249module_init(option_init); 250module_exit(option_exit); 251 252static void option_rx_throttle(struct usb_serial_port *port) 253{ 254 dbg("%s", __FUNCTION__); 255} 256 257static void option_rx_unthrottle(struct usb_serial_port *port) 258{ 259 dbg("%s", __FUNCTION__); 260} 261 262static void option_break_ctl(struct usb_serial_port *port, int break_state) 263{ 264 /* Unfortunately, I don't know how to send a break */ 265 dbg("%s", __FUNCTION__); 266} 267 268static void option_set_termios(struct usb_serial_port *port, 269 struct termios *old_termios) 270{ 271 dbg("%s", __FUNCTION__); 272 273 option_send_setup(port); 274} 275 276static int option_tiocmget(struct usb_serial_port *port, struct file *file) 277{ 278 unsigned int value; 279 struct option_port_private *portdata; 280 281 portdata = usb_get_serial_port_data(port); 282 283 value = ((portdata->rts_state) ? TIOCM_RTS : 0) | 284 ((portdata->dtr_state) ? TIOCM_DTR : 0) | 285 ((portdata->cts_state) ? TIOCM_CTS : 0) | 286 ((portdata->dsr_state) ? TIOCM_DSR : 0) | 287 ((portdata->dcd_state) ? TIOCM_CAR : 0) | 288 ((portdata->ri_state) ? TIOCM_RNG : 0); 289 290 return value; 291} 292 293static int option_tiocmset(struct usb_serial_port *port, struct file *file, 294 unsigned int set, unsigned int clear) 295{ 296 struct option_port_private *portdata; 297 298 portdata = usb_get_serial_port_data(port); 299 300 if (set & TIOCM_RTS) 301 portdata->rts_state = 1; 302 if (set & TIOCM_DTR) 303 portdata->dtr_state = 1; 304 305 if (clear & TIOCM_RTS) 306 portdata->rts_state = 0; 307 if (clear & TIOCM_DTR) 308 portdata->dtr_state = 0; 309 return option_send_setup(port); 310} 311 312static int option_ioctl(struct usb_serial_port *port, struct file *file, 313 unsigned int cmd, unsigned long arg) 314{ 315 return -ENOIOCTLCMD; 316} 317 318/* Write */ 319static int option_write(struct usb_serial_port *port, 320 const unsigned char *buf, int count) 321{ 322 struct option_port_private *portdata; 323 int i; 324 int left, todo; 325 struct urb *this_urb = NULL; /* spurious */ 326 int err; 327 328 portdata = usb_get_serial_port_data(port); 329 330 dbg("%s: write (%d chars)", __FUNCTION__, count); 331 332 i = 0; 333 left = count; 334 for (i=0; left > 0 && i < N_OUT_URB; i++) { 335 todo = left; 336 if (todo > OUT_BUFLEN) 337 todo = OUT_BUFLEN; 338 339 this_urb = portdata->out_urbs[i]; 340 if (this_urb->status == -EINPROGRESS) { 341 if (time_before(jiffies, 342 portdata->tx_start_time[i] + 10 * HZ)) 343 continue; 344 usb_unlink_urb(this_urb); 345 continue; 346 } 347 if (this_urb->status != 0) 348 dbg("usb_write %p failed (err=%d)", 349 this_urb, this_urb->status); 350 351 dbg("%s: endpoint %d buf %d", __FUNCTION__, 352 usb_pipeendpoint(this_urb->pipe), i); 353 354 /* send the data */ 355 memcpy (this_urb->transfer_buffer, buf, todo); 356 this_urb->transfer_buffer_length = todo; 357 358 this_urb->dev = port->serial->dev; 359 err = usb_submit_urb(this_urb, GFP_ATOMIC); 360 if (err) { 361 dbg("usb_submit_urb %p (write bulk) failed " 362 "(%d, has %d)", this_urb, 363 err, this_urb->status); 364 continue; 365 } 366 portdata->tx_start_time[i] = jiffies; 367 buf += todo; 368 left -= todo; 369 } 370 371 count -= left; 372 dbg("%s: wrote (did %d)", __FUNCTION__, count); 373 return count; 374} 375 376static void option_indat_callback(struct urb *urb, struct pt_regs *regs) 377{ 378 int err; 379 int endpoint; 380 struct usb_serial_port *port; 381 struct tty_struct *tty; 382 unsigned char *data = urb->transfer_buffer; 383 384 dbg("%s: %p", __FUNCTION__, urb); 385 386 endpoint = usb_pipeendpoint(urb->pipe); 387 port = (struct usb_serial_port *) urb->context; 388 389 if (urb->status) { 390 dbg("%s: nonzero status: %d on endpoint %02x.", 391 __FUNCTION__, urb->status, endpoint); 392 } else { 393 tty = port->tty; 394 if (urb->actual_length) { 395 tty_buffer_request_room(tty, urb->actual_length); 396 tty_insert_flip_string(tty, data, urb->actual_length); 397 tty_flip_buffer_push(tty); 398 } else { 399 dbg("%s: empty read urb received", __FUNCTION__); 400 } 401 402 /* Resubmit urb so we continue receiving */ 403 if (port->open_count && urb->status != -ESHUTDOWN) { 404 err = usb_submit_urb(urb, GFP_ATOMIC); 405 if (err) 406 printk(KERN_ERR "%s: resubmit read urb failed. " 407 "(%d)", __FUNCTION__, err); 408 } 409 } 410 return; 411} 412 413static void option_outdat_callback(struct urb *urb, struct pt_regs *regs) 414{ 415 struct usb_serial_port *port; 416 417 dbg("%s", __FUNCTION__); 418 419 port = (struct usb_serial_port *) urb->context; 420 421 usb_serial_port_softint(port); 422} 423 424static void option_instat_callback(struct urb *urb, struct pt_regs *regs) 425{ 426 int err; 427 struct usb_serial_port *port = (struct usb_serial_port *) urb->context; 428 struct option_port_private *portdata = usb_get_serial_port_data(port); 429 struct usb_serial *serial = port->serial; 430 431 dbg("%s", __FUNCTION__); 432 dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata); 433 434 if (urb->status == 0) { 435 struct usb_ctrlrequest *req_pkt = 436 (struct usb_ctrlrequest *)urb->transfer_buffer; 437 438 if (!req_pkt) { 439 dbg("%s: NULL req_pkt\n", __FUNCTION__); 440 return; 441 } 442 if ((req_pkt->bRequestType == 0xA1) && 443 (req_pkt->bRequest == 0x20)) { 444 int old_dcd_state; 445 unsigned char signals = *((unsigned char *) 446 urb->transfer_buffer + 447 sizeof(struct usb_ctrlrequest)); 448 449 dbg("%s: signal x%x", __FUNCTION__, signals); 450 451 old_dcd_state = portdata->dcd_state; 452 portdata->cts_state = 1; 453 portdata->dcd_state = ((signals & 0x01) ? 1 : 0); 454 portdata->dsr_state = ((signals & 0x02) ? 1 : 0); 455 portdata->ri_state = ((signals & 0x08) ? 1 : 0); 456 457 if (port->tty && !C_CLOCAL(port->tty) && 458 old_dcd_state && !portdata->dcd_state) 459 tty_hangup(port->tty); 460 } else { 461 dbg("%s: type %x req %x", __FUNCTION__, 462 req_pkt->bRequestType,req_pkt->bRequest); 463 } 464 } else 465 dbg("%s: error %d", __FUNCTION__, urb->status); 466 467 /* Resubmit urb so we continue receiving IRQ data */ 468 if (urb->status != -ESHUTDOWN) { 469 urb->dev = serial->dev; 470 err = usb_submit_urb(urb, GFP_ATOMIC); 471 if (err) 472 dbg("%s: resubmit intr urb failed. (%d)", 473 __FUNCTION__, err); 474 } 475} 476 477static int option_write_room(struct usb_serial_port *port) 478{ 479 struct option_port_private *portdata; 480 int i; 481 int data_len = 0; 482 struct urb *this_urb; 483 484 portdata = usb_get_serial_port_data(port); 485 486 for (i=0; i < N_OUT_URB; i++) { 487 this_urb = portdata->out_urbs[i]; 488 if (this_urb && this_urb->status != -EINPROGRESS) 489 data_len += OUT_BUFLEN; 490 } 491 492 dbg("%s: %d", __FUNCTION__, data_len); 493 return data_len; 494} 495 496static int option_chars_in_buffer(struct usb_serial_port *port) 497{ 498 struct option_port_private *portdata; 499 int i; 500 int data_len = 0; 501 struct urb *this_urb; 502 503 portdata = usb_get_serial_port_data(port); 504 505 for (i=0; i < N_OUT_URB; i++) { 506 this_urb = portdata->out_urbs[i]; 507 if (this_urb && this_urb->status == -EINPROGRESS) 508 data_len += this_urb->transfer_buffer_length; 509 } 510 dbg("%s: %d", __FUNCTION__, data_len); 511 return data_len; 512} 513 514static int option_open(struct usb_serial_port *port, struct file *filp) 515{ 516 struct option_port_private *portdata; 517 struct usb_serial *serial = port->serial; 518 int i, err; 519 struct urb *urb; 520 521 portdata = usb_get_serial_port_data(port); 522 523 dbg("%s", __FUNCTION__); 524 525 /* Set some sane defaults */ 526 portdata->rts_state = 1; 527 portdata->dtr_state = 1; 528 529 /* Reset low level data toggle and start reading from endpoints */ 530 for (i = 0; i < N_IN_URB; i++) { 531 urb = portdata->in_urbs[i]; 532 if (! urb) 533 continue; 534 if (urb->dev != serial->dev) { 535 dbg("%s: dev %p != %p", __FUNCTION__, 536 urb->dev, serial->dev); 537 continue; 538 } 539 540 /* 541 * make sure endpoint data toggle is synchronized with the 542 * device 543 */ 544 usb_clear_halt(urb->dev, urb->pipe); 545 546 err = usb_submit_urb(urb, GFP_KERNEL); 547 if (err) { 548 dbg("%s: submit urb %d failed (%d) %d", 549 __FUNCTION__, i, err, 550 urb->transfer_buffer_length); 551 } 552 } 553 554 /* Reset low level data toggle on out endpoints */ 555 for (i = 0; i < N_OUT_URB; i++) { 556 urb = portdata->out_urbs[i]; 557 if (! urb) 558 continue; 559 urb->dev = serial->dev; 560 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), 561 usb_pipeout(urb->pipe), 0); */ 562 } 563 564 port->tty->low_latency = 1; 565 566 option_send_setup(port); 567 568 return (0); 569} 570 571static inline void stop_urb(struct urb *urb) 572{ 573 if (urb && urb->status == -EINPROGRESS) 574 usb_kill_urb(urb); 575} 576 577static void option_close(struct usb_serial_port *port, struct file *filp) 578{ 579 int i; 580 struct usb_serial *serial = port->serial; 581 struct option_port_private *portdata; 582 583 dbg("%s", __FUNCTION__); 584 portdata = usb_get_serial_port_data(port); 585 586 portdata->rts_state = 0; 587 portdata->dtr_state = 0; 588 589 if (serial->dev) { 590 option_send_setup(port); 591 592 /* Stop reading/writing urbs */ 593 for (i = 0; i < N_IN_URB; i++) 594 stop_urb(portdata->in_urbs[i]); 595 for (i = 0; i < N_OUT_URB; i++) 596 stop_urb(portdata->out_urbs[i]); 597 } 598 port->tty = NULL; 599} 600 601/* Helper functions used by option_setup_urbs */ 602static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint, 603 int dir, void *ctx, char *buf, int len, 604 void (*callback)(struct urb *, struct pt_regs *regs)) 605{ 606 struct urb *urb; 607 608 if (endpoint == -1) 609 return NULL; /* endpoint not needed */ 610 611 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */ 612 if (urb == NULL) { 613 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint); 614 return NULL; 615 } 616 617 /* Fill URB using supplied data. */ 618 usb_fill_bulk_urb(urb, serial->dev, 619 usb_sndbulkpipe(serial->dev, endpoint) | dir, 620 buf, len, callback, ctx); 621 622 return urb; 623} 624 625/* Setup urbs */ 626static void option_setup_urbs(struct usb_serial *serial) 627{ 628 int i,j; 629 struct usb_serial_port *port; 630 struct option_port_private *portdata; 631 632 dbg("%s", __FUNCTION__); 633 634 for (i = 0; i < serial->num_ports; i++) { 635 port = serial->port[i]; 636 portdata = usb_get_serial_port_data(port); 637 638 /* Do indat endpoints first */ 639 for (j = 0; j < N_IN_URB; ++j) { 640 portdata->in_urbs[j] = option_setup_urb (serial, 641 port->bulk_in_endpointAddress, USB_DIR_IN, port, 642 portdata->in_buffer[j], IN_BUFLEN, option_indat_callback); 643 } 644 645 /* outdat endpoints */ 646 for (j = 0; j < N_OUT_URB; ++j) { 647 portdata->out_urbs[j] = option_setup_urb (serial, 648 port->bulk_out_endpointAddress, USB_DIR_OUT, port, 649 portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback); 650 } 651 } 652} 653 654static int option_send_setup(struct usb_serial_port *port) 655{ 656 struct usb_serial *serial = port->serial; 657 struct option_port_private *portdata; 658 659 dbg("%s", __FUNCTION__); 660 661 portdata = usb_get_serial_port_data(port); 662 663 if (port->tty) { 664 int val = 0; 665 if (portdata->dtr_state) 666 val |= 0x01; 667 if (portdata->rts_state) 668 val |= 0x02; 669 670 return usb_control_msg(serial->dev, 671 usb_rcvctrlpipe(serial->dev, 0), 672 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT); 673 } 674 675 return 0; 676} 677 678static int option_startup(struct usb_serial *serial) 679{ 680 int i, err; 681 struct usb_serial_port *port; 682 struct option_port_private *portdata; 683 684 dbg("%s", __FUNCTION__); 685 686 /* Now setup per port private data */ 687 for (i = 0; i < serial->num_ports; i++) { 688 port = serial->port[i]; 689 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); 690 if (!portdata) { 691 dbg("%s: kmalloc for option_port_private (%d) failed!.", 692 __FUNCTION__, i); 693 return (1); 694 } 695 696 usb_set_serial_port_data(port, portdata); 697 698 if (! port->interrupt_in_urb) 699 continue; 700 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 701 if (err) 702 dbg("%s: submit irq_in urb failed %d", 703 __FUNCTION__, err); 704 } 705 706 option_setup_urbs(serial); 707 708 return (0); 709} 710 711static void option_shutdown(struct usb_serial *serial) 712{ 713 int i, j; 714 struct usb_serial_port *port; 715 struct option_port_private *portdata; 716 717 dbg("%s", __FUNCTION__); 718 719 /* Stop reading/writing urbs */ 720 for (i = 0; i < serial->num_ports; ++i) { 721 port = serial->port[i]; 722 portdata = usb_get_serial_port_data(port); 723 for (j = 0; j < N_IN_URB; j++) 724 stop_urb(portdata->in_urbs[j]); 725 for (j = 0; j < N_OUT_URB; j++) 726 stop_urb(portdata->out_urbs[j]); 727 } 728 729 /* Now free them */ 730 for (i = 0; i < serial->num_ports; ++i) { 731 port = serial->port[i]; 732 portdata = usb_get_serial_port_data(port); 733 734 for (j = 0; j < N_IN_URB; j++) { 735 if (portdata->in_urbs[j]) { 736 usb_free_urb(portdata->in_urbs[j]); 737 portdata->in_urbs[j] = NULL; 738 } 739 } 740 for (j = 0; j < N_OUT_URB; j++) { 741 if (portdata->out_urbs[j]) { 742 usb_free_urb(portdata->out_urbs[j]); 743 portdata->out_urbs[j] = NULL; 744 } 745 } 746 } 747 748 /* Now free per port private data */ 749 for (i = 0; i < serial->num_ports; i++) { 750 port = serial->port[i]; 751 kfree(usb_get_serial_port_data(port)); 752 } 753} 754 755MODULE_AUTHOR(DRIVER_AUTHOR); 756MODULE_DESCRIPTION(DRIVER_DESC); 757MODULE_VERSION(DRIVER_VERSION); 758MODULE_LICENSE("GPL"); 759 760#ifdef CONFIG_USB_DEBUG 761module_param(debug, bool, S_IRUGO | S_IWUSR); 762MODULE_PARM_DESC(debug, "Debug messages"); 763#endif 764 765