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