2 * u_serial.c - utilities for USB gadget "serial port"/TTY support
4 * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
5 * Copyright (C) 2008 David Brownell
6 * Copyright (C) 2008 by Nokia Corporation
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)
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.
18 /* #define VERBOSE_DEBUG */
20 #include <linux/kernel.h>
21 #include <linux/sched.h>
22 #include <linux/interrupt.h>
23 #include <linux/device.h>
24 #include <linux/delay.h>
25 #include <linux/tty.h>
26 #include <linux/tty_flip.h>
27 #include <linux/slab.h>
28 #include <linux/export.h>
34 * This component encapsulates the TTY layer glue needed to provide basic
35 * "serial port" functionality through the USB gadget stack. Each such
36 * port is exposed through a /dev/ttyGS* node.
38 * After initialization (gserial_setup), these TTY port devices stay
39 * available until they are removed (gserial_cleanup). Each one may be
40 * connected to a USB function (gserial_connect), or disconnected (with
41 * gserial_disconnect) when the USB host issues a config change event.
42 * Data can only flow when the port is connected to the host.
44 * A given TTY port can be made available in multiple configurations.
45 * For example, each one might expose a ttyGS0 node which provides a
46 * login application. In one case that might use CDC ACM interface 0,
47 * while another configuration might use interface 3 for that. The
48 * work to handle that (including descriptor management) is not part
51 * Configurations may expose more than one TTY port. For example, if
52 * ttyGS0 provides login service, then ttyGS1 might provide dialer access
53 * for a telephone or fax link. And ttyGS2 might be something that just
54 * needs a simple byte stream interface for some messaging protocol that
55 * is managed in userspace ... OBEX, PTP, and MTP have been mentioned.
58 #define PREFIX "ttyGS"
61 * gserial is the lifecycle interface, used by USB functions
62 * gs_port is the I/O nexus, used by the tty driver
63 * tty_struct links to the tty/filesystem framework
65 * gserial <---> gs_port ... links will be null when the USB link is
66 * inactive; managed by gserial_{connect,disconnect}(). each gserial
67 * instance can wrap its own USB control protocol.
68 * gserial->ioport == usb_ep->driver_data ... gs_port
69 * gs_port->port_usb ... gserial
71 * gs_port <---> tty_struct ... links will be null when the TTY file
72 * isn't opened; managed by gs_open()/gs_close()
73 * gserial->port_tty ... tty_struct
74 * tty_struct->driver_data ... gserial
77 /* RX and TX queues can buffer QUEUE_SIZE packets before they hit the
78 * next layer of buffering. For TX that's a circular buffer; for RX
79 * consider it a NOP. A third layer is provided by the TTY code.
82 #define WRITE_BUF_SIZE 8192 /* TX only */
93 * The port structure holds info for each port, one for each minor number
94 * (and thus for each /dev/ node).
98 spinlock_t port_lock
; /* guard port_* access */
100 struct gserial
*port_usb
;
102 bool openclose
; /* open/close in progress */
105 struct list_head read_pool
;
108 struct list_head read_queue
;
110 struct tasklet_struct push
;
112 struct list_head write_pool
;
115 struct gs_buf port_write_buf
;
116 wait_queue_head_t drain_wait
; /* wait while writes drain */
118 /* REVISIT this state ... */
119 struct usb_cdc_line_coding port_line_coding
; /* 8-N-1 etc */
122 /* increase N_PORTS if you need more */
124 static struct portmaster
{
125 struct mutex lock
; /* protect open/close */
126 struct gs_port
*port
;
128 static unsigned n_ports
;
130 #define GS_CLOSE_TIMEOUT 15 /* seconds */
135 #define pr_vdebug(fmt, arg...) \
138 #define pr_vdebug(fmt, arg...) \
139 ({ if (0) pr_debug(fmt, ##arg); })
142 /*-------------------------------------------------------------------------*/
144 /* Circular Buffer */
149 * Allocate a circular buffer and all associated memory.
151 static int gs_buf_alloc(struct gs_buf
*gb
, unsigned size
)
153 gb
->buf_buf
= kmalloc(size
, GFP_KERNEL
);
154 if (gb
->buf_buf
== NULL
)
158 gb
->buf_put
= gb
->buf_buf
;
159 gb
->buf_get
= gb
->buf_buf
;
167 * Free the buffer and all associated memory.
169 static void gs_buf_free(struct gs_buf
*gb
)
178 * Clear out all data in the circular buffer.
180 static void gs_buf_clear(struct gs_buf
*gb
)
182 gb
->buf_get
= gb
->buf_put
;
183 /* equivalent to a get of all data available */
189 * Return the number of bytes of data written into the circular
192 static unsigned gs_buf_data_avail(struct gs_buf
*gb
)
194 return (gb
->buf_size
+ gb
->buf_put
- gb
->buf_get
) % gb
->buf_size
;
200 * Return the number of bytes of space available in the circular
203 static unsigned gs_buf_space_avail(struct gs_buf
*gb
)
205 return (gb
->buf_size
+ gb
->buf_get
- gb
->buf_put
- 1) % gb
->buf_size
;
211 * Copy data data from a user buffer and put it into the circular buffer.
212 * Restrict to the amount of space available.
214 * Return the number of bytes copied.
217 gs_buf_put(struct gs_buf
*gb
, const char *buf
, unsigned count
)
221 len
= gs_buf_space_avail(gb
);
228 len
= gb
->buf_buf
+ gb
->buf_size
- gb
->buf_put
;
230 memcpy(gb
->buf_put
, buf
, len
);
231 memcpy(gb
->buf_buf
, buf
+len
, count
- len
);
232 gb
->buf_put
= gb
->buf_buf
+ count
- len
;
234 memcpy(gb
->buf_put
, buf
, count
);
236 gb
->buf_put
+= count
;
237 else /* count == len */
238 gb
->buf_put
= gb
->buf_buf
;
247 * Get data from the circular buffer and copy to the given buffer.
248 * Restrict to the amount of data available.
250 * Return the number of bytes copied.
253 gs_buf_get(struct gs_buf
*gb
, char *buf
, unsigned count
)
257 len
= gs_buf_data_avail(gb
);
264 len
= gb
->buf_buf
+ gb
->buf_size
- gb
->buf_get
;
266 memcpy(buf
, gb
->buf_get
, len
);
267 memcpy(buf
+len
, gb
->buf_buf
, count
- len
);
268 gb
->buf_get
= gb
->buf_buf
+ count
- len
;
270 memcpy(buf
, gb
->buf_get
, count
);
272 gb
->buf_get
+= count
;
273 else /* count == len */
274 gb
->buf_get
= gb
->buf_buf
;
280 /*-------------------------------------------------------------------------*/
282 /* I/O glue between TTY (upper) and USB function (lower) driver layers */
287 * Allocate a usb_request and its buffer. Returns a pointer to the
288 * usb_request or NULL if there is an error.
291 gs_alloc_req(struct usb_ep
*ep
, unsigned len
, gfp_t kmalloc_flags
)
293 struct usb_request
*req
;
295 req
= usb_ep_alloc_request(ep
, kmalloc_flags
);
299 req
->buf
= kmalloc(len
, kmalloc_flags
);
300 if (req
->buf
== NULL
) {
301 usb_ep_free_request(ep
, req
);
312 * Free a usb_request and its buffer.
314 void gs_free_req(struct usb_ep
*ep
, struct usb_request
*req
)
317 usb_ep_free_request(ep
, req
);
323 * If there is data to send, a packet is built in the given
324 * buffer and the size is returned. If there is no data to
325 * send, 0 is returned.
327 * Called with port_lock held.
330 gs_send_packet(struct gs_port
*port
, char *packet
, unsigned size
)
334 len
= gs_buf_data_avail(&port
->port_write_buf
);
338 size
= gs_buf_get(&port
->port_write_buf
, packet
, size
);
345 * This function finds available write requests, calls
346 * gs_send_packet to fill these packets with data, and
347 * continues until either there are no more write requests
348 * available or no more data to send. This function is
349 * run whenever data arrives or write requests are available.
351 * Context: caller owns port_lock; port_usb is non-null.
353 static int gs_start_tx(struct gs_port
*port
)
355 __releases(&port->port_lock)
356 __acquires(&port->port_lock)
359 struct list_head
*pool
= &port
->write_pool
;
360 struct usb_ep
*in
= port
->port_usb
->in
;
362 bool do_tty_wake
= false;
364 while (!list_empty(pool
)) {
365 struct usb_request
*req
;
368 if (port
->write_started
>= QUEUE_SIZE
)
371 req
= list_entry(pool
->next
, struct usb_request
, list
);
372 len
= gs_send_packet(port
, req
->buf
, in
->maxpacket
);
374 wake_up_interruptible(&port
->drain_wait
);
380 list_del(&req
->list
);
381 req
->zero
= (gs_buf_data_avail(&port
->port_write_buf
) == 0);
383 pr_vdebug(PREFIX
"%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n",
384 port
->port_num
, len
, *((u8
*)req
->buf
),
385 *((u8
*)req
->buf
+1), *((u8
*)req
->buf
+2));
387 /* Drop lock while we call out of driver; completions
388 * could be issued while we do so. Disconnection may
389 * happen too; maybe immediately before we queue this!
391 * NOTE that we may keep sending data for a while after
392 * the TTY closed (dev->ioport->port_tty is NULL).
394 spin_unlock(&port
->port_lock
);
395 status
= usb_ep_queue(in
, req
, GFP_ATOMIC
);
396 spin_lock(&port
->port_lock
);
399 pr_debug("%s: %s %s err %d\n",
400 __func__
, "queue", in
->name
, status
);
401 list_add(&req
->list
, pool
);
405 port
->write_started
++;
407 /* abort immediately after disconnect */
412 if (do_tty_wake
&& port
->port
.tty
)
413 tty_wakeup(port
->port
.tty
);
418 * Context: caller owns port_lock, and port_usb is set
420 static unsigned gs_start_rx(struct gs_port
*port
)
422 __releases(&port->port_lock)
423 __acquires(&port->port_lock)
426 struct list_head
*pool
= &port
->read_pool
;
427 struct usb_ep
*out
= port
->port_usb
->out
;
429 while (!list_empty(pool
)) {
430 struct usb_request
*req
;
432 struct tty_struct
*tty
;
434 /* no more rx if closed */
435 tty
= port
->port
.tty
;
439 if (port
->read_started
>= QUEUE_SIZE
)
442 req
= list_entry(pool
->next
, struct usb_request
, list
);
443 list_del(&req
->list
);
444 req
->length
= out
->maxpacket
;
446 /* drop lock while we call out; the controller driver
447 * may need to call us back (e.g. for disconnect)
449 spin_unlock(&port
->port_lock
);
450 status
= usb_ep_queue(out
, req
, GFP_ATOMIC
);
451 spin_lock(&port
->port_lock
);
454 pr_debug("%s: %s %s err %d\n",
455 __func__
, "queue", out
->name
, status
);
456 list_add(&req
->list
, pool
);
459 port
->read_started
++;
461 /* abort immediately after disconnect */
465 return port
->read_started
;
469 * RX tasklet takes data out of the RX queue and hands it up to the TTY
470 * layer until it refuses to take any more data (or is throttled back).
471 * Then it issues reads for any further data.
473 * If the RX queue becomes full enough that no usb_request is queued,
474 * the OUT endpoint may begin NAKing as soon as its FIFO fills up.
475 * So QUEUE_SIZE packets plus however many the FIFO holds (usually two)
476 * can be buffered before the TTY layer's buffers (currently 64 KB).
478 static void gs_rx_push(unsigned long _port
)
480 struct gs_port
*port
= (void *)_port
;
481 struct tty_struct
*tty
;
482 struct list_head
*queue
= &port
->read_queue
;
483 bool disconnect
= false;
484 bool do_push
= false;
486 /* hand any queued data to the tty */
487 spin_lock_irq(&port
->port_lock
);
488 tty
= port
->port
.tty
;
489 while (!list_empty(queue
)) {
490 struct usb_request
*req
;
492 req
= list_first_entry(queue
, struct usb_request
, list
);
494 /* discard data if tty was closed */
498 /* leave data queued if tty was rx throttled */
499 if (test_bit(TTY_THROTTLED
, &tty
->flags
))
502 switch (req
->status
) {
505 pr_vdebug(PREFIX
"%d: shutdown\n", port
->port_num
);
509 /* presumably a transient fault */
510 pr_warning(PREFIX
"%d: unexpected RX status %d\n",
511 port
->port_num
, req
->status
);
514 /* normal completion */
518 /* push data to (open) tty */
520 char *packet
= req
->buf
;
521 unsigned size
= req
->actual
;
525 /* we may have pushed part of this packet already... */
532 count
= tty_insert_flip_string(tty
, packet
, size
);
536 /* stop pushing; TTY layer can't handle more */
537 port
->n_read
+= count
;
538 pr_vdebug(PREFIX
"%d: rx block %d/%d\n",
546 list_move(&req
->list
, &port
->read_pool
);
547 port
->read_started
--;
550 /* Push from tty to ldisc; without low_latency set this is handled by
551 * a workqueue, so we won't get callbacks and can hold port_lock
554 tty_flip_buffer_push(tty
);
557 /* We want our data queue to become empty ASAP, keeping data
558 * in the tty and ldisc (not here). If we couldn't push any
559 * this time around, there may be trouble unless there's an
560 * implicit tty_unthrottle() call on its way...
562 * REVISIT we should probably add a timer to keep the tasklet
563 * from starving ... but it's not clear that case ever happens.
565 if (!list_empty(queue
) && tty
) {
566 if (!test_bit(TTY_THROTTLED
, &tty
->flags
)) {
568 tasklet_schedule(&port
->push
);
570 pr_warning(PREFIX
"%d: RX not scheduled?\n",
575 /* If we're still connected, refill the USB RX queue. */
576 if (!disconnect
&& port
->port_usb
)
579 spin_unlock_irq(&port
->port_lock
);
582 static void gs_read_complete(struct usb_ep
*ep
, struct usb_request
*req
)
584 struct gs_port
*port
= ep
->driver_data
;
586 /* Queue all received data until the tty layer is ready for it. */
587 spin_lock(&port
->port_lock
);
588 list_add_tail(&req
->list
, &port
->read_queue
);
589 tasklet_schedule(&port
->push
);
590 spin_unlock(&port
->port_lock
);
593 static void gs_write_complete(struct usb_ep
*ep
, struct usb_request
*req
)
595 struct gs_port
*port
= ep
->driver_data
;
597 spin_lock(&port
->port_lock
);
598 list_add(&req
->list
, &port
->write_pool
);
599 port
->write_started
--;
601 switch (req
->status
) {
603 /* presumably a transient fault */
604 pr_warning("%s: unexpected %s status %d\n",
605 __func__
, ep
->name
, req
->status
);
608 /* normal completion */
614 pr_vdebug("%s: %s shutdown\n", __func__
, ep
->name
);
618 spin_unlock(&port
->port_lock
);
621 static void gs_free_requests(struct usb_ep
*ep
, struct list_head
*head
,
624 struct usb_request
*req
;
626 while (!list_empty(head
)) {
627 req
= list_entry(head
->next
, struct usb_request
, list
);
628 list_del(&req
->list
);
629 gs_free_req(ep
, req
);
635 static int gs_alloc_requests(struct usb_ep
*ep
, struct list_head
*head
,
636 void (*fn
)(struct usb_ep
*, struct usb_request
*),
640 struct usb_request
*req
;
641 int n
= allocated
? QUEUE_SIZE
- *allocated
: QUEUE_SIZE
;
643 /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't
644 * do quite that many this time, don't fail ... we just won't
645 * be as speedy as we might otherwise be.
647 for (i
= 0; i
< n
; i
++) {
648 req
= gs_alloc_req(ep
, ep
->maxpacket
, GFP_ATOMIC
);
650 return list_empty(head
) ? -ENOMEM
: 0;
652 list_add_tail(&req
->list
, head
);
660 * gs_start_io - start USB I/O streams
661 * @dev: encapsulates endpoints to use
662 * Context: holding port_lock; port_tty and port_usb are non-null
664 * We only start I/O when something is connected to both sides of
665 * this port. If nothing is listening on the host side, we may
666 * be pointlessly filling up our TX buffers and FIFO.
668 static int gs_start_io(struct gs_port
*port
)
670 struct list_head
*head
= &port
->read_pool
;
671 struct usb_ep
*ep
= port
->port_usb
->out
;
675 /* Allocate RX and TX I/O buffers. We can't easily do this much
676 * earlier (with GFP_KERNEL) because the requests are coupled to
677 * endpoints, as are the packet sizes we'll be using. Different
678 * configurations may use different endpoints with a given port;
679 * and high speed vs full speed changes packet sizes too.
681 status
= gs_alloc_requests(ep
, head
, gs_read_complete
,
682 &port
->read_allocated
);
686 status
= gs_alloc_requests(port
->port_usb
->in
, &port
->write_pool
,
687 gs_write_complete
, &port
->write_allocated
);
689 gs_free_requests(ep
, head
, &port
->read_allocated
);
693 /* queue read requests */
695 started
= gs_start_rx(port
);
697 /* unblock any pending writes into our circular buffer */
699 tty_wakeup(port
->port
.tty
);
701 gs_free_requests(ep
, head
, &port
->read_allocated
);
702 gs_free_requests(port
->port_usb
->in
, &port
->write_pool
,
703 &port
->write_allocated
);
710 /*-------------------------------------------------------------------------*/
715 * gs_open sets up the link between a gs_port and its associated TTY.
716 * That link is broken *only* by TTY close(), and all driver methods
719 static int gs_open(struct tty_struct
*tty
, struct file
*file
)
721 int port_num
= tty
->index
;
722 struct gs_port
*port
;
726 mutex_lock(&ports
[port_num
].lock
);
727 port
= ports
[port_num
].port
;
731 spin_lock_irq(&port
->port_lock
);
733 /* already open? Great. */
734 if (port
->port
.count
) {
738 /* currently opening/closing? wait ... */
739 } else if (port
->openclose
) {
742 /* ... else we do the work */
745 port
->openclose
= true;
747 spin_unlock_irq(&port
->port_lock
);
749 mutex_unlock(&ports
[port_num
].lock
);
756 /* must do the work */
759 /* wait for EAGAIN task to finish */
761 /* REVISIT could have a waitchannel here, if
762 * concurrent open performance is important
766 } while (status
!= -EAGAIN
);
768 /* Do the "real open" */
769 spin_lock_irq(&port
->port_lock
);
771 /* allocate circular buffer on first open */
772 if (port
->port_write_buf
.buf_buf
== NULL
) {
774 spin_unlock_irq(&port
->port_lock
);
775 status
= gs_buf_alloc(&port
->port_write_buf
, WRITE_BUF_SIZE
);
776 spin_lock_irq(&port
->port_lock
);
779 pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n",
780 port
->port_num
, tty
, file
);
781 port
->openclose
= false;
782 goto exit_unlock_port
;
786 /* REVISIT if REMOVED (ports[].port NULL), abort the open
787 * to let rmmod work faster (but this way isn't wrong).
790 /* REVISIT maybe wait for "carrier detect" */
792 tty
->driver_data
= port
;
793 port
->port
.tty
= tty
;
795 port
->port
.count
= 1;
796 port
->openclose
= false;
798 /* if connected, start the I/O stream */
799 if (port
->port_usb
) {
800 struct gserial
*gser
= port
->port_usb
;
802 pr_debug("gs_open: start ttyGS%d\n", port
->port_num
);
809 pr_debug("gs_open: ttyGS%d (%p,%p)\n", port
->port_num
, tty
, file
);
814 spin_unlock_irq(&port
->port_lock
);
818 static int gs_writes_finished(struct gs_port
*p
)
822 /* return true on disconnect or empty buffer */
823 spin_lock_irq(&p
->port_lock
);
824 cond
= (p
->port_usb
== NULL
) || !gs_buf_data_avail(&p
->port_write_buf
);
825 spin_unlock_irq(&p
->port_lock
);
830 static void gs_close(struct tty_struct
*tty
, struct file
*file
)
832 struct gs_port
*port
= tty
->driver_data
;
833 struct gserial
*gser
;
835 spin_lock_irq(&port
->port_lock
);
837 if (port
->port
.count
!= 1) {
838 if (port
->port
.count
== 0)
845 pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port
->port_num
, tty
, file
);
847 /* mark port as closing but in use; we can drop port lock
848 * and sleep if necessary
850 port
->openclose
= true;
851 port
->port
.count
= 0;
853 gser
= port
->port_usb
;
854 if (gser
&& gser
->disconnect
)
855 gser
->disconnect(gser
);
857 /* wait for circular write buffer to drain, disconnect, or at
858 * most GS_CLOSE_TIMEOUT seconds; then discard the rest
860 if (gs_buf_data_avail(&port
->port_write_buf
) > 0 && gser
) {
861 spin_unlock_irq(&port
->port_lock
);
862 wait_event_interruptible_timeout(port
->drain_wait
,
863 gs_writes_finished(port
),
864 GS_CLOSE_TIMEOUT
* HZ
);
865 spin_lock_irq(&port
->port_lock
);
866 gser
= port
->port_usb
;
869 /* Iff we're disconnected, there can be no I/O in flight so it's
870 * ok to free the circular buffer; else just scrub it. And don't
871 * let the push tasklet fire again until we're re-opened.
874 gs_buf_free(&port
->port_write_buf
);
876 gs_buf_clear(&port
->port_write_buf
);
878 tty
->driver_data
= NULL
;
879 port
->port
.tty
= NULL
;
881 port
->openclose
= false;
883 pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
884 port
->port_num
, tty
, file
);
886 wake_up_interruptible(&port
->port
.close_wait
);
888 spin_unlock_irq(&port
->port_lock
);
891 static int gs_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
)
893 struct gs_port
*port
= tty
->driver_data
;
897 pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
898 port
->port_num
, tty
, count
);
900 spin_lock_irqsave(&port
->port_lock
, flags
);
902 count
= gs_buf_put(&port
->port_write_buf
, buf
, count
);
903 /* treat count == 0 as flush_chars() */
905 status
= gs_start_tx(port
);
906 spin_unlock_irqrestore(&port
->port_lock
, flags
);
911 static int gs_put_char(struct tty_struct
*tty
, unsigned char ch
)
913 struct gs_port
*port
= tty
->driver_data
;
917 pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %pf\n",
918 port
->port_num
, tty
, ch
, __builtin_return_address(0));
920 spin_lock_irqsave(&port
->port_lock
, flags
);
921 status
= gs_buf_put(&port
->port_write_buf
, &ch
, 1);
922 spin_unlock_irqrestore(&port
->port_lock
, flags
);
927 static void gs_flush_chars(struct tty_struct
*tty
)
929 struct gs_port
*port
= tty
->driver_data
;
932 pr_vdebug("gs_flush_chars: (%d,%p)\n", port
->port_num
, tty
);
934 spin_lock_irqsave(&port
->port_lock
, flags
);
937 spin_unlock_irqrestore(&port
->port_lock
, flags
);
940 static int gs_write_room(struct tty_struct
*tty
)
942 struct gs_port
*port
= tty
->driver_data
;
946 spin_lock_irqsave(&port
->port_lock
, flags
);
948 room
= gs_buf_space_avail(&port
->port_write_buf
);
949 spin_unlock_irqrestore(&port
->port_lock
, flags
);
951 pr_vdebug("gs_write_room: (%d,%p) room=%d\n",
952 port
->port_num
, tty
, room
);
957 static int gs_chars_in_buffer(struct tty_struct
*tty
)
959 struct gs_port
*port
= tty
->driver_data
;
963 spin_lock_irqsave(&port
->port_lock
, flags
);
964 chars
= gs_buf_data_avail(&port
->port_write_buf
);
965 spin_unlock_irqrestore(&port
->port_lock
, flags
);
967 pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
968 port
->port_num
, tty
, chars
);
973 /* undo side effects of setting TTY_THROTTLED */
974 static void gs_unthrottle(struct tty_struct
*tty
)
976 struct gs_port
*port
= tty
->driver_data
;
979 spin_lock_irqsave(&port
->port_lock
, flags
);
980 if (port
->port_usb
) {
981 /* Kickstart read queue processing. We don't do xon/xoff,
982 * rts/cts, or other handshaking with the host, but if the
983 * read queue backs up enough we'll be NAKing OUT packets.
985 tasklet_schedule(&port
->push
);
986 pr_vdebug(PREFIX
"%d: unthrottle\n", port
->port_num
);
988 spin_unlock_irqrestore(&port
->port_lock
, flags
);
991 static int gs_break_ctl(struct tty_struct
*tty
, int duration
)
993 struct gs_port
*port
= tty
->driver_data
;
995 struct gserial
*gser
;
997 pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n",
998 port
->port_num
, duration
);
1000 spin_lock_irq(&port
->port_lock
);
1001 gser
= port
->port_usb
;
1002 if (gser
&& gser
->send_break
)
1003 status
= gser
->send_break(gser
, duration
);
1004 spin_unlock_irq(&port
->port_lock
);
1009 static const struct tty_operations gs_tty_ops
= {
1013 .put_char
= gs_put_char
,
1014 .flush_chars
= gs_flush_chars
,
1015 .write_room
= gs_write_room
,
1016 .chars_in_buffer
= gs_chars_in_buffer
,
1017 .unthrottle
= gs_unthrottle
,
1018 .break_ctl
= gs_break_ctl
,
1021 /*-------------------------------------------------------------------------*/
1023 static struct tty_driver
*gs_tty_driver
;
1026 gs_port_alloc(unsigned port_num
, struct usb_cdc_line_coding
*coding
)
1028 struct gs_port
*port
;
1030 port
= kzalloc(sizeof(struct gs_port
), GFP_KERNEL
);
1034 tty_port_init(&port
->port
);
1035 spin_lock_init(&port
->port_lock
);
1036 init_waitqueue_head(&port
->drain_wait
);
1038 tasklet_init(&port
->push
, gs_rx_push
, (unsigned long) port
);
1040 INIT_LIST_HEAD(&port
->read_pool
);
1041 INIT_LIST_HEAD(&port
->read_queue
);
1042 INIT_LIST_HEAD(&port
->write_pool
);
1044 port
->port_num
= port_num
;
1045 port
->port_line_coding
= *coding
;
1047 ports
[port_num
].port
= port
;
1053 * gserial_setup - initialize TTY driver for one or more ports
1054 * @g: gadget to associate with these ports
1055 * @count: how many ports to support
1056 * Context: may sleep
1058 * The TTY stack needs to know in advance how many devices it should
1059 * plan to manage. Use this call to set up the ports you will be
1060 * exporting through USB. Later, connect them to functions based
1061 * on what configuration is activated by the USB host; and disconnect
1062 * them as appropriate.
1064 * An example would be a two-configuration device in which both
1065 * configurations expose port 0, but through different functions.
1066 * One configuration could even expose port 1 while the other
1069 * Returns negative errno or zero.
1071 int gserial_setup(struct usb_gadget
*g
, unsigned count
)
1074 struct usb_cdc_line_coding coding
;
1077 if (count
== 0 || count
> N_PORTS
)
1080 gs_tty_driver
= alloc_tty_driver(count
);
1084 gs_tty_driver
->driver_name
= "g_serial";
1085 gs_tty_driver
->name
= PREFIX
;
1086 /* uses dynamically assigned dev_t values */
1088 gs_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
1089 gs_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
1090 gs_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1091 gs_tty_driver
->init_termios
= tty_std_termios
;
1093 /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
1094 * MS-Windows. Otherwise, most of these flags shouldn't affect
1095 * anything unless we were to actually hook up to a serial line.
1097 gs_tty_driver
->init_termios
.c_cflag
=
1098 B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1099 gs_tty_driver
->init_termios
.c_ispeed
= 9600;
1100 gs_tty_driver
->init_termios
.c_ospeed
= 9600;
1102 coding
.dwDTERate
= cpu_to_le32(9600);
1103 coding
.bCharFormat
= 8;
1104 coding
.bParityType
= USB_CDC_NO_PARITY
;
1105 coding
.bDataBits
= USB_CDC_1_STOP_BITS
;
1107 tty_set_operations(gs_tty_driver
, &gs_tty_ops
);
1109 /* make devices be openable */
1110 for (i
= 0; i
< count
; i
++) {
1111 mutex_init(&ports
[i
].lock
);
1112 status
= gs_port_alloc(i
, &coding
);
1120 /* export the driver ... */
1121 status
= tty_register_driver(gs_tty_driver
);
1123 pr_err("%s: cannot register, err %d\n",
1128 /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
1129 for (i
= 0; i
< count
; i
++) {
1130 struct device
*tty_dev
;
1132 tty_dev
= tty_register_device(gs_tty_driver
, i
, &g
->dev
);
1133 if (IS_ERR(tty_dev
))
1134 pr_warning("%s: no classdev for port %d, err %ld\n",
1135 __func__
, i
, PTR_ERR(tty_dev
));
1138 pr_debug("%s: registered %d ttyGS* device%s\n", __func__
,
1139 count
, (count
== 1) ? "" : "s");
1144 kfree(ports
[count
].port
);
1145 put_tty_driver(gs_tty_driver
);
1146 gs_tty_driver
= NULL
;
1150 static int gs_closed(struct gs_port
*port
)
1154 spin_lock_irq(&port
->port_lock
);
1155 cond
= (port
->port
.count
== 0) && !port
->openclose
;
1156 spin_unlock_irq(&port
->port_lock
);
1161 * gserial_cleanup - remove TTY-over-USB driver and devices
1162 * Context: may sleep
1164 * This is called to free all resources allocated by @gserial_setup().
1165 * Accordingly, it may need to wait until some open /dev/ files have
1168 * The caller must have issued @gserial_disconnect() for any ports
1169 * that had previously been connected, so that there is never any
1170 * I/O pending when it's called.
1172 void gserial_cleanup(void)
1175 struct gs_port
*port
;
1180 /* start sysfs and /dev/ttyGS* node removal */
1181 for (i
= 0; i
< n_ports
; i
++)
1182 tty_unregister_device(gs_tty_driver
, i
);
1184 for (i
= 0; i
< n_ports
; i
++) {
1185 /* prevent new opens */
1186 mutex_lock(&ports
[i
].lock
);
1187 port
= ports
[i
].port
;
1188 ports
[i
].port
= NULL
;
1189 mutex_unlock(&ports
[i
].lock
);
1191 tasklet_kill(&port
->push
);
1193 /* wait for old opens to finish */
1194 wait_event(port
->port
.close_wait
, gs_closed(port
));
1196 WARN_ON(port
->port_usb
!= NULL
);
1202 tty_unregister_driver(gs_tty_driver
);
1203 put_tty_driver(gs_tty_driver
);
1204 gs_tty_driver
= NULL
;
1206 pr_debug("%s: cleaned up ttyGS* support\n", __func__
);
1210 * gserial_connect - notify TTY I/O glue that USB link is active
1211 * @gser: the function, set up with endpoints and descriptors
1212 * @port_num: which port is active
1213 * Context: any (usually from irq)
1215 * This is called activate endpoints and let the TTY layer know that
1216 * the connection is active ... not unlike "carrier detect". It won't
1217 * necessarily start I/O queues; unless the TTY is held open by any
1218 * task, there would be no point. However, the endpoints will be
1219 * activated so the USB host can perform I/O, subject to basic USB
1220 * hardware flow control.
1222 * Caller needs to have set up the endpoints and USB function in @dev
1223 * before calling this, as well as the appropriate (speed-specific)
1224 * endpoint descriptors, and also have set up the TTY driver by calling
1227 * Returns negative errno or zero.
1228 * On success, ep->driver_data will be overwritten.
1230 int gserial_connect(struct gserial
*gser
, u8 port_num
)
1232 struct gs_port
*port
;
1233 unsigned long flags
;
1236 if (!gs_tty_driver
|| port_num
>= n_ports
)
1239 /* we "know" gserial_cleanup() hasn't been called */
1240 port
= ports
[port_num
].port
;
1242 /* activate the endpoints */
1243 status
= usb_ep_enable(gser
->in
);
1246 gser
->in
->driver_data
= port
;
1248 status
= usb_ep_enable(gser
->out
);
1251 gser
->out
->driver_data
= port
;
1253 /* then tell the tty glue that I/O can work */
1254 spin_lock_irqsave(&port
->port_lock
, flags
);
1255 gser
->ioport
= port
;
1256 port
->port_usb
= gser
;
1258 /* REVISIT unclear how best to handle this state...
1259 * we don't really couple it with the Linux TTY.
1261 gser
->port_line_coding
= port
->port_line_coding
;
1263 /* REVISIT if waiting on "carrier detect", signal. */
1265 /* if it's already open, start I/O ... and notify the serial
1266 * protocol about open/close status (connect/disconnect).
1268 if (port
->port
.count
) {
1269 pr_debug("gserial_connect: start ttyGS%d\n", port
->port_num
);
1272 gser
->connect(gser
);
1274 if (gser
->disconnect
)
1275 gser
->disconnect(gser
);
1278 spin_unlock_irqrestore(&port
->port_lock
, flags
);
1283 usb_ep_disable(gser
->in
);
1284 gser
->in
->driver_data
= NULL
;
1289 * gserial_disconnect - notify TTY I/O glue that USB link is inactive
1290 * @gser: the function, on which gserial_connect() was called
1291 * Context: any (usually from irq)
1293 * This is called to deactivate endpoints and let the TTY layer know
1294 * that the connection went inactive ... not unlike "hangup".
1296 * On return, the state is as if gserial_connect() had never been called;
1297 * there is no active USB I/O on these endpoints.
1299 void gserial_disconnect(struct gserial
*gser
)
1301 struct gs_port
*port
= gser
->ioport
;
1302 unsigned long flags
;
1307 /* tell the TTY glue not to do I/O here any more */
1308 spin_lock_irqsave(&port
->port_lock
, flags
);
1310 /* REVISIT as above: how best to track this? */
1311 port
->port_line_coding
= gser
->port_line_coding
;
1313 port
->port_usb
= NULL
;
1314 gser
->ioport
= NULL
;
1315 if (port
->port
.count
> 0 || port
->openclose
) {
1316 wake_up_interruptible(&port
->drain_wait
);
1318 tty_hangup(port
->port
.tty
);
1320 spin_unlock_irqrestore(&port
->port_lock
, flags
);
1322 /* disable endpoints, aborting down any active I/O */
1323 usb_ep_disable(gser
->out
);
1324 gser
->out
->driver_data
= NULL
;
1326 usb_ep_disable(gser
->in
);
1327 gser
->in
->driver_data
= NULL
;
1329 /* finally, free any unused/unusable I/O buffers */
1330 spin_lock_irqsave(&port
->port_lock
, flags
);
1331 if (port
->port
.count
== 0 && !port
->openclose
)
1332 gs_buf_free(&port
->port_write_buf
);
1333 gs_free_requests(gser
->out
, &port
->read_pool
, NULL
);
1334 gs_free_requests(gser
->out
, &port
->read_queue
, NULL
);
1335 gs_free_requests(gser
->in
, &port
->write_pool
, NULL
);
1337 port
->read_allocated
= port
->read_started
=
1338 port
->write_allocated
= port
->write_started
= 0;
1340 spin_unlock_irqrestore(&port
->port_lock
, flags
);