drivers/usb/gadget/function/u

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
gs_alloc_req
gs_free_req
gs_send_packet
gs_start_tx
gs_start_rx
gs_rx_push
gs_read_complete
gs_write_complete
gs_free_requests
gs_alloc_requests
gs_start_io
gs_open
gs_writes_finished
gs_close
gs_write
gs_put_char
gs_flush_chars
gs_write_room
gs_chars_in_buffer
gs_unthrottle
gs_break_ctl
gs_request_new
gs_request_free
gs_complete_out
gs_console_connect
gs_console_disconnect
gs_console_thread
gs_console_setup
gs_console_write
gs_console_device
gserial_console_init
gserial_console_exit
gs_console_connect
gs_console_disconnect
gserial_console_init
gserial_console_exit
gs_port_alloc
gs_closed
gserial_free_port
gserial_free_line
gserial_alloc_line
gserial_connect
gserial_disconnect
userial_init
userial_cleanup
   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 (alborchers@steinerpoint.com)
   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 (greg@kroah.com)
  11  * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
  12  * Copyright (C) 2000 Al Borchers (alborchers@steinerpoint.com)
  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         if (started) {
 564                 gs_start_tx(port);
 565                 /* Unblock any pending writes into our circular buffer, in case
 566                  * we didn't in gs_start_tx() */
 567                 tty_wakeup(port->port.tty);
 568         } else {
 569                 gs_free_requests(ep, head, &port->read_allocated);
 570                 gs_free_requests(port->port_usb->in, &port->write_pool,
 571                         &port->write_allocated);
 572                 status = -EIO;
 573         }
 574 
 575         return status;
 576 }
 577 
 578 /*-------------------------------------------------------------------------*/
 579 
 580 /* TTY Driver */
 581 
 582 /*
 583  * gs_open sets up the link between a gs_port and its associated TTY.
 584  * That link is broken *only* by TTY close(), and all driver methods
 585  * know that.
 586  */
 587 static int gs_open(struct tty_struct *tty, struct file *file)
 588 {
 589         int             port_num = tty->index;
 590         struct gs_port  *port;
 591         int             status;
 592 
 593         do {
 594                 mutex_lock(&ports[port_num].lock);
 595                 port = ports[port_num].port;
 596                 if (!port)
 597                         status = -ENODEV;
 598                 else {
 599                         spin_lock_irq(&port->port_lock);
 600 
 601                         /* already open?  Great. */
 602                         if (port->port.count) {
 603                                 status = 0;
 604                                 port->port.count++;
 605 
 606                         /* currently opening/closing? wait ... */
 607                         } else if (port->openclose) {
 608                                 status = -EBUSY;
 609 
 610                         /* ... else we do the work */
 611                         } else {
 612                                 status = -EAGAIN;
 613                                 port->openclose = true;
 614                         }
 615                         spin_unlock_irq(&port->port_lock);
 616                 }
 617                 mutex_unlock(&ports[port_num].lock);
 618 
 619                 switch (status) {
 620                 default:
 621                         /* fully handled */
 622                         return status;
 623                 case -EAGAIN:
 624                         /* must do the work */
 625                         break;
 626                 case -EBUSY:
 627                         /* wait for EAGAIN task to finish */
 628                         msleep(1);
 629                         /* REVISIT could have a waitchannel here, if
 630                          * concurrent open performance is important
 631                          */
 632                         break;
 633                 }
 634         } while (status != -EAGAIN);
 635 
 636         /* Do the "real open" */
 637         spin_lock_irq(&port->port_lock);
 638 
 639         /* allocate circular buffer on first open */
 640         if (!kfifo_initialized(&port->port_write_buf)) {
 641 
 642                 spin_unlock_irq(&port->port_lock);
 643                 status = kfifo_alloc(&port->port_write_buf,
 644                                      WRITE_BUF_SIZE, GFP_KERNEL);
 645                 spin_lock_irq(&port->port_lock);
 646 
 647                 if (status) {
 648                         pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n",
 649                                 port->port_num, tty, file);
 650                         port->openclose = false;
 651                         goto exit_unlock_port;
 652                 }
 653         }
 654 
 655         /* REVISIT if REMOVED (ports[].port NULL), abort the open
 656          * to let rmmod work faster (but this way isn't wrong).
 657          */
 658 
 659         /* REVISIT maybe wait for "carrier detect" */
 660 
 661         tty->driver_data = port;
 662         port->port.tty = tty;
 663 
 664         port->port.count = 1;
 665         port->openclose = false;
 666 
 667         /* if connected, start the I/O stream */
 668         if (port->port_usb) {
 669                 struct gserial  *gser = port->port_usb;
 670 
 671                 pr_debug("gs_open: start ttyGS%d\n", port->port_num);
 672                 gs_start_io(port);
 673 
 674                 if (gser->connect)
 675                         gser->connect(gser);
 676         }
 677 
 678         pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file);
 679 
 680         status = 0;
 681 
 682 exit_unlock_port:
 683         spin_unlock_irq(&port->port_lock);
 684         return status;
 685 }
 686 
 687 static int gs_writes_finished(struct gs_port *p)
 688 {
 689         int cond;
 690 
 691         /* return true on disconnect or empty buffer */
 692         spin_lock_irq(&p->port_lock);
 693         cond = (p->port_usb == NULL) || !kfifo_len(&p->port_write_buf);
 694         spin_unlock_irq(&p->port_lock);
 695 
 696         return cond;
 697 }
 698 
 699 static void gs_close(struct tty_struct *tty, struct file *file)
 700 {
 701         struct gs_port *port = tty->driver_data;
 702         struct gserial  *gser;
 703 
 704         spin_lock_irq(&port->port_lock);
 705 
 706         if (port->port.count != 1) {
 707                 if (port->port.count == 0)
 708                         WARN_ON(1);
 709                 else
 710                         --port->port.count;
 711                 goto exit;
 712         }
 713 
 714         pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file);
 715 
 716         /* mark port as closing but in use; we can drop port lock
 717          * and sleep if necessary
 718          */
 719         port->openclose = true;
 720         port->port.count = 0;
 721 
 722         gser = port->port_usb;
 723         if (gser && gser->disconnect)
 724                 gser->disconnect(gser);
 725 
 726         /* wait for circular write buffer to drain, disconnect, or at
 727          * most GS_CLOSE_TIMEOUT seconds; then discard the rest
 728          */
 729         if (kfifo_len(&port->port_write_buf) > 0 && gser) {
 730                 spin_unlock_irq(&port->port_lock);
 731                 wait_event_interruptible_timeout(port->drain_wait,
 732                                         gs_writes_finished(port),
 733                                         GS_CLOSE_TIMEOUT * HZ);
 734                 spin_lock_irq(&port->port_lock);
 735                 gser = port->port_usb;
 736         }
 737 
 738         /* Iff we're disconnected, there can be no I/O in flight so it's
 739          * ok to free the circular buffer; else just scrub it.  And don't
 740          * let the push tasklet fire again until we're re-opened.
 741          */
 742         if (gser == NULL)
 743                 kfifo_free(&port->port_write_buf);
 744         else
 745                 kfifo_reset(&port->port_write_buf);
 746 
 747         port->port.tty = NULL;
 748 
 749         port->openclose = false;
 750 
 751         pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
 752                         port->port_num, tty, file);
 753 
 754         wake_up(&port->close_wait);
 755 exit:
 756         spin_unlock_irq(&port->port_lock);
 757 }
 758 
 759 static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
 760 {
 761         struct gs_port  *port = tty->driver_data;
 762         unsigned long   flags;
 763 
 764         pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
 765                         port->port_num, tty, count);
 766 
 767         spin_lock_irqsave(&port->port_lock, flags);
 768         if (count)
 769                 count = kfifo_in(&port->port_write_buf, buf, count);
 770         /* treat count == 0 as flush_chars() */
 771         if (port->port_usb)
 772                 gs_start_tx(port);
 773         spin_unlock_irqrestore(&port->port_lock, flags);
 774 
 775         return count;
 776 }
 777 
 778 static int gs_put_char(struct tty_struct *tty, unsigned char ch)
 779 {
 780         struct gs_port  *port = tty->driver_data;
 781         unsigned long   flags;
 782         int             status;
 783 
 784         pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %ps\n",
 785                 port->port_num, tty, ch, __builtin_return_address(0));
 786 
 787         spin_lock_irqsave(&port->port_lock, flags);
 788         status = kfifo_put(&port->port_write_buf, ch);
 789         spin_unlock_irqrestore(&port->port_lock, flags);
 790 
 791         return status;
 792 }
 793 
 794 static void gs_flush_chars(struct tty_struct *tty)
 795 {
 796         struct gs_port  *port = tty->driver_data;
 797         unsigned long   flags;
 798 
 799         pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
 800 
 801         spin_lock_irqsave(&port->port_lock, flags);
 802         if (port->port_usb)
 803                 gs_start_tx(port);
 804         spin_unlock_irqrestore(&port->port_lock, flags);
 805 }
 806 
 807 static int gs_write_room(struct tty_struct *tty)
 808 {
 809         struct gs_port  *port = tty->driver_data;
 810         unsigned long   flags;
 811         int             room = 0;
 812 
 813         spin_lock_irqsave(&port->port_lock, flags);
 814         if (port->port_usb)
 815                 room = kfifo_avail(&port->port_write_buf);
 816         spin_unlock_irqrestore(&port->port_lock, flags);
 817 
 818         pr_vdebug("gs_write_room: (%d,%p) room=%d\n",
 819                 port->port_num, tty, room);
 820 
 821         return room;
 822 }
 823 
 824 static int gs_chars_in_buffer(struct tty_struct *tty)
 825 {
 826         struct gs_port  *port = tty->driver_data;
 827         unsigned long   flags;
 828         int             chars = 0;
 829 
 830         spin_lock_irqsave(&port->port_lock, flags);
 831         chars = kfifo_len(&port->port_write_buf);
 832         spin_unlock_irqrestore(&port->port_lock, flags);
 833 
 834         pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
 835                 port->port_num, tty, chars);
 836 
 837         return chars;
 838 }
 839 
 840 /* undo side effects of setting TTY_THROTTLED */
 841 static void gs_unthrottle(struct tty_struct *tty)
 842 {
 843         struct gs_port          *port = tty->driver_data;
 844         unsigned long           flags;
 845 
 846         spin_lock_irqsave(&port->port_lock, flags);
 847         if (port->port_usb) {
 848                 /* Kickstart read queue processing.  We don't do xon/xoff,
 849                  * rts/cts, or other handshaking with the host, but if the
 850                  * read queue backs up enough we'll be NAKing OUT packets.
 851                  */
 852                 pr_vdebug("ttyGS%d: unthrottle\n", port->port_num);
 853                 schedule_delayed_work(&port->push, 0);
 854         }
 855         spin_unlock_irqrestore(&port->port_lock, flags);
 856 }
 857 
 858 static int gs_break_ctl(struct tty_struct *tty, int duration)
 859 {
 860         struct gs_port  *port = tty->driver_data;
 861         int             status = 0;
 862         struct gserial  *gser;
 863 
 864         pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n",
 865                         port->port_num, duration);
 866 
 867         spin_lock_irq(&port->port_lock);
 868         gser = port->port_usb;
 869         if (gser && gser->send_break)
 870                 status = gser->send_break(gser, duration);
 871         spin_unlock_irq(&port->port_lock);
 872 
 873         return status;
 874 }
 875 
 876 static const struct tty_operations gs_tty_ops = {
 877         .open =                 gs_open,
 878         .close =                gs_close,
 879         .write =                gs_write,
 880         .put_char =             gs_put_char,
 881         .flush_chars =          gs_flush_chars,
 882         .write_room =           gs_write_room,
 883         .chars_in_buffer =      gs_chars_in_buffer,
 884         .unthrottle =           gs_unthrottle,
 885         .break_ctl =            gs_break_ctl,
 886 };
 887 
 888 /*-------------------------------------------------------------------------*/
 889 
 890 static struct tty_driver *gs_tty_driver;
 891 
 892 #ifdef CONFIG_U_SERIAL_CONSOLE
 893 
 894 static struct gscons_info gscons_info;
 895 static struct console gserial_cons;
 896 
 897 static struct usb_request *gs_request_new(struct usb_ep *ep)
 898 {
 899         struct usb_request *req = usb_ep_alloc_request(ep, GFP_ATOMIC);
 900         if (!req)
 901                 return NULL;
 902 
 903         req->buf = kmalloc(ep->maxpacket, GFP_ATOMIC);
 904         if (!req->buf) {
 905                 usb_ep_free_request(ep, req);
 906                 return NULL;
 907         }
 908 
 909         return req;
 910 }
 911 
 912 static void gs_request_free(struct usb_request *req, struct usb_ep *ep)
 913 {
 914         if (!req)
 915                 return;
 916 
 917         kfree(req->buf);
 918         usb_ep_free_request(ep, req);
 919 }
 920 
 921 static void gs_complete_out(struct usb_ep *ep, struct usb_request *req)
 922 {
 923         struct gscons_info *info = &gscons_info;
 924 
 925         switch (req->status) {
 926         default:
 927                 pr_warn("%s: unexpected %s status %d\n",
 928                         __func__, ep->name, req->status);
 929                 /* fall through */
 930         case 0:
 931                 /* normal completion */
 932                 spin_lock(&info->con_lock);
 933                 info->req_busy = 0;
 934                 spin_unlock(&info->con_lock);
 935 
 936                 wake_up_process(info->console_thread);
 937                 break;
 938         case -ESHUTDOWN:
 939                 /* disconnect */
 940                 pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
 941                 break;
 942         }
 943 }
 944 
 945 static int gs_console_connect(int port_num)
 946 {
 947         struct gscons_info *info = &gscons_info;
 948         struct gs_port *port;
 949         struct usb_ep *ep;
 950 
 951         if (port_num != gserial_cons.index) {
 952                 pr_err("%s: port num [%d] is not support console\n",
 953                        __func__, port_num);
 954                 return -ENXIO;
 955         }
 956 
 957         port = ports[port_num].port;
 958         ep = port->port_usb->in;
 959         if (!info->console_req) {
 960                 info->console_req = gs_request_new(ep);
 961                 if (!info->console_req)
 962                         return -ENOMEM;
 963                 info->console_req->complete = gs_complete_out;
 964         }
 965 
 966         info->port = port;
 967         spin_lock(&info->con_lock);
 968         info->req_busy = 0;
 969         spin_unlock(&info->con_lock);
 970         pr_vdebug("port[%d] console connect!\n", port_num);
 971         return 0;
 972 }
 973 
 974 static void gs_console_disconnect(struct usb_ep *ep)
 975 {
 976         struct gscons_info *info = &gscons_info;
 977         struct usb_request *req = info->console_req;
 978 
 979         gs_request_free(req, ep);
 980         info->console_req = NULL;
 981 }
 982 
 983 static int gs_console_thread(void *data)
 984 {
 985         struct gscons_info *info = &gscons_info;
 986         struct gs_port *port;
 987         struct usb_request *req;
 988         struct usb_ep *ep;
 989         int xfer, ret, count, size;
 990 
 991         do {
 992                 port = info->port;
 993                 set_current_state(TASK_INTERRUPTIBLE);
 994                 if (!port || !port->port_usb
 995                     || !port->port_usb->in || !info->console_req)
 996                         goto sched;
 997 
 998                 req = info->console_req;
 999                 ep = port->port_usb->in;
1000 
1001                 spin_lock_irq(&info->con_lock);
1002                 count = kfifo_len(&info->con_buf);
1003                 size = ep->maxpacket;
1004 
1005                 if (count > 0 && !info->req_busy) {
1006                         set_current_state(TASK_RUNNING);
1007                         if (count < size)
1008                                 size = count;
1009 
1010                         xfer = kfifo_out(&info->con_buf, req->buf, size);
1011                         req->length = xfer;
1012 
1013                         spin_unlock(&info->con_lock);
1014                         ret = usb_ep_queue(ep, req, GFP_ATOMIC);
1015                         spin_lock(&info->con_lock);
1016                         if (ret < 0)
1017                                 info->req_busy = 0;
1018                         else
1019                                 info->req_busy = 1;
1020 
1021                         spin_unlock_irq(&info->con_lock);
1022                 } else {
1023                         spin_unlock_irq(&info->con_lock);
1024 sched:
1025                         if (kthread_should_stop()) {
1026                                 set_current_state(TASK_RUNNING);
1027                                 break;
1028                         }
1029                         schedule();
1030                 }
1031         } while (1);
1032 
1033         return 0;
1034 }
1035 
1036 static int gs_console_setup(struct console *co, char *options)
1037 {
1038         struct gscons_info *info = &gscons_info;
1039         int status;
1040 
1041         info->port = NULL;
1042         info->console_req = NULL;
1043         info->req_busy = 0;
1044         spin_lock_init(&info->con_lock);
1045 
1046         status = kfifo_alloc(&info->con_buf, GS_CONSOLE_BUF_SIZE, GFP_KERNEL);
1047         if (status) {
1048                 pr_err("%s: allocate console buffer failed\n", __func__);
1049                 return status;
1050         }
1051 
1052         info->console_thread = kthread_create(gs_console_thread,
1053                                               co, "gs_console");
1054         if (IS_ERR(info->console_thread)) {
1055                 pr_err("%s: cannot create console thread\n", __func__);
1056                 kfifo_free(&info->con_buf);
1057                 return PTR_ERR(info->console_thread);
1058         }
1059         wake_up_process(info->console_thread);
1060 
1061         return 0;
1062 }
1063 
1064 static void gs_console_write(struct console *co,
1065                              const char *buf, unsigned count)
1066 {
1067         struct gscons_info *info = &gscons_info;
1068         unsigned long flags;
1069 
1070         spin_lock_irqsave(&info->con_lock, flags);
1071         kfifo_in(&info->con_buf, buf, count);
1072         spin_unlock_irqrestore(&info->con_lock, flags);
1073 
1074         wake_up_process(info->console_thread);
1075 }
1076 
1077 static struct tty_driver *gs_console_device(struct console *co, int *index)
1078 {
1079         struct tty_driver **p = (struct tty_driver **)co->data;
1080 
1081         if (!*p)
1082                 return NULL;
1083 
1084         *index = co->index;
1085         return *p;
1086 }
1087 
1088 static struct console gserial_cons = {
1089         .name =         "ttyGS",
1090         .write =        gs_console_write,
1091         .device =       gs_console_device,
1092         .setup =        gs_console_setup,
1093         .flags =        CON_PRINTBUFFER,
1094         .index =        -1,
1095         .data =         &gs_tty_driver,
1096 };
1097 
1098 static void gserial_console_init(void)
1099 {
1100         register_console(&gserial_cons);
1101 }
1102 
1103 static void gserial_console_exit(void)
1104 {
1105         struct gscons_info *info = &gscons_info;
1106 
1107         unregister_console(&gserial_cons);
1108         if (!IS_ERR_OR_NULL(info->console_thread))
1109                 kthread_stop(info->console_thread);
1110         kfifo_free(&info->con_buf);
1111 }
1112 
1113 #else
1114 
1115 static int gs_console_connect(int port_num)
1116 {
1117         return 0;
1118 }
1119 
1120 static void gs_console_disconnect(struct usb_ep *ep)
1121 {
1122 }
1123 
1124 static void gserial_console_init(void)
1125 {
1126 }
1127 
1128 static void gserial_console_exit(void)
1129 {
1130 }
1131 
1132 #endif
1133 
1134 static int
1135 gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding)
1136 {
1137         struct gs_port  *port;
1138         int             ret = 0;
1139 
1140         mutex_lock(&ports[port_num].lock);
1141         if (ports[port_num].port) {
1142                 ret = -EBUSY;
1143                 goto out;
1144         }
1145 
1146         port = kzalloc(sizeof(struct gs_port), GFP_KERNEL);
1147         if (port == NULL) {
1148                 ret = -ENOMEM;
1149                 goto out;
1150         }
1151 
1152         tty_port_init(&port->port);
1153         spin_lock_init(&port->port_lock);
1154         init_waitqueue_head(&port->drain_wait);
1155         init_waitqueue_head(&port->close_wait);
1156 
1157         INIT_DELAYED_WORK(&port->push, gs_rx_push);
1158 
1159         INIT_LIST_HEAD(&port->read_pool);
1160         INIT_LIST_HEAD(&port->read_queue);
1161         INIT_LIST_HEAD(&port->write_pool);
1162 
1163         port->port_num = port_num;
1164         port->port_line_coding = *coding;
1165 
1166         ports[port_num].port = port;
1167 out:
1168         mutex_unlock(&ports[port_num].lock);
1169         return ret;
1170 }
1171 
1172 static int gs_closed(struct gs_port *port)
1173 {
1174         int cond;
1175 
1176         spin_lock_irq(&port->port_lock);
1177         cond = (port->port.count == 0) && !port->openclose;
1178         spin_unlock_irq(&port->port_lock);
1179         return cond;
1180 }
1181 
1182 static void gserial_free_port(struct gs_port *port)
1183 {
1184         cancel_delayed_work_sync(&port->push);
1185         /* wait for old opens to finish */
1186         wait_event(port->close_wait, gs_closed(port));
1187         WARN_ON(port->port_usb != NULL);
1188         tty_port_destroy(&port->port);
1189         kfree(port);
1190 }
1191 
1192 void gserial_free_line(unsigned char port_num)
1193 {
1194         struct gs_port  *port;
1195 
1196         mutex_lock(&ports[port_num].lock);
1197         if (WARN_ON(!ports[port_num].port)) {
1198                 mutex_unlock(&ports[port_num].lock);
1199                 return;
1200         }
1201         port = ports[port_num].port;
1202         ports[port_num].port = NULL;
1203         mutex_unlock(&ports[port_num].lock);
1204 
1205         gserial_free_port(port);
1206         tty_unregister_device(gs_tty_driver, port_num);
1207         gserial_console_exit();
1208 }
1209 EXPORT_SYMBOL_GPL(gserial_free_line);
1210 
1211 int gserial_alloc_line(unsigned char *line_num)
1212 {
1213         struct usb_cdc_line_coding      coding;
1214         struct device                   *tty_dev;
1215         int                             ret;
1216         int                             port_num;
1217 
1218         coding.dwDTERate = cpu_to_le32(9600);
1219         coding.bCharFormat = 8;
1220         coding.bParityType = USB_CDC_NO_PARITY;
1221         coding.bDataBits = USB_CDC_1_STOP_BITS;
1222 
1223         for (port_num = 0; port_num < MAX_U_SERIAL_PORTS; port_num++) {
1224                 ret = gs_port_alloc(port_num, &coding);
1225                 if (ret == -EBUSY)
1226                         continue;
1227                 if (ret)
1228                         return ret;
1229                 break;
1230         }
1231         if (ret)
1232                 return ret;
1233 
1234         /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
1235 
1236         tty_dev = tty_port_register_device(&ports[port_num].port->port,
1237                         gs_tty_driver, port_num, NULL);
1238         if (IS_ERR(tty_dev)) {
1239                 struct gs_port  *port;
1240                 pr_err("%s: failed to register tty for port %d, err %ld\n",
1241                                 __func__, port_num, PTR_ERR(tty_dev));
1242 
1243                 ret = PTR_ERR(tty_dev);
1244                 mutex_lock(&ports[port_num].lock);
1245                 port = ports[port_num].port;
1246                 ports[port_num].port = NULL;
1247                 mutex_unlock(&ports[port_num].lock);
1248                 gserial_free_port(port);
1249                 goto err;
1250         }
1251         *line_num = port_num;
1252         gserial_console_init();
1253 err:
1254         return ret;
1255 }
1256 EXPORT_SYMBOL_GPL(gserial_alloc_line);
1257 
1258 /**
1259  * gserial_connect - notify TTY I/O glue that USB link is active
1260  * @gser: the function, set up with endpoints and descriptors
1261  * @port_num: which port is active
1262  * Context: any (usually from irq)
1263  *
1264  * This is called activate endpoints and let the TTY layer know that
1265  * the connection is active ... not unlike "carrier detect".  It won't
1266  * necessarily start I/O queues; unless the TTY is held open by any
1267  * task, there would be no point.  However, the endpoints will be
1268  * activated so the USB host can perform I/O, subject to basic USB
1269  * hardware flow control.
1270  *
1271  * Caller needs to have set up the endpoints and USB function in @dev
1272  * before calling this, as well as the appropriate (speed-specific)
1273  * endpoint descriptors, and also have allocate @port_num by calling
1274  * @gserial_alloc_line().
1275  *
1276  * Returns negative errno or zero.
1277  * On success, ep->driver_data will be overwritten.
1278  */
1279 int gserial_connect(struct gserial *gser, u8 port_num)
1280 {
1281         struct gs_port  *port;
1282         unsigned long   flags;
1283         int             status;
1284 
1285         if (port_num >= MAX_U_SERIAL_PORTS)
1286                 return -ENXIO;
1287 
1288         port = ports[port_num].port;
1289         if (!port) {
1290                 pr_err("serial line %d not allocated.\n", port_num);
1291                 return -EINVAL;
1292         }
1293         if (port->port_usb) {
1294                 pr_err("serial line %d is in use.\n", port_num);
1295                 return -EBUSY;
1296         }
1297 
1298         /* activate the endpoints */
1299         status = usb_ep_enable(gser->in);
1300         if (status < 0)
1301                 return status;
1302         gser->in->driver_data = port;
1303 
1304         status = usb_ep_enable(gser->out);
1305         if (status < 0)
1306                 goto fail_out;
1307         gser->out->driver_data = port;
1308 
1309         /* then tell the tty glue that I/O can work */
1310         spin_lock_irqsave(&port->port_lock, flags);
1311         gser->ioport = port;
1312         port->port_usb = gser;
1313 
1314         /* REVISIT unclear how best to handle this state...
1315          * we don't really couple it with the Linux TTY.
1316          */
1317         gser->port_line_coding = port->port_line_coding;
1318 
1319         /* REVISIT if waiting on "carrier detect", signal. */
1320 
1321         /* if it's already open, start I/O ... and notify the serial
1322          * protocol about open/close status (connect/disconnect).
1323          */
1324         if (port->port.count) {
1325                 pr_debug("gserial_connect: start ttyGS%d\n", port->port_num);
1326                 gs_start_io(port);
1327                 if (gser->connect)
1328                         gser->connect(gser);
1329         } else {
1330                 if (gser->disconnect)
1331                         gser->disconnect(gser);
1332         }
1333 
1334         status = gs_console_connect(port_num);
1335         spin_unlock_irqrestore(&port->port_lock, flags);
1336 
1337         return status;
1338 
1339 fail_out:
1340         usb_ep_disable(gser->in);
1341         return status;
1342 }
1343 EXPORT_SYMBOL_GPL(gserial_connect);
1344 /**
1345  * gserial_disconnect - notify TTY I/O glue that USB link is inactive
1346  * @gser: the function, on which gserial_connect() was called
1347  * Context: any (usually from irq)
1348  *
1349  * This is called to deactivate endpoints and let the TTY layer know
1350  * that the connection went inactive ... not unlike "hangup".
1351  *
1352  * On return, the state is as if gserial_connect() had never been called;
1353  * there is no active USB I/O on these endpoints.
1354  */
1355 void gserial_disconnect(struct gserial *gser)
1356 {
1357         struct gs_port  *port = gser->ioport;
1358         unsigned long   flags;
1359 
1360         if (!port)
1361                 return;
1362 
1363         /* tell the TTY glue not to do I/O here any more */
1364         spin_lock_irqsave(&port->port_lock, flags);
1365 
1366         /* REVISIT as above: how best to track this? */
1367         port->port_line_coding = gser->port_line_coding;
1368 
1369         port->port_usb = NULL;
1370         gser->ioport = NULL;
1371         if (port->port.count > 0 || port->openclose) {
1372                 wake_up_interruptible(&port->drain_wait);
1373                 if (port->port.tty)
1374                         tty_hangup(port->port.tty);
1375         }
1376         spin_unlock_irqrestore(&port->port_lock, flags);
1377 
1378         /* disable endpoints, aborting down any active I/O */
1379         usb_ep_disable(gser->out);
1380         usb_ep_disable(gser->in);
1381 
1382         /* finally, free any unused/unusable I/O buffers */
1383         spin_lock_irqsave(&port->port_lock, flags);
1384         if (port->port.count == 0 && !port->openclose)
1385                 kfifo_free(&port->port_write_buf);
1386         gs_free_requests(gser->out, &port->read_pool, NULL);
1387         gs_free_requests(gser->out, &port->read_queue, NULL);
1388         gs_free_requests(gser->in, &port->write_pool, NULL);
1389 
1390         port->read_allocated = port->read_started =
1391                 port->write_allocated = port->write_started = 0;
1392 
1393         gs_console_disconnect(gser->in);
1394         spin_unlock_irqrestore(&port->port_lock, flags);
1395 }
1396 EXPORT_SYMBOL_GPL(gserial_disconnect);
1397 
1398 static int userial_init(void)
1399 {
1400         unsigned                        i;
1401         int                             status;
1402 
1403         gs_tty_driver = alloc_tty_driver(MAX_U_SERIAL_PORTS);
1404         if (!gs_tty_driver)
1405                 return -ENOMEM;
1406 
1407         gs_tty_driver->driver_name = "g_serial";
1408         gs_tty_driver->name = "ttyGS";
1409         /* uses dynamically assigned dev_t values */
1410 
1411         gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1412         gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1413         gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1414         gs_tty_driver->init_termios = tty_std_termios;
1415 
1416         /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
1417          * MS-Windows.  Otherwise, most of these flags shouldn't affect
1418          * anything unless we were to actually hook up to a serial line.
1419          */
1420         gs_tty_driver->init_termios.c_cflag =
1421                         B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1422         gs_tty_driver->init_termios.c_ispeed = 9600;
1423         gs_tty_driver->init_termios.c_ospeed = 9600;
1424 
1425         tty_set_operations(gs_tty_driver, &gs_tty_ops);
1426         for (i = 0; i < MAX_U_SERIAL_PORTS; i++)
1427                 mutex_init(&ports[i].lock);
1428 
1429         /* export the driver ... */
1430         status = tty_register_driver(gs_tty_driver);
1431         if (status) {
1432                 pr_err("%s: cannot register, err %d\n",
1433                                 __func__, status);
1434                 goto fail;
1435         }
1436 
1437         pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
1438                         MAX_U_SERIAL_PORTS,
1439                         (MAX_U_SERIAL_PORTS == 1) ? "" : "s");
1440 
1441         return status;
1442 fail:
1443         put_tty_driver(gs_tty_driver);
1444         gs_tty_driver = NULL;
1445         return status;
1446 }
1447 module_init(userial_init);
1448 
1449 static void userial_cleanup(void)
1450 {
1451         tty_unregister_driver(gs_tty_driver);
1452         put_tty_driver(gs_tty_driver);
1453         gs_tty_driver = NULL;
1454 }
1455 module_exit(userial_cleanup);
1456 
1457 MODULE_LICENSE("GPL");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/usb/gadget/function/u_serial.c

DEFINITIONS
