X-Git-Url: https://git.enpas.org/?a=blobdiff_plain;f=module%2Felmcan.c;h=a75ddf1c3b4288d773333bf7f9828168f067bf1c;hb=521a2bdc04a021a0e58bd093097b751951caf408;hp=ac7036e778c41b1740847e7f43436e0bb808d59c;hpb=ba6991254fbe7e3e650542b6280353b9532c51f5;p=elmcan.git diff --git a/module/elmcan.c b/module/elmcan.c index ac7036e..a75ddf1 100644 --- a/module/elmcan.c +++ b/module/elmcan.c @@ -4,9 +4,14 @@ * This driver started as a derivative of linux/drivers/net/can/slcan.c * and my thanks go to the original authors for their inspiration, even * after almost none of their code is left. + * + * elmcan.c Author : Max Staudt + * slcan.c Author : Oliver Hartkopp + * slip.c Authors : Laurence Culhane + * Fred N. van Kempen */ -#define pr_fmt(fmt) "[elmcan] " fmt +#define pr_fmt(fmt) "elmcan: " fmt #include #include @@ -20,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -37,23 +43,17 @@ #include #include -MODULE_ALIAS_LDISC(N_ELMCAN); -MODULE_DESCRIPTION("ELM327 based CAN interface"); -MODULE_LICENSE("GPL"); -MODULE_AUTHOR("Max Staudt "); - -/* If this is enabled, we'll try to make the best of the situation - * even if we receive unexpected characters on the line. - * No guarantees. - * Handle with care, it's likely your hardware is unreliable! +/* Line discipline ID number. + * N_DEVELOPMENT will likely be defined from Linux 5.18 onwards: + * https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty.git/commit/?h=tty-next&id=c2faf737abfb10f88f2d2612d573e9edc3c42c37 */ -static bool accept_flaky_uart; -module_param_named(accept_flaky_uart, accept_flaky_uart, bool, 0444); -MODULE_PARM_DESC(accept_flaky_uart, "Don't bail at the first invalid character. Behavior undefined."); +#ifndef N_DEVELOPMENT +#define N_DEVELOPMENT 29 +#endif -/* Line discipline ID number */ -#ifndef N_ELMCAN -#define N_ELMCAN 29 +/* Compatibility for Linux < 5.11 */ +#if LINUX_VERSION_CODE < KERNEL_VERSION(5,11,0) +#define len can_dlc #endif #define ELM327_NAPI_WEIGHT 4 @@ -66,21 +66,21 @@ MODULE_PARM_DESC(accept_flaky_uart, "Don't bail at the first invalid character. #define ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF 0x2000 #define ELM327_CAN_CONFIG_BAUDRATE_MULT_8_7 0x1000 -#define ELM327_MAGIC_CHAR 'y' -#define ELM327_MAGIC_STRING "y" +#define ELM327_DUMMY_CHAR 'y' +#define ELM327_DUMMY_STRING "y" #define ELM327_READY_CHAR '>' /* Bits in elm->cmds_todo */ -enum ELM_TODO { - TODO_CAN_DATA = 0, - TODO_CANID_11BIT, - TODO_CANID_29BIT_LOW, - TODO_CANID_29BIT_HIGH, - TODO_CAN_CONFIG_PART2, - TODO_CAN_CONFIG, - TODO_RESPONSES, - TODO_SILENT_MONITOR, - TODO_INIT +enum ELM327_TX_DO_BITS { + ELM327_TX_DO_CAN_DATA = 0, + ELM327_TX_DO_CANID_11BIT, + ELM327_TX_DO_CANID_29BIT_LOW, + ELM327_TX_DO_CANID_29BIT_HIGH, + ELM327_TX_DO_CAN_CONFIG_PART2, + ELM327_TX_DO_CAN_CONFIG, + ELM327_TX_DO_RESPONSES, + ELM327_TX_DO_SILENT_MONITOR, + ELM327_TX_DO_INIT }; struct elmcan { @@ -90,11 +90,11 @@ struct elmcan { struct can_rx_offload offload; /* TTY and netdev devices that we're bridging */ - struct tty_struct *tty; - struct net_device *dev; + struct tty_struct *tty; + struct net_device *dev; /* Per-channel lock */ - spinlock_t lock; + spinlock_t lock; /* Keep track of how many things are using this struct. * Once it reaches 0, we are in the process of cleaning up, @@ -103,18 +103,18 @@ struct elmcan { * decrement to 0, and refcount_dec() spills a WARN_ONCE in * that case. */ - atomic_t refcount; + atomic_t refcount; /* Stop the channel on hardware failure. * Once this is true, nothing will be sent to the TTY. */ - bool hw_failure; + bool hw_failure; /* TTY TX helpers */ - struct work_struct tx_work; /* Flushes TTY TX buffer */ - unsigned char *txbuf; - unsigned char *txhead; /* Pointer to next TX byte */ - int txleft; /* Bytes left to TX */ + struct work_struct tx_work; /* Flushes TTY TX buffer */ + unsigned char *txbuf; + unsigned char *txhead; /* Pointer to next TX byte */ + int txleft; /* Bytes left to TX */ /* TTY RX helpers */ unsigned char rxbuf[ELM327_SIZE_RXBUF]; @@ -122,22 +122,20 @@ struct elmcan { /* State machine */ enum { - ELM_NOTINIT = 0, - ELM_GETMAGICCHAR, - ELM_GETPROMPT, - ELM_RECEIVING, + ELM327_STATE_NOTINIT = 0, + ELM327_STATE_GETDUMMYCHAR, + ELM327_STATE_GETPROMPT, + ELM327_STATE_RECEIVING, } state; - int drop_next_line; + bool drop_next_line; /* The CAN frame and config the ELM327 is sending/using, * or will send/use after finishing all cmds_todo */ - struct can_frame can_frame; - unsigned short can_config; - unsigned long can_bitrate; - unsigned char can_bitrate_divisor; - int silent_monitoring; + struct can_frame can_frame_to_send; + u16 can_config; + u8 can_bitrate_divisor; /* Things we have yet to send */ char **next_init_cmd; @@ -153,11 +151,12 @@ static DEFINE_SPINLOCK(elmcan_discdata_lock); static inline void elm327_hw_failure(struct elmcan *elm); -/* Assumes elm->lock taken. */ static void elm327_send(struct elmcan *elm, const void *buf, size_t len) { int actual; + lockdep_assert_held(elm->lock); + if (elm->hw_failure) return; @@ -186,32 +185,32 @@ static void elm327_send(struct elmcan *elm, const void *buf, size_t len) } /* Take the ELM327 out of almost any state and back into command mode. - * We send ELM327_MAGIC_CHAR which will either abort any running + * We send ELM327_DUMMY_CHAR which will either abort any running * operation, or be echoed back to us in case we're already in command * mode. - * - * Assumes elm->lock taken. */ static void elm327_kick_into_cmd_mode(struct elmcan *elm) { - if (elm->state != ELM_GETMAGICCHAR && elm->state != ELM_GETPROMPT) { - elm327_send(elm, ELM327_MAGIC_STRING, 1); + lockdep_assert_held(elm->lock); - elm->state = ELM_GETMAGICCHAR; + if (elm->state != ELM327_STATE_GETDUMMYCHAR && + elm->state != ELM327_STATE_GETPROMPT) { + elm327_send(elm, ELM327_DUMMY_STRING, 1); + + elm->state = ELM327_STATE_GETDUMMYCHAR; } } -/* Schedule a CAN frame and necessary config changes to be sent to the TTY. - * - * Assumes elm->lock taken. - */ +/* Schedule a CAN frame and necessary config changes to be sent to the TTY. */ static void elm327_send_frame(struct elmcan *elm, struct can_frame *frame) { + lockdep_assert_held(elm->lock); + /* Schedule any necessary changes in ELM327's CAN configuration */ - if (elm->can_frame.can_id != frame->can_id) { + if (elm->can_frame_to_send.can_id != frame->can_id) { /* Set the new CAN ID for transmission. */ - if ((frame->can_id & CAN_EFF_FLAG) - ^ (elm->can_frame.can_id & CAN_EFF_FLAG)) { + if ((frame->can_id & CAN_EFF_FLAG) ^ + (elm->can_frame_to_send.can_id & CAN_EFF_FLAG)) { elm->can_config = (frame->can_id & CAN_EFF_FLAG ? 0 : ELM327_CAN_CONFIG_SEND_SFF) @@ -219,37 +218,34 @@ static void elm327_send_frame(struct elmcan *elm, struct can_frame *frame) | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF | elm->can_bitrate_divisor; - set_bit(TODO_CAN_CONFIG, &elm->cmds_todo); + set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo); } if (frame->can_id & CAN_EFF_FLAG) { - clear_bit(TODO_CANID_11BIT, &elm->cmds_todo); - set_bit(TODO_CANID_29BIT_LOW, &elm->cmds_todo); - set_bit(TODO_CANID_29BIT_HIGH, &elm->cmds_todo); + clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo); + set_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo); + set_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo); } else { - set_bit(TODO_CANID_11BIT, &elm->cmds_todo); - clear_bit(TODO_CANID_29BIT_LOW, &elm->cmds_todo); - clear_bit(TODO_CANID_29BIT_HIGH, &elm->cmds_todo); + set_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo); + clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo); + clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo); } } /* Schedule the CAN frame itself. */ - elm->can_frame = *frame; - set_bit(TODO_CAN_DATA, &elm->cmds_todo); + elm->can_frame_to_send = *frame; + set_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo); elm327_kick_into_cmd_mode(elm); } -/* ELM327 initialization sequence. - * - * Assumes elm->lock taken. - */ +/* ELM327 initialisation sequence. */ static char *elm327_init_script[] = { "AT WS\r", /* v1.0: Warm Start */ "AT PP FF OFF\r", /* v1.0: All Programmable Parameters Off */ "AT M0\r", /* v1.0: Memory Off */ "AT AL\r", /* v1.0: Allow Long messages */ - "AT BI\r", /* v1.0: Bypass Initialization */ + "AT BI\r", /* v1.0: Bypass Initialisation */ "AT CAF0\r", /* v1.0: CAN Auto Formatting Off */ "AT CFC0\r", /* v1.0: CAN Flow Control Off */ "AT CF 000\r", /* v1.0: Reset CAN ID Filter */ @@ -268,8 +264,10 @@ static char *elm327_init_script[] = { static void elm327_init(struct elmcan *elm) { - elm->state = ELM_NOTINIT; - elm->can_frame.can_id = 0x7df; + lockdep_assert_held(elm->lock); + + elm->state = ELM327_STATE_NOTINIT; + elm->can_frame_to_send.can_id = 0x7df; /* ELM327 HW default */ elm->rxfill = 0; elm->drop_next_line = 0; @@ -285,31 +283,22 @@ static void elm327_init(struct elmcan *elm) /* Configure ELM327 and then start monitoring */ elm->next_init_cmd = &elm327_init_script[0]; - set_bit(TODO_INIT, &elm->cmds_todo); - set_bit(TODO_SILENT_MONITOR, &elm->cmds_todo); - set_bit(TODO_RESPONSES, &elm->cmds_todo); - set_bit(TODO_CAN_CONFIG, &elm->cmds_todo); + set_bit(ELM327_TX_DO_INIT, &elm->cmds_todo); + set_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo); + set_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo); + set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo); elm327_kick_into_cmd_mode(elm); } -/* Assumes elm->lock taken. */ static void elm327_feed_frame_to_netdev(struct elmcan *elm, - const struct can_frame *frame) + struct sk_buff *skb) { - struct can_frame *cf; - struct sk_buff *skb; + lockdep_assert_held(elm->lock); if (!netif_running(elm->dev)) return; - skb = alloc_can_skb(elm->dev, &cf); - - if (!skb) - return; - - memcpy(cf, frame, sizeof(struct can_frame)); - /* Queue for NAPI pickup. * rx-offload will update stats and LEDs for us. */ @@ -322,95 +311,100 @@ static void elm327_feed_frame_to_netdev(struct elmcan *elm, #endif } -/* Called when we're out of ideas and just want it all to end. - * Assumes elm->lock taken. - */ +/* Called when we're out of ideas and just want it all to end. */ static inline void elm327_hw_failure(struct elmcan *elm) { - struct can_frame frame; - - memset(&frame, 0, sizeof(frame)); - frame.can_id = CAN_ERR_FLAG; - frame.can_dlc = CAN_ERR_DLC; - frame.data[5] = 'R'; - frame.data[6] = 'I'; - frame.data[7] = 'P'; - elm327_feed_frame_to_netdev(elm, &frame); + struct can_frame *frame; + struct sk_buff *skb; - netdev_err(elm->dev, "ELM327 misbehaved. Blocking further communication.\n"); + lockdep_assert_held(elm->lock); elm->hw_failure = true; + + elm->can.can_stats.bus_off++; + netif_stop_queue(elm->dev); + elm->can.state = CAN_STATE_BUS_OFF; can_bus_off(elm->dev); + + netdev_err(elm->dev, "ELM327 misbehaved. Blocking further communication.\n"); + + skb = alloc_can_err_skb(elm->dev, &frame); + if (!skb) + return; + + frame->can_id |= CAN_ERR_BUSOFF; + elm327_feed_frame_to_netdev(elm, skb); } /* Compare a buffer to a fixed string */ -static int _memstrcmp(const u8 *mem, const char *str) +static inline int _memstrcmp(const u8 *mem, const char *str) { return memcmp(mem, str, strlen(str)); } -/* Assumes elm->lock taken. */ -static void elm327_parse_error(struct elmcan *elm, int len) +/* Compare buffer to string length, then compare buffer to fixed string. + * This ensures two things: + * - It flags cases where the fixed string is only the start of the + * buffer, rather than exactly all of it. + * - It avoids byte comparisons in case the length doesn't match. + */ +static inline int _len_memstrcmp(const u8 *mem, size_t mem_len, const char *str) +{ + size_t str_len = strlen(str); + + return (mem_len != str_len) || memcmp(mem, str, str_len); +} + +static void elm327_parse_error(struct elmcan *elm, size_t len) { - struct can_frame frame; + struct can_frame *frame; + struct sk_buff *skb; + + lockdep_assert_held(elm->lock); - memset(&frame, 0, sizeof(frame)); - frame.can_id = CAN_ERR_FLAG; - frame.can_dlc = CAN_ERR_DLC; + skb = alloc_can_err_skb(elm->dev, &frame); + if (!skb) + /* It's okay to return here: + * The outer parsing loop will drop this UART buffer. + */ + return; /* Filter possible error messages based on length of RX'd line */ - switch (len) { - case 17: - if (!_memstrcmp(elm->rxbuf, "UNABLE TO CONNECT")) { - netdev_err(elm->dev, - "ELM327 reported UNABLE TO CONNECT. Please check your setup.\n"); - } - break; - case 11: - if (!_memstrcmp(elm->rxbuf, "BUFFER FULL")) { - /* This case will only happen if the last data - * line was complete. - * Otherwise, elm327_parse_frame() will heuristically - * emit this error frame instead. - */ - frame.can_id |= CAN_ERR_CRTL; - frame.data[1] = CAN_ERR_CRTL_RX_OVERFLOW; - } - break; - case 9: - if (!_memstrcmp(elm->rxbuf, "BUS ERROR")) - frame.can_id |= CAN_ERR_BUSERROR; - if (!_memstrcmp(elm->rxbuf, "CAN ERROR")) - frame.can_id |= CAN_ERR_PROT; - if (!_memstrcmp(elm->rxbuf, "rxbuf, "BUS BUSY")) { - frame.can_id |= CAN_ERR_PROT; - frame.data[2] = CAN_ERR_PROT_OVERLOAD; - } - if (!_memstrcmp(elm->rxbuf, "FB ERROR")) { - frame.can_id |= CAN_ERR_PROT; - frame.data[2] = CAN_ERR_PROT_TX; - } - break; - case 5: /* ERR is followed by two digits, hence line length 5 */ - if (!_memstrcmp(elm->rxbuf, "ERR")) { - netdev_err(elm->dev, "ELM327 reported an ERR%c%c. Please power it off and on again.\n", - elm->rxbuf[3], elm->rxbuf[4]); - frame.can_id |= CAN_ERR_CRTL; - } - break; - default: + if (!_len_memstrcmp(elm->rxbuf, len, "UNABLE TO CONNECT")) { + netdev_err(elm->dev, + "ELM327 reported UNABLE TO CONNECT. Please check your setup.\n"); + } else if (!_len_memstrcmp(elm->rxbuf, len, "BUFFER FULL")) { + /* This will only happen if the last data line was complete. + * Otherwise, elm327_parse_frame() will heuristically + * emit this kind of error frame instead. + */ + frame->can_id |= CAN_ERR_CRTL; + frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; + } else if (!_len_memstrcmp(elm->rxbuf, len, "BUS ERROR")) { + frame->can_id |= CAN_ERR_BUSERROR; + } else if (!_len_memstrcmp(elm->rxbuf, len, "CAN ERROR")) { + frame->can_id |= CAN_ERR_PROT; + } else if (!_len_memstrcmp(elm->rxbuf, len, "can_id |= CAN_ERR_PROT; + } else if (!_len_memstrcmp(elm->rxbuf, len, "BUS BUSY")) { + frame->can_id |= CAN_ERR_PROT; + frame->data[2] = CAN_ERR_PROT_OVERLOAD; + } else if (!_len_memstrcmp(elm->rxbuf, len, "FB ERROR")) { + frame->can_id |= CAN_ERR_PROT; + frame->data[2] = CAN_ERR_PROT_TX; + } else if (len == 5 && !_memstrcmp(elm->rxbuf, "ERR")) { + /* ERR is followed by two digits, hence line length 5 */ + netdev_err(elm->dev, "ELM327 reported an ERR%c%c. Please power it off and on again.\n", + elm->rxbuf[3], elm->rxbuf[4]); + frame->can_id |= CAN_ERR_CRTL; + } else { /* Something else has happened. * Maybe garbage on the UART line. * Emit a generic error frame. */ - break; } - elm327_feed_frame_to_netdev(elm, &frame); + elm327_feed_frame_to_netdev(elm, skb); } /* Parse CAN frames coming as ASCII from ELM327. @@ -424,17 +418,20 @@ static void elm327_parse_error(struct elmcan *elm, int len) * Instead of a payload, RTR indicates a remote request. * * We will use the spaces and line length to guess the format. - * - * Assumes elm->lock taken. */ -static int elm327_parse_frame(struct elmcan *elm, int len) +static int elm327_parse_frame(struct elmcan *elm, size_t len) { - struct can_frame frame; + struct can_frame *frame; + struct sk_buff *skb; int hexlen; int datastart; int i; - memset(&frame, 0, sizeof(frame)); + lockdep_assert_held(elm->lock); + + skb = alloc_can_skb(elm->dev, &frame); + if (!skb) + return -ENOMEM; /* Find first non-hex and non-space character: * - In the simplest case, there is none. @@ -448,12 +445,10 @@ static int elm327_parse_frame(struct elmcan *elm, int len) } } - /* If we accept stray characters coming in: - * Check for stray characters on a payload line. - * No idea what causes this. + /* Sanity check whether the line is really a clean hexdump, + * or terminated by an error message, or contains garbage. */ - if (accept_flaky_uart && - hexlen < len && + if (hexlen < len && !isdigit(elm->rxbuf[hexlen]) && !isupper(elm->rxbuf[hexlen]) && '<' != elm->rxbuf[hexlen] && @@ -471,10 +466,9 @@ static int elm327_parse_frame(struct elmcan *elm, int len) if (elm->rxbuf[2] == ' ' && elm->rxbuf[5] == ' ' && elm->rxbuf[8] == ' ' && elm->rxbuf[11] == ' ' && elm->rxbuf[13] == ' ') { - frame.can_id = CAN_EFF_FLAG; + frame->can_id = CAN_EFF_FLAG; datastart = 14; } else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') { - frame.can_id = 0; datastart = 6; } else { /* This is not a well-formatted data line. @@ -495,44 +489,43 @@ static int elm327_parse_frame(struct elmcan *elm, int len) */ /* Read CAN data length */ - frame.can_dlc = (hex_to_bin(elm->rxbuf[datastart - 2]) << 0); + frame->len = (hex_to_bin(elm->rxbuf[datastart - 2]) << 0); /* Read CAN ID */ - if (frame.can_id & CAN_EFF_FLAG) { - frame.can_id |= (hex_to_bin(elm->rxbuf[0]) << 28) - | (hex_to_bin(elm->rxbuf[1]) << 24) - | (hex_to_bin(elm->rxbuf[3]) << 20) - | (hex_to_bin(elm->rxbuf[4]) << 16) - | (hex_to_bin(elm->rxbuf[6]) << 12) - | (hex_to_bin(elm->rxbuf[7]) << 8) - | (hex_to_bin(elm->rxbuf[9]) << 4) - | (hex_to_bin(elm->rxbuf[10]) << 0); + if (frame->can_id & CAN_EFF_FLAG) { + frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 28) + | (hex_to_bin(elm->rxbuf[1]) << 24) + | (hex_to_bin(elm->rxbuf[3]) << 20) + | (hex_to_bin(elm->rxbuf[4]) << 16) + | (hex_to_bin(elm->rxbuf[6]) << 12) + | (hex_to_bin(elm->rxbuf[7]) << 8) + | (hex_to_bin(elm->rxbuf[9]) << 4) + | (hex_to_bin(elm->rxbuf[10]) << 0); } else { - frame.can_id |= (hex_to_bin(elm->rxbuf[0]) << 8) - | (hex_to_bin(elm->rxbuf[1]) << 4) - | (hex_to_bin(elm->rxbuf[2]) << 0); + frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 8) + | (hex_to_bin(elm->rxbuf[1]) << 4) + | (hex_to_bin(elm->rxbuf[2]) << 0); } /* Check for RTR frame */ if (elm->rxfill >= hexlen + 3 && !_memstrcmp(&elm->rxbuf[hexlen], "RTR")) { - frame.can_id |= CAN_RTR_FLAG; + frame->can_id |= CAN_RTR_FLAG; } /* Is the line long enough to hold the advertised payload? * Note: RTR frames have a DLC, but no actual payload. */ - if (!(frame.can_id & CAN_RTR_FLAG) && - (hexlen < frame.can_dlc * 3 + datastart)) { - /* Incomplete frame. */ - - /* Probably the ELM327's RS232 TX buffer was full. + if (!(frame->can_id & CAN_RTR_FLAG) && + (hexlen < frame->len * 3 + datastart)) { + /* Incomplete frame. + * Probably the ELM327's RS232 TX buffer was full. * Emit an error frame and exit. */ - frame.can_id = CAN_ERR_FLAG | CAN_ERR_CRTL; - frame.can_dlc = CAN_ERR_DLC; - frame.data[1] = CAN_ERR_CRTL_RX_OVERFLOW; - elm327_feed_frame_to_netdev(elm, &frame); + frame->can_id = CAN_ERR_FLAG | CAN_ERR_CRTL; + frame->len = CAN_ERR_DLC; + frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; + elm327_feed_frame_to_netdev(elm, skb); /* Signal failure to parse. * The line will be re-parsed as an error line, which will fail. @@ -543,20 +536,21 @@ static int elm327_parse_frame(struct elmcan *elm, int len) } /* Parse the data nibbles. */ - for (i = 0; i < frame.can_dlc; i++) { - frame.data[i] = (hex_to_bin(elm->rxbuf[datastart + 3*i]) << 4) - | (hex_to_bin(elm->rxbuf[datastart + 3*i + 1])); + for (i = 0; i < frame->len; i++) { + frame->data[i] = (hex_to_bin(elm->rxbuf[datastart + 3*i]) << 4) + | (hex_to_bin(elm->rxbuf[datastart + 3*i + 1])); } /* Feed the frame to the network layer. */ - elm327_feed_frame_to_netdev(elm, &frame); + elm327_feed_frame_to_netdev(elm, skb); return 0; } -/* Assumes elm->lock taken. */ -static void elm327_parse_line(struct elmcan *elm, int len) +static void elm327_parse_line(struct elmcan *elm, size_t len) { + lockdep_assert_held(elm->lock); + /* Skip empty lines */ if (!len) return; @@ -570,74 +564,70 @@ static void elm327_parse_line(struct elmcan *elm, int len) } /* Regular parsing */ - switch (elm->state) { - case ELM_RECEIVING: - if (elm327_parse_frame(elm, len)) { - /* Parse an error line. */ - elm327_parse_error(elm, len); + if (elm->state == ELM327_STATE_RECEIVING + && elm327_parse_frame(elm, len)) { + /* Parse an error line. */ + elm327_parse_error(elm, len); - /* Start afresh. */ - elm327_kick_into_cmd_mode(elm); - } - break; - default: - break; + /* Start afresh. */ + elm327_kick_into_cmd_mode(elm); } } -/* Assumes elm->lock taken. */ static void elm327_handle_prompt(struct elmcan *elm) { - struct can_frame *frame = &elm->can_frame; + struct can_frame *frame = &elm->can_frame_to_send; char local_txbuf[20]; + lockdep_assert_held(elm->lock); + if (!elm->cmds_todo) { /* Enter CAN monitor mode */ elm327_send(elm, "ATMA\r", 5); - elm->state = ELM_RECEIVING; + elm->state = ELM327_STATE_RECEIVING; return; } /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */ - if (test_bit(TODO_INIT, &elm->cmds_todo)) { + if (test_bit(ELM327_TX_DO_INIT, &elm->cmds_todo)) { strcpy(local_txbuf, *elm->next_init_cmd); elm->next_init_cmd++; if (!(*elm->next_init_cmd)) { - clear_bit(TODO_INIT, &elm->cmds_todo); - netdev_info(elm->dev, "Initialization finished.\n"); + clear_bit(ELM327_TX_DO_INIT, &elm->cmds_todo); + /* Init finished. */ } - } else if (test_and_clear_bit(TODO_SILENT_MONITOR, &elm->cmds_todo)) { + } else if (test_and_clear_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo)) { sprintf(local_txbuf, "ATCSM%i\r", !(!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY))); - } else if (test_and_clear_bit(TODO_RESPONSES, &elm->cmds_todo)) { + } else if (test_and_clear_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo)) { sprintf(local_txbuf, "ATR%i\r", !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)); - } else if (test_and_clear_bit(TODO_CAN_CONFIG, &elm->cmds_todo)) { + } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo)) { sprintf(local_txbuf, "ATPC\r"); - set_bit(TODO_CAN_CONFIG_PART2, &elm->cmds_todo); + set_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo); - } else if (test_and_clear_bit(TODO_CAN_CONFIG_PART2, &elm->cmds_todo)) { + } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo)) { sprintf(local_txbuf, "ATPB%04X\r", elm->can_config); - } else if (test_and_clear_bit(TODO_CANID_29BIT_HIGH, &elm->cmds_todo)) { + } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo)) { sprintf(local_txbuf, "ATCP%02X\r", (frame->can_id & CAN_EFF_MASK) >> 24); - } else if (test_and_clear_bit(TODO_CANID_29BIT_LOW, &elm->cmds_todo)) { + } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo)) { sprintf(local_txbuf, "ATSH%06X\r", frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1)); - } else if (test_and_clear_bit(TODO_CANID_11BIT, &elm->cmds_todo)) { + } else if (test_and_clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo)) { sprintf(local_txbuf, "ATSH%03X\r", frame->can_id & CAN_SFF_MASK); - } else if (test_and_clear_bit(TODO_CAN_DATA, &elm->cmds_todo)) { + } else if (test_and_clear_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo)) { if (frame->can_id & CAN_RTR_FLAG) { /* Send an RTR frame. Their DLC is fixed. * Some chips don't send them at all. @@ -647,7 +637,7 @@ static void elm327_handle_prompt(struct elmcan *elm) /* Send a regular CAN data frame */ int i; - for (i = 0; i < frame->can_dlc; i++) { + for (i = 0; i < frame->len; i++) { sprintf(&local_txbuf[2 * i], "%02X", frame->data[i]); } @@ -656,7 +646,7 @@ static void elm327_handle_prompt(struct elmcan *elm) } elm->drop_next_line = 1; - elm->state = ELM_RECEIVING; + elm->state = ELM327_STATE_RECEIVING; } elm327_send(elm, local_txbuf, strlen(local_txbuf)); @@ -670,36 +660,37 @@ static bool elm327_is_ready_char(char c) return (c & 0x3f) == ELM327_READY_CHAR; } -/* Assumes elm->lock taken. */ -static void elm327_drop_bytes(struct elmcan *elm, int i) +static void elm327_drop_bytes(struct elmcan *elm, size_t i) { + lockdep_assert_held(elm->lock); + memmove(&elm->rxbuf[0], &elm->rxbuf[i], ELM327_SIZE_RXBUF - i); elm->rxfill -= i; } -/* Assumes elm->lock taken. */ static void elm327_parse_rxbuf(struct elmcan *elm) { - int len; + size_t len; + int i; + + lockdep_assert_held(elm->lock); switch (elm->state) { - case ELM_NOTINIT: + case ELM327_STATE_NOTINIT: elm->rxfill = 0; break; - case ELM_GETMAGICCHAR: + case ELM327_STATE_GETDUMMYCHAR: { /* Wait for 'y' or '>' */ - int i; - for (i = 0; i < elm->rxfill; i++) { - if (elm->rxbuf[i] == ELM327_MAGIC_CHAR) { + if (elm->rxbuf[i] == ELM327_DUMMY_CHAR) { elm327_send(elm, "\r", 1); - elm->state = ELM_GETPROMPT; + elm->state = ELM327_STATE_GETPROMPT; i++; break; } else if (elm327_is_ready_char(elm->rxbuf[i])) { - elm327_send(elm, ELM327_MAGIC_STRING, 1); + elm327_send(elm, ELM327_DUMMY_STRING, 1); i++; break; } @@ -710,7 +701,7 @@ static void elm327_parse_rxbuf(struct elmcan *elm) break; } - case ELM_GETPROMPT: + case ELM327_STATE_GETPROMPT: /* Wait for '>' */ if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) elm327_handle_prompt(elm); @@ -718,7 +709,7 @@ static void elm327_parse_rxbuf(struct elmcan *elm) elm->rxfill = 0; break; - case ELM_RECEIVING: + case ELM327_STATE_RECEIVING: /* Find delimiting feedback lines. */ for (len = 0; (len < elm->rxfill) && (elm->rxbuf[len] != '\r'); @@ -826,7 +817,7 @@ static int elmcan_netdev_close(struct net_device *dev) spin_lock_bh(&elm->lock); if (elm->tty) { /* Interrupt whatever we're doing right now */ - elm327_send(elm, ELM327_MAGIC_STRING, 1); + elm327_send(elm, ELM327_DUMMY_STRING, 1); /* Clear the wakeup bit, as the netdev will be down and thus * the wakeup handler won't clear it @@ -856,14 +847,6 @@ static netdev_tx_t elmcan_netdev_start_xmit(struct sk_buff *skb, struct elmcan *elm = netdev_priv(dev); struct can_frame *frame = (struct can_frame *)skb->data; - if (skb->len != sizeof(struct can_frame)) - goto out; - - if (!netif_running(dev)) { - netdev_warn(elm->dev, "xmit: iface is down.\n"); - goto out; - } - /* BHs are already disabled, so no spin_lock_bh(). * See Documentation/networking/netdevices.txt */ @@ -887,7 +870,7 @@ static netdev_tx_t elmcan_netdev_start_xmit(struct sk_buff *skb, spin_unlock(&elm->lock); dev->stats.tx_packets++; - dev->stats.tx_bytes += frame->can_dlc; + dev->stats.tx_bytes += frame->len; can_led_event(dev, CAN_LED_EVENT_TX); @@ -938,10 +921,9 @@ static void put_elm(struct elmcan *elm) static bool elmcan_is_valid_rx_char(char c) { - return (accept_flaky_uart || - isdigit(c) || + return (isdigit(c) || isupper(c) || - c == ELM327_MAGIC_CHAR || + c == ELM327_DUMMY_CHAR || c == ELM327_READY_CHAR || c == '<' || c == 'a' || @@ -1261,7 +1243,7 @@ static int elmcan_ldisc_ioctl(struct tty_struct *tty, static struct tty_ldisc_ops elmcan_ldisc = { .owner = THIS_MODULE, .name = "elmcan", - .num = N_ELMCAN, + .num = N_DEVELOPMENT, .receive_buf = elmcan_ldisc_rx, .write_wakeup = elmcan_ldisc_tx_wakeup, .open = elmcan_ldisc_open, @@ -1275,7 +1257,7 @@ static int __init elmcan_init(void) int status; #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0) - status = tty_register_ldisc(N_ELMCAN, &elmcan_ldisc); + status = tty_register_ldisc(N_DEVELOPMENT, &elmcan_ldisc); #else status = tty_register_ldisc(&elmcan_ldisc); #endif @@ -1293,7 +1275,7 @@ static void __exit elmcan_exit(void) #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0) int status; - status = tty_unregister_ldisc(N_ELMCAN); + status = tty_unregister_ldisc(N_DEVELOPMENT); if (status) pr_err("Can't unregister line discipline (error: %d)\n", status); @@ -1304,3 +1286,8 @@ static void __exit elmcan_exit(void) module_init(elmcan_init); module_exit(elmcan_exit); + +MODULE_ALIAS_LDISC(N_DEVELOPMENT); +MODULE_DESCRIPTION("ELM327 based CAN interface"); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Max Staudt ");