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