drivers/usb/serial/generic.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * USB Serial Converter Generic functions
   4  *
   5  * Copyright (C) 2010 - 2013 Johan Hovold ([email protected])
   6  * Copyright (C) 1999 - 2002 Greg Kroah-Hartman ([email protected])
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/sched/signal.h>
  11 #include <linux/errno.h>
  12 #include <linux/slab.h>
  13 #include <linux/sysrq.h>
  14 #include <linux/tty.h>
  15 #include <linux/tty_flip.h>
  16 #include <linux/module.h>
  17 #include <linux/moduleparam.h>
  18 #include <linux/usb.h>
  19 #include <linux/usb/serial.h>
  20 #include <linux/uaccess.h>
  21 #include <linux/kfifo.h>
  22 #include <linux/serial.h>
  23
  24 #ifdef CONFIG_USB_SERIAL_GENERIC
  25
  26 static __u16 vendor  = 0x05f9;
  27 static __u16 product = 0xffff;
  28
  29 module_param(vendor, ushort, 0);
  30 MODULE_PARM_DESC(vendor, "User specified USB idVendor");
  31
  32 module_param(product, ushort, 0);
  33 MODULE_PARM_DESC(product, "User specified USB idProduct");
  34
  35 static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */
  36
  37 static int usb_serial_generic_probe(struct usb_serial *serial,
  38                                         const struct usb_device_id *id)
  39 {
  40         struct device *dev = &serial->interface->dev;
  41
  42         dev_info(dev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
  43         dev_info(dev, "Tell [email protected] to add your device to a proper driver.\n");
  44
  45         return 0;
  46 }
  47
  48 static int usb_serial_generic_calc_num_ports(struct usb_serial *serial,
  49                                         struct usb_serial_endpoints *epds)
  50 {
  51         struct device *dev = &serial->interface->dev;
  52         int num_ports;
  53
  54         num_ports = max(epds->num_bulk_in, epds->num_bulk_out);
  55
  56         if (num_ports == 0) {
  57                 dev_err(dev, "device has no bulk endpoints\n");
  58                 return -ENODEV;
  59         }
  60
  61         return num_ports;
  62 }
  63
  64 static struct usb_serial_driver usb_serial_generic_device = {
  65         .driver = {
  66                 .owner =        THIS_MODULE,
  67                 .name =         "generic",
  68         },
  69         .id_table =             generic_device_ids,
  70         .probe =                usb_serial_generic_probe,
  71         .calc_num_ports =       usb_serial_generic_calc_num_ports,
  72         .throttle =             usb_serial_generic_throttle,
  73         .unthrottle =           usb_serial_generic_unthrottle,
  74         .resume =               usb_serial_generic_resume,
  75 };
  76
  77 static struct usb_serial_driver * const serial_drivers[] = {
  78         &usb_serial_generic_device, NULL
  79 };
  80
  81 #endif
  82
  83 int usb_serial_generic_register(void)
  84 {
  85         int retval = 0;
  86
  87 #ifdef CONFIG_USB_SERIAL_GENERIC
  88         generic_device_ids[0].idVendor = vendor;
  89         generic_device_ids[0].idProduct = product;
  90         generic_device_ids[0].match_flags =
  91                 USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT;
  92
  93         retval = usb_serial_register_drivers(serial_drivers,
  94                         "usbserial_generic", generic_device_ids);
  95 #endif
  96         return retval;
  97 }
  98
  99 void usb_serial_generic_deregister(void)
 100 {
 101 #ifdef CONFIG_USB_SERIAL_GENERIC
 102         usb_serial_deregister_drivers(serial_drivers);
 103 #endif
 104 }
 105
 106 int usb_serial_generic_open(struct tty_struct *tty, struct usb_serial_port *port)
 107 {
 108         int result = 0;
 109
 110         clear_bit(USB_SERIAL_THROTTLED, &port->flags);
 111
 112         if (port->bulk_in_size)
 113                 result = usb_serial_generic_submit_read_urbs(port, GFP_KERNEL);
 114
 115         return result;
 116 }
 117 EXPORT_SYMBOL_GPL(usb_serial_generic_open);
 118
 119 void usb_serial_generic_close(struct usb_serial_port *port)
 120 {
 121         unsigned long flags;
 122         int i;
 123
 124         if (port->bulk_out_size) {
 125                 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
 126                         usb_kill_urb(port->write_urbs[i]);
 127
 128                 spin_lock_irqsave(&port->lock, flags);
 129                 kfifo_reset_out(&port->write_fifo);
 130                 spin_unlock_irqrestore(&port->lock, flags);
 131         }
 132         if (port->bulk_in_size) {
 133                 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
 134                         usb_kill_urb(port->read_urbs[i]);
 135         }
 136 }
 137 EXPORT_SYMBOL_GPL(usb_serial_generic_close);
 138
 139 int usb_serial_generic_prepare_write_buffer(struct usb_serial_port *port,
 140                                                 void *dest, size_t size)
 141 {
 142         return kfifo_out_locked(&port->write_fifo, dest, size, &port->lock);
 143 }
 144
 145 /**
 146  * usb_serial_generic_write_start - start writing buffered data
 147  * @port: usb-serial port
 148  * @mem_flags: flags to use for memory allocations
 149  *
 150  * Serialised using USB_SERIAL_WRITE_BUSY flag.
 151  *
 152  * Return: Zero on success or if busy, otherwise a negative errno value.
 153  */
 154 int usb_serial_generic_write_start(struct usb_serial_port *port,
 155                                                         gfp_t mem_flags)
 156 {
 157         struct urb *urb;
 158         int count, result;
 159         unsigned long flags;
 160         int i;
 161
 162         if (test_and_set_bit_lock(USB_SERIAL_WRITE_BUSY, &port->flags))
 163                 return 0;
 164 retry:
 165         spin_lock_irqsave(&port->lock, flags);
 166         if (!port->write_urbs_free || !kfifo_len(&port->write_fifo)) {
 167                 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
 168                 spin_unlock_irqrestore(&port->lock, flags);
 169                 return 0;
 170         }
 171         i = (int)find_first_bit(&port->write_urbs_free,
 172                                                 ARRAY_SIZE(port->write_urbs));
 173         spin_unlock_irqrestore(&port->lock, flags);
 174
 175         urb = port->write_urbs[i];
 176         count = port->serial->type->prepare_write_buffer(port,
 177                                                 urb->transfer_buffer,
 178                                                 port->bulk_out_size);
 179         urb->transfer_buffer_length = count;
 180         usb_serial_debug_data(&port->dev, __func__, count, urb->transfer_buffer);
 181         spin_lock_irqsave(&port->lock, flags);
 182         port->tx_bytes += count;
 183         spin_unlock_irqrestore(&port->lock, flags);
 184
 185         clear_bit(i, &port->write_urbs_free);
 186         result = usb_submit_urb(urb, mem_flags);
 187         if (result) {
 188                 dev_err_console(port, "%s - error submitting urb: %d\n",
 189                                                 __func__, result);
 190                 set_bit(i, &port->write_urbs_free);
 191                 spin_lock_irqsave(&port->lock, flags);
 192                 port->tx_bytes -= count;
 193                 spin_unlock_irqrestore(&port->lock, flags);
 194
 195                 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
 196                 return result;
 197         }
 198
 199         goto retry;     /* try sending off another urb */
 200 }
 201 EXPORT_SYMBOL_GPL(usb_serial_generic_write_start);
 202
 203 /**
 204  * usb_serial_generic_write - generic write function
 205  * @tty: tty for the port
 206  * @port: usb-serial port
 207  * @buf: data to write
 208  * @count: number of bytes to write
 209  *
 210  * Return: The number of characters buffered, which may be anything from
 211  * zero to @count, or a negative errno value.
 212  */
 213 int usb_serial_generic_write(struct tty_struct *tty,
 214         struct usb_serial_port *port, const unsigned char *buf, int count)
 215 {
 216         int result;
 217
 218         if (!port->bulk_out_size)
 219                 return -ENODEV;
 220
 221         if (!count)
 222                 return 0;
 223
 224         count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
 225         result = usb_serial_generic_write_start(port, GFP_ATOMIC);
 226         if (result)
 227                 return result;
 228
 229         return count;
 230 }
 231 EXPORT_SYMBOL_GPL(usb_serial_generic_write);
 232
 233 unsigned int usb_serial_generic_write_room(struct tty_struct *tty)
 234 {
 235         struct usb_serial_port *port = tty->driver_data;
 236         unsigned long flags;
 237         unsigned int room;
 238
 239         if (!port->bulk_out_size)
 240                 return 0;
 241
 242         spin_lock_irqsave(&port->lock, flags);
 243         room = kfifo_avail(&port->write_fifo);
 244         spin_unlock_irqrestore(&port->lock, flags);
 245
 246         dev_dbg(&port->dev, "%s - returns %u\n", __func__, room);
 247         return room;
 248 }
 249
 250 unsigned int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
 251 {
 252         struct usb_serial_port *port = tty->driver_data;
 253         unsigned long flags;
 254         unsigned int chars;
 255
 256         if (!port->bulk_out_size)
 257                 return 0;
 258
 259         spin_lock_irqsave(&port->lock, flags);
 260         chars = kfifo_len(&port->write_fifo) + port->tx_bytes;
 261         spin_unlock_irqrestore(&port->lock, flags);
 262
 263         dev_dbg(&port->dev, "%s - returns %u\n", __func__, chars);
 264         return chars;
 265 }
 266 EXPORT_SYMBOL_GPL(usb_serial_generic_chars_in_buffer);
 267
 268 void usb_serial_generic_wait_until_sent(struct tty_struct *tty, long timeout)
 269 {
 270         struct usb_serial_port *port = tty->driver_data;
 271         unsigned int bps;
 272         unsigned long period;
 273         unsigned long expire;
 274
 275         bps = tty_get_baud_rate(tty);
 276         if (!bps)
 277                 bps = 9600;     /* B0 */
 278         /*
 279          * Use a poll-period of roughly the time it takes to send one
 280          * character or at least one jiffy.
 281          */
 282         period = max_t(unsigned long, (10 * HZ / bps), 1);
 283         if (timeout)
 284                 period = min_t(unsigned long, period, timeout);
 285
 286         dev_dbg(&port->dev, "%s - timeout = %u ms, period = %u ms\n",
 287                                         __func__, jiffies_to_msecs(timeout),
 288                                         jiffies_to_msecs(period));
 289         expire = jiffies + timeout;
 290         while (!port->serial->type->tx_empty(port)) {
 291                 schedule_timeout_interruptible(period);
 292                 if (signal_pending(current))
 293                         break;
 294                 if (timeout && time_after(jiffies, expire))
 295                         break;
 296         }
 297 }
 298 EXPORT_SYMBOL_GPL(usb_serial_generic_wait_until_sent);
 299
 300 static int usb_serial_generic_submit_read_urb(struct usb_serial_port *port,
 301                                                 int index, gfp_t mem_flags)
 302 {
 303         int res;
 304
 305         if (!test_and_clear_bit(index, &port->read_urbs_free))
 306                 return 0;
 307
 308         dev_dbg(&port->dev, "%s - urb %d\n", __func__, index);
 309
 310         res = usb_submit_urb(port->read_urbs[index], mem_flags);
 311         if (res) {
 312                 if (res != -EPERM && res != -ENODEV) {
 313                         dev_err(&port->dev,
 314                                         "%s - usb_submit_urb failed: %d\n",
 315                                         __func__, res);
 316                 }
 317                 set_bit(index, &port->read_urbs_free);
 318                 return res;
 319         }
 320
 321         return 0;
 322 }
 323
 324 int usb_serial_generic_submit_read_urbs(struct usb_serial_port *port,
 325                                         gfp_t mem_flags)
 326 {
 327         int res;
 328         int i;
 329
 330         for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
 331                 res = usb_serial_generic_submit_read_urb(port, i, mem_flags);
 332                 if (res)
 333                         goto err;
 334         }
 335
 336         return 0;
 337 err:
 338         for (; i >= 0; --i)
 339                 usb_kill_urb(port->read_urbs[i]);
 340
 341         return res;
 342 }
 343 EXPORT_SYMBOL_GPL(usb_serial_generic_submit_read_urbs);
 344
 345 void usb_serial_generic_process_read_urb(struct urb *urb)
 346 {
 347         struct usb_serial_port *port = urb->context;
 348         char *ch = urb->transfer_buffer;
 349         int i;
 350
 351         if (!urb->actual_length)
 352                 return;
 353         /*
 354          * The per character mucking around with sysrq path it too slow for
 355          * stuff like 3G modems, so shortcircuit it in the 99.9999999% of
 356          * cases where the USB serial is not a console anyway.
 357          */
 358         if (port->sysrq) {
 359                 for (i = 0; i < urb->actual_length; i++, ch++) {
 360                         if (!usb_serial_handle_sysrq_char(port, *ch))
 361                                 tty_insert_flip_char(&port->port, *ch, TTY_NORMAL);
 362                 }
 363         } else {
 364                 tty_insert_flip_string(&port->port, ch, urb->actual_length);
 365         }
 366         tty_flip_buffer_push(&port->port);
 367 }
 368 EXPORT_SYMBOL_GPL(usb_serial_generic_process_read_urb);
 369
 370 void usb_serial_generic_read_bulk_callback(struct urb *urb)
 371 {
 372         struct usb_serial_port *port = urb->context;
 373         unsigned char *data = urb->transfer_buffer;
 374         bool stopped = false;
 375         int status = urb->status;
 376         int i;
 377
 378         for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
 379                 if (urb == port->read_urbs[i])
 380                         break;
 381         }
 382
 383         dev_dbg(&port->dev, "%s - urb %d, len %d\n", __func__, i,
 384                                                         urb->actual_length);
 385         switch (status) {
 386         case 0:
 387                 usb_serial_debug_data(&port->dev, __func__, urb->actual_length,
 388                                                         data);
 389                 port->serial->type->process_read_urb(urb);
 390                 break;
 391         case -ENOENT:
 392         case -ECONNRESET:
 393         case -ESHUTDOWN:
 394                 dev_dbg(&port->dev, "%s - urb stopped: %d\n",
 395                                                         __func__, status);
 396                 stopped = true;
 397                 break;
 398         case -EPIPE:
 399                 dev_err(&port->dev, "%s - urb stopped: %d\n",
 400                                                         __func__, status);
 401                 stopped = true;
 402                 break;
 403         default:
 404                 dev_dbg(&port->dev, "%s - nonzero urb status: %d\n",
 405                                                         __func__, status);
 406                 break;
 407         }
 408
 409         /*
 410          * Make sure URB processing is done before marking as free to avoid
 411          * racing with unthrottle() on another CPU. Matches the barriers
 412          * implied by the test_and_clear_bit() in
 413          * usb_serial_generic_submit_read_urb().
 414          */
 415         smp_mb__before_atomic();
 416         set_bit(i, &port->read_urbs_free);
 417         /*
 418          * Make sure URB is marked as free before checking the throttled flag
 419          * to avoid racing with unthrottle() on another CPU. Matches the
 420          * smp_mb__after_atomic() in unthrottle().
 421          */
 422         smp_mb__after_atomic();
 423
 424         if (stopped)
 425                 return;
 426
 427         if (test_bit(USB_SERIAL_THROTTLED, &port->flags))
 428                 return;
 429
 430         usb_serial_generic_submit_read_urb(port, i, GFP_ATOMIC);
 431 }
 432 EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback);
 433
 434 void usb_serial_generic_write_bulk_callback(struct urb *urb)
 435 {
 436         unsigned long flags;
 437         struct usb_serial_port *port = urb->context;
 438         int status = urb->status;
 439         int i;
 440
 441         for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
 442                 if (port->write_urbs[i] == urb)
 443                         break;
 444         }
 445         spin_lock_irqsave(&port->lock, flags);
 446         port->tx_bytes -= urb->transfer_buffer_length;
 447         set_bit(i, &port->write_urbs_free);
 448         spin_unlock_irqrestore(&port->lock, flags);
 449
 450         switch (status) {
 451         case 0:
 452                 break;
 453         case -ENOENT:
 454         case -ECONNRESET:
 455         case -ESHUTDOWN:
 456                 dev_dbg(&port->dev, "%s - urb stopped: %d\n",
 457                                                         __func__, status);
 458                 return;
 459         case -EPIPE:
 460                 dev_err_console(port, "%s - urb stopped: %d\n",
 461                                                         __func__, status);
 462                 return;
 463         default:
 464                 dev_err_console(port, "%s - nonzero urb status: %d\n",
 465                                                         __func__, status);
 466                 break;
 467         }
 468
 469         usb_serial_generic_write_start(port, GFP_ATOMIC);
 470         usb_serial_port_softint(port);
 471 }
 472 EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);
 473
 474 void usb_serial_generic_throttle(struct tty_struct *tty)
 475 {
 476         struct usb_serial_port *port = tty->driver_data;
 477
 478         set_bit(USB_SERIAL_THROTTLED, &port->flags);
 479 }
 480 EXPORT_SYMBOL_GPL(usb_serial_generic_throttle);
 481
 482 void usb_serial_generic_unthrottle(struct tty_struct *tty)
 483 {
 484         struct usb_serial_port *port = tty->driver_data;
 485
 486         clear_bit(USB_SERIAL_THROTTLED, &port->flags);
 487
 488         /*
 489          * Matches the smp_mb__after_atomic() in
 490          * usb_serial_generic_read_bulk_callback().
 491          */
 492         smp_mb__after_atomic();
 493
 494         usb_serial_generic_submit_read_urbs(port, GFP_KERNEL);
 495 }
 496 EXPORT_SYMBOL_GPL(usb_serial_generic_unthrottle);
 497
 498 static bool usb_serial_generic_msr_changed(struct tty_struct *tty,
 499                                 unsigned long arg, struct async_icount *cprev)
 500 {
 501         struct usb_serial_port *port = tty->driver_data;
 502         struct async_icount cnow;
 503         unsigned long flags;
 504         bool ret;
 505
 506         /*
 507          * Use tty-port initialised flag to detect all hangups including the
 508          * one generated at USB-device disconnect.
 509          */
 510         if (!tty_port_initialized(&port->port))
 511                 return true;
 512
 513         spin_lock_irqsave(&port->lock, flags);
 514         cnow = port->icount;                            /* atomic copy*/
 515         spin_unlock_irqrestore(&port->lock, flags);
 516
 517         ret =   ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
 518                 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
 519                 ((arg & TIOCM_CD)  && (cnow.dcd != cprev->dcd)) ||
 520                 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
 521
 522         *cprev = cnow;
 523
 524         return ret;
 525 }
 526
 527 int usb_serial_generic_tiocmiwait(struct tty_struct *tty, unsigned long arg)
 528 {
 529         struct usb_serial_port *port = tty->driver_data;
 530         struct async_icount cnow;
 531         unsigned long flags;
 532         int ret;
 533
 534         spin_lock_irqsave(&port->lock, flags);
 535         cnow = port->icount;                            /* atomic copy */
 536         spin_unlock_irqrestore(&port->lock, flags);
 537
 538         ret = wait_event_interruptible(port->port.delta_msr_wait,
 539                         usb_serial_generic_msr_changed(tty, arg, &cnow));
 540         if (!ret && !tty_port_initialized(&port->port))
 541                 ret = -EIO;
 542
 543         return ret;
 544 }
 545 EXPORT_SYMBOL_GPL(usb_serial_generic_tiocmiwait);
 546
 547 int usb_serial_generic_get_icount(struct tty_struct *tty,
 548                                         struct serial_icounter_struct *icount)
 549 {
 550         struct usb_serial_port *port = tty->driver_data;
 551         struct async_icount cnow;
 552         unsigned long flags;
 553
 554         spin_lock_irqsave(&port->lock, flags);
 555         cnow = port->icount;                            /* atomic copy */
 556         spin_unlock_irqrestore(&port->lock, flags);
 557
 558         icount->cts = cnow.cts;
 559         icount->dsr = cnow.dsr;
 560         icount->rng = cnow.rng;
 561         icount->dcd = cnow.dcd;
 562         icount->tx = cnow.tx;
 563         icount->rx = cnow.rx;
 564         icount->frame = cnow.frame;
 565         icount->parity = cnow.parity;
 566         icount->overrun = cnow.overrun;
 567         icount->brk = cnow.brk;
 568         icount->buf_overrun = cnow.buf_overrun;
 569
 570         return 0;
 571 }
 572 EXPORT_SYMBOL_GPL(usb_serial_generic_get_icount);
 573
 574 #if defined(CONFIG_USB_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
 575 int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch)
 576 {
 577         if (port->sysrq) {
 578                 if (ch && time_before(jiffies, port->sysrq)) {
 579                         handle_sysrq(ch);
 580                         port->sysrq = 0;
 581                         return 1;
 582                 }
 583                 port->sysrq = 0;
 584         }
 585         return 0;
 586 }
 587 EXPORT_SYMBOL_GPL(usb_serial_handle_sysrq_char);
 588
 589 int usb_serial_handle_break(struct usb_serial_port *port)
 590 {
 591         if (!port->port.console)
 592                 return 0;
 593
 594         if (!port->sysrq) {
 595                 port->sysrq = jiffies + HZ*5;
 596                 return 1;
 597         }
 598         port->sysrq = 0;
 599         return 0;
 600 }
 601 EXPORT_SYMBOL_GPL(usb_serial_handle_break);
 602 #endif
 603
 604 /**
 605  * usb_serial_handle_dcd_change - handle a change of carrier detect state
 606  * @port: usb-serial port
 607  * @tty: tty for the port
 608  * @status: new carrier detect status, nonzero if active
 609  */
 610 void usb_serial_handle_dcd_change(struct usb_serial_port *port,
 611                                 struct tty_struct *tty, unsigned int status)
 612 {
 613         dev_dbg(&port->dev, "%s - status %d\n", __func__, status);
 614
 615         if (tty) {
 616                 struct tty_ldisc *ld = tty_ldisc_ref(tty);
 617
 618                 if (ld) {
 619                         if (ld->ops->dcd_change)
 620                                 ld->ops->dcd_change(tty, status);
 621                         tty_ldisc_deref(ld);
 622                 }
 623         }
 624
 625         if (status)
 626                 wake_up_interruptible(&port->port.open_wait);
 627         else if (tty && !C_CLOCAL(tty))
 628                 tty_hangup(tty);
 629 }
 630 EXPORT_SYMBOL_GPL(usb_serial_handle_dcd_change);
 631
 632 int usb_serial_generic_resume(struct usb_serial *serial)
 633 {
 634         struct usb_serial_port *port;
 635         int i, c = 0, r;
 636
 637         for (i = 0; i < serial->num_ports; i++) {
 638                 port = serial->port[i];
 639                 if (!tty_port_initialized(&port->port))
 640                         continue;
 641
 642                 if (port->bulk_in_size) {
 643                         r = usb_serial_generic_submit_read_urbs(port,
 644                                                                 GFP_NOIO);
 645                         if (r < 0)
 646                                 c++;
 647                 }
 648
 649                 if (port->bulk_out_size) {
 650                         r = usb_serial_generic_write_start(port, GFP_NOIO);
 651                         if (r < 0)
 652                                 c++;
 653                 }
 654         }
 655
 656         return c ? -EIO : 0;
 657 }
 658 EXPORT_SYMBOL_GPL(usb_serial_generic_resume);