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 ELM327_NAPI_WEIGHT 4
  54
  55 #define ELM327_SIZE_TXBUF 32
  56 #define ELM327_SIZE_RXBUF 1024
  57
  58 #define ELM327_CAN_CONFIG_SEND_SFF           0x8000
  59 #define ELM327_CAN_CONFIG_VARIABLE_DLC       0x4000
  60 #define ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF  0x2000
  61 #define ELM327_CAN_CONFIG_BAUDRATE_MULT_8_7  0x1000
  62
  63 #define ELM327_DUMMY_CHAR 'y'
  64 #define ELM327_DUMMY_STRING "y"
  65 #define ELM327_READY_CHAR '>'
  66
  67 /* Bits in elm->cmds_todo */
  68 enum elm327_tx_do {
  69         ELM327_TX_DO_CAN_DATA = 0,
  70         ELM327_TX_DO_CANID_11BIT,
  71         ELM327_TX_DO_CANID_29BIT_LOW,
  72         ELM327_TX_DO_CANID_29BIT_HIGH,
  73         ELM327_TX_DO_CAN_CONFIG_PART2,
  74         ELM327_TX_DO_CAN_CONFIG,
  75         ELM327_TX_DO_RESPONSES,
  76         ELM327_TX_DO_SILENT_MONITOR,
  77         ELM327_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[ELM327_SIZE_TXBUF];
  88         u8 rxbuf[ELM327_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                 ELM327_STATE_NOTINIT = 0,
 106                 ELM327_STATE_GETDUMMYCHAR,
 107                 ELM327_STATE_GETPROMPT,
 108                 ELM327_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 elm327_uart_side_failure(struct can327 *elm);
 134
 135 static void elm327_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                 elm327_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 ELM327_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 elm327_kick_into_cmd_mode(struct can327 *elm)
 174 {
 175         lockdep_assert_held(&elm->lock);
 176
 177         if (elm->state != ELM327_STATE_GETDUMMYCHAR &&
 178             elm->state != ELM327_STATE_GETPROMPT) {
 179                 elm327_send(elm, ELM327_DUMMY_STRING, 1);
 180
 181                 elm->state = ELM327_STATE_GETDUMMYCHAR;
 182         }
 183 }
 184
 185 /* Schedule a CAN frame and necessary config changes to be sent to the TTY. */
 186 static void elm327_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                                                 : ELM327_CAN_CONFIG_SEND_SFF)
 198                                         | ELM327_CAN_CONFIG_VARIABLE_DLC
 199                                         | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF
 200                                         | elm->can_bitrate_divisor;
 201
 202                         set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
 203                 }
 204
 205                 if (frame->can_id & CAN_EFF_FLAG) {
 206                         clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo);
 207                         set_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
 208                         set_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo);
 209                 } else {
 210                         set_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo);
 211                         clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo);
 212                         clear_bit(ELM327_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(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo);
 219
 220         elm327_kick_into_cmd_mode(elm);
 221 }
 222
 223 /* ELM327 initialisation sequence.
 224  * The line length is limited by the buffer in elm327_handle_prompt().
 225  */
 226 static char *elm327_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 elm327_init(struct can327 *elm)
 249 {
 250         lockdep_assert_held(&elm->lock);
 251
 252         elm->state = ELM327_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 = ELM327_CAN_CONFIG_SEND_SFF
 263                         | ELM327_CAN_CONFIG_VARIABLE_DLC
 264                         | ELM327_CAN_CONFIG_RECV_BOTH_SFF_EFF
 265                         | elm->can_bitrate_divisor;
 266
 267         /* Configure ELM327 and then start monitoring */
 268         elm->next_init_cmd = &elm327_init_script[0];
 269         set_bit(ELM327_TX_DO_INIT, &elm->cmds_todo);
 270         set_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo);
 271         set_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo);
 272         set_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo);
 273
 274         elm327_kick_into_cmd_mode(elm);
 275 }
 276
 277 static void elm327_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 elm327_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         elm327_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 elm327_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 elm327_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 (elm327_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 (elm327_rxbuf_cmp(elm->rxbuf, len, "BUFFER FULL")) {
 360                 /* This will only happen if the last data line was complete.
 361                  * Otherwise, elm327_parse_frame() will heuristically
 362                  * emit this kind of error frame instead.
 363                  */
 364                 frame->can_id |= CAN_ERR_CRTL;
 365                 frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 366         } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "BUS ERROR")) {
 367                 frame->can_id |= CAN_ERR_BUSERROR;
 368         } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "CAN ERROR")) {
 369                 frame->can_id |= CAN_ERR_PROT;
 370         } else if (elm327_rxbuf_cmp(elm->rxbuf, len, "<RX ERROR")) {
 371                 frame->can_id |= CAN_ERR_PROT;
 372         } else if (elm327_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 (elm327_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         elm327_feed_frame_to_netdev(elm, skb);
 391 }
 392
 393 /* Parse CAN frames coming as ASCII from ELM327.
 394  * They can be of various formats:
 395  *
 396  * 29-bit ID (EFF):  12 34 56 78 D PL PL PL PL PL PL PL PL
 397  * 11-bit ID (!EFF): 123 D PL PL PL PL PL PL PL PL
 398  *
 399  * where D = DLC, PL = payload byte
 400  *
 401  * Instead of a payload, RTR indicates a remote request.
 402  *
 403  * We will use the spaces and line length to guess the format.
 404  */
 405 static int elm327_parse_frame(struct 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                 elm327_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                 kfree_skb(skb);
 522                 return -ENODATA;
 523         }
 524
 525         /* Parse the data nibbles. */
 526         for (i = 0; i < frame->len; i++) {
 527                 frame->data[i] = (hex_to_bin(elm->rxbuf[datastart + 3*i]) << 4)
 528                                | (hex_to_bin(elm->rxbuf[datastart + 3*i + 1]));
 529         }
 530
 531         /* Feed the frame to the network layer. */
 532         elm327_feed_frame_to_netdev(elm, skb);
 533
 534         return 0;
 535 }
 536
 537 static void elm327_parse_line(struct can327 *elm, size_t len)
 538 {
 539         lockdep_assert_held(&elm->lock);
 540
 541         /* Skip empty lines */
 542         if (!len)
 543                 return;
 544
 545         /* Skip echo lines */
 546         if (elm->drop_next_line) {
 547                 elm->drop_next_line = 0;
 548                 return;
 549         } else if (!memcmp(elm->rxbuf, "AT", 2)) {
 550                 return;
 551         }
 552
 553         /* Regular parsing */
 554         if (elm->state == ELM327_STATE_RECEIVING &&
 555             elm327_parse_frame(elm, len)) {
 556                 /* Parse an error line. */
 557                 elm327_parse_error(elm, len);
 558
 559                 /* Start afresh. */
 560                 elm327_kick_into_cmd_mode(elm);
 561         }
 562 }
 563
 564 static void elm327_handle_prompt(struct can327 *elm)
 565 {
 566         struct can_frame *frame = &elm->can_frame_to_send;
 567         /* Size this buffer for the largest ELM327 line we may generate,
 568          * which is currently an 8 byte CAN frame's payload hexdump.
 569          * Items in elm327_init_script must fit here, too!
 570          */
 571         char local_txbuf[sizeof("0102030405060708\r")];
 572
 573         lockdep_assert_held(&elm->lock);
 574
 575         if (!elm->cmds_todo) {
 576                 /* Enter CAN monitor mode */
 577                 elm327_send(elm, "ATMA\r", 5);
 578                 elm->state = ELM327_STATE_RECEIVING;
 579
 580                 /* We will be in the default state once this command is
 581                  * sent, so enable the TX packet queue.
 582                  */
 583                 netif_wake_queue(elm->dev);
 584
 585                 return;
 586         }
 587
 588         /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */
 589         if (test_bit(ELM327_TX_DO_INIT, &elm->cmds_todo)) {
 590                 snprintf(local_txbuf, sizeof(local_txbuf),
 591                          "%s",
 592                          *elm->next_init_cmd);
 593
 594                 elm->next_init_cmd++;
 595                 if (!(*elm->next_init_cmd)) {
 596                         clear_bit(ELM327_TX_DO_INIT, &elm->cmds_todo);
 597                         /* Init finished. */
 598                 }
 599
 600         } else if (test_and_clear_bit(ELM327_TX_DO_SILENT_MONITOR, &elm->cmds_todo)) {
 601                 snprintf(local_txbuf, sizeof(local_txbuf),
 602                          "ATCSM%i\r",
 603                          !!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
 604
 605         } else if (test_and_clear_bit(ELM327_TX_DO_RESPONSES, &elm->cmds_todo)) {
 606                 snprintf(local_txbuf, sizeof(local_txbuf),
 607                          "ATR%i\r",
 608                          !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
 609
 610         } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG, &elm->cmds_todo)) {
 611                 snprintf(local_txbuf, sizeof(local_txbuf),
 612                          "ATPC\r");
 613                 set_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo);
 614
 615         } else if (test_and_clear_bit(ELM327_TX_DO_CAN_CONFIG_PART2, &elm->cmds_todo)) {
 616                 snprintf(local_txbuf, sizeof(local_txbuf),
 617                          "ATPB%04X\r",
 618                          elm->can_config);
 619
 620         } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_HIGH, &elm->cmds_todo)) {
 621                 snprintf(local_txbuf, sizeof(local_txbuf),
 622                          "ATCP%02X\r",
 623                          (frame->can_id & CAN_EFF_MASK) >> 24);
 624
 625         } else if (test_and_clear_bit(ELM327_TX_DO_CANID_29BIT_LOW, &elm->cmds_todo)) {
 626                 snprintf(local_txbuf, sizeof(local_txbuf),
 627                          "ATSH%06X\r",
 628                          frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1));
 629
 630         } else if (test_and_clear_bit(ELM327_TX_DO_CANID_11BIT, &elm->cmds_todo)) {
 631                 snprintf(local_txbuf, sizeof(local_txbuf),
 632                          "ATSH%03X\r",
 633                          frame->can_id & CAN_SFF_MASK);
 634
 635         } else if (test_and_clear_bit(ELM327_TX_DO_CAN_DATA, &elm->cmds_todo)) {
 636                 if (frame->can_id & CAN_RTR_FLAG) {
 637                         /* Send an RTR frame. Their DLC is fixed.
 638                          * Some chips don't send them at all.
 639                          */
 640                         snprintf(local_txbuf, sizeof(local_txbuf),
 641                                  "ATRTR\r");
 642                 } else {
 643                         /* Send a regular CAN data frame */
 644                         int i;
 645
 646                         for (i = 0; i < frame->len; i++) {
 647                                 snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
 648                                          "%02X",
 649                                          frame->data[i]);
 650                         }
 651
 652                         snprintf(&local_txbuf[2 * i], sizeof(local_txbuf),
 653                                  "\r");
 654                 }
 655
 656                 elm->drop_next_line = 1;
 657                 elm->state = ELM327_STATE_RECEIVING;
 658
 659                 /* We will be in the default state once this command is
 660                  * sent, so enable the TX packet queue.
 661                  */
 662                 netif_wake_queue(elm->dev);
 663         }
 664
 665         elm327_send(elm, local_txbuf, strlen(local_txbuf));
 666 }
 667
 668 static bool elm327_is_ready_char(char c)
 669 {
 670         /* Bits 0xc0 are sometimes set (randomly), hence the mask.
 671          * Probably bad hardware.
 672          */
 673         return (c & 0x3f) == ELM327_READY_CHAR;
 674 }
 675
 676 static void elm327_drop_bytes(struct can327 *elm, size_t i)
 677 {
 678         lockdep_assert_held(&elm->lock);
 679
 680         memmove(&elm->rxbuf[0], &elm->rxbuf[i], ELM327_SIZE_RXBUF - i);
 681         elm->rxfill -= i;
 682 }
 683
 684 static void elm327_parse_rxbuf(struct can327 *elm, size_t first_new_char_idx)
 685 {
 686         size_t len, pos;
 687
 688         lockdep_assert_held(&elm->lock);
 689
 690         switch (elm->state) {
 691         case ELM327_STATE_NOTINIT:
 692                 elm->rxfill = 0;
 693                 break;
 694
 695         case ELM327_STATE_GETDUMMYCHAR:
 696                 /* Wait for 'y' or '>' */
 697                 for (pos = 0; pos < elm->rxfill; pos++) {
 698                         if (elm->rxbuf[pos] == ELM327_DUMMY_CHAR) {
 699                                 elm327_send(elm, "\r", 1);
 700                                 elm->state = ELM327_STATE_GETPROMPT;
 701                                 pos++;
 702                                 break;
 703                         } else if (elm327_is_ready_char(elm->rxbuf[pos])) {
 704                                 elm327_send(elm, ELM327_DUMMY_STRING, 1);
 705                                 pos++;
 706                                 break;
 707                         }
 708                 }
 709
 710                 elm327_drop_bytes(elm, pos);
 711                 break;
 712
 713         case ELM327_STATE_GETPROMPT:
 714                 /* Wait for '>' */
 715                 if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1]))
 716                         elm327_handle_prompt(elm);
 717
 718                 elm->rxfill = 0;
 719                 break;
 720
 721         case ELM327_STATE_RECEIVING:
 722                 /* Find <CR> delimiting feedback lines. */
 723                 len = first_new_char_idx;
 724                 while (len < elm->rxfill && elm->rxbuf[len] != '\r')
 725                         len++;
 726
 727                 if (len == ELM327_SIZE_RXBUF) {
 728                         /* Assume the buffer ran full with garbage.
 729                          * Did we even connect at the right baud rate?
 730                          */
 731                         netdev_err(elm->dev,
 732                                    "RX buffer overflow. Faulty ELM327 or UART?\n");
 733                         elm327_uart_side_failure(elm);
 734                 } else if (len == elm->rxfill) {
 735                         if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) {
 736                                 /* The ELM327's AT ST response timeout ran out,
 737                                  * so we got a prompt.
 738                                  * Clear RX buffer and restart listening.
 739                                  */
 740                                 elm->rxfill = 0;
 741
 742                                 elm327_handle_prompt(elm);
 743                         }
 744
 745                         /* No <CR> found - we haven't received a full line yet.
 746                          * Wait for more data.
 747                          */
 748                 } else {
 749                         /* We have a full line to parse. */
 750                         elm327_parse_line(elm, len);
 751
 752                         /* Remove parsed data from RX buffer. */
 753                         elm327_drop_bytes(elm, len + 1);
 754
 755                         /* More data to parse? */
 756                         if (elm->rxfill)
 757                                 elm327_parse_rxbuf(elm, 0);
 758                 }
 759         }
 760 }
 761
 762 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
 763 /* Dummy needed to use can_rx_offload */
 764 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,5,0)
 765 static unsigned int *can327_mailbox_read(struct can_rx_offload *offload,
 766                                          struct can_frame *cf,
 767                                          u32 *timestamp, unsigned int n)
 768 {
 769         WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
 770
 771         return -ENOBUFS;
 772 }
 773 #else /* Since 4e9c9484b085 (included in v5.5) */
 774 static struct sk_buff *can327_mailbox_read(struct can_rx_offload *offload,
 775                                            unsigned int n, u32 *timestamp,
 776                                            bool drop)
 777 {
 778         WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
 779
 780         return ERR_PTR(-ENOBUFS);
 781 }
 782 #endif
 783 #endif
 784
 785 static int can327_netdev_open(struct net_device *dev)
 786 {
 787         struct can327 *elm = netdev_priv(dev);
 788         int err;
 789
 790         spin_lock_bh(&elm->lock);
 791
 792         if (!elm->tty) {
 793                 spin_unlock_bh(&elm->lock);
 794                 return -ENODEV;
 795         }
 796
 797         if (elm->uart_side_failure)
 798                 netdev_warn(elm->dev, "Reopening netdev after a UART side fault has been detected.\n");
 799
 800         /* Clear TTY buffers */
 801         elm->rxfill = 0;
 802         elm->txleft = 0;
 803
 804         /* open_candev() checks for elm->can.bittiming.bitrate != 0 */
 805         err = open_candev(dev);
 806         if (err) {
 807                 spin_unlock_bh(&elm->lock);
 808                 return err;
 809         }
 810
 811         elm327_init(elm);
 812         spin_unlock_bh(&elm->lock);
 813
 814 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
 815         elm->offload.mailbox_read = can327_mailbox_read;
 816         err = can_rx_offload_add_fifo(dev, &elm->offload, ELM327_NAPI_WEIGHT);
 817 #else
 818         err = can_rx_offload_add_manual(dev, &elm->offload, ELM327_NAPI_WEIGHT);
 819 #endif
 820         if (err) {
 821                 close_candev(dev);
 822                 return err;
 823         }
 824
 825         can_rx_offload_enable(&elm->offload);
 826
 827         elm->can.state = CAN_STATE_ERROR_ACTIVE;
 828         netif_start_queue(dev);
 829
 830         return 0;
 831 }
 832
 833 static int can327_netdev_close(struct net_device *dev)
 834 {
 835         struct can327 *elm = netdev_priv(dev);
 836
 837         /* Interrupt whatever the ELM327 is doing right now */
 838         spin_lock_bh(&elm->lock);
 839         elm327_send(elm, ELM327_DUMMY_STRING, 1);
 840         spin_unlock_bh(&elm->lock);
 841
 842         netif_stop_queue(dev);
 843
 844         /* Give UART one final chance to flush. */
 845         clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
 846         flush_work(&elm->tx_work);
 847
 848         can_rx_offload_disable(&elm->offload);
 849         elm->can.state = CAN_STATE_STOPPED;
 850         can_rx_offload_del(&elm->offload);
 851         close_candev(dev);
 852
 853         return 0;
 854 }
 855
 856 /* Send a can_frame to a TTY. */
 857 static netdev_tx_t can327_netdev_start_xmit(struct sk_buff *skb,
 858                                             struct net_device *dev)
 859 {
 860         struct can327 *elm = netdev_priv(dev);
 861         struct can_frame *frame = (struct can_frame *)skb->data;
 862
 863         if (can_dropped_invalid_skb(dev, skb))
 864                 return NETDEV_TX_OK;
 865
 866         /* This check will be part of can_dropped_invalid_skb()
 867          * in future kernels.
 868          */
 869         if (elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
 870                 goto out;
 871
 872         /* We shouldn't get here after a hardware fault:
 873          * can_bus_off() calls netif_carrier_off()
 874          */
 875         if (elm->uart_side_failure) {
 876                 WARN_ON_ONCE(elm->uart_side_failure);
 877                 goto out;
 878         }
 879
 880         netif_stop_queue(dev);
 881
 882         /* BHs are already disabled, so no spin_lock_bh().
 883          * See Documentation/networking/netdevices.txt
 884          */
 885         spin_lock(&elm->lock);
 886         elm327_send_frame(elm, frame);
 887         spin_unlock(&elm->lock);
 888
 889         dev->stats.tx_packets++;
 890         dev->stats.tx_bytes += frame->len;
 891
 892 out:
 893         kfree_skb(skb);
 894         return NETDEV_TX_OK;
 895 }
 896
 897 static const struct net_device_ops can327_netdev_ops = {
 898         .ndo_open       = can327_netdev_open,
 899         .ndo_stop       = can327_netdev_close,
 900         .ndo_start_xmit = can327_netdev_start_xmit,
 901         .ndo_change_mtu = can_change_mtu,
 902 };
 903
 904 static bool can327_is_valid_rx_char(u8 c)
 905 {
 906         static const bool lut_char_is_valid['z'] = {
 907                 ['\r'] = true,
 908                 [' '] = true,
 909                 ['.'] = true,
 910                 ['0'] = true, true, true, true, true,
 911                 ['5'] = true, true, true, true, true,
 912                 ['<'] = true,
 913                 [ELM327_READY_CHAR] = true,
 914                 ['?'] = true,
 915                 ['A'] = true, true, true, true, true, true, true,
 916                 ['H'] = true, true, true, true, true, true, true,
 917                 ['O'] = true, true, true, true, true, true, true,
 918                 ['V'] = true, true, true, true, true,
 919                 ['a'] = true,
 920                 ['b'] = true,
 921                 ['v'] = true,
 922                 [ELM327_DUMMY_CHAR] = true,
 923         };
 924         BUILD_BUG_ON(ELM327_DUMMY_CHAR >= 'z');
 925
 926         return (c < ARRAY_SIZE(lut_char_is_valid) &&
 927                 lut_char_is_valid[c]);
 928 }
 929
 930 /* Handle incoming ELM327 ASCII data.
 931  * This will not be re-entered while running, but other ldisc
 932  * functions may be called in parallel.
 933  */
 934 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
 935 static void can327_ldisc_rx(struct tty_struct *tty,
 936                             const unsigned char *cp, char *fp, int count)
 937 #else
 938 static void can327_ldisc_rx(struct tty_struct *tty,
 939                             const unsigned char *cp, const char *fp, int count)
 940 #endif
 941 {
 942         struct can327 *elm = (struct can327 *)tty->disc_data;
 943         size_t first_new_char_idx;
 944
 945         if (elm->uart_side_failure)
 946                 return;
 947
 948         spin_lock_bh(&elm->lock);
 949
 950         /* Store old rxfill, so elm327_parse_rxbuf() will have
 951          * the option of skipping already checked characters.
 952          */
 953         first_new_char_idx = elm->rxfill;
 954
 955         while (count-- && elm->rxfill < ELM327_SIZE_RXBUF) {
 956                 if (fp && *fp++) {
 957                         netdev_err(elm->dev, "Error in received character stream. Check your wiring.");
 958
 959                         elm327_uart_side_failure(elm);
 960
 961                         spin_unlock_bh(&elm->lock);
 962                         return;
 963                 }
 964
 965                 /* Ignore NUL characters, which the PIC microcontroller may
 966                  * inadvertently insert due to a known hardware bug.
 967                  * See ELM327 documentation, which refers to a Microchip PIC
 968                  * bug description.
 969                  */
 970                 if (*cp) {
 971                         /* Check for stray characters on the UART line.
 972                          * Likely caused by bad hardware.
 973                          */
 974                         if (!can327_is_valid_rx_char(*cp)) {
 975                                 netdev_err(elm->dev,
 976                                            "Received illegal character %02x.\n",
 977                                            *cp);
 978                                 elm327_uart_side_failure(elm);
 979
 980                                 spin_unlock_bh(&elm->lock);
 981                                 return;
 982                         }
 983
 984                         elm->rxbuf[elm->rxfill++] = *cp;
 985                 }
 986
 987                 cp++;
 988         }
 989
 990         if (count >= 0) {
 991                 netdev_err(elm->dev, "Receive buffer overflowed. Bad chip or wiring? count = %i", count);
 992
 993                 elm327_uart_side_failure(elm);
 994
 995                 spin_unlock_bh(&elm->lock);
 996                 return;
 997         }
 998
 999         elm327_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, elm->txleft);
1018                 if (written < 0) {
1019                         netdev_err(elm->dev,
1020                                    "Failed to write to tty %s.\n",
1021                                    elm->tty->name);
1022                         elm327_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-linux@enpas.org>");