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