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