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