module/elmcan.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* ELM327 based CAN interface driver (tty line discipline)
   3  *
   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, even
   6  * after almost none of their code is left.
   7  *
   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>
  12  */
  13
  14 #define pr_fmt(fmt) "elmcan: " fmt
  15
  16 #include <linux/init.h>
  17 #include <linux/module.h>
  18 #include <linux/moduleparam.h>
  19
  20 #include <linux/atomic.h>
  21 #include <linux/bitops.h>
  22 #include <linux/ctype.h>
  23 #include <linux/delay.h>
  24 #include <linux/errno.h>
  25 #include <linux/if_ether.h>
  26 #include <linux/kernel.h>
  27 #include <linux/list.h>
  28 #include <linux/lockdep.h>
  29 #include <linux/netdevice.h>
  30 #include <linux/skbuff.h>
  31 #include <linux/spinlock.h>
  32 #include <linux/string.h>
  33 #include <linux/tty.h>
  34 #include <linux/tty_ldisc.h>
  35 #include <linux/version.h>
  36 #include <linux/workqueue.h>
  37
  38 #include <uapi/linux/tty.h>
  39
  40 #include <linux/can.h>
  41 #include <linux/can/dev.h>
  42 #include <linux/can/error.h>
  43 #include <linux/can/led.h>
  44 #include <linux/can/rx-offload.h>
  45
  46 /* Line discipline ID number.
  47  * N_DEVELOPMENT will likely be defined from Linux 5.18 onwards:
  48  * https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty.git/commit/?h=tty-next&id=c2faf737abfb10f88f2d2612d573e9edc3c42c37
  49  */
  50 #ifndef N_DEVELOPMENT
  51 #define N_DEVELOPMENT 29
  52 #endif
  53
  54 /* Compatibility for Linux < 5.11 */
  55 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,11,0)
  56 #define len can_dlc
  57 #endif
  58
  59 #define ELM327_NAPI_WEIGHT 4
  60
  61 #define ELM327_SIZE_RXBUF 224
  62 #define ELM327_SIZE_TXBUF 32
  63
  64 #define ELM327_CAN_CONFIG_SEND_SFF           0x8000
  65 #define ELM327_CAN_CONFIG_VARIABLE_DLC       0x4000
  66 #define ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF  0x2000
  67 #define ELM327_CAN_CONFIG_BAUDRATE_MULT_8_7  0x1000
  68
  69 #define ELM327_DUMMY_CHAR 'y'
  70 #define ELM327_DUMMY_STRING "y"
  71 #define ELM327_READY_CHAR '>'
  72
  73 /* Bits in elm->cmds_todo */
  74 enum elm327_to_to_do_bits {
  75         ELM327_TX_DO_CAN_DATA = 0,
  76         ELM327_TX_DO_CANID_11BIT,
  77         ELM327_TX_DO_CANID_29BIT_LOW,
  78         ELM327_TX_DO_CANID_29BIT_HIGH,
  79         ELM327_TX_DO_CAN_CONFIG_PART2,
  80         ELM327_TX_DO_CAN_CONFIG,
  81         ELM327_TX_DO_RESPONSES,
  82         ELM327_TX_DO_SILENT_MONITOR,
  83         ELM327_TX_DO_INIT
  84 };
  85
  86 struct elmcan {
  87         /* This must be the first member when using alloc_candev() */
  88         struct can_priv can;
  89
  90         struct can_rx_offload offload;
  91
  92         /* TTY buffers */
  93         u8 rxbuf[ELM327_SIZE_RXBUF];
  94         u8 txbuf[ELM327_SIZE_TXBUF] ____cacheline_aligned;
  95
  96         /* TTY buffer accounting */
  97         struct work_struct tx_work;     /* Flushes TTY TX buffer */
  98         u8 *txhead;                     /* Next TX byte */
  99         unsigned txleft;                /* Bytes left to TX */
 100         int rxfill;                     /* Bytes already RX'd in buffer */
 101
 102         /* TTY and netdev devices that we're bridging */
 103         struct tty_struct *tty;
 104         struct net_device *dev;
 105
 106         /* Per-channel lock */
 107         spinlock_t lock;
 108
 109         /* State machine */
 110         enum {
 111                 ELM327_STATE_NOTINIT = 0,
 112                 ELM327_STATE_GETDUMMYCHAR,
 113                 ELM327_STATE_GETPROMPT,
 114                 ELM327_STATE_RECEIVING,
 115         } state;
 116
 117         /* Things we have yet to send */
 118         char **next_init_cmd;
 119         unsigned long cmds_todo;
 120
 121         /* The CAN frame and config the ELM327 is sending/using,
 122          * or will send/use after finishing all cmds_todo
 123          */
 124         struct can_frame can_frame_to_send;
 125         u16 can_config;
 126         u8 can_bitrate_divisor;
 127
 128         /* Parser state */
 129         bool drop_next_line;
 130
 131         /* Stop the channel on UART side hardware failure, e.g. stray
 132          * characters or neverending lines. This may be caused by bad
 133          * UART wiring, a bad ELM327, a bad UART bridge...
 134          * Once this is true, nothing will be sent to the TTY.
 135          */
 136         bool uart_side_failure;
 137 };
 138
 139 static inline void elm327_uart_side_failure(struct elmcan *elm);
 140
 141 static void elm327_send(struct elmcan *elm, const void *buf, size_t len)
 142 {
 143         int written;
 144
 145         lockdep_assert_held(elm->lock);
 146
 147         if (elm->uart_side_failure)
 148                 return;
 149
 150         memcpy(elm->txbuf, buf, len);
 151
 152         written = elm->tty->ops->write(elm->tty, elm->txbuf, len);
 153         if (written < 0) {
 154                 netdev_err(elm->dev,
 155                            "Failed to write to tty %s.\n",
 156                            elm->tty->name);
 157                 elm327_uart_side_failure(elm);
 158                 return;
 159         }
 160
 161         elm->txleft = len - written;
 162         elm->txhead = elm->txbuf + written;
 163
 164         if (!elm->txleft)
 165                 netif_wake_queue(elm->dev);
 166         else
 167                 set_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
 168 }
 169
 170 /* Take the ELM327 out of almost any state and back into command mode.
 171  * We send ELM327_DUMMY_CHAR which will either abort any running
 172  * operation, or be echoed back to us in case we're already in command
 173  * mode.
 174  */
 175 static void elm327_kick_into_cmd_mode(struct elmcan *elm)
 176 {
 177         lockdep_assert_held(elm->lock);
 178
 179         if (elm->state != ELM327_STATE_GETDUMMYCHAR &&
 180             elm->state != ELM327_STATE_GETPROMPT) {
 181                 elm327_send(elm, ELM327_DUMMY_STRING, 1);
 182
 183                 elm->state = ELM327_STATE_GETDUMMYCHAR;
 184         }
 185 }
 186
 187 /* Schedule a CAN frame and necessary config changes to be sent to the TTY. */
 188 static void elm327_send_frame(struct elmcan *elm, struct can_frame *frame)
 189 {
 190         lockdep_assert_held(elm->lock);
 191
 192         /* Schedule any necessary changes in ELM327's CAN configuration */
 193         if (elm->can_frame_to_send.can_id != frame->can_id) {
 194                 /* Set the new CAN ID for transmission. */
 195                 if ((frame->can_id & CAN_EFF_FLAG) ^
 196                     (elm->can_frame_to_send.can_id & CAN_EFF_FLAG)) {
 197                         elm->can_config = (frame->can_id & CAN_EFF_FLAG
 198                                                 ? 0
 199                                                 : ELM327_CAN_CONFIG_SEND_SFF)
 200                                         | ELM327_CAN_CONFIG_VARIABLE_DLC
 201                                         | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF
 202                                         | elm->can_bitrate_divisor;
 203
 204                         set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
 205                 }
 206
 207                 if (frame->can_id & CAN_EFF_FLAG) {
 208                         clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo);
 209                         set_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
 210                         set_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo);
 211                 } else {
 212                         set_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo);
 213                         clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
 214                         clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo);
 215                 }
 216         }
 217
 218         /* Schedule the CAN frame itself. */
 219         elm->can_frame_to_send = *frame;
 220         set_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo);
 221
 222         elm327_kick_into_cmd_mode(elm);
 223 }
 224
 225 /* ELM327 initialisation sequence.
 226  * The line length is limited by the buffer in elm327_handle_prompt().
 227  */
 228 static char *elm327_init_script[] = {
 229         "AT WS\r",        /* v1.0: Warm Start */
 230         "AT PP FF OFF\r", /* v1.0: All Programmable Parameters Off */
 231         "AT M0\r",        /* v1.0: Memory Off */
 232         "AT AL\r",        /* v1.0: Allow Long messages */
 233         "AT BI\r",        /* v1.0: Bypass Initialisation */
 234         "AT CAF0\r",      /* v1.0: CAN Auto Formatting Off */
 235         "AT CFC0\r",      /* v1.0: CAN Flow Control Off */
 236         "AT CF 000\r",    /* v1.0: Reset CAN ID Filter */
 237         "AT CM 000\r",    /* v1.0: Reset CAN ID Mask */
 238         "AT E1\r",        /* v1.0: Echo On */
 239         "AT H1\r",        /* v1.0: Headers On */
 240         "AT L0\r",        /* v1.0: Linefeeds Off */
 241         "AT SH 7DF\r",    /* v1.0: Set CAN sending ID to 0x7df */
 242         "AT ST FF\r",     /* v1.0: Set maximum Timeout for response after TX */
 243         "AT AT0\r",       /* v1.2: Adaptive Timing Off */
 244         "AT D1\r",        /* v1.3: Print DLC On */
 245         "AT S1\r",        /* v1.3: Spaces On */
 246         "AT TP B\r",      /* v1.0: Try Protocol B */
 247         NULL
 248 };
 249
 250 static void elm327_init(struct elmcan *elm)
 251 {
 252         lockdep_assert_held(elm->lock);
 253
 254         elm->state = ELM327_STATE_NOTINIT;
 255         elm->can_frame_to_send.can_id = 0x7df; /* ELM327 HW default */
 256         elm->rxfill = 0;
 257         elm->drop_next_line = 0;
 258
 259         /* We can only set the bitrate as a fraction of 500000.
 260          * The bit timing constants in elmcan_bittiming_const will
 261          * limit the user to the right values.
 262          */
 263         elm->can_bitrate_divisor = 500000 / elm->can.bittiming.bitrate;
 264         elm->can_config = ELM327_CAN_CONFIG_SEND_SFF
 265                         | ELM327_CAN_CONFIG_VARIABLE_DLC
 266                         | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF
 267                         | elm->can_bitrate_divisor;
 268
 269         /* Configure ELM327 and then start monitoring */
 270         elm->next_init_cmd = &elm327_init_script[0];
 271         set_bit(ELM327_TX_DO_INIT, &elm->cmds_todo);
 272         set_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo);
 273         set_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo);
 274         set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
 275
 276         elm327_kick_into_cmd_mode(elm);
 277 }
 278
 279 static void elm327_feed_frame_to_netdev(struct elmcan *elm,
 280                                         struct sk_buff *skb)
 281 {
 282         lockdep_assert_held(elm->lock);
 283
 284         if (!netif_running(elm->dev))
 285                 return;
 286
 287         /* Queue for NAPI pickup.
 288          * rx-offload will update stats and LEDs for us.
 289          */
 290         if (can_rx_offload_queue_tail(&elm->offload, skb))
 291                 elm->dev->stats.rx_fifo_errors++;
 292
 293 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5,15,0)
 294         /* Wake NAPI */
 295         can_rx_offload_irq_finish(&elm->offload);
 296 #endif
 297 }
 298
 299 /* Called when we're out of ideas and just want it all to end. */
 300 static inline void elm327_uart_side_failure(struct elmcan *elm)
 301 {
 302         struct can_frame *frame;
 303         struct sk_buff *skb;
 304
 305         lockdep_assert_held(elm->lock);
 306
 307         elm->uart_side_failure = true;
 308
 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);
 313
 314         netdev_err(elm->dev, "ELM327 misbehaved. Blocking further communication.\n");
 315
 316         skb = alloc_can_err_skb(elm->dev, &frame);
 317         if (!skb)
 318                 return;
 319
 320         frame->can_id |= CAN_ERR_BUSOFF;
 321         elm327_feed_frame_to_netdev(elm, skb);
 322 }
 323
 324 /* Compare buffer to string length, then compare buffer to fixed string.
 325  * This ensures two things:
 326  *  - It flags cases where the fixed string is only the start of the
 327  *    buffer, rather than exactly all of it.
 328  *  - It avoids byte comparisons in case the length doesn't match.
 329  *
 330  * strncmp() cannot be used here because it accepts the following wrong case:
 331  *   strncmp("CAN ER", "CAN ERROR", 6);
 332  * This must fail, hence this helper function.
 333  */
 334 static inline int check_len_then_cmp(const u8 *mem, size_t mem_len, const char *str)
 335 {
 336         size_t str_len = strlen(str);
 337
 338         return (mem_len == str_len) && !memcmp(mem, str, str_len);
 339 }
 340
 341 static void elm327_parse_error(struct elmcan *elm, size_t len)
 342 {
 343         struct can_frame *frame;
 344         struct sk_buff *skb;
 345
 346         lockdep_assert_held(elm->lock);
 347
 348         skb = alloc_can_err_skb(elm->dev, &frame);
 349         if (!skb)
 350                 /* It's okay to return here:
 351                  * The outer parsing loop will drop this UART buffer.
 352                  */
 353                 return;
 354
 355         /* Filter possible error messages based on length of RX'd line */
 356         if (check_len_then_cmp(elm->rxbuf, len, "UNABLE TO CONNECT")) {
 357                 netdev_err(elm->dev,
 358                            "ELM327 reported UNABLE TO CONNECT. Please check your setup.\n");
 359         } else if (check_len_then_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.
 363                  */
 364                 frame->can_id |= CAN_ERR_CRTL;
 365                 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 366         } else if (check_len_then_cmp(elm->rxbuf, len, "BUS ERROR")) {
 367                 frame->can_id |= CAN_ERR_BUSERROR;
 368         } else if (check_len_then_cmp(elm->rxbuf, len, "CAN ERROR")) {
 369                 frame->can_id |= CAN_ERR_PROT;
 370         } else if (check_len_then_cmp(elm->rxbuf, len, "<RX ERROR")) {
 371                 frame->can_id |= CAN_ERR_PROT;
 372         } else if (check_len_then_cmp(elm->rxbuf, len, "BUS BUSY")) {
 373                 frame->can_id |= CAN_ERR_PROT;
 374                 frame->data[2] = CAN_ERR_PROT_OVERLOAD;
 375         } else if (check_len_then_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;
 383         } else {
 384                 /* Something else has happened.
 385                  * Maybe garbage on the UART line.
 386                  * Emit a generic error frame.
 387                  */
 388         }
 389
 390         elm327_feed_frame_to_netdev(elm, skb);
 391 }
 392
 393 /* Parse CAN frames coming as ASCII from ELM327.
 394  * They can be of various formats:
 395  *
 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
 398  *
 399  * where D = DLC, PL = payload byte
 400  *
 401  * Instead of a payload, RTR indicates a remote request.
 402  *
 403  * We will use the spaces and line length to guess the format.
 404  */
 405 static int elm327_parse_frame(struct elmcan *elm, size_t len)
 406 {
 407         struct can_frame *frame;
 408         struct sk_buff *skb;
 409         int hexlen;
 410         int datastart;
 411         int i;
 412
 413         lockdep_assert_held(elm->lock);
 414
 415         skb = alloc_can_skb(elm->dev, &frame);
 416         if (!skb)
 417                 return -ENOMEM;
 418
 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.
 423          */
 424         for (hexlen = 0; hexlen <= len; hexlen++) {
 425                 if (hex_to_bin(elm->rxbuf[hexlen]) < 0 &&
 426                     elm->rxbuf[hexlen] != ' ') {
 427                         break;
 428                 }
 429         }
 430
 431         /* Sanity check whether the line is really a clean hexdump,
 432          * or terminated by an error message, or contains garbage.
 433          */
 434         if (hexlen < len &&
 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.
 441                  */
 442                 return -ENODATA;
 443         }
 444
 445         /* Use spaces in CAN ID to distinguish 29 or 11 bit address length.
 446          * No out-of-bounds access:
 447          * We use the fact that we can always read from elm->rxbuf.
 448          */
 449         if (elm->rxbuf[2] == ' ' && elm->rxbuf[5] == ' ' &&
 450             elm->rxbuf[8] == ' ' && elm->rxbuf[11] == ' ' &&
 451             elm->rxbuf[13] == ' ') {
 452                 frame->can_id = CAN_EFF_FLAG;
 453                 datastart = 14;
 454         } else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') {
 455                 datastart = 6;
 456         } else {
 457                 /* This is not a well-formatted data line.
 458                  * Assume it's an error message.
 459                  */
 460                 return -ENODATA;
 461         }
 462
 463         if (hexlen < datastart) {
 464                 /* The line is too short to be a valid frame hex dump.
 465                  * Something interrupted the hex dump or it is invalid.
 466                  */
 467                 return -ENODATA;
 468         }
 469
 470         /* From here on all chars up to buf[hexlen] are hex or spaces,
 471          * at well-defined offsets.
 472          */
 473
 474         /* Read CAN data length */
 475         frame->len = (hex_to_bin(elm->rxbuf[datastart - 2]) << 0);
 476
 477         /* Read CAN ID */
 478         if (frame->can_id & CAN_EFF_FLAG) {
 479                 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 28)
 480                                | (hex_to_bin(elm->rxbuf[1]) << 24)
 481                                | (hex_to_bin(elm->rxbuf[3]) << 20)
 482                                | (hex_to_bin(elm->rxbuf[4]) << 16)
 483                                | (hex_to_bin(elm->rxbuf[6]) << 12)
 484                                | (hex_to_bin(elm->rxbuf[7]) << 8)
 485                                | (hex_to_bin(elm->rxbuf[9]) << 4)
 486                                | (hex_to_bin(elm->rxbuf[10]) << 0);
 487         } else {
 488                 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 8)
 489                                | (hex_to_bin(elm->rxbuf[1]) << 4)
 490                                | (hex_to_bin(elm->rxbuf[2]) << 0);
 491         }
 492
 493         /* Check for RTR frame */
 494         if (elm->rxfill >= hexlen + 3 &&
 495             !memcmp(&elm->rxbuf[hexlen], "RTR", 3)) {
 496                 frame->can_id |= CAN_RTR_FLAG;
 497         }
 498
 499         /* Is the line long enough to hold the advertised payload?
 500          * Note: RTR frames have a DLC, but no actual payload.
 501          */
 502         if (!(frame->can_id & CAN_RTR_FLAG) &&
 503             (hexlen < frame->len * 3 + datastart)) {
 504                 /* Incomplete frame.
 505                  * Probably the ELM327's RS232 TX buffer was full.
 506                  * Emit an error frame and exit.
 507                  */
 508                 frame->can_id = CAN_ERR_FLAG | CAN_ERR_CRTL;
 509                 frame->len = CAN_ERR_DLC;
 510                 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 511                 elm327_feed_frame_to_netdev(elm, skb);
 512
 513                 /* Signal failure to parse.
 514                  * The line will be re-parsed as an error line, which will fail.
 515                  * However, this will correctly drop the state machine back into
 516                  * command mode.
 517                  */
 518                 return -ENODATA;
 519         }
 520
 521         /* Parse the data nibbles. */
 522         for (i = 0; i < frame->len; i++) {
 523                 frame->data[i] = (hex_to_bin(elm->rxbuf[datastart + 3*i]) << 4)
 524                                | (hex_to_bin(elm->rxbuf[datastart + 3*i + 1]));
 525         }
 526
 527         /* Feed the frame to the network layer. */
 528         elm327_feed_frame_to_netdev(elm, skb);
 529
 530         return 0;
 531 }
 532
 533 static void elm327_parse_line(struct elmcan *elm, size_t len)
 534 {
 535         lockdep_assert_held(elm->lock);
 536
 537         /* Skip empty lines */
 538         if (!len)
 539                 return;
 540
 541         /* Skip echo lines */
 542         if (elm->drop_next_line) {
 543                 elm->drop_next_line = 0;
 544                 return;
 545         } else if (!memcmp(elm->rxbuf, "AT", 2)) {
 546                 return;
 547         }
 548
 549         /* Regular parsing */
 550         if (elm->state == ELM327_STATE_RECEIVING
 551             && elm327_parse_frame(elm, len)) {
 552                 /* Parse an error line. */
 553                 elm327_parse_error(elm, len);
 554
 555                 /* Start afresh. */
 556                 elm327_kick_into_cmd_mode(elm);
 557         }
 558 }
 559
 560 static void elm327_handle_prompt(struct elmcan *elm)
 561 {
 562         struct can_frame *frame = &elm->can_frame_to_send;
 563         /* Size this buffer for the largest ELM327 line we may generate,
 564          * which is currently an 8 byte CAN frame's payload hexdump.
 565          * Items in elm327_init_script must fit here, too!
 566          */
 567         char local_txbuf[sizeof("0102030405060708\r")];
 568
 569         lockdep_assert_held(elm->lock);
 570
 571         if (!elm->cmds_todo) {
 572                 /* Enter CAN monitor mode */
 573                 elm327_send(elm, "ATMA\r", 5);
 574                 elm->state = ELM327_STATE_RECEIVING;
 575
 576                 return;
 577         }
 578
 579         /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */
 580         if (test_bit(ELM327_TX_DO_INIT, &elm->cmds_todo)) {
 581                 snprintf(local_txbuf, sizeof(local_txbuf),
 582                         "%s",
 583                         *elm->next_init_cmd);
 584
 585                 elm->next_init_cmd++;
 586                 if (!(*elm->next_init_cmd)) {
 587                         clear_bit(ELM327_TX_DO_INIT, &elm->cmds_todo);
 588                         /* Init finished. */
 589                 }
 590
 591         } else if (test_and_clear_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo)) {
 592                 snprintf(local_txbuf, sizeof(local_txbuf),
 593                         "ATCSM%i\r",
 594                         !(!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)));
 595
 596         } else if (test_and_clear_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo)) {
 597                 snprintf(local_txbuf, sizeof(local_txbuf),
 598                         "ATR%i\r",
 599                         !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
 600
 601         } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo)) {
 602                 snprintf(local_txbuf, sizeof(local_txbuf),
 603                         "ATPC\r");
 604                 set_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo);
 605
 606         } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo)) {
 607                 snprintf(local_txbuf, sizeof(local_txbuf),
 608                         "ATPB%04X\r",
 609                         elm->can_config);
 610
 611         } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo)) {
 612                 snprintf(local_txbuf, sizeof(local_txbuf),
 613                         "ATCP%02X\r",
 614                         (frame->can_id & CAN_EFF_MASK) >> 24);
 615
 616         } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo)) {
 617                 snprintf(local_txbuf, sizeof(local_txbuf),
 618                         "ATSH%06X\r",
 619                         frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1));
 620
 621         } else if (test_and_clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo)) {
 622                 snprintf(local_txbuf, sizeof(local_txbuf),
 623                         "ATSH%03X\r",
 624                         frame->can_id & CAN_SFF_MASK);
 625
 626         } else if (test_and_clear_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo)) {
 627                 if (frame->can_id & CAN_RTR_FLAG) {
 628                         /* Send an RTR frame. Their DLC is fixed.
 629                          * Some chips don't send them at all.
 630                          */
 631                         snprintf(local_txbuf, sizeof(local_txbuf),
 632                                 "ATRTR\r");
 633                 } else {
 634                         /* Send a regular CAN data frame */
 635                         int i;
 636
 637                         for (i = 0; i < frame->len; i++) {
 638                                 snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
 639                                         "%02X",
 640                                         frame->data[i]);
 641                         }
 642
 643                         snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
 644                                 "\r");
 645                 }
 646
 647                 elm->drop_next_line = 1;
 648                 elm->state = ELM327_STATE_RECEIVING;
 649         }
 650
 651         elm327_send(elm, local_txbuf, strlen(local_txbuf));
 652 }
 653
 654 static bool elm327_is_ready_char(char c)
 655 {
 656         /* Bits 0xc0 are sometimes set (randomly), hence the mask.
 657          * Probably bad hardware.
 658          */
 659         return (c & 0x3f) == ELM327_READY_CHAR;
 660 }
 661
 662 static void elm327_drop_bytes(struct elmcan *elm, size_t i)
 663 {
 664         lockdep_assert_held(elm->lock);
 665
 666         memmove(&elm->rxbuf[0], &elm->rxbuf[i], ELM327_SIZE_RXBUF - i);
 667         elm->rxfill -= i;
 668 }
 669
 670 static void elm327_parse_rxbuf(struct elmcan *elm)
 671 {
 672         size_t len;
 673         int i;
 674
 675         lockdep_assert_held(elm->lock);
 676
 677         switch (elm->state) {
 678         case ELM327_STATE_NOTINIT:
 679                 elm->rxfill = 0;
 680                 break;
 681
 682         case ELM327_STATE_GETDUMMYCHAR:
 683         {
 684                 /* Wait for 'y' or '>' */
 685                 for (i = 0; i < elm->rxfill; i++) {
 686                         if (elm->rxbuf[i] == ELM327_DUMMY_CHAR) {
 687                                 elm327_send(elm, "\r", 1);
 688                                 elm->state = ELM327_STATE_GETPROMPT;
 689                                 i++;
 690                                 break;
 691                         } else if (elm327_is_ready_char(elm->rxbuf[i])) {
 692                                 elm327_send(elm, ELM327_DUMMY_STRING, 1);
 693                                 i++;
 694                                 break;
 695                         }
 696                 }
 697
 698                 elm327_drop_bytes(elm, i);
 699
 700                 break;
 701         }
 702
 703         case ELM327_STATE_GETPROMPT:
 704                 /* Wait for '>' */
 705                 if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1]))
 706                         elm327_handle_prompt(elm);
 707
 708                 elm->rxfill = 0;
 709                 break;
 710
 711         case ELM327_STATE_RECEIVING:
 712                 /* Find <CR> delimiting feedback lines. */
 713                 for (len = 0;
 714                      (len < elm->rxfill) && (elm->rxbuf[len] != '\r');
 715                      len++) {
 716                         /* empty loop */
 717                 }
 718
 719                 if (len == ELM327_SIZE_RXBUF) {
 720                         /* Line exceeds buffer. It's probably all garbage.
 721                          * Did we even connect at the right baud rate?
 722                          */
 723                         netdev_err(elm->dev,
 724                                    "RX buffer overflow. Faulty ELM327 or UART?\n");
 725                         elm327_uart_side_failure(elm);
 726                         break;
 727                 } else if (len == elm->rxfill) {
 728                         if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) {
 729                                 /* The ELM327's AT ST response timeout ran out,
 730                                  * so we got a prompt.
 731                                  * Clear RX buffer and restart listening.
 732                                  */
 733                                 elm->rxfill = 0;
 734
 735                                 elm327_handle_prompt(elm);
 736                                 break;
 737                         }
 738
 739                         /* No <CR> found - we haven't received a full line yet.
 740                          * Wait for more data.
 741                          */
 742                         break;
 743                 }
 744
 745                 /* We have a full line to parse. */
 746                 elm327_parse_line(elm, len);
 747
 748                 /* Remove parsed data from RX buffer. */
 749                 elm327_drop_bytes(elm, len + 1);
 750
 751                 /* More data to parse? */
 752                 if (elm->rxfill)
 753                         elm327_parse_rxbuf(elm);
 754         }
 755 }
 756
 757 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
 758 /* Dummy needed to use can_rx_offload */
 759 static struct sk_buff *elmcan_mailbox_read(struct can_rx_offload *offload,
 760                                            unsigned int n, u32 *timestamp,
 761                                            bool drop)
 762 {
 763         WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
 764
 765         return ERR_PTR(-ENOBUFS);
 766 }
 767 #endif
 768
 769 static int elmcan_netdev_open(struct net_device *dev)
 770 {
 771         struct elmcan *elm = netdev_priv(dev);
 772         int err;
 773
 774         spin_lock_bh(&elm->lock);
 775
 776         if (!elm->tty) {
 777                 spin_unlock_bh(&elm->lock);
 778                 return -ENODEV;
 779         }
 780
 781         if (elm->uart_side_failure)
 782                 netdev_warn(elm->dev, "Reopening netdev after a UART side fault has been detected.\n");
 783
 784         /* Clear TTY buffers */
 785         elm->rxfill = 0;
 786         elm->txleft = 0;
 787
 788         /* open_candev() checks for elm->can.bittiming.bitrate != 0 */
 789         err = open_candev(dev);
 790         if (err) {
 791                 spin_unlock_bh(&elm->lock);
 792                 return err;
 793         }
 794
 795         elm327_init(elm);
 796         spin_unlock_bh(&elm->lock);
 797
 798 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
 799         elm->offload.mailbox_read = elmcan_mailbox_read;
 800         err = can_rx_offload_add_fifo(dev, &elm->offload, ELM327_NAPI_WEIGHT);
 801 #else
 802         err = can_rx_offload_add_manual(dev, &elm->offload, ELM327_NAPI_WEIGHT);
 803 #endif
 804         if (err) {
 805                 close_candev(dev);
 806                 return err;
 807         }
 808
 809         can_rx_offload_enable(&elm->offload);
 810
 811         can_led_event(dev, CAN_LED_EVENT_OPEN);
 812         elm->can.state = CAN_STATE_ERROR_ACTIVE;
 813         netif_start_queue(dev);
 814
 815         return 0;
 816 }
 817
 818 static int elmcan_netdev_close(struct net_device *dev)
 819 {
 820         struct elmcan *elm = netdev_priv(dev);
 821
 822         /* Interrupt whatever the ELM327 is doing right now */
 823         spin_lock_bh(&elm->lock);
 824         elm327_send(elm, ELM327_DUMMY_STRING, 1);
 825         spin_unlock_bh(&elm->lock);
 826
 827         /* Give UART one final chance to flush.
 828          * This may netif_wake_queue(), so don't netif_stop_queue()
 829          * before flushing the worker.
 830          */
 831         clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
 832         flush_work(&elm->tx_work);
 833
 834         netif_stop_queue(dev);
 835
 836         can_rx_offload_disable(&elm->offload);
 837         elm->can.state = CAN_STATE_STOPPED;
 838         can_rx_offload_del(&elm->offload);
 839         close_candev(dev);
 840         can_led_event(dev, CAN_LED_EVENT_STOP);
 841
 842         return 0;
 843 }
 844
 845 /* Send a can_frame to a TTY. */
 846 static netdev_tx_t elmcan_netdev_start_xmit(struct sk_buff *skb,
 847                                             struct net_device *dev)
 848 {
 849         struct elmcan *elm = netdev_priv(dev);
 850         struct can_frame *frame = (struct can_frame *)skb->data;
 851
 852         if (can_dropped_invalid_skb(dev, skb))
 853                 return NETDEV_TX_OK;
 854
 855         /* BHs are already disabled, so no spin_lock_bh().
 856          * See Documentation/networking/netdevices.txt
 857          */
 858         spin_lock(&elm->lock);
 859
 860         /* We shouldn't get here after a hardware fault:
 861          * can_bus_off() calls netif_carrier_off()
 862          */
 863         WARN_ON_ONCE(elm->uart_side_failure);
 864
 865         if (!elm->tty ||
 866             elm->uart_side_failure ||
 867             elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) {
 868                 spin_unlock(&elm->lock);
 869                 goto out;
 870         }
 871
 872         netif_stop_queue(dev);
 873
 874         elm327_send_frame(elm, frame);
 875         spin_unlock(&elm->lock);
 876
 877         dev->stats.tx_packets++;
 878         dev->stats.tx_bytes += frame->len;
 879
 880         can_led_event(dev, CAN_LED_EVENT_TX);
 881
 882 out:
 883         kfree_skb(skb);
 884         return NETDEV_TX_OK;
 885 }
 886
 887 static const struct net_device_ops elmcan_netdev_ops = {
 888         .ndo_open       = elmcan_netdev_open,
 889         .ndo_stop       = elmcan_netdev_close,
 890         .ndo_start_xmit = elmcan_netdev_start_xmit,
 891         .ndo_change_mtu = can_change_mtu,
 892 };
 893
 894 static bool elmcan_is_valid_rx_char(char c)
 895 {
 896         return (isdigit(c) ||
 897                 isupper(c) ||
 898                 c == ELM327_DUMMY_CHAR ||
 899                 c == ELM327_READY_CHAR ||
 900                 c == '<' ||
 901                 c == 'a' ||
 902                 c == 'b' ||
 903                 c == 'v' ||
 904                 c == '.' ||
 905                 c == '?' ||
 906                 c == '\r' ||
 907                 c == ' ');
 908 }
 909
 910 /* Handle incoming ELM327 ASCII data.
 911  * This will not be re-entered while running, but other ldisc
 912  * functions may be called in parallel.
 913  */
 914 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
 915 static void elmcan_ldisc_rx(struct tty_struct *tty,
 916                             const unsigned char *cp, char *fp, int count)
 917 #else
 918 static void elmcan_ldisc_rx(struct tty_struct *tty,
 919                             const unsigned char *cp, const char *fp, int count)
 920 #endif
 921 {
 922         struct elmcan *elm = (struct elmcan *)tty->disc_data;
 923
 924         spin_lock_bh(&elm->lock);
 925
 926         if (elm->uart_side_failure)
 927                 goto out;
 928
 929         while (count-- && elm->rxfill < ELM327_SIZE_RXBUF) {
 930                 if (fp && *fp++) {
 931                         netdev_err(elm->dev, "Error in received character stream. Check your wiring.");
 932
 933                         elm327_uart_side_failure(elm);
 934
 935                         goto out;
 936                 }
 937
 938                 /* Ignore NUL characters, which the PIC microcontroller may
 939                  * inadvertently insert due to a known hardware bug.
 940                  * See ELM327 documentation, which refers to a Microchip PIC
 941                  * bug description.
 942                  */
 943                 if (*cp != 0) {
 944                         /* Check for stray characters on the UART line.
 945                          * Likely caused by bad hardware.
 946                          */
 947                         if (!elmcan_is_valid_rx_char(*cp)) {
 948                                 netdev_err(elm->dev,
 949                                            "Received illegal character %02x.\n",
 950                                            *cp);
 951                                 elm327_uart_side_failure(elm);
 952
 953                                 goto out;
 954                         }
 955
 956                         elm->rxbuf[elm->rxfill++] = *cp;
 957                 }
 958
 959                 cp++;
 960         }
 961
 962         if (count >= 0) {
 963                 netdev_err(elm->dev, "Receive buffer overflowed. Bad chip or wiring?");
 964
 965                 elm327_uart_side_failure(elm);
 966
 967                 goto out;
 968         }
 969
 970         elm327_parse_rxbuf(elm);
 971
 972 out:
 973         spin_unlock_bh(&elm->lock);
 974 }
 975
 976 /* Write out remaining transmit buffer.
 977  * Scheduled when TTY is writable.
 978  */
 979 static void elmcan_ldisc_tx_worker(struct work_struct *work)
 980 {
 981         struct elmcan *elm = container_of(work, struct elmcan, tx_work);
 982         ssize_t written;
 983
 984         if (elm->uart_side_failure)
 985                 return;
 986
 987         spin_lock_bh(&elm->lock);
 988
 989         if (elm->txleft) {
 990                 written = elm->tty->ops->write(elm->tty, elm->txhead, elm->txleft);
 991                 if (written < 0) {
 992                         netdev_err(elm->dev,
 993                                    "Failed to write to tty %s.\n",
 994                                    elm->tty->name);
 995                         elm327_uart_side_failure(elm);
 996                         spin_unlock_bh(&elm->lock);
 997                         return;
 998                 } else {
 999                         elm->txleft -= written;
1000                         elm->txhead += written;
1001                 }
1002         }
1003
1004         if (!elm->txleft)  {
1005                 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
1006                 spin_unlock_bh(&elm->lock);
1007                 netif_wake_queue(elm->dev);
1008         } else {
1009                 spin_unlock_bh(&elm->lock);
1010         }
1011 }
1012
1013 /* Called by the driver when there's room for more data. */
1014 static void elmcan_ldisc_tx_wakeup(struct tty_struct *tty)
1015 {
1016         struct elmcan *elm = (struct elmcan *)tty->disc_data;
1017
1018         schedule_work(&elm->tx_work);
1019 }
1020
1021 /* ELM327 can only handle bitrates that are integer divisors of 500 kHz,
1022  * or 7/8 of that. Divisors are 1 to 64.
1023  * Currently we don't implement support for 7/8 rates.
1024  */
1025 static const u32 elmcan_bitrate_const[64] = {
1026          7812,  7936,  8064,  8196,  8333,  8474,  8620,  8771,
1027          8928,  9090,  9259,  9433,  9615,  9803, 10000, 10204,
1028         10416, 10638, 10869, 11111, 11363, 11627, 11904, 12195,
1029         12500, 12820, 13157, 13513, 13888, 14285, 14705, 15151,
1030         15625, 16129, 16666, 17241, 17857, 18518, 19230, 20000,
1031         20833, 21739, 22727, 23809, 25000, 26315, 27777, 29411,
1032         31250, 33333, 35714, 38461, 41666, 45454, 50000, 55555,
1033         62500, 71428, 83333, 100000, 125000, 166666, 250000, 500000
1034 };
1035
1036 /* Dummy needed to use bitrate_const */
1037 static int elmcan_do_set_bittiming(struct net_device *netdev)
1038 {
1039         return 0;
1040 }
1041
1042 static int elmcan_ldisc_open(struct tty_struct *tty)
1043 {
1044         struct net_device *dev;
1045         struct elmcan *elm;
1046         int err;
1047
1048         if (!capable(CAP_NET_ADMIN))
1049                 return -EPERM;
1050
1051         if (!tty->ops->write)
1052                 return -EOPNOTSUPP;
1053
1054         dev = alloc_candev(sizeof(struct elmcan), 0);
1055         if (!dev)
1056                 return -ENFILE;
1057         elm = netdev_priv(dev);
1058
1059         /* Configure TTY interface */
1060         tty->receive_room = 65536; /* We don't flow control */
1061         spin_lock_init(&elm->lock);
1062         INIT_WORK(&elm->tx_work, elmcan_ldisc_tx_worker);
1063
1064         /* Configure CAN metadata */
1065         elm->can.bitrate_const = elmcan_bitrate_const;
1066         elm->can.bitrate_const_cnt = ARRAY_SIZE(elmcan_bitrate_const);
1067         elm->can.do_set_bittiming = elmcan_do_set_bittiming;
1068         elm->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY;
1069
1070         /* Configure netdev interface */
1071         elm->dev = dev;
1072         dev->netdev_ops = &elmcan_netdev_ops;
1073
1074         /* Mark ldisc channel as alive */
1075         elm->tty = tty;
1076         tty->disc_data = elm;
1077
1078         devm_can_led_init(elm->dev);
1079
1080         /* Let 'er rip */
1081         err = register_candev(elm->dev);
1082         if (err)
1083                 goto out_err;
1084
1085         netdev_info(elm->dev, "elmcan on %s.\n", tty->name);
1086
1087         return 0;
1088
1089 out_err:
1090         free_candev(elm->dev);
1091         return err;
1092 }
1093
1094 /* Close down an elmcan channel.
1095  * This means flushing out any pending queues, and then returning.
1096  * This call is serialized against other ldisc functions:
1097  * Once this is called, no other ldisc function of ours is entered.
1098  *
1099  * We also use this function for a hangup event.
1100  */
1101 static void elmcan_ldisc_close(struct tty_struct *tty)
1102 {
1103         struct elmcan *elm = (struct elmcan *)tty->disc_data;
1104
1105         /* unregister_netdev() calls .ndo_stop() so we don't have to.
1106          * Our .ndo_stop() also flushes the TTY write wakeup handler,
1107          * so we can safely set elm->tty = NULL after this.
1108          */
1109         unregister_candev(elm->dev);
1110
1111         /* Mark channel as dead */
1112         spin_lock_bh(&elm->lock);
1113         tty->disc_data = NULL;
1114         elm->tty = NULL;
1115         spin_unlock_bh(&elm->lock);
1116
1117         netdev_info(elm->dev, "elmcan off %s.\n", tty->name);
1118
1119         free_candev(elm->dev);
1120 }
1121
1122 static int elmcan_ldisc_ioctl(struct tty_struct *tty,
1123 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,17,0)
1124                               struct file *file,
1125 #endif
1126                               unsigned int cmd, unsigned long arg)
1127 {
1128         struct elmcan *elm = (struct elmcan *)tty->disc_data;
1129         unsigned int tmp;
1130
1131         switch (cmd) {
1132         case SIOCGIFNAME:
1133                 tmp = strnlen(elm->dev->name, IFNAMSIZ - 1) + 1;
1134                 if (copy_to_user((void __user *)arg, elm->dev->name, tmp))
1135                         return -EFAULT;
1136                 return 0;
1137
1138         case SIOCSIFHWADDR:
1139                 return -EINVAL;
1140
1141         default:
1142 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
1143                 return tty_mode_ioctl(tty, file, cmd, arg);
1144 #else
1145                 return tty_mode_ioctl(tty, cmd, arg);
1146 #endif
1147         }
1148 }
1149
1150 static struct tty_ldisc_ops elmcan_ldisc = {
1151         .owner          = THIS_MODULE,
1152         .name           = "elmcan",
1153         .num            = N_DEVELOPMENT,
1154         .receive_buf    = elmcan_ldisc_rx,
1155         .write_wakeup   = elmcan_ldisc_tx_wakeup,
1156         .open           = elmcan_ldisc_open,
1157         .close          = elmcan_ldisc_close,
1158         .ioctl          = elmcan_ldisc_ioctl,
1159 };
1160
1161 static int __init elmcan_init(void)
1162 {
1163         int status;
1164
1165 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1166         status = tty_register_ldisc(N_DEVELOPMENT, &elmcan_ldisc);
1167 #else
1168         status = tty_register_ldisc(&elmcan_ldisc);
1169 #endif
1170         if (status)
1171                 pr_err("Can't register line discipline\n");
1172
1173         return status;
1174 }
1175
1176 static void __exit elmcan_exit(void)
1177 {
1178         /* This will only be called when all channels have been closed by
1179          * userspace - tty_ldisc.c takes care of the module's refcount.
1180          */
1181 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1182         int status;
1183
1184         status = tty_unregister_ldisc(N_DEVELOPMENT);
1185         if (status)
1186                 pr_err("Can't unregister line discipline (error: %d)\n",
1187                        status);
1188 #else
1189         tty_unregister_ldisc(&elmcan_ldisc);
1190 #endif
1191 }
1192
1193 module_init(elmcan_init);
1194 module_exit(elmcan_exit);
1195
1196 MODULE_ALIAS_LDISC(N_DEVELOPMENT);
1197 MODULE_DESCRIPTION("ELM327 based CAN interface");
1198 MODULE_LICENSE("GPL");
1199 MODULE_AUTHOR("Max Staudt <max-linux@enpas.org>");