1 // SPDX-License-Identifier: GPL-2.0
2 /* ELM327 based CAN interface driver (tty line discipline)
4 * This driver started as a derivative of linux/drivers/net/can/slcan.c
5 * and my thanks go to the original authors for their inspiration.
7 * can327.c Author : Max Staudt <max-linux@enpas.org>
8 * slcan.c Author : Oliver Hartkopp <socketcan@hartkopp.net>
9 * slip.c Authors : Laurence Culhane <loz@holmes.demon.co.uk>
10 * Fred N. van Kempen <waltje@uwalt.nl.mugnet.org>
13 #define pr_fmt(fmt) "can327: " fmt
15 #include <linux/init.h>
16 #include <linux/module.h>
18 #include <linux/bitops.h>
19 #include <linux/ctype.h>
20 #include <linux/errno.h>
21 #include <linux/kernel.h>
22 #include <linux/list.h>
23 #include <linux/lockdep.h>
24 #include <linux/netdevice.h>
25 #include <linux/skbuff.h>
26 #include <linux/spinlock.h>
27 #include <linux/string.h>
28 #include <linux/tty.h>
29 #include <linux/tty_ldisc.h>
30 #include <linux/version.h>
31 #include <linux/workqueue.h>
33 #include <uapi/linux/tty.h>
35 #include <linux/can.h>
36 #include <linux/can/dev.h>
37 #include <linux/can/error.h>
38 #include <linux/can/rx-offload.h>
40 /* Line discipline ID number.
41 * Starting with Linux v5.18-rc1, N_DEVELOPMENT is defined as 29:
42 * https://github.com/torvalds/linux/commit/c2faf737abfb10f88f2d2612d573e9edc3c42c37
45 #define N_DEVELOPMENT 29
48 /* Compatibility for Linux < 5.11 */
49 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,11,0)
53 #define CAN327_NAPI_WEIGHT 4
55 #define CAN327_SIZE_TXBUF 32
56 #define CAN327_SIZE_RXBUF 1024
58 #define CAN327_CAN_CONFIG_SEND_SFF 0x8000
59 #define CAN327_CAN_CONFIG_VARIABLE_DLC 0x4000
60 #define CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF 0x2000
61 #define CAN327_CAN_CONFIG_BAUDRATE_MULT_8_7 0x1000
63 #define CAN327_DUMMY_CHAR 'y'
64 #define CAN327_DUMMY_STRING "y"
65 #define CAN327_READY_CHAR '>'
67 /* Bits in elm->cmds_todo */
69 CAN327_TX_DO_CAN_DATA = 0,
70 CAN327_TX_DO_CANID_11BIT,
71 CAN327_TX_DO_CANID_29BIT_LOW,
72 CAN327_TX_DO_CANID_29BIT_HIGH,
73 CAN327_TX_DO_CAN_CONFIG_PART2,
74 CAN327_TX_DO_CAN_CONFIG,
75 CAN327_TX_DO_RESPONSES,
76 CAN327_TX_DO_SILENT_MONITOR,
81 /* This must be the first member when using alloc_candev() */
84 struct can_rx_offload offload;
87 u8 txbuf[CAN327_SIZE_TXBUF];
88 u8 rxbuf[CAN327_SIZE_RXBUF];
90 /* Per-channel lock */
93 /* TTY and netdev devices that we're bridging */
94 struct tty_struct *tty;
95 struct net_device *dev;
97 /* TTY buffer accounting */
98 struct work_struct tx_work; /* Flushes TTY TX buffer */
99 u8 *txhead; /* Next TX byte */
100 size_t txleft; /* Bytes left to TX */
101 int rxfill; /* Bytes already RX'd in buffer */
105 CAN327_STATE_NOTINIT = 0,
106 CAN327_STATE_GETDUMMYCHAR,
107 CAN327_STATE_GETPROMPT,
108 CAN327_STATE_RECEIVING,
111 /* Things we have yet to send */
112 char **next_init_cmd;
113 unsigned long cmds_todo;
115 /* The CAN frame and config the ELM327 is sending/using,
116 * or will send/use after finishing all cmds_todo
118 struct can_frame can_frame_to_send;
120 u8 can_bitrate_divisor;
125 /* Stop the channel on UART side hardware failure, e.g. stray
126 * characters or neverending lines. This may be caused by bad
127 * UART wiring, a bad ELM327, a bad UART bridge...
128 * Once this is true, nothing will be sent to the TTY.
130 bool uart_side_failure;
133 static inline void can327_uart_side_failure(struct can327 *elm);
135 static void can327_send(struct can327 *elm, const void *buf, size_t len)
139 lockdep_assert_held(&elm->lock);
141 if (elm->uart_side_failure)
144 memcpy(elm->txbuf, buf, len);
146 /* Order of next two lines is *very* important.
147 * When we are sending a little amount of data,
148 * the transfer may be completed inside the ops->write()
149 * routine, because it's running with interrupts enabled.
150 * In this case we *never* got WRITE_WAKEUP event,
151 * if we did not request it before write operation.
152 * 14 Oct 1994 Dmitry Gorodchanin.
154 set_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
155 written = elm->tty->ops->write(elm->tty, elm->txbuf, len);
157 netdev_err(elm->dev, "Failed to write to tty %s.\n",
159 can327_uart_side_failure(elm);
163 elm->txleft = len - written;
164 elm->txhead = elm->txbuf + written;
167 /* Take the ELM327 out of almost any state and back into command mode.
168 * We send CAN327_DUMMY_CHAR which will either abort any running
169 * operation, or be echoed back to us in case we're already in command
172 static void can327_kick_into_cmd_mode(struct can327 *elm)
174 lockdep_assert_held(&elm->lock);
176 if (elm->state != CAN327_STATE_GETDUMMYCHAR &&
177 elm->state != CAN327_STATE_GETPROMPT) {
178 can327_send(elm, CAN327_DUMMY_STRING, 1);
180 elm->state = CAN327_STATE_GETDUMMYCHAR;
184 /* Schedule a CAN frame and necessary config changes to be sent to the TTY. */
185 static void can327_send_frame(struct can327 *elm, struct can_frame *frame)
187 lockdep_assert_held(&elm->lock);
189 /* Schedule any necessary changes in ELM327's CAN configuration */
190 if (elm->can_frame_to_send.can_id != frame->can_id) {
191 /* Set the new CAN ID for transmission. */
192 if ((frame->can_id ^ elm->can_frame_to_send.can_id)
195 (frame->can_id & CAN_EFF_FLAG ? 0 : CAN327_CAN_CONFIG_SEND_SFF) |
196 CAN327_CAN_CONFIG_VARIABLE_DLC |
197 CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF |
198 elm->can_bitrate_divisor;
200 set_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
203 if (frame->can_id & CAN_EFF_FLAG) {
204 clear_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo);
205 set_bit(CAN327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
206 set_bit(CAN327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo);
208 set_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo);
209 clear_bit(CAN327_TX_DO_CANID_29BIT_LOW,
211 clear_bit(CAN327_TX_DO_CANID_29BIT_HIGH,
216 /* Schedule the CAN frame itself. */
217 elm->can_frame_to_send = *frame;
218 set_bit(CAN327_TX_DO_CAN_DATA, &elm->cmds_todo);
220 can327_kick_into_cmd_mode(elm);
223 /* ELM327 initialisation sequence.
224 * The line length is limited by the buffer in can327_handle_prompt().
226 static char *can327_init_script[] = {
227 "AT WS\r", /* v1.0: Warm Start */
228 "AT PP FF OFF\r", /* v1.0: All Programmable Parameters Off */
229 "AT M0\r", /* v1.0: Memory Off */
230 "AT AL\r", /* v1.0: Allow Long messages */
231 "AT BI\r", /* v1.0: Bypass Initialisation */
232 "AT CAF0\r", /* v1.0: CAN Auto Formatting Off */
233 "AT CFC0\r", /* v1.0: CAN Flow Control Off */
234 "AT CF 000\r", /* v1.0: Reset CAN ID Filter */
235 "AT CM 000\r", /* v1.0: Reset CAN ID Mask */
236 "AT E1\r", /* v1.0: Echo On */
237 "AT H1\r", /* v1.0: Headers On */
238 "AT L0\r", /* v1.0: Linefeeds Off */
239 "AT SH 7DF\r", /* v1.0: Set CAN sending ID to 0x7df */
240 "AT ST FF\r", /* v1.0: Set maximum Timeout for response after TX */
241 "AT AT0\r", /* v1.2: Adaptive Timing Off */
242 "AT D1\r", /* v1.3: Print DLC On */
243 "AT S1\r", /* v1.3: Spaces On */
244 "AT TP B\r", /* v1.0: Try Protocol B */
248 static void can327_init_device(struct can327 *elm)
250 lockdep_assert_held(&elm->lock);
252 elm->state = CAN327_STATE_NOTINIT;
253 elm->can_frame_to_send.can_id = 0x7df; /* ELM327 HW default */
255 elm->drop_next_line = 0;
257 /* We can only set the bitrate as a fraction of 500000.
258 * The bitrates listed in can327_bitrate_const will
259 * limit the user to the right values.
261 elm->can_bitrate_divisor = 500000 / elm->can.bittiming.bitrate;
263 CAN327_CAN_CONFIG_SEND_SFF | CAN327_CAN_CONFIG_VARIABLE_DLC |
264 CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF | elm->can_bitrate_divisor;
266 /* Configure ELM327 and then start monitoring */
267 elm->next_init_cmd = &can327_init_script[0];
268 set_bit(CAN327_TX_DO_INIT, &elm->cmds_todo);
269 set_bit(CAN327_TX_DO_SILENT_MONITOR, &elm->cmds_todo);
270 set_bit(CAN327_TX_DO_RESPONSES, &elm->cmds_todo);
271 set_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
273 can327_kick_into_cmd_mode(elm);
276 static void can327_feed_frame_to_netdev(struct can327 *elm,
279 lockdep_assert_held(&elm->lock);
281 if (!netif_running(elm->dev))
284 /* Queue for NAPI pickup.
285 * rx-offload will update stats and LEDs for us.
287 if (can_rx_offload_queue_tail(&elm->offload, skb))
288 elm->dev->stats.rx_fifo_errors++;
290 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5,15,0)
292 can_rx_offload_irq_finish(&elm->offload);
296 /* Called when we're out of ideas and just want it all to end. */
297 static inline void can327_uart_side_failure(struct can327 *elm)
299 struct can_frame *frame;
302 lockdep_assert_held(&elm->lock);
304 elm->uart_side_failure = true;
306 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
308 elm->can.can_stats.bus_off++;
309 netif_stop_queue(elm->dev);
310 elm->can.state = CAN_STATE_BUS_OFF;
311 can_bus_off(elm->dev);
314 "ELM327 misbehaved. Blocking further communication.\n");
316 skb = alloc_can_err_skb(elm->dev, &frame);
320 frame->can_id |= CAN_ERR_BUSOFF;
321 can327_feed_frame_to_netdev(elm, skb);
324 /* Compares a byte buffer (non-NUL terminated) to the payload part of
325 * a string, and returns true iff the buffer (content *and* length) is
326 * exactly that string, without the terminating NUL byte.
328 * Example: If reference is "BUS ERROR", then this returns true iff nbytes == 9
329 * and !memcmp(buf, "BUS ERROR", 9).
331 * The reason to use strings is so we can easily include them in the C
332 * code, and to avoid hardcoding lengths.
334 static inline bool can327_rxbuf_cmp(const u8 *buf, size_t nbytes,
335 const char *reference)
337 size_t ref_len = strlen(reference);
339 return (nbytes == ref_len) && !memcmp(buf, reference, ref_len);
342 static void can327_parse_error(struct can327 *elm, size_t len)
344 struct can_frame *frame;
347 lockdep_assert_held(&elm->lock);
349 skb = alloc_can_err_skb(elm->dev, &frame);
351 /* It's okay to return here:
352 * The outer parsing loop will drop this UART buffer.
356 /* Filter possible error messages based on length of RX'd line */
357 if (can327_rxbuf_cmp(elm->rxbuf, len, "UNABLE TO CONNECT")) {
359 "ELM327 reported UNABLE TO CONNECT. Please check your setup.\n");
360 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUFFER FULL")) {
361 /* This will only happen if the last data line was complete.
362 * Otherwise, can327_parse_frame() will heuristically
363 * emit this kind of error frame instead.
365 frame->can_id |= CAN_ERR_CRTL;
366 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
367 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUS ERROR")) {
368 frame->can_id |= CAN_ERR_BUSERROR;
369 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "CAN ERROR")) {
370 frame->can_id |= CAN_ERR_PROT;
371 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "<RX ERROR")) {
372 frame->can_id |= CAN_ERR_PROT;
373 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUS BUSY")) {
374 frame->can_id |= CAN_ERR_PROT;
375 frame->data[2] = CAN_ERR_PROT_OVERLOAD;
376 } else if (can327_rxbuf_cmp(elm->rxbuf, len, "FB ERROR")) {
377 frame->can_id |= CAN_ERR_PROT;
378 frame->data[2] = CAN_ERR_PROT_TX;
379 } else if (len == 5 && !memcmp(elm->rxbuf, "ERR", 3)) {
380 /* ERR is followed by two digits, hence line length 5 */
381 netdev_err(elm->dev, "ELM327 reported an ERR%c%c. Please power it off and on again.\n",
382 elm->rxbuf[3], elm->rxbuf[4]);
383 frame->can_id |= CAN_ERR_CRTL;
385 /* Something else has happened.
386 * Maybe garbage on the UART line.
387 * Emit a generic error frame.
391 can327_feed_frame_to_netdev(elm, skb);
394 /* Parse CAN frames coming as ASCII from ELM327.
395 * They can be of various formats:
397 * 29-bit ID (EFF): 12 34 56 78 D PL PL PL PL PL PL PL PL
398 * 11-bit ID (!EFF): 123 D PL PL PL PL PL PL PL PL
400 * where D = DLC, PL = payload byte
402 * Instead of a payload, RTR indicates a remote request.
404 * We will use the spaces and line length to guess the format.
406 static int can327_parse_frame(struct can327 *elm, size_t len)
408 struct can_frame *frame;
414 lockdep_assert_held(&elm->lock);
416 skb = alloc_can_skb(elm->dev, &frame);
420 /* Find first non-hex and non-space character:
421 * - In the simplest case, there is none.
422 * - For RTR frames, 'R' is the first non-hex character.
423 * - An error message may replace the end of the data line.
425 for (hexlen = 0; hexlen <= len; hexlen++) {
426 if (hex_to_bin(elm->rxbuf[hexlen]) < 0 &&
427 elm->rxbuf[hexlen] != ' ') {
432 /* Sanity check whether the line is really a clean hexdump,
433 * or terminated by an error message, or contains garbage.
435 if (hexlen < len && !isdigit(elm->rxbuf[hexlen]) &&
436 !isupper(elm->rxbuf[hexlen]) && '<' != elm->rxbuf[hexlen] &&
437 ' ' != elm->rxbuf[hexlen]) {
438 /* The line is likely garbled anyway, so bail.
439 * The main code will restart listening.
445 /* Use spaces in CAN ID to distinguish 29 or 11 bit address length.
446 * No out-of-bounds access:
447 * We use the fact that we can always read from elm->rxbuf.
449 if (elm->rxbuf[2] == ' ' && elm->rxbuf[5] == ' ' &&
450 elm->rxbuf[8] == ' ' && elm->rxbuf[11] == ' ' &&
451 elm->rxbuf[13] == ' ') {
452 frame->can_id = CAN_EFF_FLAG;
454 } else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') {
457 /* This is not a well-formatted data line.
458 * Assume it's an error message.
464 if (hexlen < datastart) {
465 /* The line is too short to be a valid frame hex dump.
466 * Something interrupted the hex dump or it is invalid.
472 /* From here on all chars up to buf[hexlen] are hex or spaces,
473 * at well-defined offsets.
476 /* Read CAN data length */
477 frame->len = (hex_to_bin(elm->rxbuf[datastart - 2]) << 0);
480 if (frame->can_id & CAN_EFF_FLAG) {
481 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 28) |
482 (hex_to_bin(elm->rxbuf[1]) << 24) |
483 (hex_to_bin(elm->rxbuf[3]) << 20) |
484 (hex_to_bin(elm->rxbuf[4]) << 16) |
485 (hex_to_bin(elm->rxbuf[6]) << 12) |
486 (hex_to_bin(elm->rxbuf[7]) << 8) |
487 (hex_to_bin(elm->rxbuf[9]) << 4) |
488 (hex_to_bin(elm->rxbuf[10]) << 0);
490 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 8) |
491 (hex_to_bin(elm->rxbuf[1]) << 4) |
492 (hex_to_bin(elm->rxbuf[2]) << 0);
495 /* Check for RTR frame */
496 if (elm->rxfill >= hexlen + 3 &&
497 !memcmp(&elm->rxbuf[hexlen], "RTR", 3)) {
498 frame->can_id |= CAN_RTR_FLAG;
501 /* Is the line long enough to hold the advertised payload?
502 * Note: RTR frames have a DLC, but no actual payload.
504 if (!(frame->can_id & CAN_RTR_FLAG) &&
505 (hexlen < frame->len * 3 + datastart)) {
507 * Probably the ELM327's RS232 TX buffer was full.
508 * Emit an error frame and exit.
510 frame->can_id = CAN_ERR_FLAG | CAN_ERR_CRTL;
511 frame->len = CAN_ERR_DLC;
512 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
513 can327_feed_frame_to_netdev(elm, skb);
515 /* Signal failure to parse.
516 * The line will be re-parsed as an error line, which will fail.
517 * However, this will correctly drop the state machine back into
523 /* Parse the data nibbles. */
524 for (i = 0; i < frame->len; i++) {
526 (hex_to_bin(elm->rxbuf[datastart + 3 * i]) << 4) |
527 (hex_to_bin(elm->rxbuf[datastart + 3 * i + 1]));
530 /* Feed the frame to the network layer. */
531 can327_feed_frame_to_netdev(elm, skb);
536 static void can327_parse_line(struct can327 *elm, size_t len)
538 lockdep_assert_held(&elm->lock);
540 /* Skip empty lines */
544 /* Skip echo lines */
545 if (elm->drop_next_line) {
546 elm->drop_next_line = 0;
548 } else if (!memcmp(elm->rxbuf, "AT", 2)) {
552 /* Regular parsing */
553 if (elm->state == CAN327_STATE_RECEIVING &&
554 can327_parse_frame(elm, len)) {
555 /* Parse an error line. */
556 can327_parse_error(elm, len);
559 can327_kick_into_cmd_mode(elm);
563 static void can327_handle_prompt(struct can327 *elm)
565 struct can_frame *frame = &elm->can_frame_to_send;
566 /* Size this buffer for the largest ELM327 line we may generate,
567 * which is currently an 8 byte CAN frame's payload hexdump.
568 * Items in can327_init_script must fit here, too!
570 char local_txbuf[sizeof("0102030405060708\r")];
572 lockdep_assert_held(&elm->lock);
574 if (!elm->cmds_todo) {
575 /* Enter CAN monitor mode */
576 can327_send(elm, "ATMA\r", 5);
577 elm->state = CAN327_STATE_RECEIVING;
579 /* We will be in the default state once this command is
580 * sent, so enable the TX packet queue.
582 netif_wake_queue(elm->dev);
587 /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */
588 if (test_bit(CAN327_TX_DO_INIT, &elm->cmds_todo)) {
589 snprintf(local_txbuf, sizeof(local_txbuf), "%s",
590 *elm->next_init_cmd);
592 elm->next_init_cmd++;
593 if (!(*elm->next_init_cmd)) {
594 clear_bit(CAN327_TX_DO_INIT, &elm->cmds_todo);
598 } else if (test_and_clear_bit(CAN327_TX_DO_SILENT_MONITOR, &elm->cmds_todo)) {
599 snprintf(local_txbuf, sizeof(local_txbuf),
601 !!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
603 } else if (test_and_clear_bit(CAN327_TX_DO_RESPONSES, &elm->cmds_todo)) {
604 snprintf(local_txbuf, sizeof(local_txbuf),
606 !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
608 } else if (test_and_clear_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo)) {
609 snprintf(local_txbuf, sizeof(local_txbuf),
611 set_bit(CAN327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo);
613 } else if (test_and_clear_bit(CAN327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo)) {
614 snprintf(local_txbuf, sizeof(local_txbuf),
618 } else if (test_and_clear_bit(CAN327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo)) {
619 snprintf(local_txbuf, sizeof(local_txbuf),
621 (frame->can_id & CAN_EFF_MASK) >> 24);
623 } else if (test_and_clear_bit(CAN327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo)) {
624 snprintf(local_txbuf, sizeof(local_txbuf),
626 frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1));
628 } else if (test_and_clear_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo)) {
629 snprintf(local_txbuf, sizeof(local_txbuf),
631 frame->can_id & CAN_SFF_MASK);
633 } else if (test_and_clear_bit(CAN327_TX_DO_CAN_DATA, &elm->cmds_todo)) {
634 if (frame->can_id & CAN_RTR_FLAG) {
635 /* Send an RTR frame. Their DLC is fixed.
636 * Some chips don't send them at all.
638 snprintf(local_txbuf, sizeof(local_txbuf), "ATRTR\r");
640 /* Send a regular CAN data frame */
643 for (i = 0; i < frame->len; i++) {
644 snprintf(&local_txbuf[2 * i],
645 sizeof(local_txbuf), "%02X",
649 snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
653 elm->drop_next_line = 1;
654 elm->state = CAN327_STATE_RECEIVING;
656 /* We will be in the default state once this command is
657 * sent, so enable the TX packet queue.
659 netif_wake_queue(elm->dev);
662 can327_send(elm, local_txbuf, strlen(local_txbuf));
665 static bool can327_is_ready_char(char c)
667 /* Bits 0xc0 are sometimes set (randomly), hence the mask.
668 * Probably bad hardware.
670 return (c & 0x3f) == CAN327_READY_CHAR;
673 static void can327_drop_bytes(struct can327 *elm, size_t i)
675 lockdep_assert_held(&elm->lock);
677 memmove(&elm->rxbuf[0], &elm->rxbuf[i], CAN327_SIZE_RXBUF - i);
681 static void can327_parse_rxbuf(struct can327 *elm, size_t first_new_char_idx)
685 lockdep_assert_held(&elm->lock);
687 switch (elm->state) {
688 case CAN327_STATE_NOTINIT:
692 case CAN327_STATE_GETDUMMYCHAR:
693 /* Wait for 'y' or '>' */
694 for (pos = 0; pos < elm->rxfill; pos++) {
695 if (elm->rxbuf[pos] == CAN327_DUMMY_CHAR) {
696 can327_send(elm, "\r", 1);
697 elm->state = CAN327_STATE_GETPROMPT;
700 } else if (can327_is_ready_char(elm->rxbuf[pos])) {
701 can327_send(elm, CAN327_DUMMY_STRING, 1);
707 can327_drop_bytes(elm, pos);
710 case CAN327_STATE_GETPROMPT:
712 if (can327_is_ready_char(elm->rxbuf[elm->rxfill - 1]))
713 can327_handle_prompt(elm);
718 case CAN327_STATE_RECEIVING:
719 /* Find <CR> delimiting feedback lines. */
720 len = first_new_char_idx;
721 while (len < elm->rxfill && elm->rxbuf[len] != '\r')
724 if (len == CAN327_SIZE_RXBUF) {
725 /* Assume the buffer ran full with garbage.
726 * Did we even connect at the right baud rate?
729 "RX buffer overflow. Faulty ELM327 or UART?\n");
730 can327_uart_side_failure(elm);
731 } else if (len == elm->rxfill) {
732 if (can327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) {
733 /* The ELM327's AT ST response timeout ran out,
734 * so we got a prompt.
735 * Clear RX buffer and restart listening.
739 can327_handle_prompt(elm);
742 /* No <CR> found - we haven't received a full line yet.
743 * Wait for more data.
746 /* We have a full line to parse. */
747 can327_parse_line(elm, len);
749 /* Remove parsed data from RX buffer. */
750 can327_drop_bytes(elm, len + 1);
752 /* More data to parse? */
754 can327_parse_rxbuf(elm, 0);
759 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
760 /* Dummy needed to use can_rx_offload
761 * Fixed in v5.10 - 728fc9ff73d3
763 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,5,0)
764 static unsigned int *can327_mailbox_read(struct can_rx_offload *offload,
765 struct can_frame *cf,
766 u32 *timestamp, unsigned int n)
768 WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
772 #else /* Since 4e9c9484b085 (included in v5.5) */
773 static struct sk_buff *can327_mailbox_read(struct can_rx_offload *offload,
774 unsigned int n, u32 *timestamp,
777 WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
779 return ERR_PTR(-ENOBUFS);
784 static int can327_netdev_open(struct net_device *dev)
786 struct can327 *elm = netdev_priv(dev);
789 spin_lock_bh(&elm->lock);
792 spin_unlock_bh(&elm->lock);
796 if (elm->uart_side_failure)
797 netdev_warn(elm->dev,
798 "Reopening netdev after a UART side fault has been detected.\n");
800 /* Clear TTY buffers */
804 /* open_candev() checks for elm->can.bittiming.bitrate != 0 */
805 err = open_candev(dev);
807 spin_unlock_bh(&elm->lock);
811 can327_init_device(elm);
812 spin_unlock_bh(&elm->lock);
814 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
815 elm->offload.mailbox_read = can327_mailbox_read;
816 err = can_rx_offload_add_fifo(dev, &elm->offload, CAN327_NAPI_WEIGHT);
818 /* Fixed in v5.10 - 728fc9ff73d3 */
819 err = can_rx_offload_add_manual(dev, &elm->offload, CAN327_NAPI_WEIGHT);
826 can_rx_offload_enable(&elm->offload);
828 elm->can.state = CAN_STATE_ERROR_ACTIVE;
829 netif_start_queue(dev);
834 static int can327_netdev_close(struct net_device *dev)
836 struct can327 *elm = netdev_priv(dev);
838 /* Interrupt whatever the ELM327 is doing right now */
839 spin_lock_bh(&elm->lock);
840 can327_send(elm, CAN327_DUMMY_STRING, 1);
841 spin_unlock_bh(&elm->lock);
843 netif_stop_queue(dev);
845 /* Give UART one final chance to flush. */
846 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
847 flush_work(&elm->tx_work);
849 can_rx_offload_disable(&elm->offload);
850 elm->can.state = CAN_STATE_STOPPED;
851 can_rx_offload_del(&elm->offload);
857 /* Send a can_frame to a TTY. */
858 static netdev_tx_t can327_netdev_start_xmit(struct sk_buff *skb,
859 struct net_device *dev)
861 struct can327 *elm = netdev_priv(dev);
862 struct can_frame *frame = (struct can_frame *)skb->data;
864 if (can_dropped_invalid_skb(dev, skb))
867 #if LINUX_VERSION_CODE < KERNEL_VERSION(6,0,0)
868 /* Fixed in v6.0 - a6d190f8c767 */
869 if (elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
873 /* We shouldn't get here after a hardware fault:
874 * can_bus_off() calls netif_carrier_off()
876 if (elm->uart_side_failure) {
877 WARN_ON_ONCE(elm->uart_side_failure);
881 netif_stop_queue(dev);
883 /* BHs are already disabled, so no spin_lock_bh().
884 * See Documentation/networking/netdevices.txt
886 spin_lock(&elm->lock);
887 can327_send_frame(elm, frame);
888 spin_unlock(&elm->lock);
890 dev->stats.tx_packets++;
891 dev->stats.tx_bytes += frame->can_id & CAN_RTR_FLAG ? 0 : frame->len;
898 static const struct net_device_ops can327_netdev_ops = {
899 .ndo_open = can327_netdev_open,
900 .ndo_stop = can327_netdev_close,
901 .ndo_start_xmit = can327_netdev_start_xmit,
902 .ndo_change_mtu = can_change_mtu,
905 static bool can327_is_valid_rx_char(u8 c)
907 static const bool lut_char_is_valid['z'] = {
911 ['0'] = true, true, true, true, true,
912 ['5'] = true, true, true, true, true,
914 [CAN327_READY_CHAR] = true,
916 ['A'] = true, true, true, true, true, true, true,
917 ['H'] = true, true, true, true, true, true, true,
918 ['O'] = true, true, true, true, true, true, true,
919 ['V'] = true, true, true, true, true,
923 [CAN327_DUMMY_CHAR] = true,
925 BUILD_BUG_ON(CAN327_DUMMY_CHAR >= 'z');
927 return (c < ARRAY_SIZE(lut_char_is_valid) && lut_char_is_valid[c]);
930 /* Handle incoming ELM327 ASCII data.
931 * This will not be re-entered while running, but other ldisc
932 * functions may be called in parallel.
934 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
935 static void can327_ldisc_rx(struct tty_struct *tty,
936 const unsigned char *cp, char *fp, int count)
938 static void can327_ldisc_rx(struct tty_struct *tty,
939 const unsigned char *cp, const char *fp, int count)
942 struct can327 *elm = (struct can327 *)tty->disc_data;
943 size_t first_new_char_idx;
945 if (elm->uart_side_failure)
948 spin_lock_bh(&elm->lock);
950 /* Store old rxfill, so can327_parse_rxbuf() will have
951 * the option of skipping already checked characters.
953 first_new_char_idx = elm->rxfill;
955 while (count-- && elm->rxfill < CAN327_SIZE_RXBUF) {
958 "Error in received character stream. Check your wiring.");
960 can327_uart_side_failure(elm);
962 spin_unlock_bh(&elm->lock);
966 /* Ignore NUL characters, which the PIC microcontroller may
967 * inadvertently insert due to a known hardware bug.
968 * See ELM327 documentation, which refers to a Microchip PIC
972 /* Check for stray characters on the UART line.
973 * Likely caused by bad hardware.
975 if (!can327_is_valid_rx_char(*cp)) {
977 "Received illegal character %02x.\n",
979 can327_uart_side_failure(elm);
981 spin_unlock_bh(&elm->lock);
985 elm->rxbuf[elm->rxfill++] = *cp;
993 "Receive buffer overflowed. Bad chip or wiring? count = %i",
996 can327_uart_side_failure(elm);
998 spin_unlock_bh(&elm->lock);
1002 can327_parse_rxbuf(elm, first_new_char_idx);
1003 spin_unlock_bh(&elm->lock);
1006 /* Write out remaining transmit buffer.
1007 * Scheduled when TTY is writable.
1009 static void can327_ldisc_tx_worker(struct work_struct *work)
1011 struct can327 *elm = container_of(work, struct can327, tx_work);
1014 if (elm->uart_side_failure)
1017 spin_lock_bh(&elm->lock);
1020 written = elm->tty->ops->write(elm->tty, elm->txhead,
1023 netdev_err(elm->dev, "Failed to write to tty %s.\n",
1025 can327_uart_side_failure(elm);
1027 spin_unlock_bh(&elm->lock);
1031 elm->txleft -= written;
1032 elm->txhead += written;
1036 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
1038 spin_unlock_bh(&elm->lock);
1041 /* Called by the driver when there's room for more data. */
1042 static void can327_ldisc_tx_wakeup(struct tty_struct *tty)
1044 struct can327 *elm = (struct can327 *)tty->disc_data;
1046 schedule_work(&elm->tx_work);
1049 /* ELM327 can only handle bitrates that are integer divisors of 500 kHz,
1050 * or 7/8 of that. Divisors are 1 to 64.
1051 * Currently we don't implement support for 7/8 rates.
1053 static const u32 can327_bitrate_const[] = {
1054 7812, 7936, 8064, 8196, 8333, 8474, 8620, 8771,
1055 8928, 9090, 9259, 9433, 9615, 9803, 10000, 10204,
1056 10416, 10638, 10869, 11111, 11363, 11627, 11904, 12195,
1057 12500, 12820, 13157, 13513, 13888, 14285, 14705, 15151,
1058 15625, 16129, 16666, 17241, 17857, 18518, 19230, 20000,
1059 20833, 21739, 22727, 23809, 25000, 26315, 27777, 29411,
1060 31250, 33333, 35714, 38461, 41666, 45454, 50000, 55555,
1061 62500, 71428, 83333, 100000, 125000, 166666, 250000, 500000
1064 #if LINUX_VERSION_CODE < KERNEL_VERSION(6,0,0)
1065 /* Dummy needed to use bitrate_const
1066 * Fixed in v6.0 - 7e193a42c37c
1068 static int can327_do_set_bittiming(struct net_device *netdev)
1074 static int can327_ldisc_open(struct tty_struct *tty)
1076 struct net_device *dev;
1080 if (!capable(CAP_NET_ADMIN))
1083 if (!tty->ops->write)
1086 dev = alloc_candev(sizeof(struct can327), 0);
1089 elm = netdev_priv(dev);
1091 /* Configure TTY interface */
1092 tty->receive_room = 65536; /* We don't flow control */
1093 spin_lock_init(&elm->lock);
1094 INIT_WORK(&elm->tx_work, can327_ldisc_tx_worker);
1096 /* Configure CAN metadata */
1097 elm->can.bitrate_const = can327_bitrate_const;
1098 elm->can.bitrate_const_cnt = ARRAY_SIZE(can327_bitrate_const);
1099 #if LINUX_VERSION_CODE < KERNEL_VERSION(6,0,0)
1100 /* Fixed in v6.0 - 7e193a42c37c */
1101 elm->can.do_set_bittiming = can327_do_set_bittiming;
1103 elm->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY;
1105 /* Configure netdev interface */
1107 dev->netdev_ops = &can327_netdev_ops;
1109 /* Mark ldisc channel as alive */
1111 tty->disc_data = elm;
1114 err = register_candev(elm->dev);
1116 free_candev(elm->dev);
1120 netdev_info(elm->dev, "can327 on %s.\n", tty->name);
1125 /* Close down a can327 channel.
1126 * This means flushing out any pending queues, and then returning.
1127 * This call is serialized against other ldisc functions:
1128 * Once this is called, no other ldisc function of ours is entered.
1130 * We also use this function for a hangup event.
1132 static void can327_ldisc_close(struct tty_struct *tty)
1134 struct can327 *elm = (struct can327 *)tty->disc_data;
1136 /* unregister_netdev() calls .ndo_stop() so we don't have to.
1137 * Our .ndo_stop() also flushes the TTY write wakeup handler,
1138 * so we can safely set elm->tty = NULL after this.
1140 unregister_candev(elm->dev);
1142 /* Mark channel as dead */
1143 spin_lock_bh(&elm->lock);
1144 tty->disc_data = NULL;
1146 spin_unlock_bh(&elm->lock);
1148 netdev_info(elm->dev, "can327 off %s.\n", tty->name);
1150 free_candev(elm->dev);
1153 static int can327_ldisc_ioctl(struct tty_struct *tty,
1154 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,17,0)
1157 unsigned int cmd, unsigned long arg)
1159 struct can327 *elm = (struct can327 *)tty->disc_data;
1164 tmp = strnlen(elm->dev->name, IFNAMSIZ - 1) + 1;
1165 if (copy_to_user((void __user *)arg, elm->dev->name, tmp))
1173 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
1174 return tty_mode_ioctl(tty, file, cmd, arg);
1176 return tty_mode_ioctl(tty, cmd, arg);
1181 static struct tty_ldisc_ops can327_ldisc = {
1182 .owner = THIS_MODULE,
1184 .num = N_DEVELOPMENT,
1185 .receive_buf = can327_ldisc_rx,
1186 .write_wakeup = can327_ldisc_tx_wakeup,
1187 .open = can327_ldisc_open,
1188 .close = can327_ldisc_close,
1189 .ioctl = can327_ldisc_ioctl,
1192 static int __init can327_init(void)
1196 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1197 status = tty_register_ldisc(N_DEVELOPMENT, &can327_ldisc);
1199 status = tty_register_ldisc(&can327_ldisc);
1202 pr_err("Can't register line discipline\n");
1207 static void __exit can327_exit(void)
1209 /* This will only be called when all channels have been closed by
1210 * userspace - tty_ldisc.c takes care of the module's refcount.
1212 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1215 status = tty_unregister_ldisc(N_DEVELOPMENT);
1217 pr_err("Can't unregister line discipline (error: %d)\n",
1220 tty_unregister_ldisc(&can327_ldisc);
1224 module_init(can327_init);
1225 module_exit(can327_exit);
1227 MODULE_ALIAS_LDISC(N_DEVELOPMENT);
1228 MODULE_DESCRIPTION("ELM327 based CAN interface");
1229 MODULE_LICENSE("GPL");
1230 MODULE_AUTHOR("Max Staudt <max@enpas.org>");