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