1// SPDX-License-Identifier: GPL-2.0
2/*
3 * xhci-dbgtty.c - tty glue for xHCI debug capability
4 *
5 * Copyright (C) 2017 Intel Corporation
6 *
7 * Author: Lu Baolu <baolu.lu@linux.intel.com>
8 */
9
10#include <linux/slab.h>
11#include <linux/tty.h>
12#include <linux/tty_flip.h>
13#include <linux/idr.h>
14
15#include "xhci.h"
16#include "xhci-dbgcap.h"
17
18static struct tty_driver *dbc_tty_driver;
19static struct idr dbc_tty_minors;
20static DEFINE_MUTEX(dbc_tty_minors_lock);
21
22static inline struct dbc_port *dbc_to_port(struct xhci_dbc *dbc)
23{
24	return dbc->priv;
25}
26
27static unsigned int
28dbc_send_packet(struct dbc_port *port, char *packet, unsigned int size)
29{
30	unsigned int		len;
31
32	len = kfifo_len(&port->write_fifo);
33	if (len < size)
34		size = len;
35	if (size != 0)
36		size = kfifo_out(&port->write_fifo, packet, size);
37	return size;
38}
39
40static int dbc_start_tx(struct dbc_port *port)
41	__releases(&port->port_lock)
42	__acquires(&port->port_lock)
43{
44	int			len;
45	struct dbc_request	*req;
46	int			status = 0;
47	bool			do_tty_wake = false;
48	struct list_head	*pool = &port->write_pool;
49
50	while (!list_empty(pool)) {
51		req = list_entry(pool->next, struct dbc_request, list_pool);
52		len = dbc_send_packet(port, req->buf, DBC_MAX_PACKET);
53		if (len == 0)
54			break;
55		do_tty_wake = true;
56
57		req->length = len;
58		list_del(&req->list_pool);
59
60		spin_unlock(&port->port_lock);
61		status = dbc_ep_queue(req);
62		spin_lock(&port->port_lock);
63
64		if (status) {
65			list_add(&req->list_pool, pool);
66			break;
67		}
68	}
69
70	if (do_tty_wake && port->port.tty)
71		tty_wakeup(port->port.tty);
72
73	return status;
74}
75
76static void dbc_start_rx(struct dbc_port *port)
77	__releases(&port->port_lock)
78	__acquires(&port->port_lock)
79{
80	struct dbc_request	*req;
81	int			status;
82	struct list_head	*pool = &port->read_pool;
83
84	while (!list_empty(pool)) {
85		if (!port->port.tty)
86			break;
87
88		req = list_entry(pool->next, struct dbc_request, list_pool);
89		list_del(&req->list_pool);
90		req->length = DBC_MAX_PACKET;
91
92		spin_unlock(&port->port_lock);
93		status = dbc_ep_queue(req);
94		spin_lock(&port->port_lock);
95
96		if (status) {
97			list_add(&req->list_pool, pool);
98			break;
99		}
100	}
101}
102
103static void
104dbc_read_complete(struct xhci_dbc *dbc, struct dbc_request *req)
105{
106	unsigned long		flags;
107	struct dbc_port		*port = dbc_to_port(dbc);
108
109	spin_lock_irqsave(&port->port_lock, flags);
110	list_add_tail(&req->list_pool, &port->read_queue);
111	tasklet_schedule(&port->push);
112	spin_unlock_irqrestore(&port->port_lock, flags);
113}
114
115static void dbc_write_complete(struct xhci_dbc *dbc, struct dbc_request *req)
116{
117	unsigned long		flags;
118	struct dbc_port		*port = dbc_to_port(dbc);
119
120	spin_lock_irqsave(&port->port_lock, flags);
121	list_add(&req->list_pool, &port->write_pool);
122	switch (req->status) {
123	case 0:
124		dbc_start_tx(port);
125		break;
126	case -ESHUTDOWN:
127		break;
128	default:
129		dev_warn(dbc->dev, "unexpected write complete status %d\n",
130			  req->status);
131		break;
132	}
133	spin_unlock_irqrestore(&port->port_lock, flags);
134}
135
136static void xhci_dbc_free_req(struct dbc_request *req)
137{
138	kfree(req->buf);
139	dbc_free_request(req);
140}
141
142static int
143xhci_dbc_alloc_requests(struct xhci_dbc *dbc, unsigned int direction,
144			struct list_head *head,
145			void (*fn)(struct xhci_dbc *, struct dbc_request *))
146{
147	int			i;
148	struct dbc_request	*req;
149
150	for (i = 0; i < DBC_QUEUE_SIZE; i++) {
151		req = dbc_alloc_request(dbc, direction, GFP_KERNEL);
152		if (!req)
153			break;
154
155		req->length = DBC_MAX_PACKET;
156		req->buf = kmalloc(req->length, GFP_KERNEL);
157		if (!req->buf) {
158			dbc_free_request(req);
159			break;
160		}
161
162		req->complete = fn;
163		list_add_tail(&req->list_pool, head);
164	}
165
166	return list_empty(head) ? -ENOMEM : 0;
167}
168
169static void
170xhci_dbc_free_requests(struct list_head *head)
171{
172	struct dbc_request	*req;
173
174	while (!list_empty(head)) {
175		req = list_entry(head->next, struct dbc_request, list_pool);
176		list_del(&req->list_pool);
177		xhci_dbc_free_req(req);
178	}
179}
180
181static int dbc_tty_install(struct tty_driver *driver, struct tty_struct *tty)
182{
183	struct dbc_port		*port;
184
185	mutex_lock(&dbc_tty_minors_lock);
186	port = idr_find(&dbc_tty_minors, tty->index);
187	mutex_unlock(&dbc_tty_minors_lock);
188
189	if (!port)
190		return -ENXIO;
191
192	tty->driver_data = port;
193
194	return tty_port_install(&port->port, driver, tty);
195}
196
197static int dbc_tty_open(struct tty_struct *tty, struct file *file)
198{
199	struct dbc_port		*port = tty->driver_data;
200
201	return tty_port_open(&port->port, tty, file);
202}
203
204static void dbc_tty_close(struct tty_struct *tty, struct file *file)
205{
206	struct dbc_port		*port = tty->driver_data;
207
208	tty_port_close(&port->port, tty, file);
209}
210
211static ssize_t dbc_tty_write(struct tty_struct *tty, const u8 *buf,
212			     size_t count)
213{
214	struct dbc_port		*port = tty->driver_data;
215	unsigned long		flags;
216
217	spin_lock_irqsave(&port->port_lock, flags);
218	if (count)
219		count = kfifo_in(&port->write_fifo, buf, count);
220	dbc_start_tx(port);
221	spin_unlock_irqrestore(&port->port_lock, flags);
222
223	return count;
224}
225
226static int dbc_tty_put_char(struct tty_struct *tty, u8 ch)
227{
228	struct dbc_port		*port = tty->driver_data;
229	unsigned long		flags;
230	int			status;
231
232	spin_lock_irqsave(&port->port_lock, flags);
233	status = kfifo_put(&port->write_fifo, ch);
234	spin_unlock_irqrestore(&port->port_lock, flags);
235
236	return status;
237}
238
239static void dbc_tty_flush_chars(struct tty_struct *tty)
240{
241	struct dbc_port		*port = tty->driver_data;
242	unsigned long		flags;
243
244	spin_lock_irqsave(&port->port_lock, flags);
245	dbc_start_tx(port);
246	spin_unlock_irqrestore(&port->port_lock, flags);
247}
248
249static unsigned int dbc_tty_write_room(struct tty_struct *tty)
250{
251	struct dbc_port		*port = tty->driver_data;
252	unsigned long		flags;
253	unsigned int		room;
254
255	spin_lock_irqsave(&port->port_lock, flags);
256	room = kfifo_avail(&port->write_fifo);
257	spin_unlock_irqrestore(&port->port_lock, flags);
258
259	return room;
260}
261
262static unsigned int dbc_tty_chars_in_buffer(struct tty_struct *tty)
263{
264	struct dbc_port		*port = tty->driver_data;
265	unsigned long		flags;
266	unsigned int		chars;
267
268	spin_lock_irqsave(&port->port_lock, flags);
269	chars = kfifo_len(&port->write_fifo);
270	spin_unlock_irqrestore(&port->port_lock, flags);
271
272	return chars;
273}
274
275static void dbc_tty_unthrottle(struct tty_struct *tty)
276{
277	struct dbc_port		*port = tty->driver_data;
278	unsigned long		flags;
279
280	spin_lock_irqsave(&port->port_lock, flags);
281	tasklet_schedule(&port->push);
282	spin_unlock_irqrestore(&port->port_lock, flags);
283}
284
285static const struct tty_operations dbc_tty_ops = {
286	.install		= dbc_tty_install,
287	.open			= dbc_tty_open,
288	.close			= dbc_tty_close,
289	.write			= dbc_tty_write,
290	.put_char		= dbc_tty_put_char,
291	.flush_chars		= dbc_tty_flush_chars,
292	.write_room		= dbc_tty_write_room,
293	.chars_in_buffer	= dbc_tty_chars_in_buffer,
294	.unthrottle		= dbc_tty_unthrottle,
295};
296
297static void dbc_rx_push(struct tasklet_struct *t)
298{
299	struct dbc_request	*req;
300	struct tty_struct	*tty;
301	unsigned long		flags;
302	bool			do_push = false;
303	bool			disconnect = false;
304	struct dbc_port		*port = from_tasklet(port, t, push);
305	struct list_head	*queue = &port->read_queue;
306
307	spin_lock_irqsave(&port->port_lock, flags);
308	tty = port->port.tty;
309	while (!list_empty(queue)) {
310		req = list_first_entry(queue, struct dbc_request, list_pool);
311
312		if (tty && tty_throttled(tty))
313			break;
314
315		switch (req->status) {
316		case 0:
317			break;
318		case -ESHUTDOWN:
319			disconnect = true;
320			break;
321		default:
322			pr_warn("ttyDBC0: unexpected RX status %d\n",
323				req->status);
324			break;
325		}
326
327		if (req->actual) {
328			char		*packet = req->buf;
329			unsigned int	n, size = req->actual;
330			int		count;
331
332			n = port->n_read;
333			if (n) {
334				packet += n;
335				size -= n;
336			}
337
338			count = tty_insert_flip_string(&port->port, packet,
339						       size);
340			if (count)
341				do_push = true;
342			if (count != size) {
343				port->n_read += count;
344				break;
345			}
346			port->n_read = 0;
347		}
348
349		list_move(&req->list_pool, &port->read_pool);
350	}
351
352	if (do_push)
353		tty_flip_buffer_push(&port->port);
354
355	if (!list_empty(queue) && tty) {
356		if (!tty_throttled(tty)) {
357			if (do_push)
358				tasklet_schedule(&port->push);
359			else
360				pr_warn("ttyDBC0: RX not scheduled?\n");
361		}
362	}
363
364	if (!disconnect)
365		dbc_start_rx(port);
366
367	spin_unlock_irqrestore(&port->port_lock, flags);
368}
369
370static int dbc_port_activate(struct tty_port *_port, struct tty_struct *tty)
371{
372	unsigned long	flags;
373	struct dbc_port	*port = container_of(_port, struct dbc_port, port);
374
375	spin_lock_irqsave(&port->port_lock, flags);
376	dbc_start_rx(port);
377	spin_unlock_irqrestore(&port->port_lock, flags);
378
379	return 0;
380}
381
382static const struct tty_port_operations dbc_port_ops = {
383	.activate =	dbc_port_activate,
384};
385
386static void
387xhci_dbc_tty_init_port(struct xhci_dbc *dbc, struct dbc_port *port)
388{
389	tty_port_init(&port->port);
390	spin_lock_init(&port->port_lock);
391	tasklet_setup(&port->push, dbc_rx_push);
392	INIT_LIST_HEAD(&port->read_pool);
393	INIT_LIST_HEAD(&port->read_queue);
394	INIT_LIST_HEAD(&port->write_pool);
395
396	port->port.ops =	&dbc_port_ops;
397	port->n_read =		0;
398}
399
400static void
401xhci_dbc_tty_exit_port(struct dbc_port *port)
402{
403	tasklet_kill(&port->push);
404	tty_port_destroy(&port->port);
405}
406
407static int xhci_dbc_tty_register_device(struct xhci_dbc *dbc)
408{
409	int			ret;
410	struct device		*tty_dev;
411	struct dbc_port		*port = dbc_to_port(dbc);
412
413	if (port->registered)
414		return -EBUSY;
415
416	xhci_dbc_tty_init_port(dbc, port);
417
418	mutex_lock(&dbc_tty_minors_lock);
419	port->minor = idr_alloc(&dbc_tty_minors, port, 0, 64, GFP_KERNEL);
420	mutex_unlock(&dbc_tty_minors_lock);
421
422	if (port->minor < 0) {
423		ret = port->minor;
424		goto err_idr;
425	}
426
427	ret = kfifo_alloc(&port->write_fifo, DBC_WRITE_BUF_SIZE, GFP_KERNEL);
428	if (ret)
429		goto err_exit_port;
430
431	ret = xhci_dbc_alloc_requests(dbc, BULK_IN, &port->read_pool,
432				      dbc_read_complete);
433	if (ret)
434		goto err_free_fifo;
435
436	ret = xhci_dbc_alloc_requests(dbc, BULK_OUT, &port->write_pool,
437				      dbc_write_complete);
438	if (ret)
439		goto err_free_requests;
440
441	tty_dev = tty_port_register_device(&port->port,
442					   dbc_tty_driver, port->minor, NULL);
443	if (IS_ERR(tty_dev)) {
444		ret = PTR_ERR(tty_dev);
445		goto err_free_requests;
446	}
447
448	port->registered = true;
449
450	return 0;
451
452err_free_requests:
453	xhci_dbc_free_requests(&port->read_pool);
454	xhci_dbc_free_requests(&port->write_pool);
455err_free_fifo:
456	kfifo_free(&port->write_fifo);
457err_exit_port:
458	idr_remove(&dbc_tty_minors, port->minor);
459err_idr:
460	xhci_dbc_tty_exit_port(port);
461
462	dev_err(dbc->dev, "can't register tty port, err %d\n", ret);
463
464	return ret;
465}
466
467static void xhci_dbc_tty_unregister_device(struct xhci_dbc *dbc)
468{
469	struct dbc_port		*port = dbc_to_port(dbc);
470
471	if (!port->registered)
472		return;
473	tty_unregister_device(dbc_tty_driver, port->minor);
474	xhci_dbc_tty_exit_port(port);
475	port->registered = false;
476
477	mutex_lock(&dbc_tty_minors_lock);
478	idr_remove(&dbc_tty_minors, port->minor);
479	mutex_unlock(&dbc_tty_minors_lock);
480
481	kfifo_free(&port->write_fifo);
482	xhci_dbc_free_requests(&port->read_pool);
483	xhci_dbc_free_requests(&port->read_queue);
484	xhci_dbc_free_requests(&port->write_pool);
485}
486
487static const struct dbc_driver dbc_driver = {
488	.configure		= xhci_dbc_tty_register_device,
489	.disconnect		= xhci_dbc_tty_unregister_device,
490};
491
492int xhci_dbc_tty_probe(struct device *dev, void __iomem *base, struct xhci_hcd *xhci)
493{
494	struct xhci_dbc		*dbc;
495	struct dbc_port		*port;
496	int			status;
497
498	if (!dbc_tty_driver)
499		return -ENODEV;
500
501	port = kzalloc(sizeof(*port), GFP_KERNEL);
502	if (!port)
503		return -ENOMEM;
504
505	dbc = xhci_alloc_dbc(dev, base, &dbc_driver);
506
507	if (!dbc) {
508		status = -ENOMEM;
509		goto out2;
510	}
511
512	dbc->priv = port;
513
514	/* get rid of xhci once this is a real driver binding to a device */
515	xhci->dbc = dbc;
516
517	return 0;
518out2:
519	kfree(port);
520
521	return status;
522}
523
524/*
525 * undo what probe did, assume dbc is stopped already.
526 * we also assume tty_unregister_device() is called before this
527 */
528void xhci_dbc_tty_remove(struct xhci_dbc *dbc)
529{
530	struct dbc_port         *port = dbc_to_port(dbc);
531
532	xhci_dbc_remove(dbc);
533	kfree(port);
534}
535
536int dbc_tty_init(void)
537{
538	int		ret;
539
540	idr_init(&dbc_tty_minors);
541
542	dbc_tty_driver = tty_alloc_driver(64, TTY_DRIVER_REAL_RAW |
543					  TTY_DRIVER_DYNAMIC_DEV);
544	if (IS_ERR(dbc_tty_driver)) {
545		idr_destroy(&dbc_tty_minors);
546		return PTR_ERR(dbc_tty_driver);
547	}
548
549	dbc_tty_driver->driver_name = "dbc_serial";
550	dbc_tty_driver->name = "ttyDBC";
551
552	dbc_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
553	dbc_tty_driver->subtype = SERIAL_TYPE_NORMAL;
554	dbc_tty_driver->init_termios = tty_std_termios;
555	dbc_tty_driver->init_termios.c_cflag =
556			B9600 | CS8 | CREAD | HUPCL | CLOCAL;
557	dbc_tty_driver->init_termios.c_ispeed = 9600;
558	dbc_tty_driver->init_termios.c_ospeed = 9600;
559
560	tty_set_operations(dbc_tty_driver, &dbc_tty_ops);
561
562	ret = tty_register_driver(dbc_tty_driver);
563	if (ret) {
564		pr_err("Can't register dbc tty driver\n");
565		tty_driver_kref_put(dbc_tty_driver);
566		idr_destroy(&dbc_tty_minors);
567	}
568
569	return ret;
570}
571
572void dbc_tty_exit(void)
573{
574	if (dbc_tty_driver) {
575		tty_unregister_driver(dbc_tty_driver);
576		tty_driver_kref_put(dbc_tty_driver);
577		dbc_tty_driver = NULL;
578	}
579
580	idr_destroy(&dbc_tty_minors);
581}
582