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,
 158                            "Failed to write to tty %s.\n",
 159                            elm->tty->name);
 160                 can327_uart_side_failure(elm);
 161                 return;
 162         }
 163
 164         elm->txleft = len - written;
 165         elm->txhead = elm->txbuf + written;
 166 }
 167
 168 /* Take the ELM327 out of almost any state and back into command mode.
 169  * We send CAN327_DUMMY_CHAR which will either abort any running
 170  * operation, or be echoed back to us in case we're already in command
 171  * mode.
 172  */
 173 static void can327_kick_into_cmd_mode(struct can327 *elm)
 174 {
 175         lockdep_assert_held(&elm->lock);
 176
 177         if (elm->state != CAN327_STATE_GETDUMMYCHAR &&
 178             elm->state != CAN327_STATE_GETPROMPT) {
 179                 can327_send(elm, CAN327_DUMMY_STRING, 1);
 180
 181                 elm->state = CAN327_STATE_GETDUMMYCHAR;
 182         }
 183 }
 184
 185 /* Schedule a CAN frame and necessary config changes to be sent to the TTY. */
 186 static void can327_send_frame(struct can327 *elm, struct can_frame *frame)
 187 {
 188         lockdep_assert_held(&elm->lock);
 189
 190         /* Schedule any necessary changes in ELM327's CAN configuration */
 191         if (elm->can_frame_to_send.can_id != frame->can_id) {
 192                 /* Set the new CAN ID for transmission. */
 193                 if ((frame->can_id ^ elm->can_frame_to_send.can_id)
 194                     & CAN_EFF_FLAG) {
 195                         elm->can_config = (frame->can_id & CAN_EFF_FLAG
 196                                                 ? 0
 197                                                 : CAN327_CAN_CONFIG_SEND_SFF)
 198                                         | CAN327_CAN_CONFIG_VARIABLE_DLC
 199                                         | CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF
 200                                         | elm->can_bitrate_divisor;
 201
 202                         set_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
 203                 }
 204
 205                 if (frame->can_id & CAN_EFF_FLAG) {
 206                         clear_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo);
 207                         set_bit(CAN327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
 208                         set_bit(CAN327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo);
 209                 } else {
 210                         set_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo);
 211                         clear_bit(CAN327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
 212                         clear_bit(CAN327_TX_DO_CANID_29BIT_HIGH, &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 = CAN327_CAN_CONFIG_SEND_SFF
 263                         | CAN327_CAN_CONFIG_VARIABLE_DLC
 264                         | CAN327_CAN_CONFIG_RECV_BOTH_SFF_EFF
 265                         | elm->can_bitrate_divisor;
 266
 267         /* Configure ELM327 and then start monitoring */
 268         elm->next_init_cmd = &can327_init_script[0];
 269         set_bit(CAN327_TX_DO_INIT, &elm->cmds_todo);
 270         set_bit(CAN327_TX_DO_SILENT_MONITOR, &elm->cmds_todo);
 271         set_bit(CAN327_TX_DO_RESPONSES, &elm->cmds_todo);
 272         set_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
 273
 274         can327_kick_into_cmd_mode(elm);
 275 }
 276
 277 static void can327_feed_frame_to_netdev(struct can327 *elm,
 278                                         struct sk_buff *skb)
 279 {
 280         lockdep_assert_held(&elm->lock);
 281
 282         if (!netif_running(elm->dev))
 283                 return;
 284
 285         /* Queue for NAPI pickup.
 286          * rx-offload will update stats and LEDs for us.
 287          */
 288         if (can_rx_offload_queue_tail(&elm->offload, skb))
 289                 elm->dev->stats.rx_fifo_errors++;
 290
 291 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5,15,0)
 292         /* Wake NAPI */
 293         can_rx_offload_irq_finish(&elm->offload);
 294 #endif
 295 }
 296
 297 /* Called when we're out of ideas and just want it all to end. */
 298 static inline void can327_uart_side_failure(struct can327 *elm)
 299 {
 300         struct can_frame *frame;
 301         struct sk_buff *skb;
 302
 303         lockdep_assert_held(&elm->lock);
 304
 305         elm->uart_side_failure = true;
 306
 307         clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
 308
 309         elm->can.can_stats.bus_off++;
 310         netif_stop_queue(elm->dev);
 311         elm->can.state = CAN_STATE_BUS_OFF;
 312         can_bus_off(elm->dev);
 313
 314         netdev_err(elm->dev, "ELM327 misbehaved. Blocking further communication.\n");
 315
 316         skb = alloc_can_err_skb(elm->dev, &frame);
 317         if (!skb)
 318                 return;
 319
 320         frame->can_id |= CAN_ERR_BUSOFF;
 321         can327_feed_frame_to_netdev(elm, skb);
 322 }
 323
 324 /* Compares a byte buffer (non-NUL terminated) to the payload part of a string,
 325  * and returns true iff the buffer (content *and* length) is exactly that
 326  * 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 code,
 332  * and to avoid hardcoding lengths.
 333  */
 334 static inline bool can327_rxbuf_cmp(const u8 *buf, size_t nbytes, const char *reference)
 335 {
 336         size_t ref_len = strlen(reference);
 337
 338         return (nbytes == ref_len) && !memcmp(buf, reference, ref_len);
 339 }
 340
 341 static void can327_parse_error(struct can327 *elm, size_t len)
 342 {
 343         struct can_frame *frame;
 344         struct sk_buff *skb;
 345
 346         lockdep_assert_held(&elm->lock);
 347
 348         skb = alloc_can_err_skb(elm->dev, &frame);
 349         if (!skb)
 350                 /* It's okay to return here:
 351                  * The outer parsing loop will drop this UART buffer.
 352                  */
 353                 return;
 354
 355         /* Filter possible error messages based on length of RX'd line */
 356         if (can327_rxbuf_cmp(elm->rxbuf, len, "UNABLE TO CONNECT")) {
 357                 netdev_err(elm->dev,
 358                            "ELM327 reported UNABLE TO CONNECT. Please check your setup.\n");
 359         } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUFFER FULL")) {
 360                 /* This will only happen if the last data line was complete.
 361                  * Otherwise, can327_parse_frame() will heuristically
 362                  * emit this kind of error frame instead.
 363                  */
 364                 frame->can_id |= CAN_ERR_CRTL;
 365                 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 366         } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUS ERROR")) {
 367                 frame->can_id |= CAN_ERR_BUSERROR;
 368         } else if (can327_rxbuf_cmp(elm->rxbuf, len, "CAN ERROR")) {
 369                 frame->can_id |= CAN_ERR_PROT;
 370         } else if (can327_rxbuf_cmp(elm->rxbuf, len, "<RX ERROR")) {
 371                 frame->can_id |= CAN_ERR_PROT;
 372         } else if (can327_rxbuf_cmp(elm->rxbuf, len, "BUS BUSY")) {
 373                 frame->can_id |= CAN_ERR_PROT;
 374                 frame->data[2] = CAN_ERR_PROT_OVERLOAD;
 375         } else if (can327_rxbuf_cmp(elm->rxbuf, len, "FB ERROR")) {
 376                 frame->can_id |= CAN_ERR_PROT;
 377                 frame->data[2] = CAN_ERR_PROT_TX;
 378         } else if (len == 5 && !memcmp(elm->rxbuf, "ERR", 3)) {
 379                 /* ERR is followed by two digits, hence line length 5 */
 380                 netdev_err(elm->dev, "ELM327 reported an ERR%c%c. Please power it off and on again.\n",
 381                            elm->rxbuf[3], elm->rxbuf[4]);
 382                 frame->can_id |= CAN_ERR_CRTL;
 383         } else {
 384                 /* Something else has happened.
 385                  * Maybe garbage on the UART line.
 386                  * Emit a generic error frame.
 387                  */
 388         }
 389
 390         can327_feed_frame_to_netdev(elm, skb);
 391 }
 392
 393 /* Parse CAN frames coming as ASCII from ELM327.
 394  * They can be of various formats:
 395  *
 396  * 29-bit ID (EFF):  12 34 56 78 D PL PL PL PL PL PL PL PL
 397  * 11-bit ID (!EFF): 123 D PL PL PL PL PL PL PL PL
 398  *
 399  * where D = DLC, PL = payload byte
 400  *
 401  * Instead of a payload, RTR indicates a remote request.
 402  *
 403  * We will use the spaces and line length to guess the format.
 404  */
 405 static int can327_parse_frame(struct can327 *elm, size_t len)
 406 {
 407         struct can_frame *frame;
 408         struct sk_buff *skb;
 409         int hexlen;
 410         int datastart;
 411         int i;
 412
 413         lockdep_assert_held(&elm->lock);
 414
 415         skb = alloc_can_skb(elm->dev, &frame);
 416         if (!skb)
 417                 return -ENOMEM;
 418
 419         /* Find first non-hex and non-space character:
 420          *  - In the simplest case, there is none.
 421          *  - For RTR frames, 'R' is the first non-hex character.
 422          *  - An error message may replace the end of the data line.
 423          */
 424         for (hexlen = 0; hexlen <= len; hexlen++) {
 425                 if (hex_to_bin(elm->rxbuf[hexlen]) < 0 &&
 426                     elm->rxbuf[hexlen] != ' ') {
 427                         break;
 428                 }
 429         }
 430
 431         /* Sanity check whether the line is really a clean hexdump,
 432          * or terminated by an error message, or contains garbage.
 433          */
 434         if (hexlen < len &&
 435             !isdigit(elm->rxbuf[hexlen]) &&
 436             !isupper(elm->rxbuf[hexlen]) &&
 437             '<' != elm->rxbuf[hexlen] &&
 438             ' ' != elm->rxbuf[hexlen]) {
 439                 /* The line is likely garbled anyway, so bail.
 440                  * The main code will restart listening.
 441                  */
 442                 kfree_skb(skb);
 443                 return -ENODATA;
 444         }
 445
 446         /* Use spaces in CAN ID to distinguish 29 or 11 bit address length.
 447          * No out-of-bounds access:
 448          * We use the fact that we can always read from elm->rxbuf.
 449          */
 450         if (elm->rxbuf[2] == ' ' && elm->rxbuf[5] == ' ' &&
 451             elm->rxbuf[8] == ' ' && elm->rxbuf[11] == ' ' &&
 452             elm->rxbuf[13] == ' ') {
 453                 frame->can_id = CAN_EFF_FLAG;
 454                 datastart = 14;
 455         } else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') {
 456                 datastart = 6;
 457         } else {
 458                 /* This is not a well-formatted data line.
 459                  * Assume it's an error message.
 460                  */
 461                 kfree_skb(skb);
 462                 return -ENODATA;
 463         }
 464
 465         if (hexlen < datastart) {
 466                 /* The line is too short to be a valid frame hex dump.
 467                  * Something interrupted the hex dump or it is invalid.
 468                  */
 469                 kfree_skb(skb);
 470                 return -ENODATA;
 471         }
 472
 473         /* From here on all chars up to buf[hexlen] are hex or spaces,
 474          * at well-defined offsets.
 475          */
 476
 477         /* Read CAN data length */
 478         frame->len = (hex_to_bin(elm->rxbuf[datastart - 2]) << 0);
 479
 480         /* Read CAN ID */
 481         if (frame->can_id & CAN_EFF_FLAG) {
 482                 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 28)
 483                                | (hex_to_bin(elm->rxbuf[1]) << 24)
 484                                | (hex_to_bin(elm->rxbuf[3]) << 20)
 485                                | (hex_to_bin(elm->rxbuf[4]) << 16)
 486                                | (hex_to_bin(elm->rxbuf[6]) << 12)
 487                                | (hex_to_bin(elm->rxbuf[7]) << 8)
 488                                | (hex_to_bin(elm->rxbuf[9]) << 4)
 489                                | (hex_to_bin(elm->rxbuf[10]) << 0);
 490         } else {
 491                 frame->can_id |= (hex_to_bin(elm->rxbuf[0]) << 8)
 492                                | (hex_to_bin(elm->rxbuf[1]) << 4)
 493                                | (hex_to_bin(elm->rxbuf[2]) << 0);
 494         }
 495
 496         /* Check for RTR frame */
 497         if (elm->rxfill >= hexlen + 3 &&
 498             !memcmp(&elm->rxbuf[hexlen], "RTR", 3)) {
 499                 frame->can_id |= CAN_RTR_FLAG;
 500         }
 501
 502         /* Is the line long enough to hold the advertised payload?
 503          * Note: RTR frames have a DLC, but no actual payload.
 504          */
 505         if (!(frame->can_id & CAN_RTR_FLAG) &&
 506             (hexlen < frame->len * 3 + datastart)) {
 507                 /* Incomplete frame.
 508                  * Probably the ELM327's RS232 TX buffer was full.
 509                  * Emit an error frame and exit.
 510                  */
 511                 frame->can_id = CAN_ERR_FLAG | CAN_ERR_CRTL;
 512                 frame->len = CAN_ERR_DLC;
 513                 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 514                 can327_feed_frame_to_netdev(elm, skb);
 515
 516                 /* Signal failure to parse.
 517                  * The line will be re-parsed as an error line, which will fail.
 518                  * However, this will correctly drop the state machine back into
 519                  * command mode.
 520                  */
 521                 return -ENODATA;
 522         }
 523
 524         /* Parse the data nibbles. */
 525         for (i = 0; i < frame->len; i++) {
 526                 frame->data[i] = (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),
 590                          "%s",
 591                          *elm->next_init_cmd);
 592
 593                 elm->next_init_cmd++;
 594                 if (!(*elm->next_init_cmd)) {
 595                         clear_bit(CAN327_TX_DO_INIT, &elm->cmds_todo);
 596                         /* Init finished. */
 597                 }
 598
 599         } else if (test_and_clear_bit(CAN327_TX_DO_SILENT_MONITOR, &elm->cmds_todo)) {
 600                 snprintf(local_txbuf, sizeof(local_txbuf),
 601                          "ATCSM%i\r",
 602                          !!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
 603
 604         } else if (test_and_clear_bit(CAN327_TX_DO_RESPONSES, &elm->cmds_todo)) {
 605                 snprintf(local_txbuf, sizeof(local_txbuf),
 606                          "ATR%i\r",
 607                          !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
 608
 609         } else if (test_and_clear_bit(CAN327_TX_DO_CAN_CONFIG, &elm->cmds_todo)) {
 610                 snprintf(local_txbuf, sizeof(local_txbuf),
 611                          "ATPC\r");
 612                 set_bit(CAN327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo);
 613
 614         } else if (test_and_clear_bit(CAN327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo)) {
 615                 snprintf(local_txbuf, sizeof(local_txbuf),
 616                          "ATPB%04X\r",
 617                          elm->can_config);
 618
 619         } else if (test_and_clear_bit(CAN327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo)) {
 620                 snprintf(local_txbuf, sizeof(local_txbuf),
 621                          "ATCP%02X\r",
 622                          (frame->can_id & CAN_EFF_MASK) >> 24);
 623
 624         } else if (test_and_clear_bit(CAN327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo)) {
 625                 snprintf(local_txbuf, sizeof(local_txbuf),
 626                          "ATSH%06X\r",
 627                          frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1));
 628
 629         } else if (test_and_clear_bit(CAN327_TX_DO_CANID_11BIT, &elm->cmds_todo)) {
 630                 snprintf(local_txbuf, sizeof(local_txbuf),
 631                          "ATSH%03X\r",
 632                          frame->can_id & CAN_SFF_MASK);
 633
 634         } else if (test_and_clear_bit(CAN327_TX_DO_CAN_DATA, &elm->cmds_todo)) {
 635                 if (frame->can_id & CAN_RTR_FLAG) {
 636                         /* Send an RTR frame. Their DLC is fixed.
 637                          * Some chips don't send them at all.
 638                          */
 639                         snprintf(local_txbuf, sizeof(local_txbuf),
 640                                  "ATRTR\r");
 641                 } else {
 642                         /* Send a regular CAN data frame */
 643                         int i;
 644
 645                         for (i = 0; i < frame->len; i++) {
 646                                 snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
 647                                          "%02X",
 648                                          frame->data[i]);
 649                         }
 650
 651                         snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
 652                                  "\r");
 653                 }
 654
 655                 elm->drop_next_line = 1;
 656                 elm->state = CAN327_STATE_RECEIVING;
 657
 658                 /* We will be in the default state once this command is
 659                  * sent, so enable the TX packet queue.
 660                  */
 661                 netif_wake_queue(elm->dev);
 662         }
 663
 664         can327_send(elm, local_txbuf, strlen(local_txbuf));
 665 }
 666
 667 static bool can327_is_ready_char(char c)
 668 {
 669         /* Bits 0xc0 are sometimes set (randomly), hence the mask.
 670          * Probably bad hardware.
 671          */
 672         return (c & 0x3f) == CAN327_READY_CHAR;
 673 }
 674
 675 static void can327_drop_bytes(struct can327 *elm, size_t i)
 676 {
 677         lockdep_assert_held(&elm->lock);
 678
 679         memmove(&elm->rxbuf[0], &elm->rxbuf[i], CAN327_SIZE_RXBUF - i);
 680         elm->rxfill -= i;
 681 }
 682
 683 static void can327_parse_rxbuf(struct can327 *elm, size_t first_new_char_idx)
 684 {
 685         size_t len, pos;
 686
 687         lockdep_assert_held(&elm->lock);
 688
 689         switch (elm->state) {
 690         case CAN327_STATE_NOTINIT:
 691                 elm->rxfill = 0;
 692                 break;
 693
 694         case CAN327_STATE_GETDUMMYCHAR:
 695                 /* Wait for 'y' or '>' */
 696                 for (pos = 0; pos < elm->rxfill; pos++) {
 697                         if (elm->rxbuf[pos] == CAN327_DUMMY_CHAR) {
 698                                 can327_send(elm, "\r", 1);
 699                                 elm->state = CAN327_STATE_GETPROMPT;
 700                                 pos++;
 701                                 break;
 702                         } else if (can327_is_ready_char(elm->rxbuf[pos])) {
 703                                 can327_send(elm, CAN327_DUMMY_STRING, 1);
 704                                 pos++;
 705                                 break;
 706                         }
 707                 }
 708
 709                 can327_drop_bytes(elm, pos);
 710                 break;
 711
 712         case CAN327_STATE_GETPROMPT:
 713                 /* Wait for '>' */
 714                 if (can327_is_ready_char(elm->rxbuf[elm->rxfill - 1]))
 715                         can327_handle_prompt(elm);
 716
 717                 elm->rxfill = 0;
 718                 break;
 719
 720         case CAN327_STATE_RECEIVING:
 721                 /* Find <CR> delimiting feedback lines. */
 722                 len = first_new_char_idx;
 723                 while (len < elm->rxfill && elm->rxbuf[len] != '\r')
 724                         len++;
 725
 726                 if (len == CAN327_SIZE_RXBUF) {
 727                         /* Assume the buffer ran full with garbage.
 728                          * Did we even connect at the right baud rate?
 729                          */
 730                         netdev_err(elm->dev,
 731                                    "RX buffer overflow. Faulty ELM327 or UART?\n");
 732                         can327_uart_side_failure(elm);
 733                 } else if (len == elm->rxfill) {
 734                         if (can327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) {
 735                                 /* The ELM327's AT ST response timeout ran out,
 736                                  * so we got a prompt.
 737                                  * Clear RX buffer and restart listening.
 738                                  */
 739                                 elm->rxfill = 0;
 740
 741                                 can327_handle_prompt(elm);
 742                         }
 743
 744                         /* No <CR> found - we haven't received a full line yet.
 745                          * Wait for more data.
 746                          */
 747                 } else {
 748                         /* We have a full line to parse. */
 749                         can327_parse_line(elm, len);
 750
 751                         /* Remove parsed data from RX buffer. */
 752                         can327_drop_bytes(elm, len + 1);
 753
 754                         /* More data to parse? */
 755                         if (elm->rxfill)
 756                                 can327_parse_rxbuf(elm, 0);
 757                 }
 758         }
 759 }
 760
 761 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
 762 /* Dummy needed to use can_rx_offload */
 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, "Reopening netdev after a UART side fault has been detected.\n");
 798
 799         /* Clear TTY buffers */
 800         elm->rxfill = 0;
 801         elm->txleft = 0;
 802
 803         /* open_candev() checks for elm->can.bittiming.bitrate != 0 */
 804         err = open_candev(dev);
 805         if (err) {
 806                 spin_unlock_bh(&elm->lock);
 807                 return err;
 808         }
 809
 810         can327_init_device(elm);
 811         spin_unlock_bh(&elm->lock);
 812
 813 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
 814         elm->offload.mailbox_read = can327_mailbox_read;
 815         err = can_rx_offload_add_fifo(dev, &elm->offload, CAN327_NAPI_WEIGHT);
 816 #else
 817         err = can_rx_offload_add_manual(dev, &elm->offload, CAN327_NAPI_WEIGHT);
 818 #endif
 819         if (err) {
 820                 close_candev(dev);
 821                 return err;
 822         }
 823
 824         can_rx_offload_enable(&elm->offload);
 825
 826         elm->can.state = CAN_STATE_ERROR_ACTIVE;
 827         netif_start_queue(dev);
 828
 829         return 0;
 830 }
 831
 832 static int can327_netdev_close(struct net_device *dev)
 833 {
 834         struct can327 *elm = netdev_priv(dev);
 835
 836         /* Interrupt whatever the ELM327 is doing right now */
 837         spin_lock_bh(&elm->lock);
 838         can327_send(elm, CAN327_DUMMY_STRING, 1);
 839         spin_unlock_bh(&elm->lock);
 840
 841         netif_stop_queue(dev);
 842
 843         /* Give UART one final chance to flush. */
 844         clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
 845         flush_work(&elm->tx_work);
 846
 847         can_rx_offload_disable(&elm->offload);
 848         elm->can.state = CAN_STATE_STOPPED;
 849         can_rx_offload_del(&elm->offload);
 850         close_candev(dev);
 851
 852         return 0;
 853 }
 854
 855 /* Send a can_frame to a TTY. */
 856 static netdev_tx_t can327_netdev_start_xmit(struct sk_buff *skb,
 857                                             struct net_device *dev)
 858 {
 859         struct can327 *elm = netdev_priv(dev);
 860         struct can_frame *frame = (struct can_frame *)skb->data;
 861
 862         if (can_dropped_invalid_skb(dev, skb))
 863                 return NETDEV_TX_OK;
 864
 865         /* This check will be part of can_dropped_invalid_skb()
 866          * in future kernels.
 867          */
 868         if (elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
 869                 goto out;
 870
 871         /* We shouldn't get here after a hardware fault:
 872          * can_bus_off() calls netif_carrier_off()
 873          */
 874         if (elm->uart_side_failure) {
 875                 WARN_ON_ONCE(elm->uart_side_failure);
 876                 goto out;
 877         }
 878
 879         netif_stop_queue(dev);
 880
 881         /* BHs are already disabled, so no spin_lock_bh().
 882          * See Documentation/networking/netdevices.txt
 883          */
 884         spin_lock(&elm->lock);
 885         can327_send_frame(elm, frame);
 886         spin_unlock(&elm->lock);
 887
 888         dev->stats.tx_packets++;
 889         dev->stats.tx_bytes += frame->can_id & CAN_RTR_FLAG ? 0 : frame->len;
 890
 891 out:
 892         kfree_skb(skb);
 893         return NETDEV_TX_OK;
 894 }
 895
 896 static const struct net_device_ops can327_netdev_ops = {
 897         .ndo_open       = can327_netdev_open,
 898         .ndo_stop       = can327_netdev_close,
 899         .ndo_start_xmit = can327_netdev_start_xmit,
 900         .ndo_change_mtu = can_change_mtu,
 901 };
 902
 903 static bool can327_is_valid_rx_char(u8 c)
 904 {
 905         static const bool lut_char_is_valid['z'] = {
 906                 ['\r'] = true,
 907                 [' '] = true,
 908                 ['.'] = true,
 909                 ['0'] = true, true, true, true, true,
 910                 ['5'] = true, true, true, true, true,
 911                 ['<'] = true,
 912                 [CAN327_READY_CHAR] = true,
 913                 ['?'] = true,
 914                 ['A'] = true, true, true, true, true, true, true,
 915                 ['H'] = true, true, true, true, true, true, true,
 916                 ['O'] = true, true, true, true, true, true, true,
 917                 ['V'] = true, true, true, true, true,
 918                 ['a'] = true,
 919                 ['b'] = true,
 920                 ['v'] = true,
 921                 [CAN327_DUMMY_CHAR] = true,
 922         };
 923         BUILD_BUG_ON(CAN327_DUMMY_CHAR >= 'z');
 924
 925         return (c < ARRAY_SIZE(lut_char_is_valid) &&
 926                 lut_char_is_valid[c]);
 927 }
 928
 929 /* Handle incoming ELM327 ASCII data.
 930  * This will not be re-entered while running, but other ldisc
 931  * functions may be called in parallel.
 932  */
 933 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
 934 static void can327_ldisc_rx(struct tty_struct *tty,
 935                             const unsigned char *cp, char *fp, int count)
 936 #else
 937 static void can327_ldisc_rx(struct tty_struct *tty,
 938                             const unsigned char *cp, const char *fp, int count)
 939 #endif
 940 {
 941         struct can327 *elm = (struct can327 *)tty->disc_data;
 942         size_t first_new_char_idx;
 943
 944         if (elm->uart_side_failure)
 945                 return;
 946
 947         spin_lock_bh(&elm->lock);
 948
 949         /* Store old rxfill, so can327_parse_rxbuf() will have
 950          * the option of skipping already checked characters.
 951          */
 952         first_new_char_idx = elm->rxfill;
 953
 954         while (count-- && elm->rxfill < CAN327_SIZE_RXBUF) {
 955                 if (fp && *fp++) {
 956                         netdev_err(elm->dev, "Error in received character stream. Check your wiring.");
 957
 958                         can327_uart_side_failure(elm);
 959
 960                         spin_unlock_bh(&elm->lock);
 961                         return;
 962                 }
 963
 964                 /* Ignore NUL characters, which the PIC microcontroller may
 965                  * inadvertently insert due to a known hardware bug.
 966                  * See ELM327 documentation, which refers to a Microchip PIC
 967                  * bug description.
 968                  */
 969                 if (*cp) {
 970                         /* Check for stray characters on the UART line.
 971                          * Likely caused by bad hardware.
 972                          */
 973                         if (!can327_is_valid_rx_char(*cp)) {
 974                                 netdev_err(elm->dev,
 975                                            "Received illegal character %02x.\n",
 976                                            *cp);
 977                                 can327_uart_side_failure(elm);
 978
 979                                 spin_unlock_bh(&elm->lock);
 980                                 return;
 981                         }
 982
 983                         elm->rxbuf[elm->rxfill++] = *cp;
 984                 }
 985
 986                 cp++;
 987         }
 988
 989         if (count >= 0) {
 990                 netdev_err(elm->dev, "Receive buffer overflowed. Bad chip or wiring? count = %i", count);
 991
 992                 can327_uart_side_failure(elm);
 993
 994                 spin_unlock_bh(&elm->lock);
 995                 return;
 996         }
 997
 998         can327_parse_rxbuf(elm, first_new_char_idx);
 999         spin_unlock_bh(&elm->lock);
1000 }
1001
1002 /* Write out remaining transmit buffer.
1003  * Scheduled when TTY is writable.
1004  */
1005 static void can327_ldisc_tx_worker(struct work_struct *work)
1006 {
1007         struct can327 *elm = container_of(work, struct can327, tx_work);
1008         ssize_t written;
1009
1010         if (elm->uart_side_failure)
1011                 return;
1012
1013         spin_lock_bh(&elm->lock);
1014
1015         if (elm->txleft) {
1016                 written = elm->tty->ops->write(elm->tty, elm->txhead, elm->txleft);
1017                 if (written < 0) {
1018                         netdev_err(elm->dev,
1019                                    "Failed to write to tty %s.\n",
1020                                    elm->tty->name);
1021                         can327_uart_side_failure(elm);
1022
1023                         spin_unlock_bh(&elm->lock);
1024                         return;
1025                 }
1026
1027                 elm->txleft -= written;
1028                 elm->txhead += written;
1029         }
1030
1031         if (!elm->txleft)
1032                 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
1033
1034         spin_unlock_bh(&elm->lock);
1035 }
1036
1037 /* Called by the driver when there's room for more data. */
1038 static void can327_ldisc_tx_wakeup(struct tty_struct *tty)
1039 {
1040         struct can327 *elm = (struct can327 *)tty->disc_data;
1041
1042         schedule_work(&elm->tx_work);
1043 }
1044
1045 /* ELM327 can only handle bitrates that are integer divisors of 500 kHz,
1046  * or 7/8 of that. Divisors are 1 to 64.
1047  * Currently we don't implement support for 7/8 rates.
1048  */
1049 static const u32 can327_bitrate_const[] = {
1050          7812,  7936,  8064,  8196,  8333,  8474,  8620,  8771,
1051          8928,  9090,  9259,  9433,  9615,  9803, 10000, 10204,
1052         10416, 10638, 10869, 11111, 11363, 11627, 11904, 12195,
1053         12500, 12820, 13157, 13513, 13888, 14285, 14705, 15151,
1054         15625, 16129, 16666, 17241, 17857, 18518, 19230, 20000,
1055         20833, 21739, 22727, 23809, 25000, 26315, 27777, 29411,
1056         31250, 33333, 35714, 38461, 41666, 45454, 50000, 55555,
1057         62500, 71428, 83333, 100000, 125000, 166666, 250000, 500000
1058 };
1059
1060 /* Dummy needed to use bitrate_const */
1061 static int can327_do_set_bittiming(struct net_device *netdev)
1062 {
1063         return 0;
1064 }
1065
1066 static int can327_ldisc_open(struct tty_struct *tty)
1067 {
1068         struct net_device *dev;
1069         struct can327 *elm;
1070         int err;
1071
1072         if (!capable(CAP_NET_ADMIN))
1073                 return -EPERM;
1074
1075         if (!tty->ops->write)
1076                 return -EOPNOTSUPP;
1077
1078         dev = alloc_candev(sizeof(struct can327), 0);
1079         if (!dev)
1080                 return -ENFILE;
1081         elm = netdev_priv(dev);
1082
1083         /* Configure TTY interface */
1084         tty->receive_room = 65536; /* We don't flow control */
1085         spin_lock_init(&elm->lock);
1086         INIT_WORK(&elm->tx_work, can327_ldisc_tx_worker);
1087
1088         /* Configure CAN metadata */
1089         elm->can.bitrate_const = can327_bitrate_const;
1090         elm->can.bitrate_const_cnt = ARRAY_SIZE(can327_bitrate_const);
1091         elm->can.do_set_bittiming = can327_do_set_bittiming;
1092         elm->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY;
1093
1094         /* Configure netdev interface */
1095         elm->dev = dev;
1096         dev->netdev_ops = &can327_netdev_ops;
1097
1098         /* Mark ldisc channel as alive */
1099         elm->tty = tty;
1100         tty->disc_data = elm;
1101
1102         /* Let 'er rip */
1103         err = register_candev(elm->dev);
1104         if (err) {
1105                 free_candev(elm->dev);
1106                 return err;
1107         }
1108
1109         netdev_info(elm->dev, "can327 on %s.\n", tty->name);
1110
1111         return 0;
1112 }
1113
1114 /* Close down a can327 channel.
1115  * This means flushing out any pending queues, and then returning.
1116  * This call is serialized against other ldisc functions:
1117  * Once this is called, no other ldisc function of ours is entered.
1118  *
1119  * We also use this function for a hangup event.
1120  */
1121 static void can327_ldisc_close(struct tty_struct *tty)
1122 {
1123         struct can327 *elm = (struct can327 *)tty->disc_data;
1124
1125         /* unregister_netdev() calls .ndo_stop() so we don't have to.
1126          * Our .ndo_stop() also flushes the TTY write wakeup handler,
1127          * so we can safely set elm->tty = NULL after this.
1128          */
1129         unregister_candev(elm->dev);
1130
1131         /* Mark channel as dead */
1132         spin_lock_bh(&elm->lock);
1133         tty->disc_data = NULL;
1134         elm->tty = NULL;
1135         spin_unlock_bh(&elm->lock);
1136
1137         netdev_info(elm->dev, "can327 off %s.\n", tty->name);
1138
1139         free_candev(elm->dev);
1140 }
1141
1142 static int can327_ldisc_ioctl(struct tty_struct *tty,
1143 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,17,0)
1144                               struct file *file,
1145 #endif
1146                               unsigned int cmd, unsigned long arg)
1147 {
1148         struct can327 *elm = (struct can327 *)tty->disc_data;
1149         unsigned int tmp;
1150
1151         switch (cmd) {
1152         case SIOCGIFNAME:
1153                 tmp = strnlen(elm->dev->name, IFNAMSIZ - 1) + 1;
1154                 if (copy_to_user((void __user *)arg, elm->dev->name, tmp))
1155                         return -EFAULT;
1156                 return 0;
1157
1158         case SIOCSIFHWADDR:
1159                 return -EINVAL;
1160
1161         default:
1162 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
1163                 return tty_mode_ioctl(tty, file, cmd, arg);
1164 #else
1165                 return tty_mode_ioctl(tty, cmd, arg);
1166 #endif
1167         }
1168 }
1169
1170 static struct tty_ldisc_ops can327_ldisc = {
1171         .owner          = THIS_MODULE,
1172         .name           = "can327",
1173         .num            = N_DEVELOPMENT,
1174         .receive_buf    = can327_ldisc_rx,
1175         .write_wakeup   = can327_ldisc_tx_wakeup,
1176         .open           = can327_ldisc_open,
1177         .close          = can327_ldisc_close,
1178         .ioctl          = can327_ldisc_ioctl,
1179 };
1180
1181 static int __init can327_init(void)
1182 {
1183         int status;
1184
1185 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1186         status = tty_register_ldisc(N_DEVELOPMENT, &can327_ldisc);
1187 #else
1188         status = tty_register_ldisc(&can327_ldisc);
1189 #endif
1190         if (status)
1191                 pr_err("Can't register line discipline\n");
1192
1193         return status;
1194 }
1195
1196 static void __exit can327_exit(void)
1197 {
1198         /* This will only be called when all channels have been closed by
1199          * userspace - tty_ldisc.c takes care of the module's refcount.
1200          */
1201 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1202         int status;
1203
1204         status = tty_unregister_ldisc(N_DEVELOPMENT);
1205         if (status)
1206                 pr_err("Can't unregister line discipline (error: %d)\n",
1207                        status);
1208 #else
1209         tty_unregister_ldisc(&can327_ldisc);
1210 #endif
1211 }
1212
1213 module_init(can327_init);
1214 module_exit(can327_exit);
1215
1216 MODULE_ALIAS_LDISC(N_DEVELOPMENT);
1217 MODULE_DESCRIPTION("ELM327 based CAN interface");
1218 MODULE_LICENSE("GPL");
1219 MODULE_AUTHOR("Max Staudt <max-linux@enpas.org>");