1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 USB Driver layer for GSM modems 4 5 Copyright (C) 2005 Matthias Urlichs <smurf@smurf.noris.de> 6 7 Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org> 8 9 History: see the git log. 10 11 Work sponsored by: Sigos GmbH, Germany <info@sigos.de> 12 13 This driver exists because the "normal" serial driver doesn't work too well 14 with GSM modems. Issues: 15 - data loss -- one single Receive URB is not nearly enough 16 - controlling the baud rate doesn't make sense 17 */ 18 19 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>" 20 #define DRIVER_DESC "USB Driver for GSM modems" 21 22 #include <linux/kernel.h> 23 #include <linux/jiffies.h> 24 #include <linux/errno.h> 25 #include <linux/slab.h> 26 #include <linux/tty.h> 27 #include <linux/tty_flip.h> 28 #include <linux/module.h> 29 #include <linux/bitops.h> 30 #include <linux/uaccess.h> 31 #include <linux/usb.h> 32 #include <linux/usb/serial.h> 33 #include <linux/serial.h> 34 #include "usb-wwan.h" 35 36 /* 37 * Generate DTR/RTS signals on the port using the SET_CONTROL_LINE_STATE request 38 * in CDC ACM. 39 */ 40 static int usb_wwan_send_setup(struct usb_serial_port *port) 41 { 42 struct usb_serial *serial = port->serial; 43 struct usb_wwan_port_private *portdata; 44 int val = 0; 45 int ifnum; 46 int res; 47 48 portdata = usb_get_serial_port_data(port); 49 50 if (portdata->dtr_state) 51 val |= 0x01; 52 if (portdata->rts_state) 53 val |= 0x02; 54 55 ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber; 56 57 res = usb_autopm_get_interface(serial->interface); 58 if (res) 59 return res; 60 61 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 62 0x22, 0x21, val, ifnum, NULL, 0, 63 USB_CTRL_SET_TIMEOUT); 64 65 usb_autopm_put_interface(port->serial->interface); 66 67 return res; 68 } 69 70 void usb_wwan_dtr_rts(struct usb_serial_port *port, int on) 71 { 72 struct usb_wwan_port_private *portdata; 73 struct usb_wwan_intf_private *intfdata; 74 75 intfdata = usb_get_serial_data(port->serial); 76 77 if (!intfdata->use_send_setup) 78 return; 79 80 portdata = usb_get_serial_port_data(port); 81 /* FIXME: locking */ 82 portdata->rts_state = on; 83 portdata->dtr_state = on; 84 85 usb_wwan_send_setup(port); 86 } 87 EXPORT_SYMBOL(usb_wwan_dtr_rts); 88 89 int usb_wwan_tiocmget(struct tty_struct *tty) 90 { 91 struct usb_serial_port *port = tty->driver_data; 92 unsigned int value; 93 struct usb_wwan_port_private *portdata; 94 95 portdata = usb_get_serial_port_data(port); 96 97 value = ((portdata->rts_state) ? TIOCM_RTS : 0) | 98 ((portdata->dtr_state) ? TIOCM_DTR : 0) | 99 ((portdata->cts_state) ? TIOCM_CTS : 0) | 100 ((portdata->dsr_state) ? TIOCM_DSR : 0) | 101 ((portdata->dcd_state) ? TIOCM_CAR : 0) | 102 ((portdata->ri_state) ? TIOCM_RNG : 0); 103 104 return value; 105 } 106 EXPORT_SYMBOL(usb_wwan_tiocmget); 107 108 int usb_wwan_tiocmset(struct tty_struct *tty, 109 unsigned int set, unsigned int clear) 110 { 111 struct usb_serial_port *port = tty->driver_data; 112 struct usb_wwan_port_private *portdata; 113 struct usb_wwan_intf_private *intfdata; 114 115 portdata = usb_get_serial_port_data(port); 116 intfdata = usb_get_serial_data(port->serial); 117 118 if (!intfdata->use_send_setup) 119 return -EINVAL; 120 121 /* FIXME: what locks portdata fields ? */ 122 if (set & TIOCM_RTS) 123 portdata->rts_state = 1; 124 if (set & TIOCM_DTR) 125 portdata->dtr_state = 1; 126 127 if (clear & TIOCM_RTS) 128 portdata->rts_state = 0; 129 if (clear & TIOCM_DTR) 130 portdata->dtr_state = 0; 131 return usb_wwan_send_setup(port); 132 } 133 EXPORT_SYMBOL(usb_wwan_tiocmset); 134 135 int usb_wwan_get_serial_info(struct tty_struct *tty, 136 struct serial_struct *ss) 137 { 138 struct usb_serial_port *port = tty->driver_data; 139 140 ss->line = port->minor; 141 ss->port = port->port_number; 142 ss->baud_base = tty_get_baud_rate(port->port.tty); 143 ss->close_delay = port->port.close_delay / 10; 144 ss->closing_wait = port->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ? 145 ASYNC_CLOSING_WAIT_NONE : 146 port->port.closing_wait / 10; 147 return 0; 148 } 149 EXPORT_SYMBOL(usb_wwan_get_serial_info); 150 151 int usb_wwan_set_serial_info(struct tty_struct *tty, 152 struct serial_struct *ss) 153 { 154 struct usb_serial_port *port = tty->driver_data; 155 unsigned int closing_wait, close_delay; 156 int retval = 0; 157 158 close_delay = ss->close_delay * 10; 159 closing_wait = ss->closing_wait == ASYNC_CLOSING_WAIT_NONE ? 160 ASYNC_CLOSING_WAIT_NONE : ss->closing_wait * 10; 161 162 mutex_lock(&port->port.mutex); 163 164 if (!capable(CAP_SYS_ADMIN)) { 165 if ((close_delay != port->port.close_delay) || 166 (closing_wait != port->port.closing_wait)) 167 retval = -EPERM; 168 else 169 retval = -EOPNOTSUPP; 170 } else { 171 port->port.close_delay = close_delay; 172 port->port.closing_wait = closing_wait; 173 } 174 175 mutex_unlock(&port->port.mutex); 176 return retval; 177 } 178 EXPORT_SYMBOL(usb_wwan_set_serial_info); 179 180 int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port, 181 const unsigned char *buf, int count) 182 { 183 struct usb_wwan_port_private *portdata; 184 struct usb_wwan_intf_private *intfdata; 185 int i; 186 int left, todo; 187 struct urb *this_urb = NULL; /* spurious */ 188 int err; 189 unsigned long flags; 190 191 portdata = usb_get_serial_port_data(port); 192 intfdata = usb_get_serial_data(port->serial); 193 194 dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count); 195 196 i = 0; 197 left = count; 198 for (i = 0; left > 0 && i < N_OUT_URB; i++) { 199 todo = left; 200 if (todo > OUT_BUFLEN) 201 todo = OUT_BUFLEN; 202 203 this_urb = portdata->out_urbs[i]; 204 if (test_and_set_bit(i, &portdata->out_busy)) { 205 if (time_before(jiffies, 206 portdata->tx_start_time[i] + 10 * HZ)) 207 continue; 208 usb_unlink_urb(this_urb); 209 continue; 210 } 211 dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__, 212 usb_pipeendpoint(this_urb->pipe), i); 213 214 err = usb_autopm_get_interface_async(port->serial->interface); 215 if (err < 0) { 216 clear_bit(i, &portdata->out_busy); 217 break; 218 } 219 220 /* send the data */ 221 memcpy(this_urb->transfer_buffer, buf, todo); 222 this_urb->transfer_buffer_length = todo; 223 224 spin_lock_irqsave(&intfdata->susp_lock, flags); 225 if (intfdata->suspended) { 226 usb_anchor_urb(this_urb, &portdata->delayed); 227 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 228 } else { 229 intfdata->in_flight++; 230 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 231 err = usb_submit_urb(this_urb, GFP_ATOMIC); 232 if (err) { 233 dev_err(&port->dev, 234 "%s: submit urb %d failed: %d\n", 235 __func__, i, err); 236 clear_bit(i, &portdata->out_busy); 237 spin_lock_irqsave(&intfdata->susp_lock, flags); 238 intfdata->in_flight--; 239 spin_unlock_irqrestore(&intfdata->susp_lock, 240 flags); 241 usb_autopm_put_interface_async(port->serial->interface); 242 break; 243 } 244 } 245 246 portdata->tx_start_time[i] = jiffies; 247 buf += todo; 248 left -= todo; 249 } 250 251 count -= left; 252 dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count); 253 return count; 254 } 255 EXPORT_SYMBOL(usb_wwan_write); 256 257 static void usb_wwan_indat_callback(struct urb *urb) 258 { 259 int err; 260 int endpoint; 261 struct usb_serial_port *port; 262 struct device *dev; 263 unsigned char *data = urb->transfer_buffer; 264 int status = urb->status; 265 266 endpoint = usb_pipeendpoint(urb->pipe); 267 port = urb->context; 268 dev = &port->dev; 269 270 if (status) { 271 dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n", 272 __func__, status, endpoint); 273 274 /* don't resubmit on fatal errors */ 275 if (status == -ESHUTDOWN || status == -ENOENT) 276 return; 277 } else { 278 if (urb->actual_length) { 279 tty_insert_flip_string(&port->port, data, 280 urb->actual_length); 281 tty_flip_buffer_push(&port->port); 282 } else 283 dev_dbg(dev, "%s: empty read urb received\n", __func__); 284 } 285 /* Resubmit urb so we continue receiving */ 286 err = usb_submit_urb(urb, GFP_ATOMIC); 287 if (err) { 288 if (err != -EPERM && err != -ENODEV) { 289 dev_err(dev, "%s: resubmit read urb failed. (%d)\n", 290 __func__, err); 291 /* busy also in error unless we are killed */ 292 usb_mark_last_busy(port->serial->dev); 293 } 294 } else { 295 usb_mark_last_busy(port->serial->dev); 296 } 297 } 298 299 static void usb_wwan_outdat_callback(struct urb *urb) 300 { 301 struct usb_serial_port *port; 302 struct usb_wwan_port_private *portdata; 303 struct usb_wwan_intf_private *intfdata; 304 unsigned long flags; 305 int i; 306 307 port = urb->context; 308 intfdata = usb_get_serial_data(port->serial); 309 310 usb_serial_port_softint(port); 311 usb_autopm_put_interface_async(port->serial->interface); 312 portdata = usb_get_serial_port_data(port); 313 spin_lock_irqsave(&intfdata->susp_lock, flags); 314 intfdata->in_flight--; 315 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 316 317 for (i = 0; i < N_OUT_URB; ++i) { 318 if (portdata->out_urbs[i] == urb) { 319 smp_mb__before_atomic(); 320 clear_bit(i, &portdata->out_busy); 321 break; 322 } 323 } 324 } 325 326 int usb_wwan_write_room(struct tty_struct *tty) 327 { 328 struct usb_serial_port *port = tty->driver_data; 329 struct usb_wwan_port_private *portdata; 330 int i; 331 int data_len = 0; 332 struct urb *this_urb; 333 334 portdata = usb_get_serial_port_data(port); 335 336 for (i = 0; i < N_OUT_URB; i++) { 337 this_urb = portdata->out_urbs[i]; 338 if (this_urb && !test_bit(i, &portdata->out_busy)) 339 data_len += OUT_BUFLEN; 340 } 341 342 dev_dbg(&port->dev, "%s: %d\n", __func__, data_len); 343 return data_len; 344 } 345 EXPORT_SYMBOL(usb_wwan_write_room); 346 347 int usb_wwan_chars_in_buffer(struct tty_struct *tty) 348 { 349 struct usb_serial_port *port = tty->driver_data; 350 struct usb_wwan_port_private *portdata; 351 int i; 352 int data_len = 0; 353 struct urb *this_urb; 354 355 portdata = usb_get_serial_port_data(port); 356 357 for (i = 0; i < N_OUT_URB; i++) { 358 this_urb = portdata->out_urbs[i]; 359 /* FIXME: This locking is insufficient as this_urb may 360 go unused during the test */ 361 if (this_urb && test_bit(i, &portdata->out_busy)) 362 data_len += this_urb->transfer_buffer_length; 363 } 364 dev_dbg(&port->dev, "%s: %d\n", __func__, data_len); 365 return data_len; 366 } 367 EXPORT_SYMBOL(usb_wwan_chars_in_buffer); 368 369 int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port) 370 { 371 struct usb_wwan_port_private *portdata; 372 struct usb_wwan_intf_private *intfdata; 373 struct usb_serial *serial = port->serial; 374 int i, err; 375 struct urb *urb; 376 377 portdata = usb_get_serial_port_data(port); 378 intfdata = usb_get_serial_data(serial); 379 380 if (port->interrupt_in_urb) { 381 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 382 if (err) { 383 dev_err(&port->dev, "%s: submit int urb failed: %d\n", 384 __func__, err); 385 } 386 } 387 388 /* Start reading from the IN endpoint */ 389 for (i = 0; i < N_IN_URB; i++) { 390 urb = portdata->in_urbs[i]; 391 if (!urb) 392 continue; 393 err = usb_submit_urb(urb, GFP_KERNEL); 394 if (err) { 395 dev_err(&port->dev, 396 "%s: submit read urb %d failed: %d\n", 397 __func__, i, err); 398 } 399 } 400 401 spin_lock_irq(&intfdata->susp_lock); 402 if (++intfdata->open_ports == 1) 403 serial->interface->needs_remote_wakeup = 1; 404 spin_unlock_irq(&intfdata->susp_lock); 405 /* this balances a get in the generic USB serial code */ 406 usb_autopm_put_interface(serial->interface); 407 408 return 0; 409 } 410 EXPORT_SYMBOL(usb_wwan_open); 411 412 static void unbusy_queued_urb(struct urb *urb, 413 struct usb_wwan_port_private *portdata) 414 { 415 int i; 416 417 for (i = 0; i < N_OUT_URB; i++) { 418 if (urb == portdata->out_urbs[i]) { 419 clear_bit(i, &portdata->out_busy); 420 break; 421 } 422 } 423 } 424 425 void usb_wwan_close(struct usb_serial_port *port) 426 { 427 int i; 428 struct usb_serial *serial = port->serial; 429 struct usb_wwan_port_private *portdata; 430 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial); 431 struct urb *urb; 432 433 portdata = usb_get_serial_port_data(port); 434 435 /* 436 * Need to take susp_lock to make sure port is not already being 437 * resumed, but no need to hold it due to initialized 438 */ 439 spin_lock_irq(&intfdata->susp_lock); 440 if (--intfdata->open_ports == 0) 441 serial->interface->needs_remote_wakeup = 0; 442 spin_unlock_irq(&intfdata->susp_lock); 443 444 for (;;) { 445 urb = usb_get_from_anchor(&portdata->delayed); 446 if (!urb) 447 break; 448 unbusy_queued_urb(urb, portdata); 449 usb_autopm_put_interface_async(serial->interface); 450 } 451 452 for (i = 0; i < N_IN_URB; i++) 453 usb_kill_urb(portdata->in_urbs[i]); 454 for (i = 0; i < N_OUT_URB; i++) 455 usb_kill_urb(portdata->out_urbs[i]); 456 usb_kill_urb(port->interrupt_in_urb); 457 458 usb_autopm_get_interface_no_resume(serial->interface); 459 } 460 EXPORT_SYMBOL(usb_wwan_close); 461 462 static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port, 463 int endpoint, 464 int dir, void *ctx, char *buf, int len, 465 void (*callback) (struct urb *)) 466 { 467 struct usb_serial *serial = port->serial; 468 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial); 469 struct urb *urb; 470 471 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */ 472 if (!urb) 473 return NULL; 474 475 usb_fill_bulk_urb(urb, serial->dev, 476 usb_sndbulkpipe(serial->dev, endpoint) | dir, 477 buf, len, callback, ctx); 478 479 if (intfdata->use_zlp && dir == USB_DIR_OUT) 480 urb->transfer_flags |= URB_ZERO_PACKET; 481 482 return urb; 483 } 484 485 int usb_wwan_port_probe(struct usb_serial_port *port) 486 { 487 struct usb_wwan_port_private *portdata; 488 struct urb *urb; 489 u8 *buffer; 490 int i; 491 492 if (!port->bulk_in_size || !port->bulk_out_size) 493 return -ENODEV; 494 495 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); 496 if (!portdata) 497 return -ENOMEM; 498 499 init_usb_anchor(&portdata->delayed); 500 501 for (i = 0; i < N_IN_URB; i++) { 502 buffer = (u8 *)__get_free_page(GFP_KERNEL); 503 if (!buffer) 504 goto bail_out_error; 505 portdata->in_buffer[i] = buffer; 506 507 urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress, 508 USB_DIR_IN, port, 509 buffer, IN_BUFLEN, 510 usb_wwan_indat_callback); 511 portdata->in_urbs[i] = urb; 512 } 513 514 for (i = 0; i < N_OUT_URB; i++) { 515 buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL); 516 if (!buffer) 517 goto bail_out_error2; 518 portdata->out_buffer[i] = buffer; 519 520 urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress, 521 USB_DIR_OUT, port, 522 buffer, OUT_BUFLEN, 523 usb_wwan_outdat_callback); 524 portdata->out_urbs[i] = urb; 525 } 526 527 usb_set_serial_port_data(port, portdata); 528 529 return 0; 530 531 bail_out_error2: 532 for (i = 0; i < N_OUT_URB; i++) { 533 usb_free_urb(portdata->out_urbs[i]); 534 kfree(portdata->out_buffer[i]); 535 } 536 bail_out_error: 537 for (i = 0; i < N_IN_URB; i++) { 538 usb_free_urb(portdata->in_urbs[i]); 539 free_page((unsigned long)portdata->in_buffer[i]); 540 } 541 kfree(portdata); 542 543 return -ENOMEM; 544 } 545 EXPORT_SYMBOL_GPL(usb_wwan_port_probe); 546 547 int usb_wwan_port_remove(struct usb_serial_port *port) 548 { 549 int i; 550 struct usb_wwan_port_private *portdata; 551 552 portdata = usb_get_serial_port_data(port); 553 usb_set_serial_port_data(port, NULL); 554 555 for (i = 0; i < N_IN_URB; i++) { 556 usb_free_urb(portdata->in_urbs[i]); 557 free_page((unsigned long)portdata->in_buffer[i]); 558 } 559 for (i = 0; i < N_OUT_URB; i++) { 560 usb_free_urb(portdata->out_urbs[i]); 561 kfree(portdata->out_buffer[i]); 562 } 563 564 kfree(portdata); 565 566 return 0; 567 } 568 EXPORT_SYMBOL(usb_wwan_port_remove); 569 570 #ifdef CONFIG_PM 571 static void stop_urbs(struct usb_serial *serial) 572 { 573 int i, j; 574 struct usb_serial_port *port; 575 struct usb_wwan_port_private *portdata; 576 577 for (i = 0; i < serial->num_ports; ++i) { 578 port = serial->port[i]; 579 portdata = usb_get_serial_port_data(port); 580 if (!portdata) 581 continue; 582 for (j = 0; j < N_IN_URB; j++) 583 usb_kill_urb(portdata->in_urbs[j]); 584 for (j = 0; j < N_OUT_URB; j++) 585 usb_kill_urb(portdata->out_urbs[j]); 586 usb_kill_urb(port->interrupt_in_urb); 587 } 588 } 589 590 int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message) 591 { 592 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial); 593 594 spin_lock_irq(&intfdata->susp_lock); 595 if (PMSG_IS_AUTO(message)) { 596 if (intfdata->in_flight) { 597 spin_unlock_irq(&intfdata->susp_lock); 598 return -EBUSY; 599 } 600 } 601 intfdata->suspended = 1; 602 spin_unlock_irq(&intfdata->susp_lock); 603 604 stop_urbs(serial); 605 606 return 0; 607 } 608 EXPORT_SYMBOL(usb_wwan_suspend); 609 610 /* Caller must hold susp_lock. */ 611 static int usb_wwan_submit_delayed_urbs(struct usb_serial_port *port) 612 { 613 struct usb_serial *serial = port->serial; 614 struct usb_wwan_intf_private *data = usb_get_serial_data(serial); 615 struct usb_wwan_port_private *portdata; 616 struct urb *urb; 617 int err_count = 0; 618 int err; 619 620 portdata = usb_get_serial_port_data(port); 621 622 for (;;) { 623 urb = usb_get_from_anchor(&portdata->delayed); 624 if (!urb) 625 break; 626 627 err = usb_submit_urb(urb, GFP_ATOMIC); 628 if (err) { 629 dev_err(&port->dev, "%s: submit urb failed: %d\n", 630 __func__, err); 631 err_count++; 632 unbusy_queued_urb(urb, portdata); 633 usb_autopm_put_interface_async(serial->interface); 634 continue; 635 } 636 data->in_flight++; 637 } 638 639 if (err_count) 640 return -EIO; 641 642 return 0; 643 } 644 645 int usb_wwan_resume(struct usb_serial *serial) 646 { 647 int i, j; 648 struct usb_serial_port *port; 649 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial); 650 struct usb_wwan_port_private *portdata; 651 struct urb *urb; 652 int err; 653 int err_count = 0; 654 655 spin_lock_irq(&intfdata->susp_lock); 656 for (i = 0; i < serial->num_ports; i++) { 657 port = serial->port[i]; 658 659 if (!tty_port_initialized(&port->port)) 660 continue; 661 662 portdata = usb_get_serial_port_data(port); 663 664 if (port->interrupt_in_urb) { 665 err = usb_submit_urb(port->interrupt_in_urb, 666 GFP_ATOMIC); 667 if (err) { 668 dev_err(&port->dev, 669 "%s: submit int urb failed: %d\n", 670 __func__, err); 671 err_count++; 672 } 673 } 674 675 err = usb_wwan_submit_delayed_urbs(port); 676 if (err) 677 err_count++; 678 679 for (j = 0; j < N_IN_URB; j++) { 680 urb = portdata->in_urbs[j]; 681 err = usb_submit_urb(urb, GFP_ATOMIC); 682 if (err < 0) { 683 dev_err(&port->dev, 684 "%s: submit read urb %d failed: %d\n", 685 __func__, i, err); 686 err_count++; 687 } 688 } 689 } 690 intfdata->suspended = 0; 691 spin_unlock_irq(&intfdata->susp_lock); 692 693 if (err_count) 694 return -EIO; 695 696 return 0; 697 } 698 EXPORT_SYMBOL(usb_wwan_resume); 699 #endif 700 701 MODULE_AUTHOR(DRIVER_AUTHOR); 702 MODULE_DESCRIPTION(DRIVER_DESC); 703 MODULE_LICENSE("GPL v2"); 704