[mirror_ubuntu-jammy-kernel.git] / net / nfc / nci / uart.c

/*
 * Copyright (C) 2015, Marvell International Ltd.
 *
 * This software file (the "File") is distributed by Marvell International
 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
 * (the "License").  You may use, redistribute and/or modify this File in
 * accordance with the terms and conditions of the License, a copy of which
 * is available on the worldwide web at
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 *
 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
 * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
 * this warranty disclaimer.
 */

/* Inspired (hugely) by HCI LDISC implementation in Bluetooth.
 *
 *  Copyright (C) 2000-2001  Qualcomm Incorporated
 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
 *  Copyright (C) 2004-2005  Marcel Holtmann <marcel@holtmann.org>
 */

#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ptrace.h>
#include <linux/poll.h>

#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/signal.h>
#include <linux/ioctl.h>
#include <linux/skbuff.h>

#include <net/nfc/nci.h>
#include <net/nfc/nci_core.h>

/* TX states  */
#define NCI_UART_SENDING	1
#define NCI_UART_TX_WAKEUP	2

static struct nci_uart *nci_uart_drivers[NCI_UART_DRIVER_MAX];

static inline struct sk_buff *nci_uart_dequeue(struct nci_uart *nu)
{
	struct sk_buff *skb = nu->tx_skb;

	if (!skb)
		skb = skb_dequeue(&nu->tx_q);
	else
		nu->tx_skb = NULL;

	return skb;
}

static inline int nci_uart_queue_empty(struct nci_uart *nu)
{
	if (nu->tx_skb)
		return 0;

	return skb_queue_empty(&nu->tx_q);
}

static int nci_uart_tx_wakeup(struct nci_uart *nu)
{
	if (test_and_set_bit(NCI_UART_SENDING, &nu->tx_state)) {
		set_bit(NCI_UART_TX_WAKEUP, &nu->tx_state);
		return 0;
	}

	schedule_work(&nu->write_work);

	return 0;
}

static void nci_uart_write_work(struct work_struct *work)
{
	struct nci_uart *nu = container_of(work, struct nci_uart, write_work);
	struct tty_struct *tty = nu->tty;
	struct sk_buff *skb;

restart:
	clear_bit(NCI_UART_TX_WAKEUP, &nu->tx_state);

	if (nu->ops.tx_start)
		nu->ops.tx_start(nu);

	while ((skb = nci_uart_dequeue(nu))) {
		int len;

		set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
		len = tty->ops->write(tty, skb->data, skb->len);
		skb_pull(skb, len);
		if (skb->len) {
			nu->tx_skb = skb;
			break;
		}
		kfree_skb(skb);
	}

	if (test_bit(NCI_UART_TX_WAKEUP, &nu->tx_state))
		goto restart;

	if (nu->ops.tx_done && nci_uart_queue_empty(nu))
		nu->ops.tx_done(nu);

	clear_bit(NCI_UART_SENDING, &nu->tx_state);
}

static int nci_uart_set_driver(struct tty_struct *tty, unsigned int driver)
{
	struct nci_uart *nu = NULL;
	int ret;

	if (driver >= NCI_UART_DRIVER_MAX)
		return -EINVAL;

	if (!nci_uart_drivers[driver])
		return -ENOENT;

	nu = kzalloc(sizeof(*nu), GFP_KERNEL);
	if (!nu)
		return -ENOMEM;

	memcpy(nu, nci_uart_drivers[driver], sizeof(struct nci_uart));
	nu->tty = tty;
	tty->disc_data = nu;
	skb_queue_head_init(&nu->tx_q);
	INIT_WORK(&nu->write_work, nci_uart_write_work);
	spin_lock_init(&nu->rx_lock);

	ret = nu->ops.open(nu);
	if (ret) {
		tty->disc_data = NULL;
		kfree(nu);
	} else if (!try_module_get(nu->owner)) {
		nu->ops.close(nu);
		tty->disc_data = NULL;
		kfree(nu);
		return -ENOENT;
	}
	return ret;
}

/* ------ LDISC part ------ */

/* nci_uart_tty_open
 *
 *     Called when line discipline changed to NCI_UART.
 *
 * Arguments:
 *     tty    pointer to tty info structure
 * Return Value:
 *     0 if success, otherwise error code
 */
