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).
97 spinlock_t port_lock
; /* guard port_* access */
99 struct gserial
*port_usb
;
100 struct tty_struct
*port_tty
;
103 bool openclose
; /* open/close in progress */
106 wait_queue_head_t close_wait
; /* wait for last close */
108 struct list_head read_pool
;
111 struct list_head read_queue
;
113 struct tasklet_struct push
;
115 struct list_head write_pool
;
118 struct gs_buf port_write_buf
;
119 wait_queue_head_t drain_wait
; /* wait while writes drain */
121 /* REVISIT this state ... */
122 struct usb_cdc_line_coding port_line_coding
; /* 8-N-1 etc */
125 /* increase N_PORTS if you need more */
127 static struct portmaster
{
128 struct mutex lock
; /* protect open/close */
129 struct gs_port
*port
;
131 static unsigned n_ports
;
133 #define GS_CLOSE_TIMEOUT 15 /* seconds */
138 #define pr_vdebug(fmt, arg...) \
141 #define pr_vdebug(fmt, arg...) \
142 ({ if (0) pr_debug(fmt, ##arg); })
145 /*-------------------------------------------------------------------------*/
147 /* Circular Buffer */
152 * Allocate a circular buffer and all associated memory.
154 static int gs_buf_alloc(struct gs_buf
*gb
, unsigned size
)
156 gb
->buf_buf
= kmalloc(size
, GFP_KERNEL
);
157 if (gb
->buf_buf
== NULL
)
161 gb
->buf_put
= gb
->buf_buf
;
162 gb
->buf_get
= gb
->buf_buf
;
170 * Free the buffer and all associated memory.
172 static void gs_buf_free(struct gs_buf
*gb
)
181 * Clear out all data in the circular buffer.
183 static void gs_buf_clear(struct gs_buf
*gb
)
185 gb
->buf_get
= gb
->buf_put
;
186 /* equivalent to a get of all data available */
192 * Return the number of bytes of data written into the circular
195 static unsigned gs_buf_data_avail(struct gs_buf
*gb
)
197 return (gb
->buf_size
+ gb
->buf_put
- gb
->buf_get
) % gb
->buf_size
;
203 * Return the number of bytes of space available in the circular
206 static unsigned gs_buf_space_avail(struct gs_buf
*gb
)
208 return (gb
->buf_size
+ gb
->buf_get
- gb
->buf_put
- 1) % gb
->buf_size
;
214 * Copy data data from a user buffer and put it into the circular buffer.
215 * Restrict to the amount of space available.
217 * Return the number of bytes copied.
220 gs_buf_put(struct gs_buf
*gb
, const char *buf
, unsigned count
)
224 len
= gs_buf_space_avail(gb
);
231 len
= gb
->buf_buf
+ gb
->buf_size
- gb
->buf_put
;
233 memcpy(gb
->buf_put
, buf
, len
);
234 memcpy(gb
->buf_buf
, buf
+len
, count
- len
);
235 gb
->buf_put
= gb
->buf_buf
+ count
- len
;
237 memcpy(gb
->buf_put
, buf
, count
);
239 gb
->buf_put
+= count
;
240 else /* count == len */
241 gb
->buf_put
= gb
->buf_buf
;
250 * Get data from the circular buffer and copy to the given buffer.
251 * Restrict to the amount of data available.
253 * Return the number of bytes copied.
256 gs_buf_get(struct gs_buf
*gb
, char *buf
, unsigned count
)
260 len
= gs_buf_data_avail(gb
);
267 len
= gb
->buf_buf
+ gb
->buf_size
- gb
->buf_get
;
269 memcpy(buf
, gb
->buf_get
, len
);
270 memcpy(buf
+len
, gb
->buf_buf
, count
- len
);
271 gb
->buf_get
= gb
->buf_buf
+ count
- len
;
273 memcpy(buf
, gb
->buf_get
, count
);
275 gb
->buf_get
+= count
;
276 else /* count == len */
277 gb
->buf_get
= gb
->buf_buf
;
283 /*-------------------------------------------------------------------------*/
285 /* I/O glue between TTY (upper) and USB function (lower) driver layers */
290 * Allocate a usb_request and its buffer. Returns a pointer to the
291 * usb_request or NULL if there is an error.
294 gs_alloc_req(struct usb_ep
*ep
, unsigned len
, gfp_t kmalloc_flags
)
296 struct usb_request
*req
;
298 req
= usb_ep_alloc_request(ep
, kmalloc_flags
);
302 req
->buf
= kmalloc(len
, kmalloc_flags
);
303 if (req
->buf
== NULL
) {
304 usb_ep_free_request(ep
, req
);
315 * Free a usb_request and its buffer.
317 void gs_free_req(struct usb_ep
*ep
, struct usb_request
*req
)
320 usb_ep_free_request(ep
, req
);
326 * If there is data to send, a packet is built in the given
327 * buffer and the size is returned. If there is no data to
328 * send, 0 is returned.
330 * Called with port_lock held.
333 gs_send_packet(struct gs_port
*port
, char *packet
, unsigned size
)
337 len
= gs_buf_data_avail(&port
->port_write_buf
);
341 size
= gs_buf_get(&port
->port_write_buf
, packet
, size
);
348 * This function finds available write requests, calls
349 * gs_send_packet to fill these packets with data, and
350 * continues until either there are no more write requests
351 * available or no more data to send. This function is
352 * run whenever data arrives or write requests are available.
354 * Context: caller owns port_lock; port_usb is non-null.
356 static int gs_start_tx(struct gs_port
*port
)
358 __releases(&port->port_lock)
359 __acquires(&port->port_lock)
362 struct list_head
*pool
= &port
->write_pool
;
363 struct usb_ep
*in
= port
->port_usb
->in
;
365 bool do_tty_wake
= false;
367 while (!list_empty(pool
)) {
368 struct usb_request
*req
;
371 if (port
->write_started
>= QUEUE_SIZE
)
374 req
= list_entry(pool
->next
, struct usb_request
, list
);
375 len
= gs_send_packet(port
, req
->buf
, in
->maxpacket
);
377 wake_up_interruptible(&port
->drain_wait
);
383 list_del(&req
->list
);
384 req
->zero
= (gs_buf_data_avail(&port
->port_write_buf
) == 0);
386 pr_vdebug(PREFIX
"%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n",
387 port
->port_num
, len
, *((u8
*)req
->buf
),
388 *((u8
*)req
->buf
+1), *((u8
*)req
->buf
+2));
390 /* Drop lock while we call out of driver; completions
391 * could be issued while we do so. Disconnection may
392 * happen too; maybe immediately before we queue this!
394 * NOTE that we may keep sending data for a while after
395 * the TTY closed (dev->ioport->port_tty is NULL).
397 spin_unlock(&port
->port_lock
);
398 status
= usb_ep_queue(in
, req
, GFP_ATOMIC
);
399 spin_lock(&port
->port_lock
);
402 pr_debug("%s: %s %s err %d\n",
403 __func__
, "queue", in
->name
, status
);
404 list_add(&req
->list
, pool
);
408 port
->write_started
++;
410 /* abort immediately after disconnect */
415 if (do_tty_wake
&& port
->port_tty
)
416 tty_wakeup(port
->port_tty
);
421 * Context: caller owns port_lock, and port_usb is set
423 static unsigned gs_start_rx(struct gs_port
*port
)
425 __releases(&port->port_lock)
426 __acquires(&port->port_lock)
429 struct list_head
*pool
= &port
->read_pool
;
430 struct usb_ep
*out
= port
->port_usb
->out
;
432 while (!list_empty(pool
)) {
433 struct usb_request
*req
;
435 struct tty_struct
*tty
;
437 /* no more rx if closed */
438 tty
= port
->port_tty
;
442 if (port
->read_started
>= QUEUE_SIZE
)
445 req
= list_entry(pool
->next
, struct usb_request
, list
);
446 list_del(&req
->list
);
447 req
->length
= out
->maxpacket
;
449 /* drop lock while we call out; the controller driver
450 * may need to call us back (e.g. for disconnect)
452 spin_unlock(&port
->port_lock
);
453 status
= usb_ep_queue(out
, req
, GFP_ATOMIC
);
454 spin_lock(&port
->port_lock
);
457 pr_debug("%s: %s %s err %d\n",
458 __func__
, "queue", out
->name
, status
);
459 list_add(&req
->list
, pool
);
462 port
->read_started
++;
464 /* abort immediately after disconnect */
468 return port
->read_started
;
472 * RX tasklet takes data out of the RX queue and hands it up to the TTY
473 * layer until it refuses to take any more data (or is throttled back).
474 * Then it issues reads for any further data.
476 * If the RX queue becomes full enough that no usb_request is queued,
477 * the OUT endpoint may begin NAKing as soon as its FIFO fills up.
478 * So QUEUE_SIZE packets plus however many the FIFO holds (usually two)
479 * can be buffered before the TTY layer's buffers (currently 64 KB).
481 static void gs_rx_push(unsigned long _port
)
483 struct gs_port
*port
= (void *)_port
;
484 struct tty_struct
*tty
;
485 struct list_head
*queue
= &port
->read_queue
;
486 bool disconnect
= false;
487 bool do_push
= false;
489 /* hand any queued data to the tty */
490 spin_lock_irq(&port
->port_lock
);
491 tty
= port
->port_tty
;
492 while (!list_empty(queue
)) {
493 struct usb_request
*req
;
495 req
= list_first_entry(queue
, struct usb_request
, list
);
497 /* discard data if tty was closed */
501 /* leave data queued if tty was rx throttled */
502 if (test_bit(TTY_THROTTLED
, &tty
->flags
))
505 switch (req
->status
) {
508 pr_vdebug(PREFIX
"%d: shutdown\n", port
->port_num
);
512 /* presumably a transient fault */
513 pr_warning(PREFIX
"%d: unexpected RX status %d\n",
514 port
->port_num
, req
->status
);
517 /* normal completion */
521 /* push data to (open) tty */
523 char *packet
= req
->buf
;
524 unsigned size
= req
->actual
;
528 /* we may have pushed part of this packet already... */
535 count
= tty_insert_flip_string(tty
, packet
, size
);
539 /* stop pushing; TTY layer can't handle more */
540 port
->n_read
+= count
;
541 pr_vdebug(PREFIX
"%d: rx block %d/%d\n",
549 list_move(&req
->list
, &port
->read_pool
);
550 port
->read_started
--;
553 /* Push from tty to ldisc; without low_latency set this is handled by
554 * a workqueue, so we won't get callbacks and can hold port_lock
557 tty_flip_buffer_push(tty
);
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...
565 * REVISIT we should probably add a timer to keep the tasklet
566 * from starving ... but it's not clear that case ever happens.
568 if (!list_empty(queue
) && tty
) {
569 if (!test_bit(TTY_THROTTLED
, &tty
->flags
)) {
571 tasklet_schedule(&port
->push
);
573 pr_warning(PREFIX
"%d: RX not scheduled?\n",
578 /* If we're still connected, refill the USB RX queue. */
579 if (!disconnect
&& port
->port_usb
)
582 spin_unlock_irq(&port
->port_lock
);
585 static void gs_read_complete(struct usb_ep
*ep
, struct usb_request
*req
)
587 struct gs_port
*port
= ep
->driver_data
;
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
);
596 static void gs_write_complete(struct usb_ep
*ep
, struct usb_request
*req
)
598 struct gs_port
*port
= ep
->driver_data
;
600 spin_lock(&port
->port_lock
);
601 list_add(&req
->list
, &port
->write_pool
);
602 port
->write_started
--;
604 switch (req
->status
) {
606 /* presumably a transient fault */
607 pr_warning("%s: unexpected %s status %d\n",
608 __func__
, ep
->name
, req
->status
);
611 /* normal completion */
617 pr_vdebug("%s: %s shutdown\n", __func__
, ep
->name
);
621 spin_unlock(&port
->port_lock
);
624 static void gs_free_requests(struct usb_ep
*ep
, struct list_head
*head
,
627 struct usb_request
*req
;
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
);
638 static int gs_alloc_requests(struct usb_ep
*ep
, struct list_head
*head
,
639 void (*fn
)(struct usb_ep
*, struct usb_request
*),
643 struct usb_request
*req
;
644 int n
= allocated
? QUEUE_SIZE
- *allocated
: QUEUE_SIZE
;
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.
650 for (i
= 0; i
< n
; i
++) {
651 req
= gs_alloc_req(ep
, ep
->maxpacket
, GFP_ATOMIC
);
653 return list_empty(head
) ? -ENOMEM
: 0;
655 list_add_tail(&req
->list
, head
);
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
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.
671 static int gs_start_io(struct gs_port
*port
)
673 struct list_head
*head
= &port
->read_pool
;
674 struct usb_ep
*ep
= port
->port_usb
->out
;
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.
684 status
= gs_alloc_requests(ep
, head
, gs_read_complete
,
685 &port
->read_allocated
);
689 status
= gs_alloc_requests(port
->port_usb
->in
, &port
->write_pool
,
690 gs_write_complete
, &port
->write_allocated
);
692 gs_free_requests(ep
, head
, &port
->read_allocated
);
696 /* queue read requests */
698 started
= gs_start_rx(port
);
700 /* unblock any pending writes into our circular buffer */
702 tty_wakeup(port
->port_tty
);
704 gs_free_requests(ep
, head
, &port
->read_allocated
);
705 gs_free_requests(port
->port_usb
->in
, &port
->write_pool
,
706 &port
->write_allocated
);
713 /*-------------------------------------------------------------------------*/
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
722 static int gs_open(struct tty_struct
*tty
, struct file
*file
)
724 int port_num
= tty
->index
;
725 struct gs_port
*port
;
729 mutex_lock(&ports
[port_num
].lock
);
730 port
= ports
[port_num
].port
;
734 spin_lock_irq(&port
->port_lock
);
736 /* already open? Great. */
737 if (port
->open_count
) {
741 /* currently opening/closing? wait ... */
742 } else if (port
->openclose
) {
745 /* ... else we do the work */
748 port
->openclose
= true;
750 spin_unlock_irq(&port
->port_lock
);
752 mutex_unlock(&ports
[port_num
].lock
);
759 /* must do the work */
762 /* wait for EAGAIN task to finish */
764 /* REVISIT could have a waitchannel here, if
765 * concurrent open performance is important
769 } while (status
!= -EAGAIN
);
771 /* Do the "real open" */
772 spin_lock_irq(&port
->port_lock
);
774 /* allocate circular buffer on first open */
775 if (port
->port_write_buf
.buf_buf
== NULL
) {
777 spin_unlock_irq(&port
->port_lock
);
778 status
= gs_buf_alloc(&port
->port_write_buf
, WRITE_BUF_SIZE
);
779 spin_lock_irq(&port
->port_lock
);
782 pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n",
783 port
->port_num
, tty
, file
);
784 port
->openclose
= false;
785 goto exit_unlock_port
;
789 /* REVISIT if REMOVED (ports[].port NULL), abort the open
790 * to let rmmod work faster (but this way isn't wrong).
793 /* REVISIT maybe wait for "carrier detect" */
795 tty
->driver_data
= port
;
796 port
->port_tty
= tty
;
798 port
->open_count
= 1;
799 port
->openclose
= false;
801 /* if connected, start the I/O stream */
802 if (port
->port_usb
) {
803 struct gserial
*gser
= port
->port_usb
;
805 pr_debug("gs_open: start ttyGS%d\n", port
->port_num
);
812 pr_debug("gs_open: ttyGS%d (%p,%p)\n", port
->port_num
, tty
, file
);
817 spin_unlock_irq(&port
->port_lock
);
821 static int gs_writes_finished(struct gs_port
*p
)
825 /* return true on disconnect or empty buffer */
826 spin_lock_irq(&p
->port_lock
);
827 cond
= (p
->port_usb
== NULL
) || !gs_buf_data_avail(&p
->port_write_buf
);
828 spin_unlock_irq(&p
->port_lock
);
833 static void gs_close(struct tty_struct
*tty
, struct file
*file
)
835 struct gs_port
*port
= tty
->driver_data
;
836 struct gserial
*gser
;
838 spin_lock_irq(&port
->port_lock
);
840 if (port
->open_count
!= 1) {
841 if (port
->open_count
== 0)
848 pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port
->port_num
, tty
, file
);
850 /* mark port as closing but in use; we can drop port lock
851 * and sleep if necessary
853 port
->openclose
= true;
854 port
->open_count
= 0;
856 gser
= port
->port_usb
;
857 if (gser
&& gser
->disconnect
)
858 gser
->disconnect(gser
);
860 /* wait for circular write buffer to drain, disconnect, or at
861 * most GS_CLOSE_TIMEOUT seconds; then discard the rest
863 if (gs_buf_data_avail(&port
->port_write_buf
) > 0 && gser
) {
864 spin_unlock_irq(&port
->port_lock
);
865 wait_event_interruptible_timeout(port
->drain_wait
,
866 gs_writes_finished(port
),
867 GS_CLOSE_TIMEOUT
* HZ
);
868 spin_lock_irq(&port
->port_lock
);
869 gser
= port
->port_usb
;
872 /* Iff we're disconnected, there can be no I/O in flight so it's
873 * ok to free the circular buffer; else just scrub it. And don't
874 * let the push tasklet fire again until we're re-opened.
877 gs_buf_free(&port
->port_write_buf
);
879 gs_buf_clear(&port
->port_write_buf
);
881 tty
->driver_data
= NULL
;
882 port
->port_tty
= NULL
;
884 port
->openclose
= false;
886 pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
887 port
->port_num
, tty
, file
);
889 wake_up_interruptible(&port
->close_wait
);
891 spin_unlock_irq(&port
->port_lock
);
894 static int gs_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
)
896 struct gs_port
*port
= tty
->driver_data
;
900 pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
901 port
->port_num
, tty
, count
);
903 spin_lock_irqsave(&port
->port_lock
, flags
);
905 count
= gs_buf_put(&port
->port_write_buf
, buf
, count
);
906 /* treat count == 0 as flush_chars() */
908 status
= gs_start_tx(port
);
909 spin_unlock_irqrestore(&port
->port_lock
, flags
);
914 static int gs_put_char(struct tty_struct
*tty
, unsigned char ch
)
916 struct gs_port
*port
= tty
->driver_data
;
920 pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %p\n",
921 port
->port_num
, tty
, ch
, __builtin_return_address(0));
923 spin_lock_irqsave(&port
->port_lock
, flags
);
924 status
= gs_buf_put(&port
->port_write_buf
, &ch
, 1);
925 spin_unlock_irqrestore(&port
->port_lock
, flags
);
930 static void gs_flush_chars(struct tty_struct
*tty
)
932 struct gs_port
*port
= tty
->driver_data
;
935 pr_vdebug("gs_flush_chars: (%d,%p)\n", port
->port_num
, tty
);
937 spin_lock_irqsave(&port
->port_lock
, flags
);
940 spin_unlock_irqrestore(&port
->port_lock
, flags
);
943 static int gs_write_room(struct tty_struct
*tty
)
945 struct gs_port
*port
= tty
->driver_data
;
949 spin_lock_irqsave(&port
->port_lock
, flags
);
951 room
= gs_buf_space_avail(&port
->port_write_buf
);
952 spin_unlock_irqrestore(&port
->port_lock
, flags
);
954 pr_vdebug("gs_write_room: (%d,%p) room=%d\n",
955 port
->port_num
, tty
, room
);
960 static int gs_chars_in_buffer(struct tty_struct
*tty
)
962 struct gs_port
*port
= tty
->driver_data
;
966 spin_lock_irqsave(&port
->port_lock
, flags
);
967 chars
= gs_buf_data_avail(&port
->port_write_buf
);
968 spin_unlock_irqrestore(&port
->port_lock
, flags
);
970 pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
971 port
->port_num
, tty
, chars
);
976 /* undo side effects of setting TTY_THROTTLED */
977 static void gs_unthrottle(struct tty_struct
*tty
)
979 struct gs_port
*port
= tty
->driver_data
;
982 spin_lock_irqsave(&port
->port_lock
, flags
);
983 if (port
->port_usb
) {
984 /* Kickstart read queue processing. We don't do xon/xoff,
985 * rts/cts, or other handshaking with the host, but if the
986 * read queue backs up enough we'll be NAKing OUT packets.
988 tasklet_schedule(&port
->push
);
989 pr_vdebug(PREFIX
"%d: unthrottle\n", port
->port_num
);
991 spin_unlock_irqrestore(&port
->port_lock
, flags
);
994 static int gs_break_ctl(struct tty_struct
*tty
, int duration
)
996 struct gs_port
*port
= tty
->driver_data
;
998 struct gserial
*gser
;
1000 pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n",
1001 port
->port_num
, duration
);
1003 spin_lock_irq(&port
->port_lock
);
1004 gser
= port
->port_usb
;
1005 if (gser
&& gser
->send_break
)
1006 status
= gser
->send_break(gser
, duration
);
1007 spin_unlock_irq(&port
->port_lock
);
1012 static const struct tty_operations gs_tty_ops
= {
1016 .put_char
= gs_put_char
,
1017 .flush_chars
= gs_flush_chars
,
1018 .write_room
= gs_write_room
,
1019 .chars_in_buffer
= gs_chars_in_buffer
,
1020 .unthrottle
= gs_unthrottle
,
1021 .break_ctl
= gs_break_ctl
,
1024 /*-------------------------------------------------------------------------*/
1026 static struct tty_driver
*gs_tty_driver
;
1029 gs_port_alloc(unsigned port_num
, struct usb_cdc_line_coding
*coding
)
1031 struct gs_port
*port
;
1033 port
= kzalloc(sizeof(struct gs_port
), GFP_KERNEL
);
1037 spin_lock_init(&port
->port_lock
);
1038 init_waitqueue_head(&port
->close_wait
);
1039 init_waitqueue_head(&port
->drain_wait
);
1041 tasklet_init(&port
->push
, gs_rx_push
, (unsigned long) port
);
1043 INIT_LIST_HEAD(&port
->read_pool
);
1044 INIT_LIST_HEAD(&port
->read_queue
);
1045 INIT_LIST_HEAD(&port
->write_pool
);
1047 port
->port_num
= port_num
;
1048 port
->port_line_coding
= *coding
;
1050 ports
[port_num
].port
= port
;
1056 * gserial_setup - initialize TTY driver for one or more ports
1057 * @g: gadget to associate with these ports
1058 * @count: how many ports to support
1059 * Context: may sleep
1061 * The TTY stack needs to know in advance how many devices it should
1062 * plan to manage. Use this call to set up the ports you will be
1063 * exporting through USB. Later, connect them to functions based
1064 * on what configuration is activated by the USB host; and disconnect
1065 * them as appropriate.
1067 * An example would be a two-configuration device in which both
1068 * configurations expose port 0, but through different functions.
1069 * One configuration could even expose port 1 while the other
1072 * Returns negative errno or zero.
1074 int gserial_setup(struct usb_gadget
*g
, unsigned count
)
1077 struct usb_cdc_line_coding coding
;
1080 if (count
== 0 || count
> N_PORTS
)
1083 gs_tty_driver
= alloc_tty_driver(count
);
1087 gs_tty_driver
->driver_name
= "g_serial";
1088 gs_tty_driver
->name
= PREFIX
;
1089 /* uses dynamically assigned dev_t values */
1091 gs_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
1092 gs_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
1093 gs_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1094 gs_tty_driver
->init_termios
= tty_std_termios
;
1096 /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
1097 * MS-Windows. Otherwise, most of these flags shouldn't affect
1098 * anything unless we were to actually hook up to a serial line.
1100 gs_tty_driver
->init_termios
.c_cflag
=
1101 B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1102 gs_tty_driver
->init_termios
.c_ispeed
= 9600;
1103 gs_tty_driver
->init_termios
.c_ospeed
= 9600;
1105 coding
.dwDTERate
= cpu_to_le32(9600);
1106 coding
.bCharFormat
= 8;
1107 coding
.bParityType
= USB_CDC_NO_PARITY
;
1108 coding
.bDataBits
= USB_CDC_1_STOP_BITS
;
1110 tty_set_operations(gs_tty_driver
, &gs_tty_ops
);
1112 /* make devices be openable */
1113 for (i
= 0; i
< count
; i
++) {
1114 mutex_init(&ports
[i
].lock
);
1115 status
= gs_port_alloc(i
, &coding
);
1123 /* export the driver ... */
1124 status
= tty_register_driver(gs_tty_driver
);
1126 pr_err("%s: cannot register, err %d\n",
1131 /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
1132 for (i
= 0; i
< count
; i
++) {
1133 struct device
*tty_dev
;
1135 tty_dev
= tty_register_device(gs_tty_driver
, i
, &g
->dev
);
1136 if (IS_ERR(tty_dev
))
1137 pr_warning("%s: no classdev for port %d, err %ld\n",
1138 __func__
, i
, PTR_ERR(tty_dev
));
1141 pr_debug("%s: registered %d ttyGS* device%s\n", __func__
,
1142 count
, (count
== 1) ? "" : "s");
1147 kfree(ports
[count
].port
);
1148 put_tty_driver(gs_tty_driver
);
1149 gs_tty_driver
= NULL
;
1153 static int gs_closed(struct gs_port
*port
)
1157 spin_lock_irq(&port
->port_lock
);
1158 cond
= (port
->open_count
== 0) && !port
->openclose
;
1159 spin_unlock_irq(&port
->port_lock
);
1164 * gserial_cleanup - remove TTY-over-USB driver and devices
1165 * Context: may sleep
1167 * This is called to free all resources allocated by @gserial_setup().
1168 * Accordingly, it may need to wait until some open /dev/ files have
1171 * The caller must have issued @gserial_disconnect() for any ports
1172 * that had previously been connected, so that there is never any
1173 * I/O pending when it's called.
1175 void gserial_cleanup(void)
1178 struct gs_port
*port
;
1183 /* start sysfs and /dev/ttyGS* node removal */
1184 for (i
= 0; i
< n_ports
; i
++)
1185 tty_unregister_device(gs_tty_driver
, i
);
1187 for (i
= 0; i
< n_ports
; i
++) {
1188 /* prevent new opens */
1189 mutex_lock(&ports
[i
].lock
);
1190 port
= ports
[i
].port
;
1191 ports
[i
].port
= NULL
;
1192 mutex_unlock(&ports
[i
].lock
);
1194 tasklet_kill(&port
->push
);
1196 /* wait for old opens to finish */
1197 wait_event(port
->close_wait
, gs_closed(port
));
1199 WARN_ON(port
->port_usb
!= NULL
);
1205 tty_unregister_driver(gs_tty_driver
);
1206 put_tty_driver(gs_tty_driver
);
1207 gs_tty_driver
= NULL
;
1209 pr_debug("%s: cleaned up ttyGS* support\n", __func__
);
1213 * gserial_connect - notify TTY I/O glue that USB link is active
1214 * @gser: the function, set up with endpoints and descriptors
1215 * @port_num: which port is active
1216 * Context: any (usually from irq)
1218 * This is called activate endpoints and let the TTY layer know that
1219 * the connection is active ... not unlike "carrier detect". It won't
1220 * necessarily start I/O queues; unless the TTY is held open by any
1221 * task, there would be no point. However, the endpoints will be
1222 * activated so the USB host can perform I/O, subject to basic USB
1223 * hardware flow control.
1225 * Caller needs to have set up the endpoints and USB function in @dev
1226 * before calling this, as well as the appropriate (speed-specific)
1227 * endpoint descriptors, and also have set up the TTY driver by calling
1230 * Returns negative errno or zero.
1231 * On success, ep->driver_data will be overwritten.
1233 int gserial_connect(struct gserial
*gser
, u8 port_num
)
1235 struct gs_port
*port
;
1236 unsigned long flags
;
1239 if (!gs_tty_driver
|| port_num
>= n_ports
)
1242 /* we "know" gserial_cleanup() hasn't been called */
1243 port
= ports
[port_num
].port
;
1245 /* activate the endpoints */
1246 status
= usb_ep_enable(gser
->in
);
1249 gser
->in
->driver_data
= port
;
1251 status
= usb_ep_enable(gser
->out
);
1254 gser
->out
->driver_data
= port
;
1256 /* then tell the tty glue that I/O can work */
1257 spin_lock_irqsave(&port
->port_lock
, flags
);
1258 gser
->ioport
= port
;
1259 port
->port_usb
= gser
;
1261 /* REVISIT unclear how best to handle this state...
1262 * we don't really couple it with the Linux TTY.
1264 gser
->port_line_coding
= port
->port_line_coding
;
1266 /* REVISIT if waiting on "carrier detect", signal. */
1268 /* if it's already open, start I/O ... and notify the serial
1269 * protocol about open/close status (connect/disconnect).
1271 if (port
->open_count
) {
1272 pr_debug("gserial_connect: start ttyGS%d\n", port
->port_num
);
1275 gser
->connect(gser
);
1277 if (gser
->disconnect
)
1278 gser
->disconnect(gser
);
1281 spin_unlock_irqrestore(&port
->port_lock
, flags
);
1286 usb_ep_disable(gser
->in
);
1287 gser
->in
->driver_data
= NULL
;
1292 * gserial_disconnect - notify TTY I/O glue that USB link is inactive
1293 * @gser: the function, on which gserial_connect() was called
1294 * Context: any (usually from irq)
1296 * This is called to deactivate endpoints and let the TTY layer know
1297 * that the connection went inactive ... not unlike "hangup".
1299 * On return, the state is as if gserial_connect() had never been called;
1300 * there is no active USB I/O on these endpoints.
1302 void gserial_disconnect(struct gserial
*gser
)
1304 struct gs_port
*port
= gser
->ioport
;
1305 unsigned long flags
;
1310 /* tell the TTY glue not to do I/O here any more */
1311 spin_lock_irqsave(&port
->port_lock
, flags
);
1313 /* REVISIT as above: how best to track this? */
1314 port
->port_line_coding
= gser
->port_line_coding
;
1316 port
->port_usb
= NULL
;
1317 gser
->ioport
= NULL
;
1318 if (port
->open_count
> 0 || port
->openclose
) {
1319 wake_up_interruptible(&port
->drain_wait
);
1321 tty_hangup(port
->port_tty
);
1323 spin_unlock_irqrestore(&port
->port_lock
, flags
);
1325 /* disable endpoints, aborting down any active I/O */
1326 usb_ep_disable(gser
->out
);
1327 gser
->out
->driver_data
= NULL
;
1329 usb_ep_disable(gser
->in
);
1330 gser
->in
->driver_data
= NULL
;
1332 /* finally, free any unused/unusable I/O buffers */
1333 spin_lock_irqsave(&port
->port_lock
, flags
);
1334 if (port
->open_count
== 0 && !port
->openclose
)
1335 gs_buf_free(&port
->port_write_buf
);
1336 gs_free_requests(gser
->out
, &port
->read_pool
, NULL
);
1337 gs_free_requests(gser
->out
, &port
->read_queue
, NULL
);
1338 gs_free_requests(gser
->in
, &port
->write_pool
, NULL
);
1340 port
->read_allocated
= port
->read_started
=
1341 port
->write_allocated
= port
->write_started
= 0;
1343 spin_unlock_irqrestore(&port
->port_lock
, flags
);