drivers/usb/gadget/function/u_serial.c

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