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