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