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