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