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