1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * CAN driver for PEAK System PCAN-USB adapter 4 * Derived from the PCAN project file driver/src/pcan_usb.c 5 * 6 * Copyright (C) 2003-2010 PEAK System-Technik GmbH 7 * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com> 8 * 9 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de> 10 */ 11 #include <asm/unaligned.h> 12 #include <linux/netdevice.h> 13 #include <linux/usb.h> 14 #include <linux/module.h> 15 #include <linux/ethtool.h> 16 17 #include <linux/can.h> 18 #include <linux/can/dev.h> 19 #include <linux/can/error.h> 20 21 #include "pcan_usb_core.h" 22 23 /* PCAN-USB Endpoints */ 24 #define PCAN_USB_EP_CMDOUT 1 25 #define PCAN_USB_EP_CMDIN (PCAN_USB_EP_CMDOUT | USB_DIR_IN) 26 #define PCAN_USB_EP_MSGOUT 2 27 #define PCAN_USB_EP_MSGIN (PCAN_USB_EP_MSGOUT | USB_DIR_IN) 28 29 /* PCAN-USB command struct */ 30 #define PCAN_USB_CMD_FUNC 0 31 #define PCAN_USB_CMD_NUM 1 32 #define PCAN_USB_CMD_ARGS 2 33 #define PCAN_USB_CMD_ARGS_LEN 14 34 #define PCAN_USB_CMD_LEN (PCAN_USB_CMD_ARGS + \ 35 PCAN_USB_CMD_ARGS_LEN) 36 37 /* PCAN-USB commands */ 38 #define PCAN_USB_CMD_BITRATE 1 39 #define PCAN_USB_CMD_SET_BUS 3 40 #define PCAN_USB_CMD_DEVID 4 41 #define PCAN_USB_CMD_SN 6 42 #define PCAN_USB_CMD_REGISTER 9 43 #define PCAN_USB_CMD_EXT_VCC 10 44 #define PCAN_USB_CMD_ERR_FR 11 45 #define PCAN_USB_CMD_LED 12 46 47 /* PCAN_USB_CMD_SET_BUS number arg */ 48 #define PCAN_USB_BUS_XCVER 2 49 #define PCAN_USB_BUS_SILENT_MODE 3 50 51 /* PCAN_USB_CMD_xxx functions */ 52 #define PCAN_USB_GET 1 53 #define PCAN_USB_SET 2 54 55 /* PCAN-USB command timeout (ms.) */ 56 #define PCAN_USB_COMMAND_TIMEOUT 1000 57 58 /* PCAN-USB startup timeout (ms.) */ 59 #define PCAN_USB_STARTUP_TIMEOUT 10 60 61 /* PCAN-USB rx/tx buffers size */ 62 #define PCAN_USB_RX_BUFFER_SIZE 64 63 #define PCAN_USB_TX_BUFFER_SIZE 64 64 65 #define PCAN_USB_MSG_HEADER_LEN 2 66 67 #define PCAN_USB_MSG_TX_CAN 2 /* Tx msg is a CAN frame */ 68 69 /* PCAN-USB adapter internal clock (MHz) */ 70 #define PCAN_USB_CRYSTAL_HZ 16000000 71 72 /* PCAN-USB USB message record status/len field */ 73 #define PCAN_USB_STATUSLEN_TIMESTAMP (1 << 7) 74 #define PCAN_USB_STATUSLEN_INTERNAL (1 << 6) 75 #define PCAN_USB_STATUSLEN_EXT_ID (1 << 5) 76 #define PCAN_USB_STATUSLEN_RTR (1 << 4) 77 #define PCAN_USB_STATUSLEN_DLC (0xf) 78 79 /* PCAN-USB 4.1 CAN Id tx extended flags */ 80 #define PCAN_USB_TX_SRR 0x01 /* SJA1000 SRR command */ 81 #define PCAN_USB_TX_AT 0x02 /* SJA1000 AT command */ 82 83 /* PCAN-USB error flags */ 84 #define PCAN_USB_ERROR_TXFULL 0x01 85 #define PCAN_USB_ERROR_RXQOVR 0x02 86 #define PCAN_USB_ERROR_BUS_LIGHT 0x04 87 #define PCAN_USB_ERROR_BUS_HEAVY 0x08 88 #define PCAN_USB_ERROR_BUS_OFF 0x10 89 #define PCAN_USB_ERROR_RXQEMPTY 0x20 90 #define PCAN_USB_ERROR_QOVR 0x40 91 #define PCAN_USB_ERROR_TXQFULL 0x80 92 93 #define PCAN_USB_ERROR_BUS (PCAN_USB_ERROR_BUS_LIGHT | \ 94 PCAN_USB_ERROR_BUS_HEAVY | \ 95 PCAN_USB_ERROR_BUS_OFF) 96 97 /* SJA1000 modes */ 98 #define SJA1000_MODE_NORMAL 0x00 99 #define SJA1000_MODE_INIT 0x01 100 101 /* 102 * tick duration = 42.666 us => 103 * (tick_number * 44739243) >> 20 ~ (tick_number * 42666) / 1000 104 * accuracy = 10^-7 105 */ 106 #define PCAN_USB_TS_DIV_SHIFTER 20 107 #define PCAN_USB_TS_US_PER_TICK 44739243 108 109 /* PCAN-USB messages record types */ 110 #define PCAN_USB_REC_ERROR 1 111 #define PCAN_USB_REC_ANALOG 2 112 #define PCAN_USB_REC_BUSLOAD 3 113 #define PCAN_USB_REC_TS 4 114 #define PCAN_USB_REC_BUSEVT 5 115 116 /* CAN bus events notifications selection mask */ 117 #define PCAN_USB_ERR_RXERR 0x02 /* ask for rxerr counter */ 118 #define PCAN_USB_ERR_TXERR 0x04 /* ask for txerr counter */ 119 120 /* This mask generates an usb packet each time the state of the bus changes. 121 * In other words, its interest is to know which side among rx and tx is 122 * responsible of the change of the bus state. 123 */ 124 #define PCAN_USB_BERR_MASK (PCAN_USB_ERR_RXERR | PCAN_USB_ERR_TXERR) 125 126 /* identify bus event packets with rx/tx error counters */ 127 #define PCAN_USB_ERR_CNT_DEC 0x00 /* counters are decreasing */ 128 #define PCAN_USB_ERR_CNT_INC 0x80 /* counters are increasing */ 129 130 /* private to PCAN-USB adapter */ 131 struct pcan_usb { 132 struct peak_usb_device dev; 133 struct peak_time_ref time_ref; 134 struct timer_list restart_timer; 135 struct can_berr_counter bec; 136 }; 137 138 /* incoming message context for decoding */ 139 struct pcan_usb_msg_context { 140 u16 ts16; 141 u8 prev_ts8; 142 u8 *ptr; 143 u8 *end; 144 u8 rec_cnt; 145 u8 rec_idx; 146 u8 rec_ts_idx; 147 struct net_device *netdev; 148 struct pcan_usb *pdev; 149 }; 150 151 /* 152 * send a command 153 */ 154 static int pcan_usb_send_cmd(struct peak_usb_device *dev, u8 f, u8 n, u8 *p) 155 { 156 int err; 157 int actual_length; 158 159 /* usb device unregistered? */ 160 if (!(dev->state & PCAN_USB_STATE_CONNECTED)) 161 return 0; 162 163 dev->cmd_buf[PCAN_USB_CMD_FUNC] = f; 164 dev->cmd_buf[PCAN_USB_CMD_NUM] = n; 165 166 if (p) 167 memcpy(dev->cmd_buf + PCAN_USB_CMD_ARGS, 168 p, PCAN_USB_CMD_ARGS_LEN); 169 170 err = usb_bulk_msg(dev->udev, 171 usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT), 172 dev->cmd_buf, PCAN_USB_CMD_LEN, &actual_length, 173 PCAN_USB_COMMAND_TIMEOUT); 174 if (err) 175 netdev_err(dev->netdev, 176 "sending cmd f=0x%x n=0x%x failure: %d\n", 177 f, n, err); 178 return err; 179 } 180 181 /* 182 * send a command then wait for its response 183 */ 184 static int pcan_usb_wait_rsp(struct peak_usb_device *dev, u8 f, u8 n, u8 *p) 185 { 186 int err; 187 int actual_length; 188 189 /* usb device unregistered? */ 190 if (!(dev->state & PCAN_USB_STATE_CONNECTED)) 191 return 0; 192 193 /* first, send command */ 194 err = pcan_usb_send_cmd(dev, f, n, NULL); 195 if (err) 196 return err; 197 198 err = usb_bulk_msg(dev->udev, 199 usb_rcvbulkpipe(dev->udev, PCAN_USB_EP_CMDIN), 200 dev->cmd_buf, PCAN_USB_CMD_LEN, &actual_length, 201 PCAN_USB_COMMAND_TIMEOUT); 202 if (err) 203 netdev_err(dev->netdev, 204 "waiting rsp f=0x%x n=0x%x failure: %d\n", f, n, err); 205 else if (p) 206 memcpy(p, dev->cmd_buf + PCAN_USB_CMD_ARGS, 207 PCAN_USB_CMD_ARGS_LEN); 208 209 return err; 210 } 211 212 static int pcan_usb_set_sja1000(struct peak_usb_device *dev, u8 mode) 213 { 214 u8 args[PCAN_USB_CMD_ARGS_LEN] = { 215 [1] = mode, 216 }; 217 218 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_REGISTER, PCAN_USB_SET, 219 args); 220 } 221 222 static int pcan_usb_set_bus(struct peak_usb_device *dev, u8 onoff) 223 { 224 u8 args[PCAN_USB_CMD_ARGS_LEN] = { 225 [0] = !!onoff, 226 }; 227 228 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_SET_BUS, PCAN_USB_BUS_XCVER, 229 args); 230 } 231 232 static int pcan_usb_set_silent(struct peak_usb_device *dev, u8 onoff) 233 { 234 u8 args[PCAN_USB_CMD_ARGS_LEN] = { 235 [0] = !!onoff, 236 }; 237 238 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_SET_BUS, 239 PCAN_USB_BUS_SILENT_MODE, args); 240 } 241 242 /* send the cmd to be notified from bus errors */ 243 static int pcan_usb_set_err_frame(struct peak_usb_device *dev, u8 err_mask) 244 { 245 u8 args[PCAN_USB_CMD_ARGS_LEN] = { 246 [0] = err_mask, 247 }; 248 249 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_ERR_FR, PCAN_USB_SET, args); 250 } 251 252 static int pcan_usb_set_ext_vcc(struct peak_usb_device *dev, u8 onoff) 253 { 254 u8 args[PCAN_USB_CMD_ARGS_LEN] = { 255 [0] = !!onoff, 256 }; 257 258 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_EXT_VCC, PCAN_USB_SET, args); 259 } 260 261 static int pcan_usb_set_led(struct peak_usb_device *dev, u8 onoff) 262 { 263 u8 args[PCAN_USB_CMD_ARGS_LEN] = { 264 [0] = !!onoff, 265 }; 266 267 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_LED, PCAN_USB_SET, args); 268 } 269 270 /* 271 * set bittiming value to can 272 */ 273 static int pcan_usb_set_bittiming(struct peak_usb_device *dev, 274 struct can_bittiming *bt) 275 { 276 u8 args[PCAN_USB_CMD_ARGS_LEN]; 277 u8 btr0, btr1; 278 279 btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6); 280 btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) | 281 (((bt->phase_seg2 - 1) & 0x7) << 4); 282 if (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 283 btr1 |= 0x80; 284 285 netdev_info(dev->netdev, "setting BTR0=0x%02x BTR1=0x%02x\n", 286 btr0, btr1); 287 288 args[0] = btr1; 289 args[1] = btr0; 290 291 return pcan_usb_send_cmd(dev, PCAN_USB_CMD_BITRATE, PCAN_USB_SET, args); 292 } 293 294 /* 295 * init/reset can 296 */ 297 static int pcan_usb_write_mode(struct peak_usb_device *dev, u8 onoff) 298 { 299 int err; 300 301 err = pcan_usb_set_bus(dev, onoff); 302 if (err) 303 return err; 304 305 if (!onoff) { 306 err = pcan_usb_set_sja1000(dev, SJA1000_MODE_INIT); 307 } else { 308 /* the PCAN-USB needs time to init */ 309 set_current_state(TASK_INTERRUPTIBLE); 310 schedule_timeout(msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT)); 311 } 312 313 return err; 314 } 315 316 /* 317 * handle end of waiting for the device to reset 318 */ 319 static void pcan_usb_restart(struct timer_list *t) 320 { 321 struct pcan_usb *pdev = from_timer(pdev, t, restart_timer); 322 struct peak_usb_device *dev = &pdev->dev; 323 324 /* notify candev and netdev */ 325 peak_usb_restart_complete(dev); 326 } 327 328 /* 329 * handle the submission of the restart urb 330 */ 331 static void pcan_usb_restart_pending(struct urb *urb) 332 { 333 struct pcan_usb *pdev = urb->context; 334 335 /* the PCAN-USB needs time to restart */ 336 mod_timer(&pdev->restart_timer, 337 jiffies + msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT)); 338 339 /* can delete usb resources */ 340 peak_usb_async_complete(urb); 341 } 342 343 /* 344 * handle asynchronous restart 345 */ 346 static int pcan_usb_restart_async(struct peak_usb_device *dev, struct urb *urb, 347 u8 *buf) 348 { 349 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev); 350 351 if (timer_pending(&pdev->restart_timer)) 352 return -EBUSY; 353 354 /* set bus on */ 355 buf[PCAN_USB_CMD_FUNC] = 3; 356 buf[PCAN_USB_CMD_NUM] = 2; 357 buf[PCAN_USB_CMD_ARGS] = 1; 358 359 usb_fill_bulk_urb(urb, dev->udev, 360 usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT), 361 buf, PCAN_USB_CMD_LEN, 362 pcan_usb_restart_pending, pdev); 363 364 return usb_submit_urb(urb, GFP_ATOMIC); 365 } 366 367 /* 368 * read serial number from device 369 */ 370 static int pcan_usb_get_serial(struct peak_usb_device *dev, u32 *serial_number) 371 { 372 u8 args[PCAN_USB_CMD_ARGS_LEN]; 373 int err; 374 375 err = pcan_usb_wait_rsp(dev, PCAN_USB_CMD_SN, PCAN_USB_GET, args); 376 if (err) 377 return err; 378 *serial_number = le32_to_cpup((__le32 *)args); 379 380 return 0; 381 } 382 383 /* 384 * read device id from device 385 */ 386 static int pcan_usb_get_device_id(struct peak_usb_device *dev, u32 *device_id) 387 { 388 u8 args[PCAN_USB_CMD_ARGS_LEN]; 389 int err; 390 391 err = pcan_usb_wait_rsp(dev, PCAN_USB_CMD_DEVID, PCAN_USB_GET, args); 392 if (err) 393 netdev_err(dev->netdev, "getting device id failure: %d\n", err); 394 395 else 396 *device_id = args[0]; 397 398 return err; 399 } 400 401 /* 402 * update current time ref with received timestamp 403 */ 404 static int pcan_usb_update_ts(struct pcan_usb_msg_context *mc) 405 { 406 if ((mc->ptr + 2) > mc->end) 407 return -EINVAL; 408 409 mc->ts16 = get_unaligned_le16(mc->ptr); 410 411 if (mc->rec_idx > 0) 412 peak_usb_update_ts_now(&mc->pdev->time_ref, mc->ts16); 413 else 414 peak_usb_set_ts_now(&mc->pdev->time_ref, mc->ts16); 415 416 return 0; 417 } 418 419 /* 420 * decode received timestamp 421 */ 422 static int pcan_usb_decode_ts(struct pcan_usb_msg_context *mc, u8 first_packet) 423 { 424 /* only 1st packet supplies a word timestamp */ 425 if (first_packet) { 426 if ((mc->ptr + 2) > mc->end) 427 return -EINVAL; 428 429 mc->ts16 = get_unaligned_le16(mc->ptr); 430 mc->prev_ts8 = mc->ts16 & 0x00ff; 431 432 mc->ptr += 2; 433 } else { 434 u8 ts8; 435 436 if ((mc->ptr + 1) > mc->end) 437 return -EINVAL; 438 439 ts8 = *mc->ptr++; 440 441 if (ts8 < mc->prev_ts8) 442 mc->ts16 += 0x100; 443 444 mc->ts16 &= 0xff00; 445 mc->ts16 |= ts8; 446 mc->prev_ts8 = ts8; 447 } 448 449 return 0; 450 } 451 452 static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n, 453 u8 status_len) 454 { 455 struct sk_buff *skb; 456 struct can_frame *cf; 457 enum can_state new_state = CAN_STATE_ERROR_ACTIVE; 458 459 /* ignore this error until 1st ts received */ 460 if (n == PCAN_USB_ERROR_QOVR) 461 if (!mc->pdev->time_ref.tick_count) 462 return 0; 463 464 /* allocate an skb to store the error frame */ 465 skb = alloc_can_err_skb(mc->netdev, &cf); 466 467 if (n & PCAN_USB_ERROR_RXQOVR) { 468 /* data overrun interrupt */ 469 netdev_dbg(mc->netdev, "data overrun interrupt\n"); 470 mc->netdev->stats.rx_over_errors++; 471 mc->netdev->stats.rx_errors++; 472 if (cf) { 473 cf->can_id |= CAN_ERR_CRTL; 474 cf->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW; 475 } 476 } 477 478 if (n & PCAN_USB_ERROR_TXQFULL) 479 netdev_dbg(mc->netdev, "device Tx queue full)\n"); 480 481 if (n & PCAN_USB_ERROR_BUS_OFF) { 482 new_state = CAN_STATE_BUS_OFF; 483 } else if (n & PCAN_USB_ERROR_BUS_HEAVY) { 484 new_state = ((mc->pdev->bec.txerr >= 128) || 485 (mc->pdev->bec.rxerr >= 128)) ? 486 CAN_STATE_ERROR_PASSIVE : 487 CAN_STATE_ERROR_WARNING; 488 } else { 489 new_state = CAN_STATE_ERROR_ACTIVE; 490 } 491 492 /* handle change of state */ 493 if (new_state != mc->pdev->dev.can.state) { 494 enum can_state tx_state = 495 (mc->pdev->bec.txerr >= mc->pdev->bec.rxerr) ? 496 new_state : 0; 497 enum can_state rx_state = 498 (mc->pdev->bec.txerr <= mc->pdev->bec.rxerr) ? 499 new_state : 0; 500 501 can_change_state(mc->netdev, cf, tx_state, rx_state); 502 503 if (new_state == CAN_STATE_BUS_OFF) { 504 can_bus_off(mc->netdev); 505 } else if (cf && (cf->can_id & CAN_ERR_CRTL)) { 506 /* Supply TX/RX error counters in case of 507 * controller error. 508 */ 509 cf->data[6] = mc->pdev->bec.txerr; 510 cf->data[7] = mc->pdev->bec.rxerr; 511 } 512 } 513 514 if (!skb) 515 return -ENOMEM; 516 517 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) { 518 struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb); 519 520 peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16, 521 &hwts->hwtstamp); 522 } 523 524 netif_rx(skb); 525 526 return 0; 527 } 528 529 /* decode bus event usb packet: first byte contains rxerr while 2nd one contains 530 * txerr. 531 */ 532 static int pcan_usb_handle_bus_evt(struct pcan_usb_msg_context *mc, u8 ir) 533 { 534 struct pcan_usb *pdev = mc->pdev; 535 536 /* acccording to the content of the packet */ 537 switch (ir) { 538 case PCAN_USB_ERR_CNT_DEC: 539 case PCAN_USB_ERR_CNT_INC: 540 541 /* save rx/tx error counters from in the device context */ 542 pdev->bec.rxerr = mc->ptr[1]; 543 pdev->bec.txerr = mc->ptr[2]; 544 break; 545 546 default: 547 /* reserved */ 548 break; 549 } 550 551 return 0; 552 } 553 554 /* 555 * decode non-data usb message 556 */ 557 static int pcan_usb_decode_status(struct pcan_usb_msg_context *mc, 558 u8 status_len) 559 { 560 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC; 561 u8 f, n; 562 int err; 563 564 /* check whether function and number can be read */ 565 if ((mc->ptr + 2) > mc->end) 566 return -EINVAL; 567 568 f = mc->ptr[PCAN_USB_CMD_FUNC]; 569 n = mc->ptr[PCAN_USB_CMD_NUM]; 570 mc->ptr += PCAN_USB_CMD_ARGS; 571 572 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) { 573 int err = pcan_usb_decode_ts(mc, !mc->rec_ts_idx); 574 575 if (err) 576 return err; 577 578 /* Next packet in the buffer will have a timestamp on a single 579 * byte 580 */ 581 mc->rec_ts_idx++; 582 } 583 584 switch (f) { 585 case PCAN_USB_REC_ERROR: 586 err = pcan_usb_decode_error(mc, n, status_len); 587 if (err) 588 return err; 589 break; 590 591 case PCAN_USB_REC_ANALOG: 592 /* analog values (ignored) */ 593 rec_len = 2; 594 break; 595 596 case PCAN_USB_REC_BUSLOAD: 597 /* bus load (ignored) */ 598 rec_len = 1; 599 break; 600 601 case PCAN_USB_REC_TS: 602 /* only timestamp */ 603 if (pcan_usb_update_ts(mc)) 604 return -EINVAL; 605 break; 606 607 case PCAN_USB_REC_BUSEVT: 608 /* bus event notifications (get rxerr/txerr) */ 609 err = pcan_usb_handle_bus_evt(mc, n); 610 if (err) 611 return err; 612 break; 613 default: 614 netdev_err(mc->netdev, "unexpected function %u\n", f); 615 break; 616 } 617 618 if ((mc->ptr + rec_len) > mc->end) 619 return -EINVAL; 620 621 mc->ptr += rec_len; 622 623 return 0; 624 } 625 626 /* 627 * decode data usb message 628 */ 629 static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len) 630 { 631 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC; 632 struct sk_buff *skb; 633 struct can_frame *cf; 634 struct skb_shared_hwtstamps *hwts; 635 u32 can_id_flags; 636 637 skb = alloc_can_skb(mc->netdev, &cf); 638 if (!skb) 639 return -ENOMEM; 640 641 if (status_len & PCAN_USB_STATUSLEN_EXT_ID) { 642 if ((mc->ptr + 4) > mc->end) 643 goto decode_failed; 644 645 can_id_flags = get_unaligned_le32(mc->ptr); 646 cf->can_id = can_id_flags >> 3 | CAN_EFF_FLAG; 647 mc->ptr += 4; 648 } else { 649 if ((mc->ptr + 2) > mc->end) 650 goto decode_failed; 651 652 can_id_flags = get_unaligned_le16(mc->ptr); 653 cf->can_id = can_id_flags >> 5; 654 mc->ptr += 2; 655 } 656 657 can_frame_set_cc_len(cf, rec_len, mc->pdev->dev.can.ctrlmode); 658 659 /* Only first packet timestamp is a word */ 660 if (pcan_usb_decode_ts(mc, !mc->rec_ts_idx)) 661 goto decode_failed; 662 663 /* Next packet in the buffer will have a timestamp on a single byte */ 664 mc->rec_ts_idx++; 665 666 /* read data */ 667 memset(cf->data, 0x0, sizeof(cf->data)); 668 if (status_len & PCAN_USB_STATUSLEN_RTR) { 669 cf->can_id |= CAN_RTR_FLAG; 670 } else { 671 if ((mc->ptr + rec_len) > mc->end) 672 goto decode_failed; 673 674 memcpy(cf->data, mc->ptr, cf->len); 675 mc->ptr += rec_len; 676 677 /* Ignore next byte (client private id) if SRR bit is set */ 678 if (can_id_flags & PCAN_USB_TX_SRR) 679 mc->ptr++; 680 681 /* update statistics */ 682 mc->netdev->stats.rx_bytes += cf->len; 683 } 684 mc->netdev->stats.rx_packets++; 685 686 /* convert timestamp into kernel time */ 687 hwts = skb_hwtstamps(skb); 688 peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16, &hwts->hwtstamp); 689 690 /* push the skb */ 691 netif_rx(skb); 692 693 return 0; 694 695 decode_failed: 696 dev_kfree_skb(skb); 697 return -EINVAL; 698 } 699 700 /* 701 * process incoming message 702 */ 703 static int pcan_usb_decode_msg(struct peak_usb_device *dev, u8 *ibuf, u32 lbuf) 704 { 705 struct pcan_usb_msg_context mc = { 706 .rec_cnt = ibuf[1], 707 .ptr = ibuf + PCAN_USB_MSG_HEADER_LEN, 708 .end = ibuf + lbuf, 709 .netdev = dev->netdev, 710 .pdev = container_of(dev, struct pcan_usb, dev), 711 }; 712 int err; 713 714 for (err = 0; mc.rec_idx < mc.rec_cnt && !err; mc.rec_idx++) { 715 u8 sl = *mc.ptr++; 716 717 /* handle status and error frames here */ 718 if (sl & PCAN_USB_STATUSLEN_INTERNAL) { 719 err = pcan_usb_decode_status(&mc, sl); 720 /* handle normal can frames here */ 721 } else { 722 err = pcan_usb_decode_data(&mc, sl); 723 } 724 } 725 726 return err; 727 } 728 729 /* 730 * process any incoming buffer 731 */ 732 static int pcan_usb_decode_buf(struct peak_usb_device *dev, struct urb *urb) 733 { 734 int err = 0; 735 736 if (urb->actual_length > PCAN_USB_MSG_HEADER_LEN) { 737 err = pcan_usb_decode_msg(dev, urb->transfer_buffer, 738 urb->actual_length); 739 740 } else if (urb->actual_length > 0) { 741 netdev_err(dev->netdev, "usb message length error (%u)\n", 742 urb->actual_length); 743 err = -EINVAL; 744 } 745 746 return err; 747 } 748 749 /* 750 * process outgoing packet 751 */ 752 static int pcan_usb_encode_msg(struct peak_usb_device *dev, struct sk_buff *skb, 753 u8 *obuf, size_t *size) 754 { 755 struct net_device *netdev = dev->netdev; 756 struct net_device_stats *stats = &netdev->stats; 757 struct can_frame *cf = (struct can_frame *)skb->data; 758 u32 can_id_flags = cf->can_id & CAN_ERR_MASK; 759 u8 *pc; 760 761 obuf[0] = PCAN_USB_MSG_TX_CAN; 762 obuf[1] = 1; /* only one CAN frame is stored in the packet */ 763 764 pc = obuf + PCAN_USB_MSG_HEADER_LEN; 765 766 /* status/len byte */ 767 *pc = can_get_cc_dlc(cf, dev->can.ctrlmode); 768 769 if (cf->can_id & CAN_RTR_FLAG) 770 *pc |= PCAN_USB_STATUSLEN_RTR; 771 772 /* can id */ 773 if (cf->can_id & CAN_EFF_FLAG) { 774 *pc |= PCAN_USB_STATUSLEN_EXT_ID; 775 pc++; 776 777 can_id_flags <<= 3; 778 779 if (dev->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) 780 can_id_flags |= PCAN_USB_TX_SRR; 781 782 if (dev->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT) 783 can_id_flags |= PCAN_USB_TX_AT; 784 785 put_unaligned_le32(can_id_flags, pc); 786 pc += 4; 787 } else { 788 pc++; 789 790 can_id_flags <<= 5; 791 792 if (dev->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) 793 can_id_flags |= PCAN_USB_TX_SRR; 794 795 if (dev->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT) 796 can_id_flags |= PCAN_USB_TX_AT; 797 798 put_unaligned_le16(can_id_flags, pc); 799 pc += 2; 800 } 801 802 /* can data */ 803 if (!(cf->can_id & CAN_RTR_FLAG)) { 804 memcpy(pc, cf->data, cf->len); 805 pc += cf->len; 806 } 807 808 /* SRR bit needs a writer id (useless here) */ 809 if (can_id_flags & PCAN_USB_TX_SRR) 810 *pc++ = 0x80; 811 812 obuf[(*size)-1] = (u8)(stats->tx_packets & 0xff); 813 814 return 0; 815 } 816 817 /* socket callback used to copy berr counters values received through USB */ 818 static int pcan_usb_get_berr_counter(const struct net_device *netdev, 819 struct can_berr_counter *bec) 820 { 821 struct peak_usb_device *dev = netdev_priv(netdev); 822 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev); 823 824 *bec = pdev->bec; 825 826 /* must return 0 */ 827 return 0; 828 } 829 830 /* 831 * start interface 832 */ 833 static int pcan_usb_start(struct peak_usb_device *dev) 834 { 835 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev); 836 int err; 837 838 /* number of bits used in timestamps read from adapter struct */ 839 peak_usb_init_time_ref(&pdev->time_ref, &pcan_usb); 840 841 pdev->bec.rxerr = 0; 842 pdev->bec.txerr = 0; 843 844 /* always ask the device for BERR reporting, to be able to switch from 845 * WARNING to PASSIVE state 846 */ 847 err = pcan_usb_set_err_frame(dev, PCAN_USB_BERR_MASK); 848 if (err) 849 netdev_warn(dev->netdev, 850 "Asking for BERR reporting error %u\n", 851 err); 852 853 /* if revision greater than 3, can put silent mode on/off */ 854 if (dev->device_rev > 3) { 855 err = pcan_usb_set_silent(dev, 856 dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY); 857 if (err) 858 return err; 859 } 860 861 return pcan_usb_set_ext_vcc(dev, 0); 862 } 863 864 static int pcan_usb_init(struct peak_usb_device *dev) 865 { 866 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev); 867 u32 serial_number; 868 int err; 869 870 /* initialize a timer needed to wait for hardware restart */ 871 timer_setup(&pdev->restart_timer, pcan_usb_restart, 0); 872 873 /* 874 * explicit use of dev_xxx() instead of netdev_xxx() here: 875 * information displayed are related to the device itself, not 876 * to the canx netdevice. 877 */ 878 err = pcan_usb_get_serial(dev, &serial_number); 879 if (err) { 880 dev_err(dev->netdev->dev.parent, 881 "unable to read %s serial number (err %d)\n", 882 pcan_usb.name, err); 883 return err; 884 } 885 886 dev_info(dev->netdev->dev.parent, 887 "PEAK-System %s adapter hwrev %u serial %08X (%u channel)\n", 888 pcan_usb.name, dev->device_rev, serial_number, 889 pcan_usb.ctrl_count); 890 891 /* Since rev 4.1, PCAN-USB is able to make single-shot as well as 892 * looped back frames. 893 */ 894 if (dev->device_rev >= 41) { 895 struct can_priv *priv = netdev_priv(dev->netdev); 896 897 priv->ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT | 898 CAN_CTRLMODE_LOOPBACK; 899 } else { 900 dev_info(dev->netdev->dev.parent, 901 "Firmware update available. Please contact support@peak-system.com\n"); 902 } 903 904 return 0; 905 } 906 907 /* 908 * probe function for new PCAN-USB usb interface 909 */ 910 static int pcan_usb_probe(struct usb_interface *intf) 911 { 912 struct usb_host_interface *if_desc; 913 int i; 914 915 if_desc = intf->altsetting; 916 917 /* check interface endpoint addresses */ 918 for (i = 0; i < if_desc->desc.bNumEndpoints; i++) { 919 struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc; 920 921 switch (ep->bEndpointAddress) { 922 case PCAN_USB_EP_CMDOUT: 923 case PCAN_USB_EP_CMDIN: 924 case PCAN_USB_EP_MSGOUT: 925 case PCAN_USB_EP_MSGIN: 926 break; 927 default: 928 return -ENODEV; 929 } 930 } 931 932 return 0; 933 } 934 935 static int pcan_usb_set_phys_id(struct net_device *netdev, 936 enum ethtool_phys_id_state state) 937 { 938 struct peak_usb_device *dev = netdev_priv(netdev); 939 int err = 0; 940 941 switch (state) { 942 case ETHTOOL_ID_ACTIVE: 943 /* call ON/OFF twice a second */ 944 return 2; 945 946 case ETHTOOL_ID_OFF: 947 err = pcan_usb_set_led(dev, 0); 948 break; 949 950 case ETHTOOL_ID_ON: 951 fallthrough; 952 953 case ETHTOOL_ID_INACTIVE: 954 /* restore LED default */ 955 err = pcan_usb_set_led(dev, 1); 956 break; 957 958 default: 959 break; 960 } 961 962 return err; 963 } 964 965 static const struct ethtool_ops pcan_usb_ethtool_ops = { 966 .set_phys_id = pcan_usb_set_phys_id, 967 }; 968 969 /* 970 * describe the PCAN-USB adapter 971 */ 972 static const struct can_bittiming_const pcan_usb_const = { 973 .name = "pcan_usb", 974 .tseg1_min = 1, 975 .tseg1_max = 16, 976 .tseg2_min = 1, 977 .tseg2_max = 8, 978 .sjw_max = 4, 979 .brp_min = 1, 980 .brp_max = 64, 981 .brp_inc = 1, 982 }; 983 984 const struct peak_usb_adapter pcan_usb = { 985 .name = "PCAN-USB", 986 .device_id = PCAN_USB_PRODUCT_ID, 987 .ctrl_count = 1, 988 .ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_LISTENONLY | 989 CAN_CTRLMODE_CC_LEN8_DLC, 990 .clock = { 991 .freq = PCAN_USB_CRYSTAL_HZ / 2, 992 }, 993 .bittiming_const = &pcan_usb_const, 994 995 /* size of device private data */ 996 .sizeof_dev_private = sizeof(struct pcan_usb), 997 998 .ethtool_ops = &pcan_usb_ethtool_ops, 999 1000 /* timestamps usage */ 1001 .ts_used_bits = 16, 1002 .us_per_ts_scale = PCAN_USB_TS_US_PER_TICK, /* us=(ts*scale) */ 1003 .us_per_ts_shift = PCAN_USB_TS_DIV_SHIFTER, /* >> shift */ 1004 1005 /* give here messages in/out endpoints */ 1006 .ep_msg_in = PCAN_USB_EP_MSGIN, 1007 .ep_msg_out = {PCAN_USB_EP_MSGOUT}, 1008 1009 /* size of rx/tx usb buffers */ 1010 .rx_buffer_size = PCAN_USB_RX_BUFFER_SIZE, 1011 .tx_buffer_size = PCAN_USB_TX_BUFFER_SIZE, 1012 1013 /* device callbacks */ 1014 .intf_probe = pcan_usb_probe, 1015 .dev_init = pcan_usb_init, 1016 .dev_set_bus = pcan_usb_write_mode, 1017 .dev_set_bittiming = pcan_usb_set_bittiming, 1018 .dev_get_device_id = pcan_usb_get_device_id, 1019 .dev_decode_buf = pcan_usb_decode_buf, 1020 .dev_encode_msg = pcan_usb_encode_msg, 1021 .dev_start = pcan_usb_start, 1022 .dev_restart_async = pcan_usb_restart_async, 1023 .do_get_berr_counter = pcan_usb_get_berr_counter, 1024 }; 1025