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 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,5,0)
 762 static unsigned int *can327_mailbox_read(struct can_rx_offload *offload,
 763                                          struct can_frame *cf,
 764                                          u32 *timestamp, unsigned int n)
 765 {
 766         WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
 767
 768         return -ENOBUFS;
 769 }
 770 #else /* Since 4e9c9484b085 (included in v5.5) */
 771 static struct sk_buff *can327_mailbox_read(struct can_rx_offload *offload,
 772                                            unsigned int n, u32 *timestamp,
 773                                            bool drop)
 774 {
 775         WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
 776
 777         return ERR_PTR(-ENOBUFS);
 778 }
 779 #endif
 780 #endif
 781
 782 static int can327_netdev_open(struct net_device *dev)
 783 {
 784         struct can327 *elm = netdev_priv(dev);
 785         int err;
 786
 787         spin_lock_bh(&elm->lock);
 788
 789         if (!elm->tty) {
 790                 spin_unlock_bh(&elm->lock);
 791                 return -ENODEV;
 792         }
 793
 794         if (elm->uart_side_failure)
 795                 netdev_warn(elm->dev,
 796                             "Reopening netdev after a UART side fault has been detected.\n");
 797
 798         /* Clear TTY buffers */
 799         elm->rxfill = 0;
 800         elm->txleft = 0;
 801
 802         /* open_candev() checks for elm->can.bittiming.bitrate != 0 */
 803         err = open_candev(dev);
 804         if (err) {
 805                 spin_unlock_bh(&elm->lock);
 806                 return err;
 807         }
 808
 809         can327_init_device(elm);
 810         spin_unlock_bh(&elm->lock);
 811
 812 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
 813         elm->offload.mailbox_read = can327_mailbox_read;
 814         err = can_rx_offload_add_fifo(dev, &elm->offload, CAN327_NAPI_WEIGHT);
 815 #else
 816         err = can_rx_offload_add_manual(dev, &elm->offload, CAN327_NAPI_WEIGHT);
 817 #endif
 818         if (err) {
 819                 close_candev(dev);
 820                 return err;
 821         }
 822
 823         can_rx_offload_enable(&elm->offload);
 824
 825         elm->can.state = CAN_STATE_ERROR_ACTIVE;
 826         netif_start_queue(dev);
 827
 828         return 0;
 829 }
 830
 831 static int can327_netdev_close(struct net_device *dev)
 832 {
 833         struct can327 *elm = netdev_priv(dev);
 834
 835         /* Interrupt whatever the ELM327 is doing right now */
 836         spin_lock_bh(&elm->lock);
 837         can327_send(elm, CAN327_DUMMY_STRING, 1);
 838         spin_unlock_bh(&elm->lock);
 839
 840         netif_stop_queue(dev);
 841
 842         /* Give UART one final chance to flush. */
 843         clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
 844         flush_work(&elm->tx_work);
 845
 846         can_rx_offload_disable(&elm->offload);
 847         elm->can.state = CAN_STATE_STOPPED;
 848         can_rx_offload_del(&elm->offload);
 849         close_candev(dev);
 850
 851         return 0;
 852 }
 853
 854 /* Send a can_frame to a TTY. */
 855 static netdev_tx_t can327_netdev_start_xmit(struct sk_buff *skb,
 856                                             struct net_device *dev)
 857 {
 858         struct can327 *elm = netdev_priv(dev);
 859         struct can_frame *frame = (struct can_frame *)skb->data;
 860
 861         if (can_dropped_invalid_skb(dev, skb))
 862                 return NETDEV_TX_OK;
 863
 864         /* This check will be part of can_dropped_invalid_skb()
 865          * in future kernels.
 866          */
 867         if (elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
 868                 goto out;
 869
 870         /* We shouldn't get here after a hardware fault:
 871          * can_bus_off() calls netif_carrier_off()
 872          */
 873         if (elm->uart_side_failure) {
 874                 WARN_ON_ONCE(elm->uart_side_failure);
 875                 goto out;
 876         }
 877
 878         netif_stop_queue(dev);
 879
 880         /* BHs are already disabled, so no spin_lock_bh().
 881          * See Documentation/networking/netdevices.txt
 882          */
 883         spin_lock(&elm->lock);
 884         can327_send_frame(elm, frame);
 885         spin_unlock(&elm->lock);
 886
 887         dev->stats.tx_packets++;
 888         dev->stats.tx_bytes += frame->can_id & CAN_RTR_FLAG ? 0 : frame->len;
 889
 890 out:
 891         kfree_skb(skb);
 892         return NETDEV_TX_OK;
 893 }
 894
 895 static const struct net_device_ops can327_netdev_ops = {
 896         .ndo_open = can327_netdev_open,
 897         .ndo_stop = can327_netdev_close,
 898         .ndo_start_xmit = can327_netdev_start_xmit,
 899         .ndo_change_mtu = can_change_mtu,
 900 };
 901
 902 static bool can327_is_valid_rx_char(u8 c)
 903 {
 904         static const bool lut_char_is_valid['z'] = {
 905                 ['\r'] = true,
 906                 [' '] = true,
 907                 ['.'] = true,
 908                 ['0'] = true, true, true, true, true,
 909                 ['5'] = true, true, true, true, true,
 910                 ['<'] = true,
 911                 [CAN327_READY_CHAR] = true,
 912                 ['?'] = true,
 913                 ['A'] = true, true, true, true, true, true, true,
 914                 ['H'] = true, true, true, true, true, true, true,
 915                 ['O'] = true, true, true, true, true, true, true,
 916                 ['V'] = true, true, true, true, true,
 917                 ['a'] = true,
 918                 ['b'] = true,
 919                 ['v'] = true,
 920                 [CAN327_DUMMY_CHAR] = true,
 921         };
 922         BUILD_BUG_ON(CAN327_DUMMY_CHAR >= 'z');
 923
 924         return (c < ARRAY_SIZE(lut_char_is_valid) && lut_char_is_valid[c]);
 925 }
 926
 927 /* Handle incoming ELM327 ASCII data.
 928  * This will not be re-entered while running, but other ldisc
 929  * functions may be called in parallel.
 930  */
 931 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
 932 static void can327_ldisc_rx(struct tty_struct *tty,
 933                             const unsigned char *cp, char *fp, int count)
 934 #else
 935 static void can327_ldisc_rx(struct tty_struct *tty,
 936                             const unsigned char *cp, const char *fp, int count)
 937 #endif
 938 {
 939         struct can327 *elm = (struct can327 *)tty->disc_data;
 940         size_t first_new_char_idx;
 941
 942         if (elm->uart_side_failure)
 943                 return;
 944
 945         spin_lock_bh(&elm->lock);
 946
 947         /* Store old rxfill, so can327_parse_rxbuf() will have
 948          * the option of skipping already checked characters.
 949          */
 950         first_new_char_idx = elm->rxfill;
 951
 952         while (count-- && elm->rxfill < CAN327_SIZE_RXBUF) {
 953                 if (fp && *fp++) {
 954                         netdev_err(elm->dev,
 955                                    "Error in received character stream. Check your wiring.");
 956
 957                         can327_uart_side_failure(elm);
 958
 959                         spin_unlock_bh(&elm->lock);
 960                         return;
 961                 }
 962
 963                 /* Ignore NUL characters, which the PIC microcontroller may
 964                  * inadvertently insert due to a known hardware bug.
 965                  * See ELM327 documentation, which refers to a Microchip PIC
 966                  * bug description.
 967                  */
 968                 if (*cp) {
 969                         /* Check for stray characters on the UART line.
 970                          * Likely caused by bad hardware.
 971                          */
 972                         if (!can327_is_valid_rx_char(*cp)) {
 973                                 netdev_err(elm->dev,
 974                                            "Received illegal character %02x.\n",
 975                                            *cp);
 976                                 can327_uart_side_failure(elm);
 977
 978                                 spin_unlock_bh(&elm->lock);
 979                                 return;
 980                         }
 981
 982                         elm->rxbuf[elm->rxfill++] = *cp;
 983                 }
 984
 985                 cp++;
 986         }
 987
 988         if (count >= 0) {
 989                 netdev_err(elm->dev,
 990                            "Receive buffer overflowed. Bad chip or wiring? count = %i",
 991                            count);
 992
 993                 can327_uart_side_failure(elm);
 994
 995                 spin_unlock_bh(&elm->lock);
 996                 return;
 997         }
 998
 999         can327_parse_rxbuf(elm, first_new_char_idx);
1000         spin_unlock_bh(&elm->lock);
1001 }
1002
1003 /* Write out remaining transmit buffer.
1004  * Scheduled when TTY is writable.
1005  */
1006 static void can327_ldisc_tx_worker(struct work_struct *work)
1007 {
1008         struct can327 *elm = container_of(work, struct can327, tx_work);
1009         ssize_t written;
1010
1011         if (elm->uart_side_failure)
1012                 return;
1013
1014         spin_lock_bh(&elm->lock);
1015
1016         if (elm->txleft) {
1017                 written = elm->tty->ops->write(elm->tty, elm->txhead,
1018                                                elm->txleft);
1019                 if (written < 0) {
1020                         netdev_err(elm->dev, "Failed to write to tty %s.\n",
1021                                    elm->tty->name);
1022                         can327_uart_side_failure(elm);
1023
1024                         spin_unlock_bh(&elm->lock);
1025                         return;
1026                 }
1027
1028                 elm->txleft -= written;
1029                 elm->txhead += written;
1030         }
1031
1032         if (!elm->txleft)
1033                 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
1034
1035         spin_unlock_bh(&elm->lock);
1036 }
1037
1038 /* Called by the driver when there's room for more data. */
1039 static void can327_ldisc_tx_wakeup(struct tty_struct *tty)
1040 {
1041         struct can327 *elm = (struct can327 *)tty->disc_data;
1042
1043         schedule_work(&elm->tx_work);
1044 }
1045
1046 /* ELM327 can only handle bitrates that are integer divisors of 500 kHz,
1047  * or 7/8 of that. Divisors are 1 to 64.
1048  * Currently we don't implement support for 7/8 rates.
1049  */
1050 static const u32 can327_bitrate_const[] = {
1051         7812,  7936,  8064,  8196,   8333,   8474,   8620,   8771,
1052         8928,  9090,  9259,  9433,   9615,   9803,   10000,  10204,
1053         10416, 10638, 10869, 11111,  11363,  11627,  11904,  12195,
1054         12500, 12820, 13157, 13513,  13888,  14285,  14705,  15151,
1055         15625, 16129, 16666, 17241,  17857,  18518,  19230,  20000,
1056         20833, 21739, 22727, 23809,  25000,  26315,  27777,  29411,
1057         31250, 33333, 35714, 38461,  41666,  45454,  50000,  55555,
1058         62500, 71428, 83333, 100000, 125000, 166666, 250000, 500000
1059 };
1060
1061 /* Dummy needed to use bitrate_const */
1062 static int can327_do_set_bittiming(struct net_device *netdev)
1063 {
1064         return 0;
1065 }
1066
1067 static int can327_ldisc_open(struct tty_struct *tty)
1068 {
1069         struct net_device *dev;
1070         struct can327 *elm;
1071         int err;
1072
1073         if (!capable(CAP_NET_ADMIN))
1074                 return -EPERM;
1075
1076         if (!tty->ops->write)
1077                 return -EOPNOTSUPP;
1078
1079         dev = alloc_candev(sizeof(struct can327), 0);
1080         if (!dev)
1081                 return -ENFILE;
1082         elm = netdev_priv(dev);
1083
1084         /* Configure TTY interface */
1085         tty->receive_room = 65536; /* We don't flow control */
1086         spin_lock_init(&elm->lock);
1087         INIT_WORK(&elm->tx_work, can327_ldisc_tx_worker);
1088
1089         /* Configure CAN metadata */
1090         elm->can.bitrate_const = can327_bitrate_const;
1091         elm->can.bitrate_const_cnt = ARRAY_SIZE(can327_bitrate_const);
1092         elm->can.do_set_bittiming = can327_do_set_bittiming;
1093         elm->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY;
1094
1095         /* Configure netdev interface */
1096         elm->dev = dev;
1097         dev->netdev_ops = &can327_netdev_ops;
1098
1099         /* Mark ldisc channel as alive */
1100         elm->tty = tty;
1101         tty->disc_data = elm;
1102
1103         /* Let 'er rip */
1104         err = register_candev(elm->dev);
1105         if (err) {
1106                 free_candev(elm->dev);
1107                 return err;
1108         }
1109
1110         netdev_info(elm->dev, "can327 on %s.\n", tty->name);
1111
1112         return 0;
1113 }
1114
1115 /* Close down a can327 channel.
1116  * This means flushing out any pending queues, and then returning.
1117  * This call is serialized against other ldisc functions:
1118  * Once this is called, no other ldisc function of ours is entered.
1119  *
1120  * We also use this function for a hangup event.
1121  */
1122 static void can327_ldisc_close(struct tty_struct *tty)
1123 {
1124         struct can327 *elm = (struct can327 *)tty->disc_data;
1125
1126         /* unregister_netdev() calls .ndo_stop() so we don't have to.
1127          * Our .ndo_stop() also flushes the TTY write wakeup handler,
1128          * so we can safely set elm->tty = NULL after this.
1129          */
1130         unregister_candev(elm->dev);
1131
1132         /* Mark channel as dead */
1133         spin_lock_bh(&elm->lock);
1134         tty->disc_data = NULL;
1135         elm->tty = NULL;
1136         spin_unlock_bh(&elm->lock);
1137
1138         netdev_info(elm->dev, "can327 off %s.\n", tty->name);
1139
1140         free_candev(elm->dev);
1141 }
1142
1143 static int can327_ldisc_ioctl(struct tty_struct *tty,
1144 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,17,0)
1145                               struct file *file,
1146 #endif
1147                               unsigned int cmd, unsigned long arg)
1148 {
1149         struct can327 *elm = (struct can327 *)tty->disc_data;
1150         unsigned int tmp;
1151
1152         switch (cmd) {
1153         case SIOCGIFNAME:
1154                 tmp = strnlen(elm->dev->name, IFNAMSIZ - 1) + 1;
1155                 if (copy_to_user((void __user *)arg, elm->dev->name, tmp))
1156                         return -EFAULT;
1157                 return 0;
1158
1159         case SIOCSIFHWADDR:
1160                 return -EINVAL;
1161
1162         default:
1163 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
1164                 return tty_mode_ioctl(tty, file, cmd, arg);
1165 #else
1166                 return tty_mode_ioctl(tty, cmd, arg);
1167 #endif
1168         }
1169 }
1170
1171 static struct tty_ldisc_ops can327_ldisc = {
1172         .owner = THIS_MODULE,
1173         .name = "can327",
1174         .num = N_DEVELOPMENT,
1175         .receive_buf = can327_ldisc_rx,
1176         .write_wakeup = can327_ldisc_tx_wakeup,
1177         .open = can327_ldisc_open,
1178         .close = can327_ldisc_close,
1179         .ioctl = can327_ldisc_ioctl,
1180 };
1181
1182 static int __init can327_init(void)
1183 {
1184         int status;
1185
1186 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1187         status = tty_register_ldisc(N_DEVELOPMENT, &can327_ldisc);
1188 #else
1189         status = tty_register_ldisc(&can327_ldisc);
1190 #endif
1191         if (status)
1192                 pr_err("Can't register line discipline\n");
1193
1194         return status;
1195 }
1196
1197 static void __exit can327_exit(void)
1198 {
1199         /* This will only be called when all channels have been closed by
1200          * userspace - tty_ldisc.c takes care of the module's refcount.
1201          */
1202 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1203         int status;
1204
1205         status = tty_unregister_ldisc(N_DEVELOPMENT);
1206         if (status)
1207                 pr_err("Can't unregister line discipline (error: %d)\n",
1208                        status);
1209 #else
1210         tty_unregister_ldisc(&can327_ldisc);
1211 #endif
1212 }
1213
1214 module_init(can327_init);
1215 module_exit(can327_exit);
1216
1217 MODULE_ALIAS_LDISC(N_DEVELOPMENT);
1218 MODULE_DESCRIPTION("ELM327 based CAN interface");
1219 MODULE_LICENSE("GPL");
1220 MODULE_AUTHOR("Max Staudt <max@enpas.org>");