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