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 mc->netdev->stats.rx_packets++; 525 mc->netdev->stats.rx_bytes += cf->len; 526 netif_rx(skb); 527 528 return 0; 529 } 530 531 /* decode bus event usb packet: first byte contains rxerr while 2nd one contains 532 * txerr. 533 */ 534 static int pcan_usb_handle_bus_evt(struct pcan_usb_msg_context *mc, u8 ir) 535 { 536 struct pcan_usb *pdev = mc->pdev; 537 538 /* acccording to the content of the packet */ 539 switch (ir) { 540 case PCAN_USB_ERR_CNT_DEC: 541 case PCAN_USB_ERR_CNT_INC: 542 543 /* save rx/tx error counters from in the device context */ 544 pdev->bec.rxerr = mc->ptr[1]; 545 pdev->bec.txerr = mc->ptr[2]; 546 break; 547 548 default: 549 /* reserved */ 550 break; 551 } 552 553 return 0; 554 } 555 556 /* 557 * decode non-data usb message 558 */ 559 static int pcan_usb_decode_status(struct pcan_usb_msg_context *mc, 560 u8 status_len) 561 { 562 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC; 563 u8 f, n; 564 int err; 565 566 /* check whether function and number can be read */ 567 if ((mc->ptr + 2) > mc->end) 568 return -EINVAL; 569 570 f = mc->ptr[PCAN_USB_CMD_FUNC]; 571 n = mc->ptr[PCAN_USB_CMD_NUM]; 572 mc->ptr += PCAN_USB_CMD_ARGS; 573 574 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) { 575 int err = pcan_usb_decode_ts(mc, !mc->rec_ts_idx); 576 577 if (err) 578 return err; 579 580 /* Next packet in the buffer will have a timestamp on a single 581 * byte 582 */ 583 mc->rec_ts_idx++; 584 } 585 586 switch (f) { 587 case PCAN_USB_REC_ERROR: 588 err = pcan_usb_decode_error(mc, n, status_len); 589 if (err) 590 return err; 591 break; 592 593 case PCAN_USB_REC_ANALOG: 594 /* analog values (ignored) */ 595 rec_len = 2; 596 break; 597 598 case PCAN_USB_REC_BUSLOAD: 599 /* bus load (ignored) */ 600 rec_len = 1; 601 break; 602 603 case PCAN_USB_REC_TS: 604 /* only timestamp */ 605 if (pcan_usb_update_ts(mc)) 606 return -EINVAL; 607 break; 608 609 case PCAN_USB_REC_BUSEVT: 610 /* bus event notifications (get rxerr/txerr) */ 611 err = pcan_usb_handle_bus_evt(mc, n); 612 if (err) 613 return err; 614 break; 615 default: 616 netdev_err(mc->netdev, "unexpected function %u\n", f); 617 break; 618 } 619 620 if ((mc->ptr + rec_len) > mc->end) 621 return -EINVAL; 622 623 mc->ptr += rec_len; 624 625 return 0; 626 } 627 628 /* 629 * decode data usb message 630 */ 631 static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len) 632 { 633 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC; 634 struct sk_buff *skb; 635 struct can_frame *cf; 636 struct skb_shared_hwtstamps *hwts; 637 u32 can_id_flags; 638 639 skb = alloc_can_skb(mc->netdev, &cf); 640 if (!skb) 641 return -ENOMEM; 642 643 if (status_len & PCAN_USB_STATUSLEN_EXT_ID) { 644 if ((mc->ptr + 4) > mc->end) 645 goto decode_failed; 646 647 can_id_flags = get_unaligned_le32(mc->ptr); 648 cf->can_id = can_id_flags >> 3 | CAN_EFF_FLAG; 649 mc->ptr += 4; 650 } else { 651 if ((mc->ptr + 2) > mc->end) 652 goto decode_failed; 653 654 can_id_flags = get_unaligned_le16(mc->ptr); 655 cf->can_id = can_id_flags >> 5; 656 mc->ptr += 2; 657 } 658 659 can_frame_set_cc_len(cf, rec_len, mc->pdev->dev.can.ctrlmode); 660 661 /* Only first packet timestamp is a word */ 662 if (pcan_usb_decode_ts(mc, !mc->rec_ts_idx)) 663 goto decode_failed; 664 665 /* Next packet in the buffer will have a timestamp on a single byte */ 666 mc->rec_ts_idx++; 667 668 /* read data */ 669 memset(cf->data, 0x0, sizeof(cf->data)); 670 if (status_len & PCAN_USB_STATUSLEN_RTR) { 671 cf->can_id |= CAN_RTR_FLAG; 672 } else { 673 if ((mc->ptr + rec_len) > mc->end) 674 goto decode_failed; 675 676 memcpy(cf->data, mc->ptr, cf->len); 677 mc->ptr += rec_len; 678 679 /* Ignore next byte (client private id) if SRR bit is set */ 680 if (can_id_flags & PCAN_USB_TX_SRR) 681 mc->ptr++; 682 } 683 684 /* convert timestamp into kernel time */ 685 hwts = skb_hwtstamps(skb); 686 peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16, &hwts->hwtstamp); 687 688 /* update statistics */ 689 mc->netdev->stats.rx_packets++; 690 mc->netdev->stats.rx_bytes += cf->len; 691 /* push the skb */ 692 netif_rx(skb); 693 694 return 0; 695 696 decode_failed: 697 dev_kfree_skb(skb); 698 return -EINVAL; 699 } 700 701 /* 702 * process incoming message 703 */ 704 static int pcan_usb_decode_msg(struct peak_usb_device *dev, u8 *ibuf, u32 lbuf) 705 { 706 struct pcan_usb_msg_context mc = { 707 .rec_cnt = ibuf[1], 708 .ptr = ibuf + PCAN_USB_MSG_HEADER_LEN, 709 .end = ibuf + lbuf, 710 .netdev = dev->netdev, 711 .pdev = container_of(dev, struct pcan_usb, dev), 712 }; 713 int err; 714 715 for (err = 0; mc.rec_idx < mc.rec_cnt && !err; mc.rec_idx++) { 716 u8 sl = *mc.ptr++; 717 718 /* handle status and error frames here */ 719 if (sl & PCAN_USB_STATUSLEN_INTERNAL) { 720 err = pcan_usb_decode_status(&mc, sl); 721 /* handle normal can frames here */ 722 } else { 723 err = pcan_usb_decode_data(&mc, sl); 724 } 725 } 726 727 return err; 728 } 729 730 /* 731 * process any incoming buffer 732 */ 733 static int pcan_usb_decode_buf(struct peak_usb_device *dev, struct urb *urb) 734 { 735 int err = 0; 736 737 if (urb->actual_length > PCAN_USB_MSG_HEADER_LEN) { 738 err = pcan_usb_decode_msg(dev, urb->transfer_buffer, 739 urb->actual_length); 740 741 } else if (urb->actual_length > 0) { 742 netdev_err(dev->netdev, "usb message length error (%u)\n", 743 urb->actual_length); 744 err = -EINVAL; 745 } 746 747 return err; 748 } 749 750 /* 751 * process outgoing packet 752 */ 753 static int pcan_usb_encode_msg(struct peak_usb_device *dev, struct sk_buff *skb, 754 u8 *obuf, size_t *size) 755 { 756 struct net_device *netdev = dev->netdev; 757 struct net_device_stats *stats = &netdev->stats; 758 struct can_frame *cf = (struct can_frame *)skb->data; 759 u32 can_id_flags = cf->can_id & CAN_ERR_MASK; 760 u8 *pc; 761 762 obuf[0] = PCAN_USB_MSG_TX_CAN; 763 obuf[1] = 1; /* only one CAN frame is stored in the packet */ 764 765 pc = obuf + PCAN_USB_MSG_HEADER_LEN; 766 767 /* status/len byte */ 768 *pc = can_get_cc_dlc(cf, dev->can.ctrlmode); 769 770 if (cf->can_id & CAN_RTR_FLAG) 771 *pc |= PCAN_USB_STATUSLEN_RTR; 772 773 /* can id */ 774 if (cf->can_id & CAN_EFF_FLAG) { 775 *pc |= PCAN_USB_STATUSLEN_EXT_ID; 776 pc++; 777 778 can_id_flags <<= 3; 779 780 if (dev->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) 781 can_id_flags |= PCAN_USB_TX_SRR; 782 783 if (dev->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT) 784 can_id_flags |= PCAN_USB_TX_AT; 785 786 put_unaligned_le32(can_id_flags, pc); 787 pc += 4; 788 } else { 789 pc++; 790 791 can_id_flags <<= 5; 792 793 if (dev->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) 794 can_id_flags |= PCAN_USB_TX_SRR; 795 796 if (dev->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT) 797 can_id_flags |= PCAN_USB_TX_AT; 798 799 put_unaligned_le16(can_id_flags, pc); 800 pc += 2; 801 } 802 803 /* can data */ 804 if (!(cf->can_id & CAN_RTR_FLAG)) { 805 memcpy(pc, cf->data, cf->len); 806 pc += cf->len; 807 } 808 809 /* SRR bit needs a writer id (useless here) */ 810 if (can_id_flags & PCAN_USB_TX_SRR) 811 *pc++ = 0x80; 812 813 obuf[(*size)-1] = (u8)(stats->tx_packets & 0xff); 814 815 return 0; 816 } 817 818 /* socket callback used to copy berr counters values received through USB */ 819 static int pcan_usb_get_berr_counter(const struct net_device *netdev, 820 struct can_berr_counter *bec) 821 { 822 struct peak_usb_device *dev = netdev_priv(netdev); 823 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev); 824 825 *bec = pdev->bec; 826 827 /* must return 0 */ 828 return 0; 829 } 830 831 /* 832 * start interface 833 */ 834 static int pcan_usb_start(struct peak_usb_device *dev) 835 { 836 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev); 837 int err; 838 839 /* number of bits used in timestamps read from adapter struct */ 840 peak_usb_init_time_ref(&pdev->time_ref, &pcan_usb); 841 842 pdev->bec.rxerr = 0; 843 pdev->bec.txerr = 0; 844 845 /* always ask the device for BERR reporting, to be able to switch from 846 * WARNING to PASSIVE state 847 */ 848 err = pcan_usb_set_err_frame(dev, PCAN_USB_BERR_MASK); 849 if (err) 850 netdev_warn(dev->netdev, 851 "Asking for BERR reporting error %u\n", 852 err); 853 854 /* if revision greater than 3, can put silent mode on/off */ 855 if (dev->device_rev > 3) { 856 err = pcan_usb_set_silent(dev, 857 dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY); 858 if (err) 859 return err; 860 } 861 862 return pcan_usb_set_ext_vcc(dev, 0); 863 } 864 865 static int pcan_usb_init(struct peak_usb_device *dev) 866 { 867 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev); 868 u32 serial_number; 869 int err; 870 871 /* initialize a timer needed to wait for hardware restart */ 872 timer_setup(&pdev->restart_timer, pcan_usb_restart, 0); 873 874 /* 875 * explicit use of dev_xxx() instead of netdev_xxx() here: 876 * information displayed are related to the device itself, not 877 * to the canx netdevice. 878 */ 879 err = pcan_usb_get_serial(dev, &serial_number); 880 if (err) { 881 dev_err(dev->netdev->dev.parent, 882 "unable to read %s serial number (err %d)\n", 883 pcan_usb.name, err); 884 return err; 885 } 886 887 dev_info(dev->netdev->dev.parent, 888 "PEAK-System %s adapter hwrev %u serial %08X (%u channel)\n", 889 pcan_usb.name, dev->device_rev, serial_number, 890 pcan_usb.ctrl_count); 891 892 /* Since rev 4.1, PCAN-USB is able to make single-shot as well as 893 * looped back frames. 894 */ 895 if (dev->device_rev >= 41) { 896 struct can_priv *priv = netdev_priv(dev->netdev); 897 898 priv->ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT | 899 CAN_CTRLMODE_LOOPBACK; 900 } else { 901 dev_info(dev->netdev->dev.parent, 902 "Firmware update available. Please contact support@peak-system.com\n"); 903 } 904 905 return 0; 906 } 907 908 /* 909 * probe function for new PCAN-USB usb interface 910 */ 911 static int pcan_usb_probe(struct usb_interface *intf) 912 { 913 struct usb_host_interface *if_desc; 914 int i; 915 916 if_desc = intf->altsetting; 917 918 /* check interface endpoint addresses */ 919 for (i = 0; i < if_desc->desc.bNumEndpoints; i++) { 920 struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc; 921 922 switch (ep->bEndpointAddress) { 923 case PCAN_USB_EP_CMDOUT: 924 case PCAN_USB_EP_CMDIN: 925 case PCAN_USB_EP_MSGOUT: 926 case PCAN_USB_EP_MSGIN: 927 break; 928 default: 929 return -ENODEV; 930 } 931 } 932 933 return 0; 934 } 935 936 static int pcan_usb_set_phys_id(struct net_device *netdev, 937 enum ethtool_phys_id_state state) 938 { 939 struct peak_usb_device *dev = netdev_priv(netdev); 940 int err = 0; 941 942 switch (state) { 943 case ETHTOOL_ID_ACTIVE: 944 /* call ON/OFF twice a second */ 945 return 2; 946 947 case ETHTOOL_ID_OFF: 948 err = pcan_usb_set_led(dev, 0); 949 break; 950 951 case ETHTOOL_ID_ON: 952 fallthrough; 953 954 case ETHTOOL_ID_INACTIVE: 955 /* restore LED default */ 956 err = pcan_usb_set_led(dev, 1); 957 break; 958 959 default: 960 break; 961 } 962 963 return err; 964 } 965 966 static const struct ethtool_ops pcan_usb_ethtool_ops = { 967 .set_phys_id = pcan_usb_set_phys_id, 968 }; 969 970 /* 971 * describe the PCAN-USB adapter 972 */ 973 static const struct can_bittiming_const pcan_usb_const = { 974 .name = "pcan_usb", 975 .tseg1_min = 1, 976 .tseg1_max = 16, 977 .tseg2_min = 1, 978 .tseg2_max = 8, 979 .sjw_max = 4, 980 .brp_min = 1, 981 .brp_max = 64, 982 .brp_inc = 1, 983 }; 984 985 const struct peak_usb_adapter pcan_usb = { 986 .name = "PCAN-USB", 987 .device_id = PCAN_USB_PRODUCT_ID, 988 .ctrl_count = 1, 989 .ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_LISTENONLY | 990 CAN_CTRLMODE_CC_LEN8_DLC, 991 .clock = { 992 .freq = PCAN_USB_CRYSTAL_HZ / 2, 993 }, 994 .bittiming_const = &pcan_usb_const, 995 996 /* size of device private data */ 997 .sizeof_dev_private = sizeof(struct pcan_usb), 998 999 .ethtool_ops = &pcan_usb_ethtool_ops, 1000 1001 /* timestamps usage */ 1002 .ts_used_bits = 16, 1003 .us_per_ts_scale = PCAN_USB_TS_US_PER_TICK, /* us=(ts*scale) */ 1004 .us_per_ts_shift = PCAN_USB_TS_DIV_SHIFTER, /* >> shift */ 1005 1006 /* give here messages in/out endpoints */ 1007 .ep_msg_in = PCAN_USB_EP_MSGIN, 1008 .ep_msg_out = {PCAN_USB_EP_MSGOUT}, 1009 1010 /* size of rx/tx usb buffers */ 1011 .rx_buffer_size = PCAN_USB_RX_BUFFER_SIZE, 1012 .tx_buffer_size = PCAN_USB_TX_BUFFER_SIZE, 1013 1014 /* device callbacks */ 1015 .intf_probe = pcan_usb_probe, 1016 .dev_init = pcan_usb_init, 1017 .dev_set_bus = pcan_usb_write_mode, 1018 .dev_set_bittiming = pcan_usb_set_bittiming, 1019 .dev_get_device_id = pcan_usb_get_device_id, 1020 .dev_decode_buf = pcan_usb_decode_buf, 1021 .dev_encode_msg = pcan_usb_encode_msg, 1022 .dev_start = pcan_usb_start, 1023 .dev_restart_async = pcan_usb_restart_async, 1024 .do_get_berr_counter = pcan_usb_get_berr_counter, 1025 }; 1026