Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
u_serial.c
Go to the documentation of this file.
1 /*
2  * u_serial.c - utilities for USB gadget "serial port"/TTY support
3  *
4  * Copyright (C) 2003 Al Borchers ([email protected])
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 ([email protected])
10  * Copyright (C) 2000 Peter Berger ([email protected])
11  * Copyright (C) 2000 Al Borchers ([email protected])
12  *
13  * This software is distributed under the terms of the GNU General
14  * Public License ("GPL") as published by the Free Software Foundation,
15  * either version 2 of that License or (at your option) any later version.
16  */
17 
18 /* #define VERBOSE_DEBUG */
19 
20 #include <linux/kernel.h>
21 #include <linux/sched.h>
22 #include <linux/interrupt.h>
23 #include <linux/device.h>
24 #include <linux/delay.h>
25 #include <linux/tty.h>
26 #include <linux/tty_flip.h>
27 #include <linux/slab.h>
28 #include <linux/export.h>
29 
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 
58 #define PREFIX "ttyGS"
59 
60 /*
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
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
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 */
85 struct 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  */
96 struct gs_port {
97  struct tty_port port;
98  spinlock_t port_lock; /* guard port_* access */
99 
100  struct gserial *port_usb;
101 
102  bool openclose; /* open/close in progress */
104 
109  unsigned n_read;
111 
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
124 static struct portmaster {
125  struct mutex lock; /* protect open/close */
126  struct gs_port *port;
127 } ports[N_PORTS];
128 static unsigned n_ports;
129 
130 #define GS_CLOSE_TIMEOUT 15 /* seconds */
131 
132 
133 
134 #ifdef VERBOSE_DEBUG
135 #define pr_vdebug(fmt, arg...) \
136  pr_debug(fmt, ##arg)
137 #else
138 #define pr_vdebug(fmt, arg...) \
139  ({ if (0) pr_debug(fmt, ##arg); })
140 #endif
141 
142 /*-------------------------------------------------------------------------*/
143 
144 /* Circular Buffer */
145 
146 /*
147  * gs_buf_alloc
148  *
149  * Allocate a circular buffer and all associated memory.
150  */
151 static int gs_buf_alloc(struct gs_buf *gb, unsigned size)
152 {
153  gb->buf_buf = kmalloc(size, GFP_KERNEL);
154  if (gb->buf_buf == NULL)
155  return -ENOMEM;
156 
157  gb->buf_size = size;
158  gb->buf_put = gb->buf_buf;
159  gb->buf_get = gb->buf_buf;
160 
161  return 0;
162 }
163 
164 /*
165  * gs_buf_free
166  *
167  * Free the buffer and all associated memory.
168  */
169 static void gs_buf_free(struct gs_buf *gb)
170 {
171  kfree(gb->buf_buf);
172  gb->buf_buf = NULL;
173 }
174 
175 /*
176  * gs_buf_clear
177  *
178  * Clear out all data in the circular buffer.
179  */
180 static void gs_buf_clear(struct gs_buf *gb)
181 {
182  gb->buf_get = gb->buf_put;
183  /* equivalent to a get of all data available */
184 }
185 
186 /*
187  * gs_buf_data_avail
188  *
189  * Return the number of bytes of data written into the circular
190  * buffer.
191  */
192 static unsigned gs_buf_data_avail(struct gs_buf *gb)
193 {
194  return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size;
195 }
196 
197 /*
198  * gs_buf_space_avail
199  *
200  * Return the number of bytes of space available in the circular
201  * buffer.
202  */
203 static unsigned gs_buf_space_avail(struct gs_buf *gb)
204 {
205  return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size;
206 }
207 
208 /*
209  * gs_buf_put
210  *
211  * Copy data data from a user buffer and put it into the circular buffer.
212  * Restrict to the amount of space available.
213  *
214  * Return the number of bytes copied.
215  */
216 static unsigned
217 gs_buf_put(struct gs_buf *gb, const char *buf, unsigned count)
218 {
219  unsigned len;
220 
221  len = gs_buf_space_avail(gb);
222  if (count > len)
223  count = len;
224 
225  if (count == 0)
226  return 0;
227 
228  len = gb->buf_buf + gb->buf_size - gb->buf_put;
229  if (count > len) {
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;
233  } else {
234  memcpy(gb->buf_put, buf, count);
235  if (count < len)
236  gb->buf_put += count;
237  else /* count == len */
238  gb->buf_put = gb->buf_buf;
239  }
240 
241  return count;
242 }
243 
244 /*
245  * gs_buf_get
246  *
247  * Get data from the circular buffer and copy to the given buffer.
248  * Restrict to the amount of data available.
249  *
250  * Return the number of bytes copied.
251  */
252 static unsigned
253 gs_buf_get(struct gs_buf *gb, char *buf, unsigned count)
254 {
255  unsigned len;
256 
257  len = gs_buf_data_avail(gb);
258  if (count > len)
259  count = len;
260 
261  if (count == 0)
262  return 0;
263 
264  len = gb->buf_buf + gb->buf_size - gb->buf_get;
265  if (count > len) {
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;
269  } else {
270  memcpy(buf, gb->buf_get, count);
271  if (count < len)
272  gb->buf_get += count;
273  else /* count == len */
274  gb->buf_get = gb->buf_buf;
275  }
276 
277  return count;
278 }
279 
280 /*-------------------------------------------------------------------------*/
281 
282 /* I/O glue between TTY (upper) and USB function (lower) driver layers */
283 
284 /*
285  * gs_alloc_req
286  *
287  * Allocate a usb_request and its buffer. Returns a pointer to the
288  * usb_request or NULL if there is an error.
289  */
290 struct usb_request *
291 gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
292 {
293  struct usb_request *req;
294 
295  req = usb_ep_alloc_request(ep, kmalloc_flags);
296 
297  if (req != NULL) {
298  req->length = len;
299  req->buf = kmalloc(len, kmalloc_flags);
300  if (req->buf == NULL) {
301  usb_ep_free_request(ep, req);
302  return NULL;
303  }
304  }
305 
306  return req;
307 }
308 
309 /*
310  * gs_free_req
311  *
312  * Free a usb_request and its buffer.
313  */
314 void gs_free_req(struct usb_ep *ep, struct usb_request *req)
315 {
316  kfree(req->buf);
317  usb_ep_free_request(ep, req);
318 }
319 
320 /*
321  * gs_send_packet
322  *
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.
326  *
327  * Called with port_lock held.
328  */
329 static unsigned
330 gs_send_packet(struct gs_port *port, char *packet, unsigned size)
331 {
332  unsigned len;
333 
334  len = gs_buf_data_avail(&port->port_write_buf);
335  if (len < size)
336  size = len;
337  if (size != 0)
338  size = gs_buf_get(&port->port_write_buf, packet, size);
339  return size;
340 }
341 
342 /*
343  * gs_start_tx
344  *
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.
350  *
351  * Context: caller owns port_lock; port_usb is non-null.
352  */
353 static int gs_start_tx(struct gs_port *port)
354 /*
355 __releases(&port->port_lock)
356 __acquires(&port->port_lock)
357 */
358 {
359  struct list_head *pool = &port->write_pool;
360  struct usb_ep *in = port->port_usb->in;
361  int status = 0;
362  bool do_tty_wake = false;
363 
364  while (!list_empty(pool)) {
365  struct usb_request *req;
366  int len;
367 
368  if (port->write_started >= QUEUE_SIZE)
369  break;
370 
371  req = list_entry(pool->next, struct usb_request, list);
372  len = gs_send_packet(port, req->buf, in->maxpacket);
373  if (len == 0) {
375  break;
376  }
377  do_tty_wake = true;
378 
379  req->length = len;
380  list_del(&req->list);
381  req->zero = (gs_buf_data_avail(&port->port_write_buf) == 0);
382 
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));
386 
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!
390  *
391  * NOTE that we may keep sending data for a while after
392  * the TTY closed (dev->ioport->port_tty is NULL).
393  */
394  spin_unlock(&port->port_lock);
395  status = usb_ep_queue(in, req, GFP_ATOMIC);
396  spin_lock(&port->port_lock);
397 
398  if (status) {
399  pr_debug("%s: %s %s err %d\n",
400  __func__, "queue", in->name, status);
401  list_add(&req->list, pool);
402  break;
403  }
404 
405  port->write_started++;
406 
407  /* abort immediately after disconnect */
408  if (!port->port_usb)
409  break;
410  }
411 
412  if (do_tty_wake && port->port.tty)
413  tty_wakeup(port->port.tty);
414  return status;
415 }
416 
417 /*
418  * Context: caller owns port_lock, and port_usb is set
419  */
420 static unsigned gs_start_rx(struct gs_port *port)
421 /*
422 __releases(&port->port_lock)
423 __acquires(&port->port_lock)
424 */
425 {
426  struct list_head *pool = &port->read_pool;
427  struct usb_ep *out = port->port_usb->out;
428 
429  while (!list_empty(pool)) {
430  struct usb_request *req;
431  int status;
432  struct tty_struct *tty;
433 
434  /* no more rx if closed */
435  tty = port->port.tty;
436  if (!tty)
437  break;
438 
439  if (port->read_started >= QUEUE_SIZE)
440  break;
441 
442  req = list_entry(pool->next, struct usb_request, list);
443  list_del(&req->list);
444  req->length = out->maxpacket;
445 
446  /* drop lock while we call out; the controller driver
447  * may need to call us back (e.g. for disconnect)
448  */
449  spin_unlock(&port->port_lock);
450  status = usb_ep_queue(out, req, GFP_ATOMIC);
451  spin_lock(&port->port_lock);
452 
453  if (status) {
454  pr_debug("%s: %s %s err %d\n",
455  __func__, "queue", out->name, status);
456  list_add(&req->list, pool);
457  break;
458  }
459  port->read_started++;
460 
461  /* abort immediately after disconnect */
462  if (!port->port_usb)
463  break;
464  }
465  return port->read_started;
466 }
467 
468 /*
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.
472  *
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).
477  */
478 static void gs_rx_push(unsigned long _port)
479 {
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;
485 
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;
491 
492  req = list_first_entry(queue, struct usb_request, list);
493 
494  /* discard data if tty was closed */
495  if (!tty)
496  goto recycle;
497 
498  /* leave data queued if tty was rx throttled */
499  if (test_bit(TTY_THROTTLED, &tty->flags))
500  break;
501 
502  switch (req->status) {
503  case -ESHUTDOWN:
504  disconnect = true;
505  pr_vdebug(PREFIX "%d: shutdown\n", port->port_num);
506  break;
507 
508  default:
509  /* presumably a transient fault */
510  pr_warning(PREFIX "%d: unexpected RX status %d\n",
511  port->port_num, req->status);
512  /* FALLTHROUGH */
513  case 0:
514  /* normal completion */
515  break;
516  }
517 
518  /* push data to (open) tty */
519  if (req->actual) {
520  char *packet = req->buf;
521  unsigned size = req->actual;
522  unsigned n;
523  int count;
524 
525  /* we may have pushed part of this packet already... */
526  n = port->n_read;
527  if (n) {
528  packet += n;
529  size -= n;
530  }
531 
532  count = tty_insert_flip_string(tty, packet, size);
533  if (count)
534  do_push = true;
535  if (count != 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",
539  port->port_num,
540  count, req->actual);
541  break;
542  }
543  port->n_read = 0;
544  }
545 recycle:
546  list_move(&req->list, &port->read_pool);
547  port->read_started--;
548  }
549 
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
552  */
553  if (tty && do_push)
555 
556 
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...
561  *
562  * REVISIT we should probably add a timer to keep the tasklet
563  * from starving ... but it's not clear that case ever happens.
564  */
565  if (!list_empty(queue) && tty) {
566  if (!test_bit(TTY_THROTTLED, &tty->flags)) {
567  if (do_push)
568  tasklet_schedule(&port->push);
569  else
570  pr_warning(PREFIX "%d: RX not scheduled?\n",
571  port->port_num);
572  }
573  }
574 
575  /* If we're still connected, refill the USB RX queue. */
576  if (!disconnect && port->port_usb)
577  gs_start_rx(port);
578 
579  spin_unlock_irq(&port->port_lock);
580 }
581 
582 static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
583 {
584  struct gs_port *port = ep->driver_data;
585 
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);
591 }
592 
593 static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
594 {
595  struct gs_port *port = ep->driver_data;
596 
597  spin_lock(&port->port_lock);
598  list_add(&req->list, &port->write_pool);
599  port->write_started--;
600 
601  switch (req->status) {
602  default:
603  /* presumably a transient fault */
604  pr_warning("%s: unexpected %s status %d\n",
605  __func__, ep->name, req->status);
606  /* FALL THROUGH */
607  case 0:
608  /* normal completion */
609  gs_start_tx(port);
610  break;
611 
612  case -ESHUTDOWN:
613  /* disconnect */
614  pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
615  break;
616  }
617 
618  spin_unlock(&port->port_lock);
619 }
620 
621 static void gs_free_requests(struct usb_ep *ep, struct list_head *head,
622  int *allocated)
623 {
624  struct usb_request *req;
625 
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);
630  if (allocated)
631  (*allocated)--;
632  }
633 }
634 
635 static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
636  void (*fn)(struct usb_ep *, struct usb_request *),
637  int *allocated)
638 {
639  int i;
640  struct usb_request *req;
641  int n = allocated ? QUEUE_SIZE - *allocated : QUEUE_SIZE;
642 
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.
646  */
647  for (i = 0; i < n; i++) {
648  req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
649  if (!req)
650  return list_empty(head) ? -ENOMEM : 0;
651  req->complete = fn;
652  list_add_tail(&req->list, head);
653  if (allocated)
654  (*allocated)++;
655  }
656  return 0;
657 }
658 
668 static int gs_start_io(struct gs_port *port)
669 {
670  struct list_head *head = &port->read_pool;
671  struct usb_ep *ep = port->port_usb->out;
672  int status;
673  unsigned started;
674 
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.
680  */
681  status = gs_alloc_requests(ep, head, gs_read_complete,
682  &port->read_allocated);
683  if (status)
684  return status;
685 
686  status = gs_alloc_requests(port->port_usb->in, &port->write_pool,
687  gs_write_complete, &port->write_allocated);
688  if (status) {
689  gs_free_requests(ep, head, &port->read_allocated);
690  return status;
691  }
692 
693  /* queue read requests */
694  port->n_read = 0;
695  started = gs_start_rx(port);
696 
697  /* unblock any pending writes into our circular buffer */
698  if (started) {
699  tty_wakeup(port->port.tty);
700  } else {
701  gs_free_requests(ep, head, &port->read_allocated);
702  gs_free_requests(port->port_usb->in, &port->write_pool,
703  &port->write_allocated);
704  status = -EIO;
705  }
706 
707  return status;
708 }
709 
710 /*-------------------------------------------------------------------------*/
711 
712 /* TTY Driver */
713 
714 /*
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
717  * know that.
718  */
719 static int gs_open(struct tty_struct *tty, struct file *file)
720 {
721  int port_num = tty->index;
722  struct gs_port *port;
723  int status;
724 
725  do {
726  mutex_lock(&ports[port_num].lock);
727  port = ports[port_num].port;
728  if (!port)
729  status = -ENODEV;
730  else {
731  spin_lock_irq(&port->port_lock);
732 
733  /* already open? Great. */
734  if (port->port.count) {
735  status = 0;
736  port->port.count++;
737 
738  /* currently opening/closing? wait ... */
739  } else if (port->openclose) {
740  status = -EBUSY;
741 
742  /* ... else we do the work */
743  } else {
744  status = -EAGAIN;
745  port->openclose = true;
746  }
747  spin_unlock_irq(&port->port_lock);
748  }
749  mutex_unlock(&ports[port_num].lock);
750 
751  switch (status) {
752  default:
753  /* fully handled */
754  return status;
755  case -EAGAIN:
756  /* must do the work */
757  break;
758  case -EBUSY:
759  /* wait for EAGAIN task to finish */
760  msleep(1);
761  /* REVISIT could have a waitchannel here, if
762  * concurrent open performance is important
763  */
764  break;
765  }
766  } while (status != -EAGAIN);
767 
768  /* Do the "real open" */
769  spin_lock_irq(&port->port_lock);
770 
771  /* allocate circular buffer on first open */
772  if (port->port_write_buf.buf_buf == NULL) {
773 
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);
777 
778  if (status) {
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;
783  }
784  }
785 
786  /* REVISIT if REMOVED (ports[].port NULL), abort the open
787  * to let rmmod work faster (but this way isn't wrong).
788  */
789 
790  /* REVISIT maybe wait for "carrier detect" */
791 
792  tty->driver_data = port;
793  port->port.tty = tty;
794 
795  port->port.count = 1;
796  port->openclose = false;
797 
798  /* if connected, start the I/O stream */
799  if (port->port_usb) {
800  struct gserial *gser = port->port_usb;
801 
802  pr_debug("gs_open: start ttyGS%d\n", port->port_num);
803  gs_start_io(port);
804 
805  if (gser->connect)
806  gser->connect(gser);
807  }
808 
809  pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file);
810 
811  status = 0;
812 
813 exit_unlock_port:
814  spin_unlock_irq(&port->port_lock);
815  return status;
816 }
817 
818 static int gs_writes_finished(struct gs_port *p)
819 {
820  int cond;
821 
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);
826 
827  return cond;
828 }
829 
830 static void gs_close(struct tty_struct *tty, struct file *file)
831 {
832  struct gs_port *port = tty->driver_data;
833  struct gserial *gser;
834 
835  spin_lock_irq(&port->port_lock);
836 
837  if (port->port.count != 1) {
838  if (port->port.count == 0)
839  WARN_ON(1);
840  else
841  --port->port.count;
842  goto exit;
843  }
844 
845  pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file);
846 
847  /* mark port as closing but in use; we can drop port lock
848  * and sleep if necessary
849  */
850  port->openclose = true;
851  port->port.count = 0;
852 
853  gser = port->port_usb;
854  if (gser && gser->disconnect)
855  gser->disconnect(gser);
856 
857  /* wait for circular write buffer to drain, disconnect, or at
858  * most GS_CLOSE_TIMEOUT seconds; then discard the rest
859  */
860  if (gs_buf_data_avail(&port->port_write_buf) > 0 && gser) {
861  spin_unlock_irq(&port->port_lock);
863  gs_writes_finished(port),
864  GS_CLOSE_TIMEOUT * HZ);
865  spin_lock_irq(&port->port_lock);
866  gser = port->port_usb;
867  }
868 
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.
872  */
873  if (gser == NULL)
874  gs_buf_free(&port->port_write_buf);
875  else
876  gs_buf_clear(&port->port_write_buf);
877 
878  tty->driver_data = NULL;
879  port->port.tty = NULL;
880 
881  port->openclose = false;
882 
883  pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
884  port->port_num, tty, file);
885 
886  wake_up_interruptible(&port->port.close_wait);
887 exit:
888  spin_unlock_irq(&port->port_lock);
889 }
890 
891 static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
892 {
893  struct gs_port *port = tty->driver_data;
894  unsigned long flags;
895  int status;
896 
897  pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
898  port->port_num, tty, count);
899 
900  spin_lock_irqsave(&port->port_lock, flags);
901  if (count)
902  count = gs_buf_put(&port->port_write_buf, buf, count);
903  /* treat count == 0 as flush_chars() */
904  if (port->port_usb)
905  status = gs_start_tx(port);
906  spin_unlock_irqrestore(&port->port_lock, flags);
907 
908  return count;
909 }
910 
911 static int gs_put_char(struct tty_struct *tty, unsigned char ch)
912 {
913  struct gs_port *port = tty->driver_data;
914  unsigned long flags;
915  int status;
916 
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));
919 
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);
923 
924  return status;
925 }
926 
927 static void gs_flush_chars(struct tty_struct *tty)
928 {
929  struct gs_port *port = tty->driver_data;
930  unsigned long flags;
931 
932  pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
933 
934  spin_lock_irqsave(&port->port_lock, flags);
935  if (port->port_usb)
936  gs_start_tx(port);
937  spin_unlock_irqrestore(&port->port_lock, flags);
938 }
939 
940 static int gs_write_room(struct tty_struct *tty)
941 {
942  struct gs_port *port = tty->driver_data;
943  unsigned long flags;
944  int room = 0;
945 
946  spin_lock_irqsave(&port->port_lock, flags);
947  if (port->port_usb)
948  room = gs_buf_space_avail(&port->port_write_buf);
949  spin_unlock_irqrestore(&port->port_lock, flags);
950 
951  pr_vdebug("gs_write_room: (%d,%p) room=%d\n",
952  port->port_num, tty, room);
953 
954  return room;
955 }
956 
957 static int gs_chars_in_buffer(struct tty_struct *tty)
958 {
959  struct gs_port *port = tty->driver_data;
960  unsigned long flags;
961  int chars = 0;
962 
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);
966 
967  pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
968  port->port_num, tty, chars);
969 
970  return chars;
971 }
972 
973 /* undo side effects of setting TTY_THROTTLED */
974 static void gs_unthrottle(struct tty_struct *tty)
975 {
976  struct gs_port *port = tty->driver_data;
977  unsigned long flags;
978 
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.
984  */
985  tasklet_schedule(&port->push);
986  pr_vdebug(PREFIX "%d: unthrottle\n", port->port_num);
987  }
988  spin_unlock_irqrestore(&port->port_lock, flags);
989 }
990 
991 static int gs_break_ctl(struct tty_struct *tty, int duration)
992 {
993  struct gs_port *port = tty->driver_data;
994  int status = 0;
995  struct gserial *gser;
996 
997  pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n",
998  port->port_num, duration);
999 
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);
1005 
1006  return status;
1007 }
1008 
1009 static const struct tty_operations gs_tty_ops = {
1010  .open = gs_open,
1011  .close = gs_close,
1012  .write = gs_write,
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,
1019 };
1020 
1021 /*-------------------------------------------------------------------------*/
1022 
1023 static struct tty_driver *gs_tty_driver;
1024 
1025 static int
1026 gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding)
1027 {
1028  struct gs_port *port;
1029 
1030  port = kzalloc(sizeof(struct gs_port), GFP_KERNEL);
1031  if (port == NULL)
1032  return -ENOMEM;
1033 
1034  tty_port_init(&port->port);
1035  spin_lock_init(&port->port_lock);
1037 
1038  tasklet_init(&port->push, gs_rx_push, (unsigned long) port);
1039 
1040  INIT_LIST_HEAD(&port->read_pool);
1041  INIT_LIST_HEAD(&port->read_queue);
1042  INIT_LIST_HEAD(&port->write_pool);
1043 
1044  port->port_num = port_num;
1045  port->port_line_coding = *coding;
1046 
1047  ports[port_num].port = port;
1048 
1049  return 0;
1050 }
1051 
1071 int gserial_setup(struct usb_gadget *g, unsigned count)
1072 {
1073  unsigned i;
1074  struct usb_cdc_line_coding coding;
1075  int status;
1076 
1077  if (count == 0 || count > N_PORTS)
1078  return -EINVAL;
1079 
1080  gs_tty_driver = alloc_tty_driver(count);
1081  if (!gs_tty_driver)
1082  return -ENOMEM;
1083 
1084  gs_tty_driver->driver_name = "g_serial";
1085  gs_tty_driver->name = PREFIX;
1086  /* uses dynamically assigned dev_t values */
1087 
1088  gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1089  gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1091  gs_tty_driver->init_termios = tty_std_termios;
1092 
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.
1096  */
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;
1101 
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;
1106 
1107  tty_set_operations(gs_tty_driver, &gs_tty_ops);
1108 
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);
1113  if (status) {
1114  count = i;
1115  goto fail;
1116  }
1117  }
1118  n_ports = count;
1119 
1120  /* export the driver ... */
1121  status = tty_register_driver(gs_tty_driver);
1122  if (status) {
1123  pr_err("%s: cannot register, err %d\n",
1124  __func__, status);
1125  goto fail;
1126  }
1127 
1128  /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
1129  for (i = 0; i < count; i++) {
1130  struct device *tty_dev;
1131 
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));
1136  }
1137 
1138  pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
1139  count, (count == 1) ? "" : "s");
1140 
1141  return status;
1142 fail:
1143  while (count--)
1144  kfree(ports[count].port);
1145  put_tty_driver(gs_tty_driver);
1146  gs_tty_driver = NULL;
1147  return status;
1148 }
1149 
1150 static int gs_closed(struct gs_port *port)
1151 {
1152  int cond;
1153 
1154  spin_lock_irq(&port->port_lock);
1155  cond = (port->port.count == 0) && !port->openclose;
1156  spin_unlock_irq(&port->port_lock);
1157  return cond;
1158 }
1159 
1173 {
1174  unsigned i;
1175  struct gs_port *port;
1176 
1177  if (!gs_tty_driver)
1178  return;
1179 
1180  /* start sysfs and /dev/ttyGS* node removal */
1181  for (i = 0; i < n_ports; i++)
1182  tty_unregister_device(gs_tty_driver, i);
1183 
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);
1190 
1191  tasklet_kill(&port->push);
1192 
1193  /* wait for old opens to finish */
1194  wait_event(port->port.close_wait, gs_closed(port));
1195 
1196  WARN_ON(port->port_usb != NULL);
1197 
1198  kfree(port);
1199  }
1200  n_ports = 0;
1201 
1202  tty_unregister_driver(gs_tty_driver);
1203  put_tty_driver(gs_tty_driver);
1204  gs_tty_driver = NULL;
1205 
1206  pr_debug("%s: cleaned up ttyGS* support\n", __func__);
1207 }
1208 
1230 int gserial_connect(struct gserial *gser, u8 port_num)
1231 {
1232  struct gs_port *port;
1233  unsigned long flags;
1234  int status;
1235 
1236  if (!gs_tty_driver || port_num >= n_ports)
1237  return -ENXIO;
1238 
1239  /* we "know" gserial_cleanup() hasn't been called */
1240  port = ports[port_num].port;
1241 
1242  /* activate the endpoints */
1243  status = usb_ep_enable(gser->in);
1244  if (status < 0)
1245  return status;
1246  gser->in->driver_data = port;
1247 
1248  status = usb_ep_enable(gser->out);
1249  if (status < 0)
1250  goto fail_out;
1251  gser->out->driver_data = port;
1252 
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;
1257 
1258  /* REVISIT unclear how best to handle this state...
1259  * we don't really couple it with the Linux TTY.
1260  */
1261  gser->port_line_coding = port->port_line_coding;
1262 
1263  /* REVISIT if waiting on "carrier detect", signal. */
1264 
1265  /* if it's already open, start I/O ... and notify the serial
1266  * protocol about open/close status (connect/disconnect).
1267  */
1268  if (port->port.count) {
1269  pr_debug("gserial_connect: start ttyGS%d\n", port->port_num);
1270  gs_start_io(port);
1271  if (gser->connect)
1272  gser->connect(gser);
1273  } else {
1274  if (gser->disconnect)
1275  gser->disconnect(gser);
1276  }
1277 
1278  spin_unlock_irqrestore(&port->port_lock, flags);
1279 
1280  return status;
1281 
1282 fail_out:
1283  usb_ep_disable(gser->in);
1284  gser->in->driver_data = NULL;
1285  return status;
1286 }
1287 
1299 void gserial_disconnect(struct gserial *gser)
1300 {
1301  struct gs_port *port = gser->ioport;
1302  unsigned long flags;
1303 
1304  if (!port)
1305  return;
1306 
1307  /* tell the TTY glue not to do I/O here any more */
1308  spin_lock_irqsave(&port->port_lock, flags);
1309 
1310  /* REVISIT as above: how best to track this? */
1311  port->port_line_coding = gser->port_line_coding;
1312 
1313  port->port_usb = NULL;
1314  gser->ioport = NULL;
1315  if (port->port.count > 0 || port->openclose) {
1317  if (port->port.tty)
1318  tty_hangup(port->port.tty);
1319  }
1320  spin_unlock_irqrestore(&port->port_lock, flags);
1321 
1322  /* disable endpoints, aborting down any active I/O */
1323  usb_ep_disable(gser->out);
1324  gser->out->driver_data = NULL;
1325 
1326  usb_ep_disable(gser->in);
1327  gser->in->driver_data = NULL;
1328 
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);
1336 
1337  port->read_allocated = port->read_started =
1338  port->write_allocated = port->write_started = 0;
1339 
1340  spin_unlock_irqrestore(&port->port_lock, flags);
1341 }