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