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/led.h>
39 #include <linux/can/rx-offload.h>
41 /* Line discipline ID number.
42 * Starting with Linux v5.18-rc1, N_DEVELOPMENT is defined as 29:
43 * https://github.com/torvalds/linux/commit/c2faf737abfb10f88f2d2612d573e9edc3c42c37
46 #define N_DEVELOPMENT 29
49 /* Compatibility for Linux < 5.11 */
50 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,11,0)
54 #define ELM327_NAPI_WEIGHT 4
56 #define ELM327_SIZE_RXBUF 992
57 #define ELM327_SIZE_TXBUF 32
59 #define ELM327_CAN_CONFIG_SEND_SFF 0x8000
60 #define ELM327_CAN_CONFIG_VARIABLE_DLC 0x4000
61 #define ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF 0x2000
62 #define ELM327_CAN_CONFIG_BAUDRATE_MULT_8_7 0x1000
64 #define ELM327_DUMMY_CHAR 'y'
65 #define ELM327_DUMMY_STRING "y"
66 #define ELM327_READY_CHAR '>'
68 /* Bits in elm->cmds_todo */
70 ELM327_TX_DO_CAN_DATA = 0,
71 ELM327_TX_DO_CANID_11BIT,
72 ELM327_TX_DO_CANID_29BIT_LOW,
73 ELM327_TX_DO_CANID_29BIT_HIGH,
74 ELM327_TX_DO_CAN_CONFIG_PART2,
75 ELM327_TX_DO_CAN_CONFIG,
76 ELM327_TX_DO_RESPONSES,
77 ELM327_TX_DO_SILENT_MONITOR,
82 /* This must be the first member when using alloc_candev() */
85 struct can_rx_offload offload;
88 u8 rxbuf[ELM327_SIZE_RXBUF];
89 u8 txbuf[ELM327_SIZE_TXBUF];
91 /* Per-channel lock */
94 /* TTY and netdev devices that we're bridging */
95 struct tty_struct *tty;
96 struct net_device *dev;
98 /* TTY buffer accounting */
99 struct work_struct tx_work; /* Flushes TTY TX buffer */
100 u8 *txhead; /* Next TX byte */
101 size_t txleft; /* Bytes left to TX */
102 int rxfill; /* Bytes already RX'd in buffer */
106 ELM327_STATE_NOTINIT = 0,
107 ELM327_STATE_GETDUMMYCHAR,
108 ELM327_STATE_GETPROMPT,
109 ELM327_STATE_RECEIVING,
112 /* Things we have yet to send */
113 char **next_init_cmd;
114 unsigned long cmds_todo;
116 /* The CAN frame and config the ELM327 is sending/using,
117 * or will send/use after finishing all cmds_todo
119 struct can_frame can_frame_to_send;
121 u8 can_bitrate_divisor;
126 /* Stop the channel on UART side hardware failure, e.g. stray
127 * characters or neverending lines. This may be caused by bad
128 * UART wiring, a bad ELM327, a bad UART bridge...
129 * Once this is true, nothing will be sent to the TTY.
131 bool uart_side_failure;
134 static inline void elm327_uart_side_failure(struct can327 *elm);
136 static void elm327_send(struct can327 *elm, const void *buf, size_t len)
140 lockdep_assert_held(&elm->lock);
142 if (elm->uart_side_failure)
145 memcpy(elm->txbuf, buf, len);
147 /* Order of next two lines is *very* important.
148 * When we are sending a little amount of data,
149 * the transfer may be completed inside the ops->write()
150 * routine, because it's running with interrupts enabled.
151 * In this case we *never* got WRITE_WAKEUP event,
152 * if we did not request it before write operation.
153 * 14 Oct 1994 Dmitry Gorodchanin.
155 set_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
156 written = elm->tty->ops->write(elm->tty, elm->txbuf, len);
159 "Failed to write to tty %s.\n",
161 elm327_uart_side_failure(elm);
165 elm->txleft = len - written;
166 elm->txhead = elm->txbuf + written;
169 /* Take the ELM327 out of almost any state and back into command mode.
170 * We send ELM327_DUMMY_CHAR which will either abort any running
171 * operation, or be echoed back to us in case we're already in command
174 static void elm327_kick_into_cmd_mode(struct can327 *elm)
176 lockdep_assert_held(&elm->lock);
178 if (elm->state != ELM327_STATE_GETDUMMYCHAR &&
179 elm->state != ELM327_STATE_GETPROMPT) {
180 elm327_send(elm, ELM327_DUMMY_STRING, 1);
182 elm->state = ELM327_STATE_GETDUMMYCHAR;
186 /* Schedule a CAN frame and necessary config changes to be sent to the TTY. */
187 static void elm327_send_frame(struct can327 *elm, struct can_frame *frame)
189 lockdep_assert_held(&elm->lock);
191 /* Schedule any necessary changes in ELM327's CAN configuration */
192 if (elm->can_frame_to_send.can_id != frame->can_id) {
193 /* Set the new CAN ID for transmission. */
194 if ((frame->can_id ^ elm->can_frame_to_send.can_id)
196 elm->can_config = (frame->can_id & CAN_EFF_FLAG
198 : ELM327_CAN_CONFIG_SEND_SFF)
199 | ELM327_CAN_CONFIG_VARIABLE_DLC
200 | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF
201 | elm->can_bitrate_divisor;
203 set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
206 if (frame->can_id & CAN_EFF_FLAG) {
207 clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo);
208 set_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
209 set_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo);
211 set_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo);
212 clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
213 clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo);
217 /* Schedule the CAN frame itself. */
218 elm->can_frame_to_send = *frame;
219 set_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo);
221 elm327_kick_into_cmd_mode(elm);
224 /* ELM327 initialisation sequence.
225 * The line length is limited by the buffer in elm327_handle_prompt().
227 static char *elm327_init_script[] = {
228 "AT WS\r", /* v1.0: Warm Start */
229 "AT PP FF OFF\r", /* v1.0: All Programmable Parameters Off */
230 "AT M0\r", /* v1.0: Memory Off */
231 "AT AL\r", /* v1.0: Allow Long messages */
232 "AT BI\r", /* v1.0: Bypass Initialisation */
233 "AT CAF0\r", /* v1.0: CAN Auto Formatting Off */
234 "AT CFC0\r", /* v1.0: CAN Flow Control Off */
235 "AT CF 000\r", /* v1.0: Reset CAN ID Filter */
236 "AT CM 000\r", /* v1.0: Reset CAN ID Mask */
237 "AT E1\r", /* v1.0: Echo On */
238 "AT H1\r", /* v1.0: Headers On */
239 "AT L0\r", /* v1.0: Linefeeds Off */
240 "AT SH 7DF\r", /* v1.0: Set CAN sending ID to 0x7df */
241 "AT ST FF\r", /* v1.0: Set maximum Timeout for response after TX */
242 "AT AT0\r", /* v1.2: Adaptive Timing Off */
243 "AT D1\r", /* v1.3: Print DLC On */
244 "AT S1\r", /* v1.3: Spaces On */
245 "AT TP B\r", /* v1.0: Try Protocol B */
249 static void elm327_init(struct can327 *elm)
251 lockdep_assert_held(&elm->lock);
253 elm->state = ELM327_STATE_NOTINIT;
254 elm->can_frame_to_send.can_id = 0x7df; /* ELM327 HW default */
256 elm->drop_next_line = 0;
258 /* We can only set the bitrate as a fraction of 500000.
259 * The bit timing constants in can327_bittiming_const will
260 * limit the user to the right values.
262 elm->can_bitrate_divisor = 500000 / elm->can.bittiming.bitrate;
263 elm->can_config = ELM327_CAN_CONFIG_SEND_SFF
264 | ELM327_CAN_CONFIG_VARIABLE_DLC
265 | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF
266 | elm->can_bitrate_divisor;
268 /* Configure ELM327 and then start monitoring */
269 elm->next_init_cmd = &elm327_init_script[0];
270 set_bit(ELM327_TX_DO_INIT, &elm->cmds_todo);
271 set_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo);
272 set_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo);
273 set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
275 elm327_kick_into_cmd_mode(elm);
278 static void elm327_feed_frame_to_netdev(struct can327 *elm,
281 lockdep_assert_held(&elm->lock);
283 if (!netif_running(elm->dev))
286 /* Queue for NAPI pickup.
287 * rx-offload will update stats and LEDs for us.
289 if (can_rx_offload_queue_tail(&elm->offload, skb))
290 elm->dev->stats.rx_fifo_errors++;
292 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5,15,0)
294 can_rx_offload_irq_finish(&elm->offload);
298 /* Called when we're out of ideas and just want it all to end. */
299 static inline void elm327_uart_side_failure(struct can327 *elm)
301 struct can_frame *frame;
304 lockdep_assert_held(&elm->lock);
306 elm->uart_side_failure = true;
308 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
310 elm->can.can_stats.bus_off++;
311 netif_stop_queue(elm->dev);
312 elm->can.state = CAN_STATE_BUS_OFF;
313 can_bus_off(elm->dev);
315 netdev_err(elm->dev, "ELM327 misbehaved. Blocking further communication.\n");
317 skb = alloc_can_err_skb(elm->dev, &frame);
321 frame->can_id |= CAN_ERR_BUSOFF;
322 elm327_feed_frame_to_netdev(elm, skb);
325 /* Compares a byte buffer (non-NUL terminated) to the payload part of a string,
326 * and returns true iff the buffer (content *and* length) is exactly that
327 * string, without the terminating NUL byte.
329 * Example: If reference is "BUS ERROR", then this returns true iff nbytes == 9
330 * and !memcmp(buf, "BUS ERROR", 9).
332 * The reason to use strings is so we can easily include them in the C code,
333 * and to avoid hardcoding lengths.
335 static inline bool elm327_rxbuf_cmp(const u8 *buf, size_t nbytes, const char *reference)
337 size_t ref_len = strlen(reference);
339 return (nbytes == ref_len) && !memcmp(buf, reference, ref_len);
342 static void elm327_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 (elm327_rxbuf_cmp(elm->rxbuf, len, "UNABLE TO CONNECT")) {
359 "ELM327 reported UNABLE TO CONNECT. Please check your setup.\n");
360 } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "BUFFER FULL")) {
361 /* This will only happen if the last data line was complete.
362 * Otherwise, elm327_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 (elm327_rxbuf_cmp(elm->rxbuf, len, "BUS ERROR")) {
368 frame->can_id |= CAN_ERR_BUSERROR;
369 } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "CAN ERROR")) {
370 frame->can_id |= CAN_ERR_PROT;
371 } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "<RX ERROR")) {
372 frame->can_id |= CAN_ERR_PROT;
373 } else if (elm327_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 (elm327_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 elm327_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 elm327_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.
436 !isdigit(elm->rxbuf[hexlen]) &&
437 !isupper(elm->rxbuf[hexlen]) &&
438 '<' != elm->rxbuf[hexlen] &&
439 ' ' != elm->rxbuf[hexlen]) {
440 /* The line is likely garbled anyway, so bail.
441 * The main code will restart listening.
447 /* Use spaces in CAN ID to distinguish 29 or 11 bit address length.
448 * No out-of-bounds access:
449 * We use the fact that we can always read from elm->rxbuf.
451 if (elm->rxbuf[2] == ' ' && elm->rxbuf[5] == ' ' &&
452 elm->rxbuf[8] == ' ' && elm->rxbuf[11] == ' ' &&
453 elm->rxbuf[13] == ' ') {
454 frame->can_id = CAN_EFF_FLAG;
456 } else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') {
459 /* This is not a well-formatted data line.
460 * Assume it's an error message.
466 if (hexlen < datastart) {
467 /* The line is too short to be a valid frame hex dump.
468 * Something interrupted the hex dump or it is invalid.
474 /* From here on all chars up to buf[hexlen] are hex or spaces,
475 * at well-defined offsets.
478 /* Read CAN data length */
479 frame->len = (hex_to_bin(elm->rxbuf[datastart - 2]) << 0);
482 if (frame->can_id & CAN_EFF_FLAG) {
483 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 28)
484 | (hex_to_bin(elm->rxbuf[1]) << 24)
485 | (hex_to_bin(elm->rxbuf[3]) << 20)
486 | (hex_to_bin(elm->rxbuf[4]) << 16)
487 | (hex_to_bin(elm->rxbuf[6]) << 12)
488 | (hex_to_bin(elm->rxbuf[7]) << 8)
489 | (hex_to_bin(elm->rxbuf[9]) << 4)
490 | (hex_to_bin(elm->rxbuf[10]) << 0);
492 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 8)
493 | (hex_to_bin(elm->rxbuf[1]) << 4)
494 | (hex_to_bin(elm->rxbuf[2]) << 0);
497 /* Check for RTR frame */
498 if (elm->rxfill >= hexlen + 3 &&
499 !memcmp(&elm->rxbuf[hexlen], "RTR", 3)) {
500 frame->can_id |= CAN_RTR_FLAG;
503 /* Is the line long enough to hold the advertised payload?
504 * Note: RTR frames have a DLC, but no actual payload.
506 if (!(frame->can_id & CAN_RTR_FLAG) &&
507 (hexlen < frame->len * 3 + datastart)) {
509 * Probably the ELM327's RS232 TX buffer was full.
510 * Emit an error frame and exit.
512 frame->can_id = CAN_ERR_FLAG | CAN_ERR_CRTL;
513 frame->len = CAN_ERR_DLC;
514 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
515 elm327_feed_frame_to_netdev(elm, skb);
517 /* Signal failure to parse.
518 * The line will be re-parsed as an error line, which will fail.
519 * However, this will correctly drop the state machine back into
526 /* Parse the data nibbles. */
527 for (i = 0; i < frame->len; i++) {
528 frame->data[i] = (hex_to_bin(elm->rxbuf[datastart + 3*i]) << 4)
529 | (hex_to_bin(elm->rxbuf[datastart + 3*i + 1]));
532 /* Feed the frame to the network layer. */
533 elm327_feed_frame_to_netdev(elm, skb);
538 static void elm327_parse_line(struct can327 *elm, size_t len)
540 lockdep_assert_held(&elm->lock);
542 /* Skip empty lines */
546 /* Skip echo lines */
547 if (elm->drop_next_line) {
548 elm->drop_next_line = 0;
550 } else if (!memcmp(elm->rxbuf, "AT", 2)) {
554 /* Regular parsing */
555 if (elm->state == ELM327_STATE_RECEIVING &&
556 elm327_parse_frame(elm, len)) {
557 /* Parse an error line. */
558 elm327_parse_error(elm, len);
561 elm327_kick_into_cmd_mode(elm);
565 static void elm327_handle_prompt(struct can327 *elm)
567 struct can_frame *frame = &elm->can_frame_to_send;
568 /* Size this buffer for the largest ELM327 line we may generate,
569 * which is currently an 8 byte CAN frame's payload hexdump.
570 * Items in elm327_init_script must fit here, too!
572 char local_txbuf[sizeof("0102030405060708\r")];
574 lockdep_assert_held(&elm->lock);
576 if (!elm->cmds_todo) {
577 /* Enter CAN monitor mode */
578 elm327_send(elm, "ATMA\r", 5);
579 elm->state = ELM327_STATE_RECEIVING;
581 /* We will be in the default state once this command is
582 * sent, so enable the TX packet queue.
584 netif_wake_queue(elm->dev);
589 /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */
590 if (test_bit(ELM327_TX_DO_INIT, &elm->cmds_todo)) {
591 snprintf(local_txbuf, sizeof(local_txbuf),
593 *elm->next_init_cmd);
595 elm->next_init_cmd++;
596 if (!(*elm->next_init_cmd)) {
597 clear_bit(ELM327_TX_DO_INIT, &elm->cmds_todo);
601 } else if (test_and_clear_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo)) {
602 snprintf(local_txbuf, sizeof(local_txbuf),
604 !!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
606 } else if (test_and_clear_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo)) {
607 snprintf(local_txbuf, sizeof(local_txbuf),
609 !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
611 } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo)) {
612 snprintf(local_txbuf, sizeof(local_txbuf),
614 set_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo);
616 } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo)) {
617 snprintf(local_txbuf, sizeof(local_txbuf),
621 } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo)) {
622 snprintf(local_txbuf, sizeof(local_txbuf),
624 (frame->can_id & CAN_EFF_MASK) >> 24);
626 } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo)) {
627 snprintf(local_txbuf, sizeof(local_txbuf),
629 frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1));
631 } else if (test_and_clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo)) {
632 snprintf(local_txbuf, sizeof(local_txbuf),
634 frame->can_id & CAN_SFF_MASK);
636 } else if (test_and_clear_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo)) {
637 if (frame->can_id & CAN_RTR_FLAG) {
638 /* Send an RTR frame. Their DLC is fixed.
639 * Some chips don't send them at all.
641 snprintf(local_txbuf, sizeof(local_txbuf),
644 /* Send a regular CAN data frame */
647 for (i = 0; i < frame->len; i++) {
648 snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
653 snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
657 elm->drop_next_line = 1;
658 elm->state = ELM327_STATE_RECEIVING;
660 /* We will be in the default state once this command is
661 * sent, so enable the TX packet queue.
663 netif_wake_queue(elm->dev);
666 elm327_send(elm, local_txbuf, strlen(local_txbuf));
669 static bool elm327_is_ready_char(char c)
671 /* Bits 0xc0 are sometimes set (randomly), hence the mask.
672 * Probably bad hardware.
674 return (c & 0x3f) == ELM327_READY_CHAR;
677 static void elm327_drop_bytes(struct can327 *elm, size_t i)
679 lockdep_assert_held(&elm->lock);
681 memmove(&elm->rxbuf[0], &elm->rxbuf[i], ELM327_SIZE_RXBUF - i);
685 static void elm327_parse_rxbuf(struct can327 *elm, size_t first_new_char_idx)
689 lockdep_assert_held(&elm->lock);
691 switch (elm->state) {
692 case ELM327_STATE_NOTINIT:
696 case ELM327_STATE_GETDUMMYCHAR:
697 /* Wait for 'y' or '>' */
698 for (pos = 0; pos < elm->rxfill; pos++) {
699 if (elm->rxbuf[pos] == ELM327_DUMMY_CHAR) {
700 elm327_send(elm, "\r", 1);
701 elm->state = ELM327_STATE_GETPROMPT;
704 } else if (elm327_is_ready_char(elm->rxbuf[pos])) {
705 elm327_send(elm, ELM327_DUMMY_STRING, 1);
711 elm327_drop_bytes(elm, pos);
714 case ELM327_STATE_GETPROMPT:
716 if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1]))
717 elm327_handle_prompt(elm);
722 case ELM327_STATE_RECEIVING:
723 /* Find <CR> delimiting feedback lines. */
724 len = first_new_char_idx;
725 while (len < elm->rxfill && elm->rxbuf[len] != '\r')
728 if (len == ELM327_SIZE_RXBUF) {
729 /* Assume the buffer ran full with garbage.
730 * Did we even connect at the right baud rate?
733 "RX buffer overflow. Faulty ELM327 or UART?\n");
734 elm327_uart_side_failure(elm);
735 } else if (len == elm->rxfill) {
736 if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) {
737 /* The ELM327's AT ST response timeout ran out,
738 * so we got a prompt.
739 * Clear RX buffer and restart listening.
743 elm327_handle_prompt(elm);
746 /* No <CR> found - we haven't received a full line yet.
747 * Wait for more data.
750 /* We have a full line to parse. */
751 elm327_parse_line(elm, len);
753 /* Remove parsed data from RX buffer. */
754 elm327_drop_bytes(elm, len + 1);
756 /* More data to parse? */
758 elm327_parse_rxbuf(elm, 0);
763 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
764 /* Dummy needed to use can_rx_offload */
765 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,5,0)
766 static unsigned int *can327_mailbox_read(struct can_rx_offload *offload,
767 struct can_frame *cf,
768 u32 *timestamp, unsigned int n)
770 WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
774 #else /* Since 4e9c9484b085 (included in v5.5) */
775 static struct sk_buff *can327_mailbox_read(struct can_rx_offload *offload,
776 unsigned int n, u32 *timestamp,
779 WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
781 return ERR_PTR(-ENOBUFS);
786 static int can327_netdev_open(struct net_device *dev)
788 struct can327 *elm = netdev_priv(dev);
791 spin_lock_bh(&elm->lock);
794 spin_unlock_bh(&elm->lock);
798 if (elm->uart_side_failure)
799 netdev_warn(elm->dev, "Reopening netdev after a UART side fault has been detected.\n");
801 /* Clear TTY buffers */
805 /* open_candev() checks for elm->can.bittiming.bitrate != 0 */
806 err = open_candev(dev);
808 spin_unlock_bh(&elm->lock);
813 spin_unlock_bh(&elm->lock);
815 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
816 elm->offload.mailbox_read = can327_mailbox_read;
817 err = can_rx_offload_add_fifo(dev, &elm->offload, ELM327_NAPI_WEIGHT);
819 err = can_rx_offload_add_manual(dev, &elm->offload, ELM327_NAPI_WEIGHT);
826 can_rx_offload_enable(&elm->offload);
828 can_led_event(dev, CAN_LED_EVENT_OPEN);
829 elm->can.state = CAN_STATE_ERROR_ACTIVE;
830 netif_start_queue(dev);
835 static int can327_netdev_close(struct net_device *dev)
837 struct can327 *elm = netdev_priv(dev);
839 /* Interrupt whatever the ELM327 is doing right now */
840 spin_lock_bh(&elm->lock);
841 elm327_send(elm, ELM327_DUMMY_STRING, 1);
842 spin_unlock_bh(&elm->lock);
844 netif_stop_queue(dev);
846 /* Give UART one final chance to flush. */
847 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
848 flush_work(&elm->tx_work);
850 can_rx_offload_disable(&elm->offload);
851 elm->can.state = CAN_STATE_STOPPED;
852 can_rx_offload_del(&elm->offload);
854 can_led_event(dev, CAN_LED_EVENT_STOP);
859 /* Send a can_frame to a TTY. */
860 static netdev_tx_t can327_netdev_start_xmit(struct sk_buff *skb,
861 struct net_device *dev)
863 struct can327 *elm = netdev_priv(dev);
864 struct can_frame *frame = (struct can_frame *)skb->data;
866 if (can_dropped_invalid_skb(dev, skb))
869 /* This check will be part of can_dropped_invalid_skb()
872 if (elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
875 /* We shouldn't get here after a hardware fault:
876 * can_bus_off() calls netif_carrier_off()
878 if (elm->uart_side_failure) {
879 WARN_ON_ONCE(elm->uart_side_failure);
883 netif_stop_queue(dev);
885 /* BHs are already disabled, so no spin_lock_bh().
886 * See Documentation/networking/netdevices.txt
888 spin_lock(&elm->lock);
889 elm327_send_frame(elm, frame);
890 spin_unlock(&elm->lock);
892 dev->stats.tx_packets++;
893 dev->stats.tx_bytes += frame->len;
895 can_led_event(dev, CAN_LED_EVENT_TX);
902 static const struct net_device_ops can327_netdev_ops = {
903 .ndo_open = can327_netdev_open,
904 .ndo_stop = can327_netdev_close,
905 .ndo_start_xmit = can327_netdev_start_xmit,
906 .ndo_change_mtu = can_change_mtu,
909 static bool can327_is_valid_rx_char(u8 c)
911 static const bool lut_char_is_valid['z'] = {
915 ['0'] = true, true, true, true, true,
916 ['5'] = true, true, true, true, true,
918 [ELM327_READY_CHAR] = true,
920 ['A'] = true, true, true, true, true, true, true,
921 ['H'] = true, true, true, true, true, true, true,
922 ['O'] = true, true, true, true, true, true, true,
923 ['V'] = true, true, true, true, true,
927 [ELM327_DUMMY_CHAR] = true,
929 BUILD_BUG_ON(ELM327_DUMMY_CHAR >= 'z');
931 return (c < ARRAY_SIZE(lut_char_is_valid) &&
932 lut_char_is_valid[c]);
935 /* Handle incoming ELM327 ASCII data.
936 * This will not be re-entered while running, but other ldisc
937 * functions may be called in parallel.
939 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
940 static void can327_ldisc_rx(struct tty_struct *tty,
941 const unsigned char *cp, char *fp, int count)
943 static void can327_ldisc_rx(struct tty_struct *tty,
944 const unsigned char *cp, const char *fp, int count)
947 struct can327 *elm = (struct can327 *)tty->disc_data;
948 size_t first_new_char_idx;
950 if (elm->uart_side_failure)
953 spin_lock_bh(&elm->lock);
955 /* Store old rxfill, so elm327_parse_rxbuf() will have
956 * the option of skipping already checked characters.
958 first_new_char_idx = elm->rxfill;
960 while (count-- && elm->rxfill < ELM327_SIZE_RXBUF) {
962 netdev_err(elm->dev, "Error in received character stream. Check your wiring.");
964 elm327_uart_side_failure(elm);
966 spin_unlock_bh(&elm->lock);
970 /* Ignore NUL characters, which the PIC microcontroller may
971 * inadvertently insert due to a known hardware bug.
972 * See ELM327 documentation, which refers to a Microchip PIC
976 /* Check for stray characters on the UART line.
977 * Likely caused by bad hardware.
979 if (!can327_is_valid_rx_char(*cp)) {
981 "Received illegal character %02x.\n",
983 elm327_uart_side_failure(elm);
985 spin_unlock_bh(&elm->lock);
989 elm->rxbuf[elm->rxfill++] = *cp;
996 netdev_err(elm->dev, "Receive buffer overflowed. Bad chip or wiring? count = %i", count);
998 elm327_uart_side_failure(elm);
1000 spin_unlock_bh(&elm->lock);
1004 elm327_parse_rxbuf(elm, first_new_char_idx);
1005 spin_unlock_bh(&elm->lock);
1008 /* Write out remaining transmit buffer.
1009 * Scheduled when TTY is writable.
1011 static void can327_ldisc_tx_worker(struct work_struct *work)
1013 struct can327 *elm = container_of(work, struct can327, tx_work);
1016 if (elm->uart_side_failure)
1019 spin_lock_bh(&elm->lock);
1022 written = elm->tty->ops->write(elm->tty, elm->txhead, elm->txleft);
1024 netdev_err(elm->dev,
1025 "Failed to write to tty %s.\n",
1027 elm327_uart_side_failure(elm);
1029 spin_unlock_bh(&elm->lock);
1033 elm->txleft -= written;
1034 elm->txhead += written;
1038 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
1040 spin_unlock_bh(&elm->lock);
1043 /* Called by the driver when there's room for more data. */
1044 static void can327_ldisc_tx_wakeup(struct tty_struct *tty)
1046 struct can327 *elm = (struct can327 *)tty->disc_data;
1048 schedule_work(&elm->tx_work);
1051 /* ELM327 can only handle bitrates that are integer divisors of 500 kHz,
1052 * or 7/8 of that. Divisors are 1 to 64.
1053 * Currently we don't implement support for 7/8 rates.
1055 static const u32 can327_bitrate_const[] = {
1056 7812, 7936, 8064, 8196, 8333, 8474, 8620, 8771,
1057 8928, 9090, 9259, 9433, 9615, 9803, 10000, 10204,
1058 10416, 10638, 10869, 11111, 11363, 11627, 11904, 12195,
1059 12500, 12820, 13157, 13513, 13888, 14285, 14705, 15151,
1060 15625, 16129, 16666, 17241, 17857, 18518, 19230, 20000,
1061 20833, 21739, 22727, 23809, 25000, 26315, 27777, 29411,
1062 31250, 33333, 35714, 38461, 41666, 45454, 50000, 55555,
1063 62500, 71428, 83333, 100000, 125000, 166666, 250000, 500000
1066 /* Dummy needed to use bitrate_const */
1067 static int can327_do_set_bittiming(struct net_device *netdev)
1072 static int can327_ldisc_open(struct tty_struct *tty)
1074 struct net_device *dev;
1078 if (!capable(CAP_NET_ADMIN))
1081 if (!tty->ops->write)
1084 dev = alloc_candev(sizeof(struct can327), 0);
1087 elm = netdev_priv(dev);
1089 /* Configure TTY interface */
1090 tty->receive_room = 65536; /* We don't flow control */
1091 spin_lock_init(&elm->lock);
1092 INIT_WORK(&elm->tx_work, can327_ldisc_tx_worker);
1094 /* Configure CAN metadata */
1095 elm->can.bitrate_const = can327_bitrate_const;
1096 elm->can.bitrate_const_cnt = ARRAY_SIZE(can327_bitrate_const);
1097 elm->can.do_set_bittiming = can327_do_set_bittiming;
1098 elm->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY;
1100 /* Configure netdev interface */
1102 dev->netdev_ops = &can327_netdev_ops;
1104 /* Mark ldisc channel as alive */
1106 tty->disc_data = elm;
1108 devm_can_led_init(elm->dev);
1111 err = register_candev(elm->dev);
1113 free_candev(elm->dev);
1117 netdev_info(elm->dev, "can327 on %s.\n", tty->name);
1122 /* Close down a can327 channel.
1123 * This means flushing out any pending queues, and then returning.
1124 * This call is serialized against other ldisc functions:
1125 * Once this is called, no other ldisc function of ours is entered.
1127 * We also use this function for a hangup event.
1129 static void can327_ldisc_close(struct tty_struct *tty)
1131 struct can327 *elm = (struct can327 *)tty->disc_data;
1133 /* unregister_netdev() calls .ndo_stop() so we don't have to.
1134 * Our .ndo_stop() also flushes the TTY write wakeup handler,
1135 * so we can safely set elm->tty = NULL after this.
1137 unregister_candev(elm->dev);
1139 /* Mark channel as dead */
1140 spin_lock_bh(&elm->lock);
1141 tty->disc_data = NULL;
1143 spin_unlock_bh(&elm->lock);
1145 netdev_info(elm->dev, "can327 off %s.\n", tty->name);
1147 free_candev(elm->dev);
1150 static int can327_ldisc_ioctl(struct tty_struct *tty,
1151 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,17,0)
1154 unsigned int cmd, unsigned long arg)
1156 struct can327 *elm = (struct can327 *)tty->disc_data;
1161 tmp = strnlen(elm->dev->name, IFNAMSIZ - 1) + 1;
1162 if (copy_to_user((void __user *)arg, elm->dev->name, tmp))
1170 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
1171 return tty_mode_ioctl(tty, file, cmd, arg);
1173 return tty_mode_ioctl(tty, cmd, arg);
1178 static struct tty_ldisc_ops can327_ldisc = {
1179 .owner = THIS_MODULE,
1181 .num = N_DEVELOPMENT,
1182 .receive_buf = can327_ldisc_rx,
1183 .write_wakeup = can327_ldisc_tx_wakeup,
1184 .open = can327_ldisc_open,
1185 .close = can327_ldisc_close,
1186 .ioctl = can327_ldisc_ioctl,
1189 static int __init can327_init(void)
1193 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1194 status = tty_register_ldisc(N_DEVELOPMENT, &can327_ldisc);
1196 status = tty_register_ldisc(&can327_ldisc);
1199 pr_err("Can't register line discipline\n");
1204 static void __exit can327_exit(void)
1206 /* This will only be called when all channels have been closed by
1207 * userspace - tty_ldisc.c takes care of the module's refcount.
1209 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1212 status = tty_unregister_ldisc(N_DEVELOPMENT);
1214 pr_err("Can't unregister line discipline (error: %d)\n",
1217 tty_unregister_ldisc(&can327_ldisc);
1221 module_init(can327_init);
1222 module_exit(can327_exit);
1224 MODULE_ALIAS_LDISC(N_DEVELOPMENT);
1225 MODULE_DESCRIPTION("ELM327 based CAN interface");
1226 MODULE_LICENSE("GPL");
1227 MODULE_AUTHOR("Max Staudt <max-linux@enpas.org>");