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