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