88d4f5452c49baaf42ed6e342139b2977dbc1cea
[linux-3.10.git] / drivers / usb / gadget / 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/interrupt.h>
22 #include <linux/device.h>
23 #include <linux/delay.h>
24 #include <linux/tty.h>
25 #include <linux/tty_flip.h>
26
27 #include "u_serial.h"
28
29
30 /*
31  * This component encapsulates the TTY layer glue needed to provide basic
32  * "serial port" functionality through the USB gadget stack.  Each such
33  * port is exposed through a /dev/ttyGS* node.
34  *
35  * After initialization (gserial_setup), these TTY port devices stay
36  * available until they are removed (gserial_cleanup).  Each one may be
37  * connected to a USB function (gserial_connect), or disconnected (with
38  * gserial_disconnect) when the USB host issues a config change event.
39  * Data can only flow when the port is connected to the host.
40  *
41  * A given TTY port can be made available in multiple configurations.
42  * For example, each one might expose a ttyGS0 node which provides a
43  * login application.  In one case that might use CDC ACM interface 0,
44  * while another configuration might use interface 3 for that.  The
45  * work to handle that (including descriptor management) is not part
46  * of this component.
47  *
48  * Configurations may expose more than one TTY port.  For example, if
49  * ttyGS0 provides login service, then ttyGS1 might provide dialer access
50  * for a telephone or fax link.  And ttyGS2 might be something that just
51  * needs a simple byte stream interface for some messaging protocol that
52  * is managed in userspace ... OBEX, PTP, and MTP have been mentioned.
53  */
54
55 /*
56  * gserial is the lifecycle interface, used by USB functions
57  * gs_port is the I/O nexus, used by the tty driver
58  * tty_struct links to the tty/filesystem framework
59  *
60  * gserial <---> gs_port ... links will be null when the USB link is
61  * inactive; managed by gserial_{connect,disconnect}().
62  *      gserial->ioport == usb_ep->driver_data ... gs_port
63  *      gs_port->port_usb ... gserial
64  *
65  * gs_port <---> tty_struct ... links will be null when the TTY file
66  * isn't opened; managed by gs_open()/gs_close()
67  *      gserial->port_tty ... tty_struct
68  *      tty_struct->driver_data ... gserial
69  */
70
71 /* RX and TX queues can buffer QUEUE_SIZE packets before they hit the
72  * next layer of buffering.  For TX that's a circular buffer; for RX
73  * consider it a NOP.  A third layer is provided by the TTY code.
74  */
75 #define QUEUE_SIZE              16
76 #define WRITE_BUF_SIZE          8192            /* TX only */
77
78 /* circular buffer */
79 struct gs_buf {
80         unsigned                buf_size;
81         char                    *buf_buf;
82         char                    *buf_get;
83         char                    *buf_put;
84 };
85
86 /*
87  * The port structure holds info for each port, one for each minor number
88  * (and thus for each /dev/ node).
89  */
90 struct gs_port {
91         spinlock_t              port_lock;      /* guard port_* access */
92
93         struct gserial          *port_usb;
94         struct tty_struct       *port_tty;
95
96         unsigned                open_count;
97         bool                    openclose;      /* open/close in progress */
98         u8                      port_num;
99
100         wait_queue_head_t       close_wait;     /* wait for last close */
101
102         struct list_head        read_pool;
103         struct tasklet_struct   push;
104
105         struct list_head        write_pool;
106         struct gs_buf           port_write_buf;
107         wait_queue_head_t       drain_wait;     /* wait while writes drain */
108
109         /* REVISIT this state ... */
110         struct usb_cdc_line_coding port_line_coding;    /* 8-N-1 etc */
111 };
112
113 /* increase N_PORTS if you need more */
114 #define N_PORTS         4
115 static struct portmaster {
116         struct mutex    lock;                   /* protect open/close */
117         struct gs_port  *port;
118 } ports[N_PORTS];
119 static unsigned n_ports;
120
121 #define GS_CLOSE_TIMEOUT                15              /* seconds */
122
123
124
125 #ifdef VERBOSE_DEBUG
126 #define pr_vdebug(fmt, arg...) \
127         pr_debug(fmt, ##arg)
128 #else
129 #define pr_vdebug(fmt, arg...) \
130         ({ if (0) pr_debug(fmt, ##arg); })
131 #endif
132
133 /*-------------------------------------------------------------------------*/
134
135 /* Circular Buffer */
136
137 /*
138  * gs_buf_alloc
139  *
140  * Allocate a circular buffer and all associated memory.
141  */
142 static int gs_buf_alloc(struct gs_buf *gb, unsigned size)
143 {
144         gb->buf_buf = kmalloc(size, GFP_KERNEL);
145         if (gb->buf_buf == NULL)
146                 return -ENOMEM;
147
148         gb->buf_size = size;
149         gb->buf_put = gb->buf_buf;
150         gb->buf_get = gb->buf_buf;
151
152         return 0;
153 }
154
155 /*
156  * gs_buf_free
157  *
158  * Free the buffer and all associated memory.
159  */
160 static void gs_buf_free(struct gs_buf *gb)
161 {
162         kfree(gb->buf_buf);
163         gb->buf_buf = NULL;
164 }
165
166 /*
167  * gs_buf_clear
168  *
169  * Clear out all data in the circular buffer.
170  */
171 static void gs_buf_clear(struct gs_buf *gb)
172 {
173         gb->buf_get = gb->buf_put;
174         /* equivalent to a get of all data available */
175 }
176
177 /*
178  * gs_buf_data_avail
179  *
180  * Return the number of bytes of data available in the circular
181  * buffer.
182  */
183 static unsigned gs_buf_data_avail(struct gs_buf *gb)
184 {
185         return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size;
186 }
187
188 /*
189  * gs_buf_space_avail
190  *
191  * Return the number of bytes of space available in the circular
192  * buffer.
193  */
194 static unsigned gs_buf_space_avail(struct gs_buf *gb)
195 {
196         return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size;
197 }
198
199 /*
200  * gs_buf_put
201  *
202  * Copy data data from a user buffer and put it into the circular buffer.
203  * Restrict to the amount of space available.
204  *
205  * Return the number of bytes copied.
206  */
207 static unsigned
208 gs_buf_put(struct gs_buf *gb, const char *buf, unsigned count)
209 {
210         unsigned len;
211
212         len  = gs_buf_space_avail(gb);
213         if (count > len)
214                 count = len;
215
216         if (count == 0)
217                 return 0;
218
219         len = gb->buf_buf + gb->buf_size - gb->buf_put;
220         if (count > len) {
221                 memcpy(gb->buf_put, buf, len);
222                 memcpy(gb->buf_buf, buf+len, count - len);
223                 gb->buf_put = gb->buf_buf + count - len;
224         } else {
225                 memcpy(gb->buf_put, buf, count);
226                 if (count < len)
227                         gb->buf_put += count;
228                 else /* count == len */
229                         gb->buf_put = gb->buf_buf;
230         }
231
232         return count;
233 }
234
235 /*
236  * gs_buf_get
237  *
238  * Get data from the circular buffer and copy to the given buffer.
239  * Restrict to the amount of data available.
240  *
241  * Return the number of bytes copied.
242  */
243 static unsigned
244 gs_buf_get(struct gs_buf *gb, char *buf, unsigned count)
245 {
246         unsigned len;
247
248         len = gs_buf_data_avail(gb);
249         if (count > len)
250                 count = len;
251
252         if (count == 0)
253                 return 0;
254
255         len = gb->buf_buf + gb->buf_size - gb->buf_get;
256         if (count > len) {
257                 memcpy(buf, gb->buf_get, len);
258                 memcpy(buf+len, gb->buf_buf, count - len);
259                 gb->buf_get = gb->buf_buf + count - len;
260         } else {
261                 memcpy(buf, gb->buf_get, count);
262                 if (count < len)
263                         gb->buf_get += count;
264                 else /* count == len */
265                         gb->buf_get = gb->buf_buf;
266         }
267
268         return count;
269 }
270
271 /*-------------------------------------------------------------------------*/
272
273 /* I/O glue between TTY (upper) and USB function (lower) driver layers */
274
275 /*
276  * gs_alloc_req
277  *
278  * Allocate a usb_request and its buffer.  Returns a pointer to the
279  * usb_request or NULL if there is an error.
280  */
281 static struct usb_request *
282 gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
283 {
284         struct usb_request *req;
285
286         req = usb_ep_alloc_request(ep, kmalloc_flags);
287
288         if (req != NULL) {
289                 req->length = len;
290                 req->buf = kmalloc(len, kmalloc_flags);
291                 if (req->buf == NULL) {
292                         usb_ep_free_request(ep, req);
293                         return NULL;
294                 }
295         }
296
297         return req;
298 }
299
300 /*
301  * gs_free_req
302  *
303  * Free a usb_request and its buffer.
304  */
305 static void gs_free_req(struct usb_ep *ep, struct usb_request *req)
306 {
307         kfree(req->buf);
308         usb_ep_free_request(ep, req);
309 }
310
311 /*
312  * gs_send_packet
313  *
314  * If there is data to send, a packet is built in the given
315  * buffer and the size is returned.  If there is no data to
316  * send, 0 is returned.
317  *
318  * Called with port_lock held.
319  */
320 static unsigned
321 gs_send_packet(struct gs_port *port, char *packet, unsigned size)
322 {
323         unsigned len;
324
325         len = gs_buf_data_avail(&port->port_write_buf);
326         if (len < size)
327                 size = len;
328         if (size != 0)
329                 size = gs_buf_get(&port->port_write_buf, packet, size);
330         return size;
331 }
332
333 /*
334  * gs_start_tx
335  *
336  * This function finds available write requests, calls
337  * gs_send_packet to fill these packets with data, and
338  * continues until either there are no more write requests
339  * available or no more data to send.  This function is
340  * run whenever data arrives or write requests are available.
341  *
342  * Context: caller owns port_lock; port_usb is non-null.
343  */
344 static int gs_start_tx(struct gs_port *port)
345 /*
346 __releases(&port->port_lock)
347 __acquires(&port->port_lock)
348 */
349 {
350         struct list_head        *pool = &port->write_pool;
351         struct usb_ep           *in = port->port_usb->in;
352         int                     status = 0;
353         bool                    do_tty_wake = false;
354
355         while (!list_empty(pool)) {
356                 struct usb_request      *req;
357                 int                     len;
358
359                 req = list_entry(pool->next, struct usb_request, list);
360                 len = gs_send_packet(port, req->buf, in->maxpacket);
361                 if (len == 0) {
362                         wake_up_interruptible(&port->drain_wait);
363                         break;
364                 }
365                 do_tty_wake = true;
366
367                 req->length = len;
368                 list_del(&req->list);
369
370 #ifdef VERBOSE_DEBUG
371                 pr_debug("%s: %s, len=%d, 0x%02x 0x%02x 0x%02x ...\n",
372                                 __func__, in->name, len, *((u8 *)req->buf),
373                                 *((u8 *)req->buf+1), *((u8 *)req->buf+2));
374 #endif
375
376                 /* Drop lock while we call out of driver; completions
377                  * could be issued while we do so.  Disconnection may
378                  * happen too; maybe immediately before we queue this!
379                  *
380                  * NOTE that we may keep sending data for a while after
381                  * the TTY closed (dev->ioport->port_tty is NULL).
382                  */
383                 spin_unlock(&port->port_lock);
384                 status = usb_ep_queue(in, req, GFP_ATOMIC);
385                 spin_lock(&port->port_lock);
386
387                 if (status) {
388                         pr_debug("%s: %s %s err %d\n",
389                                         __func__, "queue", in->name, status);
390                         list_add(&req->list, pool);
391                         break;
392                 }
393
394                 /* abort immediately after disconnect */
395                 if (!port->port_usb)
396                         break;
397         }
398
399         if (do_tty_wake && port->port_tty)
400                 tty_wakeup(port->port_tty);
401         return status;
402 }
403
404 static void gs_rx_push(unsigned long _port)
405 {
406         struct gs_port          *port = (void *)_port;
407         struct tty_struct       *tty = port->port_tty;
408
409         /* With low_latency, tty_flip_buffer_push() doesn't put its
410          * real work through a workqueue, so the ldisc has a better
411          * chance to keep up with peak USB data rates.
412          */
413         if (tty) {
414                 tty_flip_buffer_push(tty);
415                 wake_up_interruptible(&tty->read_wait);
416         }
417 }
418
419 /*
420  * gs_recv_packet
421  *
422  * Called for each USB packet received.  Reads the packet
423  * header and stuffs the data in the appropriate tty buffer.
424  * Returns 0 if successful, or a negative error number.
425  *
426  * Called during USB completion routine, on interrupt time.
427  * With port_lock.
428  */
429 static int gs_recv_packet(struct gs_port *port, char *packet, unsigned size)
430 {
431         unsigned                len;
432         struct tty_struct       *tty;
433
434         /* I/O completions can continue for a while after close(), until the
435          * request queue empties.  Just discard any data we receive, until
436          * something reopens this TTY ... as if there were no HW flow control.
437          */
438         tty = port->port_tty;
439         if (tty == NULL) {
440                 pr_vdebug("%s: ttyGS%d, after close\n",
441                                 __func__, port->port_num);
442                 return -EIO;
443         }
444
445         len = tty_insert_flip_string(tty, packet, size);
446         if (len > 0)
447                 tasklet_schedule(&port->push);
448         if (len < size)
449                 pr_debug("%s: ttyGS%d, drop %d bytes\n",
450                                 __func__, port->port_num, size - len);
451         return 0;
452 }
453
454 /*
455  * Context: caller owns port_lock, and port_usb is set
456  */
457 static unsigned gs_start_rx(struct gs_port *port)
458 /*
459 __releases(&port->port_lock)
460 __acquires(&port->port_lock)
461 */
462 {
463         struct list_head        *pool = &port->read_pool;
464         struct usb_ep           *out = port->port_usb->out;
465         unsigned                started = 0;
466
467         while (!list_empty(pool)) {
468                 struct usb_request      *req;
469                 int                     status;
470                 struct tty_struct       *tty;
471
472                 /* no more rx if closed or throttled */
473                 tty = port->port_tty;
474                 if (!tty || test_bit(TTY_THROTTLED, &tty->flags))
475                         break;
476
477                 req = list_entry(pool->next, struct usb_request, list);
478                 list_del(&req->list);
479                 req->length = out->maxpacket;
480
481                 /* drop lock while we call out; the controller driver
482                  * may need to call us back (e.g. for disconnect)
483                  */
484                 spin_unlock(&port->port_lock);
485                 status = usb_ep_queue(out, req, GFP_ATOMIC);
486                 spin_lock(&port->port_lock);
487
488                 if (status) {
489                         pr_debug("%s: %s %s err %d\n",
490                                         __func__, "queue", out->name, status);
491                         list_add(&req->list, pool);
492                         break;
493                 }
494                 started++;
495
496                 /* abort immediately after disconnect */
497                 if (!port->port_usb)
498                         break;
499         }
500         return started;
501 }
502
503 static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
504 {
505         int             status;
506         struct gs_port  *port = ep->driver_data;
507
508         spin_lock(&port->port_lock);
509         list_add(&req->list, &port->read_pool);
510
511         switch (req->status) {
512         case 0:
513                 /* normal completion */
514                 status = gs_recv_packet(port, req->buf, req->actual);
515                 if (status && status != -EIO)
516                         pr_debug("%s: %s %s err %d\n",
517                                 __func__, "recv", ep->name, status);
518                 gs_start_rx(port);
519                 break;
520
521         case -ESHUTDOWN:
522                 /* disconnect */
523                 pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
524                 break;
525
526         default:
527                 /* presumably a transient fault */
528                 pr_warning("%s: unexpected %s status %d\n",
529                                 __func__, ep->name, req->status);
530                 gs_start_rx(port);
531                 break;
532         }
533         spin_unlock(&port->port_lock);
534 }
535
536 static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
537 {
538         struct gs_port  *port = ep->driver_data;
539
540         spin_lock(&port->port_lock);
541         list_add(&req->list, &port->write_pool);
542
543         switch (req->status) {
544         default:
545                 /* presumably a transient fault */
546                 pr_warning("%s: unexpected %s status %d\n",
547                                 __func__, ep->name, req->status);
548                 /* FALL THROUGH */
549         case 0:
550                 /* normal completion */
551                 gs_start_tx(port);
552                 break;
553
554         case -ESHUTDOWN:
555                 /* disconnect */
556                 pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
557                 break;
558         }
559
560         spin_unlock(&port->port_lock);
561 }
562
563 static void gs_free_requests(struct usb_ep *ep, struct list_head *head)
564 {
565         struct usb_request      *req;
566
567         while (!list_empty(head)) {
568                 req = list_entry(head->next, struct usb_request, list);
569                 list_del(&req->list);
570                 gs_free_req(ep, req);
571         }
572 }
573
574 static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
575                 void (*fn)(struct usb_ep *, struct usb_request *))
576 {
577         int                     i;
578         struct usb_request      *req;
579
580         /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't
581          * do quite that many this time, don't fail ... we just won't
582          * be as speedy as we might otherwise be.
583          */
584         for (i = 0; i < QUEUE_SIZE; i++) {
585                 req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
586                 if (!req)
587                         return list_empty(head) ? -ENOMEM : 0;
588                 req->complete = fn;
589                 list_add_tail(&req->list, head);
590         }
591         return 0;
592 }
593
594 /**
595  * gs_start_io - start USB I/O streams
596  * @dev: encapsulates endpoints to use
597  * Context: holding port_lock; port_tty and port_usb are non-null
598  *
599  * We only start I/O when something is connected to both sides of
600  * this port.  If nothing is listening on the host side, we may
601  * be pointlessly filling up our TX buffers and FIFO.
602  */
603 static int gs_start_io(struct gs_port *port)
604 {
605         struct list_head        *head = &port->read_pool;
606         struct usb_ep           *ep = port->port_usb->out;
607         int                     status;
608         unsigned                started;
609
610         /* Allocate RX and TX I/O buffers.  We can't easily do this much
611          * earlier (with GFP_KERNEL) because the requests are coupled to
612          * endpoints, as are the packet sizes we'll be using.  Different
613          * configurations may use different endpoints with a given port;
614          * and high speed vs full speed changes packet sizes too.
615          */
616         status = gs_alloc_requests(ep, head, gs_read_complete);
617         if (status)
618                 return status;
619
620         status = gs_alloc_requests(port->port_usb->in, &port->write_pool,
621                         gs_write_complete);
622         if (status) {
623                 gs_free_requests(ep, head);
624                 return status;
625         }
626
627         /* queue read requests */
628         started = gs_start_rx(port);
629
630         /* unblock any pending writes into our circular buffer */
631         if (started) {
632                 tty_wakeup(port->port_tty);
633         } else {
634                 gs_free_requests(ep, head);
635                 gs_free_requests(port->port_usb->in, &port->write_pool);
636         }
637
638         return started ? 0 : status;
639 }
640
641 /*-------------------------------------------------------------------------*/
642
643 /* TTY Driver */
644
645 /*
646  * gs_open sets up the link between a gs_port and its associated TTY.
647  * That link is broken *only* by TTY close(), and all driver methods
648  * know that.
649  */
650 static int gs_open(struct tty_struct *tty, struct file *file)
651 {
652         int             port_num = tty->index;
653         struct gs_port  *port;
654         int             status;
655
656         if (port_num < 0 || port_num >= n_ports)
657                 return -ENXIO;
658
659         do {
660                 mutex_lock(&ports[port_num].lock);
661                 port = ports[port_num].port;
662                 if (!port)
663                         status = -ENODEV;
664                 else {
665                         spin_lock_irq(&port->port_lock);
666
667                         /* already open?  Great. */
668                         if (port->open_count) {
669                                 status = 0;
670                                 port->open_count++;
671
672                         /* currently opening/closing? wait ... */
673                         } else if (port->openclose) {
674                                 status = -EBUSY;
675
676                         /* ... else we do the work */
677                         } else {
678                                 status = -EAGAIN;
679                                 port->openclose = true;
680                         }
681                         spin_unlock_irq(&port->port_lock);
682                 }
683                 mutex_unlock(&ports[port_num].lock);
684
685                 switch (status) {
686                 default:
687                         /* fully handled */
688                         return status;
689                 case -EAGAIN:
690                         /* must do the work */
691                         break;
692                 case -EBUSY:
693                         /* wait for EAGAIN task to finish */
694                         msleep(1);
695                         /* REVISIT could have a waitchannel here, if
696                          * concurrent open performance is important
697                          */
698                         break;
699                 }
700         } while (status != -EAGAIN);
701
702         /* Do the "real open" */
703         spin_lock_irq(&port->port_lock);
704
705         /* allocate circular buffer on first open */
706         if (port->port_write_buf.buf_buf == NULL) {
707
708                 spin_unlock_irq(&port->port_lock);
709                 status = gs_buf_alloc(&port->port_write_buf, WRITE_BUF_SIZE);
710                 spin_lock_irq(&port->port_lock);
711
712                 if (status) {
713                         pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n",
714                                 port->port_num, tty, file);
715                         port->openclose = false;
716                         goto exit_unlock_port;
717                 }
718         }
719
720         /* REVISIT if REMOVED (ports[].port NULL), abort the open
721          * to let rmmod work faster (but this way isn't wrong).
722          */
723
724         /* REVISIT maybe wait for "carrier detect" */
725
726         tty->driver_data = port;
727         port->port_tty = tty;
728
729         port->open_count = 1;
730         port->openclose = false;
731
732         /* low_latency means ldiscs work in tasklet context, without
733          * needing a workqueue schedule ... easier to keep up.
734          */
735         tty->low_latency = 1;
736
737         /* if connected, start the I/O stream */
738         if (port->port_usb) {
739                 pr_debug("gs_open: start ttyGS%d\n", port->port_num);
740                 gs_start_io(port);
741
742                 /* REVISIT for ACM, issue "network connected" event */
743         }
744
745         pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file);
746
747         status = 0;
748
749 exit_unlock_port:
750         spin_unlock_irq(&port->port_lock);
751         return status;
752 }
753
754 static int gs_writes_finished(struct gs_port *p)
755 {
756         int cond;
757
758         /* return true on disconnect or empty buffer */
759         spin_lock_irq(&p->port_lock);
760         cond = (p->port_usb == NULL) || !gs_buf_data_avail(&p->port_write_buf);
761         spin_unlock_irq(&p->port_lock);
762
763         return cond;
764 }
765
766 static void gs_close(struct tty_struct *tty, struct file *file)
767 {
768         struct gs_port *port = tty->driver_data;
769
770         spin_lock_irq(&port->port_lock);
771
772         if (port->open_count != 1) {
773                 if (port->open_count == 0)
774                         WARN_ON(1);
775                 else
776                         --port->open_count;
777                 goto exit;
778         }
779
780         pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file);
781
782         /* mark port as closing but in use; we can drop port lock
783          * and sleep if necessary
784          */
785         port->openclose = true;
786         port->open_count = 0;
787
788         if (port->port_usb)
789                 /* REVISIT for ACM, issue "network disconnected" event */;
790
791         /* wait for circular write buffer to drain, disconnect, or at
792          * most GS_CLOSE_TIMEOUT seconds; then discard the rest
793          */
794         if (gs_buf_data_avail(&port->port_write_buf) > 0
795                         && port->port_usb) {
796                 spin_unlock_irq(&port->port_lock);
797                 wait_event_interruptible_timeout(port->drain_wait,
798                                         gs_writes_finished(port),
799                                         GS_CLOSE_TIMEOUT * HZ);
800                 spin_lock_irq(&port->port_lock);
801         }
802
803         /* Iff we're disconnected, there can be no I/O in flight so it's
804          * ok to free the circular buffer; else just scrub it.  And don't
805          * let the push tasklet fire again until we're re-opened.
806          */
807         if (port->port_usb == NULL)
808                 gs_buf_free(&port->port_write_buf);
809         else
810                 gs_buf_clear(&port->port_write_buf);
811
812         tasklet_kill(&port->push);
813
814         tty->driver_data = NULL;
815         port->port_tty = NULL;
816
817         port->openclose = false;
818
819         pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
820                         port->port_num, tty, file);
821
822         wake_up_interruptible(&port->close_wait);
823 exit:
824         spin_unlock_irq(&port->port_lock);
825 }
826
827 static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
828 {
829         struct gs_port  *port = tty->driver_data;
830         unsigned long   flags;
831         int             status;
832
833         pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
834                         port->port_num, tty, count);
835
836         spin_lock_irqsave(&port->port_lock, flags);
837         if (count)
838                 count = gs_buf_put(&port->port_write_buf, buf, count);
839         /* treat count == 0 as flush_chars() */
840         if (port->port_usb)
841                 status = gs_start_tx(port);
842         spin_unlock_irqrestore(&port->port_lock, flags);
843
844         return count;
845 }
846
847 static int gs_put_char(struct tty_struct *tty, unsigned char ch)
848 {
849         struct gs_port  *port = tty->driver_data;
850         unsigned long   flags;
851         int             status;
852
853         pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %p\n",
854                 port->port_num, tty, ch, __builtin_return_address(0));
855
856         spin_lock_irqsave(&port->port_lock, flags);
857         status = gs_buf_put(&port->port_write_buf, &ch, 1);
858         spin_unlock_irqrestore(&port->port_lock, flags);
859
860         return status;
861 }
862
863 static void gs_flush_chars(struct tty_struct *tty)
864 {
865         struct gs_port  *port = tty->driver_data;
866         unsigned long   flags;
867
868         pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
869
870         spin_lock_irqsave(&port->port_lock, flags);
871         if (port->port_usb)
872                 gs_start_tx(port);
873         spin_unlock_irqrestore(&port->port_lock, flags);
874 }
875
876 static int gs_write_room(struct tty_struct *tty)
877 {
878         struct gs_port  *port = tty->driver_data;
879         unsigned long   flags;
880         int             room = 0;
881
882         spin_lock_irqsave(&port->port_lock, flags);
883         if (port->port_usb)
884                 room = gs_buf_space_avail(&port->port_write_buf);
885         spin_unlock_irqrestore(&port->port_lock, flags);
886
887         pr_vdebug("gs_write_room: (%d,%p) room=%d\n",
888                 port->port_num, tty, room);
889
890         return room;
891 }
892
893 static int gs_chars_in_buffer(struct tty_struct *tty)
894 {
895         struct gs_port  *port = tty->driver_data;
896         unsigned long   flags;
897         int             chars = 0;
898
899         spin_lock_irqsave(&port->port_lock, flags);
900         chars = gs_buf_data_avail(&port->port_write_buf);
901         spin_unlock_irqrestore(&port->port_lock, flags);
902
903         pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
904                 port->port_num, tty, chars);
905
906         return chars;
907 }
908
909 /* undo side effects of setting TTY_THROTTLED */
910 static void gs_unthrottle(struct tty_struct *tty)
911 {
912         struct gs_port          *port = tty->driver_data;
913         unsigned long           flags;
914         unsigned                started = 0;
915
916         spin_lock_irqsave(&port->port_lock, flags);
917         if (port->port_usb)
918                 started = gs_start_rx(port);
919         spin_unlock_irqrestore(&port->port_lock, flags);
920
921         pr_vdebug("gs_unthrottle: ttyGS%d, %d packets\n",
922                         port->port_num, started);
923 }
924
925 static const struct tty_operations gs_tty_ops = {
926         .open =                 gs_open,
927         .close =                gs_close,
928         .write =                gs_write,
929         .put_char =             gs_put_char,
930         .flush_chars =          gs_flush_chars,
931         .write_room =           gs_write_room,
932         .chars_in_buffer =      gs_chars_in_buffer,
933         .unthrottle =           gs_unthrottle,
934 };
935
936 /*-------------------------------------------------------------------------*/
937
938 static struct tty_driver *gs_tty_driver;
939
940 static int __init
941 gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding)
942 {
943         struct gs_port  *port;
944
945         port = kzalloc(sizeof(struct gs_port), GFP_KERNEL);
946         if (port == NULL)
947                 return -ENOMEM;
948
949         spin_lock_init(&port->port_lock);
950         init_waitqueue_head(&port->close_wait);
951         init_waitqueue_head(&port->drain_wait);
952
953         tasklet_init(&port->push, gs_rx_push, (unsigned long) port);
954
955         INIT_LIST_HEAD(&port->read_pool);
956         INIT_LIST_HEAD(&port->write_pool);
957
958         port->port_num = port_num;
959         port->port_line_coding = *coding;
960
961         ports[port_num].port = port;
962
963         return 0;
964 }
965
966 /**
967  * gserial_setup - initialize TTY driver for one or more ports
968  * @g: gadget to associate with these ports
969  * @count: how many ports to support
970  * Context: may sleep
971  *
972  * The TTY stack needs to know in advance how many devices it should
973  * plan to manage.  Use this call to set up the ports you will be
974  * exporting through USB.  Later, connect them to functions based
975  * on what configuration is activated by the USB host; and disconnect
976  * them as appropriate.
977  *
978  * An example would be a two-configuration device in which both
979  * configurations expose port 0, but through different functions.
980  * One configuration could even expose port 1 while the other
981  * one doesn't.
982  *
983  * Returns negative errno or zero.
984  */
985 int __init gserial_setup(struct usb_gadget *g, unsigned count)
986 {
987         unsigned                        i;
988         struct usb_cdc_line_coding      coding;
989         int                             status;
990
991         if (count == 0 || count > N_PORTS)
992                 return -EINVAL;
993
994         gs_tty_driver = alloc_tty_driver(count);
995         if (!gs_tty_driver)
996                 return -ENOMEM;
997
998         gs_tty_driver->owner = THIS_MODULE;
999         gs_tty_driver->driver_name = "g_serial";
1000         gs_tty_driver->name = "ttyGS";
1001         /* uses dynamically assigned dev_t values */
1002
1003         gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1004         gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1005         gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1006         gs_tty_driver->init_termios = tty_std_termios;
1007
1008         /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
1009          * MS-Windows.  Otherwise, most of these flags shouldn't affect
1010          * anything unless we were to actually hook up to a serial line.
1011          */
1012         gs_tty_driver->init_termios.c_cflag =
1013                         B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1014         gs_tty_driver->init_termios.c_ispeed = 9600;
1015         gs_tty_driver->init_termios.c_ospeed = 9600;
1016
1017         coding.dwDTERate = __constant_cpu_to_le32(9600);
1018         coding.bCharFormat = 8;
1019         coding.bParityType = USB_CDC_NO_PARITY;
1020         coding.bDataBits = USB_CDC_1_STOP_BITS;
1021
1022         tty_set_operations(gs_tty_driver, &gs_tty_ops);
1023
1024         /* make devices be openable */
1025         for (i = 0; i < count; i++) {
1026                 mutex_init(&ports[i].lock);
1027                 status = gs_port_alloc(i, &coding);
1028                 if (status) {
1029                         count = i;
1030                         goto fail;
1031                 }
1032         }
1033         n_ports = count;
1034
1035         /* export the driver ... */
1036         status = tty_register_driver(gs_tty_driver);
1037         if (status) {
1038                 put_tty_driver(gs_tty_driver);
1039                 pr_err("%s: cannot register, err %d\n",
1040                                 __func__, status);
1041                 goto fail;
1042         }
1043
1044         /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
1045         for (i = 0; i < count; i++) {
1046                 struct device   *tty_dev;
1047
1048                 tty_dev = tty_register_device(gs_tty_driver, i, &g->dev);
1049                 if (IS_ERR(tty_dev))
1050                         pr_warning("%s: no classdev for port %d, err %ld\n",
1051                                 __func__, i, PTR_ERR(tty_dev));
1052         }
1053
1054         pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
1055                         count, (count == 1) ? "" : "s");
1056
1057         return status;
1058 fail:
1059         while (count--)
1060                 kfree(ports[count].port);
1061         put_tty_driver(gs_tty_driver);
1062         gs_tty_driver = NULL;
1063         return status;
1064 }
1065
1066 static int gs_closed(struct gs_port *port)
1067 {
1068         int cond;
1069
1070         spin_lock_irq(&port->port_lock);
1071         cond = (port->open_count == 0) && !port->openclose;
1072         spin_unlock_irq(&port->port_lock);
1073         return cond;
1074 }
1075
1076 /**
1077  * gserial_cleanup - remove TTY-over-USB driver and devices
1078  * Context: may sleep
1079  *
1080  * This is called to free all resources allocated by @gserial_setup().
1081  * Accordingly, it may need to wait until some open /dev/ files have
1082  * closed.
1083  *
1084  * The caller must have issued @gserial_disconnect() for any ports
1085  * that had previously been connected, so that there is never any
1086  * I/O pending when it's called.
1087  */
1088 void gserial_cleanup(void)
1089 {
1090         unsigned        i;
1091         struct gs_port  *port;
1092
1093         /* start sysfs and /dev/ttyGS* node removal */
1094         for (i = 0; i < n_ports; i++)
1095                 tty_unregister_device(gs_tty_driver, i);
1096
1097         for (i = 0; i < n_ports; i++) {
1098                 /* prevent new opens */
1099                 mutex_lock(&ports[i].lock);
1100                 port = ports[i].port;
1101                 ports[i].port = NULL;
1102                 mutex_unlock(&ports[i].lock);
1103
1104                 /* wait for old opens to finish */
1105                 wait_event(port->close_wait, gs_closed(port));
1106
1107                 WARN_ON(port->port_usb != NULL);
1108
1109                 kfree(port);
1110         }
1111         n_ports = 0;
1112
1113         tty_unregister_driver(gs_tty_driver);
1114         gs_tty_driver = NULL;
1115
1116         pr_debug("%s: cleaned up ttyGS* support\n", __func__);
1117 }
1118
1119 /**
1120  * gserial_connect - notify TTY I/O glue that USB link is active
1121  * @gser: the function, set up with endpoints and descriptors
1122  * @port_num: which port is active
1123  * Context: any (usually from irq)
1124  *
1125  * This is called activate endpoints and let the TTY layer know that
1126  * the connection is active ... not unlike "carrier detect".  It won't
1127  * necessarily start I/O queues; unless the TTY is held open by any
1128  * task, there would be no point.  However, the endpoints will be
1129  * activated so the USB host can perform I/O, subject to basic USB
1130  * hardware flow control.
1131  *
1132  * Caller needs to have set up the endpoints and USB function in @dev
1133  * before calling this, as well as the appropriate (speed-specific)
1134  * endpoint descriptors, and also have set up the TTY driver by calling
1135  * @gserial_setup().
1136  *
1137  * Returns negative errno or zero.
1138  * On success, ep->driver_data will be overwritten.
1139  */
1140 int gserial_connect(struct gserial *gser, u8 port_num)
1141 {
1142         struct gs_port  *port;
1143         unsigned long   flags;
1144         int             status;
1145
1146         if (!gs_tty_driver || port_num >= n_ports)
1147                 return -ENXIO;
1148
1149         /* we "know" gserial_cleanup() hasn't been called */
1150         port = ports[port_num].port;
1151
1152         /* activate the endpoints */
1153         status = usb_ep_enable(gser->in, gser->in_desc);
1154         if (status < 0)
1155                 return status;
1156         gser->in->driver_data = port;
1157
1158         status = usb_ep_enable(gser->out, gser->out_desc);
1159         if (status < 0)
1160                 goto fail_out;
1161         gser->out->driver_data = port;
1162
1163         /* then tell the tty glue that I/O can work */
1164         spin_lock_irqsave(&port->port_lock, flags);
1165         gser->ioport = port;
1166         port->port_usb = gser;
1167
1168         /* REVISIT unclear how best to handle this state...
1169          * we don't really couple it with the Linux TTY.
1170          */
1171         gser->port_line_coding = port->port_line_coding;
1172
1173         /* REVISIT if waiting on "carrier detect", signal. */
1174
1175         /* REVISIT for ACM, issue "network connection" status notification:
1176          * connected if open_count, else disconnected.
1177          */
1178
1179         /* if it's already open, start I/O */
1180         if (port->open_count) {
1181                 pr_debug("gserial_connect: start ttyGS%d\n", port->port_num);
1182                 gs_start_io(port);
1183         }
1184
1185         spin_unlock_irqrestore(&port->port_lock, flags);
1186
1187         return status;
1188
1189 fail_out:
1190         usb_ep_disable(gser->in);
1191         gser->in->driver_data = NULL;
1192         return status;
1193 }
1194
1195 /**
1196  * gserial_disconnect - notify TTY I/O glue that USB link is inactive
1197  * @gser: the function, on which gserial_connect() was called
1198  * Context: any (usually from irq)
1199  *
1200  * This is called to deactivate endpoints and let the TTY layer know
1201  * that the connection went inactive ... not unlike "hangup".
1202  *
1203  * On return, the state is as if gserial_connect() had never been called;
1204  * there is no active USB I/O on these endpoints.
1205  */
1206 void gserial_disconnect(struct gserial *gser)
1207 {
1208         struct gs_port  *port = gser->ioport;
1209         unsigned long   flags;
1210
1211         if (!port)
1212                 return;
1213
1214         /* tell the TTY glue not to do I/O here any more */
1215         spin_lock_irqsave(&port->port_lock, flags);
1216
1217         /* REVISIT as above: how best to track this? */
1218         port->port_line_coding = gser->port_line_coding;
1219
1220         port->port_usb = NULL;
1221         gser->ioport = NULL;
1222         if (port->open_count > 0 || port->openclose) {
1223                 wake_up_interruptible(&port->drain_wait);
1224                 if (port->port_tty)
1225                         tty_hangup(port->port_tty);
1226         }
1227         spin_unlock_irqrestore(&port->port_lock, flags);
1228
1229         /* disable endpoints, aborting down any active I/O */
1230         usb_ep_disable(gser->out);
1231         gser->out->driver_data = NULL;
1232
1233         usb_ep_disable(gser->in);
1234         gser->in->driver_data = NULL;
1235
1236         /* finally, free any unused/unusable I/O buffers */
1237         spin_lock_irqsave(&port->port_lock, flags);
1238         if (port->open_count == 0 && !port->openclose)
1239                 gs_buf_free(&port->port_write_buf);
1240         gs_free_requests(gser->out, &port->read_pool);
1241         gs_free_requests(gser->in, &port->write_pool);
1242         spin_unlock_irqrestore(&port->port_lock, flags);
1243 }