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                 /* Something else has happened.
 400                  * Maybe garbage on the UART line.
 401                  * Emit a generic error frame.
 402                  */
 403                 break;
 404         }
 405
 406         elm327_feed_frame_to_netdev(elm, &frame);
 407 }
 408
 409 /* Parse CAN frames coming as ASCII from ELM327.
 410  * They can be of various formats:
 411  *
 412  * 29-bit ID (EFF):  12 34 56 78 D PL PL PL PL PL PL PL PL
 413  * 11-bit ID (!EFF): 123 D PL PL PL PL PL PL PL PL
 414  *
 415  * where D = DLC, PL = payload byte
 416  *
 417  * Instead of a payload, RTR indicates a remote request.
 418  *
 419  * We will use the spaces and line length to guess the format.
 420  *
 421  * Assumes elm->lock taken.
 422  */
 423 static int elm327_parse_frame(struct elmcan *elm, int len)
 424 {
 425         struct can_frame frame;
 426         int hexlen;
 427         int datastart;
 428         int i;
 429
 430         memset(&frame, 0, sizeof(frame));
 431
 432         /* Find first non-hex and non-space character:
 433          *  - In the simplest case, there is none.
 434          *  - For RTR frames, 'R' is the first non-hex character.
 435          *  - An error message may replace the end of the data line.
 436          */
 437         for (hexlen = 0; hexlen <= len; hexlen++) {
 438                 if (hex_to_bin(elm->rxbuf[hexlen]) < 0 &&
 439                     elm->rxbuf[hexlen] != ' ') {
 440                         break;
 441                 }
 442         }
 443
 444         /* If we accept stray characters coming in:
 445          * Check for stray characters on a payload line.
 446          * No idea what causes this.
 447          */
 448         if (accept_flaky_uart &&
 449             hexlen < len &&
 450             !isdigit(elm->rxbuf[hexlen]) &&
 451             !isupper(elm->rxbuf[hexlen]) &&
 452             '<' != elm->rxbuf[hexlen] &&
 453             ' ' != elm->rxbuf[hexlen]) {
 454                 /* The line is likely garbled anyway, so bail.
 455                  * The main code will restart listening.
 456                  */
 457                 return -ENODATA;
 458         }
 459
 460         /* Use spaces in CAN ID to distinguish 29 or 11 bit address length.
 461          * No out-of-bounds access:
 462          * We use the fact that we can always read from elm->rxbuf.
 463          */
 464         if (elm->rxbuf[2] == ' ' && elm->rxbuf[5] == ' ' &&
 465             elm->rxbuf[8] == ' ' && elm->rxbuf[11] == ' ' &&
 466             elm->rxbuf[13] == ' ') {
 467                 frame.can_id = CAN_EFF_FLAG;
 468                 datastart = 14;
 469         } else if (elm->rxbuf[3] == ' ' && elm->rxbuf[5] == ' ') {
 470                 frame.can_id = 0;
 471                 datastart = 6;
 472         } else {
 473                 /* This is not a well-formatted data line.
 474                  * Assume it's an error message.
 475                  */
 476                 return -ENODATA;
 477         }
 478
 479         if (hexlen < datastart) {
 480                 /* The line is too short to be a valid frame hex dump.
 481                  * Something interrupted the hex dump or it is invalid.
 482                  */
 483                 return -ENODATA;
 484         }
 485
 486         /* From here on all chars up to buf[hexlen] are hex or spaces,
 487          * at well-defined offsets.
 488          */
 489
 490         /* Read CAN data length */
 491         frame.can_dlc = (hex_to_bin(elm->rxbuf[datastart - 2]) << 0);
 492
 493         /* Read CAN ID */
 494         if (frame.can_id & CAN_EFF_FLAG) {
 495                 frame.can_id |= (hex_to_bin(elm->rxbuf[0]) << 28)
 496                               | (hex_to_bin(elm->rxbuf[1]) << 24)
 497                               | (hex_to_bin(elm->rxbuf[3]) << 20)
 498                               | (hex_to_bin(elm->rxbuf[4]) << 16)
 499                               | (hex_to_bin(elm->rxbuf[6]) << 12)
 500                               | (hex_to_bin(elm->rxbuf[7]) << 8)
 501                               | (hex_to_bin(elm->rxbuf[9]) << 4)
 502                               | (hex_to_bin(elm->rxbuf[10]) << 0);
 503         } else {
 504                 frame.can_id |= (hex_to_bin(elm->rxbuf[0]) << 8)
 505                               | (hex_to_bin(elm->rxbuf[1]) << 4)
 506                               | (hex_to_bin(elm->rxbuf[2]) << 0);
 507         }
 508
 509         /* Check for RTR frame */
 510         if (elm->rxfill >= hexlen + 3 &&
 511             !memcmp(&elm->rxbuf[hexlen], "RTR", 3)) {
 512                 frame.can_id |= CAN_RTR_FLAG;
 513         }
 514
 515         /* Is the line long enough to hold the advertised payload?
 516          * Note: RTR frames have a DLC, but no actual payload.
 517          */
 518         if (!(frame.can_id & CAN_RTR_FLAG) &&
 519             (hexlen < frame.can_dlc * 3 + datastart)) {
 520                 /* Incomplete frame. */
 521
 522                 /* Probably the ELM327's RS232 TX buffer was full.
 523                  * Emit an error frame and exit.
 524                  */
 525                 frame.can_id = CAN_ERR_FLAG | CAN_ERR_CRTL;
 526                 frame.can_dlc = CAN_ERR_DLC;
 527                 frame.data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 528                 elm327_feed_frame_to_netdev(elm, &frame);
 529
 530                 /* Signal failure to parse.
 531                  * The line will be re-parsed as an error line, which will fail.
 532                  * However, this will correctly drop the state machine back into
 533                  * command mode.
 534                  */
 535                 return -ENODATA;
 536         }
 537
 538         /* Parse the data nibbles. */
 539         for (i = 0; i < frame.can_dlc; i++) {
 540                 frame.data[i] = (hex_to_bin(elm->rxbuf[datastart + 3*i]) << 4)
 541                               | (hex_to_bin(elm->rxbuf[datastart + 3*i + 1]));
 542         }
 543
 544         /* Feed the frame to the network layer. */
 545         elm327_feed_frame_to_netdev(elm, &frame);
 546
 547         return 0;
 548 }
 549
 550 /* Assumes elm->lock taken. */
 551 static void elm327_parse_line(struct elmcan *elm, int len)
 552 {
 553         /* Skip empty lines */
 554         if (!len)
 555                 return;
 556
 557         /* Skip echo lines */
 558         if (elm->drop_next_line) {
 559                 elm->drop_next_line = 0;
 560                 return;
 561         } else if (elm->rxbuf[0] == 'A' && elm->rxbuf[1] == 'T') {
 562                 return;
 563         }
 564
 565         /* Regular parsing */
 566         switch (elm->state) {
 567         case ELM_RECEIVING:
 568                 if (elm327_parse_frame(elm, len)) {
 569                         /* Parse an error line. */
 570                         elm327_parse_error(elm, len);
 571
 572                         /* Start afresh. */
 573                         elm327_kick_into_cmd_mode(elm);
 574                 }
 575                 break;
 576         default:
 577                 break;
 578         }
 579 }
 580
 581 /* Assumes elm->lock taken. */
 582 static void elm327_handle_prompt(struct elmcan *elm)
 583 {
 584         struct can_frame *frame = &elm->can_frame;
 585         char local_txbuf[20];
 586
 587         if (!elm->cmds_todo) {
 588                 /* Enter CAN monitor mode */
 589                 elm327_send(elm, "ATMA\r", 5);
 590                 elm->state = ELM_RECEIVING;
 591
 592                 return;
 593         }
 594
 595         /* Reconfigure ELM327 step by step as indicated by elm->cmds_todo */
 596         if (test_bit(TODO_INIT, &elm->cmds_todo)) {
 597                 strcpy(local_txbuf, *elm->next_init_cmd);
 598
 599                 elm->next_init_cmd++;
 600                 if (!(*elm->next_init_cmd)) {
 601                         clear_bit(TODO_INIT, &elm->cmds_todo);
 602                         netdev_info(elm->dev, "Initialization finished.\n");
 603                 }
 604
 605         } else if (test_and_clear_bit(TODO_SILENT_MONITOR, &elm->cmds_todo)) {
 606                 sprintf(local_txbuf, "ATCSM%i\r",
 607                         !(!(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)));
 608
 609         } else if (test_and_clear_bit(TODO_RESPONSES, &elm->cmds_todo)) {
 610                 sprintf(local_txbuf, "ATR%i\r",
 611                         !(elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY));
 612
 613         } else if (test_and_clear_bit(TODO_CAN_CONFIG, &elm->cmds_todo)) {
 614                 sprintf(local_txbuf, "ATPC\r");
 615                 set_bit(TODO_CAN_CONFIG_PART2, &elm->cmds_todo);
 616
 617         } else if (test_and_clear_bit(TODO_CAN_CONFIG_PART2, &elm->cmds_todo)) {
 618                 sprintf(local_txbuf, "ATPB%04X\r",
 619                         elm->can_config);
 620
 621         } else if (test_and_clear_bit(TODO_CANID_29BIT_HIGH, &elm->cmds_todo)) {
 622                 sprintf(local_txbuf, "ATCP%02X\r",
 623                         (frame->can_id & CAN_EFF_MASK) >> 24);
 624
 625         } else if (test_and_clear_bit(TODO_CANID_29BIT_LOW, &elm->cmds_todo)) {
 626                 sprintf(local_txbuf, "ATSH%06X\r",
 627                         frame->can_id & CAN_EFF_MASK & ((1 << 24) - 1));
 628
 629         } else if (test_and_clear_bit(TODO_CANID_11BIT, &elm->cmds_todo)) {
 630                 sprintf(local_txbuf, "ATSH%03X\r",
 631                         frame->can_id & CAN_SFF_MASK);
 632
 633         } else if (test_and_clear_bit(TODO_CAN_DATA, &elm->cmds_todo)) {
 634                 if (frame->can_id & CAN_RTR_FLAG) {
 635                         /* Send an RTR frame. Their DLC is fixed.
 636                          * Some chips don't send them at all.
 637                          */
 638                         sprintf(local_txbuf, "ATRTR\r");
 639                 } else {
 640                         /* Send a regular CAN data frame */
 641                         int i;
 642
 643                         for (i = 0; i < frame->can_dlc; i++) {
 644                                 sprintf(&local_txbuf[2 * i], "%02X",
 645                                         frame->data[i]);
 646                         }
 647
 648                         sprintf(&local_txbuf[2 * i], "\r");
 649                 }
 650
 651                 elm->drop_next_line = 1;
 652                 elm->state = ELM_RECEIVING;
 653         }
 654
 655         elm327_send(elm, local_txbuf, strlen(local_txbuf));
 656 }
 657
 658 static bool elm327_is_ready_char(char c)
 659 {
 660         /* Bits 0xc0 are sometimes set (randomly), hence the mask.
 661          * Probably bad hardware.
 662          */
 663         return (c & 0x3f) == ELM327_READY_CHAR;
 664 }
 665
 666 /* Assumes elm->lock taken. */
 667 static void elm327_drop_bytes(struct elmcan *elm, int i)
 668 {
 669         memmove(&elm->rxbuf[0], &elm->rxbuf[i], ELM327_SIZE_RXBUF - i);
 670         elm->rxfill -= i;
 671 }
 672
 673 /* Assumes elm->lock taken. */
 674 static void elm327_parse_rxbuf(struct elmcan *elm)
 675 {
 676         int len;
 677
 678         switch (elm->state) {
 679         case ELM_NOTINIT:
 680                 elm->rxfill = 0;
 681                 break;
 682
 683         case ELM_GETMAGICCHAR:
 684         {
 685                 /* Wait for 'y' or '>' */
 686                 int i;
 687
 688                 for (i = 0; i < elm->rxfill; i++) {
 689                         if (elm->rxbuf[i] == ELM327_MAGIC_CHAR) {
 690                                 elm327_send(elm, "\r", 1);
 691                                 elm->state = ELM_GETPROMPT;
 692                                 i++;
 693                                 break;
 694                         } else if (elm327_is_ready_char(elm->rxbuf[i])) {
 695                                 elm327_send(elm, ELM327_MAGIC_STRING, 1);
 696                                 i++;
 697                                 break;
 698                         }
 699                 }
 700
 701                 elm327_drop_bytes(elm, i);
 702
 703                 break;
 704         }
 705
 706         case ELM_GETPROMPT:
 707                 /* Wait for '>' */
 708                 if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1]))
 709                         elm327_handle_prompt(elm);
 710
 711                 elm->rxfill = 0;
 712                 break;
 713
 714         case ELM_RECEIVING:
 715                 /* Find <CR> delimiting feedback lines. */
 716                 for (len = 0;
 717                      (len < elm->rxfill) && (elm->rxbuf[len] != '\r');
 718                      len++) {
 719                         /* empty loop */
 720                 }
 721
 722                 if (len == ELM327_SIZE_RXBUF) {
 723                         /* Line exceeds buffer. It's probably all garbage.
 724                          * Did we even connect at the right baud rate?
 725                          */
 726                         netdev_err(elm->dev,
 727                                    "RX buffer overflow. Faulty ELM327 or UART?\n");
 728                         elm327_hw_failure(elm);
 729                         break;
 730                 } else if (len == elm->rxfill) {
 731                         if (elm327_is_ready_char(elm->rxbuf[elm->rxfill - 1])) {
 732                                 /* The ELM327's AT ST response timeout ran out,
 733                                  * so we got a prompt.
 734                                  * Clear RX buffer and restart listening.
 735                                  */
 736                                 elm->rxfill = 0;
 737
 738                                 elm327_handle_prompt(elm);
 739                                 break;
 740                         }
 741
 742                         /* No <CR> found - we haven't received a full line yet.
 743                          * Wait for more data.
 744                          */
 745                         break;
 746                 }
 747
 748                 /* We have a full line to parse. */
 749                 elm327_parse_line(elm, len);
 750
 751                 /* Remove parsed data from RX buffer. */
 752                 elm327_drop_bytes(elm, len + 1);
 753
 754                 /* More data to parse? */
 755                 if (elm->rxfill)
 756                         elm327_parse_rxbuf(elm);
 757         }
 758 }
 759
 760 /* Dummy needed to use can_rx_offload */
 761 static struct sk_buff *elmcan_mailbox_read(struct can_rx_offload *offload,
 762                                            unsigned int n, u32 *timestamp,
 763                                            bool drop)
 764 {
 765         WARN_ON_ONCE(1); /* This function is a dummy, so don't call it! */
 766
 767         return ERR_PTR(-ENOBUFS);
 768 }
 769
 770 static int elmcan_netdev_open(struct net_device *dev)
 771 {
 772         struct elmcan *elm = netdev_priv(dev);
 773         int err;
 774
 775         spin_lock_bh(&elm->lock);
 776         if (elm->hw_failure) {
 777                 netdev_err(elm->dev, "Refusing to open interface after a hardware fault has been detected.\n");
 778                 spin_unlock_bh(&elm->lock);
 779                 return -EIO;
 780         }
 781
 782         if (!elm->tty) {
 783                 spin_unlock_bh(&elm->lock);
 784                 return -ENODEV;
 785         }
 786
 787         /* open_candev() checks for elm->can.bittiming.bitrate != 0 */
 788         err = open_candev(dev);
 789         if (err) {
 790                 spin_unlock_bh(&elm->lock);
 791                 return err;
 792         }
 793
 794         elm327_init(elm);
 795         spin_unlock_bh(&elm->lock);
 796
 797         elm->offload.mailbox_read = elmcan_mailbox_read;
 798         err = can_rx_offload_add_fifo(dev, &elm->offload, ELM327_NAPI_WEIGHT);
 799         if (err) {
 800                 close_candev(dev);
 801                 return err;
 802         }
 803
 804         can_rx_offload_enable(&elm->offload);
 805
 806         can_led_event(dev, CAN_LED_EVENT_OPEN);
 807         elm->can.state = CAN_STATE_ERROR_ACTIVE;
 808         netif_start_queue(dev);
 809
 810         return 0;
 811 }
 812
 813 static int elmcan_netdev_close(struct net_device *dev)
 814 {
 815         struct elmcan *elm = netdev_priv(dev);
 816
 817         netif_stop_queue(dev);
 818
 819         spin_lock_bh(&elm->lock);
 820         if (elm->tty) {
 821                 /* Interrupt whatever we're doing right now */
 822                 elm327_send(elm, ELM327_MAGIC_STRING, 1);
 823
 824                 /* Clear the wakeup bit, as the netdev will be down and thus
 825                  * the wakeup handler won't clear it
 826                  */
 827                 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
 828
 829                 spin_unlock_bh(&elm->lock);
 830
 831                 flush_work(&elm->tx_work);
 832         } else {
 833                 spin_unlock_bh(&elm->lock);
 834         }
 835
 836         can_rx_offload_disable(&elm->offload);
 837         elm->can.state = CAN_STATE_STOPPED;
 838         can_rx_offload_del(&elm->offload);
 839         close_candev(dev);
 840         can_led_event(dev, CAN_LED_EVENT_STOP);
 841
 842         return 0;
 843 }
 844
 845 /* Send a can_frame to a TTY. */
 846 static netdev_tx_t elmcan_netdev_start_xmit(struct sk_buff *skb,
 847                                             struct net_device *dev)
 848 {
 849         struct elmcan *elm = netdev_priv(dev);
 850         struct can_frame *frame = (struct can_frame *)skb->data;
 851
 852         if (skb->len != sizeof(struct can_frame))
 853                 goto out;
 854
 855         if (!netif_running(dev))  {
 856                 netdev_warn(elm->dev, "xmit: iface is down.\n");
 857                 goto out;
 858         }
 859
 860         /* BHs are already disabled, so no spin_lock_bh().
 861          * See Documentation/networking/netdevices.txt
 862          */
 863         spin_lock(&elm->lock);
 864
 865         /* We shouldn't get here after a hardware fault:
 866          * can_bus_off() calls netif_carrier_off()
 867          */
 868         WARN_ON_ONCE(elm->hw_failure);
 869
 870         if (!elm->tty ||
 871             elm->hw_failure ||
 872             elm->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) {
 873                 spin_unlock(&elm->lock);
 874                 goto out;
 875         }
 876
 877         netif_stop_queue(dev);
 878
 879         elm327_send_frame(elm, frame);
 880         spin_unlock(&elm->lock);
 881
 882         dev->stats.tx_packets++;
 883         dev->stats.tx_bytes += frame->can_dlc;
 884
 885         can_led_event(dev, CAN_LED_EVENT_TX);
 886
 887 out:
 888         kfree_skb(skb);
 889         return NETDEV_TX_OK;
 890 }
 891
 892 static const struct net_device_ops elmcan_netdev_ops = {
 893         .ndo_open       = elmcan_netdev_open,
 894         .ndo_stop       = elmcan_netdev_close,
 895         .ndo_start_xmit = elmcan_netdev_start_xmit,
 896         .ndo_change_mtu = can_change_mtu,
 897 };
 898
 899 /* Get a reference to our struct, taking into account locks/refcounts.
 900  * This is to ensure ordering in case we are shutting down, and to ensure
 901  * there is a refcount at all (otherwise tty->disc_data may be freed and
 902  * before we increment the refcount).
 903  * Use this for anything that can race against elmcan_ldisc_close().
 904  */
 905 static struct elmcan *get_elm(struct tty_struct *tty)
 906 {
 907         struct elmcan *elm;
 908         bool got_ref;
 909
 910         spin_lock_bh(&elmcan_discdata_lock);
 911         elm = (struct elmcan *)tty->disc_data;
 912
 913         if (!elm) {
 914                 spin_unlock_bh(&elmcan_discdata_lock);
 915                 return NULL;
 916         }
 917
 918         got_ref = atomic_inc_not_zero(&elm->refcount);
 919         spin_unlock_bh(&elmcan_discdata_lock);
 920
 921         if (!got_ref)
 922                 return NULL;
 923
 924         return elm;
 925 }
 926
 927 static void put_elm(struct elmcan *elm)
 928 {
 929         atomic_dec(&elm->refcount);
 930 }
 931
 932 static bool elmcan_is_valid_rx_char(char c)
 933 {
 934         return (accept_flaky_uart ||
 935                 isdigit(c) ||
 936                 isupper(c) ||
 937                 c == ELM327_MAGIC_CHAR ||
 938                 c == ELM327_READY_CHAR ||
 939                 c == '<' ||
 940                 c == 'a' ||
 941                 c == 'b' ||
 942                 c == 'v' ||
 943                 c == '.' ||
 944                 c == '?' ||
 945                 c == '\r' ||
 946                 c == ' ');
 947 }
 948
 949 /* Handle incoming ELM327 ASCII data.
 950  * This will not be re-entered while running, but other ldisc
 951  * functions may be called in parallel.
 952  */
 953 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
 954 static void elmcan_ldisc_rx(struct tty_struct *tty,
 955                             const unsigned char *cp, char *fp, int count)
 956 #else
 957 static void elmcan_ldisc_rx(struct tty_struct *tty,
 958                             const unsigned char *cp, const char *fp, int count)
 959 #endif
 960 {
 961         struct elmcan *elm = get_elm(tty);
 962
 963         if (!elm)
 964                 return;
 965
 966         spin_lock_bh(&elm->lock);
 967
 968         if (elm->hw_failure)
 969                 goto out;
 970
 971         while (count-- && elm->rxfill < ELM327_SIZE_RXBUF) {
 972                 if (fp && *fp++) {
 973                         netdev_err(elm->dev, "Error in received character stream. Check your wiring.");
 974
 975                         elm327_hw_failure(elm);
 976
 977                         goto out;
 978                 }
 979
 980                 /* Ignore NUL characters, which the PIC microcontroller may
 981                  * inadvertently insert due to a known hardware bug.
 982                  * See ELM327 documentation, which refers to a Microchip PIC
 983                  * bug description.
 984                  */
 985                 if (*cp != 0) {
 986                         /* Check for stray characters on the UART line.
 987                          * Likely caused by bad hardware.
 988                          */
 989                         if (!elmcan_is_valid_rx_char(*cp)) {
 990                                 netdev_err(elm->dev,
 991                                            "Received illegal character %02x.\n",
 992                                            *cp);
 993                                 elm327_hw_failure(elm);
 994
 995                                 goto out;
 996                         }
 997
 998                         elm->rxbuf[elm->rxfill++] = *cp;
 999                 }
1000
1001                 cp++;
1002         }
1003
1004         if (count >= 0) {
1005                 netdev_err(elm->dev, "Receive buffer overflowed. Bad chip or wiring?");
1006
1007                 elm327_hw_failure(elm);
1008
1009                 goto out;
1010         }
1011
1012         elm327_parse_rxbuf(elm);
1013
1014 out:
1015         spin_unlock_bh(&elm->lock);
1016         put_elm(elm);
1017 }
1018
1019 /* Write out remaining transmit buffer.
1020  * Scheduled when TTY is writable.
1021  */
1022 static void elmcan_ldisc_tx_worker(struct work_struct *work)
1023 {
1024         /* No need to use get_elm() here, as we'll always flush workers
1025          * before destroying the elmcan object.
1026          */
1027         struct elmcan *elm = container_of(work, struct elmcan, tx_work);
1028         ssize_t actual;
1029
1030         spin_lock_bh(&elm->lock);
1031         if (elm->hw_failure) {
1032                 spin_unlock_bh(&elm->lock);
1033                 return;
1034         }
1035
1036         if (!elm->tty || !netif_running(elm->dev)) {
1037                 spin_unlock_bh(&elm->lock);
1038                 return;
1039         }
1040
1041         if (elm->txleft <= 0)  {
1042                 /* Our TTY write buffer is empty:
1043                  * Allow netdev to hand us another packet
1044                  */
1045                 clear_bit(TTY_DO_WRITE_WAKEUP, &elm->tty->flags);
1046                 spin_unlock_bh(&elm->lock);
1047                 netif_wake_queue(elm->dev);
1048                 return;
1049         }
1050
1051         actual = elm->tty->ops->write(elm->tty, elm->txhead, elm->txleft);
1052         if (actual < 0) {
1053                 netdev_err(elm->dev,
1054                            "Failed to write to tty %s.\n",
1055                            elm->tty->name);
1056                 elm327_hw_failure(elm);
1057                 spin_unlock_bh(&elm->lock);
1058                 return;
1059         }
1060
1061         elm->txleft -= actual;
1062         elm->txhead += actual;
1063         spin_unlock_bh(&elm->lock);
1064 }
1065
1066 /* Called by the driver when there's room for more data. */
1067 static void elmcan_ldisc_tx_wakeup(struct tty_struct *tty)
1068 {
1069         struct elmcan *elm = get_elm(tty);
1070
1071         if (!elm)
1072                 return;
1073
1074         schedule_work(&elm->tx_work);
1075
1076         put_elm(elm);
1077 }
1078
1079 /* ELM327 can only handle bitrates that are integer divisors of 500 kHz,
1080  * or 7/8 of that. Divisors are 1 to 64.
1081  * Currently we don't implement support for 7/8 rates.
1082  */
1083 static const u32 elmcan_bitrate_const[64] = {
1084          7812,  7936,  8064,  8196,  8333,  8474,  8620,  8771,
1085          8928,  9090,  9259,  9433,  9615,  9803, 10000, 10204,
1086         10416, 10638, 10869, 11111, 11363, 11627, 11904, 12195,
1087         12500, 12820, 13157, 13513, 13888, 14285, 14705, 15151,
1088         15625, 16129, 16666, 17241, 17857, 18518, 19230, 20000,
1089         20833, 21739, 22727, 23809, 25000, 26315, 27777, 29411,
1090         31250, 33333, 35714, 38461, 41666, 45454, 50000, 55555,
1091         62500, 71428, 83333, 100000, 125000, 166666, 250000, 500000
1092 };
1093
1094 /* Dummy needed to use bitrate_const */
1095 static int elmcan_do_set_bittiming(struct net_device *netdev)
1096 {
1097         return 0;
1098 }
1099
1100 static int elmcan_ldisc_open(struct tty_struct *tty)
1101 {
1102         struct net_device *dev;
1103         struct elmcan *elm;
1104         int err;
1105
1106         if (!capable(CAP_NET_ADMIN))
1107                 return -EPERM;
1108
1109         if (!tty->ops->write)
1110                 return -EOPNOTSUPP;
1111
1112         dev = alloc_candev(sizeof(struct elmcan), 0);
1113         if (!dev)
1114                 return -ENFILE;
1115         elm = netdev_priv(dev);
1116
1117         elm->txbuf = kmalloc(ELM327_SIZE_TXBUF, GFP_KERNEL);
1118         if (!elm->txbuf) {
1119                 err = -ENOMEM;
1120                 goto out_err;
1121         }
1122
1123         /* Configure TTY interface */
1124         tty->receive_room = 65536; /* We don't flow control */
1125         elm->txleft = 0; /* Clear TTY TX buffer */
1126         spin_lock_init(&elm->lock);
1127         atomic_set(&elm->refcount, 1);
1128         INIT_WORK(&elm->tx_work, elmcan_ldisc_tx_worker);
1129
1130         /* Configure CAN metadata */
1131         elm->can.state = CAN_STATE_STOPPED;
1132         elm->can.bitrate_const = elmcan_bitrate_const;
1133         elm->can.bitrate_const_cnt = ARRAY_SIZE(elmcan_bitrate_const);
1134         elm->can.do_set_bittiming = elmcan_do_set_bittiming;
1135         elm->can.ctrlmode_supported = CAN_CTRLMODE_LISTENONLY;
1136
1137         /* Configure netdev interface */
1138         elm->dev = dev;
1139         dev->netdev_ops = &elmcan_netdev_ops;
1140
1141         /* Mark ldisc channel as alive */
1142         elm->tty = tty;
1143         tty->disc_data = elm;
1144
1145         devm_can_led_init(elm->dev);
1146
1147         /* Let 'er rip */
1148         err = register_candev(elm->dev);
1149         if (err)
1150                 goto out_err;
1151
1152         netdev_info(elm->dev, "elmcan on %s.\n", tty->name);
1153
1154         return 0;
1155
1156 out_err:
1157         kfree(elm->txbuf);
1158         free_candev(elm->dev);
1159         return err;
1160 }
1161
1162 /* Close down an elmcan channel.
1163  * This means flushing out any pending queues, and then returning.
1164  * This call is serialized against other ldisc functions:
1165  * Once this is called, no other ldisc function of ours is entered.
1166  *
1167  * We also use this function for a hangup event.
1168  */
1169 static void elmcan_ldisc_close(struct tty_struct *tty)
1170 {
1171         struct elmcan *elm = get_elm(tty);
1172
1173         if (!elm)
1174                 return;
1175
1176         /* unregister_netdev() calls .ndo_stop() so we don't have to. */
1177         unregister_candev(elm->dev);
1178
1179         /* Decrease the refcount twice, once for our own get_elm(),
1180          * and once to remove the count of 1 that we set in _open().
1181          * Once it reaches 0, we can safely destroy it.
1182          */
1183         put_elm(elm);
1184         put_elm(elm);
1185
1186         while (atomic_read(&elm->refcount) > 0)
1187                 msleep_interruptible(10);
1188
1189         /* At this point, all ldisc calls to us have become no-ops. */
1190
1191         flush_work(&elm->tx_work);
1192
1193         /* Mark channel as dead */
1194         spin_lock_bh(&elm->lock);
1195         tty->disc_data = NULL;
1196         elm->tty = NULL;
1197         spin_unlock_bh(&elm->lock);
1198
1199         netdev_info(elm->dev, "elmcan off %s.\n", tty->name);
1200
1201         kfree(elm->txbuf);
1202         free_candev(elm->dev);
1203 }
1204
1205 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
1206 static int elmcan_ldisc_hangup(struct tty_struct *tty)
1207 #else
1208 static void elmcan_ldisc_hangup(struct tty_struct *tty)
1209 #endif
1210 {
1211         elmcan_ldisc_close(tty);
1212 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
1213         return 0;
1214 #endif
1215 }
1216
1217 static int elmcan_ldisc_ioctl(struct tty_struct *tty,
1218 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,17,0)
1219                               struct file *file,
1220 #endif
1221                               unsigned int cmd, unsigned long arg)
1222 {
1223         struct elmcan *elm = get_elm(tty);
1224         unsigned int tmp;
1225
1226         if (!elm)
1227                 return -EINVAL;
1228
1229         switch (cmd) {
1230         case SIOCGIFNAME:
1231                 tmp = strnlen(elm->dev->name, IFNAMSIZ - 1) + 1;
1232                 if (copy_to_user((void __user *)arg, elm->dev->name, tmp)) {
1233                         put_elm(elm);
1234                         return -EFAULT;
1235                 }
1236
1237                 put_elm(elm);
1238                 return 0;
1239
1240         case SIOCSIFHWADDR:
1241                 put_elm(elm);
1242                 return -EINVAL;
1243
1244         default:
1245                 put_elm(elm);
1246 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,16,0)
1247                 return tty_mode_ioctl(tty, file, cmd, arg);
1248 #else
1249                 return tty_mode_ioctl(tty, cmd, arg);
1250 #endif
1251         }
1252 }
1253
1254 static struct tty_ldisc_ops elmcan_ldisc = {
1255         .owner          = THIS_MODULE,
1256         .name           = "elmcan",
1257         .num            = N_ELMCAN,
1258         .receive_buf    = elmcan_ldisc_rx,
1259         .write_wakeup   = elmcan_ldisc_tx_wakeup,
1260         .open           = elmcan_ldisc_open,
1261         .close          = elmcan_ldisc_close,
1262         .hangup         = elmcan_ldisc_hangup,
1263         .ioctl          = elmcan_ldisc_ioctl,
1264 };
1265
1266 static int __init elmcan_init(void)
1267 {
1268         int status;
1269
1270 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1271         status = tty_register_ldisc(N_ELMCAN, &elmcan_ldisc);
1272 #else
1273         status = tty_register_ldisc(&elmcan_ldisc);
1274 #endif
1275         if (status)
1276                 pr_err("Can't register line discipline\n");
1277
1278         return status;
1279 }
1280
1281 static void __exit elmcan_exit(void)
1282 {
1283         /* This will only be called when all channels have been closed by
1284          * userspace - tty_ldisc.c takes care of the module's refcount.
1285          */
1286 #if LINUX_VERSION_CODE < KERNEL_VERSION(5,14,0)
1287         int status;
1288
1289         status = tty_unregister_ldisc(N_ELMCAN);
1290         if (status)
1291                 pr_err("Can't unregister line discipline (error: %d)\n",
1292                        status);
1293 #else
1294         tty_unregister_ldisc(&elmcan_ldisc);
1295 #endif
1296 }
1297
1298 module_init(elmcan_init);
1299 module_exit(elmcan_exit);