static int nci_uart_tty_open(struct tty_struct *tty)
{
	/* Error if the tty has no write op instead of leaving an exploitable
	 * hole
	 */
	if (!tty->ops->write)
		return -EOPNOTSUPP;

	tty->disc_data = NULL;
	tty->receive_room = 65536;

	/* Flush any pending characters in the driver */
	tty_driver_flush_buffer(tty);

	return 0;
}

/* nci_uart_tty_close()
 *
 *    Called when the line discipline is changed to something
 *    else, the tty is closed, or the tty detects a hangup.
 */
static void nci_uart_tty_close(struct tty_struct *tty)
{
	struct nci_uart *nu = (void *)tty->disc_data;

	/* Detach from the tty */
	tty->disc_data = NULL;

	if (!nu)
		return;

	if (nu->tx_skb)
		kfree_skb(nu->tx_skb);
	if (nu->rx_skb)
		kfree_skb(nu->rx_skb);

	skb_queue_purge(&nu->tx_q);

	nu->ops.close(nu);
	nu->tty = NULL;
	module_put(nu->owner);

	cancel_work_sync(&nu->write_work);

	kfree(nu);
}

/* nci_uart_tty_wakeup()
 *
 *    Callback for transmit wakeup. Called when low level
 *    device driver can accept more send data.
 *
 * Arguments:        tty    pointer to associated tty instance data
 * Return Value:    None
 */
static void nci_uart_tty_wakeup(struct tty_struct *tty)
{
	struct nci_uart *nu = (void *)tty->disc_data;

	if (!nu)
		return;

	clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);

	if (tty != nu->tty)
		return;

	nci_uart_tx_wakeup(nu);
}

/* nci_uart_tty_receive()
 *
 *     Called by tty low level driver when receive data is
 *     available.
 *
 * Arguments:  tty          pointer to tty isntance data
 *             data         pointer to received data
 *             flags        pointer to flags for data
 *             count        count of received data in bytes
 *
 * Return Value:    None
 */
static void nci_uart_tty_receive(struct tty_struct *tty, const u8 *data,
				 char *flags, int count)
{
	struct nci_uart *nu = (void *)tty->disc_data;

	if (!nu || tty != nu->tty)
		return;

	spin_lock(&nu->rx_lock);
	nu->ops.recv_buf(nu, (void *)data, flags, count);
	spin_unlock(&nu->rx_lock);

	tty_unthrottle(tty);
}

/* nci_uart_tty_ioctl()
 *
 *    Process IOCTL system call for the tty device.
 *
 * Arguments:
 *
 *    tty        pointer to tty instance data
 *    file       pointer to open file object for device
 *    cmd        IOCTL command code
 *    arg        argument for IOCTL call (cmd dependent)
 *
 * Return Value:    Command dependent
 */
static int nci_uart_tty_ioctl(struct tty_struct *tty, struct file *file,
			      unsigned int cmd, unsigned long arg)
{
	struct nci_uart *nu = (void *)tty->disc_data;
	int err = 0;

	switch (cmd) {
	case NCIUARTSETDRIVER:
		if (!nu)
			return nci_uart_set_driver(tty, (unsigned int)arg);
		else
			return -EBUSY;
		break;
	default:
		err = n_tty_ioctl_helper(tty, file, cmd, arg);
		break;
	}

	return err;
}

/* We don't provide read/write/poll interface for user space. */
static ssize_t nci_uart_tty_read(struct tty_struct *tty, struct file *file,
				 unsigned char __user *buf, size_t nr)
{
	return 0;
}

static ssize_t nci_uart_tty_write(struct tty_struct *tty, struct file *file,
				  const unsigned char *data, size_t count)
{
	return 0;
}

static __poll_t nci_uart_tty_poll(struct tty_struct *tty,
				      struct file *filp, poll_table *wait)
{
	return 0;
}

static int nci_uart_send(struct nci_uart *nu, struct sk_buff *skb)
{
	/* Queue TX packet */
	skb_queue_tail(&nu->tx_q, skb);

	/* Try to start TX (if possible) */
	nci_uart_tx_wakeup(nu);

	return 0;
}

