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