drivers/usb/gadget/function/u_serial.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * u_serial.c - utilities for USB gadget "serial port"/TTY support
   4  *
   5  * Copyright (C) 2003 Al Borchers ([email protected])
   6  * Copyright (C) 2008 David Brownell
   7  * Copyright (C) 2008 by Nokia Corporation
   8  *
   9  * This code also borrows from usbserial.c, which is
  10  * Copyright (C) 1999 - 2002 Greg Kroah-Hartman ([email protected])
  11  * Copyright (C) 2000 Peter Berger ([email protected])
  12  * Copyright (C) 2000 Al Borchers ([email protected])
  13  */
  14
  15 /* #define VERBOSE_DEBUG */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/sched.h>
  19 #include <linux/device.h>
  20 #include <linux/delay.h>
  21 #include <linux/tty.h>
  22 #include <linux/tty_flip.h>
  23 #include <linux/slab.h>
  24 #include <linux/export.h>
  25 #include <linux/module.h>
  26 #include <linux/console.h>
  27 #include <linux/kstrtox.h>
  28 #include <linux/kthread.h>
  29 #include <linux/workqueue.h>
  30 #include <linux/kfifo.h>
  31 #include <linux/serial.h>
  32
  33 #include "u_serial.h"
  34
  35
  36 /*
  37  * This component encapsulates the TTY layer glue needed to provide basic
  38  * "serial port" functionality through the USB gadget stack.  Each such
  39  * port is exposed through a /dev/ttyGS* node.
  40  *
  41  * After this module has been loaded, the individual TTY port can be requested
  42  * (gserial_alloc_line()) and it will stay available until they are removed
  43  * (gserial_free_line()). Each one may be connected to a USB function
  44  * (gserial_connect), or disconnected (with gserial_disconnect) when the USB
  45  * host issues a config change event. Data can only flow when the port is
  46  * connected to the host.
  47  *
  48  * A given TTY port can be made available in multiple configurations.
  49  * For example, each one might expose a ttyGS0 node which provides a
  50  * login application.  In one case that might use CDC ACM interface 0,
  51  * while another configuration might use interface 3 for that.  The
  52  * work to handle that (including descriptor management) is not part
  53  * of this component.
  54  *
  55  * Configurations may expose more than one TTY port.  For example, if
  56  * ttyGS0 provides login service, then ttyGS1 might provide dialer access
  57  * for a telephone or fax link.  And ttyGS2 might be something that just
  58  * needs a simple byte stream interface for some messaging protocol that
  59  * is managed in userspace ... OBEX, PTP, and MTP have been mentioned.
  60  *
  61  *
  62  * gserial is the lifecycle interface, used by USB functions
  63  * gs_port is the I/O nexus, used by the tty driver
  64  * tty_struct links to the tty/filesystem framework
  65  *
  66  * gserial <---> gs_port ... links will be null when the USB link is
  67  * inactive; managed by gserial_{connect,disconnect}().  each gserial
  68  * instance can wrap its own USB control protocol.
  69  *      gserial->ioport == usb_ep->driver_data ... gs_port
  70  *      gs_port->port_usb ... gserial
  71  *
  72  * gs_port <---> tty_struct ... links will be null when the TTY file
  73  * isn't opened; managed by gs_open()/gs_close()
  74  *      gserial->port_tty ... tty_struct
  75  *      tty_struct->driver_data ... gserial
  76  */
  77
  78 /* RX and TX queues can buffer QUEUE_SIZE packets before they hit the
  79  * next layer of buffering.  For TX that's a circular buffer; for RX
  80  * consider it a NOP.  A third layer is provided by the TTY code.
  81  */
  82 #define QUEUE_SIZE              16
  83 #define WRITE_BUF_SIZE          8192            /* TX only */
  84 #define GS_CONSOLE_BUF_SIZE     8192
  85
  86 /* Prevents race conditions while accessing gser->ioport */
  87 static DEFINE_SPINLOCK(serial_port_lock);
  88
  89 /* console info */
  90 struct gs_console {
  91         struct console          console;
  92         struct work_struct      work;
  93         spinlock_t              lock;
  94         struct usb_request      *req;
  95         struct kfifo            buf;
  96         size_t                  missed;
  97 };
  98
  99 /*
 100  * The port structure holds info for each port, one for each minor number
 101  * (and thus for each /dev/ node).
 102  */
 103 struct gs_port {
 104         struct tty_port         port;
 105         spinlock_t              port_lock;      /* guard port_* access */
 106
 107         struct gserial          *port_usb;
 108 #ifdef CONFIG_U_SERIAL_CONSOLE
 109         struct gs_console       *console;
 110 #endif
 111
 112         u8                      port_num;
 113
 114         struct list_head        read_pool;
 115         int read_started;
 116         int read_allocated;
 117         struct list_head        read_queue;
 118         unsigned                n_read;
 119         struct delayed_work     push;
 120
 121         struct list_head        write_pool;
 122         int write_started;
 123         int write_allocated;
 124         struct kfifo            port_write_buf;
 125         wait_queue_head_t       drain_wait;     /* wait while writes drain */
 126         bool                    write_busy;
 127         wait_queue_head_t       close_wait;
 128         bool                    suspended;      /* port suspended */
 129         bool                    start_delayed;  /* delay start when suspended */
 130         struct async_icount     icount;
 131
 132         /* REVISIT this state ... */
 133         struct usb_cdc_line_coding port_line_coding;    /* 8-N-1 etc */
 134 };
 135
 136 static struct portmaster {
 137         struct mutex    lock;                   /* protect open/close */
 138         struct gs_port  *port;
 139 } ports[MAX_U_SERIAL_PORTS];
 140
 141 #define GS_CLOSE_TIMEOUT                15              /* seconds */
 142
 143
 144
 145 #ifdef VERBOSE_DEBUG
 146 #ifndef pr_vdebug
 147 #define pr_vdebug(fmt, arg...) \
 148         pr_debug(fmt, ##arg)
 149 #endif /* pr_vdebug */
 150 #else
 151 #ifndef pr_vdebug
 152 #define pr_vdebug(fmt, arg...) \
 153         ({ if (0) pr_debug(fmt, ##arg); })
 154 #endif /* pr_vdebug */
 155 #endif
 156
 157 /*-------------------------------------------------------------------------*/
 158
 159 /* I/O glue between TTY (upper) and USB function (lower) driver layers */
 160
 161 /*
 162  * gs_alloc_req
 163  *
 164  * Allocate a usb_request and its buffer.  Returns a pointer to the
 165  * usb_request or NULL if there is an error.
 166  */
 167 struct usb_request *
 168 gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
 169 {
 170         struct usb_request *req;
 171
 172         req = usb_ep_alloc_request(ep, kmalloc_flags);
 173
 174         if (req != NULL) {
 175                 req->length = len;
 176                 req->buf = kmalloc(len, kmalloc_flags);
 177                 if (req->buf == NULL) {
 178                         usb_ep_free_request(ep, req);
 179                         return NULL;
 180                 }
 181         }
 182
 183         return req;
 184 }
 185 EXPORT_SYMBOL_GPL(gs_alloc_req);
 186
 187 /*
 188  * gs_free_req
 189  *
 190  * Free a usb_request and its buffer.
 191  */
 192 void gs_free_req(struct usb_ep *ep, struct usb_request *req)
 193 {
 194         kfree(req->buf);
 195         usb_ep_free_request(ep, req);
 196 }
 197 EXPORT_SYMBOL_GPL(gs_free_req);
 198
 199 /*
 200  * gs_send_packet
 201  *
 202  * If there is data to send, a packet is built in the given
 203  * buffer and the size is returned.  If there is no data to
 204  * send, 0 is returned.
 205  *
 206  * Called with port_lock held.
 207  */
 208 static unsigned
 209 gs_send_packet(struct gs_port *port, char *packet, unsigned size)
 210 {
 211         unsigned len;
 212
 213         len = kfifo_len(&port->port_write_buf);
 214         if (len < size)
 215                 size = len;
 216         if (size != 0)
 217                 size = kfifo_out(&port->port_write_buf, packet, size);
 218         return size;
 219 }
 220
 221 /*
 222  * gs_start_tx
 223  *
 224  * This function finds available write requests, calls
 225  * gs_send_packet to fill these packets with data, and
 226  * continues until either there are no more write requests
 227  * available or no more data to send.  This function is
 228  * run whenever data arrives or write requests are available.
 229  *
 230  * Context: caller owns port_lock; port_usb is non-null.
 231  */
 232 static int gs_start_tx(struct gs_port *port)
 233 /*
 234 __releases(&port->port_lock)
 235 __acquires(&port->port_lock)
 236 */
 237 {
 238         struct list_head        *pool = &port->write_pool;
 239         struct usb_ep           *in;
 240         int                     status = 0;
 241         bool                    do_tty_wake = false;
 242
 243         if (!port->port_usb)
 244                 return status;
 245
 246         in = port->port_usb->in;
 247
 248         while (!port->write_busy && !list_empty(pool)) {
 249                 struct usb_request      *req;
 250                 int                     len;
 251
 252                 if (port->write_started >= QUEUE_SIZE)
 253                         break;
 254
 255                 req = list_entry(pool->next, struct usb_request, list);
 256                 len = gs_send_packet(port, req->buf, in->maxpacket);
 257                 if (len == 0) {
 258                         wake_up_interruptible(&port->drain_wait);
 259                         break;
 260                 }
 261                 do_tty_wake = true;
 262                 port->icount.tx += len;
 263
 264                 req->length = len;
 265                 list_del(&req->list);
 266                 req->zero = kfifo_is_empty(&port->port_write_buf);
 267
 268                 pr_vdebug("ttyGS%d: tx len=%d, %3ph ...\n", port->port_num, len, req->buf);
 269
 270                 /* Drop lock while we call out of driver; completions
 271                  * could be issued while we do so.  Disconnection may
 272                  * happen too; maybe immediately before we queue this!
 273                  *
 274                  * NOTE that we may keep sending data for a while after
 275                  * the TTY closed (dev->ioport->port_tty is NULL).
 276                  */
 277                 port->write_busy = true;
 278                 spin_unlock(&port->port_lock);
 279                 status = usb_ep_queue(in, req, GFP_ATOMIC);
 280                 spin_lock(&port->port_lock);
 281                 port->write_busy = false;
 282
 283                 if (status) {
 284                         pr_debug("%s: %s %s err %d\n",
 285                                         __func__, "queue", in->name, status);
 286                         list_add(&req->list, pool);
 287                         break;
 288                 }
 289
 290                 port->write_started++;
 291
 292                 /* abort immediately after disconnect */
 293                 if (!port->port_usb)
 294                         break;
 295         }
 296
 297         if (do_tty_wake && port->port.tty)
 298                 tty_wakeup(port->port.tty);
 299         return status;
 300 }
 301
 302 /*
 303  * Context: caller owns port_lock, and port_usb is set
 304  */
 305 static unsigned gs_start_rx(struct gs_port *port)
 306 /*
 307 __releases(&port->port_lock)
 308 __acquires(&port->port_lock)
 309 */
 310 {
 311         struct list_head        *pool = &port->read_pool;
 312         struct usb_ep           *out = port->port_usb->out;
 313
 314         while (!list_empty(pool)) {
 315                 struct usb_request      *req;
 316                 int                     status;
 317                 struct tty_struct       *tty;
 318
 319                 /* no more rx if closed */
 320                 tty = port->port.tty;
 321                 if (!tty)
 322                         break;
 323
 324                 if (port->read_started >= QUEUE_SIZE)
 325                         break;
 326
 327                 req = list_entry(pool->next, struct usb_request, list);
 328                 list_del(&req->list);
 329                 req->length = out->maxpacket;
 330
 331                 /* drop lock while we call out; the controller driver
 332                  * may need to call us back (e.g. for disconnect)
 333                  */
 334                 spin_unlock(&port->port_lock);
 335                 status = usb_ep_queue(out, req, GFP_ATOMIC);
 336                 spin_lock(&port->port_lock);
 337
 338                 if (status) {
 339                         pr_debug("%s: %s %s err %d\n",
 340                                         __func__, "queue", out->name, status);
 341                         list_add(&req->list, pool);
 342                         break;
 343                 }
 344                 port->read_started++;
 345
 346                 /* abort immediately after disconnect */
 347                 if (!port->port_usb)
 348                         break;
 349         }
 350         return port->read_started;
 351 }
 352
 353 /*
 354  * RX work takes data out of the RX queue and hands it up to the TTY
 355  * layer until it refuses to take any more data (or is throttled back).
 356  * Then it issues reads for any further data.
 357  *
 358  * If the RX queue becomes full enough that no usb_request is queued,
 359  * the OUT endpoint may begin NAKing as soon as its FIFO fills up.
 360  * So QUEUE_SIZE packets plus however many the FIFO holds (usually two)
 361  * can be buffered before the TTY layer's buffers (currently 64 KB).
 362  */
 363 static void gs_rx_push(struct work_struct *work)
 364 {
 365         struct delayed_work     *w = to_delayed_work(work);
 366         struct gs_port          *port = container_of(w, struct gs_port, push);
 367         struct tty_struct       *tty;
 368         struct list_head        *queue = &port->read_queue;
 369         bool                    disconnect = false;
 370         bool                    do_push = false;
 371
 372         /* hand any queued data to the tty */
 373         spin_lock_irq(&port->port_lock);
 374         tty = port->port.tty;
 375         while (!list_empty(queue)) {
 376                 struct usb_request      *req;
 377
 378                 req = list_first_entry(queue, struct usb_request, list);
 379
 380                 /* leave data queued if tty was rx throttled */
 381                 if (tty && tty_throttled(tty))
 382                         break;
 383
 384                 switch (req->status) {
 385                 case -ESHUTDOWN:
 386                         disconnect = true;
 387                         pr_vdebug("ttyGS%d: shutdown\n", port->port_num);
 388                         break;
 389
 390                 default:
 391                         /* presumably a transient fault */
 392                         pr_warn("ttyGS%d: unexpected RX status %d\n",
 393                                 port->port_num, req->status);
 394                         fallthrough;
 395                 case 0:
 396                         /* normal completion */
 397                         break;
 398                 }
 399
 400                 /* push data to (open) tty */
 401                 if (req->actual && tty) {
 402                         char            *packet = req->buf;
 403                         unsigned        size = req->actual;
 404                         unsigned        n;
 405                         int             count;
 406
 407                         /* we may have pushed part of this packet already... */
 408                         n = port->n_read;
 409                         if (n) {
 410                                 packet += n;
 411                                 size -= n;
 412                         }
 413
 414                         port->icount.rx += size;
 415                         count = tty_insert_flip_string(&port->port, packet,
 416                                         size);
 417                         if (count)
 418                                 do_push = true;
 419                         if (count != size) {
 420                                 /* stop pushing; TTY layer can't handle more */
 421                                 port->n_read += count;
 422                                 pr_vdebug("ttyGS%d: rx block %d/%d\n",
 423                                           port->port_num, count, req->actual);
 424                                 break;
 425                         }
 426                         port->n_read = 0;
 427                 }
 428
 429                 list_move(&req->list, &port->read_pool);
 430                 port->read_started--;
 431         }
 432
 433         /* Push from tty to ldisc; this is handled by a workqueue,
 434          * so we won't get callbacks and can hold port_lock
 435          */
 436         if (do_push)
 437                 tty_flip_buffer_push(&port->port);
 438
 439
 440         /* We want our data queue to become empty ASAP, keeping data
 441          * in the tty and ldisc (not here).  If we couldn't push any
 442          * this time around, RX may be starved, so wait until next jiffy.
 443          *
 444          * We may leave non-empty queue only when there is a tty, and
 445          * either it is throttled or there is no more room in flip buffer.
 446          */
 447         if (!list_empty(queue) && !tty_throttled(tty))
 448                 schedule_delayed_work(&port->push, 1);
 449
 450         /* If we're still connected, refill the USB RX queue. */
 451         if (!disconnect && port->port_usb)
 452                 gs_start_rx(port);
 453
 454         spin_unlock_irq(&port->port_lock);
 455 }
 456
 457 static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
 458 {
 459         struct gs_port  *port = ep->driver_data;
 460
 461         /* Queue all received data until the tty layer is ready for it. */
 462         spin_lock(&port->port_lock);
 463         list_add_tail(&req->list, &port->read_queue);
 464         schedule_delayed_work(&port->push, 0);
 465         spin_unlock(&port->port_lock);
 466 }
 467
 468 static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
 469 {
 470         struct gs_port  *port = ep->driver_data;
 471
 472         spin_lock(&port->port_lock);
 473         list_add(&req->list, &port->write_pool);
 474         port->write_started--;
 475
 476         switch (req->status) {
 477         default:
 478                 /* presumably a transient fault */
 479                 pr_warn("%s: unexpected %s status %d\n",
 480                         __func__, ep->name, req->status);
 481                 fallthrough;
 482         case 0:
 483                 /* normal completion */
 484                 gs_start_tx(port);
 485                 break;
 486
 487         case -ESHUTDOWN:
 488                 /* disconnect */
 489                 pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
 490                 break;
 491         }
 492
 493         spin_unlock(&port->port_lock);
 494 }
 495
 496 static void gs_free_requests(struct usb_ep *ep, struct list_head *head,
 497                                                          int *allocated)
 498 {
 499         struct usb_request      *req;
 500
 501         while (!list_empty(head)) {
 502                 req = list_entry(head->next, struct usb_request, list);
 503                 list_del(&req->list);
 504                 gs_free_req(ep, req);
 505                 if (allocated)
 506                         (*allocated)--;
 507         }
 508 }
 509
 510 static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
 511                 void (*fn)(struct usb_ep *, struct usb_request *),
 512                 int *allocated)
 513 {
 514         int                     i;
 515         struct usb_request      *req;
 516         int n = allocated ? QUEUE_SIZE - *allocated : QUEUE_SIZE;
 517
 518         /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't
 519          * do quite that many this time, don't fail ... we just won't
 520          * be as speedy as we might otherwise be.
 521          */
 522         for (i = 0; i < n; i++) {
 523                 req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
 524                 if (!req)
 525                         return list_empty(head) ? -ENOMEM : 0;
 526                 req->complete = fn;
 527                 list_add_tail(&req->list, head);
 528                 if (allocated)
 529                         (*allocated)++;
 530         }
 531         return 0;
 532 }
 533
 534 /**
 535  * gs_start_io - start USB I/O streams
 536  * @port: port to use
 537  * Context: holding port_lock; port_tty and port_usb are non-null
 538  *
 539  * We only start I/O when something is connected to both sides of
 540  * this port.  If nothing is listening on the host side, we may
 541  * be pointlessly filling up our TX buffers and FIFO.
 542  */
 543 static int gs_start_io(struct gs_port *port)
 544 {
 545         struct list_head        *head = &port->read_pool;
 546         struct usb_ep           *ep;
 547         int                     status;
 548         unsigned                started;
 549
 550         if (!port->port_usb || !port->port.tty)
 551                 return -EIO;
 552
 553         /* Allocate RX and TX I/O buffers.  We can't easily do this much
 554          * earlier (with GFP_KERNEL) because the requests are coupled to
 555          * endpoints, as are the packet sizes we'll be using.  Different
 556          * configurations may use different endpoints with a given port;
 557          * and high speed vs full speed changes packet sizes too.
 558          */
 559         ep = port->port_usb->out;
 560         status = gs_alloc_requests(ep, head, gs_read_complete,
 561                 &port->read_allocated);
 562         if (status)
 563                 return status;
 564
 565         status = gs_alloc_requests(port->port_usb->in, &port->write_pool,
 566                         gs_write_complete, &port->write_allocated);
 567         if (status) {
 568                 gs_free_requests(ep, head, &port->read_allocated);
 569                 return status;
 570         }
 571
 572         /* queue read requests */
 573         port->n_read = 0;
 574         started = gs_start_rx(port);
 575
 576         if (started) {
 577                 gs_start_tx(port);
 578                 /* Unblock any pending writes into our circular buffer, in case
 579                  * we didn't in gs_start_tx() */
 580                 tty_wakeup(port->port.tty);
 581         } else {
 582                 gs_free_requests(ep, head, &port->read_allocated);
 583                 gs_free_requests(port->port_usb->in, &port->write_pool,
 584                         &port->write_allocated);
 585                 status = -EIO;
 586         }
 587
 588         return status;
 589 }
 590
 591 /*-------------------------------------------------------------------------*/
 592
 593 /* TTY Driver */
 594
 595 /*
 596  * gs_open sets up the link between a gs_port and its associated TTY.
 597  * That link is broken *only* by TTY close(), and all driver methods
 598  * know that.
 599  */
 600 static int gs_open(struct tty_struct *tty, struct file *file)
 601 {
 602         int             port_num = tty->index;
 603         struct gs_port  *port;
 604         int             status = 0;
 605
 606         mutex_lock(&ports[port_num].lock);
 607         port = ports[port_num].port;
 608         if (!port) {
 609                 status = -ENODEV;
 610                 goto out;
 611         }
 612
 613         spin_lock_irq(&port->port_lock);
 614
 615         /* allocate circular buffer on first open */
 616         if (!kfifo_initialized(&port->port_write_buf)) {
 617
 618                 spin_unlock_irq(&port->port_lock);
 619
 620                 /*
 621                  * portmaster's mutex still protects from simultaneous open(),
 622                  * and close() can't happen, yet.
 623                  */
 624
 625                 status = kfifo_alloc(&port->port_write_buf,
 626                                      WRITE_BUF_SIZE, GFP_KERNEL);
 627                 if (status) {
 628                         pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n",
 629                                  port_num, tty, file);
 630                         goto out;
 631                 }
 632
 633                 spin_lock_irq(&port->port_lock);
 634         }
 635
 636         /* already open?  Great. */
 637         if (port->port.count++)
 638                 goto exit_unlock_port;
 639
 640         tty->driver_data = port;
 641         port->port.tty = tty;
 642
 643         /* if connected, start the I/O stream */
 644         if (port->port_usb) {
 645                 /* if port is suspended, wait resume to start I/0 stream */
 646                 if (!port->suspended) {
 647                         struct gserial  *gser = port->port_usb;
 648
 649                         pr_debug("gs_open: start ttyGS%d\n", port->port_num);
 650                         gs_start_io(port);
 651
 652                         if (gser->connect)
 653                                 gser->connect(gser);
 654                 } else {
 655                         pr_debug("delay start of ttyGS%d\n", port->port_num);
 656                         port->start_delayed = true;
 657                 }
 658         }
 659
 660         pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file);
 661
 662 exit_unlock_port:
 663         spin_unlock_irq(&port->port_lock);
 664 out:
 665         mutex_unlock(&ports[port_num].lock);
 666         return status;
 667 }
 668
 669 static int gs_close_flush_done(struct gs_port *p)
 670 {
 671         int cond;
 672
 673         /* return true on disconnect or empty buffer or if raced with open() */
 674         spin_lock_irq(&p->port_lock);
 675         cond = p->port_usb == NULL || !kfifo_len(&p->port_write_buf) ||
 676                 p->port.count > 1;
 677         spin_unlock_irq(&p->port_lock);
 678
 679         return cond;
 680 }
 681
 682 static void gs_close(struct tty_struct *tty, struct file *file)
 683 {
 684         struct gs_port *port = tty->driver_data;
 685         struct gserial  *gser;
 686
 687         spin_lock_irq(&port->port_lock);
 688
 689         if (port->port.count != 1) {
 690 raced_with_open:
 691                 if (port->port.count == 0)
 692                         WARN_ON(1);
 693                 else
 694                         --port->port.count;
 695                 goto exit;
 696         }
 697
 698         pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file);
 699
 700         gser = port->port_usb;
 701         if (gser && !port->suspended && gser->disconnect)
 702                 gser->disconnect(gser);
 703
 704         /* wait for circular write buffer to drain, disconnect, or at
 705          * most GS_CLOSE_TIMEOUT seconds; then discard the rest
 706          */
 707         if (kfifo_len(&port->port_write_buf) > 0 && gser) {
 708                 spin_unlock_irq(&port->port_lock);
 709                 wait_event_interruptible_timeout(port->drain_wait,
 710                                         gs_close_flush_done(port),
 711                                         GS_CLOSE_TIMEOUT * HZ);
 712                 spin_lock_irq(&port->port_lock);
 713
 714                 if (port->port.count != 1)
 715                         goto raced_with_open;
 716
 717                 gser = port->port_usb;
 718         }
 719
 720         /* Iff we're disconnected, there can be no I/O in flight so it's
 721          * ok to free the circular buffer; else just scrub it.  And don't
 722          * let the push async work fire again until we're re-opened.
 723          */
 724         if (gser == NULL)
 725                 kfifo_free(&port->port_write_buf);
 726         else
 727                 kfifo_reset(&port->port_write_buf);
 728
 729         port->start_delayed = false;
 730         port->port.count = 0;
 731         port->port.tty = NULL;
 732
 733         pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
 734                         port->port_num, tty, file);
 735
 736         wake_up(&port->close_wait);
 737 exit:
 738         spin_unlock_irq(&port->port_lock);
 739 }
 740
 741 static ssize_t gs_write(struct tty_struct *tty, const u8 *buf, size_t count)
 742 {
 743         struct gs_port  *port = tty->driver_data;
 744         unsigned long   flags;
 745
 746         pr_vdebug("gs_write: ttyGS%d (%p) writing %zu bytes\n",
 747                         port->port_num, tty, count);
 748
 749         spin_lock_irqsave(&port->port_lock, flags);
 750         if (count)
 751                 count = kfifo_in(&port->port_write_buf, buf, count);
 752         /* treat count == 0 as flush_chars() */
 753         if (port->port_usb)
 754                 gs_start_tx(port);
 755         spin_unlock_irqrestore(&port->port_lock, flags);
 756
 757         return count;
 758 }
 759
 760 static int gs_put_char(struct tty_struct *tty, u8 ch)
 761 {
 762         struct gs_port  *port = tty->driver_data;
 763         unsigned long   flags;
 764         int             status;
 765
 766         pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %ps\n",
 767                 port->port_num, tty, ch, __builtin_return_address(0));
 768
 769         spin_lock_irqsave(&port->port_lock, flags);
 770         status = kfifo_put(&port->port_write_buf, ch);
 771         spin_unlock_irqrestore(&port->port_lock, flags);
 772
 773         return status;
 774 }
 775
 776 static void gs_flush_chars(struct tty_struct *tty)
 777 {
 778         struct gs_port  *port = tty->driver_data;
 779         unsigned long   flags;
 780
 781         pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
 782
 783         spin_lock_irqsave(&port->port_lock, flags);
 784         if (port->port_usb)
 785                 gs_start_tx(port);
 786         spin_unlock_irqrestore(&port->port_lock, flags);
 787 }
 788
 789 static unsigned int gs_write_room(struct tty_struct *tty)
 790 {
 791         struct gs_port  *port = tty->driver_data;
 792         unsigned long   flags;
 793         unsigned int room = 0;
 794
 795         spin_lock_irqsave(&port->port_lock, flags);
 796         if (port->port_usb)
 797                 room = kfifo_avail(&port->port_write_buf);
 798         spin_unlock_irqrestore(&port->port_lock, flags);
 799
 800         pr_vdebug("gs_write_room: (%d,%p) room=%u\n",
 801                 port->port_num, tty, room);
 802
 803         return room;
 804 }
 805
 806 static unsigned int gs_chars_in_buffer(struct tty_struct *tty)
 807 {
 808         struct gs_port  *port = tty->driver_data;
 809         unsigned long   flags;
 810         unsigned int    chars;
 811
 812         spin_lock_irqsave(&port->port_lock, flags);
 813         chars = kfifo_len(&port->port_write_buf);
 814         spin_unlock_irqrestore(&port->port_lock, flags);
 815
 816         pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%u\n",
 817                 port->port_num, tty, chars);
 818
 819         return chars;
 820 }
 821
 822 /* undo side effects of setting TTY_THROTTLED */
 823 static void gs_unthrottle(struct tty_struct *tty)
 824 {
 825         struct gs_port          *port = tty->driver_data;
 826         unsigned long           flags;
 827
 828         spin_lock_irqsave(&port->port_lock, flags);
 829         if (port->port_usb) {
 830                 /* Kickstart read queue processing.  We don't do xon/xoff,
 831                  * rts/cts, or other handshaking with the host, but if the
 832                  * read queue backs up enough we'll be NAKing OUT packets.
 833                  */
 834                 pr_vdebug("ttyGS%d: unthrottle\n", port->port_num);
 835                 schedule_delayed_work(&port->push, 0);
 836         }
 837         spin_unlock_irqrestore(&port->port_lock, flags);
 838 }
 839
 840 static int gs_break_ctl(struct tty_struct *tty, int duration)
 841 {
 842         struct gs_port  *port = tty->driver_data;
 843         int             status = 0;
 844         struct gserial  *gser;
 845
 846         pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n",
 847                         port->port_num, duration);
 848
 849         spin_lock_irq(&port->port_lock);
 850         gser = port->port_usb;
 851         if (gser && gser->send_break)
 852                 status = gser->send_break(gser, duration);
 853         spin_unlock_irq(&port->port_lock);
 854
 855         return status;
 856 }
 857
 858 static int gs_get_icount(struct tty_struct *tty,
 859                          struct serial_icounter_struct *icount)
 860 {
 861         struct gs_port *port = tty->driver_data;
 862         struct async_icount cnow;
 863         unsigned long flags;
 864
 865         spin_lock_irqsave(&port->port_lock, flags);
 866         cnow = port->icount;
 867         spin_unlock_irqrestore(&port->port_lock, flags);
 868
 869         icount->rx = cnow.rx;
 870         icount->tx = cnow.tx;
 871
 872         return 0;
 873 }
 874
 875 static const struct tty_operations gs_tty_ops = {
 876         .open =                 gs_open,
 877         .close =                gs_close,
 878         .write =                gs_write,
 879         .put_char =             gs_put_char,
 880         .flush_chars =          gs_flush_chars,
 881         .write_room =           gs_write_room,
 882         .chars_in_buffer =      gs_chars_in_buffer,
 883         .unthrottle =           gs_unthrottle,
 884         .break_ctl =            gs_break_ctl,
 885         .get_icount =           gs_get_icount,
 886 };
 887
 888 /*-------------------------------------------------------------------------*/
 889
 890 static struct tty_driver *gs_tty_driver;
 891
 892 #ifdef CONFIG_U_SERIAL_CONSOLE
 893
 894 static void gs_console_complete_out(struct usb_ep *ep, struct usb_request *req)
 895 {
 896         struct gs_console *cons = req->context;
 897
 898         switch (req->status) {
 899         default:
 900                 pr_warn("%s: unexpected %s status %d\n",
 901                         __func__, ep->name, req->status);
 902                 fallthrough;
 903         case 0:
 904                 /* normal completion */
 905                 spin_lock(&cons->lock);
 906                 req->length = 0;
 907                 schedule_work(&cons->work);
 908                 spin_unlock(&cons->lock);
 909                 break;
 910         case -ECONNRESET:
 911         case -ESHUTDOWN:
 912                 /* disconnect */
 913                 pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
 914                 break;
 915         }
 916 }
 917
 918 static void __gs_console_push(struct gs_console *cons)
 919 {
 920         struct usb_request *req = cons->req;
 921         struct usb_ep *ep;
 922         size_t size;
 923
 924         if (!req)
 925                 return; /* disconnected */
 926
 927         if (req->length)
 928                 return; /* busy */
 929
 930         ep = cons->console.data;
 931         size = kfifo_out(&cons->buf, req->buf, ep->maxpacket);
 932         if (!size)
 933                 return;
 934
 935         if (cons->missed && ep->maxpacket >= 64) {
 936                 char buf[64];
 937                 size_t len;
 938
 939                 len = sprintf(buf, "\n[missed %zu bytes]\n", cons->missed);
 940                 kfifo_in(&cons->buf, buf, len);
 941                 cons->missed = 0;
 942         }
 943
 944         req->length = size;
 945
 946         spin_unlock_irq(&cons->lock);
 947         if (usb_ep_queue(ep, req, GFP_ATOMIC))
 948                 req->length = 0;
 949         spin_lock_irq(&cons->lock);
 950 }
 951
 952 static void gs_console_work(struct work_struct *work)
 953 {
 954         struct gs_console *cons = container_of(work, struct gs_console, work);
 955
 956         spin_lock_irq(&cons->lock);
 957
 958         __gs_console_push(cons);
 959
 960         spin_unlock_irq(&cons->lock);
 961 }
 962
 963 static void gs_console_write(struct console *co,
 964                              const char *buf, unsigned count)
 965 {
 966         struct gs_console *cons = container_of(co, struct gs_console, console);
 967         unsigned long flags;
 968         size_t n;
 969
 970         spin_lock_irqsave(&cons->lock, flags);
 971
 972         n = kfifo_in(&cons->buf, buf, count);
 973         if (n < count)
 974                 cons->missed += count - n;
 975
 976         if (cons->req && !cons->req->length)
 977                 schedule_work(&cons->work);
 978
 979         spin_unlock_irqrestore(&cons->lock, flags);
 980 }
 981
 982 static struct tty_driver *gs_console_device(struct console *co, int *index)
 983 {
 984         *index = co->index;
 985         return gs_tty_driver;
 986 }
 987
 988 static int gs_console_connect(struct gs_port *port)
 989 {
 990         struct gs_console *cons = port->console;
 991         struct usb_request *req;
 992         struct usb_ep *ep;
 993
 994         if (!cons)
 995                 return 0;
 996
 997         ep = port->port_usb->in;
 998         req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
 999         if (!req)
1000                 return -ENOMEM;
1001         req->complete = gs_console_complete_out;
1002         req->context = cons;
1003         req->length = 0;
1004
1005         spin_lock(&cons->lock);
1006         cons->req = req;
1007         cons->console.data = ep;
1008         spin_unlock(&cons->lock);
1009
1010         pr_debug("ttyGS%d: console connected!\n", port->port_num);
1011
1012         schedule_work(&cons->work);
1013
1014         return 0;
1015 }
1016
1017 static void gs_console_disconnect(struct gs_port *port)
1018 {
1019         struct gs_console *cons = port->console;
1020         struct usb_request *req;
1021         struct usb_ep *ep;
1022
1023         if (!cons)
1024                 return;
1025
1026         spin_lock(&cons->lock);
1027
1028         req = cons->req;
1029         ep = cons->console.data;
1030         cons->req = NULL;
1031
1032         spin_unlock(&cons->lock);
1033
1034         if (!req)
1035                 return;
1036
1037         usb_ep_dequeue(ep, req);
1038         gs_free_req(ep, req);
1039 }
1040
1041 static int gs_console_init(struct gs_port *port)
1042 {
1043         struct gs_console *cons;
1044         int err;
1045
1046         if (port->console)
1047                 return 0;
1048
1049         cons = kzalloc(sizeof(*port->console), GFP_KERNEL);
1050         if (!cons)
1051                 return -ENOMEM;
1052
1053         strcpy(cons->console.name, "ttyGS");
1054         cons->console.write = gs_console_write;
1055         cons->console.device = gs_console_device;
1056         cons->console.flags = CON_PRINTBUFFER;
1057         cons->console.index = port->port_num;
1058
1059         INIT_WORK(&cons->work, gs_console_work);
1060         spin_lock_init(&cons->lock);
1061
1062         err = kfifo_alloc(&cons->buf, GS_CONSOLE_BUF_SIZE, GFP_KERNEL);
1063         if (err) {
1064                 pr_err("ttyGS%d: allocate console buffer failed\n", port->port_num);
1065                 kfree(cons);
1066                 return err;
1067         }
1068
1069         port->console = cons;
1070         register_console(&cons->console);
1071
1072         spin_lock_irq(&port->port_lock);
1073         if (port->port_usb)
1074                 gs_console_connect(port);
1075         spin_unlock_irq(&port->port_lock);
1076
1077         return 0;
1078 }
1079
1080 static void gs_console_exit(struct gs_port *port)
1081 {
1082         struct gs_console *cons = port->console;
1083
1084         if (!cons)
1085                 return;
1086
1087         unregister_console(&cons->console);
1088
1089         spin_lock_irq(&port->port_lock);
1090         if (cons->req)
1091                 gs_console_disconnect(port);
1092         spin_unlock_irq(&port->port_lock);
1093
1094         cancel_work_sync(&cons->work);
1095         kfifo_free(&cons->buf);
1096         kfree(cons);
1097         port->console = NULL;
1098 }
1099
1100 ssize_t gserial_set_console(unsigned char port_num, const char *page, size_t count)
1101 {
1102         struct gs_port *port;
1103         bool enable;
1104         int ret;
1105
1106         ret = kstrtobool(page, &enable);
1107         if (ret)
1108                 return ret;
1109
1110         mutex_lock(&ports[port_num].lock);
1111         port = ports[port_num].port;
1112
1113         if (WARN_ON(port == NULL)) {
1114                 ret = -ENXIO;
1115                 goto out;
1116         }
1117
1118         if (enable)
1119                 ret = gs_console_init(port);
1120         else
1121                 gs_console_exit(port);
1122 out:
1123         mutex_unlock(&ports[port_num].lock);
1124
1125         return ret < 0 ? ret : count;
1126 }
1127 EXPORT_SYMBOL_GPL(gserial_set_console);
1128
1129 ssize_t gserial_get_console(unsigned char port_num, char *page)
1130 {
1131         struct gs_port *port;
1132         ssize_t ret;
1133
1134         mutex_lock(&ports[port_num].lock);
1135         port = ports[port_num].port;
1136
1137         if (WARN_ON(port == NULL))
1138                 ret = -ENXIO;
1139         else
1140                 ret = sprintf(page, "%u\n", !!port->console);
1141
1142         mutex_unlock(&ports[port_num].lock);
1143
1144         return ret;
1145 }
1146 EXPORT_SYMBOL_GPL(gserial_get_console);
1147
1148 #else
1149
1150 static int gs_console_connect(struct gs_port *port)
1151 {
1152         return 0;
1153 }
1154
1155 static void gs_console_disconnect(struct gs_port *port)
1156 {
1157 }
1158
1159 static int gs_console_init(struct gs_port *port)
1160 {
1161         return -ENOSYS;
1162 }
1163
1164 static void gs_console_exit(struct gs_port *port)
1165 {
1166 }
1167
1168 #endif
1169
1170 static int
1171 gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding)
1172 {
1173         struct gs_port  *port;
1174         int             ret = 0;
1175
1176         mutex_lock(&ports[port_num].lock);
1177         if (ports[port_num].port) {
1178                 ret = -EBUSY;
1179                 goto out;
1180         }
1181
1182         port = kzalloc(sizeof(struct gs_port), GFP_KERNEL);
1183         if (port == NULL) {
1184                 ret = -ENOMEM;
1185                 goto out;
1186         }
1187
1188         tty_port_init(&port->port);
1189         spin_lock_init(&port->port_lock);
1190         init_waitqueue_head(&port->drain_wait);
1191         init_waitqueue_head(&port->close_wait);
1192
1193         INIT_DELAYED_WORK(&port->push, gs_rx_push);
1194
1195         INIT_LIST_HEAD(&port->read_pool);
1196         INIT_LIST_HEAD(&port->read_queue);
1197         INIT_LIST_HEAD(&port->write_pool);
1198
1199         port->port_num = port_num;
1200         port->port_line_coding = *coding;
1201
1202         ports[port_num].port = port;
1203 out:
1204         mutex_unlock(&ports[port_num].lock);
1205         return ret;
1206 }
1207
1208 static int gs_closed(struct gs_port *port)
1209 {
1210         int cond;
1211
1212         spin_lock_irq(&port->port_lock);
1213         cond = port->port.count == 0;
1214         spin_unlock_irq(&port->port_lock);
1215
1216         return cond;
1217 }
1218
1219 static void gserial_free_port(struct gs_port *port)
1220 {
1221         cancel_delayed_work_sync(&port->push);
1222         /* wait for old opens to finish */
1223         wait_event(port->close_wait, gs_closed(port));
1224         WARN_ON(port->port_usb != NULL);
1225         tty_port_destroy(&port->port);
1226         kfree(port);
1227 }
1228
1229 void gserial_free_line(unsigned char port_num)
1230 {
1231         struct gs_port  *port;
1232
1233         mutex_lock(&ports[port_num].lock);
1234         if (!ports[port_num].port) {
1235                 mutex_unlock(&ports[port_num].lock);
1236                 return;
1237         }
1238         port = ports[port_num].port;
1239         gs_console_exit(port);
1240         ports[port_num].port = NULL;
1241         mutex_unlock(&ports[port_num].lock);
1242
1243         gserial_free_port(port);
1244         tty_unregister_device(gs_tty_driver, port_num);
1245 }
1246 EXPORT_SYMBOL_GPL(gserial_free_line);
1247
1248 int gserial_alloc_line_no_console(unsigned char *line_num)
1249 {
1250         struct usb_cdc_line_coding      coding;
1251         struct gs_port                  *port;
1252         struct device                   *tty_dev;
1253         int                             ret;
1254         int                             port_num;
1255
1256         coding.dwDTERate = cpu_to_le32(9600);
1257         coding.bCharFormat = 8;
1258         coding.bParityType = USB_CDC_NO_PARITY;
1259         coding.bDataBits = USB_CDC_1_STOP_BITS;
1260
1261         for (port_num = 0; port_num < MAX_U_SERIAL_PORTS; port_num++) {
1262                 ret = gs_port_alloc(port_num, &coding);
1263                 if (ret == -EBUSY)
1264                         continue;
1265                 if (ret)
1266                         return ret;
1267                 break;
1268         }
1269         if (ret)
1270                 return ret;
1271
1272         /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
1273
1274         port = ports[port_num].port;
1275         tty_dev = tty_port_register_device(&port->port,
1276                         gs_tty_driver, port_num, NULL);
1277         if (IS_ERR(tty_dev)) {
1278                 pr_err("%s: failed to register tty for port %d, err %ld\n",
1279                                 __func__, port_num, PTR_ERR(tty_dev));
1280
1281                 ret = PTR_ERR(tty_dev);
1282                 mutex_lock(&ports[port_num].lock);
1283                 ports[port_num].port = NULL;
1284                 mutex_unlock(&ports[port_num].lock);
1285                 gserial_free_port(port);
1286                 goto err;
1287         }
1288         *line_num = port_num;
1289 err:
1290         return ret;
1291 }
1292 EXPORT_SYMBOL_GPL(gserial_alloc_line_no_console);
1293
1294 int gserial_alloc_line(unsigned char *line_num)
1295 {
1296         int ret = gserial_alloc_line_no_console(line_num);
1297
1298         if (!ret && !*line_num)
1299                 gs_console_init(ports[*line_num].port);
1300
1301         return ret;
1302 }
1303 EXPORT_SYMBOL_GPL(gserial_alloc_line);
1304
1305 /**
1306  * gserial_connect - notify TTY I/O glue that USB link is active
1307  * @gser: the function, set up with endpoints and descriptors
1308  * @port_num: which port is active
1309  * Context: any (usually from irq)
1310  *
1311  * This is called activate endpoints and let the TTY layer know that
1312  * the connection is active ... not unlike "carrier detect".  It won't
1313  * necessarily start I/O queues; unless the TTY is held open by any
1314  * task, there would be no point.  However, the endpoints will be
1315  * activated so the USB host can perform I/O, subject to basic USB
1316  * hardware flow control.
1317  *
1318  * Caller needs to have set up the endpoints and USB function in @dev
1319  * before calling this, as well as the appropriate (speed-specific)
1320  * endpoint descriptors, and also have allocate @port_num by calling
1321  * @gserial_alloc_line().
1322  *
1323  * Returns negative errno or zero.
1324  * On success, ep->driver_data will be overwritten.
1325  */
1326 int gserial_connect(struct gserial *gser, u8 port_num)
1327 {
1328         struct gs_port  *port;
1329         unsigned long   flags;
1330         int             status;
1331
1332         if (port_num >= MAX_U_SERIAL_PORTS)
1333                 return -ENXIO;
1334
1335         port = ports[port_num].port;
1336         if (!port) {
1337                 pr_err("serial line %d not allocated.\n", port_num);
1338                 return -EINVAL;
1339         }
1340         if (port->port_usb) {
1341                 pr_err("serial line %d is in use.\n", port_num);
1342                 return -EBUSY;
1343         }
1344
1345         /* activate the endpoints */
1346         status = usb_ep_enable(gser->in);
1347         if (status < 0)
1348                 return status;
1349         gser->in->driver_data = port;
1350
1351         status = usb_ep_enable(gser->out);
1352         if (status < 0)
1353                 goto fail_out;
1354         gser->out->driver_data = port;
1355
1356         /* then tell the tty glue that I/O can work */
1357         spin_lock_irqsave(&port->port_lock, flags);
1358         gser->ioport = port;
1359         port->port_usb = gser;
1360
1361         /* REVISIT unclear how best to handle this state...
1362          * we don't really couple it with the Linux TTY.
1363          */
1364         gser->port_line_coding = port->port_line_coding;
1365
1366         /* REVISIT if waiting on "carrier detect", signal. */
1367
1368         /* if it's already open, start I/O ... and notify the serial
1369          * protocol about open/close status (connect/disconnect).
1370          */
1371         if (port->port.count) {
1372                 pr_debug("gserial_connect: start ttyGS%d\n", port->port_num);
1373                 gs_start_io(port);
1374                 if (gser->connect)
1375                         gser->connect(gser);
1376         } else {
1377                 if (gser->disconnect)
1378                         gser->disconnect(gser);
1379         }
1380
1381         status = gs_console_connect(port);
1382         spin_unlock_irqrestore(&port->port_lock, flags);
1383
1384         return status;
1385
1386 fail_out:
1387         usb_ep_disable(gser->in);
1388         return status;
1389 }
1390 EXPORT_SYMBOL_GPL(gserial_connect);
1391 /**
1392  * gserial_disconnect - notify TTY I/O glue that USB link is inactive
1393  * @gser: the function, on which gserial_connect() was called
1394  * Context: any (usually from irq)
1395  *
1396  * This is called to deactivate endpoints and let the TTY layer know
1397  * that the connection went inactive ... not unlike "hangup".
1398  *
1399  * On return, the state is as if gserial_connect() had never been called;
1400  * there is no active USB I/O on these endpoints.
1401  */
1402 void gserial_disconnect(struct gserial *gser)
1403 {
1404         struct gs_port  *port = gser->ioport;
1405         unsigned long   flags;
1406
1407         if (!port)
1408                 return;
1409
1410         spin_lock_irqsave(&serial_port_lock, flags);
1411
1412         /* tell the TTY glue not to do I/O here any more */
1413         spin_lock(&port->port_lock);
1414
1415         gs_console_disconnect(port);
1416
1417         /* REVISIT as above: how best to track this? */
1418         port->port_line_coding = gser->port_line_coding;
1419
1420         port->port_usb = NULL;
1421         gser->ioport = NULL;
1422         if (port->port.count > 0) {
1423                 wake_up_interruptible(&port->drain_wait);
1424                 if (port->port.tty)
1425                         tty_hangup(port->port.tty);
1426         }
1427         port->suspended = false;
1428         spin_unlock(&port->port_lock);
1429         spin_unlock_irqrestore(&serial_port_lock, flags);
1430
1431         /* disable endpoints, aborting down any active I/O */
1432         usb_ep_disable(gser->out);
1433         usb_ep_disable(gser->in);
1434
1435         /* finally, free any unused/unusable I/O buffers */
1436         spin_lock_irqsave(&port->port_lock, flags);
1437         if (port->port.count == 0)
1438                 kfifo_free(&port->port_write_buf);
1439         gs_free_requests(gser->out, &port->read_pool, NULL);
1440         gs_free_requests(gser->out, &port->read_queue, NULL);
1441         gs_free_requests(gser->in, &port->write_pool, NULL);
1442
1443         port->read_allocated = port->read_started =
1444                 port->write_allocated = port->write_started = 0;
1445
1446         spin_unlock_irqrestore(&port->port_lock, flags);
1447 }
1448 EXPORT_SYMBOL_GPL(gserial_disconnect);
1449
1450 void gserial_suspend(struct gserial *gser)
1451 {
1452         struct gs_port  *port;
1453         unsigned long   flags;
1454
1455         spin_lock_irqsave(&serial_port_lock, flags);
1456         port = gser->ioport;
1457
1458         if (!port) {
1459                 spin_unlock_irqrestore(&serial_port_lock, flags);
1460                 return;
1461         }
1462
1463         spin_lock(&port->port_lock);
1464         spin_unlock(&serial_port_lock);
1465         port->suspended = true;
1466         port->start_delayed = true;
1467         spin_unlock_irqrestore(&port->port_lock, flags);
1468 }
1469 EXPORT_SYMBOL_GPL(gserial_suspend);
1470
1471 void gserial_resume(struct gserial *gser)
1472 {
1473         struct gs_port *port;
1474         unsigned long   flags;
1475
1476         spin_lock_irqsave(&serial_port_lock, flags);
1477         port = gser->ioport;
1478
1479         if (!port) {
1480                 spin_unlock_irqrestore(&serial_port_lock, flags);
1481                 return;
1482         }
1483
1484         spin_lock(&port->port_lock);
1485         spin_unlock(&serial_port_lock);
1486         port->suspended = false;
1487         if (!port->start_delayed) {
1488                 spin_unlock_irqrestore(&port->port_lock, flags);
1489                 return;
1490         }
1491
1492         pr_debug("delayed start ttyGS%d\n", port->port_num);
1493         gs_start_io(port);
1494         if (gser->connect)
1495                 gser->connect(gser);
1496         port->start_delayed = false;
1497         spin_unlock_irqrestore(&port->port_lock, flags);
1498 }
1499 EXPORT_SYMBOL_GPL(gserial_resume);
1500
1501 static int __init userial_init(void)
1502 {
1503         struct tty_driver *driver;
1504         unsigned                        i;
1505         int                             status;
1506
1507         driver = tty_alloc_driver(MAX_U_SERIAL_PORTS, TTY_DRIVER_REAL_RAW |
1508                         TTY_DRIVER_DYNAMIC_DEV);
1509         if (IS_ERR(driver))
1510                 return PTR_ERR(driver);
1511
1512         driver->driver_name = "g_serial";
1513         driver->name = "ttyGS";
1514         /* uses dynamically assigned dev_t values */
1515
1516         driver->type = TTY_DRIVER_TYPE_SERIAL;
1517         driver->subtype = SERIAL_TYPE_NORMAL;
1518         driver->init_termios = tty_std_termios;
1519
1520         /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
1521          * MS-Windows.  Otherwise, most of these flags shouldn't affect
1522          * anything unless we were to actually hook up to a serial line.
1523          */
1524         driver->init_termios.c_cflag =
1525                         B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1526         driver->init_termios.c_ispeed = 9600;
1527         driver->init_termios.c_ospeed = 9600;
1528
1529         tty_set_operations(driver, &gs_tty_ops);
1530         for (i = 0; i < MAX_U_SERIAL_PORTS; i++)
1531                 mutex_init(&ports[i].lock);
1532
1533         /* export the driver ... */
1534         status = tty_register_driver(driver);
1535         if (status) {
1536                 pr_err("%s: cannot register, err %d\n",
1537                                 __func__, status);
1538                 goto fail;
1539         }
1540
1541         gs_tty_driver = driver;
1542
1543         pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
1544                         MAX_U_SERIAL_PORTS,
1545                         (MAX_U_SERIAL_PORTS == 1) ? "" : "s");
1546
1547         return status;
1548 fail:
1549         tty_driver_kref_put(driver);
1550         return status;
1551 }
1552 module_init(userial_init);
1553
1554 static void __exit userial_cleanup(void)
1555 {
1556         tty_unregister_driver(gs_tty_driver);
1557         tty_driver_kref_put(gs_tty_driver);
1558         gs_tty_driver = NULL;
1559 }
1560 module_exit(userial_cleanup);
1561
1562 MODULE_DESCRIPTION("utilities for USB gadget \"serial port\"/TTY support");
1563 MODULE_LICENSE("GPL");