/* -- Default recv_buf handler --
 *
 * This handler supposes that NCI frames are sent over UART link without any
 * framing. It reads NCI header, retrieve the packet size and once all packet
 * bytes are received it passes it to nci_uart driver for processing.
 */
static int nci_uart_default_recv_buf(struct nci_uart *nu, const u8 *data,
				     char *flags, int count)
{
	int chunk_len;

	if (!nu->ndev) {
		nfc_err(nu->tty->dev,
			"receive data from tty but no NCI dev is attached yet, drop buffer\n");
		return 0;
	}

	/* Decode all incoming data in packets
	 * and enqueue then for processing.
	 */
	while (count > 0) {
		/* If this is the first data of a packet, allocate a buffer */
		if (!nu->rx_skb) {
			nu->rx_packet_len = -1;
			nu->rx_skb = nci_skb_alloc(nu->ndev,
						   NCI_MAX_PACKET_SIZE,
						   GFP_KERNEL);
			if (!nu->rx_skb)
				return -ENOMEM;
		}

		/* Eat byte after byte till full packet header is received */
		if (nu->rx_skb->len < NCI_CTRL_HDR_SIZE) {
			skb_put_u8(nu->rx_skb, *data++);
			--count;
			continue;
		}

		/* Header was received but packet len was not read */
		if (nu->rx_packet_len < 0)
			nu->rx_packet_len = NCI_CTRL_HDR_SIZE +
				nci_plen(nu->rx_skb->data);

		/* Compute how many bytes are missing and how many bytes can
		 * be consumed.
		 */
		chunk_len = nu->rx_packet_len - nu->rx_skb->len;
		if (count < chunk_len)
			chunk_len = count;
		skb_put_data(nu->rx_skb, data, chunk_len);
		data += chunk_len;
		count -= chunk_len;

		/* Chcek if packet is fully received */
		if (nu->rx_packet_len == nu->rx_skb->len) {
			/* Pass RX packet to driver */
			if (nu->ops.recv(nu, nu->rx_skb) != 0)
				nfc_err(nu->tty->dev, "corrupted RX packet\n");
			/* Next packet will be a new one */
			nu->rx_skb = NULL;
		}
	}

	return 0;
}

/* -- Default recv handler -- */
static int nci_uart_default_recv(struct nci_uart *nu, struct sk_buff *skb)
{
	return nci_recv_frame(nu->ndev, skb);
}

int nci_uart_register(struct nci_uart *nu)
{
	if (!nu || !nu->ops.open ||
	    !nu->ops.recv || !nu->ops.close)
		return -EINVAL;

	/* Set the send callback */
	nu->ops.send = nci_uart_send;

	/* Install default handlers if not overridden */
	if (!nu->ops.recv_buf)
		nu->ops.recv_buf = nci_uart_default_recv_buf;
	if (!nu->ops.recv)
		nu->ops.recv = nci_uart_default_recv;

	/* Add this driver in the driver list */
	if (nci_uart_drivers[nu->driver]) {
		pr_err("driver %d is already registered\n", nu->driver);
		return -EBUSY;
	}
	nci_uart_drivers[nu->driver] = nu;

	pr_info("NCI uart driver '%s [%d]' registered\n", nu->name, nu->driver);

	return 0;
}
EXPORT_SYMBOL_GPL(nci_uart_register);

void nci_uart_unregister(struct nci_uart *nu)
{
	pr_info("NCI uart driver '%s [%d]' unregistered\n", nu->name,
		nu->driver);

	/* Remove this driver from the driver list */
	nci_uart_drivers[nu->driver] = NULL;
}
EXPORT_SYMBOL_GPL(nci_uart_unregister);

void nci_uart_set_config(struct nci_uart *nu, int baudrate, int flow_ctrl)
{
	struct ktermios new_termios;

	if (!nu->tty)
		return;

	down_read(&nu->tty->termios_rwsem);
	new_termios = nu->tty->termios;
	up_read(&nu->tty->termios_rwsem);
	tty_termios_encode_baud_rate(&new_termios, baudrate, baudrate);

	if (flow_ctrl)
		new_termios.c_cflag |= CRTSCTS;
	else
		new_termios.c_cflag &= ~CRTSCTS;

	tty_set_termios(nu->tty, &new_termios);
}
EXPORT_SYMBOL_GPL(nci_uart_set_config);

