1/* 2 USB Driver layer 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 - controlling the baud rate doesn't make sense 20*/ 21 22#define DRIVER_VERSION "v0.7.2" 23#define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>" 24#define DRIVER_DESC "USB Driver for GSM modems" 25 26#include <linux/kernel.h> 27#include <linux/jiffies.h> 28#include <linux/errno.h> 29#include <linux/slab.h> 30#include <linux/tty.h> 31#include <linux/tty_flip.h> 32#include <linux/module.h> 33#include <linux/bitops.h> 34#include <linux/usb.h> 35#include <linux/usb/serial.h> 36#include "usb-wwan.h" 37 38static int debug; 39 40void usb_wwan_dtr_rts(struct usb_serial_port *port, int on) 41{ 42 struct usb_serial *serial = port->serial; 43 struct usb_wwan_port_private *portdata; 44 45 struct usb_wwan_intf_private *intfdata; 46 47 dbg("%s", __func__); 48 49 intfdata = port->serial->private; 50 51 if (!intfdata->send_setup) 52 return; 53 54 portdata = usb_get_serial_port_data(port); 55 mutex_lock(&serial->disc_mutex); 56 portdata->rts_state = on; 57 portdata->dtr_state = on; 58 if (serial->dev) 59 intfdata->send_setup(port); 60 mutex_unlock(&serial->disc_mutex); 61} 62EXPORT_SYMBOL(usb_wwan_dtr_rts); 63 64void usb_wwan_set_termios(struct tty_struct *tty, 65 struct usb_serial_port *port, 66 struct ktermios *old_termios) 67{ 68 struct usb_wwan_intf_private *intfdata = port->serial->private; 69 70 dbg("%s", __func__); 71 72 /* Doesn't support option setting */ 73 tty_termios_copy_hw(tty->termios, old_termios); 74 75 if (intfdata->send_setup) 76 intfdata->send_setup(port); 77} 78EXPORT_SYMBOL(usb_wwan_set_termios); 79 80int usb_wwan_tiocmget(struct tty_struct *tty, struct file *file) 81{ 82 struct usb_serial_port *port = tty->driver_data; 83 unsigned int value; 84 struct usb_wwan_port_private *portdata; 85 86 portdata = usb_get_serial_port_data(port); 87 88 value = ((portdata->rts_state) ? TIOCM_RTS : 0) | 89 ((portdata->dtr_state) ? TIOCM_DTR : 0) | 90 ((portdata->cts_state) ? TIOCM_CTS : 0) | 91 ((portdata->dsr_state) ? TIOCM_DSR : 0) | 92 ((portdata->dcd_state) ? TIOCM_CAR : 0) | 93 ((portdata->ri_state) ? TIOCM_RNG : 0); 94 95 return value; 96} 97EXPORT_SYMBOL(usb_wwan_tiocmget); 98 99int usb_wwan_tiocmset(struct tty_struct *tty, struct file *file, 100 unsigned int set, unsigned int clear) 101{ 102 struct usb_serial_port *port = tty->driver_data; 103 struct usb_wwan_port_private *portdata; 104 struct usb_wwan_intf_private *intfdata; 105 106 portdata = usb_get_serial_port_data(port); 107 intfdata = port->serial->private; 108 109 if (!intfdata->send_setup) 110 return -EINVAL; 111 112 if (set & TIOCM_RTS) 113 portdata->rts_state = 1; 114 if (set & TIOCM_DTR) 115 portdata->dtr_state = 1; 116 117 if (clear & TIOCM_RTS) 118 portdata->rts_state = 0; 119 if (clear & TIOCM_DTR) 120 portdata->dtr_state = 0; 121 return intfdata->send_setup(port); 122} 123EXPORT_SYMBOL(usb_wwan_tiocmset); 124 125/* Write */ 126int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port, 127 const unsigned char *buf, int count) 128{ 129 struct usb_wwan_port_private *portdata; 130 struct usb_wwan_intf_private *intfdata; 131 int i; 132 int left, todo; 133 struct urb *this_urb = NULL; /* spurious */ 134 int err; 135 unsigned long flags; 136 137 portdata = usb_get_serial_port_data(port); 138 intfdata = port->serial->private; 139 140 dbg("%s: write (%d chars)", __func__, count); 141 142 i = 0; 143 left = count; 144 for (i = 0; left > 0 && i < N_OUT_URB; i++) { 145 todo = left; 146 if (todo > OUT_BUFLEN) 147 todo = OUT_BUFLEN; 148 149 this_urb = portdata->out_urbs[i]; 150 if (test_and_set_bit(i, &portdata->out_busy)) { 151 if (time_before(jiffies, 152 portdata->tx_start_time[i] + 10 * HZ)) 153 continue; 154 usb_unlink_urb(this_urb); 155 continue; 156 } 157 dbg("%s: endpoint %d buf %d", __func__, 158 usb_pipeendpoint(this_urb->pipe), i); 159 160 err = usb_autopm_get_interface_async(port->serial->interface); 161 if (err < 0) 162 break; 163 164 /* send the data */ 165 memcpy(this_urb->transfer_buffer, buf, todo); 166 this_urb->transfer_buffer_length = todo; 167 168 spin_lock_irqsave(&intfdata->susp_lock, flags); 169 if (intfdata->suspended) { 170 usb_anchor_urb(this_urb, &portdata->delayed); 171 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 172 } else { 173 intfdata->in_flight++; 174 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 175 err = usb_submit_urb(this_urb, GFP_ATOMIC); 176 if (err) { 177 dbg("usb_submit_urb %p (write bulk) failed " 178 "(%d)", this_urb, err); 179 clear_bit(i, &portdata->out_busy); 180 spin_lock_irqsave(&intfdata->susp_lock, flags); 181 intfdata->in_flight--; 182 spin_unlock_irqrestore(&intfdata->susp_lock, 183 flags); 184 continue; 185 } 186 } 187 188 portdata->tx_start_time[i] = jiffies; 189 buf += todo; 190 left -= todo; 191 } 192 193 count -= left; 194 dbg("%s: wrote (did %d)", __func__, count); 195 return count; 196} 197EXPORT_SYMBOL(usb_wwan_write); 198 199static void usb_wwan_indat_callback(struct urb *urb) 200{ 201 int err; 202 int endpoint; 203 struct usb_serial_port *port; 204 struct tty_struct *tty; 205 unsigned char *data = urb->transfer_buffer; 206 int status = urb->status; 207 208 dbg("%s: %p", __func__, urb); 209 210 endpoint = usb_pipeendpoint(urb->pipe); 211 port = urb->context; 212 213 if (status) { 214 dbg("%s: nonzero status: %d on endpoint %02x.", 215 __func__, status, endpoint); 216 } else { 217 tty = tty_port_tty_get(&port->port); 218 if (urb->actual_length) { 219 tty_insert_flip_string(tty, data, urb->actual_length); 220 tty_flip_buffer_push(tty); 221 } else 222 dbg("%s: empty read urb received", __func__); 223 tty_kref_put(tty); 224 225 /* Resubmit urb so we continue receiving */ 226 if (status != -ESHUTDOWN) { 227 err = usb_submit_urb(urb, GFP_ATOMIC); 228 if (err && err != -EPERM) 229 printk(KERN_ERR "%s: resubmit read urb failed. " 230 "(%d)", __func__, err); 231 else 232 usb_mark_last_busy(port->serial->dev); 233 } 234 235 } 236 return; 237} 238 239static void usb_wwan_outdat_callback(struct urb *urb) 240{ 241 struct usb_serial_port *port; 242 struct usb_wwan_port_private *portdata; 243 struct usb_wwan_intf_private *intfdata; 244 int i; 245 246 dbg("%s", __func__); 247 248 port = urb->context; 249 intfdata = port->serial->private; 250 251 usb_serial_port_softint(port); 252 usb_autopm_put_interface_async(port->serial->interface); 253 portdata = usb_get_serial_port_data(port); 254 spin_lock(&intfdata->susp_lock); 255 intfdata->in_flight--; 256 spin_unlock(&intfdata->susp_lock); 257 258 for (i = 0; i < N_OUT_URB; ++i) { 259 if (portdata->out_urbs[i] == urb) { 260 smp_mb__before_clear_bit(); 261 clear_bit(i, &portdata->out_busy); 262 break; 263 } 264 } 265} 266 267int usb_wwan_write_room(struct tty_struct *tty) 268{ 269 struct usb_serial_port *port = tty->driver_data; 270 struct usb_wwan_port_private *portdata; 271 int i; 272 int data_len = 0; 273 struct urb *this_urb; 274 275 portdata = usb_get_serial_port_data(port); 276 277 for (i = 0; i < N_OUT_URB; i++) { 278 this_urb = portdata->out_urbs[i]; 279 if (this_urb && !test_bit(i, &portdata->out_busy)) 280 data_len += OUT_BUFLEN; 281 } 282 283 dbg("%s: %d", __func__, data_len); 284 return data_len; 285} 286EXPORT_SYMBOL(usb_wwan_write_room); 287 288int usb_wwan_chars_in_buffer(struct tty_struct *tty) 289{ 290 struct usb_serial_port *port = tty->driver_data; 291 struct usb_wwan_port_private *portdata; 292 int i; 293 int data_len = 0; 294 struct urb *this_urb; 295 296 portdata = usb_get_serial_port_data(port); 297 298 for (i = 0; i < N_OUT_URB; i++) { 299 this_urb = portdata->out_urbs[i]; 300 if (this_urb && test_bit(i, &portdata->out_busy)) 301 data_len += this_urb->transfer_buffer_length; 302 } 303 dbg("%s: %d", __func__, data_len); 304 return data_len; 305} 306EXPORT_SYMBOL(usb_wwan_chars_in_buffer); 307 308int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port) 309{ 310 struct usb_wwan_port_private *portdata; 311 struct usb_wwan_intf_private *intfdata; 312 struct usb_serial *serial = port->serial; 313 int i, err; 314 struct urb *urb; 315 316 portdata = usb_get_serial_port_data(port); 317 intfdata = serial->private; 318 319 dbg("%s", __func__); 320 321 /* Start reading from the IN endpoint */ 322 for (i = 0; i < N_IN_URB; i++) { 323 urb = portdata->in_urbs[i]; 324 if (!urb) 325 continue; 326 err = usb_submit_urb(urb, GFP_KERNEL); 327 if (err) { 328 dbg("%s: submit urb %d failed (%d) %d", 329 __func__, i, err, urb->transfer_buffer_length); 330 } 331 } 332 333 if (intfdata->send_setup) 334 intfdata->send_setup(port); 335 336 serial->interface->needs_remote_wakeup = 1; 337 spin_lock_irq(&intfdata->susp_lock); 338 portdata->opened = 1; 339 spin_unlock_irq(&intfdata->susp_lock); 340 usb_autopm_put_interface(serial->interface); 341 342 return 0; 343} 344EXPORT_SYMBOL(usb_wwan_open); 345 346void usb_wwan_close(struct usb_serial_port *port) 347{ 348 int i; 349 struct usb_serial *serial = port->serial; 350 struct usb_wwan_port_private *portdata; 351 struct usb_wwan_intf_private *intfdata = port->serial->private; 352 353 dbg("%s", __func__); 354 portdata = usb_get_serial_port_data(port); 355 356 if (serial->dev) { 357 /* Stop reading/writing urbs */ 358 spin_lock_irq(&intfdata->susp_lock); 359 portdata->opened = 0; 360 spin_unlock_irq(&intfdata->susp_lock); 361 362 for (i = 0; i < N_IN_URB; i++) 363 usb_kill_urb(portdata->in_urbs[i]); 364 for (i = 0; i < N_OUT_URB; i++) 365 usb_kill_urb(portdata->out_urbs[i]); 366 usb_autopm_get_interface(serial->interface); 367 serial->interface->needs_remote_wakeup = 0; 368 } 369} 370EXPORT_SYMBOL(usb_wwan_close); 371 372/* Helper functions used by usb_wwan_setup_urbs */ 373static struct urb *usb_wwan_setup_urb(struct usb_serial *serial, int endpoint, 374 int dir, void *ctx, char *buf, int len, 375 void (*callback) (struct urb *)) 376{ 377 struct urb *urb; 378 379 if (endpoint == -1) 380 return NULL; /* endpoint not needed */ 381 382 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */ 383 if (urb == NULL) { 384 dbg("%s: alloc for endpoint %d failed.", __func__, endpoint); 385 return NULL; 386 } 387 388 /* Fill URB using supplied data. */ 389 usb_fill_bulk_urb(urb, serial->dev, 390 usb_sndbulkpipe(serial->dev, endpoint) | dir, 391 buf, len, callback, ctx); 392 393 return urb; 394} 395 396/* Setup urbs */ 397static void usb_wwan_setup_urbs(struct usb_serial *serial) 398{ 399 int i, j; 400 struct usb_serial_port *port; 401 struct usb_wwan_port_private *portdata; 402 403 dbg("%s", __func__); 404 405 for (i = 0; i < serial->num_ports; i++) { 406 port = serial->port[i]; 407 portdata = usb_get_serial_port_data(port); 408 409 /* Do indat endpoints first */ 410 for (j = 0; j < N_IN_URB; ++j) { 411 portdata->in_urbs[j] = usb_wwan_setup_urb(serial, 412 port-> 413 bulk_in_endpointAddress, 414 USB_DIR_IN, 415 port, 416 portdata-> 417 in_buffer[j], 418 IN_BUFLEN, 419 usb_wwan_indat_callback); 420 } 421 422 /* outdat endpoints */ 423 for (j = 0; j < N_OUT_URB; ++j) { 424 portdata->out_urbs[j] = usb_wwan_setup_urb(serial, 425 port-> 426 bulk_out_endpointAddress, 427 USB_DIR_OUT, 428 port, 429 portdata-> 430 out_buffer 431 [j], 432 OUT_BUFLEN, 433 usb_wwan_outdat_callback); 434 } 435 } 436} 437 438int usb_wwan_startup(struct usb_serial *serial) 439{ 440 int i, j, err; 441 struct usb_serial_port *port; 442 struct usb_wwan_port_private *portdata; 443 u8 *buffer; 444 445 dbg("%s", __func__); 446 447 /* Now setup per port private data */ 448 for (i = 0; i < serial->num_ports; i++) { 449 port = serial->port[i]; 450 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); 451 if (!portdata) { 452 dbg("%s: kmalloc for usb_wwan_port_private (%d) failed!.", 453 __func__, i); 454 return 1; 455 } 456 init_usb_anchor(&portdata->delayed); 457 458 for (j = 0; j < N_IN_URB; j++) { 459 buffer = (u8 *) __get_free_page(GFP_KERNEL); 460 if (!buffer) 461 goto bail_out_error; 462 portdata->in_buffer[j] = buffer; 463 } 464 465 for (j = 0; j < N_OUT_URB; j++) { 466 buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL); 467 if (!buffer) 468 goto bail_out_error2; 469 portdata->out_buffer[j] = buffer; 470 } 471 472 usb_set_serial_port_data(port, portdata); 473 474 if (!port->interrupt_in_urb) 475 continue; 476 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 477 if (err) 478 dbg("%s: submit irq_in urb failed %d", __func__, err); 479 } 480 usb_wwan_setup_urbs(serial); 481 return 0; 482 483bail_out_error2: 484 for (j = 0; j < N_OUT_URB; j++) 485 kfree(portdata->out_buffer[j]); 486bail_out_error: 487 for (j = 0; j < N_IN_URB; j++) 488 if (portdata->in_buffer[j]) 489 free_page((unsigned long)portdata->in_buffer[j]); 490 kfree(portdata); 491 return 1; 492} 493EXPORT_SYMBOL(usb_wwan_startup); 494 495static void stop_read_write_urbs(struct usb_serial *serial) 496{ 497 int i, j; 498 struct usb_serial_port *port; 499 struct usb_wwan_port_private *portdata; 500 501 /* Stop reading/writing urbs */ 502 for (i = 0; i < serial->num_ports; ++i) { 503 port = serial->port[i]; 504 portdata = usb_get_serial_port_data(port); 505 for (j = 0; j < N_IN_URB; j++) 506 usb_kill_urb(portdata->in_urbs[j]); 507 for (j = 0; j < N_OUT_URB; j++) 508 usb_kill_urb(portdata->out_urbs[j]); 509 } 510} 511 512void usb_wwan_disconnect(struct usb_serial *serial) 513{ 514 dbg("%s", __func__); 515 516 stop_read_write_urbs(serial); 517} 518EXPORT_SYMBOL(usb_wwan_disconnect); 519 520void usb_wwan_release(struct usb_serial *serial) 521{ 522 int i, j; 523 struct usb_serial_port *port; 524 struct usb_wwan_port_private *portdata; 525 526 dbg("%s", __func__); 527 528 /* Now free them */ 529 for (i = 0; i < serial->num_ports; ++i) { 530 port = serial->port[i]; 531 portdata = usb_get_serial_port_data(port); 532 533 for (j = 0; j < N_IN_URB; j++) { 534 usb_free_urb(portdata->in_urbs[j]); 535 free_page((unsigned long) 536 portdata->in_buffer[j]); 537 portdata->in_urbs[j] = NULL; 538 } 539 for (j = 0; j < N_OUT_URB; j++) { 540 usb_free_urb(portdata->out_urbs[j]); 541 kfree(portdata->out_buffer[j]); 542 portdata->out_urbs[j] = NULL; 543 } 544 } 545 546 /* Now free per port private data */ 547 for (i = 0; i < serial->num_ports; i++) { 548 port = serial->port[i]; 549 kfree(usb_get_serial_port_data(port)); 550 } 551} 552EXPORT_SYMBOL(usb_wwan_release); 553 554#ifdef CONFIG_PM 555int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message) 556{ 557 struct usb_wwan_intf_private *intfdata = serial->private; 558 int b; 559 560 dbg("%s entered", __func__); 561 562 if (message.event & PM_EVENT_AUTO) { 563 spin_lock_irq(&intfdata->susp_lock); 564 b = intfdata->in_flight; 565 spin_unlock_irq(&intfdata->susp_lock); 566 567 if (b) 568 return -EBUSY; 569 } 570 571 spin_lock_irq(&intfdata->susp_lock); 572 intfdata->suspended = 1; 573 spin_unlock_irq(&intfdata->susp_lock); 574 stop_read_write_urbs(serial); 575 576 return 0; 577} 578EXPORT_SYMBOL(usb_wwan_suspend); 579 580static void play_delayed(struct usb_serial_port *port) 581{ 582 struct usb_wwan_intf_private *data; 583 struct usb_wwan_port_private *portdata; 584 struct urb *urb; 585 int err; 586 587 portdata = usb_get_serial_port_data(port); 588 data = port->serial->private; 589 while ((urb = usb_get_from_anchor(&portdata->delayed))) { 590 err = usb_submit_urb(urb, GFP_ATOMIC); 591 if (!err) 592 data->in_flight++; 593 } 594} 595 596int usb_wwan_resume(struct usb_serial *serial) 597{ 598 int i, j; 599 struct usb_serial_port *port; 600 struct usb_wwan_intf_private *intfdata = serial->private; 601 struct usb_wwan_port_private *portdata; 602 struct urb *urb; 603 int err = 0; 604 605 dbg("%s entered", __func__); 606 /* get the interrupt URBs resubmitted unconditionally */ 607 for (i = 0; i < serial->num_ports; i++) { 608 port = serial->port[i]; 609 if (!port->interrupt_in_urb) { 610 dbg("%s: No interrupt URB for port %d", __func__, i); 611 continue; 612 } 613 err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO); 614 dbg("Submitted interrupt URB for port %d (result %d)", i, err); 615 if (err < 0) { 616 err("%s: Error %d for interrupt URB of port%d", 617 __func__, err, i); 618 goto err_out; 619 } 620 } 621 622 for (i = 0; i < serial->num_ports; i++) { 623 /* walk all ports */ 624 port = serial->port[i]; 625 portdata = usb_get_serial_port_data(port); 626 627 /* skip closed ports */ 628 spin_lock_irq(&intfdata->susp_lock); 629 if (!portdata->opened) { 630 spin_unlock_irq(&intfdata->susp_lock); 631 continue; 632 } 633 634 for (j = 0; j < N_IN_URB; j++) { 635 urb = portdata->in_urbs[j]; 636 err = usb_submit_urb(urb, GFP_ATOMIC); 637 if (err < 0) { 638 err("%s: Error %d for bulk URB %d", 639 __func__, err, i); 640 spin_unlock_irq(&intfdata->susp_lock); 641 goto err_out; 642 } 643 } 644 play_delayed(port); 645 spin_unlock_irq(&intfdata->susp_lock); 646 } 647 spin_lock_irq(&intfdata->susp_lock); 648 intfdata->suspended = 0; 649 spin_unlock_irq(&intfdata->susp_lock); 650err_out: 651 return err; 652} 653EXPORT_SYMBOL(usb_wwan_resume); 654#endif 655 656MODULE_AUTHOR(DRIVER_AUTHOR); 657MODULE_DESCRIPTION(DRIVER_DESC); 658MODULE_VERSION(DRIVER_VERSION); 659MODULE_LICENSE("GPL"); 660 661module_param(debug, bool, S_IRUGO | S_IWUSR); 662MODULE_PARM_DESC(debug, "Debug messages"); 663