xref: /openbmc/linux/drivers/net/mctp/mctp-serial.c (revision ec368152)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Management Component Transport Protocol (MCTP) - serial transport
4  * binding. This driver is an implementation of the DMTF specificiation
5  * "DSP0253 - Management Component Transport Protocol (MCTP) Serial Transport
6  * Binding", available at:
7  *
8  *  https://www.dmtf.org/sites/default/files/standards/documents/DSP0253_1.0.0.pdf
9  *
10  * This driver provides DSP0253-type MCTP-over-serial transport using a Linux
11  * tty device, by setting the N_MCTP line discipline on the tty.
12  *
13  * Copyright (c) 2021 Code Construct
14  */
15 
16 #include <linux/idr.h>
17 #include <linux/if_arp.h>
18 #include <linux/module.h>
19 #include <linux/skbuff.h>
20 #include <linux/tty.h>
21 #include <linux/workqueue.h>
22 #include <linux/crc-ccitt.h>
23 
24 #include <linux/mctp.h>
25 #include <net/mctp.h>
26 #include <net/pkt_sched.h>
27 
28 #define MCTP_SERIAL_MTU		68 /* base mtu (64) + mctp header */
29 #define MCTP_SERIAL_FRAME_MTU	(MCTP_SERIAL_MTU + 6) /* + serial framing */
30 
31 #define MCTP_SERIAL_VERSION	0x1 /* DSP0253 defines a single version: 1 */
32 
33 #define BUFSIZE			MCTP_SERIAL_FRAME_MTU
34 
35 #define BYTE_FRAME		0x7e
36 #define BYTE_ESC		0x7d
37 
38 #define FCS_INIT		0xffff
39 
40 static DEFINE_IDA(mctp_serial_ida);
41 
42 enum mctp_serial_state {
43 	STATE_IDLE,
44 	STATE_START,
45 	STATE_HEADER,
46 	STATE_DATA,
47 	STATE_ESCAPE,
48 	STATE_TRAILER,
49 	STATE_DONE,
50 	STATE_ERR,
51 };
52 
53 struct mctp_serial {
54 	struct net_device	*netdev;
55 	struct tty_struct	*tty;
56 
57 	int			idx;
58 
59 	/* protects our rx & tx state machines; held during both paths */
60 	spinlock_t		lock;
61 
62 	struct work_struct	tx_work;
63 	enum mctp_serial_state	txstate, rxstate;
64 	u16			txfcs, rxfcs, rxfcs_rcvd;
65 	unsigned int		txlen, rxlen;
66 	unsigned int		txpos, rxpos;
67 	unsigned char		txbuf[BUFSIZE],
68 				rxbuf[BUFSIZE];
69 };
70 
needs_escape(unsigned char c)71 static bool needs_escape(unsigned char c)
72 {
73 	return c == BYTE_ESC || c == BYTE_FRAME;
74 }
75 
next_chunk_len(struct mctp_serial * dev)76 static int next_chunk_len(struct mctp_serial *dev)
77 {
78 	int i;
79 
80 	/* either we have no bytes to send ... */
81 	if (dev->txpos == dev->txlen)
82 		return 0;
83 
84 	/* ... or the next byte to send is an escaped byte; requiring a
85 	 * single-byte chunk...
86 	 */
87 	if (needs_escape(dev->txbuf[dev->txpos]))
88 		return 1;
89 
90 	/* ... or we have one or more bytes up to the next escape - this chunk
91 	 * will be those non-escaped bytes, and does not include the escaped
92 	 * byte.
93 	 */
94 	for (i = 1; i + dev->txpos < dev->txlen; i++) {
95 		if (needs_escape(dev->txbuf[dev->txpos + i]))
96 			break;
97 	}
98 
99 	return i;
100 }
101 
write_chunk(struct mctp_serial * dev,unsigned char * buf,int len)102 static int write_chunk(struct mctp_serial *dev, unsigned char *buf, int len)
103 {
104 	return dev->tty->ops->write(dev->tty, buf, len);
105 }
106 
mctp_serial_tx_work(struct work_struct * work)107 static void mctp_serial_tx_work(struct work_struct *work)
108 {
109 	struct mctp_serial *dev = container_of(work, struct mctp_serial,
110 					       tx_work);
111 	unsigned char c, buf[3];
112 	unsigned long flags;
113 	int len, txlen;
114 
115 	spin_lock_irqsave(&dev->lock, flags);
116 
117 	/* txstate represents the next thing to send */
118 	switch (dev->txstate) {
119 	case STATE_START:
120 		dev->txpos = 0;
121 		fallthrough;
122 	case STATE_HEADER:
123 		buf[0] = BYTE_FRAME;
124 		buf[1] = MCTP_SERIAL_VERSION;
125 		buf[2] = dev->txlen;
126 
127 		if (!dev->txpos)
128 			dev->txfcs = crc_ccitt(FCS_INIT, buf + 1, 2);
129 
130 		txlen = write_chunk(dev, buf + dev->txpos, 3 - dev->txpos);
131 		if (txlen <= 0) {
132 			dev->txstate = STATE_ERR;
133 		} else {
134 			dev->txpos += txlen;
135 			if (dev->txpos == 3) {
136 				dev->txstate = STATE_DATA;
137 				dev->txpos = 0;
138 			}
139 		}
140 		break;
141 
142 	case STATE_ESCAPE:
143 		buf[0] = dev->txbuf[dev->txpos] & ~0x20;
144 		txlen = write_chunk(dev, buf, 1);
145 		if (txlen <= 0) {
146 			dev->txstate = STATE_ERR;
147 		} else {
148 			dev->txpos += txlen;
149 			if (dev->txpos == dev->txlen) {
150 				dev->txstate = STATE_TRAILER;
151 				dev->txpos = 0;
152 			}
153 		}
154 
155 		break;
156 
157 	case STATE_DATA:
158 		len = next_chunk_len(dev);
159 		if (len) {
160 			c = dev->txbuf[dev->txpos];
161 			if (len == 1 && needs_escape(c)) {
162 				buf[0] = BYTE_ESC;
163 				buf[1] = c & ~0x20;
164 				dev->txfcs = crc_ccitt_byte(dev->txfcs, c);
165 				txlen = write_chunk(dev, buf, 2);
166 				if (txlen == 2)
167 					dev->txpos++;
168 				else if (txlen == 1)
169 					dev->txstate = STATE_ESCAPE;
170 				else
171 					dev->txstate = STATE_ERR;
172 			} else {
173 				txlen = write_chunk(dev,
174 						    dev->txbuf + dev->txpos,
175 						    len);
176 				if (txlen <= 0) {
177 					dev->txstate = STATE_ERR;
178 				} else {
179 					dev->txfcs = crc_ccitt(dev->txfcs,
180 							       dev->txbuf +
181 							       dev->txpos,
182 							       txlen);
183 					dev->txpos += txlen;
184 				}
185 			}
186 			if (dev->txstate == STATE_DATA &&
187 			    dev->txpos == dev->txlen) {
188 				dev->txstate = STATE_TRAILER;
189 				dev->txpos = 0;
190 			}
191 			break;
192 		}
193 		dev->txstate = STATE_TRAILER;
194 		dev->txpos = 0;
195 		fallthrough;
196 
197 	case STATE_TRAILER:
198 		buf[0] = dev->txfcs >> 8;
199 		buf[1] = dev->txfcs & 0xff;
200 		buf[2] = BYTE_FRAME;
201 		txlen = write_chunk(dev, buf + dev->txpos, 3 - dev->txpos);
202 		if (txlen <= 0) {
203 			dev->txstate = STATE_ERR;
204 		} else {
205 			dev->txpos += txlen;
206 			if (dev->txpos == 3) {
207 				dev->txstate = STATE_DONE;
208 				dev->txpos = 0;
209 			}
210 		}
211 		break;
212 	default:
213 		netdev_err_once(dev->netdev, "invalid tx state %d\n",
214 				dev->txstate);
215 	}
216 
217 	if (dev->txstate == STATE_DONE) {
218 		dev->netdev->stats.tx_packets++;
219 		dev->netdev->stats.tx_bytes += dev->txlen;
220 		dev->txlen = 0;
221 		dev->txpos = 0;
222 		clear_bit(TTY_DO_WRITE_WAKEUP, &dev->tty->flags);
223 		dev->txstate = STATE_IDLE;
224 		spin_unlock_irqrestore(&dev->lock, flags);
225 
226 		netif_wake_queue(dev->netdev);
227 	} else {
228 		spin_unlock_irqrestore(&dev->lock, flags);
229 	}
230 }
231 
mctp_serial_tx(struct sk_buff * skb,struct net_device * ndev)232 static netdev_tx_t mctp_serial_tx(struct sk_buff *skb, struct net_device *ndev)
233 {
234 	struct mctp_serial *dev = netdev_priv(ndev);
235 	unsigned long flags;
236 
237 	WARN_ON(dev->txstate != STATE_IDLE);
238 
239 	if (skb->len > MCTP_SERIAL_MTU) {
240 		dev->netdev->stats.tx_dropped++;
241 		goto out;
242 	}
243 
244 	spin_lock_irqsave(&dev->lock, flags);
245 	netif_stop_queue(dev->netdev);
246 	skb_copy_bits(skb, 0, dev->txbuf, skb->len);
247 	dev->txpos = 0;
248 	dev->txlen = skb->len;
249 	dev->txstate = STATE_START;
250 	spin_unlock_irqrestore(&dev->lock, flags);
251 
252 	set_bit(TTY_DO_WRITE_WAKEUP, &dev->tty->flags);
253 	schedule_work(&dev->tx_work);
254 
255 out:
256 	kfree_skb(skb);
257 	return NETDEV_TX_OK;
258 }
259 
mctp_serial_tty_write_wakeup(struct tty_struct * tty)260 static void mctp_serial_tty_write_wakeup(struct tty_struct *tty)
261 {
262 	struct mctp_serial *dev = tty->disc_data;
263 
264 	schedule_work(&dev->tx_work);
265 }
266 
mctp_serial_rx(struct mctp_serial * dev)267 static void mctp_serial_rx(struct mctp_serial *dev)
268 {
269 	struct mctp_skb_cb *cb;
270 	struct sk_buff *skb;
271 
272 	if (dev->rxfcs != dev->rxfcs_rcvd) {
273 		dev->netdev->stats.rx_dropped++;
274 		dev->netdev->stats.rx_crc_errors++;
275 		return;
276 	}
277 
278 	skb = netdev_alloc_skb(dev->netdev, dev->rxlen);
279 	if (!skb) {
280 		dev->netdev->stats.rx_dropped++;
281 		return;
282 	}
283 
284 	skb->protocol = htons(ETH_P_MCTP);
285 	skb_put_data(skb, dev->rxbuf, dev->rxlen);
286 	skb_reset_network_header(skb);
287 
288 	cb = __mctp_cb(skb);
289 	cb->halen = 0;
290 
291 	netif_rx(skb);
292 	dev->netdev->stats.rx_packets++;
293 	dev->netdev->stats.rx_bytes += dev->rxlen;
294 }
295 
mctp_serial_push_header(struct mctp_serial * dev,unsigned char c)296 static void mctp_serial_push_header(struct mctp_serial *dev, unsigned char c)
297 {
298 	switch (dev->rxpos) {
299 	case 0:
300 		if (c == BYTE_FRAME)
301 			dev->rxpos++;
302 		else
303 			dev->rxstate = STATE_ERR;
304 		break;
305 	case 1:
306 		if (c == MCTP_SERIAL_VERSION) {
307 			dev->rxpos++;
308 			dev->rxfcs = crc_ccitt_byte(FCS_INIT, c);
309 		} else {
310 			dev->rxstate = STATE_ERR;
311 		}
312 		break;
313 	case 2:
314 		if (c > MCTP_SERIAL_FRAME_MTU) {
315 			dev->rxstate = STATE_ERR;
316 		} else {
317 			dev->rxlen = c;
318 			dev->rxpos = 0;
319 			dev->rxstate = STATE_DATA;
320 			dev->rxfcs = crc_ccitt_byte(dev->rxfcs, c);
321 		}
322 		break;
323 	}
324 }
325 
mctp_serial_push_trailer(struct mctp_serial * dev,unsigned char c)326 static void mctp_serial_push_trailer(struct mctp_serial *dev, unsigned char c)
327 {
328 	switch (dev->rxpos) {
329 	case 0:
330 		dev->rxfcs_rcvd = c << 8;
331 		dev->rxpos++;
332 		break;
333 	case 1:
334 		dev->rxfcs_rcvd |= c;
335 		dev->rxpos++;
336 		break;
337 	case 2:
338 		if (c != BYTE_FRAME) {
339 			dev->rxstate = STATE_ERR;
340 		} else {
341 			mctp_serial_rx(dev);
342 			dev->rxlen = 0;
343 			dev->rxpos = 0;
344 			dev->rxstate = STATE_IDLE;
345 		}
346 		break;
347 	}
348 }
349 
mctp_serial_push(struct mctp_serial * dev,unsigned char c)350 static void mctp_serial_push(struct mctp_serial *dev, unsigned char c)
351 {
352 	switch (dev->rxstate) {
353 	case STATE_IDLE:
354 		dev->rxstate = STATE_HEADER;
355 		fallthrough;
356 	case STATE_HEADER:
357 		mctp_serial_push_header(dev, c);
358 		break;
359 
360 	case STATE_ESCAPE:
361 		c |= 0x20;
362 		fallthrough;
363 	case STATE_DATA:
364 		if (dev->rxstate != STATE_ESCAPE && c == BYTE_ESC) {
365 			dev->rxstate = STATE_ESCAPE;
366 		} else {
367 			dev->rxfcs = crc_ccitt_byte(dev->rxfcs, c);
368 			dev->rxbuf[dev->rxpos] = c;
369 			dev->rxpos++;
370 			dev->rxstate = STATE_DATA;
371 			if (dev->rxpos == dev->rxlen) {
372 				dev->rxpos = 0;
373 				dev->rxstate = STATE_TRAILER;
374 			}
375 		}
376 		break;
377 
378 	case STATE_TRAILER:
379 		mctp_serial_push_trailer(dev, c);
380 		break;
381 
382 	case STATE_ERR:
383 		if (c == BYTE_FRAME)
384 			dev->rxstate = STATE_IDLE;
385 		break;
386 
387 	default:
388 		netdev_err_once(dev->netdev, "invalid rx state %d\n",
389 				dev->rxstate);
390 	}
391 }
392 
mctp_serial_tty_receive_buf(struct tty_struct * tty,const u8 * c,const u8 * f,size_t len)393 static void mctp_serial_tty_receive_buf(struct tty_struct *tty, const u8 *c,
394 					const u8 *f, size_t len)
395 {
396 	struct mctp_serial *dev = tty->disc_data;
397 	int i;
398 
399 	if (!netif_running(dev->netdev))
400 		return;
401 
402 	/* we don't (currently) use the flag bytes, just data. */
403 	for (i = 0; i < len; i++)
404 		mctp_serial_push(dev, c[i]);
405 }
406 
mctp_serial_uninit(struct net_device * ndev)407 static void mctp_serial_uninit(struct net_device *ndev)
408 {
409 	struct mctp_serial *dev = netdev_priv(ndev);
410 
411 	cancel_work_sync(&dev->tx_work);
412 }
413 
414 static const struct net_device_ops mctp_serial_netdev_ops = {
415 	.ndo_start_xmit = mctp_serial_tx,
416 	.ndo_uninit = mctp_serial_uninit,
417 };
418 
mctp_serial_setup(struct net_device * ndev)419 static void mctp_serial_setup(struct net_device *ndev)
420 {
421 	ndev->type = ARPHRD_MCTP;
422 
423 	/* we limit at the fixed MTU, which is also the MCTP-standard
424 	 * baseline MTU, so is also our minimum
425 	 */
426 	ndev->mtu = MCTP_SERIAL_MTU;
427 	ndev->max_mtu = MCTP_SERIAL_MTU;
428 	ndev->min_mtu = MCTP_SERIAL_MTU;
429 
430 	ndev->hard_header_len = 0;
431 	ndev->addr_len = 0;
432 	ndev->tx_queue_len = DEFAULT_TX_QUEUE_LEN;
433 	ndev->flags = IFF_NOARP;
434 	ndev->netdev_ops = &mctp_serial_netdev_ops;
435 	ndev->needs_free_netdev = true;
436 }
437 
mctp_serial_open(struct tty_struct * tty)438 static int mctp_serial_open(struct tty_struct *tty)
439 {
440 	struct mctp_serial *dev;
441 	struct net_device *ndev;
442 	char name[32];
443 	int idx, rc;
444 
445 	if (!capable(CAP_NET_ADMIN))
446 		return -EPERM;
447 
448 	if (!tty->ops->write)
449 		return -EOPNOTSUPP;
450 
451 	idx = ida_alloc(&mctp_serial_ida, GFP_KERNEL);
452 	if (idx < 0)
453 		return idx;
454 
455 	snprintf(name, sizeof(name), "mctpserial%d", idx);
456 	ndev = alloc_netdev(sizeof(*dev), name, NET_NAME_ENUM,
457 			    mctp_serial_setup);
458 	if (!ndev) {
459 		rc = -ENOMEM;
460 		goto free_ida;
461 	}
462 
463 	dev = netdev_priv(ndev);
464 	dev->idx = idx;
465 	dev->tty = tty;
466 	dev->netdev = ndev;
467 	dev->txstate = STATE_IDLE;
468 	dev->rxstate = STATE_IDLE;
469 	spin_lock_init(&dev->lock);
470 	INIT_WORK(&dev->tx_work, mctp_serial_tx_work);
471 
472 	rc = register_netdev(ndev);
473 	if (rc)
474 		goto free_netdev;
475 
476 	tty->receive_room = 64 * 1024;
477 	tty->disc_data = dev;
478 
479 	return 0;
480 
481 free_netdev:
482 	free_netdev(ndev);
483 
484 free_ida:
485 	ida_free(&mctp_serial_ida, idx);
486 	return rc;
487 }
488 
mctp_serial_close(struct tty_struct * tty)489 static void mctp_serial_close(struct tty_struct *tty)
490 {
491 	struct mctp_serial *dev = tty->disc_data;
492 	int idx = dev->idx;
493 
494 	unregister_netdev(dev->netdev);
495 	ida_free(&mctp_serial_ida, idx);
496 }
497 
498 static struct tty_ldisc_ops mctp_ldisc = {
499 	.owner		= THIS_MODULE,
500 	.num		= N_MCTP,
501 	.name		= "mctp",
502 	.open		= mctp_serial_open,
503 	.close		= mctp_serial_close,
504 	.receive_buf	= mctp_serial_tty_receive_buf,
505 	.write_wakeup	= mctp_serial_tty_write_wakeup,
506 };
507 
mctp_serial_init(void)508 static int __init mctp_serial_init(void)
509 {
510 	return tty_register_ldisc(&mctp_ldisc);
511 }
512 
mctp_serial_exit(void)513 static void __exit mctp_serial_exit(void)
514 {
515 	tty_unregister_ldisc(&mctp_ldisc);
516 }
517 
518 module_init(mctp_serial_init);
519 module_exit(mctp_serial_exit);
520 
521 MODULE_LICENSE("GPL v2");
522 MODULE_AUTHOR("Jeremy Kerr <jk@codeconstruct.com.au>");
523 MODULE_DESCRIPTION("MCTP Serial transport");
524