blob: 598dcc1212f0bb231830f0022961f67e37b6b0fa [file] [log] [blame]
David Brownellc1dca562008-06-19 17:51:44 -07001/*
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>
stephane duverger1e413942010-06-29 16:57:25 +020021#include <linux/sched.h>
David Brownellc1dca562008-06-19 17:51:44 -070022#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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090027#include <linux/slab.h>
Paul Gortmakerf940fcd2011-05-27 09:56:31 -040028#include <linux/export.h>
David Brownellc1dca562008-06-19 17:51:44 -070029
30#include "u_serial.h"
31
32
33/*
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.
37 *
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.
43 *
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
49 * of this component.
50 *
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.
56 */
57
David Brownell937ef732008-07-07 12:16:08 -070058#define PREFIX "ttyGS"
59
David Brownellc1dca562008-06-19 17:51:44 -070060/*
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
64 *
65 * gserial <---> gs_port ... links will be null when the USB link is
David Brownell1f1ba112008-08-06 18:49:57 -070066 * inactive; managed by gserial_{connect,disconnect}(). each gserial
67 * instance can wrap its own USB control protocol.
David Brownellc1dca562008-06-19 17:51:44 -070068 * gserial->ioport == usb_ep->driver_data ... gs_port
69 * gs_port->port_usb ... gserial
70 *
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
75 */
76
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.
80 */
81#define QUEUE_SIZE 16
82#define WRITE_BUF_SIZE 8192 /* TX only */
83
84/* circular buffer */
85struct gs_buf {
86 unsigned buf_size;
87 char *buf_buf;
88 char *buf_get;
89 char *buf_put;
90};
91
92/*
93 * The port structure holds info for each port, one for each minor number
94 * (and thus for each /dev/ node).
95 */
96struct gs_port {
Jiri Slaby266e37e2012-04-02 13:54:47 +020097 struct tty_port port;
David Brownellc1dca562008-06-19 17:51:44 -070098 spinlock_t port_lock; /* guard port_* access */
99
100 struct gserial *port_usb;
David Brownellc1dca562008-06-19 17:51:44 -0700101
David Brownellc1dca562008-06-19 17:51:44 -0700102 bool openclose; /* open/close in progress */
103 u8 port_num;
104
David Brownellc1dca562008-06-19 17:51:44 -0700105 struct list_head read_pool;
Jim Sung28609d42010-11-04 18:47:51 -0700106 int read_started;
107 int read_allocated;
David Brownell937ef732008-07-07 12:16:08 -0700108 struct list_head read_queue;
109 unsigned n_read;
David Brownellc1dca562008-06-19 17:51:44 -0700110 struct tasklet_struct push;
111
112 struct list_head write_pool;
Jim Sung28609d42010-11-04 18:47:51 -0700113 int write_started;
114 int write_allocated;
David Brownellc1dca562008-06-19 17:51:44 -0700115 struct gs_buf port_write_buf;
116 wait_queue_head_t drain_wait; /* wait while writes drain */
117
118 /* REVISIT this state ... */
119 struct usb_cdc_line_coding port_line_coding; /* 8-N-1 etc */
120};
121
122/* increase N_PORTS if you need more */
123#define N_PORTS 4
124static struct portmaster {
125 struct mutex lock; /* protect open/close */
126 struct gs_port *port;
127} ports[N_PORTS];
128static unsigned n_ports;
129
130#define GS_CLOSE_TIMEOUT 15 /* seconds */
131
132
133
134#ifdef VERBOSE_DEBUG
Andrzej Pietrasiewiczea0e6272012-06-11 11:13:15 +0200135#ifndef pr_vdebug
David Brownellc1dca562008-06-19 17:51:44 -0700136#define pr_vdebug(fmt, arg...) \
137 pr_debug(fmt, ##arg)
Andrzej Pietrasiewiczea0e6272012-06-11 11:13:15 +0200138#endif /* pr_vdebug */
David Brownellc1dca562008-06-19 17:51:44 -0700139#else
Andrzej Pietrasiewiczea0e6272012-06-11 11:13:15 +0200140#ifndef pr_vdebig
David Brownellc1dca562008-06-19 17:51:44 -0700141#define pr_vdebug(fmt, arg...) \
142 ({ if (0) pr_debug(fmt, ##arg); })
Andrzej Pietrasiewiczea0e6272012-06-11 11:13:15 +0200143#endif /* pr_vdebug */
David Brownellc1dca562008-06-19 17:51:44 -0700144#endif
145
146/*-------------------------------------------------------------------------*/
147
148/* Circular Buffer */
149
150/*
151 * gs_buf_alloc
152 *
153 * Allocate a circular buffer and all associated memory.
154 */
155static int gs_buf_alloc(struct gs_buf *gb, unsigned size)
156{
157 gb->buf_buf = kmalloc(size, GFP_KERNEL);
158 if (gb->buf_buf == NULL)
159 return -ENOMEM;
160
161 gb->buf_size = size;
162 gb->buf_put = gb->buf_buf;
163 gb->buf_get = gb->buf_buf;
164
165 return 0;
166}
167
168/*
169 * gs_buf_free
170 *
171 * Free the buffer and all associated memory.
172 */
173static void gs_buf_free(struct gs_buf *gb)
174{
175 kfree(gb->buf_buf);
176 gb->buf_buf = NULL;
177}
178
179/*
180 * gs_buf_clear
181 *
182 * Clear out all data in the circular buffer.
183 */
184static void gs_buf_clear(struct gs_buf *gb)
185{
186 gb->buf_get = gb->buf_put;
187 /* equivalent to a get of all data available */
188}
189
190/*
191 * gs_buf_data_avail
192 *
David Brownell1f1ba112008-08-06 18:49:57 -0700193 * Return the number of bytes of data written into the circular
David Brownellc1dca562008-06-19 17:51:44 -0700194 * buffer.
195 */
196static unsigned gs_buf_data_avail(struct gs_buf *gb)
197{
198 return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size;
199}
200
201/*
202 * gs_buf_space_avail
203 *
204 * Return the number of bytes of space available in the circular
205 * buffer.
206 */
207static unsigned gs_buf_space_avail(struct gs_buf *gb)
208{
209 return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size;
210}
211
212/*
213 * gs_buf_put
214 *
215 * Copy data data from a user buffer and put it into the circular buffer.
216 * Restrict to the amount of space available.
217 *
218 * Return the number of bytes copied.
219 */
220static unsigned
221gs_buf_put(struct gs_buf *gb, const char *buf, unsigned count)
222{
223 unsigned len;
224
225 len = gs_buf_space_avail(gb);
226 if (count > len)
227 count = len;
228
229 if (count == 0)
230 return 0;
231
232 len = gb->buf_buf + gb->buf_size - gb->buf_put;
233 if (count > len) {
234 memcpy(gb->buf_put, buf, len);
235 memcpy(gb->buf_buf, buf+len, count - len);
236 gb->buf_put = gb->buf_buf + count - len;
237 } else {
238 memcpy(gb->buf_put, buf, count);
239 if (count < len)
240 gb->buf_put += count;
241 else /* count == len */
242 gb->buf_put = gb->buf_buf;
243 }
244
245 return count;
246}
247
248/*
249 * gs_buf_get
250 *
251 * Get data from the circular buffer and copy to the given buffer.
252 * Restrict to the amount of data available.
253 *
254 * Return the number of bytes copied.
255 */
256static unsigned
257gs_buf_get(struct gs_buf *gb, char *buf, unsigned count)
258{
259 unsigned len;
260
261 len = gs_buf_data_avail(gb);
262 if (count > len)
263 count = len;
264
265 if (count == 0)
266 return 0;
267
268 len = gb->buf_buf + gb->buf_size - gb->buf_get;
269 if (count > len) {
270 memcpy(buf, gb->buf_get, len);
271 memcpy(buf+len, gb->buf_buf, count - len);
272 gb->buf_get = gb->buf_buf + count - len;
273 } else {
274 memcpy(buf, gb->buf_get, count);
275 if (count < len)
276 gb->buf_get += count;
277 else /* count == len */
278 gb->buf_get = gb->buf_buf;
279 }
280
281 return count;
282}
283
284/*-------------------------------------------------------------------------*/
285
286/* I/O glue between TTY (upper) and USB function (lower) driver layers */
287
288/*
289 * gs_alloc_req
290 *
291 * Allocate a usb_request and its buffer. Returns a pointer to the
292 * usb_request or NULL if there is an error.
293 */
David Brownell1f1ba112008-08-06 18:49:57 -0700294struct usb_request *
David Brownellc1dca562008-06-19 17:51:44 -0700295gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
296{
297 struct usb_request *req;
298
299 req = usb_ep_alloc_request(ep, kmalloc_flags);
300
301 if (req != NULL) {
302 req->length = len;
303 req->buf = kmalloc(len, kmalloc_flags);
304 if (req->buf == NULL) {
305 usb_ep_free_request(ep, req);
306 return NULL;
307 }
308 }
309
310 return req;
311}
312
313/*
314 * gs_free_req
315 *
316 * Free a usb_request and its buffer.
317 */
David Brownell1f1ba112008-08-06 18:49:57 -0700318void gs_free_req(struct usb_ep *ep, struct usb_request *req)
David Brownellc1dca562008-06-19 17:51:44 -0700319{
320 kfree(req->buf);
321 usb_ep_free_request(ep, req);
322}
323
324/*
325 * gs_send_packet
326 *
327 * If there is data to send, a packet is built in the given
328 * buffer and the size is returned. If there is no data to
329 * send, 0 is returned.
330 *
331 * Called with port_lock held.
332 */
333static unsigned
334gs_send_packet(struct gs_port *port, char *packet, unsigned size)
335{
336 unsigned len;
337
338 len = gs_buf_data_avail(&port->port_write_buf);
339 if (len < size)
340 size = len;
341 if (size != 0)
342 size = gs_buf_get(&port->port_write_buf, packet, size);
343 return size;
344}
345
346/*
347 * gs_start_tx
348 *
349 * This function finds available write requests, calls
350 * gs_send_packet to fill these packets with data, and
351 * continues until either there are no more write requests
352 * available or no more data to send. This function is
353 * run whenever data arrives or write requests are available.
354 *
355 * Context: caller owns port_lock; port_usb is non-null.
356 */
357static int gs_start_tx(struct gs_port *port)
358/*
359__releases(&port->port_lock)
360__acquires(&port->port_lock)
361*/
362{
363 struct list_head *pool = &port->write_pool;
364 struct usb_ep *in = port->port_usb->in;
365 int status = 0;
366 bool do_tty_wake = false;
367
368 while (!list_empty(pool)) {
369 struct usb_request *req;
370 int len;
371
Jim Sung28609d42010-11-04 18:47:51 -0700372 if (port->write_started >= QUEUE_SIZE)
373 break;
374
David Brownellc1dca562008-06-19 17:51:44 -0700375 req = list_entry(pool->next, struct usb_request, list);
376 len = gs_send_packet(port, req->buf, in->maxpacket);
377 if (len == 0) {
378 wake_up_interruptible(&port->drain_wait);
379 break;
380 }
381 do_tty_wake = true;
382
383 req->length = len;
384 list_del(&req->list);
Daniel Glöckner2e251342009-05-28 12:53:24 +0200385 req->zero = (gs_buf_data_avail(&port->port_write_buf) == 0);
David Brownellc1dca562008-06-19 17:51:44 -0700386
David Brownell937ef732008-07-07 12:16:08 -0700387 pr_vdebug(PREFIX "%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n",
388 port->port_num, len, *((u8 *)req->buf),
David Brownellc1dca562008-06-19 17:51:44 -0700389 *((u8 *)req->buf+1), *((u8 *)req->buf+2));
David Brownellc1dca562008-06-19 17:51:44 -0700390
391 /* Drop lock while we call out of driver; completions
392 * could be issued while we do so. Disconnection may
393 * happen too; maybe immediately before we queue this!
394 *
395 * NOTE that we may keep sending data for a while after
396 * the TTY closed (dev->ioport->port_tty is NULL).
397 */
398 spin_unlock(&port->port_lock);
399 status = usb_ep_queue(in, req, GFP_ATOMIC);
400 spin_lock(&port->port_lock);
401
402 if (status) {
403 pr_debug("%s: %s %s err %d\n",
404 __func__, "queue", in->name, status);
405 list_add(&req->list, pool);
406 break;
407 }
408
Jim Sung28609d42010-11-04 18:47:51 -0700409 port->write_started++;
410
David Brownellc1dca562008-06-19 17:51:44 -0700411 /* abort immediately after disconnect */
412 if (!port->port_usb)
413 break;
414 }
415
Jiri Slaby35f95fd2012-04-02 13:54:48 +0200416 if (do_tty_wake && port->port.tty)
417 tty_wakeup(port->port.tty);
David Brownellc1dca562008-06-19 17:51:44 -0700418 return status;
419}
420
David Brownellc1dca562008-06-19 17:51:44 -0700421/*
422 * Context: caller owns port_lock, and port_usb is set
423 */
424static unsigned gs_start_rx(struct gs_port *port)
425/*
426__releases(&port->port_lock)
427__acquires(&port->port_lock)
428*/
429{
430 struct list_head *pool = &port->read_pool;
431 struct usb_ep *out = port->port_usb->out;
David Brownellc1dca562008-06-19 17:51:44 -0700432
433 while (!list_empty(pool)) {
434 struct usb_request *req;
435 int status;
436 struct tty_struct *tty;
437
David Brownell937ef732008-07-07 12:16:08 -0700438 /* no more rx if closed */
Jiri Slaby35f95fd2012-04-02 13:54:48 +0200439 tty = port->port.tty;
David Brownell937ef732008-07-07 12:16:08 -0700440 if (!tty)
David Brownellc1dca562008-06-19 17:51:44 -0700441 break;
442
Jim Sung28609d42010-11-04 18:47:51 -0700443 if (port->read_started >= QUEUE_SIZE)
444 break;
445
David Brownellc1dca562008-06-19 17:51:44 -0700446 req = list_entry(pool->next, struct usb_request, list);
447 list_del(&req->list);
448 req->length = out->maxpacket;
449
450 /* drop lock while we call out; the controller driver
451 * may need to call us back (e.g. for disconnect)
452 */
453 spin_unlock(&port->port_lock);
454 status = usb_ep_queue(out, req, GFP_ATOMIC);
455 spin_lock(&port->port_lock);
456
457 if (status) {
458 pr_debug("%s: %s %s err %d\n",
459 __func__, "queue", out->name, status);
460 list_add(&req->list, pool);
461 break;
462 }
Jim Sung28609d42010-11-04 18:47:51 -0700463 port->read_started++;
David Brownellc1dca562008-06-19 17:51:44 -0700464
465 /* abort immediately after disconnect */
466 if (!port->port_usb)
467 break;
468 }
Jim Sung28609d42010-11-04 18:47:51 -0700469 return port->read_started;
David Brownellc1dca562008-06-19 17:51:44 -0700470}
471
David Brownell937ef732008-07-07 12:16:08 -0700472/*
473 * RX tasklet takes data out of the RX queue and hands it up to the TTY
474 * layer until it refuses to take any more data (or is throttled back).
475 * Then it issues reads for any further data.
476 *
477 * If the RX queue becomes full enough that no usb_request is queued,
478 * the OUT endpoint may begin NAKing as soon as its FIFO fills up.
479 * So QUEUE_SIZE packets plus however many the FIFO holds (usually two)
480 * can be buffered before the TTY layer's buffers (currently 64 KB).
481 */
482static void gs_rx_push(unsigned long _port)
483{
484 struct gs_port *port = (void *)_port;
485 struct tty_struct *tty;
486 struct list_head *queue = &port->read_queue;
487 bool disconnect = false;
488 bool do_push = false;
489
490 /* hand any queued data to the tty */
491 spin_lock_irq(&port->port_lock);
Jiri Slaby35f95fd2012-04-02 13:54:48 +0200492 tty = port->port.tty;
David Brownell937ef732008-07-07 12:16:08 -0700493 while (!list_empty(queue)) {
494 struct usb_request *req;
495
496 req = list_first_entry(queue, struct usb_request, list);
497
498 /* discard data if tty was closed */
499 if (!tty)
500 goto recycle;
501
502 /* leave data queued if tty was rx throttled */
503 if (test_bit(TTY_THROTTLED, &tty->flags))
504 break;
505
506 switch (req->status) {
507 case -ESHUTDOWN:
508 disconnect = true;
509 pr_vdebug(PREFIX "%d: shutdown\n", port->port_num);
510 break;
511
512 default:
513 /* presumably a transient fault */
514 pr_warning(PREFIX "%d: unexpected RX status %d\n",
515 port->port_num, req->status);
516 /* FALLTHROUGH */
517 case 0:
518 /* normal completion */
519 break;
520 }
521
522 /* push data to (open) tty */
523 if (req->actual) {
524 char *packet = req->buf;
525 unsigned size = req->actual;
526 unsigned n;
527 int count;
528
529 /* we may have pushed part of this packet already... */
530 n = port->n_read;
531 if (n) {
532 packet += n;
533 size -= n;
534 }
535
536 count = tty_insert_flip_string(tty, packet, size);
537 if (count)
538 do_push = true;
539 if (count != size) {
540 /* stop pushing; TTY layer can't handle more */
541 port->n_read += count;
542 pr_vdebug(PREFIX "%d: rx block %d/%d\n",
543 port->port_num,
544 count, req->actual);
545 break;
546 }
547 port->n_read = 0;
548 }
549recycle:
550 list_move(&req->list, &port->read_pool);
Jim Sung28609d42010-11-04 18:47:51 -0700551 port->read_started--;
David Brownell937ef732008-07-07 12:16:08 -0700552 }
553
Jon Povey44a0c012010-06-14 19:41:04 +0900554 /* Push from tty to ldisc; without low_latency set this is handled by
555 * a workqueue, so we won't get callbacks and can hold port_lock
David Brownell937ef732008-07-07 12:16:08 -0700556 */
Shaun Silk50238292011-09-26 11:26:43 +1000557 if (tty && do_push)
David Brownell937ef732008-07-07 12:16:08 -0700558 tty_flip_buffer_push(tty);
David Brownell937ef732008-07-07 12:16:08 -0700559
560
561 /* We want our data queue to become empty ASAP, keeping data
562 * in the tty and ldisc (not here). If we couldn't push any
563 * this time around, there may be trouble unless there's an
564 * implicit tty_unthrottle() call on its way...
565 *
566 * REVISIT we should probably add a timer to keep the tasklet
567 * from starving ... but it's not clear that case ever happens.
568 */
569 if (!list_empty(queue) && tty) {
570 if (!test_bit(TTY_THROTTLED, &tty->flags)) {
571 if (do_push)
572 tasklet_schedule(&port->push);
573 else
574 pr_warning(PREFIX "%d: RX not scheduled?\n",
575 port->port_num);
576 }
577 }
578
579 /* If we're still connected, refill the USB RX queue. */
580 if (!disconnect && port->port_usb)
581 gs_start_rx(port);
582
583 spin_unlock_irq(&port->port_lock);
584}
585
David Brownellc1dca562008-06-19 17:51:44 -0700586static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
587{
David Brownellc1dca562008-06-19 17:51:44 -0700588 struct gs_port *port = ep->driver_data;
589
David Brownell937ef732008-07-07 12:16:08 -0700590 /* Queue all received data until the tty layer is ready for it. */
David Brownellc1dca562008-06-19 17:51:44 -0700591 spin_lock(&port->port_lock);
David Brownell937ef732008-07-07 12:16:08 -0700592 list_add_tail(&req->list, &port->read_queue);
593 tasklet_schedule(&port->push);
David Brownellc1dca562008-06-19 17:51:44 -0700594 spin_unlock(&port->port_lock);
595}
596
597static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
598{
599 struct gs_port *port = ep->driver_data;
600
601 spin_lock(&port->port_lock);
602 list_add(&req->list, &port->write_pool);
Jim Sung28609d42010-11-04 18:47:51 -0700603 port->write_started--;
David Brownellc1dca562008-06-19 17:51:44 -0700604
605 switch (req->status) {
606 default:
607 /* presumably a transient fault */
608 pr_warning("%s: unexpected %s status %d\n",
609 __func__, ep->name, req->status);
610 /* FALL THROUGH */
611 case 0:
612 /* normal completion */
613 gs_start_tx(port);
614 break;
615
616 case -ESHUTDOWN:
617 /* disconnect */
618 pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
619 break;
620 }
621
622 spin_unlock(&port->port_lock);
623}
624
Jim Sung28609d42010-11-04 18:47:51 -0700625static void gs_free_requests(struct usb_ep *ep, struct list_head *head,
626 int *allocated)
David Brownellc1dca562008-06-19 17:51:44 -0700627{
628 struct usb_request *req;
629
630 while (!list_empty(head)) {
631 req = list_entry(head->next, struct usb_request, list);
632 list_del(&req->list);
633 gs_free_req(ep, req);
Jim Sung28609d42010-11-04 18:47:51 -0700634 if (allocated)
635 (*allocated)--;
David Brownellc1dca562008-06-19 17:51:44 -0700636 }
637}
638
639static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
Jim Sung28609d42010-11-04 18:47:51 -0700640 void (*fn)(struct usb_ep *, struct usb_request *),
641 int *allocated)
David Brownellc1dca562008-06-19 17:51:44 -0700642{
643 int i;
644 struct usb_request *req;
Jim Sung28609d42010-11-04 18:47:51 -0700645 int n = allocated ? QUEUE_SIZE - *allocated : QUEUE_SIZE;
David Brownellc1dca562008-06-19 17:51:44 -0700646
647 /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't
648 * do quite that many this time, don't fail ... we just won't
649 * be as speedy as we might otherwise be.
650 */
Jim Sung28609d42010-11-04 18:47:51 -0700651 for (i = 0; i < n; i++) {
David Brownellc1dca562008-06-19 17:51:44 -0700652 req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
653 if (!req)
654 return list_empty(head) ? -ENOMEM : 0;
655 req->complete = fn;
656 list_add_tail(&req->list, head);
Jim Sung28609d42010-11-04 18:47:51 -0700657 if (allocated)
658 (*allocated)++;
David Brownellc1dca562008-06-19 17:51:44 -0700659 }
660 return 0;
661}
662
663/**
664 * gs_start_io - start USB I/O streams
665 * @dev: encapsulates endpoints to use
666 * Context: holding port_lock; port_tty and port_usb are non-null
667 *
668 * We only start I/O when something is connected to both sides of
669 * this port. If nothing is listening on the host side, we may
670 * be pointlessly filling up our TX buffers and FIFO.
671 */
672static int gs_start_io(struct gs_port *port)
673{
674 struct list_head *head = &port->read_pool;
675 struct usb_ep *ep = port->port_usb->out;
676 int status;
677 unsigned started;
678
679 /* Allocate RX and TX I/O buffers. We can't easily do this much
680 * earlier (with GFP_KERNEL) because the requests are coupled to
681 * endpoints, as are the packet sizes we'll be using. Different
682 * configurations may use different endpoints with a given port;
683 * and high speed vs full speed changes packet sizes too.
684 */
Jim Sung28609d42010-11-04 18:47:51 -0700685 status = gs_alloc_requests(ep, head, gs_read_complete,
686 &port->read_allocated);
David Brownellc1dca562008-06-19 17:51:44 -0700687 if (status)
688 return status;
689
690 status = gs_alloc_requests(port->port_usb->in, &port->write_pool,
Jim Sung28609d42010-11-04 18:47:51 -0700691 gs_write_complete, &port->write_allocated);
David Brownellc1dca562008-06-19 17:51:44 -0700692 if (status) {
Jim Sung28609d42010-11-04 18:47:51 -0700693 gs_free_requests(ep, head, &port->read_allocated);
David Brownellc1dca562008-06-19 17:51:44 -0700694 return status;
695 }
696
697 /* queue read requests */
David Brownell937ef732008-07-07 12:16:08 -0700698 port->n_read = 0;
David Brownellc1dca562008-06-19 17:51:44 -0700699 started = gs_start_rx(port);
700
701 /* unblock any pending writes into our circular buffer */
702 if (started) {
Jiri Slaby35f95fd2012-04-02 13:54:48 +0200703 tty_wakeup(port->port.tty);
David Brownellc1dca562008-06-19 17:51:44 -0700704 } else {
Jim Sung28609d42010-11-04 18:47:51 -0700705 gs_free_requests(ep, head, &port->read_allocated);
706 gs_free_requests(port->port_usb->in, &port->write_pool,
707 &port->write_allocated);
David Brownell937ef732008-07-07 12:16:08 -0700708 status = -EIO;
David Brownellc1dca562008-06-19 17:51:44 -0700709 }
710
David Brownell937ef732008-07-07 12:16:08 -0700711 return status;
David Brownellc1dca562008-06-19 17:51:44 -0700712}
713
714/*-------------------------------------------------------------------------*/
715
716/* TTY Driver */
717
718/*
719 * gs_open sets up the link between a gs_port and its associated TTY.
720 * That link is broken *only* by TTY close(), and all driver methods
721 * know that.
722 */
723static int gs_open(struct tty_struct *tty, struct file *file)
724{
725 int port_num = tty->index;
726 struct gs_port *port;
727 int status;
728
David Brownellc1dca562008-06-19 17:51:44 -0700729 do {
730 mutex_lock(&ports[port_num].lock);
731 port = ports[port_num].port;
732 if (!port)
733 status = -ENODEV;
734 else {
735 spin_lock_irq(&port->port_lock);
736
737 /* already open? Great. */
Jiri Slaby266e37e2012-04-02 13:54:47 +0200738 if (port->port.count) {
David Brownellc1dca562008-06-19 17:51:44 -0700739 status = 0;
Jiri Slaby266e37e2012-04-02 13:54:47 +0200740 port->port.count++;
David Brownellc1dca562008-06-19 17:51:44 -0700741
742 /* currently opening/closing? wait ... */
743 } else if (port->openclose) {
744 status = -EBUSY;
745
746 /* ... else we do the work */
747 } else {
748 status = -EAGAIN;
749 port->openclose = true;
750 }
751 spin_unlock_irq(&port->port_lock);
752 }
753 mutex_unlock(&ports[port_num].lock);
754
755 switch (status) {
756 default:
757 /* fully handled */
758 return status;
759 case -EAGAIN:
760 /* must do the work */
761 break;
762 case -EBUSY:
763 /* wait for EAGAIN task to finish */
764 msleep(1);
765 /* REVISIT could have a waitchannel here, if
766 * concurrent open performance is important
767 */
768 break;
769 }
770 } while (status != -EAGAIN);
771
772 /* Do the "real open" */
773 spin_lock_irq(&port->port_lock);
774
775 /* allocate circular buffer on first open */
776 if (port->port_write_buf.buf_buf == NULL) {
777
778 spin_unlock_irq(&port->port_lock);
779 status = gs_buf_alloc(&port->port_write_buf, WRITE_BUF_SIZE);
780 spin_lock_irq(&port->port_lock);
781
782 if (status) {
783 pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n",
784 port->port_num, tty, file);
785 port->openclose = false;
786 goto exit_unlock_port;
787 }
788 }
789
790 /* REVISIT if REMOVED (ports[].port NULL), abort the open
791 * to let rmmod work faster (but this way isn't wrong).
792 */
793
794 /* REVISIT maybe wait for "carrier detect" */
795
796 tty->driver_data = port;
Jiri Slaby35f95fd2012-04-02 13:54:48 +0200797 port->port.tty = tty;
David Brownellc1dca562008-06-19 17:51:44 -0700798
Jiri Slaby266e37e2012-04-02 13:54:47 +0200799 port->port.count = 1;
David Brownellc1dca562008-06-19 17:51:44 -0700800 port->openclose = false;
801
David Brownellc1dca562008-06-19 17:51:44 -0700802 /* if connected, start the I/O stream */
803 if (port->port_usb) {
David Brownell1f1ba112008-08-06 18:49:57 -0700804 struct gserial *gser = port->port_usb;
805
David Brownellc1dca562008-06-19 17:51:44 -0700806 pr_debug("gs_open: start ttyGS%d\n", port->port_num);
807 gs_start_io(port);
808
David Brownell1f1ba112008-08-06 18:49:57 -0700809 if (gser->connect)
810 gser->connect(gser);
David Brownellc1dca562008-06-19 17:51:44 -0700811 }
812
813 pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file);
814
815 status = 0;
816
817exit_unlock_port:
818 spin_unlock_irq(&port->port_lock);
819 return status;
820}
821
822static int gs_writes_finished(struct gs_port *p)
823{
824 int cond;
825
826 /* return true on disconnect or empty buffer */
827 spin_lock_irq(&p->port_lock);
828 cond = (p->port_usb == NULL) || !gs_buf_data_avail(&p->port_write_buf);
829 spin_unlock_irq(&p->port_lock);
830
831 return cond;
832}
833
834static void gs_close(struct tty_struct *tty, struct file *file)
835{
836 struct gs_port *port = tty->driver_data;
David Brownell1f1ba112008-08-06 18:49:57 -0700837 struct gserial *gser;
David Brownellc1dca562008-06-19 17:51:44 -0700838
839 spin_lock_irq(&port->port_lock);
840
Jiri Slaby266e37e2012-04-02 13:54:47 +0200841 if (port->port.count != 1) {
842 if (port->port.count == 0)
David Brownellc1dca562008-06-19 17:51:44 -0700843 WARN_ON(1);
844 else
Jiri Slaby266e37e2012-04-02 13:54:47 +0200845 --port->port.count;
David Brownellc1dca562008-06-19 17:51:44 -0700846 goto exit;
847 }
848
849 pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file);
850
851 /* mark port as closing but in use; we can drop port lock
852 * and sleep if necessary
853 */
854 port->openclose = true;
Jiri Slaby266e37e2012-04-02 13:54:47 +0200855 port->port.count = 0;
David Brownellc1dca562008-06-19 17:51:44 -0700856
David Brownell1f1ba112008-08-06 18:49:57 -0700857 gser = port->port_usb;
858 if (gser && gser->disconnect)
859 gser->disconnect(gser);
David Brownellc1dca562008-06-19 17:51:44 -0700860
861 /* wait for circular write buffer to drain, disconnect, or at
862 * most GS_CLOSE_TIMEOUT seconds; then discard the rest
863 */
David Brownell1f1ba112008-08-06 18:49:57 -0700864 if (gs_buf_data_avail(&port->port_write_buf) > 0 && gser) {
David Brownellc1dca562008-06-19 17:51:44 -0700865 spin_unlock_irq(&port->port_lock);
866 wait_event_interruptible_timeout(port->drain_wait,
867 gs_writes_finished(port),
868 GS_CLOSE_TIMEOUT * HZ);
869 spin_lock_irq(&port->port_lock);
David Brownell1f1ba112008-08-06 18:49:57 -0700870 gser = port->port_usb;
David Brownellc1dca562008-06-19 17:51:44 -0700871 }
872
873 /* Iff we're disconnected, there can be no I/O in flight so it's
874 * ok to free the circular buffer; else just scrub it. And don't
875 * let the push tasklet fire again until we're re-opened.
876 */
David Brownell1f1ba112008-08-06 18:49:57 -0700877 if (gser == NULL)
David Brownellc1dca562008-06-19 17:51:44 -0700878 gs_buf_free(&port->port_write_buf);
879 else
880 gs_buf_clear(&port->port_write_buf);
881
David Brownellc1dca562008-06-19 17:51:44 -0700882 tty->driver_data = NULL;
Jiri Slaby35f95fd2012-04-02 13:54:48 +0200883 port->port.tty = NULL;
David Brownellc1dca562008-06-19 17:51:44 -0700884
885 port->openclose = false;
886
887 pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
888 port->port_num, tty, file);
889
Haipeng YU484ca3a2012-11-14 15:40:01 +0100890 wake_up(&port->port.close_wait);
David Brownellc1dca562008-06-19 17:51:44 -0700891exit:
892 spin_unlock_irq(&port->port_lock);
893}
894
895static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
896{
897 struct gs_port *port = tty->driver_data;
898 unsigned long flags;
899 int status;
900
901 pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
902 port->port_num, tty, count);
903
904 spin_lock_irqsave(&port->port_lock, flags);
905 if (count)
906 count = gs_buf_put(&port->port_write_buf, buf, count);
907 /* treat count == 0 as flush_chars() */
908 if (port->port_usb)
909 status = gs_start_tx(port);
910 spin_unlock_irqrestore(&port->port_lock, flags);
911
912 return count;
913}
914
915static int gs_put_char(struct tty_struct *tty, unsigned char ch)
916{
917 struct gs_port *port = tty->driver_data;
918 unsigned long flags;
919 int status;
920
Joe Perchesbfa346a2012-02-28 10:49:38 -0800921 pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %pf\n",
David Brownellc1dca562008-06-19 17:51:44 -0700922 port->port_num, tty, ch, __builtin_return_address(0));
923
924 spin_lock_irqsave(&port->port_lock, flags);
925 status = gs_buf_put(&port->port_write_buf, &ch, 1);
926 spin_unlock_irqrestore(&port->port_lock, flags);
927
928 return status;
929}
930
931static void gs_flush_chars(struct tty_struct *tty)
932{
933 struct gs_port *port = tty->driver_data;
934 unsigned long flags;
935
936 pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
937
938 spin_lock_irqsave(&port->port_lock, flags);
939 if (port->port_usb)
940 gs_start_tx(port);
941 spin_unlock_irqrestore(&port->port_lock, flags);
942}
943
944static int gs_write_room(struct tty_struct *tty)
945{
946 struct gs_port *port = tty->driver_data;
947 unsigned long flags;
948 int room = 0;
949
950 spin_lock_irqsave(&port->port_lock, flags);
951 if (port->port_usb)
952 room = gs_buf_space_avail(&port->port_write_buf);
953 spin_unlock_irqrestore(&port->port_lock, flags);
954
955 pr_vdebug("gs_write_room: (%d,%p) room=%d\n",
956 port->port_num, tty, room);
957
958 return room;
959}
960
961static int gs_chars_in_buffer(struct tty_struct *tty)
962{
963 struct gs_port *port = tty->driver_data;
964 unsigned long flags;
965 int chars = 0;
966
967 spin_lock_irqsave(&port->port_lock, flags);
968 chars = gs_buf_data_avail(&port->port_write_buf);
969 spin_unlock_irqrestore(&port->port_lock, flags);
970
971 pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
972 port->port_num, tty, chars);
973
974 return chars;
975}
976
977/* undo side effects of setting TTY_THROTTLED */
978static void gs_unthrottle(struct tty_struct *tty)
979{
980 struct gs_port *port = tty->driver_data;
981 unsigned long flags;
David Brownellc1dca562008-06-19 17:51:44 -0700982
983 spin_lock_irqsave(&port->port_lock, flags);
David Brownell937ef732008-07-07 12:16:08 -0700984 if (port->port_usb) {
985 /* Kickstart read queue processing. We don't do xon/xoff,
986 * rts/cts, or other handshaking with the host, but if the
987 * read queue backs up enough we'll be NAKing OUT packets.
988 */
989 tasklet_schedule(&port->push);
990 pr_vdebug(PREFIX "%d: unthrottle\n", port->port_num);
991 }
David Brownellc1dca562008-06-19 17:51:44 -0700992 spin_unlock_irqrestore(&port->port_lock, flags);
David Brownellc1dca562008-06-19 17:51:44 -0700993}
994
David Brownell1f1ba112008-08-06 18:49:57 -0700995static int gs_break_ctl(struct tty_struct *tty, int duration)
996{
997 struct gs_port *port = tty->driver_data;
998 int status = 0;
999 struct gserial *gser;
1000
1001 pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n",
1002 port->port_num, duration);
1003
1004 spin_lock_irq(&port->port_lock);
1005 gser = port->port_usb;
1006 if (gser && gser->send_break)
1007 status = gser->send_break(gser, duration);
1008 spin_unlock_irq(&port->port_lock);
1009
1010 return status;
1011}
1012
David Brownellc1dca562008-06-19 17:51:44 -07001013static const struct tty_operations gs_tty_ops = {
1014 .open = gs_open,
1015 .close = gs_close,
1016 .write = gs_write,
1017 .put_char = gs_put_char,
1018 .flush_chars = gs_flush_chars,
1019 .write_room = gs_write_room,
1020 .chars_in_buffer = gs_chars_in_buffer,
1021 .unthrottle = gs_unthrottle,
David Brownell1f1ba112008-08-06 18:49:57 -07001022 .break_ctl = gs_break_ctl,
David Brownellc1dca562008-06-19 17:51:44 -07001023};
1024
1025/*-------------------------------------------------------------------------*/
1026
1027static struct tty_driver *gs_tty_driver;
1028
Benoit Gobyc3c04b22012-05-10 10:08:01 +02001029static int
David Brownellc1dca562008-06-19 17:51:44 -07001030gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding)
1031{
1032 struct gs_port *port;
1033
1034 port = kzalloc(sizeof(struct gs_port), GFP_KERNEL);
1035 if (port == NULL)
1036 return -ENOMEM;
1037
Jiri Slaby266e37e2012-04-02 13:54:47 +02001038 tty_port_init(&port->port);
David Brownellc1dca562008-06-19 17:51:44 -07001039 spin_lock_init(&port->port_lock);
David Brownellc1dca562008-06-19 17:51:44 -07001040 init_waitqueue_head(&port->drain_wait);
1041
1042 tasklet_init(&port->push, gs_rx_push, (unsigned long) port);
1043
1044 INIT_LIST_HEAD(&port->read_pool);
David Brownell937ef732008-07-07 12:16:08 -07001045 INIT_LIST_HEAD(&port->read_queue);
David Brownellc1dca562008-06-19 17:51:44 -07001046 INIT_LIST_HEAD(&port->write_pool);
1047
1048 port->port_num = port_num;
1049 port->port_line_coding = *coding;
1050
1051 ports[port_num].port = port;
1052
1053 return 0;
1054}
1055
1056/**
1057 * gserial_setup - initialize TTY driver for one or more ports
1058 * @g: gadget to associate with these ports
1059 * @count: how many ports to support
1060 * Context: may sleep
1061 *
1062 * The TTY stack needs to know in advance how many devices it should
1063 * plan to manage. Use this call to set up the ports you will be
1064 * exporting through USB. Later, connect them to functions based
1065 * on what configuration is activated by the USB host; and disconnect
1066 * them as appropriate.
1067 *
1068 * An example would be a two-configuration device in which both
1069 * configurations expose port 0, but through different functions.
1070 * One configuration could even expose port 1 while the other
1071 * one doesn't.
1072 *
1073 * Returns negative errno or zero.
1074 */
Benoit Gobyc3c04b22012-05-10 10:08:01 +02001075int gserial_setup(struct usb_gadget *g, unsigned count)
David Brownellc1dca562008-06-19 17:51:44 -07001076{
1077 unsigned i;
1078 struct usb_cdc_line_coding coding;
1079 int status;
1080
1081 if (count == 0 || count > N_PORTS)
1082 return -EINVAL;
1083
1084 gs_tty_driver = alloc_tty_driver(count);
1085 if (!gs_tty_driver)
1086 return -ENOMEM;
1087
David Brownellc1dca562008-06-19 17:51:44 -07001088 gs_tty_driver->driver_name = "g_serial";
David Brownell937ef732008-07-07 12:16:08 -07001089 gs_tty_driver->name = PREFIX;
David Brownellc1dca562008-06-19 17:51:44 -07001090 /* uses dynamically assigned dev_t values */
1091
1092 gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1093 gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1094 gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1095 gs_tty_driver->init_termios = tty_std_termios;
1096
1097 /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
1098 * MS-Windows. Otherwise, most of these flags shouldn't affect
1099 * anything unless we were to actually hook up to a serial line.
1100 */
1101 gs_tty_driver->init_termios.c_cflag =
1102 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1103 gs_tty_driver->init_termios.c_ispeed = 9600;
1104 gs_tty_driver->init_termios.c_ospeed = 9600;
1105
Harvey Harrison551509d2009-02-11 14:11:36 -08001106 coding.dwDTERate = cpu_to_le32(9600);
David Brownellc1dca562008-06-19 17:51:44 -07001107 coding.bCharFormat = 8;
1108 coding.bParityType = USB_CDC_NO_PARITY;
1109 coding.bDataBits = USB_CDC_1_STOP_BITS;
1110
1111 tty_set_operations(gs_tty_driver, &gs_tty_ops);
1112
1113 /* make devices be openable */
1114 for (i = 0; i < count; i++) {
1115 mutex_init(&ports[i].lock);
1116 status = gs_port_alloc(i, &coding);
1117 if (status) {
1118 count = i;
1119 goto fail;
1120 }
1121 }
1122 n_ports = count;
1123
1124 /* export the driver ... */
1125 status = tty_register_driver(gs_tty_driver);
1126 if (status) {
David Brownellc1dca562008-06-19 17:51:44 -07001127 pr_err("%s: cannot register, err %d\n",
1128 __func__, status);
1129 goto fail;
1130 }
1131
1132 /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
1133 for (i = 0; i < count; i++) {
1134 struct device *tty_dev;
1135
Jiri Slaby734cc172012-08-07 21:47:47 +02001136 tty_dev = tty_port_register_device(&ports[i].port->port,
1137 gs_tty_driver, i, &g->dev);
David Brownellc1dca562008-06-19 17:51:44 -07001138 if (IS_ERR(tty_dev))
1139 pr_warning("%s: no classdev for port %d, err %ld\n",
1140 __func__, i, PTR_ERR(tty_dev));
1141 }
1142
1143 pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
1144 count, (count == 1) ? "" : "s");
1145
1146 return status;
1147fail:
Jiri Slaby191c5f12012-11-15 09:49:56 +01001148 while (count--) {
1149 tty_port_destroy(&ports[count].port->port);
David Brownellc1dca562008-06-19 17:51:44 -07001150 kfree(ports[count].port);
Jiri Slaby191c5f12012-11-15 09:49:56 +01001151 }
David Brownellc1dca562008-06-19 17:51:44 -07001152 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);
Jiri Slaby266e37e2012-04-02 13:54:47 +02001162 cond = (port->port.count == 0) && !port->openclose;
David Brownellc1dca562008-06-19 17:51:44 -07001163 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
David Brownellac90e362008-07-01 13:18:20 -07001184 if (!gs_tty_driver)
1185 return;
1186
David Brownellc1dca562008-06-19 17:51:44 -07001187 /* 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
David Brownell937ef732008-07-07 12:16:08 -07001198 tasklet_kill(&port->push);
1199
David Brownellc1dca562008-06-19 17:51:44 -07001200 /* wait for old opens to finish */
Jiri Slaby3d5ea592012-04-02 13:54:49 +02001201 wait_event(port->port.close_wait, gs_closed(port));
David Brownellc1dca562008-06-19 17:51:44 -07001202
1203 WARN_ON(port->port_usb != NULL);
1204
Jiri Slaby191c5f12012-11-15 09:49:56 +01001205 tty_port_destroy(&port->port);
David Brownellc1dca562008-06-19 17:51:44 -07001206 kfree(port);
1207 }
1208 n_ports = 0;
1209
1210 tty_unregister_driver(gs_tty_driver);
Jon Poveyb23097b2010-06-14 19:42:10 +09001211 put_tty_driver(gs_tty_driver);
David Brownellc1dca562008-06-19 17:51:44 -07001212 gs_tty_driver = NULL;
1213
1214 pr_debug("%s: cleaned up ttyGS* support\n", __func__);
1215}
1216
1217/**
1218 * gserial_connect - notify TTY I/O glue that USB link is active
1219 * @gser: the function, set up with endpoints and descriptors
1220 * @port_num: which port is active
1221 * Context: any (usually from irq)
1222 *
1223 * This is called activate endpoints and let the TTY layer know that
1224 * the connection is active ... not unlike "carrier detect". It won't
1225 * necessarily start I/O queues; unless the TTY is held open by any
1226 * task, there would be no point. However, the endpoints will be
1227 * activated so the USB host can perform I/O, subject to basic USB
1228 * hardware flow control.
1229 *
1230 * Caller needs to have set up the endpoints and USB function in @dev
1231 * before calling this, as well as the appropriate (speed-specific)
1232 * endpoint descriptors, and also have set up the TTY driver by calling
1233 * @gserial_setup().
1234 *
1235 * Returns negative errno or zero.
1236 * On success, ep->driver_data will be overwritten.
1237 */
1238int gserial_connect(struct gserial *gser, u8 port_num)
1239{
1240 struct gs_port *port;
1241 unsigned long flags;
1242 int status;
1243
1244 if (!gs_tty_driver || port_num >= n_ports)
1245 return -ENXIO;
1246
1247 /* we "know" gserial_cleanup() hasn't been called */
1248 port = ports[port_num].port;
1249
1250 /* activate the endpoints */
Tatyana Brokhman72c973d2011-06-28 16:33:48 +03001251 status = usb_ep_enable(gser->in);
David Brownellc1dca562008-06-19 17:51:44 -07001252 if (status < 0)
1253 return status;
1254 gser->in->driver_data = port;
1255
Tatyana Brokhman72c973d2011-06-28 16:33:48 +03001256 status = usb_ep_enable(gser->out);
David Brownellc1dca562008-06-19 17:51:44 -07001257 if (status < 0)
1258 goto fail_out;
1259 gser->out->driver_data = port;
1260
1261 /* then tell the tty glue that I/O can work */
1262 spin_lock_irqsave(&port->port_lock, flags);
1263 gser->ioport = port;
1264 port->port_usb = gser;
1265
1266 /* REVISIT unclear how best to handle this state...
1267 * we don't really couple it with the Linux TTY.
1268 */
1269 gser->port_line_coding = port->port_line_coding;
1270
1271 /* REVISIT if waiting on "carrier detect", signal. */
1272
David Brownell1f1ba112008-08-06 18:49:57 -07001273 /* if it's already open, start I/O ... and notify the serial
1274 * protocol about open/close status (connect/disconnect).
David Brownellc1dca562008-06-19 17:51:44 -07001275 */
Jiri Slaby266e37e2012-04-02 13:54:47 +02001276 if (port->port.count) {
David Brownellc1dca562008-06-19 17:51:44 -07001277 pr_debug("gserial_connect: start ttyGS%d\n", port->port_num);
1278 gs_start_io(port);
David Brownell1f1ba112008-08-06 18:49:57 -07001279 if (gser->connect)
1280 gser->connect(gser);
1281 } else {
1282 if (gser->disconnect)
1283 gser->disconnect(gser);
David Brownellc1dca562008-06-19 17:51:44 -07001284 }
1285
1286 spin_unlock_irqrestore(&port->port_lock, flags);
1287
1288 return status;
1289
1290fail_out:
1291 usb_ep_disable(gser->in);
1292 gser->in->driver_data = NULL;
1293 return status;
1294}
1295
1296/**
1297 * gserial_disconnect - notify TTY I/O glue that USB link is inactive
1298 * @gser: the function, on which gserial_connect() was called
1299 * Context: any (usually from irq)
1300 *
1301 * This is called to deactivate endpoints and let the TTY layer know
1302 * that the connection went inactive ... not unlike "hangup".
1303 *
1304 * On return, the state is as if gserial_connect() had never been called;
1305 * there is no active USB I/O on these endpoints.
1306 */
1307void gserial_disconnect(struct gserial *gser)
1308{
1309 struct gs_port *port = gser->ioport;
1310 unsigned long flags;
1311
1312 if (!port)
1313 return;
1314
1315 /* tell the TTY glue not to do I/O here any more */
1316 spin_lock_irqsave(&port->port_lock, flags);
1317
1318 /* REVISIT as above: how best to track this? */
1319 port->port_line_coding = gser->port_line_coding;
1320
1321 port->port_usb = NULL;
1322 gser->ioport = NULL;
Jiri Slaby266e37e2012-04-02 13:54:47 +02001323 if (port->port.count > 0 || port->openclose) {
David Brownellc1dca562008-06-19 17:51:44 -07001324 wake_up_interruptible(&port->drain_wait);
Jiri Slaby35f95fd2012-04-02 13:54:48 +02001325 if (port->port.tty)
1326 tty_hangup(port->port.tty);
David Brownellc1dca562008-06-19 17:51:44 -07001327 }
1328 spin_unlock_irqrestore(&port->port_lock, flags);
1329
1330 /* disable endpoints, aborting down any active I/O */
1331 usb_ep_disable(gser->out);
1332 gser->out->driver_data = NULL;
1333
1334 usb_ep_disable(gser->in);
1335 gser->in->driver_data = NULL;
1336
1337 /* finally, free any unused/unusable I/O buffers */
1338 spin_lock_irqsave(&port->port_lock, flags);
Jiri Slaby266e37e2012-04-02 13:54:47 +02001339 if (port->port.count == 0 && !port->openclose)
David Brownellc1dca562008-06-19 17:51:44 -07001340 gs_buf_free(&port->port_write_buf);
Jim Sung28609d42010-11-04 18:47:51 -07001341 gs_free_requests(gser->out, &port->read_pool, NULL);
1342 gs_free_requests(gser->out, &port->read_queue, NULL);
1343 gs_free_requests(gser->in, &port->write_pool, NULL);
1344
1345 port->read_allocated = port->read_started =
1346 port->write_allocated = port->write_started = 0;
1347
David Brownellc1dca562008-06-19 17:51:44 -07001348 spin_unlock_irqrestore(&port->port_lock, flags);
1349}