1 /*
2  *   Copyright (c) 2011, 2012, Qualcomm Atheros Communications Inc.
3  *   Copyright (c) 2017, I2SE GmbH
4  *
5  *   Permission to use, copy, modify, and/or distribute this software
6  *   for any purpose with or without fee is hereby granted, provided
7  *   that the above copyright notice and this permission notice appear
8  *   in all copies.
9  *
10  *   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11  *   WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12  *   WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
13  *   THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
14  *   CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
15  *   LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
16  *   NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
17  *   CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 /*   This module implements the Qualcomm Atheros UART protocol for
21  *   kernel-based UART device; it is essentially an Ethernet-to-UART
22  *   serial converter;
23  */
24 
25 #include <linux/device.h>
26 #include <linux/errno.h>
27 #include <linux/etherdevice.h>
28 #include <linux/if_arp.h>
29 #include <linux/if_ether.h>
30 #include <linux/jiffies.h>
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33 #include <linux/netdevice.h>
34 #include <linux/of.h>
35 #include <linux/of_device.h>
36 #include <linux/of_net.h>
37 #include <linux/sched.h>
38 #include <linux/serdev.h>
39 #include <linux/skbuff.h>
40 #include <linux/types.h>
41 
42 #include "qca_7k_common.h"
43 
44 #define QCAUART_DRV_VERSION "0.1.0"
45 #define QCAUART_DRV_NAME "qcauart"
46 #define QCAUART_TX_TIMEOUT (1 * HZ)
47 
48 struct qcauart {
49 	struct net_device *net_dev;
50 	spinlock_t lock;			/* transmit lock */
51 	struct work_struct tx_work;		/* Flushes transmit buffer   */
52 
53 	struct serdev_device *serdev;
54 	struct qcafrm_handle frm_handle;
55 	struct sk_buff *rx_skb;
56 
57 	unsigned char *tx_head;			/* pointer to next XMIT byte */
58 	int tx_left;				/* bytes left in XMIT queue  */
59 	unsigned char *tx_buffer;
60 };
61 
62 static int
63 qca_tty_receive(struct serdev_device *serdev, const unsigned char *data,
64 		size_t count)
65 {
66 	struct qcauart *qca = serdev_device_get_drvdata(serdev);
67 	struct net_device *netdev = qca->net_dev;
68 	struct net_device_stats *n_stats = &netdev->stats;
69 	size_t i;
70 
71 	if (!qca->rx_skb) {
72 		qca->rx_skb = netdev_alloc_skb_ip_align(netdev,
73 							netdev->mtu +
74 							VLAN_ETH_HLEN);
75 		if (!qca->rx_skb) {
76 			n_stats->rx_errors++;
77 			n_stats->rx_dropped++;
78 			return 0;
79 		}
80 	}
81 
82 	for (i = 0; i < count; i++) {
83 		s32 retcode;
84 
85 		retcode = qcafrm_fsm_decode(&qca->frm_handle,
86 					    qca->rx_skb->data,
87 					    skb_tailroom(qca->rx_skb),
88 					    data[i]);
89 
90 		switch (retcode) {
91 		case QCAFRM_GATHER:
92 		case QCAFRM_NOHEAD:
93 			break;
94 		case QCAFRM_NOTAIL:
95 			netdev_dbg(netdev, "recv: no RX tail\n");
96 			n_stats->rx_errors++;
97 			n_stats->rx_dropped++;
98 			break;
99 		case QCAFRM_INVLEN:
100 			netdev_dbg(netdev, "recv: invalid RX length\n");
101 			n_stats->rx_errors++;
102 			n_stats->rx_dropped++;
103 			break;
104 		default:
105 			n_stats->rx_packets++;
106 			n_stats->rx_bytes += retcode;
107 			skb_put(qca->rx_skb, retcode);
108 			qca->rx_skb->protocol = eth_type_trans(
109 						qca->rx_skb, qca->rx_skb->dev);
110 			skb_checksum_none_assert(qca->rx_skb);
111 			netif_rx_ni(qca->rx_skb);
112 			qca->rx_skb = netdev_alloc_skb_ip_align(netdev,
113 								netdev->mtu +
114 								VLAN_ETH_HLEN);
115 			if (!qca->rx_skb) {
116 				netdev_dbg(netdev, "recv: out of RX resources\n");
117 				n_stats->rx_errors++;
118 				return i;
119 			}
120 		}
121 	}
122 
123 	return i;
124 }
125 
126 /* Write out any remaining transmit buffer. Scheduled when tty is writable */
127 static void qcauart_transmit(struct work_struct *work)
128 {
129 	struct qcauart *qca = container_of(work, struct qcauart, tx_work);
130 	struct net_device_stats *n_stats = &qca->net_dev->stats;
131 	int written;
132 
133 	spin_lock_bh(&qca->lock);
134 
135 	/* First make sure we're connected. */
136 	if (!netif_running(qca->net_dev)) {
137 		spin_unlock_bh(&qca->lock);
138 		return;
139 	}
140 
141 	if (qca->tx_left <= 0)  {
142 		/* Now serial buffer is almost free & we can start
143 		 * transmission of another packet
144 		 */
145 		n_stats->tx_packets++;
146 		spin_unlock_bh(&qca->lock);
147 		netif_wake_queue(qca->net_dev);
148 		return;
149 	}
150 
151 	written = serdev_device_write_buf(qca->serdev, qca->tx_head,
152 					  qca->tx_left);
153 	if (written > 0) {
154 		qca->tx_left -= written;
155 		qca->tx_head += written;
156 	}
157 	spin_unlock_bh(&qca->lock);
158 }
159 
160 /* Called by the driver when there's room for more data.
161  * Schedule the transmit.
162  */
163 static void qca_tty_wakeup(struct serdev_device *serdev)
164 {
165 	struct qcauart *qca = serdev_device_get_drvdata(serdev);
166 
167 	schedule_work(&qca->tx_work);
168 }
169 
170 static const struct serdev_device_ops qca_serdev_ops = {
171 	.receive_buf = qca_tty_receive,
172 	.write_wakeup = qca_tty_wakeup,
173 };
174 
175 static int qcauart_netdev_open(struct net_device *dev)
176 {
177 	struct qcauart *qca = netdev_priv(dev);
178 
179 	netif_start_queue(qca->net_dev);
180 
181 	return 0;
182 }
183 
184 static int qcauart_netdev_close(struct net_device *dev)
185 {
186 	struct qcauart *qca = netdev_priv(dev);
187 
188 	netif_stop_queue(dev);
189 	flush_work(&qca->tx_work);
190 
191 	spin_lock_bh(&qca->lock);
192 	qca->tx_left = 0;
193 	spin_unlock_bh(&qca->lock);
194 
195 	return 0;
196 }
197 
198 static netdev_tx_t
199 qcauart_netdev_xmit(struct sk_buff *skb, struct net_device *dev)
200 {
201 	struct net_device_stats *n_stats = &dev->stats;
202 	struct qcauart *qca = netdev_priv(dev);
203 	u8 pad_len = 0;
204 	int written;
205 	u8 *pos;
206 
207 	spin_lock(&qca->lock);
208 
209 	WARN_ON(qca->tx_left);
210 
211 	if (!netif_running(dev))  {
212 		spin_unlock(&qca->lock);
213 		netdev_warn(qca->net_dev, "xmit: iface is down\n");
214 		goto out;
215 	}
216 
217 	pos = qca->tx_buffer;
218 
219 	if (skb->len < QCAFRM_MIN_LEN)
220 		pad_len = QCAFRM_MIN_LEN - skb->len;
221 
222 	pos += qcafrm_create_header(pos, skb->len + pad_len);
223 
224 	memcpy(pos, skb->data, skb->len);
225 	pos += skb->len;
226 
227 	if (pad_len) {
228 		memset(pos, 0, pad_len);
229 		pos += pad_len;
230 	}
231 
232 	pos += qcafrm_create_footer(pos);
233 
234 	netif_stop_queue(qca->net_dev);
235 
236 	written = serdev_device_write_buf(qca->serdev, qca->tx_buffer,
237 					  pos - qca->tx_buffer);
238 	if (written > 0) {
239 		qca->tx_left = (pos - qca->tx_buffer) - written;
240 		qca->tx_head = qca->tx_buffer + written;
241 		n_stats->tx_bytes += written;
242 	}
243 	spin_unlock(&qca->lock);
244 
245 	netif_trans_update(dev);
246 out:
247 	dev_kfree_skb_any(skb);
248 	return NETDEV_TX_OK;
249 }
250 
251 static void qcauart_netdev_tx_timeout(struct net_device *dev, unsigned int txqueue)
252 {
253 	struct qcauart *qca = netdev_priv(dev);
254 
255 	netdev_info(qca->net_dev, "Transmit timeout at %ld, latency %ld\n",
256 		    jiffies, dev_trans_start(dev));
257 	dev->stats.tx_errors++;
258 	dev->stats.tx_dropped++;
259 }
260 
261 static int qcauart_netdev_init(struct net_device *dev)
262 {
263 	struct qcauart *qca = netdev_priv(dev);
264 	size_t len;
265 
266 	/* Finish setting up the device info. */
267 	dev->mtu = QCAFRM_MAX_MTU;
268 	dev->type = ARPHRD_ETHER;
269 
270 	len = QCAFRM_HEADER_LEN + QCAFRM_MAX_LEN + QCAFRM_FOOTER_LEN;
271 	qca->tx_buffer = devm_kmalloc(&qca->serdev->dev, len, GFP_KERNEL);
272 	if (!qca->tx_buffer)
273 		return -ENOMEM;
274 
275 	qca->rx_skb = netdev_alloc_skb_ip_align(qca->net_dev,
276 						qca->net_dev->mtu +
277 						VLAN_ETH_HLEN);
278 	if (!qca->rx_skb)
279 		return -ENOBUFS;
280 
281 	return 0;
282 }
283 
284 static void qcauart_netdev_uninit(struct net_device *dev)
285 {
286 	struct qcauart *qca = netdev_priv(dev);
287 
288 	dev_kfree_skb(qca->rx_skb);
289 }
290 
291 static const struct net_device_ops qcauart_netdev_ops = {
292 	.ndo_init = qcauart_netdev_init,
293 	.ndo_uninit = qcauart_netdev_uninit,
294 	.ndo_open = qcauart_netdev_open,
295 	.ndo_stop = qcauart_netdev_close,
296 	.ndo_start_xmit = qcauart_netdev_xmit,
297 	.ndo_set_mac_address = eth_mac_addr,
298 	.ndo_tx_timeout = qcauart_netdev_tx_timeout,
299 	.ndo_validate_addr = eth_validate_addr,
300 };
301 
302 static void qcauart_netdev_setup(struct net_device *dev)
303 {
304 	dev->netdev_ops = &qcauart_netdev_ops;
305 	dev->watchdog_timeo = QCAUART_TX_TIMEOUT;
306 	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
307 	dev->tx_queue_len = 100;
308 
309 	/* MTU range: 46 - 1500 */
310 	dev->min_mtu = QCAFRM_MIN_MTU;
311 	dev->max_mtu = QCAFRM_MAX_MTU;
312 }
313 
314 static const struct of_device_id qca_uart_of_match[] = {
315 	{
316 	 .compatible = "qca,qca7000",
317 	},
318 	{}
319 };
320 MODULE_DEVICE_TABLE(of, qca_uart_of_match);
321 
322 static int qca_uart_probe(struct serdev_device *serdev)
323 {
324 	struct net_device *qcauart_dev = alloc_etherdev(sizeof(struct qcauart));
325 	struct qcauart *qca;
326 	u32 speed = 115200;
327 	int ret;
328 
329 	if (!qcauart_dev)
330 		return -ENOMEM;
331 
332 	qcauart_netdev_setup(qcauart_dev);
333 	SET_NETDEV_DEV(qcauart_dev, &serdev->dev);
334 
335 	qca = netdev_priv(qcauart_dev);
336 	if (!qca) {
337 		pr_err("qca_uart: Fail to retrieve private structure\n");
338 		ret = -ENOMEM;
339 		goto free;
340 	}
341 	qca->net_dev = qcauart_dev;
342 	qca->serdev = serdev;
343 	qcafrm_fsm_init_uart(&qca->frm_handle);
344 
345 	spin_lock_init(&qca->lock);
346 	INIT_WORK(&qca->tx_work, qcauart_transmit);
347 
348 	of_property_read_u32(serdev->dev.of_node, "current-speed", &speed);
349 
350 	ret = of_get_ethdev_address(serdev->dev.of_node, qca->net_dev);
351 	if (ret) {
352 		eth_hw_addr_random(qca->net_dev);
353 		dev_info(&serdev->dev, "Using random MAC address: %pM\n",
354 			 qca->net_dev->dev_addr);
355 	}
356 
357 	netif_carrier_on(qca->net_dev);
358 	serdev_device_set_drvdata(serdev, qca);
359 	serdev_device_set_client_ops(serdev, &qca_serdev_ops);
360 
361 	ret = serdev_device_open(serdev);
362 	if (ret) {
363 		dev_err(&serdev->dev, "Unable to open device %s\n",
364 			qcauart_dev->name);
365 		goto free;
366 	}
367 
368 	speed = serdev_device_set_baudrate(serdev, speed);
369 	dev_info(&serdev->dev, "Using baudrate: %u\n", speed);
370 
371 	serdev_device_set_flow_control(serdev, false);
372 
373 	ret = register_netdev(qcauart_dev);
374 	if (ret) {
375 		dev_err(&serdev->dev, "Unable to register net device %s\n",
376 			qcauart_dev->name);
377 		serdev_device_close(serdev);
378 		cancel_work_sync(&qca->tx_work);
379 		goto free;
380 	}
381 
382 	return 0;
383 
384 free:
385 	free_netdev(qcauart_dev);
386 	return ret;
387 }
388 
389 static void qca_uart_remove(struct serdev_device *serdev)
390 {
391 	struct qcauart *qca = serdev_device_get_drvdata(serdev);
392 
393 	unregister_netdev(qca->net_dev);
394 
395 	/* Flush any pending characters in the driver. */
396 	serdev_device_close(serdev);
397 	cancel_work_sync(&qca->tx_work);
398 
399 	free_netdev(qca->net_dev);
400 }
401 
402 static struct serdev_device_driver qca_uart_driver = {
403 	.probe = qca_uart_probe,
404 	.remove = qca_uart_remove,
405 	.driver = {
406 		.name = QCAUART_DRV_NAME,
407 		.of_match_table = of_match_ptr(qca_uart_of_match),
408 	},
409 };
410 
411 module_serdev_device_driver(qca_uart_driver);
412 
413 MODULE_DESCRIPTION("Qualcomm Atheros QCA7000 UART Driver");
414 MODULE_AUTHOR("Qualcomm Atheros Communications");
415 MODULE_AUTHOR("Stefan Wahren <stefan.wahren@i2se.com>");
416 MODULE_LICENSE("Dual BSD/GPL");
417 MODULE_VERSION(QCAUART_DRV_VERSION);
418