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