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