module/elmcan.c

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