module/can327.c

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