static struct tty_ldisc_ops nci_uart_ldisc = {
	.magic		= TTY_LDISC_MAGIC,
	.owner		= THIS_MODULE,
	.name		= "n_nci",
	.open		= nci_uart_tty_open,
	.close		= nci_uart_tty_close,
	.read		= nci_uart_tty_read,
	.write		= nci_uart_tty_write,
	.poll		= nci_uart_tty_poll,
	.receive_buf	= nci_uart_tty_receive,
	.write_wakeup	= nci_uart_tty_wakeup,
	.ioctl		= nci_uart_tty_ioctl,
};

static int __init nci_uart_init(void)
{
	memset(nci_uart_drivers, 0, sizeof(nci_uart_drivers));
	return tty_register_ldisc(N_NCI, &nci_uart_ldisc);
}

static void __exit nci_uart_exit(void)
{
	tty_unregister_ldisc(N_NCI);
}

module_init(nci_uart_init);
module_exit(nci_uart_exit);

MODULE_AUTHOR("Marvell International Ltd.");
MODULE_DESCRIPTION("NFC NCI UART driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS_LDISC(N_NCI);
Commit	Line	Data
9961127d VC	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.
9961127d VC	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
582e20a0	174	/* Flush any pending characters in the driver */
9961127d VC	175	tty_driver_flush_buffer(tty);
	176
	177	return 0;
	178	}
	179
	180	/* nci_uart_tty_close()
	181	*
	182	* Called when the line discipline is changed to something
	183	* else, the tty is closed, or the tty detects a hangup.
	184	*/
	185	static void nci_uart_tty_close(struct tty_struct *tty)
	186	{
	187	struct nci_uart nu = (void )tty->disc_data;
	188
	189	/* Detach from the tty */
	190	tty->disc_data = NULL;
	191
	192	if (!nu)
	193	return;
	194
	195	if (nu->tx_skb)
	196	kfree_skb(nu->tx_skb);
	197	if (nu->rx_skb)
	198	kfree_skb(nu->rx_skb);
	199
	200	skb_queue_purge(&nu->tx_q);
	201
	202	nu->ops.close(nu);
	203	nu->tty = NULL;
	204	module_put(nu->owner);
	205
	206	cancel_work_sync(&nu->write_work);
	207
	208	kfree(nu);
	209	}
	210
	211	/* nci_uart_tty_wakeup()
	212	*
	213	* Callback for transmit wakeup. Called when low level
	214	* device driver can accept more send data.
	215	*
	216	* Arguments: tty pointer to associated tty instance data
	217	* Return Value: None
	218	*/
	219	static void nci_uart_tty_wakeup(struct tty_struct *tty)
	220	{
	221	struct nci_uart nu = (void )tty->disc_data;
	222
	223	if (!nu)
	224	return;
	225
	226	clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
	227
	228	if (tty != nu->tty)
	229	return;
	230
	231	nci_uart_tx_wakeup(nu);
	232	}
	233
	234	/* nci_uart_tty_receive()
	235	*
	236	* Called by tty low level driver when receive data is
	237	* available.
	238	*
239	* Arguments: tty pointer to tty isntance data
240	* data pointer to received data
241	* flags pointer to flags for data
242	* count count of received data in bytes
243	*
244	* Return Value: None
245	*/
246	static void nci_uart_tty_receive(struct tty_struct tty, const u8 data,
247	char *flags, int count)
248	{
249	struct nci_uart nu = (void )tty->disc_data;
250
251	if (!nu \|\| tty != nu->tty)
252	return;
253
254	spin_lock(&nu->rx_lock);
255	nu->ops.recv_buf(nu, (void *)data, flags, count);
256	spin_unlock(&nu->rx_lock);
257
258	tty_unthrottle(tty);
259	}
260
261	/* nci_uart_tty_ioctl()
262	*
263	* Process IOCTL system call for the tty device.
264	*
265	* Arguments:
266	*
267	* tty pointer to tty instance data
268	* file pointer to open file object for device
269	* cmd IOCTL command code
270	* arg argument for IOCTL call (cmd dependent)
271	*
272	* Return Value: Command dependent
273	*/
274	static int nci_uart_tty_ioctl(struct tty_struct tty, struct file file,
275	unsigned int cmd, unsigned long arg)
276	{
277	struct nci_uart nu = (void )tty->disc_data;
278	int err = 0;
279
280	switch (cmd) {
281	case NCIUARTSETDRIVER:
282	if (!nu)
283	return nci_uart_set_driver(tty, (unsigned int)arg);
284	else
285	return -EBUSY;
286	break;
287	default:
288	err = n_tty_ioctl_helper(tty, file, cmd, arg);
289	break;
290	}
291
292	return err;
293	}
294
295	/* We don't provide read/write/poll interface for user space. */
296	static ssize_t nci_uart_tty_read(struct tty_struct tty, struct file file,
297	unsigned char __user *buf, size_t nr)
298	{
299	return 0;
300	}
301
302	static ssize_t nci_uart_tty_write(struct tty_struct tty, struct file file,
303	const unsigned char *data, size_t count)
304	{
305	return 0;
306	}
307
ade994f4	308	static __poll_t nci_uart_tty_poll(struct tty_struct *tty,
9961127d VC	309	struct file filp, poll_table wait)
	310	{
	311	return 0;
	312	}
	313
	314	static int nci_uart_send(struct nci_uart nu, struct sk_buff skb)
	315	{
	316	/* Queue TX packet */
	317	skb_queue_tail(&nu->tx_q, skb);
	318
	319	/* Try to start TX (if possible) */
	320	nci_uart_tx_wakeup(nu);
	321
	322	return 0;
	323	}
	324
	325	/* -- Default recv_buf handler --
	326	*
	327	* This handler supposes that NCI frames are sent over UART link without any
	328	* framing. It reads NCI header, retrieve the packet size and once all packet
	329	* bytes are received it passes it to nci_uart driver for processing.
	330	*/
	331	static int nci_uart_default_recv_buf(struct nci_uart nu, const u8 data,
	332	char *flags, int count)
	333	{
	334	int chunk_len;
	335
	336	if (!nu->ndev) {
	337	nfc_err(nu->tty->dev,
	338	"receive data from tty but no NCI dev is attached yet, drop buffer\n");
	339	return 0;
	340	}
	341
	342	/* Decode all incoming data in packets
	343	* and enqueue then for processing.
	344	*/
	345	while (count > 0) {
	346	/* If this is the first data of a packet, allocate a buffer */
	347	if (!nu->rx_skb) {
	348	nu->rx_packet_len = -1;
	349	nu->rx_skb = nci_skb_alloc(nu->ndev,
	350	NCI_MAX_PACKET_SIZE,
	351	GFP_KERNEL);
	352	if (!nu->rx_skb)
	353	return -ENOMEM;
	354	}
	355
	356	/* Eat byte after byte till full packet header is received */
	357	if (nu->rx_skb->len < NCI_CTRL_HDR_SIZE) {
634fef61	358	skb_put_u8(nu->rx_skb, *data++);
9961127d VC	359	--count;
	360	continue;
	361	}
	362
	363	/* Header was received but packet len was not read */
	364	if (nu->rx_packet_len < 0)
	365	nu->rx_packet_len = NCI_CTRL_HDR_SIZE +
	366	nci_plen(nu->rx_skb->data);
	367
	368	/* Compute how many bytes are missing and how many bytes can
	369	* be consumed.
	370	*/
	371	chunk_len = nu->rx_packet_len - nu->rx_skb->len;
	372	if (count < chunk_len)
	373	chunk_len = count;
59ae1d12	374	skb_put_data(nu->rx_skb, data, chunk_len);
9961127d VC	375	data += chunk_len;
	376	count -= chunk_len;
	377
	378	/* Chcek if packet is fully received */
	379	if (nu->rx_packet_len == nu->rx_skb->len) {
	380	/* Pass RX packet to driver */
	381	if (nu->ops.recv(nu, nu->rx_skb) != 0)
	382	nfc_err(nu->tty->dev, "corrupted RX packet\n");
	383	/* Next packet will be a new one */
	384	nu->rx_skb = NULL;
	385	}
	386	}
	387
	388	return 0;
	389	}
	390
	391	/* -- Default recv handler -- */
	392	static int nci_uart_default_recv(struct nci_uart nu, struct sk_buff skb)
	393	{
	394	return nci_recv_frame(nu->ndev, skb);
	395	}
	396
	397	int nci_uart_register(struct nci_uart *nu)
	398	{
	399	if (!nu \|\| !nu->ops.open \|\|
	400	!nu->ops.recv \|\| !nu->ops.close)
	401	return -EINVAL;
	402
	403	/* Set the send callback */
	404	nu->ops.send = nci_uart_send;
	405
	406	/* Install default handlers if not overridden */
	407	if (!nu->ops.recv_buf)
	408	nu->ops.recv_buf = nci_uart_default_recv_buf;
	409	if (!nu->ops.recv)
	410	nu->ops.recv = nci_uart_default_recv;
	411
	412	/* Add this driver in the driver list */
fb77ff4f	413	if (nci_uart_drivers[nu->driver]) {
9961127d VC	414	pr_err("driver %d is already registered\n", nu->driver);
	415	return -EBUSY;
	416	}
	417	nci_uart_drivers[nu->driver] = nu;
	418
	419	pr_info("NCI uart driver '%s [%d]' registered\n", nu->name, nu->driver);
	420
	421	return 0;
	422	}
	423	EXPORT_SYMBOL_GPL(nci_uart_register);
	424
	425	void nci_uart_unregister(struct nci_uart *nu)
	426	{
	427	pr_info("NCI uart driver '%s [%d]' unregistered\n", nu->name,
	428	nu->driver);
	429
	430	/* Remove this driver from the driver list */
	431	nci_uart_drivers[nu->driver] = NULL;
	432	}
	433	EXPORT_SYMBOL_GPL(nci_uart_unregister);
	434
	435	void nci_uart_set_config(struct nci_uart *nu, int baudrate, int flow_ctrl)
	436	{
	437	struct ktermios new_termios;
	438
	439	if (!nu->tty)
	440	return;
	441
	442	down_read(&nu->tty->termios_rwsem);
	443	new_termios = nu->tty->termios;
	444	up_read(&nu->tty->termios_rwsem);
	445	tty_termios_encode_baud_rate(&new_termios, baudrate, baudrate);
	446
	447	if (flow_ctrl)
	448	new_termios.c_cflag \|= CRTSCTS;
	449	else
	450	new_termios.c_cflag &= ~CRTSCTS;
	451
	452	tty_set_termios(nu->tty, &new_termios);
	453	}
	454	EXPORT_SYMBOL_GPL(nci_uart_set_config);
	455
	456	static struct tty_ldisc_ops nci_uart_ldisc = {
	457	.magic = TTY_LDISC_MAGIC,
	458	.owner = THIS_MODULE,
	459	.name = "n_nci",
	460	.open = nci_uart_tty_open,
	461	.close = nci_uart_tty_close,
	462	.read = nci_uart_tty_read,
	463	.write = nci_uart_tty_write,
	464	.poll = nci_uart_tty_poll,
	465	.receive_buf = nci_uart_tty_receive,
	466	.write_wakeup = nci_uart_tty_wakeup,
	467	.ioctl = nci_uart_tty_ioctl,
	468	};
	469
	470	static int __init nci_uart_init(void)
	471	{
	472	memset(nci_uart_drivers, 0, sizeof(nci_uart_drivers));
	473	return tty_register_ldisc(N_NCI, &nci_uart_ldisc);
	474	}
	475
	476	static void __exit nci_uart_exit(void)
	477	{
478	tty_unregister_ldisc(N_NCI);
479	}
480
481	module_init(nci_uart_init);
482	module_exit(nci_uart_exit);
483
484	MODULE_AUTHOR("Marvell International Ltd.");
485	MODULE_DESCRIPTION("NFC NCI UART driver");
486	MODULE_LICENSE("GPL");
487	MODULE_ALIAS_LDISC(N_NCI);