kvaser_usb.c revision e59e36e7333702d1d835113ced85243bb7f30f99
1/* 2 * This program is free software; you can redistribute it and/or 3 * modify it under the terms of the GNU General Public License as 4 * published by the Free Software Foundation version 2. 5 * 6 * Parts of this driver are based on the following: 7 * - Kvaser linux leaf driver (version 4.78) 8 * - CAN driver for esd CAN-USB/2 9 * 10 * Copyright (C) 2002-2006 KVASER AB, Sweden. All rights reserved. 11 * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh 12 * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be> 13 */ 14 15#include <linux/completion.h> 16#include <linux/module.h> 17#include <linux/netdevice.h> 18#include <linux/usb.h> 19 20#include <linux/can.h> 21#include <linux/can/dev.h> 22#include <linux/can/error.h> 23 24#define MAX_TX_URBS 16 25#define MAX_RX_URBS 4 26#define START_TIMEOUT 1000 /* msecs */ 27#define STOP_TIMEOUT 1000 /* msecs */ 28#define USB_SEND_TIMEOUT 1000 /* msecs */ 29#define USB_RECV_TIMEOUT 1000 /* msecs */ 30#define RX_BUFFER_SIZE 3072 31#define CAN_USB_CLOCK 8000000 32#define MAX_NET_DEVICES 3 33 34/* Kvaser USB devices */ 35#define KVASER_VENDOR_ID 0x0bfd 36#define USB_LEAF_DEVEL_PRODUCT_ID 10 37#define USB_LEAF_LITE_PRODUCT_ID 11 38#define USB_LEAF_PRO_PRODUCT_ID 12 39#define USB_LEAF_SPRO_PRODUCT_ID 14 40#define USB_LEAF_PRO_LS_PRODUCT_ID 15 41#define USB_LEAF_PRO_SWC_PRODUCT_ID 16 42#define USB_LEAF_PRO_LIN_PRODUCT_ID 17 43#define USB_LEAF_SPRO_LS_PRODUCT_ID 18 44#define USB_LEAF_SPRO_SWC_PRODUCT_ID 19 45#define USB_MEMO2_DEVEL_PRODUCT_ID 22 46#define USB_MEMO2_HSHS_PRODUCT_ID 23 47#define USB_UPRO_HSHS_PRODUCT_ID 24 48#define USB_LEAF_LITE_GI_PRODUCT_ID 25 49#define USB_LEAF_PRO_OBDII_PRODUCT_ID 26 50#define USB_MEMO2_HSLS_PRODUCT_ID 27 51#define USB_LEAF_LITE_CH_PRODUCT_ID 28 52#define USB_BLACKBIRD_SPRO_PRODUCT_ID 29 53#define USB_OEM_MERCURY_PRODUCT_ID 34 54#define USB_OEM_LEAF_PRODUCT_ID 35 55#define USB_CAN_R_PRODUCT_ID 39 56 57/* USB devices features */ 58#define KVASER_HAS_SILENT_MODE BIT(0) 59#define KVASER_HAS_TXRX_ERRORS BIT(1) 60 61/* Message header size */ 62#define MSG_HEADER_LEN 2 63 64/* Can message flags */ 65#define MSG_FLAG_ERROR_FRAME BIT(0) 66#define MSG_FLAG_OVERRUN BIT(1) 67#define MSG_FLAG_NERR BIT(2) 68#define MSG_FLAG_WAKEUP BIT(3) 69#define MSG_FLAG_REMOTE_FRAME BIT(4) 70#define MSG_FLAG_RESERVED BIT(5) 71#define MSG_FLAG_TX_ACK BIT(6) 72#define MSG_FLAG_TX_REQUEST BIT(7) 73 74/* Can states */ 75#define M16C_STATE_BUS_RESET BIT(0) 76#define M16C_STATE_BUS_ERROR BIT(4) 77#define M16C_STATE_BUS_PASSIVE BIT(5) 78#define M16C_STATE_BUS_OFF BIT(6) 79 80/* Can msg ids */ 81#define CMD_RX_STD_MESSAGE 12 82#define CMD_TX_STD_MESSAGE 13 83#define CMD_RX_EXT_MESSAGE 14 84#define CMD_TX_EXT_MESSAGE 15 85#define CMD_SET_BUS_PARAMS 16 86#define CMD_GET_BUS_PARAMS 17 87#define CMD_GET_BUS_PARAMS_REPLY 18 88#define CMD_GET_CHIP_STATE 19 89#define CMD_CHIP_STATE_EVENT 20 90#define CMD_SET_CTRL_MODE 21 91#define CMD_GET_CTRL_MODE 22 92#define CMD_GET_CTRL_MODE_REPLY 23 93#define CMD_RESET_CHIP 24 94#define CMD_RESET_CARD 25 95#define CMD_START_CHIP 26 96#define CMD_START_CHIP_REPLY 27 97#define CMD_STOP_CHIP 28 98#define CMD_STOP_CHIP_REPLY 29 99#define CMD_GET_CARD_INFO2 32 100#define CMD_GET_CARD_INFO 34 101#define CMD_GET_CARD_INFO_REPLY 35 102#define CMD_GET_SOFTWARE_INFO 38 103#define CMD_GET_SOFTWARE_INFO_REPLY 39 104#define CMD_ERROR_EVENT 45 105#define CMD_FLUSH_QUEUE 48 106#define CMD_RESET_ERROR_COUNTER 49 107#define CMD_TX_ACKNOWLEDGE 50 108#define CMD_CAN_ERROR_EVENT 51 109#define CMD_USB_THROTTLE 77 110#define CMD_LOG_MESSAGE 106 111 112/* error factors */ 113#define M16C_EF_ACKE BIT(0) 114#define M16C_EF_CRCE BIT(1) 115#define M16C_EF_FORME BIT(2) 116#define M16C_EF_STFE BIT(3) 117#define M16C_EF_BITE0 BIT(4) 118#define M16C_EF_BITE1 BIT(5) 119#define M16C_EF_RCVE BIT(6) 120#define M16C_EF_TRE BIT(7) 121 122/* bittiming parameters */ 123#define KVASER_USB_TSEG1_MIN 1 124#define KVASER_USB_TSEG1_MAX 16 125#define KVASER_USB_TSEG2_MIN 1 126#define KVASER_USB_TSEG2_MAX 8 127#define KVASER_USB_SJW_MAX 4 128#define KVASER_USB_BRP_MIN 1 129#define KVASER_USB_BRP_MAX 64 130#define KVASER_USB_BRP_INC 1 131 132/* ctrl modes */ 133#define KVASER_CTRL_MODE_NORMAL 1 134#define KVASER_CTRL_MODE_SILENT 2 135#define KVASER_CTRL_MODE_SELFRECEPTION 3 136#define KVASER_CTRL_MODE_OFF 4 137 138/* log message */ 139#define KVASER_EXTENDED_FRAME BIT(31) 140 141struct kvaser_msg_simple { 142 u8 tid; 143 u8 channel; 144} __packed; 145 146struct kvaser_msg_cardinfo { 147 u8 tid; 148 u8 nchannels; 149 __le32 serial_number; 150 __le32 padding; 151 __le32 clock_resolution; 152 __le32 mfgdate; 153 u8 ean[8]; 154 u8 hw_revision; 155 u8 usb_hs_mode; 156 __le16 padding2; 157} __packed; 158 159struct kvaser_msg_cardinfo2 { 160 u8 tid; 161 u8 channel; 162 u8 pcb_id[24]; 163 __le32 oem_unlock_code; 164} __packed; 165 166struct kvaser_msg_softinfo { 167 u8 tid; 168 u8 channel; 169 __le32 sw_options; 170 __le32 fw_version; 171 __le16 max_outstanding_tx; 172 __le16 padding[9]; 173} __packed; 174 175struct kvaser_msg_busparams { 176 u8 tid; 177 u8 channel; 178 __le32 bitrate; 179 u8 tseg1; 180 u8 tseg2; 181 u8 sjw; 182 u8 no_samp; 183} __packed; 184 185struct kvaser_msg_tx_can { 186 u8 channel; 187 u8 tid; 188 u8 msg[14]; 189 u8 padding; 190 u8 flags; 191} __packed; 192 193struct kvaser_msg_rx_can { 194 u8 channel; 195 u8 flag; 196 __le16 time[3]; 197 u8 msg[14]; 198} __packed; 199 200struct kvaser_msg_chip_state_event { 201 u8 tid; 202 u8 channel; 203 __le16 time[3]; 204 u8 tx_errors_count; 205 u8 rx_errors_count; 206 u8 status; 207 u8 padding[3]; 208} __packed; 209 210struct kvaser_msg_tx_acknowledge { 211 u8 channel; 212 u8 tid; 213 __le16 time[3]; 214 u8 flags; 215 u8 time_offset; 216} __packed; 217 218struct kvaser_msg_error_event { 219 u8 tid; 220 u8 flags; 221 __le16 time[3]; 222 u8 channel; 223 u8 padding; 224 u8 tx_errors_count; 225 u8 rx_errors_count; 226 u8 status; 227 u8 error_factor; 228} __packed; 229 230struct kvaser_msg_ctrl_mode { 231 u8 tid; 232 u8 channel; 233 u8 ctrl_mode; 234 u8 padding[3]; 235} __packed; 236 237struct kvaser_msg_flush_queue { 238 u8 tid; 239 u8 channel; 240 u8 flags; 241 u8 padding[3]; 242} __packed; 243 244struct kvaser_msg_log_message { 245 u8 channel; 246 u8 flags; 247 __le16 time[3]; 248 u8 dlc; 249 u8 time_offset; 250 __le32 id; 251 u8 data[8]; 252} __packed; 253 254struct kvaser_msg { 255 u8 len; 256 u8 id; 257 union { 258 struct kvaser_msg_simple simple; 259 struct kvaser_msg_cardinfo cardinfo; 260 struct kvaser_msg_cardinfo2 cardinfo2; 261 struct kvaser_msg_softinfo softinfo; 262 struct kvaser_msg_busparams busparams; 263 struct kvaser_msg_tx_can tx_can; 264 struct kvaser_msg_rx_can rx_can; 265 struct kvaser_msg_chip_state_event chip_state_event; 266 struct kvaser_msg_tx_acknowledge tx_acknowledge; 267 struct kvaser_msg_error_event error_event; 268 struct kvaser_msg_ctrl_mode ctrl_mode; 269 struct kvaser_msg_flush_queue flush_queue; 270 struct kvaser_msg_log_message log_message; 271 } u; 272} __packed; 273 274struct kvaser_usb_tx_urb_context { 275 struct kvaser_usb_net_priv *priv; 276 u32 echo_index; 277 int dlc; 278}; 279 280struct kvaser_usb { 281 struct usb_device *udev; 282 struct kvaser_usb_net_priv *nets[MAX_NET_DEVICES]; 283 284 struct usb_endpoint_descriptor *bulk_in, *bulk_out; 285 struct usb_anchor rx_submitted; 286 287 u32 fw_version; 288 unsigned int nchannels; 289 290 bool rxinitdone; 291 void *rxbuf[MAX_RX_URBS]; 292 dma_addr_t rxbuf_dma[MAX_RX_URBS]; 293}; 294 295struct kvaser_usb_net_priv { 296 struct can_priv can; 297 298 atomic_t active_tx_urbs; 299 struct usb_anchor tx_submitted; 300 struct kvaser_usb_tx_urb_context tx_contexts[MAX_TX_URBS]; 301 302 struct completion start_comp, stop_comp; 303 304 struct kvaser_usb *dev; 305 struct net_device *netdev; 306 int channel; 307 308 struct can_berr_counter bec; 309}; 310 311static const struct usb_device_id kvaser_usb_table[] = { 312 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_DEVEL_PRODUCT_ID) }, 313 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_PRODUCT_ID) }, 314 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_PRODUCT_ID), 315 .driver_info = KVASER_HAS_TXRX_ERRORS | 316 KVASER_HAS_SILENT_MODE }, 317 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_PRODUCT_ID), 318 .driver_info = KVASER_HAS_TXRX_ERRORS | 319 KVASER_HAS_SILENT_MODE }, 320 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LS_PRODUCT_ID), 321 .driver_info = KVASER_HAS_TXRX_ERRORS | 322 KVASER_HAS_SILENT_MODE }, 323 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_SWC_PRODUCT_ID), 324 .driver_info = KVASER_HAS_TXRX_ERRORS | 325 KVASER_HAS_SILENT_MODE }, 326 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_LIN_PRODUCT_ID), 327 .driver_info = KVASER_HAS_TXRX_ERRORS | 328 KVASER_HAS_SILENT_MODE }, 329 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_LS_PRODUCT_ID), 330 .driver_info = KVASER_HAS_TXRX_ERRORS | 331 KVASER_HAS_SILENT_MODE }, 332 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_SPRO_SWC_PRODUCT_ID), 333 .driver_info = KVASER_HAS_TXRX_ERRORS | 334 KVASER_HAS_SILENT_MODE }, 335 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_DEVEL_PRODUCT_ID), 336 .driver_info = KVASER_HAS_TXRX_ERRORS | 337 KVASER_HAS_SILENT_MODE }, 338 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSHS_PRODUCT_ID), 339 .driver_info = KVASER_HAS_TXRX_ERRORS | 340 KVASER_HAS_SILENT_MODE }, 341 { USB_DEVICE(KVASER_VENDOR_ID, USB_UPRO_HSHS_PRODUCT_ID), 342 .driver_info = KVASER_HAS_TXRX_ERRORS }, 343 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_GI_PRODUCT_ID) }, 344 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_PRO_OBDII_PRODUCT_ID), 345 .driver_info = KVASER_HAS_TXRX_ERRORS | 346 KVASER_HAS_SILENT_MODE }, 347 { USB_DEVICE(KVASER_VENDOR_ID, USB_MEMO2_HSLS_PRODUCT_ID), 348 .driver_info = KVASER_HAS_TXRX_ERRORS }, 349 { USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_CH_PRODUCT_ID), 350 .driver_info = KVASER_HAS_TXRX_ERRORS }, 351 { USB_DEVICE(KVASER_VENDOR_ID, USB_BLACKBIRD_SPRO_PRODUCT_ID), 352 .driver_info = KVASER_HAS_TXRX_ERRORS }, 353 { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_MERCURY_PRODUCT_ID), 354 .driver_info = KVASER_HAS_TXRX_ERRORS }, 355 { USB_DEVICE(KVASER_VENDOR_ID, USB_OEM_LEAF_PRODUCT_ID), 356 .driver_info = KVASER_HAS_TXRX_ERRORS }, 357 { USB_DEVICE(KVASER_VENDOR_ID, USB_CAN_R_PRODUCT_ID), 358 .driver_info = KVASER_HAS_TXRX_ERRORS }, 359 { } 360}; 361MODULE_DEVICE_TABLE(usb, kvaser_usb_table); 362 363static inline int kvaser_usb_send_msg(const struct kvaser_usb *dev, 364 struct kvaser_msg *msg) 365{ 366 int actual_len; 367 368 return usb_bulk_msg(dev->udev, 369 usb_sndbulkpipe(dev->udev, 370 dev->bulk_out->bEndpointAddress), 371 msg, msg->len, &actual_len, 372 USB_SEND_TIMEOUT); 373} 374 375static int kvaser_usb_wait_msg(const struct kvaser_usb *dev, u8 id, 376 struct kvaser_msg *msg) 377{ 378 struct kvaser_msg *tmp; 379 void *buf; 380 int actual_len; 381 int err; 382 int pos; 383 unsigned long to = jiffies + msecs_to_jiffies(USB_RECV_TIMEOUT); 384 385 buf = kzalloc(RX_BUFFER_SIZE, GFP_KERNEL); 386 if (!buf) 387 return -ENOMEM; 388 389 do { 390 err = usb_bulk_msg(dev->udev, 391 usb_rcvbulkpipe(dev->udev, 392 dev->bulk_in->bEndpointAddress), 393 buf, RX_BUFFER_SIZE, &actual_len, 394 USB_RECV_TIMEOUT); 395 if (err < 0) 396 goto end; 397 398 pos = 0; 399 while (pos <= actual_len - MSG_HEADER_LEN) { 400 tmp = buf + pos; 401 402 if (!tmp->len) 403 break; 404 405 if (pos + tmp->len > actual_len) { 406 dev_err(dev->udev->dev.parent, 407 "Format error\n"); 408 break; 409 } 410 411 if (tmp->id == id) { 412 memcpy(msg, tmp, tmp->len); 413 goto end; 414 } 415 416 pos += tmp->len; 417 } 418 } while (time_before(jiffies, to)); 419 420 err = -EINVAL; 421 422end: 423 kfree(buf); 424 425 return err; 426} 427 428static int kvaser_usb_send_simple_msg(const struct kvaser_usb *dev, 429 u8 msg_id, int channel) 430{ 431 struct kvaser_msg *msg; 432 int rc; 433 434 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 435 if (!msg) 436 return -ENOMEM; 437 438 msg->id = msg_id; 439 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_simple); 440 msg->u.simple.channel = channel; 441 msg->u.simple.tid = 0xff; 442 443 rc = kvaser_usb_send_msg(dev, msg); 444 445 kfree(msg); 446 return rc; 447} 448 449static int kvaser_usb_get_software_info(struct kvaser_usb *dev) 450{ 451 struct kvaser_msg msg; 452 int err; 453 454 err = kvaser_usb_send_simple_msg(dev, CMD_GET_SOFTWARE_INFO, 0); 455 if (err) 456 return err; 457 458 err = kvaser_usb_wait_msg(dev, CMD_GET_SOFTWARE_INFO_REPLY, &msg); 459 if (err) 460 return err; 461 462 dev->fw_version = le32_to_cpu(msg.u.softinfo.fw_version); 463 464 return 0; 465} 466 467static int kvaser_usb_get_card_info(struct kvaser_usb *dev) 468{ 469 struct kvaser_msg msg; 470 int err; 471 472 err = kvaser_usb_send_simple_msg(dev, CMD_GET_CARD_INFO, 0); 473 if (err) 474 return err; 475 476 err = kvaser_usb_wait_msg(dev, CMD_GET_CARD_INFO_REPLY, &msg); 477 if (err) 478 return err; 479 480 dev->nchannels = msg.u.cardinfo.nchannels; 481 if (dev->nchannels > MAX_NET_DEVICES) 482 return -EINVAL; 483 484 return 0; 485} 486 487static void kvaser_usb_tx_acknowledge(const struct kvaser_usb *dev, 488 const struct kvaser_msg *msg) 489{ 490 struct net_device_stats *stats; 491 struct kvaser_usb_tx_urb_context *context; 492 struct kvaser_usb_net_priv *priv; 493 struct sk_buff *skb; 494 struct can_frame *cf; 495 u8 channel = msg->u.tx_acknowledge.channel; 496 u8 tid = msg->u.tx_acknowledge.tid; 497 498 if (channel >= dev->nchannels) { 499 dev_err(dev->udev->dev.parent, 500 "Invalid channel number (%d)\n", channel); 501 return; 502 } 503 504 priv = dev->nets[channel]; 505 506 if (!netif_device_present(priv->netdev)) 507 return; 508 509 stats = &priv->netdev->stats; 510 511 context = &priv->tx_contexts[tid % MAX_TX_URBS]; 512 513 /* Sometimes the state change doesn't come after a bus-off event */ 514 if (priv->can.restart_ms && 515 (priv->can.state >= CAN_STATE_BUS_OFF)) { 516 skb = alloc_can_err_skb(priv->netdev, &cf); 517 if (skb) { 518 cf->can_id |= CAN_ERR_RESTARTED; 519 netif_rx(skb); 520 521 stats->rx_packets++; 522 stats->rx_bytes += cf->can_dlc; 523 } else { 524 netdev_err(priv->netdev, 525 "No memory left for err_skb\n"); 526 } 527 528 priv->can.can_stats.restarts++; 529 netif_carrier_on(priv->netdev); 530 531 priv->can.state = CAN_STATE_ERROR_ACTIVE; 532 } 533 534 stats->tx_packets++; 535 stats->tx_bytes += context->dlc; 536 can_get_echo_skb(priv->netdev, context->echo_index); 537 538 context->echo_index = MAX_TX_URBS; 539 atomic_dec(&priv->active_tx_urbs); 540 541 netif_wake_queue(priv->netdev); 542} 543 544static void kvaser_usb_simple_msg_callback(struct urb *urb) 545{ 546 struct net_device *netdev = urb->context; 547 548 kfree(urb->transfer_buffer); 549 550 if (urb->status) 551 netdev_warn(netdev, "urb status received: %d\n", 552 urb->status); 553} 554 555static int kvaser_usb_simple_msg_async(struct kvaser_usb_net_priv *priv, 556 u8 msg_id) 557{ 558 struct kvaser_usb *dev = priv->dev; 559 struct net_device *netdev = priv->netdev; 560 struct kvaser_msg *msg; 561 struct urb *urb; 562 void *buf; 563 int err; 564 565 urb = usb_alloc_urb(0, GFP_ATOMIC); 566 if (!urb) { 567 netdev_err(netdev, "No memory left for URBs\n"); 568 return -ENOMEM; 569 } 570 571 buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC); 572 if (!buf) { 573 usb_free_urb(urb); 574 return -ENOMEM; 575 } 576 577 msg = (struct kvaser_msg *)buf; 578 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_simple); 579 msg->id = msg_id; 580 msg->u.simple.channel = priv->channel; 581 582 usb_fill_bulk_urb(urb, dev->udev, 583 usb_sndbulkpipe(dev->udev, 584 dev->bulk_out->bEndpointAddress), 585 buf, msg->len, 586 kvaser_usb_simple_msg_callback, priv); 587 usb_anchor_urb(urb, &priv->tx_submitted); 588 589 err = usb_submit_urb(urb, GFP_ATOMIC); 590 if (err) { 591 netdev_err(netdev, "Error transmitting URB\n"); 592 usb_unanchor_urb(urb); 593 usb_free_urb(urb); 594 kfree(buf); 595 return err; 596 } 597 598 usb_free_urb(urb); 599 600 return 0; 601} 602 603static void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv *priv) 604{ 605 int i; 606 607 usb_kill_anchored_urbs(&priv->tx_submitted); 608 atomic_set(&priv->active_tx_urbs, 0); 609 610 for (i = 0; i < MAX_TX_URBS; i++) 611 priv->tx_contexts[i].echo_index = MAX_TX_URBS; 612} 613 614static void kvaser_usb_rx_error(const struct kvaser_usb *dev, 615 const struct kvaser_msg *msg) 616{ 617 struct can_frame *cf; 618 struct sk_buff *skb; 619 struct net_device_stats *stats; 620 struct kvaser_usb_net_priv *priv; 621 unsigned int new_state; 622 u8 channel, status, txerr, rxerr, error_factor; 623 624 switch (msg->id) { 625 case CMD_CAN_ERROR_EVENT: 626 channel = msg->u.error_event.channel; 627 status = msg->u.error_event.status; 628 txerr = msg->u.error_event.tx_errors_count; 629 rxerr = msg->u.error_event.rx_errors_count; 630 error_factor = msg->u.error_event.error_factor; 631 break; 632 case CMD_LOG_MESSAGE: 633 channel = msg->u.log_message.channel; 634 status = msg->u.log_message.data[0]; 635 txerr = msg->u.log_message.data[2]; 636 rxerr = msg->u.log_message.data[3]; 637 error_factor = msg->u.log_message.data[1]; 638 break; 639 case CMD_CHIP_STATE_EVENT: 640 channel = msg->u.chip_state_event.channel; 641 status = msg->u.chip_state_event.status; 642 txerr = msg->u.chip_state_event.tx_errors_count; 643 rxerr = msg->u.chip_state_event.rx_errors_count; 644 error_factor = 0; 645 break; 646 default: 647 dev_err(dev->udev->dev.parent, "Invalid msg id (%d)\n", 648 msg->id); 649 return; 650 } 651 652 if (channel >= dev->nchannels) { 653 dev_err(dev->udev->dev.parent, 654 "Invalid channel number (%d)\n", channel); 655 return; 656 } 657 658 priv = dev->nets[channel]; 659 stats = &priv->netdev->stats; 660 661 if (status & M16C_STATE_BUS_RESET) { 662 kvaser_usb_unlink_tx_urbs(priv); 663 return; 664 } 665 666 skb = alloc_can_err_skb(priv->netdev, &cf); 667 if (!skb) { 668 stats->rx_dropped++; 669 return; 670 } 671 672 new_state = priv->can.state; 673 674 netdev_dbg(priv->netdev, "Error status: 0x%02x\n", status); 675 676 if (status & M16C_STATE_BUS_OFF) { 677 cf->can_id |= CAN_ERR_BUSOFF; 678 679 priv->can.can_stats.bus_off++; 680 if (!priv->can.restart_ms) 681 kvaser_usb_simple_msg_async(priv, CMD_STOP_CHIP); 682 683 netif_carrier_off(priv->netdev); 684 685 new_state = CAN_STATE_BUS_OFF; 686 } else if (status & M16C_STATE_BUS_PASSIVE) { 687 if (priv->can.state != CAN_STATE_ERROR_PASSIVE) { 688 cf->can_id |= CAN_ERR_CRTL; 689 690 if (txerr || rxerr) 691 cf->data[1] = (txerr > rxerr) 692 ? CAN_ERR_CRTL_TX_PASSIVE 693 : CAN_ERR_CRTL_RX_PASSIVE; 694 else 695 cf->data[1] = CAN_ERR_CRTL_TX_PASSIVE | 696 CAN_ERR_CRTL_RX_PASSIVE; 697 698 priv->can.can_stats.error_passive++; 699 } 700 701 new_state = CAN_STATE_ERROR_PASSIVE; 702 } 703 704 if (status == M16C_STATE_BUS_ERROR) { 705 if ((priv->can.state < CAN_STATE_ERROR_WARNING) && 706 ((txerr >= 96) || (rxerr >= 96))) { 707 cf->can_id |= CAN_ERR_CRTL; 708 cf->data[1] = (txerr > rxerr) 709 ? CAN_ERR_CRTL_TX_WARNING 710 : CAN_ERR_CRTL_RX_WARNING; 711 712 priv->can.can_stats.error_warning++; 713 new_state = CAN_STATE_ERROR_WARNING; 714 } else if (priv->can.state > CAN_STATE_ERROR_ACTIVE) { 715 cf->can_id |= CAN_ERR_PROT; 716 cf->data[2] = CAN_ERR_PROT_ACTIVE; 717 718 new_state = CAN_STATE_ERROR_ACTIVE; 719 } 720 } 721 722 if (!status) { 723 cf->can_id |= CAN_ERR_PROT; 724 cf->data[2] = CAN_ERR_PROT_ACTIVE; 725 726 new_state = CAN_STATE_ERROR_ACTIVE; 727 } 728 729 if (priv->can.restart_ms && 730 (priv->can.state >= CAN_STATE_BUS_OFF) && 731 (new_state < CAN_STATE_BUS_OFF)) { 732 cf->can_id |= CAN_ERR_RESTARTED; 733 netif_carrier_on(priv->netdev); 734 735 priv->can.can_stats.restarts++; 736 } 737 738 if (error_factor) { 739 priv->can.can_stats.bus_error++; 740 stats->rx_errors++; 741 742 cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT; 743 744 if (error_factor & M16C_EF_ACKE) 745 cf->data[3] |= (CAN_ERR_PROT_LOC_ACK); 746 if (error_factor & M16C_EF_CRCE) 747 cf->data[3] |= (CAN_ERR_PROT_LOC_CRC_SEQ | 748 CAN_ERR_PROT_LOC_CRC_DEL); 749 if (error_factor & M16C_EF_FORME) 750 cf->data[2] |= CAN_ERR_PROT_FORM; 751 if (error_factor & M16C_EF_STFE) 752 cf->data[2] |= CAN_ERR_PROT_STUFF; 753 if (error_factor & M16C_EF_BITE0) 754 cf->data[2] |= CAN_ERR_PROT_BIT0; 755 if (error_factor & M16C_EF_BITE1) 756 cf->data[2] |= CAN_ERR_PROT_BIT1; 757 if (error_factor & M16C_EF_TRE) 758 cf->data[2] |= CAN_ERR_PROT_TX; 759 } 760 761 cf->data[6] = txerr; 762 cf->data[7] = rxerr; 763 764 priv->bec.txerr = txerr; 765 priv->bec.rxerr = rxerr; 766 767 priv->can.state = new_state; 768 769 netif_rx(skb); 770 771 stats->rx_packets++; 772 stats->rx_bytes += cf->can_dlc; 773} 774 775static void kvaser_usb_rx_can_err(const struct kvaser_usb_net_priv *priv, 776 const struct kvaser_msg *msg) 777{ 778 struct can_frame *cf; 779 struct sk_buff *skb; 780 struct net_device_stats *stats = &priv->netdev->stats; 781 782 if (msg->u.rx_can.flag & (MSG_FLAG_ERROR_FRAME | 783 MSG_FLAG_NERR)) { 784 netdev_err(priv->netdev, "Unknow error (flags: 0x%02x)\n", 785 msg->u.rx_can.flag); 786 787 stats->rx_errors++; 788 return; 789 } 790 791 if (msg->u.rx_can.flag & MSG_FLAG_OVERRUN) { 792 skb = alloc_can_err_skb(priv->netdev, &cf); 793 if (!skb) { 794 stats->rx_dropped++; 795 return; 796 } 797 798 cf->can_id |= CAN_ERR_CRTL; 799 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 800 801 stats->rx_over_errors++; 802 stats->rx_errors++; 803 804 netif_rx(skb); 805 806 stats->rx_packets++; 807 stats->rx_bytes += cf->can_dlc; 808 } 809} 810 811static void kvaser_usb_rx_can_msg(const struct kvaser_usb *dev, 812 const struct kvaser_msg *msg) 813{ 814 struct kvaser_usb_net_priv *priv; 815 struct can_frame *cf; 816 struct sk_buff *skb; 817 struct net_device_stats *stats; 818 u8 channel = msg->u.rx_can.channel; 819 820 if (channel >= dev->nchannels) { 821 dev_err(dev->udev->dev.parent, 822 "Invalid channel number (%d)\n", channel); 823 return; 824 } 825 826 priv = dev->nets[channel]; 827 stats = &priv->netdev->stats; 828 829 if ((msg->u.rx_can.flag & MSG_FLAG_ERROR_FRAME) && 830 (msg->id == CMD_LOG_MESSAGE)) { 831 kvaser_usb_rx_error(dev, msg); 832 return; 833 } else if (msg->u.rx_can.flag & (MSG_FLAG_ERROR_FRAME | 834 MSG_FLAG_NERR | 835 MSG_FLAG_OVERRUN)) { 836 kvaser_usb_rx_can_err(priv, msg); 837 return; 838 } else if (msg->u.rx_can.flag & ~MSG_FLAG_REMOTE_FRAME) { 839 netdev_warn(priv->netdev, 840 "Unhandled frame (flags: 0x%02x)", 841 msg->u.rx_can.flag); 842 return; 843 } 844 845 skb = alloc_can_skb(priv->netdev, &cf); 846 if (!skb) { 847 stats->tx_dropped++; 848 return; 849 } 850 851 if (msg->id == CMD_LOG_MESSAGE) { 852 cf->can_id = le32_to_cpu(msg->u.log_message.id); 853 if (cf->can_id & KVASER_EXTENDED_FRAME) 854 cf->can_id &= CAN_EFF_MASK | CAN_EFF_FLAG; 855 else 856 cf->can_id &= CAN_SFF_MASK; 857 858 cf->can_dlc = get_can_dlc(msg->u.log_message.dlc); 859 860 if (msg->u.log_message.flags & MSG_FLAG_REMOTE_FRAME) 861 cf->can_id |= CAN_RTR_FLAG; 862 else 863 memcpy(cf->data, &msg->u.log_message.data, 864 cf->can_dlc); 865 } else { 866 cf->can_id = ((msg->u.rx_can.msg[0] & 0x1f) << 6) | 867 (msg->u.rx_can.msg[1] & 0x3f); 868 869 if (msg->id == CMD_RX_EXT_MESSAGE) { 870 cf->can_id <<= 18; 871 cf->can_id |= ((msg->u.rx_can.msg[2] & 0x0f) << 14) | 872 ((msg->u.rx_can.msg[3] & 0xff) << 6) | 873 (msg->u.rx_can.msg[4] & 0x3f); 874 cf->can_id |= CAN_EFF_FLAG; 875 } 876 877 cf->can_dlc = get_can_dlc(msg->u.rx_can.msg[5]); 878 879 if (msg->u.rx_can.flag & MSG_FLAG_REMOTE_FRAME) 880 cf->can_id |= CAN_RTR_FLAG; 881 else 882 memcpy(cf->data, &msg->u.rx_can.msg[6], 883 cf->can_dlc); 884 } 885 886 netif_rx(skb); 887 888 stats->rx_packets++; 889 stats->rx_bytes += cf->can_dlc; 890} 891 892static void kvaser_usb_start_chip_reply(const struct kvaser_usb *dev, 893 const struct kvaser_msg *msg) 894{ 895 struct kvaser_usb_net_priv *priv; 896 u8 channel = msg->u.simple.channel; 897 898 if (channel >= dev->nchannels) { 899 dev_err(dev->udev->dev.parent, 900 "Invalid channel number (%d)\n", channel); 901 return; 902 } 903 904 priv = dev->nets[channel]; 905 906 if (completion_done(&priv->start_comp) && 907 netif_queue_stopped(priv->netdev)) { 908 netif_wake_queue(priv->netdev); 909 } else { 910 netif_start_queue(priv->netdev); 911 complete(&priv->start_comp); 912 } 913} 914 915static void kvaser_usb_stop_chip_reply(const struct kvaser_usb *dev, 916 const struct kvaser_msg *msg) 917{ 918 struct kvaser_usb_net_priv *priv; 919 u8 channel = msg->u.simple.channel; 920 921 if (channel >= dev->nchannels) { 922 dev_err(dev->udev->dev.parent, 923 "Invalid channel number (%d)\n", channel); 924 return; 925 } 926 927 priv = dev->nets[channel]; 928 929 complete(&priv->stop_comp); 930} 931 932static void kvaser_usb_handle_message(const struct kvaser_usb *dev, 933 const struct kvaser_msg *msg) 934{ 935 switch (msg->id) { 936 case CMD_START_CHIP_REPLY: 937 kvaser_usb_start_chip_reply(dev, msg); 938 break; 939 940 case CMD_STOP_CHIP_REPLY: 941 kvaser_usb_stop_chip_reply(dev, msg); 942 break; 943 944 case CMD_RX_STD_MESSAGE: 945 case CMD_RX_EXT_MESSAGE: 946 case CMD_LOG_MESSAGE: 947 kvaser_usb_rx_can_msg(dev, msg); 948 break; 949 950 case CMD_CHIP_STATE_EVENT: 951 case CMD_CAN_ERROR_EVENT: 952 kvaser_usb_rx_error(dev, msg); 953 break; 954 955 case CMD_TX_ACKNOWLEDGE: 956 kvaser_usb_tx_acknowledge(dev, msg); 957 break; 958 959 default: 960 dev_warn(dev->udev->dev.parent, 961 "Unhandled message (%d)\n", msg->id); 962 break; 963 } 964} 965 966static void kvaser_usb_read_bulk_callback(struct urb *urb) 967{ 968 struct kvaser_usb *dev = urb->context; 969 struct kvaser_msg *msg; 970 int pos = 0; 971 int err, i; 972 973 switch (urb->status) { 974 case 0: 975 break; 976 case -ENOENT: 977 case -ESHUTDOWN: 978 return; 979 default: 980 dev_info(dev->udev->dev.parent, "Rx URB aborted (%d)\n", 981 urb->status); 982 goto resubmit_urb; 983 } 984 985 while (pos <= urb->actual_length - MSG_HEADER_LEN) { 986 msg = urb->transfer_buffer + pos; 987 988 if (!msg->len) 989 break; 990 991 if (pos + msg->len > urb->actual_length) { 992 dev_err(dev->udev->dev.parent, "Format error\n"); 993 break; 994 } 995 996 kvaser_usb_handle_message(dev, msg); 997 998 pos += msg->len; 999 } 1000 1001resubmit_urb: 1002 usb_fill_bulk_urb(urb, dev->udev, 1003 usb_rcvbulkpipe(dev->udev, 1004 dev->bulk_in->bEndpointAddress), 1005 urb->transfer_buffer, RX_BUFFER_SIZE, 1006 kvaser_usb_read_bulk_callback, dev); 1007 1008 err = usb_submit_urb(urb, GFP_ATOMIC); 1009 if (err == -ENODEV) { 1010 for (i = 0; i < dev->nchannels; i++) { 1011 if (!dev->nets[i]) 1012 continue; 1013 1014 netif_device_detach(dev->nets[i]->netdev); 1015 } 1016 } else if (err) { 1017 dev_err(dev->udev->dev.parent, 1018 "Failed resubmitting read bulk urb: %d\n", err); 1019 } 1020 1021 return; 1022} 1023 1024static int kvaser_usb_setup_rx_urbs(struct kvaser_usb *dev) 1025{ 1026 int i, err = 0; 1027 1028 if (dev->rxinitdone) 1029 return 0; 1030 1031 for (i = 0; i < MAX_RX_URBS; i++) { 1032 struct urb *urb = NULL; 1033 u8 *buf = NULL; 1034 dma_addr_t buf_dma; 1035 1036 urb = usb_alloc_urb(0, GFP_KERNEL); 1037 if (!urb) { 1038 dev_warn(dev->udev->dev.parent, 1039 "No memory left for URBs\n"); 1040 err = -ENOMEM; 1041 break; 1042 } 1043 1044 buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE, 1045 GFP_KERNEL, &buf_dma); 1046 if (!buf) { 1047 dev_warn(dev->udev->dev.parent, 1048 "No memory left for USB buffer\n"); 1049 usb_free_urb(urb); 1050 err = -ENOMEM; 1051 break; 1052 } 1053 1054 usb_fill_bulk_urb(urb, dev->udev, 1055 usb_rcvbulkpipe(dev->udev, 1056 dev->bulk_in->bEndpointAddress), 1057 buf, RX_BUFFER_SIZE, 1058 kvaser_usb_read_bulk_callback, 1059 dev); 1060 urb->transfer_dma = buf_dma; 1061 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1062 usb_anchor_urb(urb, &dev->rx_submitted); 1063 1064 err = usb_submit_urb(urb, GFP_KERNEL); 1065 if (err) { 1066 usb_unanchor_urb(urb); 1067 usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf, 1068 buf_dma); 1069 usb_free_urb(urb); 1070 break; 1071 } 1072 1073 dev->rxbuf[i] = buf; 1074 dev->rxbuf_dma[i] = buf_dma; 1075 1076 usb_free_urb(urb); 1077 } 1078 1079 if (i == 0) { 1080 dev_warn(dev->udev->dev.parent, 1081 "Cannot setup read URBs, error %d\n", err); 1082 return err; 1083 } else if (i < MAX_RX_URBS) { 1084 dev_warn(dev->udev->dev.parent, 1085 "RX performances may be slow\n"); 1086 } 1087 1088 dev->rxinitdone = true; 1089 1090 return 0; 1091} 1092 1093static int kvaser_usb_set_opt_mode(const struct kvaser_usb_net_priv *priv) 1094{ 1095 struct kvaser_msg *msg; 1096 int rc; 1097 1098 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 1099 if (!msg) 1100 return -ENOMEM; 1101 1102 msg->id = CMD_SET_CTRL_MODE; 1103 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_ctrl_mode); 1104 msg->u.ctrl_mode.tid = 0xff; 1105 msg->u.ctrl_mode.channel = priv->channel; 1106 1107 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) 1108 msg->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT; 1109 else 1110 msg->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL; 1111 1112 rc = kvaser_usb_send_msg(priv->dev, msg); 1113 1114 kfree(msg); 1115 return rc; 1116} 1117 1118static int kvaser_usb_start_chip(struct kvaser_usb_net_priv *priv) 1119{ 1120 int err; 1121 1122 init_completion(&priv->start_comp); 1123 1124 err = kvaser_usb_send_simple_msg(priv->dev, CMD_START_CHIP, 1125 priv->channel); 1126 if (err) 1127 return err; 1128 1129 if (!wait_for_completion_timeout(&priv->start_comp, 1130 msecs_to_jiffies(START_TIMEOUT))) 1131 return -ETIMEDOUT; 1132 1133 return 0; 1134} 1135 1136static int kvaser_usb_open(struct net_device *netdev) 1137{ 1138 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1139 struct kvaser_usb *dev = priv->dev; 1140 int err; 1141 1142 err = open_candev(netdev); 1143 if (err) 1144 return err; 1145 1146 err = kvaser_usb_setup_rx_urbs(dev); 1147 if (err) 1148 goto error; 1149 1150 err = kvaser_usb_set_opt_mode(priv); 1151 if (err) 1152 goto error; 1153 1154 err = kvaser_usb_start_chip(priv); 1155 if (err) { 1156 netdev_warn(netdev, "Cannot start device, error %d\n", err); 1157 goto error; 1158 } 1159 1160 priv->can.state = CAN_STATE_ERROR_ACTIVE; 1161 1162 return 0; 1163 1164error: 1165 close_candev(netdev); 1166 return err; 1167} 1168 1169static void kvaser_usb_unlink_all_urbs(struct kvaser_usb *dev) 1170{ 1171 int i; 1172 1173 usb_kill_anchored_urbs(&dev->rx_submitted); 1174 1175 for (i = 0; i < MAX_RX_URBS; i++) 1176 usb_free_coherent(dev->udev, RX_BUFFER_SIZE, 1177 dev->rxbuf[i], 1178 dev->rxbuf_dma[i]); 1179 1180 for (i = 0; i < MAX_NET_DEVICES; i++) { 1181 struct kvaser_usb_net_priv *priv = dev->nets[i]; 1182 1183 if (priv) 1184 kvaser_usb_unlink_tx_urbs(priv); 1185 } 1186} 1187 1188static int kvaser_usb_stop_chip(struct kvaser_usb_net_priv *priv) 1189{ 1190 int err; 1191 1192 init_completion(&priv->stop_comp); 1193 1194 err = kvaser_usb_send_simple_msg(priv->dev, CMD_STOP_CHIP, 1195 priv->channel); 1196 if (err) 1197 return err; 1198 1199 if (!wait_for_completion_timeout(&priv->stop_comp, 1200 msecs_to_jiffies(STOP_TIMEOUT))) 1201 return -ETIMEDOUT; 1202 1203 return 0; 1204} 1205 1206static int kvaser_usb_flush_queue(struct kvaser_usb_net_priv *priv) 1207{ 1208 struct kvaser_msg *msg; 1209 int rc; 1210 1211 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 1212 if (!msg) 1213 return -ENOMEM; 1214 1215 msg->id = CMD_FLUSH_QUEUE; 1216 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_flush_queue); 1217 msg->u.flush_queue.channel = priv->channel; 1218 msg->u.flush_queue.flags = 0x00; 1219 1220 rc = kvaser_usb_send_msg(priv->dev, msg); 1221 1222 kfree(msg); 1223 return rc; 1224} 1225 1226static int kvaser_usb_close(struct net_device *netdev) 1227{ 1228 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1229 struct kvaser_usb *dev = priv->dev; 1230 int err; 1231 1232 netif_stop_queue(netdev); 1233 1234 err = kvaser_usb_flush_queue(priv); 1235 if (err) 1236 netdev_warn(netdev, "Cannot flush queue, error %d\n", err); 1237 1238 if (kvaser_usb_send_simple_msg(dev, CMD_RESET_CHIP, priv->channel)) 1239 netdev_warn(netdev, "Cannot reset card, error %d\n", err); 1240 1241 err = kvaser_usb_stop_chip(priv); 1242 if (err) 1243 netdev_warn(netdev, "Cannot stop device, error %d\n", err); 1244 1245 priv->can.state = CAN_STATE_STOPPED; 1246 close_candev(priv->netdev); 1247 1248 return 0; 1249} 1250 1251static void kvaser_usb_write_bulk_callback(struct urb *urb) 1252{ 1253 struct kvaser_usb_tx_urb_context *context = urb->context; 1254 struct kvaser_usb_net_priv *priv; 1255 struct net_device *netdev; 1256 1257 if (WARN_ON(!context)) 1258 return; 1259 1260 priv = context->priv; 1261 netdev = priv->netdev; 1262 1263 kfree(urb->transfer_buffer); 1264 1265 if (!netif_device_present(netdev)) 1266 return; 1267 1268 if (urb->status) 1269 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status); 1270} 1271 1272static netdev_tx_t kvaser_usb_start_xmit(struct sk_buff *skb, 1273 struct net_device *netdev) 1274{ 1275 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1276 struct kvaser_usb *dev = priv->dev; 1277 struct net_device_stats *stats = &netdev->stats; 1278 struct can_frame *cf = (struct can_frame *)skb->data; 1279 struct kvaser_usb_tx_urb_context *context = NULL; 1280 struct urb *urb; 1281 void *buf; 1282 struct kvaser_msg *msg; 1283 int i, err; 1284 int ret = NETDEV_TX_OK; 1285 1286 if (can_dropped_invalid_skb(netdev, skb)) 1287 return NETDEV_TX_OK; 1288 1289 urb = usb_alloc_urb(0, GFP_ATOMIC); 1290 if (!urb) { 1291 netdev_err(netdev, "No memory left for URBs\n"); 1292 stats->tx_dropped++; 1293 goto nourbmem; 1294 } 1295 1296 buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC); 1297 if (!buf) { 1298 stats->tx_dropped++; 1299 goto nobufmem; 1300 } 1301 1302 msg = buf; 1303 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_tx_can); 1304 msg->u.tx_can.flags = 0; 1305 msg->u.tx_can.channel = priv->channel; 1306 1307 if (cf->can_id & CAN_EFF_FLAG) { 1308 msg->id = CMD_TX_EXT_MESSAGE; 1309 msg->u.tx_can.msg[0] = (cf->can_id >> 24) & 0x1f; 1310 msg->u.tx_can.msg[1] = (cf->can_id >> 18) & 0x3f; 1311 msg->u.tx_can.msg[2] = (cf->can_id >> 14) & 0x0f; 1312 msg->u.tx_can.msg[3] = (cf->can_id >> 6) & 0xff; 1313 msg->u.tx_can.msg[4] = cf->can_id & 0x3f; 1314 } else { 1315 msg->id = CMD_TX_STD_MESSAGE; 1316 msg->u.tx_can.msg[0] = (cf->can_id >> 6) & 0x1f; 1317 msg->u.tx_can.msg[1] = cf->can_id & 0x3f; 1318 } 1319 1320 msg->u.tx_can.msg[5] = cf->can_dlc; 1321 memcpy(&msg->u.tx_can.msg[6], cf->data, cf->can_dlc); 1322 1323 if (cf->can_id & CAN_RTR_FLAG) 1324 msg->u.tx_can.flags |= MSG_FLAG_REMOTE_FRAME; 1325 1326 for (i = 0; i < ARRAY_SIZE(priv->tx_contexts); i++) { 1327 if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) { 1328 context = &priv->tx_contexts[i]; 1329 break; 1330 } 1331 } 1332 1333 if (!context) { 1334 netdev_warn(netdev, "cannot find free context\n"); 1335 ret = NETDEV_TX_BUSY; 1336 goto releasebuf; 1337 } 1338 1339 context->priv = priv; 1340 context->echo_index = i; 1341 context->dlc = cf->can_dlc; 1342 1343 msg->u.tx_can.tid = context->echo_index; 1344 1345 usb_fill_bulk_urb(urb, dev->udev, 1346 usb_sndbulkpipe(dev->udev, 1347 dev->bulk_out->bEndpointAddress), 1348 buf, msg->len, 1349 kvaser_usb_write_bulk_callback, context); 1350 usb_anchor_urb(urb, &priv->tx_submitted); 1351 1352 can_put_echo_skb(skb, netdev, context->echo_index); 1353 1354 atomic_inc(&priv->active_tx_urbs); 1355 1356 if (atomic_read(&priv->active_tx_urbs) >= MAX_TX_URBS) 1357 netif_stop_queue(netdev); 1358 1359 err = usb_submit_urb(urb, GFP_ATOMIC); 1360 if (unlikely(err)) { 1361 can_free_echo_skb(netdev, context->echo_index); 1362 1363 skb = NULL; /* set to NULL to avoid double free in 1364 * dev_kfree_skb(skb) */ 1365 1366 atomic_dec(&priv->active_tx_urbs); 1367 usb_unanchor_urb(urb); 1368 1369 stats->tx_dropped++; 1370 1371 if (err == -ENODEV) 1372 netif_device_detach(netdev); 1373 else 1374 netdev_warn(netdev, "Failed tx_urb %d\n", err); 1375 1376 goto releasebuf; 1377 } 1378 1379 usb_free_urb(urb); 1380 1381 return NETDEV_TX_OK; 1382 1383releasebuf: 1384 kfree(buf); 1385nobufmem: 1386 usb_free_urb(urb); 1387nourbmem: 1388 dev_kfree_skb(skb); 1389 return ret; 1390} 1391 1392static const struct net_device_ops kvaser_usb_netdev_ops = { 1393 .ndo_open = kvaser_usb_open, 1394 .ndo_stop = kvaser_usb_close, 1395 .ndo_start_xmit = kvaser_usb_start_xmit, 1396 .ndo_change_mtu = can_change_mtu, 1397}; 1398 1399static const struct can_bittiming_const kvaser_usb_bittiming_const = { 1400 .name = "kvaser_usb", 1401 .tseg1_min = KVASER_USB_TSEG1_MIN, 1402 .tseg1_max = KVASER_USB_TSEG1_MAX, 1403 .tseg2_min = KVASER_USB_TSEG2_MIN, 1404 .tseg2_max = KVASER_USB_TSEG2_MAX, 1405 .sjw_max = KVASER_USB_SJW_MAX, 1406 .brp_min = KVASER_USB_BRP_MIN, 1407 .brp_max = KVASER_USB_BRP_MAX, 1408 .brp_inc = KVASER_USB_BRP_INC, 1409}; 1410 1411static int kvaser_usb_set_bittiming(struct net_device *netdev) 1412{ 1413 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1414 struct can_bittiming *bt = &priv->can.bittiming; 1415 struct kvaser_usb *dev = priv->dev; 1416 struct kvaser_msg *msg; 1417 int rc; 1418 1419 msg = kmalloc(sizeof(*msg), GFP_KERNEL); 1420 if (!msg) 1421 return -ENOMEM; 1422 1423 msg->id = CMD_SET_BUS_PARAMS; 1424 msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_busparams); 1425 msg->u.busparams.channel = priv->channel; 1426 msg->u.busparams.tid = 0xff; 1427 msg->u.busparams.bitrate = cpu_to_le32(bt->bitrate); 1428 msg->u.busparams.sjw = bt->sjw; 1429 msg->u.busparams.tseg1 = bt->prop_seg + bt->phase_seg1; 1430 msg->u.busparams.tseg2 = bt->phase_seg2; 1431 1432 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) 1433 msg->u.busparams.no_samp = 3; 1434 else 1435 msg->u.busparams.no_samp = 1; 1436 1437 rc = kvaser_usb_send_msg(dev, msg); 1438 1439 kfree(msg); 1440 return rc; 1441} 1442 1443static int kvaser_usb_set_mode(struct net_device *netdev, 1444 enum can_mode mode) 1445{ 1446 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1447 int err; 1448 1449 switch (mode) { 1450 case CAN_MODE_START: 1451 err = kvaser_usb_simple_msg_async(priv, CMD_START_CHIP); 1452 if (err) 1453 return err; 1454 break; 1455 default: 1456 return -EOPNOTSUPP; 1457 } 1458 1459 return 0; 1460} 1461 1462static int kvaser_usb_get_berr_counter(const struct net_device *netdev, 1463 struct can_berr_counter *bec) 1464{ 1465 struct kvaser_usb_net_priv *priv = netdev_priv(netdev); 1466 1467 *bec = priv->bec; 1468 1469 return 0; 1470} 1471 1472static void kvaser_usb_remove_interfaces(struct kvaser_usb *dev) 1473{ 1474 int i; 1475 1476 for (i = 0; i < dev->nchannels; i++) { 1477 if (!dev->nets[i]) 1478 continue; 1479 1480 unregister_netdev(dev->nets[i]->netdev); 1481 } 1482 1483 kvaser_usb_unlink_all_urbs(dev); 1484 1485 for (i = 0; i < dev->nchannels; i++) { 1486 if (!dev->nets[i]) 1487 continue; 1488 1489 free_candev(dev->nets[i]->netdev); 1490 } 1491} 1492 1493static int kvaser_usb_init_one(struct usb_interface *intf, 1494 const struct usb_device_id *id, int channel) 1495{ 1496 struct kvaser_usb *dev = usb_get_intfdata(intf); 1497 struct net_device *netdev; 1498 struct kvaser_usb_net_priv *priv; 1499 int i, err; 1500 1501 netdev = alloc_candev(sizeof(*priv), MAX_TX_URBS); 1502 if (!netdev) { 1503 dev_err(&intf->dev, "Cannot alloc candev\n"); 1504 return -ENOMEM; 1505 } 1506 1507 priv = netdev_priv(netdev); 1508 1509 init_completion(&priv->start_comp); 1510 init_completion(&priv->stop_comp); 1511 1512 init_usb_anchor(&priv->tx_submitted); 1513 atomic_set(&priv->active_tx_urbs, 0); 1514 1515 for (i = 0; i < ARRAY_SIZE(priv->tx_contexts); i++) 1516 priv->tx_contexts[i].echo_index = MAX_TX_URBS; 1517 1518 priv->dev = dev; 1519 priv->netdev = netdev; 1520 priv->channel = channel; 1521 1522 priv->can.state = CAN_STATE_STOPPED; 1523 priv->can.clock.freq = CAN_USB_CLOCK; 1524 priv->can.bittiming_const = &kvaser_usb_bittiming_const; 1525 priv->can.do_set_bittiming = kvaser_usb_set_bittiming; 1526 priv->can.do_set_mode = kvaser_usb_set_mode; 1527 if (id->driver_info & KVASER_HAS_TXRX_ERRORS) 1528 priv->can.do_get_berr_counter = kvaser_usb_get_berr_counter; 1529 priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES; 1530 if (id->driver_info & KVASER_HAS_SILENT_MODE) 1531 priv->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY; 1532 1533 netdev->flags |= IFF_ECHO; 1534 1535 netdev->netdev_ops = &kvaser_usb_netdev_ops; 1536 1537 SET_NETDEV_DEV(netdev, &intf->dev); 1538 netdev->dev_id = channel; 1539 1540 dev->nets[channel] = priv; 1541 1542 err = register_candev(netdev); 1543 if (err) { 1544 dev_err(&intf->dev, "Failed to register can device\n"); 1545 free_candev(netdev); 1546 dev->nets[channel] = NULL; 1547 return err; 1548 } 1549 1550 netdev_dbg(netdev, "device registered\n"); 1551 1552 return 0; 1553} 1554 1555static int kvaser_usb_get_endpoints(const struct usb_interface *intf, 1556 struct usb_endpoint_descriptor **in, 1557 struct usb_endpoint_descriptor **out) 1558{ 1559 const struct usb_host_interface *iface_desc; 1560 struct usb_endpoint_descriptor *endpoint; 1561 int i; 1562 1563 iface_desc = &intf->altsetting[0]; 1564 1565 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 1566 endpoint = &iface_desc->endpoint[i].desc; 1567 1568 if (!*in && usb_endpoint_is_bulk_in(endpoint)) 1569 *in = endpoint; 1570 1571 if (!*out && usb_endpoint_is_bulk_out(endpoint)) 1572 *out = endpoint; 1573 1574 /* use first bulk endpoint for in and out */ 1575 if (*in && *out) 1576 return 0; 1577 } 1578 1579 return -ENODEV; 1580} 1581 1582static int kvaser_usb_probe(struct usb_interface *intf, 1583 const struct usb_device_id *id) 1584{ 1585 struct kvaser_usb *dev; 1586 int err = -ENOMEM; 1587 int i; 1588 1589 dev = devm_kzalloc(&intf->dev, sizeof(*dev), GFP_KERNEL); 1590 if (!dev) 1591 return -ENOMEM; 1592 1593 err = kvaser_usb_get_endpoints(intf, &dev->bulk_in, &dev->bulk_out); 1594 if (err) { 1595 dev_err(&intf->dev, "Cannot get usb endpoint(s)"); 1596 return err; 1597 } 1598 1599 dev->udev = interface_to_usbdev(intf); 1600 1601 init_usb_anchor(&dev->rx_submitted); 1602 1603 usb_set_intfdata(intf, dev); 1604 1605 for (i = 0; i < MAX_NET_DEVICES; i++) 1606 kvaser_usb_send_simple_msg(dev, CMD_RESET_CHIP, i); 1607 1608 err = kvaser_usb_get_software_info(dev); 1609 if (err) { 1610 dev_err(&intf->dev, 1611 "Cannot get software infos, error %d\n", err); 1612 return err; 1613 } 1614 1615 err = kvaser_usb_get_card_info(dev); 1616 if (err) { 1617 dev_err(&intf->dev, 1618 "Cannot get card infos, error %d\n", err); 1619 return err; 1620 } 1621 1622 dev_dbg(&intf->dev, "Firmware version: %d.%d.%d\n", 1623 ((dev->fw_version >> 24) & 0xff), 1624 ((dev->fw_version >> 16) & 0xff), 1625 (dev->fw_version & 0xffff)); 1626 1627 for (i = 0; i < dev->nchannels; i++) { 1628 err = kvaser_usb_init_one(intf, id, i); 1629 if (err) { 1630 kvaser_usb_remove_interfaces(dev); 1631 return err; 1632 } 1633 } 1634 1635 return 0; 1636} 1637 1638static void kvaser_usb_disconnect(struct usb_interface *intf) 1639{ 1640 struct kvaser_usb *dev = usb_get_intfdata(intf); 1641 1642 usb_set_intfdata(intf, NULL); 1643 1644 if (!dev) 1645 return; 1646 1647 kvaser_usb_remove_interfaces(dev); 1648} 1649 1650static struct usb_driver kvaser_usb_driver = { 1651 .name = "kvaser_usb", 1652 .probe = kvaser_usb_probe, 1653 .disconnect = kvaser_usb_disconnect, 1654 .id_table = kvaser_usb_table, 1655}; 1656 1657module_usb_driver(kvaser_usb_driver); 1658 1659MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>"); 1660MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices"); 1661MODULE_LICENSE("GPL v2"); 1662