1 // SPDX-License-Identifier: GPL-2.0 2 /* Parts of this driver are based on the following: 3 * - Kvaser linux leaf driver (version 4.78) 4 * - CAN driver for esd CAN-USB/2 5 * - Kvaser linux usbcanII driver (version 5.3) 6 * 7 * Copyright (C) 2002-2018 KVASER AB, Sweden. All rights reserved. 8 * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh 9 * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be> 10 * Copyright (C) 2015 Valeo S.A. 11 */ 12 13 #include <linux/completion.h> 14 #include <linux/device.h> 15 #include <linux/gfp.h> 16 #include <linux/jiffies.h> 17 #include <linux/kernel.h> 18 #include <linux/netdevice.h> 19 #include <linux/spinlock.h> 20 #include <linux/string.h> 21 #include <linux/types.h> 22 #include <linux/usb.h> 23 24 #include <linux/can.h> 25 #include <linux/can/dev.h> 26 #include <linux/can/error.h> 27 #include <linux/can/netlink.h> 28 29 #include "kvaser_usb.h" 30 31 /* Forward declaration */ 32 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg; 33 34 #define CAN_USB_CLOCK 8000000 35 #define MAX_USBCAN_NET_DEVICES 2 36 37 /* Command header size */ 38 #define CMD_HEADER_LEN 2 39 40 /* Kvaser CAN message flags */ 41 #define MSG_FLAG_ERROR_FRAME BIT(0) 42 #define MSG_FLAG_OVERRUN BIT(1) 43 #define MSG_FLAG_NERR BIT(2) 44 #define MSG_FLAG_WAKEUP BIT(3) 45 #define MSG_FLAG_REMOTE_FRAME BIT(4) 46 #define MSG_FLAG_RESERVED BIT(5) 47 #define MSG_FLAG_TX_ACK BIT(6) 48 #define MSG_FLAG_TX_REQUEST BIT(7) 49 50 /* CAN states (M16C CxSTRH register) */ 51 #define M16C_STATE_BUS_RESET BIT(0) 52 #define M16C_STATE_BUS_ERROR BIT(4) 53 #define M16C_STATE_BUS_PASSIVE BIT(5) 54 #define M16C_STATE_BUS_OFF BIT(6) 55 56 /* Leaf/usbcan command ids */ 57 #define CMD_RX_STD_MESSAGE 12 58 #define CMD_TX_STD_MESSAGE 13 59 #define CMD_RX_EXT_MESSAGE 14 60 #define CMD_TX_EXT_MESSAGE 15 61 #define CMD_SET_BUS_PARAMS 16 62 #define CMD_CHIP_STATE_EVENT 20 63 #define CMD_SET_CTRL_MODE 21 64 #define CMD_RESET_CHIP 24 65 #define CMD_START_CHIP 26 66 #define CMD_START_CHIP_REPLY 27 67 #define CMD_STOP_CHIP 28 68 #define CMD_STOP_CHIP_REPLY 29 69 70 #define CMD_USBCAN_CLOCK_OVERFLOW_EVENT 33 71 72 #define CMD_GET_CARD_INFO 34 73 #define CMD_GET_CARD_INFO_REPLY 35 74 #define CMD_GET_SOFTWARE_INFO 38 75 #define CMD_GET_SOFTWARE_INFO_REPLY 39 76 #define CMD_FLUSH_QUEUE 48 77 #define CMD_TX_ACKNOWLEDGE 50 78 #define CMD_CAN_ERROR_EVENT 51 79 #define CMD_FLUSH_QUEUE_REPLY 68 80 81 #define CMD_LEAF_LOG_MESSAGE 106 82 83 /* error factors */ 84 #define M16C_EF_ACKE BIT(0) 85 #define M16C_EF_CRCE BIT(1) 86 #define M16C_EF_FORME BIT(2) 87 #define M16C_EF_STFE BIT(3) 88 #define M16C_EF_BITE0 BIT(4) 89 #define M16C_EF_BITE1 BIT(5) 90 #define M16C_EF_RCVE BIT(6) 91 #define M16C_EF_TRE BIT(7) 92 93 /* Only Leaf-based devices can report M16C error factors, 94 * thus define our own error status flags for USBCANII 95 */ 96 #define USBCAN_ERROR_STATE_NONE 0 97 #define USBCAN_ERROR_STATE_TX_ERROR BIT(0) 98 #define USBCAN_ERROR_STATE_RX_ERROR BIT(1) 99 #define USBCAN_ERROR_STATE_BUSERROR BIT(2) 100 101 /* bittiming parameters */ 102 #define KVASER_USB_TSEG1_MIN 1 103 #define KVASER_USB_TSEG1_MAX 16 104 #define KVASER_USB_TSEG2_MIN 1 105 #define KVASER_USB_TSEG2_MAX 8 106 #define KVASER_USB_SJW_MAX 4 107 #define KVASER_USB_BRP_MIN 1 108 #define KVASER_USB_BRP_MAX 64 109 #define KVASER_USB_BRP_INC 1 110 111 /* ctrl modes */ 112 #define KVASER_CTRL_MODE_NORMAL 1 113 #define KVASER_CTRL_MODE_SILENT 2 114 #define KVASER_CTRL_MODE_SELFRECEPTION 3 115 #define KVASER_CTRL_MODE_OFF 4 116 117 /* Extended CAN identifier flag */ 118 #define KVASER_EXTENDED_FRAME BIT(31) 119 120 struct kvaser_cmd_simple { 121 u8 tid; 122 u8 channel; 123 } __packed; 124 125 struct kvaser_cmd_cardinfo { 126 u8 tid; 127 u8 nchannels; 128 __le32 serial_number; 129 __le32 padding0; 130 __le32 clock_resolution; 131 __le32 mfgdate; 132 u8 ean[8]; 133 u8 hw_revision; 134 union { 135 struct { 136 u8 usb_hs_mode; 137 } __packed leaf1; 138 struct { 139 u8 padding; 140 } __packed usbcan1; 141 } __packed; 142 __le16 padding1; 143 } __packed; 144 145 struct leaf_cmd_softinfo { 146 u8 tid; 147 u8 padding0; 148 __le32 sw_options; 149 __le32 fw_version; 150 __le16 max_outstanding_tx; 151 __le16 padding1[9]; 152 } __packed; 153 154 struct usbcan_cmd_softinfo { 155 u8 tid; 156 u8 fw_name[5]; 157 __le16 max_outstanding_tx; 158 u8 padding[6]; 159 __le32 fw_version; 160 __le16 checksum; 161 __le16 sw_options; 162 } __packed; 163 164 struct kvaser_cmd_busparams { 165 u8 tid; 166 u8 channel; 167 __le32 bitrate; 168 u8 tseg1; 169 u8 tseg2; 170 u8 sjw; 171 u8 no_samp; 172 } __packed; 173 174 struct kvaser_cmd_tx_can { 175 u8 channel; 176 u8 tid; 177 u8 data[14]; 178 union { 179 struct { 180 u8 padding; 181 u8 flags; 182 } __packed leaf; 183 struct { 184 u8 flags; 185 u8 padding; 186 } __packed usbcan; 187 } __packed; 188 } __packed; 189 190 struct kvaser_cmd_rx_can_header { 191 u8 channel; 192 u8 flag; 193 } __packed; 194 195 struct leaf_cmd_rx_can { 196 u8 channel; 197 u8 flag; 198 199 __le16 time[3]; 200 u8 data[14]; 201 } __packed; 202 203 struct usbcan_cmd_rx_can { 204 u8 channel; 205 u8 flag; 206 207 u8 data[14]; 208 __le16 time; 209 } __packed; 210 211 struct leaf_cmd_chip_state_event { 212 u8 tid; 213 u8 channel; 214 215 __le16 time[3]; 216 u8 tx_errors_count; 217 u8 rx_errors_count; 218 219 u8 status; 220 u8 padding[3]; 221 } __packed; 222 223 struct usbcan_cmd_chip_state_event { 224 u8 tid; 225 u8 channel; 226 227 u8 tx_errors_count; 228 u8 rx_errors_count; 229 __le16 time; 230 231 u8 status; 232 u8 padding[3]; 233 } __packed; 234 235 struct kvaser_cmd_tx_acknowledge_header { 236 u8 channel; 237 u8 tid; 238 } __packed; 239 240 struct leaf_cmd_error_event { 241 u8 tid; 242 u8 flags; 243 __le16 time[3]; 244 u8 channel; 245 u8 padding; 246 u8 tx_errors_count; 247 u8 rx_errors_count; 248 u8 status; 249 u8 error_factor; 250 } __packed; 251 252 struct usbcan_cmd_error_event { 253 u8 tid; 254 u8 padding; 255 u8 tx_errors_count_ch0; 256 u8 rx_errors_count_ch0; 257 u8 tx_errors_count_ch1; 258 u8 rx_errors_count_ch1; 259 u8 status_ch0; 260 u8 status_ch1; 261 __le16 time; 262 } __packed; 263 264 struct kvaser_cmd_ctrl_mode { 265 u8 tid; 266 u8 channel; 267 u8 ctrl_mode; 268 u8 padding[3]; 269 } __packed; 270 271 struct kvaser_cmd_flush_queue { 272 u8 tid; 273 u8 channel; 274 u8 flags; 275 u8 padding[3]; 276 } __packed; 277 278 struct leaf_cmd_log_message { 279 u8 channel; 280 u8 flags; 281 __le16 time[3]; 282 u8 dlc; 283 u8 time_offset; 284 __le32 id; 285 u8 data[8]; 286 } __packed; 287 288 struct kvaser_cmd { 289 u8 len; 290 u8 id; 291 union { 292 struct kvaser_cmd_simple simple; 293 struct kvaser_cmd_cardinfo cardinfo; 294 struct kvaser_cmd_busparams busparams; 295 296 struct kvaser_cmd_rx_can_header rx_can_header; 297 struct kvaser_cmd_tx_acknowledge_header tx_acknowledge_header; 298 299 union { 300 struct leaf_cmd_softinfo softinfo; 301 struct leaf_cmd_rx_can rx_can; 302 struct leaf_cmd_chip_state_event chip_state_event; 303 struct leaf_cmd_error_event error_event; 304 struct leaf_cmd_log_message log_message; 305 } __packed leaf; 306 307 union { 308 struct usbcan_cmd_softinfo softinfo; 309 struct usbcan_cmd_rx_can rx_can; 310 struct usbcan_cmd_chip_state_event chip_state_event; 311 struct usbcan_cmd_error_event error_event; 312 } __packed usbcan; 313 314 struct kvaser_cmd_tx_can tx_can; 315 struct kvaser_cmd_ctrl_mode ctrl_mode; 316 struct kvaser_cmd_flush_queue flush_queue; 317 } u; 318 } __packed; 319 320 /* Summary of a kvaser error event, for a unified Leaf/Usbcan error 321 * handling. Some discrepancies between the two families exist: 322 * 323 * - USBCAN firmware does not report M16C "error factors" 324 * - USBCAN controllers has difficulties reporting if the raised error 325 * event is for ch0 or ch1. They leave such arbitration to the OS 326 * driver by letting it compare error counters with previous values 327 * and decide the error event's channel. Thus for USBCAN, the channel 328 * field is only advisory. 329 */ 330 struct kvaser_usb_err_summary { 331 u8 channel, status, txerr, rxerr; 332 union { 333 struct { 334 u8 error_factor; 335 } leaf; 336 struct { 337 u8 other_ch_status; 338 u8 error_state; 339 } usbcan; 340 }; 341 }; 342 343 static void * 344 kvaser_usb_leaf_frame_to_cmd(const struct kvaser_usb_net_priv *priv, 345 const struct sk_buff *skb, int *frame_len, 346 int *cmd_len, u16 transid) 347 { 348 struct kvaser_usb *dev = priv->dev; 349 struct kvaser_cmd *cmd; 350 u8 *cmd_tx_can_flags = NULL; /* GCC */ 351 struct can_frame *cf = (struct can_frame *)skb->data; 352 353 *frame_len = cf->can_dlc; 354 355 cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC); 356 if (cmd) { 357 cmd->u.tx_can.tid = transid & 0xff; 358 cmd->len = *cmd_len = CMD_HEADER_LEN + 359 sizeof(struct kvaser_cmd_tx_can); 360 cmd->u.tx_can.channel = priv->channel; 361 362 switch (dev->card_data.leaf.family) { 363 case KVASER_LEAF: 364 cmd_tx_can_flags = &cmd->u.tx_can.leaf.flags; 365 break; 366 case KVASER_USBCAN: 367 cmd_tx_can_flags = &cmd->u.tx_can.usbcan.flags; 368 break; 369 } 370 371 *cmd_tx_can_flags = 0; 372 373 if (cf->can_id & CAN_EFF_FLAG) { 374 cmd->id = CMD_TX_EXT_MESSAGE; 375 cmd->u.tx_can.data[0] = (cf->can_id >> 24) & 0x1f; 376 cmd->u.tx_can.data[1] = (cf->can_id >> 18) & 0x3f; 377 cmd->u.tx_can.data[2] = (cf->can_id >> 14) & 0x0f; 378 cmd->u.tx_can.data[3] = (cf->can_id >> 6) & 0xff; 379 cmd->u.tx_can.data[4] = cf->can_id & 0x3f; 380 } else { 381 cmd->id = CMD_TX_STD_MESSAGE; 382 cmd->u.tx_can.data[0] = (cf->can_id >> 6) & 0x1f; 383 cmd->u.tx_can.data[1] = cf->can_id & 0x3f; 384 } 385 386 cmd->u.tx_can.data[5] = cf->can_dlc; 387 memcpy(&cmd->u.tx_can.data[6], cf->data, cf->can_dlc); 388 389 if (cf->can_id & CAN_RTR_FLAG) 390 *cmd_tx_can_flags |= MSG_FLAG_REMOTE_FRAME; 391 } 392 return cmd; 393 } 394 395 static int kvaser_usb_leaf_wait_cmd(const struct kvaser_usb *dev, u8 id, 396 struct kvaser_cmd *cmd) 397 { 398 struct kvaser_cmd *tmp; 399 void *buf; 400 int actual_len; 401 int err; 402 int pos; 403 unsigned long to = jiffies + msecs_to_jiffies(KVASER_USB_TIMEOUT); 404 405 buf = kzalloc(KVASER_USB_RX_BUFFER_SIZE, GFP_KERNEL); 406 if (!buf) 407 return -ENOMEM; 408 409 do { 410 err = kvaser_usb_recv_cmd(dev, buf, KVASER_USB_RX_BUFFER_SIZE, 411 &actual_len); 412 if (err < 0) 413 goto end; 414 415 pos = 0; 416 while (pos <= actual_len - CMD_HEADER_LEN) { 417 tmp = buf + pos; 418 419 /* Handle commands crossing the USB endpoint max packet 420 * size boundary. Check kvaser_usb_read_bulk_callback() 421 * for further details. 422 */ 423 if (tmp->len == 0) { 424 pos = round_up(pos, 425 le16_to_cpu 426 (dev->bulk_in->wMaxPacketSize)); 427 continue; 428 } 429 430 if (pos + tmp->len > actual_len) { 431 dev_err_ratelimited(&dev->intf->dev, 432 "Format error\n"); 433 break; 434 } 435 436 if (tmp->id == id) { 437 memcpy(cmd, tmp, tmp->len); 438 goto end; 439 } 440 441 pos += tmp->len; 442 } 443 } while (time_before(jiffies, to)); 444 445 err = -EINVAL; 446 447 end: 448 kfree(buf); 449 450 return err; 451 } 452 453 static int kvaser_usb_leaf_send_simple_cmd(const struct kvaser_usb *dev, 454 u8 cmd_id, int channel) 455 { 456 struct kvaser_cmd *cmd; 457 int rc; 458 459 cmd = kmalloc(sizeof(*cmd), GFP_KERNEL); 460 if (!cmd) 461 return -ENOMEM; 462 463 cmd->id = cmd_id; 464 cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple); 465 cmd->u.simple.channel = channel; 466 cmd->u.simple.tid = 0xff; 467 468 rc = kvaser_usb_send_cmd(dev, cmd, cmd->len); 469 470 kfree(cmd); 471 return rc; 472 } 473 474 static int kvaser_usb_leaf_get_software_info_inner(struct kvaser_usb *dev) 475 { 476 struct kvaser_cmd cmd; 477 int err; 478 479 err = kvaser_usb_leaf_send_simple_cmd(dev, CMD_GET_SOFTWARE_INFO, 0); 480 if (err) 481 return err; 482 483 err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_SOFTWARE_INFO_REPLY, &cmd); 484 if (err) 485 return err; 486 487 switch (dev->card_data.leaf.family) { 488 case KVASER_LEAF: 489 dev->fw_version = le32_to_cpu(cmd.u.leaf.softinfo.fw_version); 490 dev->max_tx_urbs = 491 le16_to_cpu(cmd.u.leaf.softinfo.max_outstanding_tx); 492 break; 493 case KVASER_USBCAN: 494 dev->fw_version = le32_to_cpu(cmd.u.usbcan.softinfo.fw_version); 495 dev->max_tx_urbs = 496 le16_to_cpu(cmd.u.usbcan.softinfo.max_outstanding_tx); 497 break; 498 } 499 500 return 0; 501 } 502 503 static int kvaser_usb_leaf_get_software_info(struct kvaser_usb *dev) 504 { 505 int err; 506 int retry = 3; 507 508 /* On some x86 laptops, plugging a Kvaser device again after 509 * an unplug makes the firmware always ignore the very first 510 * command. For such a case, provide some room for retries 511 * instead of completely exiting the driver. 512 */ 513 do { 514 err = kvaser_usb_leaf_get_software_info_inner(dev); 515 } while (--retry && err == -ETIMEDOUT); 516 517 return err; 518 } 519 520 static int kvaser_usb_leaf_get_card_info(struct kvaser_usb *dev) 521 { 522 struct kvaser_cmd cmd; 523 int err; 524 525 err = kvaser_usb_leaf_send_simple_cmd(dev, CMD_GET_CARD_INFO, 0); 526 if (err) 527 return err; 528 529 err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_CARD_INFO_REPLY, &cmd); 530 if (err) 531 return err; 532 533 dev->nchannels = cmd.u.cardinfo.nchannels; 534 if (dev->nchannels > KVASER_USB_MAX_NET_DEVICES || 535 (dev->card_data.leaf.family == KVASER_USBCAN && 536 dev->nchannels > MAX_USBCAN_NET_DEVICES)) 537 return -EINVAL; 538 539 return 0; 540 } 541 542 static void kvaser_usb_leaf_tx_acknowledge(const struct kvaser_usb *dev, 543 const struct kvaser_cmd *cmd) 544 { 545 struct net_device_stats *stats; 546 struct kvaser_usb_tx_urb_context *context; 547 struct kvaser_usb_net_priv *priv; 548 unsigned long flags; 549 u8 channel, tid; 550 551 channel = cmd->u.tx_acknowledge_header.channel; 552 tid = cmd->u.tx_acknowledge_header.tid; 553 554 if (channel >= dev->nchannels) { 555 dev_err(&dev->intf->dev, 556 "Invalid channel number (%d)\n", channel); 557 return; 558 } 559 560 priv = dev->nets[channel]; 561 562 if (!netif_device_present(priv->netdev)) 563 return; 564 565 stats = &priv->netdev->stats; 566 567 context = &priv->tx_contexts[tid % dev->max_tx_urbs]; 568 569 /* Sometimes the state change doesn't come after a bus-off event */ 570 if (priv->can.restart_ms && priv->can.state >= CAN_STATE_BUS_OFF) { 571 struct sk_buff *skb; 572 struct can_frame *cf; 573 574 skb = alloc_can_err_skb(priv->netdev, &cf); 575 if (skb) { 576 cf->can_id |= CAN_ERR_RESTARTED; 577 578 stats->rx_packets++; 579 stats->rx_bytes += cf->can_dlc; 580 netif_rx(skb); 581 } else { 582 netdev_err(priv->netdev, 583 "No memory left for err_skb\n"); 584 } 585 586 priv->can.can_stats.restarts++; 587 netif_carrier_on(priv->netdev); 588 589 priv->can.state = CAN_STATE_ERROR_ACTIVE; 590 } 591 592 stats->tx_packets++; 593 stats->tx_bytes += context->dlc; 594 595 spin_lock_irqsave(&priv->tx_contexts_lock, flags); 596 597 can_get_echo_skb(priv->netdev, context->echo_index); 598 context->echo_index = dev->max_tx_urbs; 599 --priv->active_tx_contexts; 600 netif_wake_queue(priv->netdev); 601 602 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags); 603 } 604 605 static int kvaser_usb_leaf_simple_cmd_async(struct kvaser_usb_net_priv *priv, 606 u8 cmd_id) 607 { 608 struct kvaser_cmd *cmd; 609 int err; 610 611 cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC); 612 if (!cmd) 613 return -ENOMEM; 614 615 cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple); 616 cmd->id = cmd_id; 617 cmd->u.simple.channel = priv->channel; 618 619 err = kvaser_usb_send_cmd_async(priv, cmd, cmd->len); 620 if (err) 621 kfree(cmd); 622 623 return err; 624 } 625 626 static void 627 kvaser_usb_leaf_rx_error_update_can_state(struct kvaser_usb_net_priv *priv, 628 const struct kvaser_usb_err_summary *es, 629 struct can_frame *cf) 630 { 631 struct kvaser_usb *dev = priv->dev; 632 struct net_device_stats *stats = &priv->netdev->stats; 633 enum can_state cur_state, new_state, tx_state, rx_state; 634 635 netdev_dbg(priv->netdev, "Error status: 0x%02x\n", es->status); 636 637 new_state = priv->can.state; 638 cur_state = priv->can.state; 639 640 if (es->status & (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) { 641 new_state = CAN_STATE_BUS_OFF; 642 } else if (es->status & M16C_STATE_BUS_PASSIVE) { 643 new_state = CAN_STATE_ERROR_PASSIVE; 644 } else if (es->status & M16C_STATE_BUS_ERROR) { 645 /* Guard against spurious error events after a busoff */ 646 if (cur_state < CAN_STATE_BUS_OFF) { 647 if (es->txerr >= 128 || es->rxerr >= 128) 648 new_state = CAN_STATE_ERROR_PASSIVE; 649 else if (es->txerr >= 96 || es->rxerr >= 96) 650 new_state = CAN_STATE_ERROR_WARNING; 651 else if (cur_state > CAN_STATE_ERROR_ACTIVE) 652 new_state = CAN_STATE_ERROR_ACTIVE; 653 } 654 } 655 656 if (!es->status) 657 new_state = CAN_STATE_ERROR_ACTIVE; 658 659 if (new_state != cur_state) { 660 tx_state = (es->txerr >= es->rxerr) ? new_state : 0; 661 rx_state = (es->txerr <= es->rxerr) ? new_state : 0; 662 663 can_change_state(priv->netdev, cf, tx_state, rx_state); 664 } 665 666 if (priv->can.restart_ms && 667 cur_state >= CAN_STATE_BUS_OFF && 668 new_state < CAN_STATE_BUS_OFF) 669 priv->can.can_stats.restarts++; 670 671 switch (dev->card_data.leaf.family) { 672 case KVASER_LEAF: 673 if (es->leaf.error_factor) { 674 priv->can.can_stats.bus_error++; 675 stats->rx_errors++; 676 } 677 break; 678 case KVASER_USBCAN: 679 if (es->usbcan.error_state & USBCAN_ERROR_STATE_TX_ERROR) 680 stats->tx_errors++; 681 if (es->usbcan.error_state & USBCAN_ERROR_STATE_RX_ERROR) 682 stats->rx_errors++; 683 if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR) 684 priv->can.can_stats.bus_error++; 685 break; 686 } 687 688 priv->bec.txerr = es->txerr; 689 priv->bec.rxerr = es->rxerr; 690 } 691 692 static void kvaser_usb_leaf_rx_error(const struct kvaser_usb *dev, 693 const struct kvaser_usb_err_summary *es) 694 { 695 struct can_frame *cf; 696 struct can_frame tmp_cf = { .can_id = CAN_ERR_FLAG, 697 .can_dlc = CAN_ERR_DLC }; 698 struct sk_buff *skb; 699 struct net_device_stats *stats; 700 struct kvaser_usb_net_priv *priv; 701 enum can_state old_state, new_state; 702 703 if (es->channel >= dev->nchannels) { 704 dev_err(&dev->intf->dev, 705 "Invalid channel number (%d)\n", es->channel); 706 return; 707 } 708 709 priv = dev->nets[es->channel]; 710 stats = &priv->netdev->stats; 711 712 /* Update all of the CAN interface's state and error counters before 713 * trying any memory allocation that can actually fail with -ENOMEM. 714 * 715 * We send a temporary stack-allocated error CAN frame to 716 * can_change_state() for the very same reason. 717 * 718 * TODO: Split can_change_state() responsibility between updating the 719 * CAN interface's state and counters, and the setting up of CAN error 720 * frame ID and data to userspace. Remove stack allocation afterwards. 721 */ 722 old_state = priv->can.state; 723 kvaser_usb_leaf_rx_error_update_can_state(priv, es, &tmp_cf); 724 new_state = priv->can.state; 725 726 skb = alloc_can_err_skb(priv->netdev, &cf); 727 if (!skb) { 728 stats->rx_dropped++; 729 return; 730 } 731 memcpy(cf, &tmp_cf, sizeof(*cf)); 732 733 if (new_state != old_state) { 734 if (es->status & 735 (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) { 736 if (!priv->can.restart_ms) 737 kvaser_usb_leaf_simple_cmd_async(priv, 738 CMD_STOP_CHIP); 739 netif_carrier_off(priv->netdev); 740 } 741 742 if (priv->can.restart_ms && 743 old_state >= CAN_STATE_BUS_OFF && 744 new_state < CAN_STATE_BUS_OFF) { 745 cf->can_id |= CAN_ERR_RESTARTED; 746 netif_carrier_on(priv->netdev); 747 } 748 } 749 750 switch (dev->card_data.leaf.family) { 751 case KVASER_LEAF: 752 if (es->leaf.error_factor) { 753 cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT; 754 755 if (es->leaf.error_factor & M16C_EF_ACKE) 756 cf->data[3] = CAN_ERR_PROT_LOC_ACK; 757 if (es->leaf.error_factor & M16C_EF_CRCE) 758 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 759 if (es->leaf.error_factor & M16C_EF_FORME) 760 cf->data[2] |= CAN_ERR_PROT_FORM; 761 if (es->leaf.error_factor & M16C_EF_STFE) 762 cf->data[2] |= CAN_ERR_PROT_STUFF; 763 if (es->leaf.error_factor & M16C_EF_BITE0) 764 cf->data[2] |= CAN_ERR_PROT_BIT0; 765 if (es->leaf.error_factor & M16C_EF_BITE1) 766 cf->data[2] |= CAN_ERR_PROT_BIT1; 767 if (es->leaf.error_factor & M16C_EF_TRE) 768 cf->data[2] |= CAN_ERR_PROT_TX; 769 } 770 break; 771 case KVASER_USBCAN: 772 if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR) 773 cf->can_id |= CAN_ERR_BUSERROR; 774 break; 775 } 776 777 cf->data[6] = es->txerr; 778 cf->data[7] = es->rxerr; 779 780 stats->rx_packets++; 781 stats->rx_bytes += cf->can_dlc; 782 netif_rx(skb); 783 } 784 785 /* For USBCAN, report error to userspace if the channels's errors counter 786 * has changed, or we're the only channel seeing a bus error state. 787 */ 788 static void 789 kvaser_usb_leaf_usbcan_conditionally_rx_error(const struct kvaser_usb *dev, 790 struct kvaser_usb_err_summary *es) 791 { 792 struct kvaser_usb_net_priv *priv; 793 unsigned int channel; 794 bool report_error; 795 796 channel = es->channel; 797 if (channel >= dev->nchannels) { 798 dev_err(&dev->intf->dev, 799 "Invalid channel number (%d)\n", channel); 800 return; 801 } 802 803 priv = dev->nets[channel]; 804 report_error = false; 805 806 if (es->txerr != priv->bec.txerr) { 807 es->usbcan.error_state |= USBCAN_ERROR_STATE_TX_ERROR; 808 report_error = true; 809 } 810 if (es->rxerr != priv->bec.rxerr) { 811 es->usbcan.error_state |= USBCAN_ERROR_STATE_RX_ERROR; 812 report_error = true; 813 } 814 if ((es->status & M16C_STATE_BUS_ERROR) && 815 !(es->usbcan.other_ch_status & M16C_STATE_BUS_ERROR)) { 816 es->usbcan.error_state |= USBCAN_ERROR_STATE_BUSERROR; 817 report_error = true; 818 } 819 820 if (report_error) 821 kvaser_usb_leaf_rx_error(dev, es); 822 } 823 824 static void kvaser_usb_leaf_usbcan_rx_error(const struct kvaser_usb *dev, 825 const struct kvaser_cmd *cmd) 826 { 827 struct kvaser_usb_err_summary es = { }; 828 829 switch (cmd->id) { 830 /* Sometimes errors are sent as unsolicited chip state events */ 831 case CMD_CHIP_STATE_EVENT: 832 es.channel = cmd->u.usbcan.chip_state_event.channel; 833 es.status = cmd->u.usbcan.chip_state_event.status; 834 es.txerr = cmd->u.usbcan.chip_state_event.tx_errors_count; 835 es.rxerr = cmd->u.usbcan.chip_state_event.rx_errors_count; 836 kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es); 837 break; 838 839 case CMD_CAN_ERROR_EVENT: 840 es.channel = 0; 841 es.status = cmd->u.usbcan.error_event.status_ch0; 842 es.txerr = cmd->u.usbcan.error_event.tx_errors_count_ch0; 843 es.rxerr = cmd->u.usbcan.error_event.rx_errors_count_ch0; 844 es.usbcan.other_ch_status = 845 cmd->u.usbcan.error_event.status_ch1; 846 kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es); 847 848 /* The USBCAN firmware supports up to 2 channels. 849 * Now that ch0 was checked, check if ch1 has any errors. 850 */ 851 if (dev->nchannels == MAX_USBCAN_NET_DEVICES) { 852 es.channel = 1; 853 es.status = cmd->u.usbcan.error_event.status_ch1; 854 es.txerr = 855 cmd->u.usbcan.error_event.tx_errors_count_ch1; 856 es.rxerr = 857 cmd->u.usbcan.error_event.rx_errors_count_ch1; 858 es.usbcan.other_ch_status = 859 cmd->u.usbcan.error_event.status_ch0; 860 kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es); 861 } 862 break; 863 864 default: 865 dev_err(&dev->intf->dev, "Invalid cmd id (%d)\n", cmd->id); 866 } 867 } 868 869 static void kvaser_usb_leaf_leaf_rx_error(const struct kvaser_usb *dev, 870 const struct kvaser_cmd *cmd) 871 { 872 struct kvaser_usb_err_summary es = { }; 873 874 switch (cmd->id) { 875 case CMD_CAN_ERROR_EVENT: 876 es.channel = cmd->u.leaf.error_event.channel; 877 es.status = cmd->u.leaf.error_event.status; 878 es.txerr = cmd->u.leaf.error_event.tx_errors_count; 879 es.rxerr = cmd->u.leaf.error_event.rx_errors_count; 880 es.leaf.error_factor = cmd->u.leaf.error_event.error_factor; 881 break; 882 case CMD_LEAF_LOG_MESSAGE: 883 es.channel = cmd->u.leaf.log_message.channel; 884 es.status = cmd->u.leaf.log_message.data[0]; 885 es.txerr = cmd->u.leaf.log_message.data[2]; 886 es.rxerr = cmd->u.leaf.log_message.data[3]; 887 es.leaf.error_factor = cmd->u.leaf.log_message.data[1]; 888 break; 889 case CMD_CHIP_STATE_EVENT: 890 es.channel = cmd->u.leaf.chip_state_event.channel; 891 es.status = cmd->u.leaf.chip_state_event.status; 892 es.txerr = cmd->u.leaf.chip_state_event.tx_errors_count; 893 es.rxerr = cmd->u.leaf.chip_state_event.rx_errors_count; 894 es.leaf.error_factor = 0; 895 break; 896 default: 897 dev_err(&dev->intf->dev, "Invalid cmd id (%d)\n", cmd->id); 898 return; 899 } 900 901 kvaser_usb_leaf_rx_error(dev, &es); 902 } 903 904 static void kvaser_usb_leaf_rx_can_err(const struct kvaser_usb_net_priv *priv, 905 const struct kvaser_cmd *cmd) 906 { 907 if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME | 908 MSG_FLAG_NERR)) { 909 struct net_device_stats *stats = &priv->netdev->stats; 910 911 netdev_err(priv->netdev, "Unknown error (flags: 0x%02x)\n", 912 cmd->u.rx_can_header.flag); 913 914 stats->rx_errors++; 915 return; 916 } 917 918 if (cmd->u.rx_can_header.flag & MSG_FLAG_OVERRUN) 919 kvaser_usb_can_rx_over_error(priv->netdev); 920 } 921 922 static void kvaser_usb_leaf_rx_can_msg(const struct kvaser_usb *dev, 923 const struct kvaser_cmd *cmd) 924 { 925 struct kvaser_usb_net_priv *priv; 926 struct can_frame *cf; 927 struct sk_buff *skb; 928 struct net_device_stats *stats; 929 u8 channel = cmd->u.rx_can_header.channel; 930 const u8 *rx_data = NULL; /* GCC */ 931 932 if (channel >= dev->nchannels) { 933 dev_err(&dev->intf->dev, 934 "Invalid channel number (%d)\n", channel); 935 return; 936 } 937 938 priv = dev->nets[channel]; 939 stats = &priv->netdev->stats; 940 941 if ((cmd->u.rx_can_header.flag & MSG_FLAG_ERROR_FRAME) && 942 (dev->card_data.leaf.family == KVASER_LEAF && 943 cmd->id == CMD_LEAF_LOG_MESSAGE)) { 944 kvaser_usb_leaf_leaf_rx_error(dev, cmd); 945 return; 946 } else if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME | 947 MSG_FLAG_NERR | 948 MSG_FLAG_OVERRUN)) { 949 kvaser_usb_leaf_rx_can_err(priv, cmd); 950 return; 951 } else if (cmd->u.rx_can_header.flag & ~MSG_FLAG_REMOTE_FRAME) { 952 netdev_warn(priv->netdev, 953 "Unhandled frame (flags: 0x%02x)\n", 954 cmd->u.rx_can_header.flag); 955 return; 956 } 957 958 switch (dev->card_data.leaf.family) { 959 case KVASER_LEAF: 960 rx_data = cmd->u.leaf.rx_can.data; 961 break; 962 case KVASER_USBCAN: 963 rx_data = cmd->u.usbcan.rx_can.data; 964 break; 965 } 966 967 skb = alloc_can_skb(priv->netdev, &cf); 968 if (!skb) { 969 stats->rx_dropped++; 970 return; 971 } 972 973 if (dev->card_data.leaf.family == KVASER_LEAF && cmd->id == 974 CMD_LEAF_LOG_MESSAGE) { 975 cf->can_id = le32_to_cpu(cmd->u.leaf.log_message.id); 976 if (cf->can_id & KVASER_EXTENDED_FRAME) 977 cf->can_id &= CAN_EFF_MASK | CAN_EFF_FLAG; 978 else 979 cf->can_id &= CAN_SFF_MASK; 980 981 cf->can_dlc = get_can_dlc(cmd->u.leaf.log_message.dlc); 982 983 if (cmd->u.leaf.log_message.flags & MSG_FLAG_REMOTE_FRAME) 984 cf->can_id |= CAN_RTR_FLAG; 985 else 986 memcpy(cf->data, &cmd->u.leaf.log_message.data, 987 cf->can_dlc); 988 } else { 989 cf->can_id = ((rx_data[0] & 0x1f) << 6) | (rx_data[1] & 0x3f); 990 991 if (cmd->id == CMD_RX_EXT_MESSAGE) { 992 cf->can_id <<= 18; 993 cf->can_id |= ((rx_data[2] & 0x0f) << 14) | 994 ((rx_data[3] & 0xff) << 6) | 995 (rx_data[4] & 0x3f); 996 cf->can_id |= CAN_EFF_FLAG; 997 } 998 999 cf->can_dlc = get_can_dlc(rx_data[5]); 1000 1001 if (cmd->u.rx_can_header.flag & MSG_FLAG_REMOTE_FRAME) 1002 cf->can_id |= CAN_RTR_FLAG; 1003 else 1004 memcpy(cf->data, &rx_data[6], cf->can_dlc); 1005 } 1006 1007 stats->rx_packets++; 1008 stats->rx_bytes += cf->can_dlc; 1009 netif_rx(skb); 1010 } 1011 1012 static void kvaser_usb_leaf_start_chip_reply(const struct kvaser_usb *dev, 1013 const struct kvaser_cmd *cmd) 1014 { 1015 struct kvaser_usb_net_priv *priv; 1016 u8 channel = cmd->u.simple.channel; 1017 1018 if (channel >= dev->nchannels) { 1019 dev_err(&dev->intf->dev, 1020 "Invalid channel number (%d)\n", channel); 1021 return; 1022 } 1023 1024 priv = dev->nets[channel]; 1025 1026 if (completion_done(&priv->start_comp) && 1027 netif_queue_stopped(priv->netdev)) { 1028 netif_wake_queue(priv->netdev); 1029 } else { 1030 netif_start_queue(priv->netdev); 1031 complete(&priv->start_comp); 1032 } 1033 } 1034 1035 static void kvaser_usb_leaf_stop_chip_reply(const struct kvaser_usb *dev, 1036 const struct kvaser_cmd *cmd) 1037 { 1038 struct kvaser_usb_net_priv *priv; 1039 u8 channel = cmd->u.simple.channel; 1040 1041 if (channel >= dev->nchannels) { 1042 dev_err(&dev->intf->dev, 1043 "Invalid channel number (%d)\n", channel); 1044 return; 1045 } 1046 1047 priv = dev->nets[channel]; 1048 1049 complete(&priv->stop_comp); 1050 } 1051 1052 static void kvaser_usb_leaf_handle_command(const struct kvaser_usb *dev, 1053 const struct kvaser_cmd *cmd) 1054 { 1055 switch (cmd->id) { 1056 case CMD_START_CHIP_REPLY: 1057 kvaser_usb_leaf_start_chip_reply(dev, cmd); 1058 break; 1059 1060 case CMD_STOP_CHIP_REPLY: 1061 kvaser_usb_leaf_stop_chip_reply(dev, cmd); 1062 break; 1063 1064 case CMD_RX_STD_MESSAGE: 1065 case CMD_RX_EXT_MESSAGE: 1066 kvaser_usb_leaf_rx_can_msg(dev, cmd); 1067 break; 1068 1069 case CMD_LEAF_LOG_MESSAGE: 1070 if (dev->card_data.leaf.family != KVASER_LEAF) 1071 goto warn; 1072 kvaser_usb_leaf_rx_can_msg(dev, cmd); 1073 break; 1074 1075 case CMD_CHIP_STATE_EVENT: 1076 case CMD_CAN_ERROR_EVENT: 1077 if (dev->card_data.leaf.family == KVASER_LEAF) 1078 kvaser_usb_leaf_leaf_rx_error(dev, cmd); 1079 else 1080 kvaser_usb_leaf_usbcan_rx_error(dev, cmd); 1081 break; 1082 1083 case CMD_TX_ACKNOWLEDGE: 1084 kvaser_usb_leaf_tx_acknowledge(dev, cmd); 1085 break; 1086 1087 /* Ignored commands */ 1088 case CMD_USBCAN_CLOCK_OVERFLOW_EVENT: 1089 if (dev->card_data.leaf.family != KVASER_USBCAN) 1090 goto warn; 1091 break; 1092 1093 case CMD_FLUSH_QUEUE_REPLY: 1094 if (dev->card_data.leaf.family != KVASER_LEAF) 1095 goto warn; 1096 break; 1097 1098 default: 1099 warn: dev_warn(&dev->intf->dev, "Unhandled command (%d)\n", cmd->id); 1100 break; 1101 } 1102 } 1103 1104 static void kvaser_usb_leaf_read_bulk_callback(struct kvaser_usb *dev, 1105 void *buf, int len) 1106 { 1107 struct kvaser_cmd *cmd; 1108 int pos = 0; 1109 1110 while (pos <= len - CMD_HEADER_LEN) { 1111 cmd = buf + pos; 1112 1113 /* The Kvaser firmware can only read and write commands that 1114 * does not cross the USB's endpoint wMaxPacketSize boundary. 1115 * If a follow-up command crosses such boundary, firmware puts 1116 * a placeholder zero-length command in its place then aligns 1117 * the real command to the next max packet size. 1118 * 1119 * Handle such cases or we're going to miss a significant 1120 * number of events in case of a heavy rx load on the bus. 1121 */ 1122 if (cmd->len == 0) { 1123 pos = round_up(pos, le16_to_cpu 1124 (dev->bulk_in->wMaxPacketSize)); 1125 continue; 1126 } 1127 1128 if (pos + cmd->len > len) { 1129 dev_err_ratelimited(&dev->intf->dev, "Format error\n"); 1130 break; 1131 } 1132 1133 kvaser_usb_leaf_handle_command(dev, cmd); 1134 pos += cmd->len; 1135 } 1136 } 1137 1138 static int kvaser_usb_leaf_set_opt_mode(const struct kvaser_usb_net_priv *priv) 1139 { 1140 struct kvaser_cmd *cmd; 1141 int rc; 1142 1143 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1144 if (!cmd) 1145 return -ENOMEM; 1146 1147 cmd->id = CMD_SET_CTRL_MODE; 1148 cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_ctrl_mode); 1149 cmd->u.ctrl_mode.tid = 0xff; 1150 cmd->u.ctrl_mode.channel = priv->channel; 1151 1152 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 1153 cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT; 1154 else 1155 cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL; 1156 1157 rc = kvaser_usb_send_cmd(priv->dev, cmd, cmd->len); 1158 1159 kfree(cmd); 1160 return rc; 1161 } 1162 1163 static int kvaser_usb_leaf_start_chip(struct kvaser_usb_net_priv *priv) 1164 { 1165 int err; 1166 1167 init_completion(&priv->start_comp); 1168 1169 err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_START_CHIP, 1170 priv->channel); 1171 if (err) 1172 return err; 1173 1174 if (!wait_for_completion_timeout(&priv->start_comp, 1175 msecs_to_jiffies(KVASER_USB_TIMEOUT))) 1176 return -ETIMEDOUT; 1177 1178 return 0; 1179 } 1180 1181 static int kvaser_usb_leaf_stop_chip(struct kvaser_usb_net_priv *priv) 1182 { 1183 int err; 1184 1185 init_completion(&priv->stop_comp); 1186 1187 err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_STOP_CHIP, 1188 priv->channel); 1189 if (err) 1190 return err; 1191 1192 if (!wait_for_completion_timeout(&priv->stop_comp, 1193 msecs_to_jiffies(KVASER_USB_TIMEOUT))) 1194 return -ETIMEDOUT; 1195 1196 return 0; 1197 } 1198 1199 static int kvaser_usb_leaf_reset_chip(struct kvaser_usb *dev, int channel) 1200 { 1201 return kvaser_usb_leaf_send_simple_cmd(dev, CMD_RESET_CHIP, channel); 1202 } 1203 1204 static int kvaser_usb_leaf_flush_queue(struct kvaser_usb_net_priv *priv) 1205 { 1206 struct kvaser_cmd *cmd; 1207 int rc; 1208 1209 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 1210 if (!cmd) 1211 return -ENOMEM; 1212 1213 cmd->id = CMD_FLUSH_QUEUE; 1214 cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_flush_queue); 1215 cmd->u.flush_queue.channel = priv->channel; 1216 cmd->u.flush_queue.flags = 0x00; 1217 1218 rc = kvaser_usb_send_cmd(priv->dev, cmd, cmd->len); 1219 1220 kfree(cmd); 1221 return rc; 1222 } 1223 1224 static int kvaser_usb_leaf_init_card(struct kvaser_usb *dev) 1225 { 1226 struct kvaser_usb_dev_card_data *card_data = &dev->card_data; 1227 1228 dev->cfg = &kvaser_usb_leaf_dev_cfg; 1229 card_data->ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES; 1230 1231 return 0; 1232 } 1233 1234 static const struct can_bittiming_const kvaser_usb_leaf_bittiming_const = { 1235 .name = "kvaser_usb", 1236 .tseg1_min = KVASER_USB_TSEG1_MIN, 1237 .tseg1_max = KVASER_USB_TSEG1_MAX, 1238 .tseg2_min = KVASER_USB_TSEG2_MIN, 1239 .tseg2_max = KVASER_USB_TSEG2_MAX, 1240 .sjw_max = KVASER_USB_SJW_MAX, 1241 .brp_min = KVASER_USB_BRP_MIN, 1242 .brp_max = KVASER_USB_BRP_MAX, 1243 .brp_inc = KVASER_USB_BRP_INC, 1244 }; 1245 1246 static int kvaser_usb_leaf_set_bittiming(struct net_device *netdev) 1247 { 1248 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1249 struct can_bittiming *bt = &priv->can.bittiming; 1250 struct kvaser_usb *dev = priv->dev; 1251 struct kvaser_cmd *cmd; 1252 int rc; 1253 1254 cmd = kmalloc(sizeof(*cmd), GFP_KERNEL); 1255 if (!cmd) 1256 return -ENOMEM; 1257 1258 cmd->id = CMD_SET_BUS_PARAMS; 1259 cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_busparams); 1260 cmd->u.busparams.channel = priv->channel; 1261 cmd->u.busparams.tid = 0xff; 1262 cmd->u.busparams.bitrate = cpu_to_le32(bt->bitrate); 1263 cmd->u.busparams.sjw = bt->sjw; 1264 cmd->u.busparams.tseg1 = bt->prop_seg + bt->phase_seg1; 1265 cmd->u.busparams.tseg2 = bt->phase_seg2; 1266 1267 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 1268 cmd->u.busparams.no_samp = 3; 1269 else 1270 cmd->u.busparams.no_samp = 1; 1271 1272 rc = kvaser_usb_send_cmd(dev, cmd, cmd->len); 1273 1274 kfree(cmd); 1275 return rc; 1276 } 1277 1278 static int kvaser_usb_leaf_set_mode(struct net_device *netdev, 1279 enum can_mode mode) 1280 { 1281 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1282 int err; 1283 1284 switch (mode) { 1285 case CAN_MODE_START: 1286 err = kvaser_usb_leaf_simple_cmd_async(priv, CMD_START_CHIP); 1287 if (err) 1288 return err; 1289 break; 1290 default: 1291 return -EOPNOTSUPP; 1292 } 1293 1294 return 0; 1295 } 1296 1297 static int kvaser_usb_leaf_get_berr_counter(const struct net_device *netdev, 1298 struct can_berr_counter *bec) 1299 { 1300 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1301 1302 *bec = priv->bec; 1303 1304 return 0; 1305 } 1306 1307 static int kvaser_usb_leaf_setup_endpoints(struct kvaser_usb *dev) 1308 { 1309 const struct usb_host_interface *iface_desc; 1310 struct usb_endpoint_descriptor *endpoint; 1311 int i; 1312 1313 iface_desc = &dev->intf->altsetting[0]; 1314 1315 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 1316 endpoint = &iface_desc->endpoint[i].desc; 1317 1318 if (!dev->bulk_in && usb_endpoint_is_bulk_in(endpoint)) 1319 dev->bulk_in = endpoint; 1320 1321 if (!dev->bulk_out && usb_endpoint_is_bulk_out(endpoint)) 1322 dev->bulk_out = endpoint; 1323 1324 /* use first bulk endpoint for in and out */ 1325 if (dev->bulk_in && dev->bulk_out) 1326 return 0; 1327 } 1328 1329 return -ENODEV; 1330 } 1331 1332 const struct kvaser_usb_dev_ops kvaser_usb_leaf_dev_ops = { 1333 .dev_set_mode = kvaser_usb_leaf_set_mode, 1334 .dev_set_bittiming = kvaser_usb_leaf_set_bittiming, 1335 .dev_set_data_bittiming = NULL, 1336 .dev_get_berr_counter = kvaser_usb_leaf_get_berr_counter, 1337 .dev_setup_endpoints = kvaser_usb_leaf_setup_endpoints, 1338 .dev_init_card = kvaser_usb_leaf_init_card, 1339 .dev_get_software_info = kvaser_usb_leaf_get_software_info, 1340 .dev_get_software_details = NULL, 1341 .dev_get_card_info = kvaser_usb_leaf_get_card_info, 1342 .dev_get_capabilities = NULL, 1343 .dev_set_opt_mode = kvaser_usb_leaf_set_opt_mode, 1344 .dev_start_chip = kvaser_usb_leaf_start_chip, 1345 .dev_stop_chip = kvaser_usb_leaf_stop_chip, 1346 .dev_reset_chip = kvaser_usb_leaf_reset_chip, 1347 .dev_flush_queue = kvaser_usb_leaf_flush_queue, 1348 .dev_read_bulk_callback = kvaser_usb_leaf_read_bulk_callback, 1349 .dev_frame_to_cmd = kvaser_usb_leaf_frame_to_cmd, 1350 }; 1351 1352 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg = { 1353 .clock = { 1354 .freq = CAN_USB_CLOCK, 1355 }, 1356 .timestamp_freq = 1, 1357 .bittiming_const = &kvaser_usb_leaf_bittiming_const, 1358 }; 1359