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 ELM327_NAPI_WEIGHT 4
55 #define ELM327_SIZE_TXBUF 32
56 #define ELM327_SIZE_RXBUF 1024
58 #define ELM327_CAN_CONFIG_SEND_SFF 0x8000
59 #define ELM327_CAN_CONFIG_VARIABLE_DLC 0x4000
60 #define ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF 0x2000
61 #define ELM327_CAN_CONFIG_BAUDRATE_MULT_8_7 0x1000
63 #define ELM327_DUMMY_CHAR 'y'
64 #define ELM327_DUMMY_STRING "y"
65 #define ELM327_READY_CHAR '>'
67 /* Bits in elm->cmds_todo */
69 ELM327_TX_DO_CAN_DATA = 0,
70 ELM327_TX_DO_CANID_11BIT,
71 ELM327_TX_DO_CANID_29BIT_LOW,
72 ELM327_TX_DO_CANID_29BIT_HIGH,
73 ELM327_TX_DO_CAN_CONFIG_PART2,
74 ELM327_TX_DO_CAN_CONFIG,
75 ELM327_TX_DO_RESPONSES,
76 ELM327_TX_DO_SILENT_MONITOR,
81 /* This must be the first member when using alloc_candev() */
84 struct can_rx_offload offload;
87 u8 txbuf[ELM327_SIZE_TXBUF];
88 u8 rxbuf[ELM327_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 ELM327_STATE_NOTINIT = 0,
106 ELM327_STATE_GETDUMMYCHAR,
107 ELM327_STATE_GETPROMPT,
108 ELM327_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 elm327_uart_side_failure(struct can327 *elm);
135 static void elm327_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);
158 "Failed to write to tty %s.\n",
160 elm327_uart_side_failure(elm);
164 elm->txleft = len - written;
165 elm->txhead = elm->txbuf + written;
168 /* Take the ELM327 out of almost any state and back into command mode.
169 * We send ELM327_DUMMY_CHAR which will either abort any running
170 * operation, or be echoed back to us in case we're already in command
173 static void elm327_kick_into_cmd_mode(struct can327 *elm)
175 lockdep_assert_held(&elm->lock);
177 if (elm->state != ELM327_STATE_GETDUMMYCHAR &&
178 elm->state != ELM327_STATE_GETPROMPT) {
179 elm327_send(elm, ELM327_DUMMY_STRING, 1);
181 elm->state = ELM327_STATE_GETDUMMYCHAR;
185 /* Schedule a CAN frame and necessary config changes to be sent to the TTY. */
186 static void elm327_send_frame(struct can327 *elm, struct can_frame *frame)
188 lockdep_assert_held(&elm->lock);
190 /* Schedule any necessary changes in ELM327's CAN configuration */
191 if (elm->can_frame_to_send.can_id != frame->can_id) {
192 /* Set the new CAN ID for transmission. */
193 if ((frame->can_id ^ elm->can_frame_to_send.can_id)
195 elm->can_config = (frame->can_id & CAN_EFF_FLAG
197 : ELM327_CAN_CONFIG_SEND_SFF)
198 | ELM327_CAN_CONFIG_VARIABLE_DLC
199 | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF
200 | elm->can_bitrate_divisor;
202 set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
205 if (frame->can_id & CAN_EFF_FLAG) {
206 clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo);
207 set_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
208 set_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo);
210 set_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo);
211 clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
212 clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo);
216 /* Schedule the CAN frame itself. */
217 elm->can_frame_to_send = *frame;
218 set_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo);
220 elm327_kick_into_cmd_mode(elm);
223 /* ELM327 initialisation sequence.
224 * The line length is limited by the buffer in elm327_handle_prompt().
226 static char *elm327_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 elm327_init(struct can327 *elm)
250 lockdep_assert_held(&elm->lock);
252 elm->state = ELM327_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;
262 elm->can_config = ELM327_CAN_CONFIG_SEND_SFF
263 | ELM327_CAN_CONFIG_VARIABLE_DLC
264 | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF
265 | elm->can_bitrate_divisor;
267 /* Configure ELM327 and then start monitoring */
268 elm->next_init_cmd = &elm327_init_script[0];
269 set_bit(ELM327_TX_DO_INIT, &elm->cmds_todo);
270 set_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo);
271 set_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo);
272 set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
274 elm327_kick_into_cmd_mode(elm);
277 static void elm327_feed_frame_to_netdev(struct can327 *elm,
280 lockdep_assert_held(&elm->lock);
282 if (!netif_running(elm->dev))
285 /* Queue for NAPI pickup.
286 * rx-offload will update stats and LEDs for us.
288 if (can_rx_offload_queue_tail(&elm->offload, skb))
289 elm->dev->stats.rx_fifo_errors++;
291 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5,15,0)
293 can_rx_offload_irq_finish(&elm->offload);
297 /* Called when we're out of ideas and just want it all to end. */
298 static inline void elm327_uart_side_failure(struct can327 *elm)
300 struct can_frame *frame;
303 lockdep_assert_held(&elm->lock);
305 elm->uart_side_failure = true;
307 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
309 elm->can.can_stats.bus_off++;
310 netif_stop_queue(elm->dev);
311 elm->can.state = CAN_STATE_BUS_OFF;
312 can_bus_off(elm->dev);
314 netdev_err(elm->dev, "ELM327 misbehaved. Blocking further communication.\n");
316 skb = alloc_can_err_skb(elm->dev, &frame);
320 frame->can_id |= CAN_ERR_BUSOFF;
321 elm327_feed_frame_to_netdev(elm, skb);
324 /* Compares a byte buffer (non-NUL terminated) to the payload part of a string,
325 * and returns true iff the buffer (content *and* length) is exactly that
326 * 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 code,
332 * and to avoid hardcoding lengths.
334 static inline bool elm327_rxbuf_cmp(const u8 *buf, size_t nbytes, const char *reference)
336 size_t ref_len = strlen(reference);
338 return (nbytes == ref_len) && !memcmp(buf, reference, ref_len);
341 static void elm327_parse_error(struct can327 *elm, size_t len)
343 struct can_frame *frame;
346 lockdep_assert_held(&elm->lock);
348 skb = alloc_can_err_skb(elm->dev, &frame);
350 /* It's okay to return here:
351 * The outer parsing loop will drop this UART buffer.
355 /* Filter possible error messages based on length of RX'd line */
356 if (elm327_rxbuf_cmp(elm->rxbuf, len, "UNABLE TO CONNECT")) {
358 "ELM327 reported UNABLE TO CONNECT. Please check your setup.\n");
359 } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "BUFFER FULL")) {
360 /* This will only happen if the last data line was complete.
361 * Otherwise, elm327_parse_frame() will heuristically
362 * emit this kind of error frame instead.
364 frame->can_id |= CAN_ERR_CRTL;
365 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
366 } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "BUS ERROR")) {
367 frame->can_id |= CAN_ERR_BUSERROR;
368 } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "CAN ERROR")) {
369 frame->can_id |= CAN_ERR_PROT;
370 } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "<RX ERROR")) {
371 frame->can_id |= CAN_ERR_PROT;
372 } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "BUS BUSY")) {
373 frame->can_id |= CAN_ERR_PROT;
374 frame->data[2] = CAN_ERR_PROT_OVERLOAD;
375 } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "FB ERROR")) {
376 frame->can_id |= CAN_ERR_PROT;
377 frame->data[2] = CAN_ERR_PROT_TX;
378 } else if (len == 5 && !memcmp(elm->rxbuf, "ERR", 3)) {
379 /* ERR is followed by two digits, hence line length 5 */
380 netdev_err(elm->dev, "ELM327 reported an ERR%c%c. Please power it off and on again.\n",
381 elm->rxbuf[3], elm->rxbuf[4]);
382 frame->can_id |= CAN_ERR_CRTL;
384 /* Something else has happened.
385 * Maybe garbage on the UART line.
386 * Emit a generic error frame.
390 elm327_feed_frame_to_netdev(elm, skb);
393 /* Parse CAN frames coming as ASCII from ELM327.
394 * They can be of various formats:
396 * 29-bit ID (EFF): 12 34 56 78 D PL PL PL PL PL PL PL PL
397 * 11-bit ID (!EFF): 123 D PL PL PL PL PL PL PL PL
399 * where D = DLC, PL = payload byte
401 * Instead of a payload, RTR indicates a remote request.
403 * We will use the spaces and line length to guess the format.
405 static int elm327_parse_frame(struct can327 *elm, size_t len)
407 struct can_frame *frame;
413 lockdep_assert_held(&elm->lock);
415 skb = alloc_can_skb(elm->dev, &frame);
419 /* Find first non-hex and non-space character:
420 * - In the simplest case, there is none.
421 * - For RTR frames, 'R' is the first non-hex character.
422 * - An error message may replace the end of the data line.
424 for (hexlen = 0; hexlen <= len; hexlen++) {
425 if (hex_to_bin(elm->rxbuf[hexlen]) < 0 &&
426 elm->rxbuf[hexlen] != ' ') {
431 /* Sanity check whether the line is really a clean hexdump,
432 * or terminated by an error message, or contains garbage.
435 !isdigit(elm->rxbuf[hexlen]) &&
436 !isupper(elm->rxbuf[hexlen]) &&
437 '<' != elm->rxbuf[hexlen] &&
438 ' ' != elm->rxbuf[hexlen]) {
439 /* The line is likely garbled anyway, so bail.
440 * The main code will restart listening.
446 /* Use spaces in CAN ID to distinguish 29 or 11 bit address length.
447 * No out-of-bounds access:
448 * We use the fact that we can always read from elm->rxbuf.
450 if (elm->rxbuf[2] == ' ' && elm->rxbuf[5] == ' ' &&
451 elm->rxbuf[8] == ' ' && elm->rxbuf[11] == ' ' &&
452 elm->rxbuf[13] == ' ') {
453 frame->can_id = CAN_EFF_FLAG;
455 } else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') {
458 /* This is not a well-formatted data line.
459 * Assume it's an error message.
465 if (hexlen < datastart) {
466 /* The line is too short to be a valid frame hex dump.
467 * Something interrupted the hex dump or it is invalid.
473 /* From here on all chars up to buf[hexlen] are hex or spaces,
474 * at well-defined offsets.
477 /* Read CAN data length */
478 frame->len = (hex_to_bin(elm->rxbuf[datastart - 2]) << 0);
481 if (frame->can_id & CAN_EFF_FLAG) {
482 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 28)
483 | (hex_to_bin(elm->rxbuf[1]) << 24)
484 | (hex_to_bin(elm->rxbuf[3]) << 20)
485 | (hex_to_bin(elm->rxbuf[4]) << 16)
486 | (hex_to_bin(elm->rxbuf[6]) << 12)
487 | (hex_to_bin(elm->rxbuf[7]) << 8)
488 | (hex_to_bin(elm->rxbuf[9]) << 4)
489 | (hex_to_bin(elm->rxbuf[10]) << 0);
491 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 8)
492 | (hex_to_bin(elm->rxbuf[1]) << 4)
493 | (hex_to_bin(elm->rxbuf[2]) << 0);
496 /* Check for RTR frame */
497 if (elm->rxfill >= hexlen + 3 &&
498 !memcmp(&elm->rxbuf[hexlen], "RTR", 3)) {
499 frame->can_id |= CAN_RTR_FLAG;
502 /* Is the line long enough to hold the advertised payload?
503 * Note: RTR frames have a DLC, but no actual payload.
505 if (!(frame->can_id & CAN_RTR_FLAG) &&
506 (hexlen < frame->len * 3 + datastart)) {
508 * Probably the ELM327's RS232 TX buffer was full.
509 * Emit an error frame and exit.
511 frame->can_id = CAN_ERR_FLAG | CAN_ERR_CRTL;
512 frame->len = CAN_ERR_DLC;
513 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
514 elm327_feed_frame_to_netdev(elm, skb);
516 /* Signal failure to parse.
517 * The line will be re-parsed as an error line, which will fail.
518 * However, this will correctly drop the state machine back into
525 /* Parse the data nibbles. */
526 for (i = 0; i < frame->len; i++) {
527 frame->data[i] = (hex_to_bin(elm->rxbuf[datastart + 3*i]) << 4)
528 | (hex_to_bin(elm->rxbuf[datastart + 3*i + 1]));
531 /* Feed the frame to the network layer. */
532 elm327_feed_frame_to_netdev(elm, skb);
537 static void elm327_parse_line(struct can327 *elm, size_t len)
539 lockdep_assert_held(&elm->lock);
541 /* Skip empty lines */
545 /* Skip echo lines */
546 if (elm->drop_next_line) {
547 elm->drop_next_line = 0;
549 } else if (!memcmp(elm->rxbuf, "AT", 2)) {
553 /* Regular parsing */
554 if (elm->state == ELM327_STATE_RECEIVING &&
555 elm327_parse_frame(elm, len)) {
556 /* Parse an error line. */
557 elm327_parse_error(elm, len);
560 elm327_kick_into_cmd_mode(elm);
564 static void elm327_handle_prompt(struct can327 *elm)
566 struct can_frame *frame = &elm->can_frame_to_send;
567 /* Size this buffer for the largest ELM327 line we may generate,
568 * which is currently an 8 byte CAN frame's payload hexdump.
569 * Items in elm327_init_script must fit here, too!
571 char local_txbuf[sizeof("0102030405060708\r")];
573 lockdep_assert_held(&elm->lock);
575 if (!elm->cmds_todo) {
576 /* Enter CAN monitor mode */
577 elm327_send(elm, "ATMA\r", 5);
578 elm->state = ELM327_STATE_RECEIVING;
580 /* We will be in the default state once this command is
581 * sent, so enable the TX packet queue.
583 netif_wake_queue(elm->dev);
588 /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */
589 if (test_bit(ELM327_TX_DO_INIT, &elm->cmds_todo)) {
590 snprintf(local_txbuf, sizeof(local_txbuf),
592 *elm->next_init_cmd);
594 elm->next_init_cmd++;
595 if (!(*elm->next_init_cmd)) {
596 clear_bit(ELM327_TX_DO_INIT, &elm->cmds_todo);
600 } else if (test_and_clear_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo)) {
601 snprintf(local_txbuf, sizeof(local_txbuf),
603 !!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
605 } else if (test_and_clear_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo)) {
606 snprintf(local_txbuf, sizeof(local_txbuf),
608 !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
610 } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo)) {
611 snprintf(local_txbuf, sizeof(local_txbuf),
613 set_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo);
615 } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo)) {
616 snprintf(local_txbuf, sizeof(local_txbuf),
620 } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo)) {
621 snprintf(local_txbuf, sizeof(local_txbuf),
623 (frame->can_id & CAN_EFF_MASK) >> 24);
625 } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo)) {
626 snprintf(local_txbuf, sizeof(local_txbuf),
628 frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1));
630 } else if (test_and_clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo)) {
631 snprintf(local_txbuf, sizeof(local_txbuf),
633 frame->can_id & CAN_SFF_MASK);
635 } else if (test_and_clear_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo)) {
636 if (frame->can_id & CAN_RTR_FLAG) {
637 /* Send an RTR frame. Their DLC is fixed.
638 * Some chips don't send them at all.
640 snprintf(local_txbuf, sizeof(local_txbuf),
643 /* Send a regular CAN data frame */
646 for (i = 0; i < frame->len; i++) {
647 snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
652 snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
656 elm->drop_next_line = 1;
657 elm->state = ELM327_STATE_RECEIVING;
659 /* We will be in the default state once this command is
660 * sent, so enable the TX packet queue.
662 netif_wake_queue(elm->dev);
665 elm327_send(elm, local_txbuf, strlen(local_txbuf));
668 static bool elm327_is_ready_char(char c)
670 /* Bits 0xc0 are sometimes set (randomly), hence the mask.
671 * Probably bad hardware.
673 return (c & 0x3f) == ELM327_READY_CHAR;
676 static void elm327_drop_bytes(struct can327 *elm, size_t i)
678 lockdep_assert_held(&elm->lock);
680 memmove(&elm->rxbuf[0], &elm->rxbuf[i], ELM327_SIZE_RXBUF - i);
684 static void elm327_parse_rxbuf(struct can327 *elm, size_t first_new_char_idx)
688 lockdep_assert_held(&elm->lock);
690 switch (elm->state) {
691 case ELM327_STATE_NOTINIT:
695 case ELM327_STATE_GETDUMMYCHAR:
696 /* Wait for 'y' or '>' */
697 for (pos = 0; pos < elm->rxfill; pos++) {
698 if (elm->rxbuf[pos] == ELM327_DUMMY_CHAR) {
699 elm327_send(elm, "\r", 1);
700 elm->state = ELM327_STATE_GETPROMPT;
703 } else if (elm327_is_ready_char(elm->rxbuf[pos])) {
704 elm327_send(elm, ELM327_DUMMY_STRING, 1);
710 elm327_drop_bytes(elm, pos);
713 case ELM327_STATE_GETPROMPT:
715 if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1]))
716 elm327_handle_prompt(elm);
721 case ELM327_STATE_RECEIVING:
722 /* Find <CR> delimiting feedback lines. */
723 len = first_new_char_idx;
724 while (len < elm->rxfill && elm->rxbuf[len] != '\r')
727 if (len == ELM327_SIZE_RXBUF) {
728 /* Assume the buffer ran full with garbage.
729 * Did we even connect at the right baud rate?
732 "RX buffer overflow. Faulty ELM327 or UART?\n");
733 elm327_uart_side_failure(elm);
734 } else if (len == elm->rxfill) {
735 if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) {
736 /* The ELM327's AT ST response timeout ran out,
737 * so we got a prompt.
738 * Clear RX buffer and restart listening.
742 elm327_handle_prompt(elm);
745 /* No <CR> found - we haven't received a full line yet.
746 * Wait for more data.
749 /* We have a full line to parse. */
750 elm327_parse_line(elm, len);
752 /* Remove parsed data from RX buffer. */
753 elm327_drop_bytes(elm, len + 1);
755 /* More data to parse? */
757 elm327_parse_rxbuf(elm, 0);
762 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
763 /* Dummy needed to use can_rx_offload */
764 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,5,0)
765 static unsigned int *can327_mailbox_read(struct can_rx_offload *offload,
766 struct can_frame *cf,
767 u32 *timestamp, unsigned int n)
769 WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
773 #else /* Since 4e9c9484b085 (included in v5.5) */
774 static struct sk_buff *can327_mailbox_read(struct can_rx_offload *offload,
775 unsigned int n, u32 *timestamp,
778 WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
780 return ERR_PTR(-ENOBUFS);
785 static int can327_netdev_open(struct net_device *dev)
787 struct can327 *elm = netdev_priv(dev);
790 spin_lock_bh(&elm->lock);
793 spin_unlock_bh(&elm->lock);
797 if (elm->uart_side_failure)
798 netdev_warn(elm->dev, "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);
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, ELM327_NAPI_WEIGHT);
818 err = can_rx_offload_add_manual(dev, &elm->offload, ELM327_NAPI_WEIGHT);
825 can_rx_offload_enable(&elm->offload);
827 elm->can.state = CAN_STATE_ERROR_ACTIVE;
828 netif_start_queue(dev);
833 static int can327_netdev_close(struct net_device *dev)
835 struct can327 *elm = netdev_priv(dev);
837 /* Interrupt whatever the ELM327 is doing right now */
838 spin_lock_bh(&elm->lock);
839 elm327_send(elm, ELM327_DUMMY_STRING, 1);
840 spin_unlock_bh(&elm->lock);
842 netif_stop_queue(dev);
844 /* Give UART one final chance to flush. */
845 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
846 flush_work(&elm->tx_work);
848 can_rx_offload_disable(&elm->offload);
849 elm->can.state = CAN_STATE_STOPPED;
850 can_rx_offload_del(&elm->offload);
856 /* Send a can_frame to a TTY. */
857 static netdev_tx_t can327_netdev_start_xmit(struct sk_buff *skb,
858 struct net_device *dev)
860 struct can327 *elm = netdev_priv(dev);
861 struct can_frame *frame = (struct can_frame *)skb->data;
863 if (can_dropped_invalid_skb(dev, skb))
866 /* This check will be part of can_dropped_invalid_skb()
869 if (elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
872 /* We shouldn't get here after a hardware fault:
873 * can_bus_off() calls netif_carrier_off()
875 if (elm->uart_side_failure) {
876 WARN_ON_ONCE(elm->uart_side_failure);
880 netif_stop_queue(dev);
882 /* BHs are already disabled, so no spin_lock_bh().
883 * See Documentation/networking/netdevices.txt
885 spin_lock(&elm->lock);
886 elm327_send_frame(elm, frame);
887 spin_unlock(&elm->lock);
889 dev->stats.tx_packets++;
890 dev->stats.tx_bytes += frame->len;
897 static const struct net_device_ops can327_netdev_ops = {
898 .ndo_open = can327_netdev_open,
899 .ndo_stop = can327_netdev_close,
900 .ndo_start_xmit = can327_netdev_start_xmit,
901 .ndo_change_mtu = can_change_mtu,
904 static bool can327_is_valid_rx_char(u8 c)
906 static const bool lut_char_is_valid['z'] = {
910 ['0'] = true, true, true, true, true,
911 ['5'] = true, true, true, true, true,
913 [ELM327_READY_CHAR] = true,
915 ['A'] = true, true, true, true, true, true, true,
916 ['H'] = true, true, true, true, true, true, true,
917 ['O'] = true, true, true, true, true, true, true,
918 ['V'] = true, true, true, true, true,
922 [ELM327_DUMMY_CHAR] = true,
924 BUILD_BUG_ON(ELM327_DUMMY_CHAR >= 'z');
926 return (c < ARRAY_SIZE(lut_char_is_valid) &&
927 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 elm327_parse_rxbuf() will have
951 * the option of skipping already checked characters.
953 first_new_char_idx = elm->rxfill;
955 while (count-- && elm->rxfill < ELM327_SIZE_RXBUF) {
957 netdev_err(elm->dev, "Error in received character stream. Check your wiring.");
959 elm327_uart_side_failure(elm);
961 spin_unlock_bh(&elm->lock);
965 /* Ignore NUL characters, which the PIC microcontroller may
966 * inadvertently insert due to a known hardware bug.
967 * See ELM327 documentation, which refers to a Microchip PIC
971 /* Check for stray characters on the UART line.
972 * Likely caused by bad hardware.
974 if (!can327_is_valid_rx_char(*cp)) {
976 "Received illegal character %02x.\n",
978 elm327_uart_side_failure(elm);
980 spin_unlock_bh(&elm->lock);
984 elm->rxbuf[elm->rxfill++] = *cp;
991 netdev_err(elm->dev, "Receive buffer overflowed. Bad chip or wiring? count = %i", count);
993 elm327_uart_side_failure(elm);
995 spin_unlock_bh(&elm->lock);
999 elm327_parse_rxbuf(elm, first_new_char_idx);
1000 spin_unlock_bh(&elm->lock);
1003 /* Write out remaining transmit buffer.
1004 * Scheduled when TTY is writable.
1006 static void can327_ldisc_tx_worker(struct work_struct *work)
1008 struct can327 *elm = container_of(work, struct can327, tx_work);
1011 if (elm->uart_side_failure)
1014 spin_lock_bh(&elm->lock);
1017 written = elm->tty->ops->write(elm->tty, elm->txhead, elm->txleft);
1019 netdev_err(elm->dev,
1020 "Failed to write to tty %s.\n",
1022 elm327_uart_side_failure(elm);
1024 spin_unlock_bh(&elm->lock);
1028 elm->txleft -= written;
1029 elm->txhead += written;
1033 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
1035 spin_unlock_bh(&elm->lock);
1038 /* Called by the driver when there's room for more data. */
1039 static void can327_ldisc_tx_wakeup(struct tty_struct *tty)
1041 struct can327 *elm = (struct can327 *)tty->disc_data;
1043 schedule_work(&elm->tx_work);
1046 /* ELM327 can only handle bitrates that are integer divisors of 500 kHz,
1047 * or 7/8 of that. Divisors are 1 to 64.
1048 * Currently we don't implement support for 7/8 rates.
1050 static const u32 can327_bitrate_const[] = {
1051 7812, 7936, 8064, 8196, 8333, 8474, 8620, 8771,
1052 8928, 9090, 9259, 9433, 9615, 9803, 10000, 10204,
1053 10416, 10638, 10869, 11111, 11363, 11627, 11904, 12195,
1054 12500, 12820, 13157, 13513, 13888, 14285, 14705, 15151,
1055 15625, 16129, 16666, 17241, 17857, 18518, 19230, 20000,
1056 20833, 21739, 22727, 23809, 25000, 26315, 27777, 29411,
1057 31250, 33333, 35714, 38461, 41666, 45454, 50000, 55555,
1058 62500, 71428, 83333, 100000, 125000, 166666, 250000, 500000
1061 /* Dummy needed to use bitrate_const */
1062 static int can327_do_set_bittiming(struct net_device *netdev)
1067 static int can327_ldisc_open(struct tty_struct *tty)
1069 struct net_device *dev;
1073 if (!capable(CAP_NET_ADMIN))
1076 if (!tty->ops->write)
1079 dev = alloc_candev(sizeof(struct can327), 0);
1082 elm = netdev_priv(dev);
1084 /* Configure TTY interface */
1085 tty->receive_room = 65536; /* We don't flow control */
1086 spin_lock_init(&elm->lock);
1087 INIT_WORK(&elm->tx_work, can327_ldisc_tx_worker);
1089 /* Configure CAN metadata */
1090 elm->can.bitrate_const = can327_bitrate_const;
1091 elm->can.bitrate_const_cnt = ARRAY_SIZE(can327_bitrate_const);
1092 elm->can.do_set_bittiming = can327_do_set_bittiming;
1093 elm->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY;
1095 /* Configure netdev interface */
1097 dev->netdev_ops = &can327_netdev_ops;
1099 /* Mark ldisc channel as alive */
1101 tty->disc_data = elm;
1104 err = register_candev(elm->dev);
1106 free_candev(elm->dev);
1110 netdev_info(elm->dev, "can327 on %s.\n", tty->name);
1115 /* Close down a can327 channel.
1116 * This means flushing out any pending queues, and then returning.
1117 * This call is serialized against other ldisc functions:
1118 * Once this is called, no other ldisc function of ours is entered.
1120 * We also use this function for a hangup event.
1122 static void can327_ldisc_close(struct tty_struct *tty)
1124 struct can327 *elm = (struct can327 *)tty->disc_data;
1126 /* unregister_netdev() calls .ndo_stop() so we don't have to.
1127 * Our .ndo_stop() also flushes the TTY write wakeup handler,
1128 * so we can safely set elm->tty = NULL after this.
1130 unregister_candev(elm->dev);
1132 /* Mark channel as dead */
1133 spin_lock_bh(&elm->lock);
1134 tty->disc_data = NULL;
1136 spin_unlock_bh(&elm->lock);
1138 netdev_info(elm->dev, "can327 off %s.\n", tty->name);
1140 free_candev(elm->dev);
1143 static int can327_ldisc_ioctl(struct tty_struct *tty,
1144 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,17,0)
1147 unsigned int cmd, unsigned long arg)
1149 struct can327 *elm = (struct can327 *)tty->disc_data;
1154 tmp = strnlen(elm->dev->name, IFNAMSIZ - 1) + 1;
1155 if (copy_to_user((void __user *)arg, elm->dev->name, tmp))
1163 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
1164 return tty_mode_ioctl(tty, file, cmd, arg);
1166 return tty_mode_ioctl(tty, cmd, arg);
1171 static struct tty_ldisc_ops can327_ldisc = {
1172 .owner = THIS_MODULE,
1174 .num = N_DEVELOPMENT,
1175 .receive_buf = can327_ldisc_rx,
1176 .write_wakeup = can327_ldisc_tx_wakeup,
1177 .open = can327_ldisc_open,
1178 .close = can327_ldisc_close,
1179 .ioctl = can327_ldisc_ioctl,
1182 static int __init can327_init(void)
1186 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1187 status = tty_register_ldisc(N_DEVELOPMENT, &can327_ldisc);
1189 status = tty_register_ldisc(&can327_ldisc);
1192 pr_err("Can't register line discipline\n");
1197 static void __exit can327_exit(void)
1199 /* This will only be called when all channels have been closed by
1200 * userspace - tty_ldisc.c takes care of the module's refcount.
1202 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1205 status = tty_unregister_ldisc(N_DEVELOPMENT);
1207 pr_err("Can't unregister line discipline (error: %d)\n",
1210 tty_unregister_ldisc(&can327_ldisc);
1214 module_init(can327_init);
1215 module_exit(can327_exit);
1217 MODULE_ALIAS_LDISC(N_DEVELOPMENT);
1218 MODULE_DESCRIPTION("ELM327 based CAN interface");
1219 MODULE_LICENSE("GPL");
1220 MODULE_AUTHOR("Max Staudt <max-linux@enpas.org>");