xref: /openbmc/linux/net/nfc/nci/uart.c (revision c0e297dc) 
1 /*
2  * Copyright (C) 2015, Marvell International Ltd.
3  *
4  * This software file (the "File") is distributed by Marvell International
5  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
6  * (the "License").  You may use, redistribute and/or modify this File in
7  * accordance with the terms and conditions of the License, a copy of which
8  * is available on the worldwide web at
9  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
10  *
11  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
12  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
13  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
14  * this warranty disclaimer.
15  */
16 
17 /* Inspired (hugely) by HCI LDISC implementation in Bluetooth.
18  *
19  *  Copyright (C) 2000-2001  Qualcomm Incorporated
20  *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
21  *  Copyright (C) 2004-2005  Marcel Holtmann <marcel@holtmann.org>
22  */
23 
24 #include <linux/module.h>
25 
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/types.h>
29 #include <linux/fcntl.h>
30 #include <linux/interrupt.h>
31 #include <linux/ptrace.h>
32 #include <linux/poll.h>
33 
34 #include <linux/slab.h>
35 #include <linux/tty.h>
36 #include <linux/errno.h>
37 #include <linux/string.h>
38 #include <linux/signal.h>
39 #include <linux/ioctl.h>
40 #include <linux/skbuff.h>
41 
42 #include <net/nfc/nci.h>
43 #include <net/nfc/nci_core.h>
44 
45 /* TX states  */
46 #define NCI_UART_SENDING	1
47 #define NCI_UART_TX_WAKEUP	2
48 
49 static struct nci_uart *nci_uart_drivers[NCI_UART_DRIVER_MAX];
50 
51 static inline struct sk_buff *nci_uart_dequeue(struct nci_uart *nu)
52 {
53 	struct sk_buff *skb = nu->tx_skb;
54 
55 	if (!skb)
56 		skb = skb_dequeue(&nu->tx_q);
57 	else
58 		nu->tx_skb = NULL;
59 
60 	return skb;
61 }
62 
63 static inline int nci_uart_queue_empty(struct nci_uart *nu)
64 {
65 	if (nu->tx_skb)
66 		return 0;
67 
68 	return skb_queue_empty(&nu->tx_q);
69 }
70 
71 static int nci_uart_tx_wakeup(struct nci_uart *nu)
72 {
73 	if (test_and_set_bit(NCI_UART_SENDING, &nu->tx_state)) {
74 		set_bit(NCI_UART_TX_WAKEUP, &nu->tx_state);
75 		return 0;
76 	}
77 
78 	schedule_work(&nu->write_work);
79 
80 	return 0;
81 }
82 
83 static void nci_uart_write_work(struct work_struct *work)
84 {
85 	struct nci_uart *nu = container_of(work, struct nci_uart, write_work);
86 	struct tty_struct *tty = nu->tty;
87 	struct sk_buff *skb;
88 
89 restart:
90 	clear_bit(NCI_UART_TX_WAKEUP, &nu->tx_state);
91 
92 	if (nu->ops.tx_start)
93 		nu->ops.tx_start(nu);
94 
95 	while ((skb = nci_uart_dequeue(nu))) {
96 		int len;
97 
98 		set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
99 		len = tty->ops->write(tty, skb->data, skb->len);
100 		skb_pull(skb, len);
101 		if (skb->len) {
102 			nu->tx_skb = skb;
103 			break;
104 		}
105 		kfree_skb(skb);
106 	}
107 
108 	if (test_bit(NCI_UART_TX_WAKEUP, &nu->tx_state))
109 		goto restart;
110 
111 	if (nu->ops.tx_done && nci_uart_queue_empty(nu))
112 		nu->ops.tx_done(nu);
113 
114 	clear_bit(NCI_UART_SENDING, &nu->tx_state);
115 }
116 
117 static int nci_uart_set_driver(struct tty_struct *tty, unsigned int driver)
118 {
119 	struct nci_uart *nu = NULL;
120 	int ret;
121 
122 	if (driver >= NCI_UART_DRIVER_MAX)
123 		return -EINVAL;
124 
125 	if (!nci_uart_drivers[driver])
126 		return -ENOENT;
127 
128 	nu = kzalloc(sizeof(*nu), GFP_KERNEL);
129 	if (!nu)
130 		return -ENOMEM;
131 
132 	memcpy(nu, nci_uart_drivers[driver], sizeof(struct nci_uart));
133 	nu->tty = tty;
134 	tty->disc_data = nu;
135 	skb_queue_head_init(&nu->tx_q);
136 	INIT_WORK(&nu->write_work, nci_uart_write_work);
137 	spin_lock_init(&nu->rx_lock);
138 
139 	ret = nu->ops.open(nu);
140 	if (ret) {
141 		tty->disc_data = NULL;
142 		kfree(nu);
143 	} else if (!try_module_get(nu->owner)) {
144 		nu->ops.close(nu);
145 		tty->disc_data = NULL;
146 		kfree(nu);
147 		return -ENOENT;
148 	}
149 	return ret;
150 }
151 
152 /* ------ LDISC part ------ */
153 
154 /* nci_uart_tty_open
155  *
156  *     Called when line discipline changed to NCI_UART.
157  *
158  * Arguments:
159  *     tty    pointer to tty info structure
160  * Return Value:
161  *     0 if success, otherwise error code
162  */
163 static int nci_uart_tty_open(struct tty_struct *tty)
164 {
165 	/* Error if the tty has no write op instead of leaving an exploitable
166 	 * hole
167 	 */
168 	if (!tty->ops->write)
169 		return -EOPNOTSUPP;
170 
171 	tty->disc_data = NULL;
172 	tty->receive_room = 65536;
173 
174 	/* Flush any pending characters in the driver and line discipline. */
175 
176 	/* FIXME: why is this needed. Note don't use ldisc_ref here as the
177 	 * open path is before the ldisc is referencable.
178 	 */
179 
180 	if (tty->ldisc->ops->flush_buffer)
181 		tty->ldisc->ops->flush_buffer(tty);
182 	tty_driver_flush_buffer(tty);
183 
184 	return 0;
185 }
186 
187 /* nci_uart_tty_close()
188  *
189  *    Called when the line discipline is changed to something
190  *    else, the tty is closed, or the tty detects a hangup.
191  */
192 static void nci_uart_tty_close(struct tty_struct *tty)
193 {
194 	struct nci_uart *nu = (void *)tty->disc_data;
195 
196 	/* Detach from the tty */
197 	tty->disc_data = NULL;
198 
199 	if (!nu)
200 		return;
201 
202 	if (nu->tx_skb)
203 		kfree_skb(nu->tx_skb);
204 	if (nu->rx_skb)
205 		kfree_skb(nu->rx_skb);
206 
207 	skb_queue_purge(&nu->tx_q);
208 
209 	nu->ops.close(nu);
210 	nu->tty = NULL;
211 	module_put(nu->owner);
212 
213 	cancel_work_sync(&nu->write_work);
214 
215 	kfree(nu);
216 }
217 
218 /* nci_uart_tty_wakeup()
219  *
220  *    Callback for transmit wakeup. Called when low level
221  *    device driver can accept more send data.
222  *
223  * Arguments:        tty    pointer to associated tty instance data
224  * Return Value:    None
225  */
226 static void nci_uart_tty_wakeup(struct tty_struct *tty)
227 {
228 	struct nci_uart *nu = (void *)tty->disc_data;
229 
230 	if (!nu)
231 		return;
232 
233 	clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
234 
235 	if (tty != nu->tty)
236 		return;
237 
238 	nci_uart_tx_wakeup(nu);
239 }
240 
241 /* nci_uart_tty_receive()
242  *
243  *     Called by tty low level driver when receive data is
244  *     available.
245  *
246  * Arguments:  tty          pointer to tty isntance data
247  *             data         pointer to received data
248  *             flags        pointer to flags for data
249  *             count        count of received data in bytes
250  *
251  * Return Value:    None
252  */
253 static void nci_uart_tty_receive(struct tty_struct *tty, const u8 *data,
254 				 char *flags, int count)
255 {
256 	struct nci_uart *nu = (void *)tty->disc_data;
257 
258 	if (!nu || tty != nu->tty)
259 		return;
260 
261 	spin_lock(&nu->rx_lock);
262 	nu->ops.recv_buf(nu, (void *)data, flags, count);
263 	spin_unlock(&nu->rx_lock);
264 
265 	tty_unthrottle(tty);
266 }
267 
268 /* nci_uart_tty_ioctl()
269  *
270  *    Process IOCTL system call for the tty device.
271  *
272  * Arguments:
273  *
274  *    tty        pointer to tty instance data
275  *    file       pointer to open file object for device
276  *    cmd        IOCTL command code
277  *    arg        argument for IOCTL call (cmd dependent)
278  *
279  * Return Value:    Command dependent
280  */
281 static int nci_uart_tty_ioctl(struct tty_struct *tty, struct file *file,
282 			      unsigned int cmd, unsigned long arg)
283 {
284 	struct nci_uart *nu = (void *)tty->disc_data;
285 	int err = 0;
286 
287 	switch (cmd) {
288 	case NCIUARTSETDRIVER:
289 		if (!nu)
290 			return nci_uart_set_driver(tty, (unsigned int)arg);
291 		else
292 			return -EBUSY;
293 		break;
294 	default:
295 		err = n_tty_ioctl_helper(tty, file, cmd, arg);
296 		break;
297 	}
298 
299 	return err;
300 }
301 
302 /* We don't provide read/write/poll interface for user space. */
303 static ssize_t nci_uart_tty_read(struct tty_struct *tty, struct file *file,
304 				 unsigned char __user *buf, size_t nr)
305 {
306 	return 0;
307 }
308 
309 static ssize_t nci_uart_tty_write(struct tty_struct *tty, struct file *file,
310 				  const unsigned char *data, size_t count)
311 {
312 	return 0;
313 }
314 
315 static unsigned int nci_uart_tty_poll(struct tty_struct *tty,
316 				      struct file *filp, poll_table *wait)
317 {
318 	return 0;
319 }
320 
321 static int nci_uart_send(struct nci_uart *nu, struct sk_buff *skb)
322 {
323 	/* Queue TX packet */
324 	skb_queue_tail(&nu->tx_q, skb);
325 
326 	/* Try to start TX (if possible) */
327 	nci_uart_tx_wakeup(nu);
328 
329 	return 0;
330 }
331 
332 /* -- Default recv_buf handler --
333  *
334  * This handler supposes that NCI frames are sent over UART link without any
335  * framing. It reads NCI header, retrieve the packet size and once all packet
336  * bytes are received it passes it to nci_uart driver for processing.
337  */
338 static int nci_uart_default_recv_buf(struct nci_uart *nu, const u8 *data,
339 				     char *flags, int count)
340 {
341 	int chunk_len;
342 
343 	if (!nu->ndev) {
344 		nfc_err(nu->tty->dev,
345 			"receive data from tty but no NCI dev is attached yet, drop buffer\n");
346 		return 0;
347 	}
348 
349 	/* Decode all incoming data in packets
350 	 * and enqueue then for processing.
351 	 */
352 	while (count > 0) {
353 		/* If this is the first data of a packet, allocate a buffer */
354 		if (!nu->rx_skb) {
355 			nu->rx_packet_len = -1;
356 			nu->rx_skb = nci_skb_alloc(nu->ndev,
357 						   NCI_MAX_PACKET_SIZE,
358 						   GFP_KERNEL);
359 			if (!nu->rx_skb)
360 				return -ENOMEM;
361 		}
362 
363 		/* Eat byte after byte till full packet header is received */
364 		if (nu->rx_skb->len < NCI_CTRL_HDR_SIZE) {
365 			*skb_put(nu->rx_skb, 1) = *data++;
366 			--count;
367 			continue;
368 		}
369 
370 		/* Header was received but packet len was not read */
371 		if (nu->rx_packet_len < 0)
372 			nu->rx_packet_len = NCI_CTRL_HDR_SIZE +
373 				nci_plen(nu->rx_skb->data);
374 
375 		/* Compute how many bytes are missing and how many bytes can
376 		 * be consumed.
377 		 */
378 		chunk_len = nu->rx_packet_len - nu->rx_skb->len;
379 		if (count < chunk_len)
380 			chunk_len = count;
381 		memcpy(skb_put(nu->rx_skb, chunk_len), data, chunk_len);
382 		data += chunk_len;
383 		count -= chunk_len;
384 
385 		/* Chcek if packet is fully received */
386 		if (nu->rx_packet_len == nu->rx_skb->len) {
387 			/* Pass RX packet to driver */
388 			if (nu->ops.recv(nu, nu->rx_skb) != 0)
389 				nfc_err(nu->tty->dev, "corrupted RX packet\n");
390 			/* Next packet will be a new one */
391 			nu->rx_skb = NULL;
392 		}
393 	}
394 
395 	return 0;
396 }
397 
398 /* -- Default recv handler -- */
399 static int nci_uart_default_recv(struct nci_uart *nu, struct sk_buff *skb)
400 {
401 	return nci_recv_frame(nu->ndev, skb);
402 }
403 
404 int nci_uart_register(struct nci_uart *nu)
405 {
406 	if (!nu || !nu->ops.open ||
407 	    !nu->ops.recv || !nu->ops.close)
408 		return -EINVAL;
409 
410 	/* Set the send callback */
411 	nu->ops.send = nci_uart_send;
412 
413 	/* Install default handlers if not overridden */
414 	if (!nu->ops.recv_buf)
415 		nu->ops.recv_buf = nci_uart_default_recv_buf;
416 	if (!nu->ops.recv)
417 		nu->ops.recv = nci_uart_default_recv;
418 
419 	/* Add this driver in the driver list */
420 	if (nci_uart_drivers[nu->driver]) {
421 		pr_err("driver %d is already registered\n", nu->driver);
422 		return -EBUSY;
423 	}
424 	nci_uart_drivers[nu->driver] = nu;
425 
426 	pr_info("NCI uart driver '%s [%d]' registered\n", nu->name, nu->driver);
427 
428 	return 0;
429 }
430 EXPORT_SYMBOL_GPL(nci_uart_register);
431 
432 void nci_uart_unregister(struct nci_uart *nu)
433 {
434 	pr_info("NCI uart driver '%s [%d]' unregistered\n", nu->name,
435 		nu->driver);
436 
437 	/* Remove this driver from the driver list */
438 	nci_uart_drivers[nu->driver] = NULL;
439 }
440 EXPORT_SYMBOL_GPL(nci_uart_unregister);
441 
442 void nci_uart_set_config(struct nci_uart *nu, int baudrate, int flow_ctrl)
443 {
444 	struct ktermios new_termios;
445 
446 	if (!nu->tty)
447 		return;
448 
449 	down_read(&nu->tty->termios_rwsem);
450 	new_termios = nu->tty->termios;
451 	up_read(&nu->tty->termios_rwsem);
452 	tty_termios_encode_baud_rate(&new_termios, baudrate, baudrate);
453 
454 	if (flow_ctrl)
455 		new_termios.c_cflag |= CRTSCTS;
456 	else
457 		new_termios.c_cflag &= ~CRTSCTS;
458 
459 	tty_set_termios(nu->tty, &new_termios);
460 }
461 EXPORT_SYMBOL_GPL(nci_uart_set_config);
462 
463 static struct tty_ldisc_ops nci_uart_ldisc = {
464 	.magic		= TTY_LDISC_MAGIC,
465 	.owner		= THIS_MODULE,
466 	.name		= "n_nci",
467 	.open		= nci_uart_tty_open,
468 	.close		= nci_uart_tty_close,
469 	.read		= nci_uart_tty_read,
470 	.write		= nci_uart_tty_write,
471 	.poll		= nci_uart_tty_poll,
472 	.receive_buf	= nci_uart_tty_receive,
473 	.write_wakeup	= nci_uart_tty_wakeup,
474 	.ioctl		= nci_uart_tty_ioctl,
475 };
476 
477 static int __init nci_uart_init(void)
478 {
479 	memset(nci_uart_drivers, 0, sizeof(nci_uart_drivers));
480 	return tty_register_ldisc(N_NCI, &nci_uart_ldisc);
481 }
482 
483 static void __exit nci_uart_exit(void)
484 {
485 	tty_unregister_ldisc(N_NCI);
486 }
487 
488 module_init(nci_uart_init);
489 module_exit(nci_uart_exit);
490 
491 MODULE_AUTHOR("Marvell International Ltd.");
492 MODULE_DESCRIPTION("NFC NCI UART driver");
493 MODULE_LICENSE("GPL");
494 MODULE_ALIAS_LDISC(N_NCI);
495