1 // SPDX-License-Identifier: GPL-2.0
3 * elmcan.c - ELM327 based CAN interface driver
4 * (tty line discipline)
6 * This file is derived from linux/drivers/net/can/slcan.c
8 * elmcan.c Author : Max Staudt <max-linux@enpas.org>
9 * slcan.c Author : Oliver Hartkopp <socketcan@hartkopp.net>
10 * slip.c Authors : Laurence Culhane <loz@holmes.demon.co.uk>
11 * Fred N. van Kempen <waltje@uwalt.nl.mugnet.org>
15 #define pr_fmt(fmt) "[elmcan] " fmt
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/moduleparam.h>
22 #include <linux/atomic.h>
23 #include <linux/bitops.h>
24 #include <linux/ctype.h>
25 #include <linux/delay.h>
26 #include <linux/errno.h>
27 #include <linux/if_ether.h>
28 #include <linux/kernel.h>
29 #include <linux/list.h>
30 #include <linux/netdevice.h>
31 #include <linux/skbuff.h>
32 #include <linux/spinlock.h>
33 #include <linux/string.h>
34 #include <linux/tty.h>
35 #include <linux/workqueue.h>
37 #include <linux/can.h>
38 #include <linux/can/dev.h>
39 #include <linux/can/error.h>
40 #include <linux/can/led.h>
43 MODULE_ALIAS_LDISC(N_ELMCAN);
44 MODULE_DESCRIPTION("ELM327 based CAN interface");
45 MODULE_LICENSE("GPL");
46 MODULE_AUTHOR("Max Staudt <max-linux@enpas.org>");
48 /* If this is enabled, we'll try to make the best of the situation
49 * even if we receive unexpected characters on the line.
51 * Handle with care, it's likely your hardware is unreliable!
53 static bool accept_flaky_uart;
54 module_param_named(accept_flaky_uart, accept_flaky_uart, bool, 0444);
55 MODULE_PARM_DESC(accept_flaky_uart, "Don't bail at the first invalid character. Behavior undefined.");
58 /* Line discipline ID number */
63 #define ELM327_SIZE_RXBUF 256
64 #define ELM327_SIZE_TXBUF 32
66 #define ELM327_CAN_CONFIG_SEND_SFF 0x8000
67 #define ELM327_CAN_CONFIG_VARIABLE_DLC 0x4000
68 #define ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF 0x2000
69 #define ELM327_CAN_CONFIG_BAUDRATE_MULT_8_7 0x1000
71 #define ELM327_MAGIC_CHAR 'y'
72 #define ELM327_MAGIC_STRING "y"
73 #define ELM327_READY_CHAR '>'
76 /* Bits in elm->cmds_todo */
78 ELM_TODO_CAN_DATA = 0,
80 ELM_TODO_CANID_29BIT_LOW,
81 ELM_TODO_CANID_29BIT_HIGH,
82 ELM_TODO_CAN_CONFIG_PART2,
85 ELM_TODO_SILENT_MONITOR,
91 /* This must be the first member when using alloc_candev() */
94 /* TTY and netdev devices that we're bridging */
95 struct tty_struct *tty;
96 struct net_device *dev;
98 /* Per-channel lock */
101 /* Keep track of how many things are using this struct.
102 * Once it reaches 0, we are in the process of cleaning up,
103 * and new operations will be cancelled immediately.
104 * Use atomic_t rather than refcount_t because we deliberately
105 * decrement to 0, and refcount_dec() spills a WARN_ONCE in
110 /* Stop the channel on hardware failure.
111 * Once this is true, nothing will be sent to the TTY.
116 struct work_struct tx_work; /* Flushes TTY TX buffer */
117 unsigned char *txbuf;
118 unsigned char *txhead; /* Pointer to next TX byte */
119 int txleft; /* Bytes left to TX */
122 unsigned char rxbuf[ELM327_SIZE_RXBUF];
135 /* The CAN frame and config the ELM327 is sending/using,
136 * or will send/use after finishing all cmds_todo
138 struct can_frame can_frame;
139 unsigned short can_config;
140 unsigned long can_bitrate;
141 unsigned char can_bitrate_divisor;
142 int silent_monitoring;
144 /* Things we have yet to send */
145 char **next_init_cmd;
146 unsigned long cmds_todo;
150 /* A lock for all tty->disc_data handled by this ldisc.
151 * This is to prevent a case where tty->disc_data is set to NULL,
152 * yet someone is still trying to dereference it.
153 * Without this, we cannot do a clean shutdown.
155 static DEFINE_SPINLOCK(elmcan_discdata_lock);
158 static inline void elm327_hw_failure(struct elmcan *elm);
162 /***********************************************************************
163 * ELM327: Transmission *
165 * (all functions assume elm->lock taken) *
166 ***********************************************************************/
168 static void elm327_send(struct elmcan *elm, const void *buf, size_t len)
175 memcpy(elm->txbuf, buf, len);
177 /* Order of next two lines is *very* important.
178 * When we are sending a little amount of data,
179 * the transfer may be completed inside the ops->write()
180 * routine, because it's running with interrupts enabled.
181 * In this case we *never* got WRITE_WAKEUP event,
182 * if we did not request it before write operation.
183 * 14 Oct 1994 Dmitry Gorodchanin.
185 set_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
186 actual = elm->tty->ops->write(elm->tty, elm->txbuf, len);
189 "Failed to write to tty %s.\n",
191 elm327_hw_failure(elm);
195 elm->txleft = len - actual;
196 elm->txhead = elm->txbuf + actual;
200 /* Take the ELM327 out of almost any state and back into command mode.
201 * We send ELM327_MAGIC_CHAR which will either abort any running
202 * operation, or be echoed back to us in case we're already in command
205 static void elm327_kick_into_cmd_mode(struct elmcan *elm)
207 if (elm->state != ELM_GETMAGICCHAR && elm->state != ELM_GETPROMPT) {
208 elm327_send(elm, ELM327_MAGIC_STRING, 1);
210 elm->state = ELM_GETMAGICCHAR;
215 /* Schedule a CAN frame and necessary config changes to be sent to the TTY. */
216 static void elm327_send_frame(struct elmcan *elm, struct can_frame *frame)
218 /* Schedule any necessary changes in ELM327's CAN configuration */
219 if (elm->can_frame.can_id != frame->can_id) {
220 /* Set the new CAN ID for transmission. */
221 if ((frame->can_id & CAN_EFF_FLAG)
222 ^ (elm->can_frame.can_id & CAN_EFF_FLAG)) {
223 elm->can_config = (frame->can_id & CAN_EFF_FLAG
225 : ELM327_CAN_CONFIG_SEND_SFF)
226 | ELM327_CAN_CONFIG_VARIABLE_DLC
227 | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF
228 | elm->can_bitrate_divisor;
230 set_bit(ELM_TODO_CAN_CONFIG, &elm->cmds_todo);
233 if (frame->can_id & CAN_EFF_FLAG) {
234 clear_bit(ELM_TODO_CANID_11BIT, &elm->cmds_todo);
235 set_bit(ELM_TODO_CANID_29BIT_LOW, &elm->cmds_todo);
236 set_bit(ELM_TODO_CANID_29BIT_HIGH, &elm->cmds_todo);
238 set_bit(ELM_TODO_CANID_11BIT, &elm->cmds_todo);
239 clear_bit(ELM_TODO_CANID_29BIT_LOW, &elm->cmds_todo);
240 clear_bit(ELM_TODO_CANID_29BIT_HIGH, &elm->cmds_todo);
244 /* Schedule the CAN frame itself. */
245 elm->can_frame = *frame;
246 set_bit(ELM_TODO_CAN_DATA, &elm->cmds_todo);
248 elm327_kick_into_cmd_mode(elm);
253 /***********************************************************************
254 * ELM327: Initialization sequence *
256 * (assumes elm->lock taken) *
257 ***********************************************************************/
259 static char *elm327_init_script[] = {
260 "AT WS\r", /* v1.0: Warm Start */
261 "AT PP FF OFF\r", /* v1.0: All Programmable Parameters Off */
262 "AT M0\r", /* v1.0: Memory Off */
263 "AT AL\r", /* v1.0: Allow Long messages */
264 "AT BI\r", /* v1.0: Bypass Initialization */
265 "AT CAF0\r", /* v1.0: CAN Auto Formatting Off */
266 "AT CFC0\r", /* v1.0: CAN Flow Control Off */
267 "AT CF 000\r", /* v1.0: Reset CAN ID Filter */
268 "AT CM 000\r", /* v1.0: Reset CAN ID Mask */
269 "AT E1\r", /* v1.0: Echo On */
270 "AT H1\r", /* v1.0: Headers On */
271 "AT L0\r", /* v1.0: Linefeeds Off */
272 "AT SH 7DF\r", /* v1.0: Set CAN sending ID to 0x7df */
273 "AT ST FF\r", /* v1.0: Set maximum Timeout for response after TX */
274 "AT AT0\r", /* v1.2: Adaptive Timing Off */
275 "AT D1\r", /* v1.3: Print DLC On */
276 "AT S1\r", /* v1.3: Spaces On */
277 "AT TP B\r", /* v1.0: Try Protocol B */
282 static void elm327_init(struct elmcan *elm)
284 elm->state = ELM_NOTINIT;
285 elm->can_frame.can_id = 0x7df;
287 elm->drop_next_line = 0;
289 /* We can only set the bitrate as a fraction of 500000.
290 * The bit timing constants in elmcan_bittiming_const will
291 * limit the user to the right values.
293 elm->can_bitrate_divisor = 500000 / elm->can.bittiming.bitrate;
294 elm->can_config = ELM327_CAN_CONFIG_SEND_SFF
295 | ELM327_CAN_CONFIG_VARIABLE_DLC
296 | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF
297 | elm->can_bitrate_divisor;
299 /* Configure ELM327 and then start monitoring */
300 elm->next_init_cmd = &elm327_init_script[0];
301 set_bit(ELM_TODO_INIT, &elm->cmds_todo);
302 set_bit(ELM_TODO_SILENT_MONITOR, &elm->cmds_todo);
303 set_bit(ELM_TODO_RESPONSES, &elm->cmds_todo);
304 set_bit(ELM_TODO_CAN_CONFIG, &elm->cmds_todo);
306 elm327_kick_into_cmd_mode(elm);
311 /***********************************************************************
312 * ELM327: Reception -> netdev glue *
314 * (assumes elm->lock taken) *
315 ***********************************************************************/
317 static void elm327_feed_frame_to_netdev(struct elmcan *elm,
318 const struct can_frame *frame)
320 struct can_frame *cf;
323 if (!netif_running(elm->dev))
326 skb = alloc_can_skb(elm->dev, &cf);
331 memcpy(cf, frame, sizeof(struct can_frame));
333 elm->dev->stats.rx_packets++;
334 elm->dev->stats.rx_bytes += frame->can_dlc;
337 can_led_event(elm->dev, CAN_LED_EVENT_RX);
342 /***********************************************************************
343 * ELM327: "Panic" handler *
345 * (assumes elm->lock taken) *
346 ***********************************************************************/
348 /* Called when we're out of ideas and just want it all to end. */
349 static inline void elm327_hw_failure(struct elmcan *elm)
351 struct can_frame frame;
353 memset(&frame, 0, sizeof(frame));
354 frame.can_id = CAN_ERR_FLAG;
355 frame.can_dlc = CAN_ERR_DLC;
359 elm327_feed_frame_to_netdev(elm, &frame);
361 netdev_err(elm->dev, "ELM327 misbehaved. Blocking further communication.\n");
363 elm->hw_failure = true;
364 can_bus_off(elm->dev);
369 /***********************************************************************
370 * ELM327: Reception parser *
372 * (assumes elm->lock taken) *
373 ***********************************************************************/
375 static void elm327_parse_error(struct elmcan *elm, int len)
377 struct can_frame frame;
379 memset(&frame, 0, sizeof(frame));
380 frame.can_id = CAN_ERR_FLAG;
381 frame.can_dlc = CAN_ERR_DLC;
385 if (!memcmp(elm->rxbuf, "UNABLE TO CONNECT", 17)) {
387 "The ELM327 reported UNABLE TO CONNECT. Please check your setup.\n");
391 if (!memcmp(elm->rxbuf, "BUFFER FULL", 11)) {
392 /* This case will only happen if the last data
394 * Otherwise, elm327_parse_frame() will heuristically
395 * emit this error frame instead.
397 frame.can_id |= CAN_ERR_CRTL;
398 frame.data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
402 if (!memcmp(elm->rxbuf, "BUS ERROR", 9))
403 frame.can_id |= CAN_ERR_BUSERROR;
404 if (!memcmp(elm->rxbuf, "CAN ERROR", 9))
405 frame.can_id |= CAN_ERR_PROT;
406 if (!memcmp(elm->rxbuf, "<RX ERROR", 9))
407 frame.can_id |= CAN_ERR_PROT;
410 if (!memcmp(elm->rxbuf, "BUS BUSY", 8)) {
411 frame.can_id |= CAN_ERR_PROT;
412 frame.data[2] = CAN_ERR_PROT_OVERLOAD;
414 if (!memcmp(elm->rxbuf, "FB ERROR", 8)) {
415 frame.can_id |= CAN_ERR_PROT;
416 frame.data[2] = CAN_ERR_PROT_TX;
420 if (!memcmp(elm->rxbuf, "ERR", 3)) {
421 netdev_err(elm->dev, "The ELM327 reported an ERR%c%c. Please power it off and on again.\n",
422 elm->rxbuf[3], elm->rxbuf[4]);
423 frame.can_id |= CAN_ERR_CRTL;
427 /* Don't emit an error frame if we're unsure */
431 elm327_feed_frame_to_netdev(elm, &frame);
435 /* Parse CAN frames coming as ASCII from ELM327.
436 * They can be of various formats:
438 * 29-bit ID (EFF): 12 34 56 78 D PL PL PL PL PL PL PL PL
439 * 11-bit ID (!EFF): 123 D PL PL PL PL PL PL PL PL
441 * where D = DLC, PL = payload byte
443 * Instead of a payload, RTR indicates a remote request.
445 * We will use the spaces and line length to guess the format.
447 static int elm327_parse_frame(struct elmcan *elm, int len)
449 struct can_frame frame;
454 memset(&frame, 0, sizeof(frame));
456 /* Find first non-hex and non-space character:
457 * - In the simplest case, there is none.
458 * - For RTR frames, 'R' is the first non-hex character.
459 * - An error message may replace the end of the data line.
461 for (hexlen = 0; hexlen <= len; hexlen++) {
462 if (hex_to_bin(elm->rxbuf[hexlen]) < 0
463 && elm->rxbuf[hexlen] != ' ') {
468 /* If we accept stray characters coming in:
469 * Check for stray characters on a payload line.
470 * No idea what causes this.
472 if (accept_flaky_uart
474 && !isdigit(elm->rxbuf[hexlen])
475 && !isupper(elm->rxbuf[hexlen])
476 && '<' != elm->rxbuf[hexlen]
477 && ' ' != elm->rxbuf[hexlen]) {
478 /* The line is likely garbled anyway, so bail.
479 * The main code will restart listening.
481 elm327_kick_into_cmd_mode(elm);
485 /* Use spaces in CAN ID to distinguish 29 or 11 bit address length.
486 * No out-of-bounds access:
487 * We use the fact that we can always read from elm->rxbuf.
489 if (elm->rxbuf[2] == ' ' && elm->rxbuf[5] == ' '
490 && elm->rxbuf[8] == ' ' && elm->rxbuf[11] == ' '
491 && elm->rxbuf[13] == ' ') {
492 frame.can_id = CAN_EFF_FLAG;
494 } else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') {
498 /* This is not a well-formatted data line.
499 * Assume it's an error message.
504 if (hexlen < datastart) {
505 /* The line is too short to be a valid frame hex dump.
506 * Something interrupted the hex dump or it is invalid.
511 /* From here on all chars up to buf[hexlen] are hex or spaces,
512 * at well-defined offsets.
515 /* Read CAN data length */
516 frame.can_dlc = (hex_to_bin(elm->rxbuf[datastart - 2]) << 0);
519 if (frame.can_id & CAN_EFF_FLAG) {
520 frame.can_id |= (hex_to_bin(elm->rxbuf[0]) << 28)
521 | (hex_to_bin(elm->rxbuf[1]) << 24)
522 | (hex_to_bin(elm->rxbuf[3]) << 20)
523 | (hex_to_bin(elm->rxbuf[4]) << 16)
524 | (hex_to_bin(elm->rxbuf[6]) << 12)
525 | (hex_to_bin(elm->rxbuf[7]) << 8)
526 | (hex_to_bin(elm->rxbuf[9]) << 4)
527 | (hex_to_bin(elm->rxbuf[10]) << 0);
529 frame.can_id |= (hex_to_bin(elm->rxbuf[0]) << 8)
530 | (hex_to_bin(elm->rxbuf[1]) << 4)
531 | (hex_to_bin(elm->rxbuf[2]) << 0);
534 /* Check for RTR frame */
535 if (elm->rxfill >= hexlen + 3
536 && !memcmp(&elm->rxbuf[hexlen], "RTR", 3)) {
537 frame.can_id |= CAN_RTR_FLAG;
540 /* Is the line long enough to hold the advertised payload?
541 * Note: RTR frames have a DLC, but no actual payload.
543 if (!(frame.can_id & CAN_RTR_FLAG)
544 && (hexlen < frame.can_dlc * 3 + datastart)) {
545 /* Incomplete frame. */
547 /* Probably the ELM327's RS232 TX buffer was full.
548 * Emit an error frame and exit.
550 frame.can_id = CAN_ERR_FLAG | CAN_ERR_CRTL;
551 frame.can_dlc = CAN_ERR_DLC;
552 frame.data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
553 elm327_feed_frame_to_netdev(elm, &frame);
555 /* Signal failure to parse.
556 * The line will be re-parsed as an error line, which will fail.
557 * However, this will correctly drop the state machine back into
563 /* Parse the data nibbles. */
564 for (i = 0; i < frame.can_dlc; i++) {
565 frame.data[i] = (hex_to_bin(elm->rxbuf[datastart+3*i]) << 4)
566 | (hex_to_bin(elm->rxbuf[datastart+3*i+1]) << 0);
569 /* Feed the frame to the network layer. */
570 elm327_feed_frame_to_netdev(elm, &frame);
576 static void elm327_parse_line(struct elmcan *elm, int len)
578 /* Skip empty lines */
582 /* Skip echo lines */
583 if (elm->drop_next_line) {
584 elm->drop_next_line = 0;
586 } else if (elm->rxbuf[0] == 'A' && elm->rxbuf[1] == 'T') {
590 /* Regular parsing */
591 switch (elm->state) {
593 if (elm327_parse_frame(elm, len)) {
594 /* Parse an error line. */
595 elm327_parse_error(elm, len);
598 elm327_kick_into_cmd_mode(elm);
606 static void elm327_handle_prompt(struct elmcan *elm)
608 struct can_frame *frame = &elm->can_frame;
609 char local_txbuf[20];
611 if (!elm->cmds_todo) {
612 /* Enter CAN monitor mode */
613 elm327_send(elm, "ATMA\r", 5);
614 elm->state = ELM_RECEIVING;
619 /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */
620 if (test_bit(ELM_TODO_INIT, &elm->cmds_todo)) {
621 strcpy(local_txbuf, *elm->next_init_cmd);
623 elm->next_init_cmd++;
624 if (!(*elm->next_init_cmd)) {
625 clear_bit(ELM_TODO_INIT, &elm->cmds_todo);
626 netdev_info(elm->dev, "Initialization finished.\n");
629 } else if (test_and_clear_bit(ELM_TODO_SILENT_MONITOR, &elm->cmds_todo)) {
630 sprintf(local_txbuf, "ATCSM%i\r",
631 !(!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)));
633 } else if (test_and_clear_bit(ELM_TODO_RESPONSES, &elm->cmds_todo)) {
634 sprintf(local_txbuf, "ATR%i\r",
635 !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
637 } else if (test_and_clear_bit(ELM_TODO_CAN_CONFIG, &elm->cmds_todo)) {
638 sprintf(local_txbuf, "ATPC\r");
639 set_bit(ELM_TODO_CAN_CONFIG_PART2, &elm->cmds_todo);
641 } else if (test_and_clear_bit(ELM_TODO_CAN_CONFIG_PART2, &elm->cmds_todo)) {
642 sprintf(local_txbuf, "ATPB%04X\r",
645 } else if (test_and_clear_bit(ELM_TODO_CANID_29BIT_HIGH, &elm->cmds_todo)) {
646 sprintf(local_txbuf, "ATCP%02X\r",
647 (frame->can_id & CAN_EFF_MASK) >> 24);
649 } else if (test_and_clear_bit(ELM_TODO_CANID_29BIT_LOW, &elm->cmds_todo)) {
650 sprintf(local_txbuf, "ATSH%06X\r",
651 frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1));
653 } else if (test_and_clear_bit(ELM_TODO_CANID_11BIT, &elm->cmds_todo)) {
654 sprintf(local_txbuf, "ATSH%03X\r",
655 frame->can_id & CAN_SFF_MASK);
657 } else if (test_and_clear_bit(ELM_TODO_CAN_DATA, &elm->cmds_todo)) {
658 if (frame->can_id & CAN_RTR_FLAG) {
659 /* Send an RTR frame. Their DLC is fixed.
660 * Some chips don't send them at all.
662 sprintf(local_txbuf, "ATRTR\r");
664 /* Send a regular CAN data frame */
667 for (i = 0; i < frame->can_dlc; i++) {
668 sprintf(&local_txbuf[2*i], "%02X",
672 sprintf(&local_txbuf[2*i], "\r");
675 elm->drop_next_line = 1;
676 elm->state = ELM_RECEIVING;
679 elm327_send(elm, local_txbuf, strlen(local_txbuf));
683 static bool elm327_is_ready_char(char c)
685 /* Bits 0xc0 are sometimes set (randomly), hence the mask.
686 * Probably bad hardware.
688 return (c & 0x3f) == ELM327_READY_CHAR;
691 static void elm327_drop_bytes(struct elmcan *elm, int i)
693 memmove(&elm->rxbuf[0], &elm->rxbuf[i], ELM327_SIZE_RXBUF - i);
697 static void elm327_parse_rxbuf(struct elmcan *elm)
701 switch (elm->state) {
706 case ELM_GETMAGICCHAR:
708 /* Wait for 'y' or '>' */
711 for (i = 0; i < elm->rxfill; i++) {
712 if (elm->rxbuf[i] == ELM327_MAGIC_CHAR) {
713 elm327_send(elm, "\r", 1);
714 elm->state = ELM_GETPROMPT;
717 } else if (elm327_is_ready_char(elm->rxbuf[i])) {
718 elm327_send(elm, ELM327_MAGIC_STRING, 1);
724 elm327_drop_bytes(elm, i);
731 if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1]))
732 elm327_handle_prompt(elm);
738 /* Find <CR> delimiting feedback lines. */
740 (len < elm->rxfill) && (elm->rxbuf[len] != '\r');
745 if (len == ELM327_SIZE_RXBUF) {
746 /* Line exceeds buffer. It's probably all garbage.
747 * Did we even connect at the right baud rate?
750 "RX buffer overflow. Faulty ELM327 or UART?\n");
751 elm327_hw_failure(elm);
753 } else if (len == elm->rxfill) {
754 if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) {
755 /* The ELM327's AT ST response timeout ran out,
756 * so we got a prompt.
757 * Clear RX buffer and restart listening.
761 elm327_handle_prompt(elm);
765 /* No <CR> found - we haven't received a full line yet.
766 * Wait for more data.
771 /* We have a full line to parse. */
772 elm327_parse_line(elm, len);
774 /* Remove parsed data from RX buffer. */
775 elm327_drop_bytes(elm, len+1);
777 /* More data to parse? */
779 elm327_parse_rxbuf(elm);
787 /***********************************************************************
790 * (takes elm->lock) *
791 ***********************************************************************/
793 static int elmcan_netdev_open(struct net_device *dev)
795 struct elmcan *elm = netdev_priv(dev);
798 spin_lock_bh(&elm->lock);
799 if (elm->hw_failure) {
800 netdev_err(elm->dev, "Refusing to open interface after a hardware fault has been detected.\n");
801 spin_unlock_bh(&elm->lock);
805 if (elm->tty == NULL) {
806 spin_unlock_bh(&elm->lock);
810 /* open_candev() checks for elm->can.bittiming.bitrate != 0 */
811 err = open_candev(dev);
813 spin_unlock_bh(&elm->lock);
818 spin_unlock_bh(&elm->lock);
820 can_led_event(dev, CAN_LED_EVENT_OPEN);
821 elm->can.state = CAN_STATE_ERROR_ACTIVE;
822 netif_start_queue(dev);
827 static int elmcan_netdev_close(struct net_device *dev)
829 struct elmcan *elm = netdev_priv(dev);
831 spin_lock_bh(&elm->lock);
833 /* Interrupt whatever we're doing right now */
834 elm327_send(elm, ELM327_MAGIC_STRING, 1);
836 /* Clear the wakeup bit, as the netdev will be down and thus
837 * the wakeup handler won't clear it
839 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
841 spin_unlock_bh(&elm->lock);
843 flush_work(&elm->tx_work);
845 spin_unlock_bh(&elm->lock);
848 elm->can.state = CAN_STATE_STOPPED;
849 netif_stop_queue(dev);
851 can_led_event(dev, CAN_LED_EVENT_STOP);
856 /* Send a can_frame to a TTY. */
857 static netdev_tx_t elmcan_netdev_start_xmit(struct sk_buff *skb,
858 struct net_device *dev)
860 struct elmcan *elm = netdev_priv(dev);
861 struct can_frame *frame = (struct can_frame *) skb->data;
863 if (skb->len != sizeof(struct can_frame))
866 if (!netif_running(dev)) {
867 netdev_warn(elm->dev, "xmit: iface is down.\n");
871 /* BHs are already disabled, so no spin_lock_bh().
872 * See Documentation/networking/netdevices.txt
874 spin_lock(&elm->lock);
876 /* We shouldn't get here after a hardware fault:
877 * can_bus_off() calls netif_carrier_off()
879 WARN_ON(elm->hw_failure);
883 || elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) {
884 spin_unlock(&elm->lock);
888 netif_stop_queue(dev);
890 elm327_send_frame(elm, frame);
891 spin_unlock(&elm->lock);
893 dev->stats.tx_packets++;
894 dev->stats.tx_bytes += frame->can_dlc;
896 can_led_event(dev, CAN_LED_EVENT_TX);
904 static const struct net_device_ops elmcan_netdev_ops = {
905 .ndo_open = elmcan_netdev_open,
906 .ndo_stop = elmcan_netdev_close,
907 .ndo_start_xmit = elmcan_netdev_start_xmit,
908 .ndo_change_mtu = can_change_mtu,
915 /***********************************************************************
918 * (takes elm->lock) *
919 ***********************************************************************/
921 /* Get a reference to our struct, taking into account locks/refcounts.
922 * This is to ensure ordering in case we are shutting down, and to ensure
923 * there is a refcount at all (otherwise tty->disc_data may be freed and
924 * before we increment the refcount).
925 * Use this for anything that can race against elmcan_ldisc_close().
927 static struct elmcan *get_elm(struct tty_struct *tty)
932 spin_lock_bh(&elmcan_discdata_lock);
933 elm = (struct elmcan *) tty->disc_data;
936 spin_unlock_bh(&elmcan_discdata_lock);
940 got_ref = atomic_inc_not_zero(&elm->refcount);
941 spin_unlock_bh(&elmcan_discdata_lock);
949 static void put_elm(struct elmcan *elm)
951 atomic_dec(&elm->refcount);
955 static bool elmcan_is_valid_rx_char(char c)
957 return (accept_flaky_uart
960 || ELM327_MAGIC_CHAR == c
961 || ELM327_READY_CHAR == c
972 /* Handle incoming ELM327 ASCII data.
973 * This will not be re-entered while running, but other ldisc
974 * functions may be called in parallel.
976 static void elmcan_ldisc_rx(struct tty_struct *tty,
977 const unsigned char *cp, char *fp, int count)
979 struct elmcan *elm = get_elm(tty);
984 spin_lock_bh(&elm->lock);
986 if (elm->hw_failure) {
990 while (count-- && elm->rxfill < ELM327_SIZE_RXBUF) {
992 netdev_err(elm->dev, "Error in received character stream. Check your wiring.");
994 elm327_hw_failure(elm);
999 /* Ignore NUL characters, which the PIC microcontroller may
1000 * inadvertently insert due to a known hardware bug.
1001 * See ELM327 documentation, which refers to a Microchip PIC
1005 /* Check for stray characters on the UART line.
1006 * Likely caused by bad hardware.
1008 if (!elmcan_is_valid_rx_char(*cp)) {
1009 netdev_err(elm->dev,
1010 "Received illegal character %02x.\n",
1012 elm327_hw_failure(elm);
1017 elm->rxbuf[elm->rxfill++] = *cp;
1024 netdev_err(elm->dev, "Receive buffer overflowed. Bad chip or wiring?");
1026 elm327_hw_failure(elm);
1031 elm327_parse_rxbuf(elm);
1034 spin_unlock_bh(&elm->lock);
1039 /* Write out remaining transmit buffer.
1040 * Scheduled when TTY is writable.
1042 static void elmcan_ldisc_tx_worker(struct work_struct *work)
1044 /* No need to use get_elm() here, as we'll always flush workers
1045 * before destroying the elmcan object.
1047 struct elmcan *elm = container_of(work, struct elmcan, tx_work);
1050 spin_lock_bh(&elm->lock);
1051 if (elm->hw_failure) {
1052 spin_unlock_bh(&elm->lock);
1056 if (!elm->tty || !netif_running(elm->dev)) {
1057 spin_unlock_bh(&elm->lock);
1061 if (elm->txleft <= 0) {
1062 /* Our TTY write buffer is empty:
1063 * Allow netdev to hand us another packet
1065 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
1066 spin_unlock_bh(&elm->lock);
1067 netif_wake_queue(elm->dev);
1071 actual = elm->tty->ops->write(elm->tty, elm->txhead, elm->txleft);
1073 netdev_err(elm->dev,
1074 "Failed to write to tty %s.\n",
1076 elm327_hw_failure(elm);
1077 spin_unlock_bh(&elm->lock);
1081 elm->txleft -= actual;
1082 elm->txhead += actual;
1083 spin_unlock_bh(&elm->lock);
1086 /* Called by the driver when there's room for more data. */
1087 static void elmcan_ldisc_tx_wakeup(struct tty_struct *tty)
1089 struct elmcan *elm = get_elm(tty);
1094 schedule_work(&elm->tx_work);
1100 /* ELM327 can only handle bitrates that are integer divisors of 500 kHz,
1101 * or 7/8 of that. Divisors are 1 to 64.
1102 * Currently we don't implement support for 7/8 rates.
1104 static const u32 elmcan_bitrate_const[64] = {
1105 7812, 7936, 8064, 8196, 8333, 8474, 8620, 8771,
1106 8928, 9090, 9259, 9433, 9615, 9803, 10000, 10204,
1107 10416, 10638, 10869, 11111, 11363, 11627, 11904, 12195,
1108 12500, 12820, 13157, 13513, 13888, 14285, 14705, 15151,
1109 15625, 16129, 16666, 17241, 17857, 18518, 19230, 20000,
1110 20833, 21739, 22727, 23809, 25000, 26315, 27777, 29411,
1111 31250, 33333, 35714, 38461, 41666, 45454, 50000, 55555,
1112 62500, 71428, 83333, 100000, 125000, 166666, 250000, 500000
1116 /* Dummy needed to use bitrate_const */
1117 static int elmcan_do_set_bittiming(struct net_device *netdev)
1125 static int elmcan_ldisc_open(struct tty_struct *tty)
1127 struct net_device *dev;
1131 if (!capable(CAP_NET_ADMIN))
1134 if (!tty->ops->write)
1138 dev = alloc_candev(sizeof(struct elmcan), 0);
1141 elm = netdev_priv(dev);
1143 elm->txbuf = kmalloc(ELM327_SIZE_TXBUF, GFP_KERNEL);
1149 /* Configure TTY interface */
1150 tty->receive_room = 65536; /* We don't flow control */
1151 elm->txleft = 0; /* Clear TTY TX buffer */
1152 spin_lock_init(&elm->lock);
1153 atomic_set(&elm->refcount, 1);
1154 INIT_WORK(&elm->tx_work, elmcan_ldisc_tx_worker);
1156 /* Configure CAN metadata */
1157 elm->can.state = CAN_STATE_STOPPED;
1158 elm->can.bitrate_const = elmcan_bitrate_const;
1159 elm->can.bitrate_const_cnt = ARRAY_SIZE(elmcan_bitrate_const);
1160 elm->can.do_set_bittiming = elmcan_do_set_bittiming;
1161 elm->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY;
1163 /* Configure netlink interface */
1165 dev->netdev_ops = &elmcan_netdev_ops;
1167 /* Mark ldisc channel as alive */
1169 tty->disc_data = elm;
1171 devm_can_led_init(elm->dev);
1174 err = register_candev(elm->dev);
1178 netdev_info(elm->dev, "elmcan on %s.\n", tty->name);
1185 free_candev(elm->dev);
1189 /* Close down an elmcan channel.
1190 * This means flushing out any pending queues, and then returning.
1191 * This call is serialized against other ldisc functions:
1192 * Once this is called, no other ldisc function of ours is entered.
1194 * We also use this function for a hangup event.
1196 static void elmcan_ldisc_close(struct tty_struct *tty)
1198 struct elmcan *elm = get_elm(tty);
1203 /* unregister_netdev() calls .ndo_stop() so we don't have to. */
1204 unregister_candev(elm->dev);
1206 /* Decrease the refcount twice, once for our own get_elm(),
1207 * and once to remove the count of 1 that we set in _open().
1208 * Once it reaches 0, we can safely destroy it.
1213 while (atomic_read(&elm->refcount) > 0)
1214 msleep_interruptible(10);
1216 /* At this point, all ldisc calls to us have become no-ops. */
1218 flush_work(&elm->tx_work);
1220 /* Mark channel as dead */
1221 spin_lock_bh(&elm->lock);
1222 tty->disc_data = NULL;
1224 spin_unlock_bh(&elm->lock);
1226 netdev_info(elm->dev, "elmcan off %s.\n", tty->name);
1229 free_candev(elm->dev);
1232 static int elmcan_ldisc_hangup(struct tty_struct *tty)
1234 elmcan_ldisc_close(tty);
1238 static int elmcan_ldisc_ioctl(struct tty_struct *tty, struct file *file,
1239 unsigned int cmd, unsigned long arg)
1241 struct elmcan *elm = get_elm(tty);
1249 tmp = strnlen(elm->dev->name, IFNAMSIZ - 1) + 1;
1250 if (copy_to_user((void __user *)arg, elm->dev->name, tmp)) {
1264 return tty_mode_ioctl(tty, file, cmd, arg);
1268 static struct tty_ldisc_ops elmcan_ldisc = {
1269 .owner = THIS_MODULE,
1270 .magic = TTY_LDISC_MAGIC,
1272 .receive_buf = elmcan_ldisc_rx,
1273 .write_wakeup = elmcan_ldisc_tx_wakeup,
1274 .open = elmcan_ldisc_open,
1275 .close = elmcan_ldisc_close,
1276 .hangup = elmcan_ldisc_hangup,
1277 .ioctl = elmcan_ldisc_ioctl,
1282 static int __init elmcan_init(void)
1286 pr_info("ELM327 based best-effort CAN interface driver\n");
1287 pr_info("This device is severely limited as a CAN interface, see documentation.\n");
1289 status = tty_register_ldisc(N_ELMCAN, &elmcan_ldisc);
1291 pr_err("can't register line discipline\n");
1296 static void __exit elmcan_exit(void)
1298 /* This will only be called when all channels have been closed by
1299 * userspace - tty_ldisc.c takes care of the module's refcount.
1303 status = tty_unregister_ldisc(N_ELMCAN);
1305 pr_err("Can't unregister line discipline (error: %d)\n",
1309 module_init(elmcan_init);
1310 module_exit(elmcan_exit);