module/elmcan.c

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