1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * CAN driver for PEAK System USB adapters 4 * Derived from the PCAN project file driver/src/pcan_usb_core.c 5 * 6 * Copyright (C) 2003-2010 PEAK System-Technik GmbH 7 * Copyright (C) 2010-2012 Stephane Grosjean <s.grosjean@peak-system.com> 8 * 9 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de> 10 */ 11 #include <linux/init.h> 12 #include <linux/signal.h> 13 #include <linux/slab.h> 14 #include <linux/module.h> 15 #include <linux/netdevice.h> 16 #include <linux/usb.h> 17 #include <linux/ethtool.h> 18 19 #include <linux/can.h> 20 #include <linux/can/dev.h> 21 #include <linux/can/error.h> 22 23 #include "pcan_usb_core.h" 24 25 MODULE_AUTHOR("Stephane Grosjean <s.grosjean@peak-system.com>"); 26 MODULE_DESCRIPTION("CAN driver for PEAK-System USB adapters"); 27 MODULE_LICENSE("GPL v2"); 28 29 /* Table of devices that work with this driver */ 30 static const struct usb_device_id peak_usb_table[] = { 31 { 32 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USB_PRODUCT_ID), 33 .driver_info = (kernel_ulong_t)&pcan_usb, 34 }, { 35 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBPRO_PRODUCT_ID), 36 .driver_info = (kernel_ulong_t)&pcan_usb_pro, 37 }, { 38 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBFD_PRODUCT_ID), 39 .driver_info = (kernel_ulong_t)&pcan_usb_fd, 40 }, { 41 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBPROFD_PRODUCT_ID), 42 .driver_info = (kernel_ulong_t)&pcan_usb_pro_fd, 43 }, { 44 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBCHIP_PRODUCT_ID), 45 .driver_info = (kernel_ulong_t)&pcan_usb_chip, 46 }, { 47 USB_DEVICE(PCAN_USB_VENDOR_ID, PCAN_USBX6_PRODUCT_ID), 48 .driver_info = (kernel_ulong_t)&pcan_usb_x6, 49 }, { 50 /* Terminating entry */ 51 } 52 }; 53 54 MODULE_DEVICE_TABLE(usb, peak_usb_table); 55 56 /* 57 * dump memory 58 */ 59 #define DUMP_WIDTH 16 60 void pcan_dump_mem(char *prompt, void *p, int l) 61 { 62 pr_info("%s dumping %s (%d bytes):\n", 63 PCAN_USB_DRIVER_NAME, prompt ? prompt : "memory", l); 64 print_hex_dump(KERN_INFO, PCAN_USB_DRIVER_NAME " ", DUMP_PREFIX_NONE, 65 DUMP_WIDTH, 1, p, l, false); 66 } 67 68 /* 69 * initialize a time_ref object with usb adapter own settings 70 */ 71 void peak_usb_init_time_ref(struct peak_time_ref *time_ref, 72 const struct peak_usb_adapter *adapter) 73 { 74 if (time_ref) { 75 memset(time_ref, 0, sizeof(struct peak_time_ref)); 76 time_ref->adapter = adapter; 77 } 78 } 79 80 /* 81 * sometimes, another now may be more recent than current one... 82 */ 83 void peak_usb_update_ts_now(struct peak_time_ref *time_ref, u32 ts_now) 84 { 85 time_ref->ts_dev_2 = ts_now; 86 87 /* should wait at least two passes before computing */ 88 if (ktime_to_ns(time_ref->tv_host) > 0) { 89 u32 delta_ts = time_ref->ts_dev_2 - time_ref->ts_dev_1; 90 91 if (time_ref->ts_dev_2 < time_ref->ts_dev_1) 92 delta_ts &= (1 << time_ref->adapter->ts_used_bits) - 1; 93 94 time_ref->ts_total += delta_ts; 95 } 96 } 97 98 /* 99 * register device timestamp as now 100 */ 101 void peak_usb_set_ts_now(struct peak_time_ref *time_ref, u32 ts_now) 102 { 103 if (ktime_to_ns(time_ref->tv_host_0) == 0) { 104 /* use monotonic clock to correctly compute further deltas */ 105 time_ref->tv_host_0 = ktime_get(); 106 time_ref->tv_host = ktime_set(0, 0); 107 } else { 108 /* 109 * delta_us should not be >= 2^32 => delta should be < 4294s 110 * handle 32-bits wrapping here: if count of s. reaches 4200, 111 * reset counters and change time base 112 */ 113 if (ktime_to_ns(time_ref->tv_host)) { 114 ktime_t delta = ktime_sub(time_ref->tv_host, 115 time_ref->tv_host_0); 116 if (ktime_to_ns(delta) > (4200ull * NSEC_PER_SEC)) { 117 time_ref->tv_host_0 = time_ref->tv_host; 118 time_ref->ts_total = 0; 119 } 120 } 121 122 time_ref->tv_host = ktime_get(); 123 time_ref->tick_count++; 124 } 125 126 time_ref->ts_dev_1 = time_ref->ts_dev_2; 127 peak_usb_update_ts_now(time_ref, ts_now); 128 } 129 130 /* 131 * compute time according to current ts and time_ref data 132 */ 133 void peak_usb_get_ts_time(struct peak_time_ref *time_ref, u32 ts, ktime_t *time) 134 { 135 /* protect from getting time before setting now */ 136 if (ktime_to_ns(time_ref->tv_host)) { 137 u64 delta_us; 138 s64 delta_ts = 0; 139 140 /* General case: dev_ts_1 < dev_ts_2 < ts, with: 141 * 142 * - dev_ts_1 = previous sync timestamp 143 * - dev_ts_2 = last sync timestamp 144 * - ts = event timestamp 145 * - ts_period = known sync period (theoretical) 146 * ~ dev_ts2 - dev_ts1 147 * *but*: 148 * 149 * - time counters wrap (see adapter->ts_used_bits) 150 * - sometimes, dev_ts_1 < ts < dev_ts2 151 * 152 * "normal" case (sync time counters increase): 153 * must take into account case when ts wraps (tsw) 154 * 155 * < ts_period > < > 156 * | | | 157 * ---+--------+----+-------0-+--+--> 158 * ts_dev_1 | ts_dev_2 | 159 * ts tsw 160 */ 161 if (time_ref->ts_dev_1 < time_ref->ts_dev_2) { 162 /* case when event time (tsw) wraps */ 163 if (ts < time_ref->ts_dev_1) 164 delta_ts = BIT_ULL(time_ref->adapter->ts_used_bits); 165 166 /* Otherwise, sync time counter (ts_dev_2) has wrapped: 167 * handle case when event time (tsn) hasn't. 168 * 169 * < ts_period > < > 170 * | | | 171 * ---+--------+--0-+---------+--+--> 172 * ts_dev_1 | ts_dev_2 | 173 * tsn ts 174 */ 175 } else if (time_ref->ts_dev_1 < ts) { 176 delta_ts = -BIT_ULL(time_ref->adapter->ts_used_bits); 177 } 178 179 /* add delay between last sync and event timestamps */ 180 delta_ts += (signed int)(ts - time_ref->ts_dev_2); 181 182 /* add time from beginning to last sync */ 183 delta_ts += time_ref->ts_total; 184 185 /* convert ticks number into microseconds */ 186 delta_us = delta_ts * time_ref->adapter->us_per_ts_scale; 187 delta_us >>= time_ref->adapter->us_per_ts_shift; 188 189 *time = ktime_add_us(time_ref->tv_host_0, delta_us); 190 } else { 191 *time = ktime_get(); 192 } 193 } 194 195 /* 196 * post received skb after having set any hw timestamp 197 */ 198 int peak_usb_netif_rx(struct sk_buff *skb, 199 struct peak_time_ref *time_ref, u32 ts_low) 200 { 201 struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb); 202 203 peak_usb_get_ts_time(time_ref, ts_low, &hwts->hwtstamp); 204 205 return netif_rx(skb); 206 } 207 208 /* 209 * callback for bulk Rx urb 210 */ 211 static void peak_usb_read_bulk_callback(struct urb *urb) 212 { 213 struct peak_usb_device *dev = urb->context; 214 struct net_device *netdev; 215 int err; 216 217 netdev = dev->netdev; 218 219 if (!netif_device_present(netdev)) 220 return; 221 222 /* check reception status */ 223 switch (urb->status) { 224 case 0: 225 /* success */ 226 break; 227 228 case -EILSEQ: 229 case -ENOENT: 230 case -ECONNRESET: 231 case -ESHUTDOWN: 232 return; 233 234 default: 235 if (net_ratelimit()) 236 netdev_err(netdev, 237 "Rx urb aborted (%d)\n", urb->status); 238 goto resubmit_urb; 239 } 240 241 /* protect from any incoming empty msgs */ 242 if ((urb->actual_length > 0) && (dev->adapter->dev_decode_buf)) { 243 /* handle these kinds of msgs only if _start callback called */ 244 if (dev->state & PCAN_USB_STATE_STARTED) { 245 err = dev->adapter->dev_decode_buf(dev, urb); 246 if (err) 247 pcan_dump_mem("received usb message", 248 urb->transfer_buffer, 249 urb->transfer_buffer_length); 250 } 251 } 252 253 resubmit_urb: 254 usb_fill_bulk_urb(urb, dev->udev, 255 usb_rcvbulkpipe(dev->udev, dev->ep_msg_in), 256 urb->transfer_buffer, dev->adapter->rx_buffer_size, 257 peak_usb_read_bulk_callback, dev); 258 259 usb_anchor_urb(urb, &dev->rx_submitted); 260 err = usb_submit_urb(urb, GFP_ATOMIC); 261 if (!err) 262 return; 263 264 usb_unanchor_urb(urb); 265 266 if (err == -ENODEV) 267 netif_device_detach(netdev); 268 else 269 netdev_err(netdev, "failed resubmitting read bulk urb: %d\n", 270 err); 271 } 272 273 /* 274 * callback for bulk Tx urb 275 */ 276 static void peak_usb_write_bulk_callback(struct urb *urb) 277 { 278 struct peak_tx_urb_context *context = urb->context; 279 struct peak_usb_device *dev; 280 struct net_device *netdev; 281 282 BUG_ON(!context); 283 284 dev = context->dev; 285 netdev = dev->netdev; 286 287 atomic_dec(&dev->active_tx_urbs); 288 289 if (!netif_device_present(netdev)) 290 return; 291 292 /* check tx status */ 293 switch (urb->status) { 294 case 0: 295 /* transmission complete */ 296 netdev->stats.tx_packets++; 297 netdev->stats.tx_bytes += context->data_len; 298 299 /* prevent tx timeout */ 300 netif_trans_update(netdev); 301 break; 302 303 case -EPROTO: 304 case -ENOENT: 305 case -ECONNRESET: 306 case -ESHUTDOWN: 307 break; 308 309 default: 310 if (net_ratelimit()) 311 netdev_err(netdev, "Tx urb aborted (%d)\n", 312 urb->status); 313 break; 314 } 315 316 /* should always release echo skb and corresponding context */ 317 can_get_echo_skb(netdev, context->echo_index, NULL); 318 context->echo_index = PCAN_USB_MAX_TX_URBS; 319 320 /* do wakeup tx queue in case of success only */ 321 if (!urb->status) 322 netif_wake_queue(netdev); 323 } 324 325 /* 326 * called by netdev to send one skb on the CAN interface. 327 */ 328 static netdev_tx_t peak_usb_ndo_start_xmit(struct sk_buff *skb, 329 struct net_device *netdev) 330 { 331 struct peak_usb_device *dev = netdev_priv(netdev); 332 struct peak_tx_urb_context *context = NULL; 333 struct net_device_stats *stats = &netdev->stats; 334 struct canfd_frame *cfd = (struct canfd_frame *)skb->data; 335 struct urb *urb; 336 u8 *obuf; 337 int i, err; 338 size_t size = dev->adapter->tx_buffer_size; 339 340 if (can_dropped_invalid_skb(netdev, skb)) 341 return NETDEV_TX_OK; 342 343 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) 344 if (dev->tx_contexts[i].echo_index == PCAN_USB_MAX_TX_URBS) { 345 context = dev->tx_contexts + i; 346 break; 347 } 348 349 if (!context) { 350 /* should not occur except during restart */ 351 return NETDEV_TX_BUSY; 352 } 353 354 urb = context->urb; 355 obuf = urb->transfer_buffer; 356 357 err = dev->adapter->dev_encode_msg(dev, skb, obuf, &size); 358 if (err) { 359 if (net_ratelimit()) 360 netdev_err(netdev, "packet dropped\n"); 361 dev_kfree_skb(skb); 362 stats->tx_dropped++; 363 return NETDEV_TX_OK; 364 } 365 366 context->echo_index = i; 367 368 /* Note: this works with CANFD frames too */ 369 context->data_len = cfd->len; 370 371 usb_anchor_urb(urb, &dev->tx_submitted); 372 373 can_put_echo_skb(skb, netdev, context->echo_index, 0); 374 375 atomic_inc(&dev->active_tx_urbs); 376 377 err = usb_submit_urb(urb, GFP_ATOMIC); 378 if (err) { 379 can_free_echo_skb(netdev, context->echo_index, NULL); 380 381 usb_unanchor_urb(urb); 382 383 /* this context is not used in fact */ 384 context->echo_index = PCAN_USB_MAX_TX_URBS; 385 386 atomic_dec(&dev->active_tx_urbs); 387 388 switch (err) { 389 case -ENODEV: 390 netif_device_detach(netdev); 391 break; 392 default: 393 netdev_warn(netdev, "tx urb submitting failed err=%d\n", 394 err); 395 fallthrough; 396 case -ENOENT: 397 /* cable unplugged */ 398 stats->tx_dropped++; 399 } 400 } else { 401 netif_trans_update(netdev); 402 403 /* slow down tx path */ 404 if (atomic_read(&dev->active_tx_urbs) >= PCAN_USB_MAX_TX_URBS) 405 netif_stop_queue(netdev); 406 } 407 408 return NETDEV_TX_OK; 409 } 410 411 /* 412 * start the CAN interface. 413 * Rx and Tx urbs are allocated here. Rx urbs are submitted here. 414 */ 415 static int peak_usb_start(struct peak_usb_device *dev) 416 { 417 struct net_device *netdev = dev->netdev; 418 int err, i; 419 420 for (i = 0; i < PCAN_USB_MAX_RX_URBS; i++) { 421 struct urb *urb; 422 u8 *buf; 423 424 /* create a URB, and a buffer for it, to receive usb messages */ 425 urb = usb_alloc_urb(0, GFP_KERNEL); 426 if (!urb) { 427 err = -ENOMEM; 428 break; 429 } 430 431 buf = kmalloc(dev->adapter->rx_buffer_size, GFP_KERNEL); 432 if (!buf) { 433 usb_free_urb(urb); 434 err = -ENOMEM; 435 break; 436 } 437 438 usb_fill_bulk_urb(urb, dev->udev, 439 usb_rcvbulkpipe(dev->udev, dev->ep_msg_in), 440 buf, dev->adapter->rx_buffer_size, 441 peak_usb_read_bulk_callback, dev); 442 443 /* ask last usb_free_urb() to also kfree() transfer_buffer */ 444 urb->transfer_flags |= URB_FREE_BUFFER; 445 usb_anchor_urb(urb, &dev->rx_submitted); 446 447 err = usb_submit_urb(urb, GFP_KERNEL); 448 if (err) { 449 if (err == -ENODEV) 450 netif_device_detach(dev->netdev); 451 452 usb_unanchor_urb(urb); 453 kfree(buf); 454 usb_free_urb(urb); 455 break; 456 } 457 458 /* drop reference, USB core will take care of freeing it */ 459 usb_free_urb(urb); 460 } 461 462 /* did we submit any URBs? Warn if we was not able to submit all urbs */ 463 if (i < PCAN_USB_MAX_RX_URBS) { 464 if (i == 0) { 465 netdev_err(netdev, "couldn't setup any rx URB\n"); 466 return err; 467 } 468 469 netdev_warn(netdev, "rx performance may be slow\n"); 470 } 471 472 /* pre-alloc tx buffers and corresponding urbs */ 473 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) { 474 struct peak_tx_urb_context *context; 475 struct urb *urb; 476 u8 *buf; 477 478 /* create a URB and a buffer for it, to transmit usb messages */ 479 urb = usb_alloc_urb(0, GFP_KERNEL); 480 if (!urb) { 481 err = -ENOMEM; 482 break; 483 } 484 485 buf = kmalloc(dev->adapter->tx_buffer_size, GFP_KERNEL); 486 if (!buf) { 487 usb_free_urb(urb); 488 err = -ENOMEM; 489 break; 490 } 491 492 context = dev->tx_contexts + i; 493 context->dev = dev; 494 context->urb = urb; 495 496 usb_fill_bulk_urb(urb, dev->udev, 497 usb_sndbulkpipe(dev->udev, dev->ep_msg_out), 498 buf, dev->adapter->tx_buffer_size, 499 peak_usb_write_bulk_callback, context); 500 501 /* ask last usb_free_urb() to also kfree() transfer_buffer */ 502 urb->transfer_flags |= URB_FREE_BUFFER; 503 } 504 505 /* warn if we were not able to allocate enough tx contexts */ 506 if (i < PCAN_USB_MAX_TX_URBS) { 507 if (i == 0) { 508 netdev_err(netdev, "couldn't setup any tx URB\n"); 509 goto err_tx; 510 } 511 512 netdev_warn(netdev, "tx performance may be slow\n"); 513 } 514 515 if (dev->adapter->dev_start) { 516 err = dev->adapter->dev_start(dev); 517 if (err) 518 goto err_adapter; 519 } 520 521 dev->state |= PCAN_USB_STATE_STARTED; 522 523 /* can set bus on now */ 524 if (dev->adapter->dev_set_bus) { 525 err = dev->adapter->dev_set_bus(dev, 1); 526 if (err) 527 goto err_adapter; 528 } 529 530 dev->can.state = CAN_STATE_ERROR_ACTIVE; 531 532 return 0; 533 534 err_adapter: 535 if (err == -ENODEV) 536 netif_device_detach(dev->netdev); 537 538 netdev_warn(netdev, "couldn't submit control: %d\n", err); 539 540 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) { 541 usb_free_urb(dev->tx_contexts[i].urb); 542 dev->tx_contexts[i].urb = NULL; 543 } 544 err_tx: 545 usb_kill_anchored_urbs(&dev->rx_submitted); 546 547 return err; 548 } 549 550 /* 551 * called by netdev to open the corresponding CAN interface. 552 */ 553 static int peak_usb_ndo_open(struct net_device *netdev) 554 { 555 struct peak_usb_device *dev = netdev_priv(netdev); 556 int err; 557 558 /* common open */ 559 err = open_candev(netdev); 560 if (err) 561 return err; 562 563 /* finally start device */ 564 err = peak_usb_start(dev); 565 if (err) { 566 netdev_err(netdev, "couldn't start device: %d\n", err); 567 close_candev(netdev); 568 return err; 569 } 570 571 netif_start_queue(netdev); 572 573 return 0; 574 } 575 576 /* 577 * unlink in-flight Rx and Tx urbs and free their memory. 578 */ 579 static void peak_usb_unlink_all_urbs(struct peak_usb_device *dev) 580 { 581 int i; 582 583 /* free all Rx (submitted) urbs */ 584 usb_kill_anchored_urbs(&dev->rx_submitted); 585 586 /* free unsubmitted Tx urbs first */ 587 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) { 588 struct urb *urb = dev->tx_contexts[i].urb; 589 590 if (!urb || 591 dev->tx_contexts[i].echo_index != PCAN_USB_MAX_TX_URBS) { 592 /* 593 * this urb is already released or always submitted, 594 * let usb core free by itself 595 */ 596 continue; 597 } 598 599 usb_free_urb(urb); 600 dev->tx_contexts[i].urb = NULL; 601 } 602 603 /* then free all submitted Tx urbs */ 604 usb_kill_anchored_urbs(&dev->tx_submitted); 605 atomic_set(&dev->active_tx_urbs, 0); 606 } 607 608 /* 609 * called by netdev to close the corresponding CAN interface. 610 */ 611 static int peak_usb_ndo_stop(struct net_device *netdev) 612 { 613 struct peak_usb_device *dev = netdev_priv(netdev); 614 615 dev->state &= ~PCAN_USB_STATE_STARTED; 616 netif_stop_queue(netdev); 617 618 close_candev(netdev); 619 620 dev->can.state = CAN_STATE_STOPPED; 621 622 /* unlink all pending urbs and free used memory */ 623 peak_usb_unlink_all_urbs(dev); 624 625 if (dev->adapter->dev_stop) 626 dev->adapter->dev_stop(dev); 627 628 /* can set bus off now */ 629 if (dev->adapter->dev_set_bus) { 630 int err = dev->adapter->dev_set_bus(dev, 0); 631 632 if (err) 633 return err; 634 } 635 636 return 0; 637 } 638 639 /* 640 * handle end of waiting for the device to reset 641 */ 642 void peak_usb_restart_complete(struct peak_usb_device *dev) 643 { 644 /* finally MUST update can state */ 645 dev->can.state = CAN_STATE_ERROR_ACTIVE; 646 647 /* netdev queue can be awaken now */ 648 netif_wake_queue(dev->netdev); 649 } 650 651 void peak_usb_async_complete(struct urb *urb) 652 { 653 kfree(urb->transfer_buffer); 654 usb_free_urb(urb); 655 } 656 657 /* 658 * device (auto-)restart mechanism runs in a timer context => 659 * MUST handle restart with asynchronous usb transfers 660 */ 661 static int peak_usb_restart(struct peak_usb_device *dev) 662 { 663 struct urb *urb; 664 int err; 665 u8 *buf; 666 667 /* 668 * if device doesn't define any asynchronous restart handler, simply 669 * wake the netdev queue up 670 */ 671 if (!dev->adapter->dev_restart_async) { 672 peak_usb_restart_complete(dev); 673 return 0; 674 } 675 676 /* first allocate a urb to handle the asynchronous steps */ 677 urb = usb_alloc_urb(0, GFP_ATOMIC); 678 if (!urb) 679 return -ENOMEM; 680 681 /* also allocate enough space for the commands to send */ 682 buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_ATOMIC); 683 if (!buf) { 684 usb_free_urb(urb); 685 return -ENOMEM; 686 } 687 688 /* call the device specific handler for the restart */ 689 err = dev->adapter->dev_restart_async(dev, urb, buf); 690 if (!err) 691 return 0; 692 693 kfree(buf); 694 usb_free_urb(urb); 695 696 return err; 697 } 698 699 /* 700 * candev callback used to change CAN mode. 701 * Warning: this is called from a timer context! 702 */ 703 static int peak_usb_set_mode(struct net_device *netdev, enum can_mode mode) 704 { 705 struct peak_usb_device *dev = netdev_priv(netdev); 706 int err = 0; 707 708 switch (mode) { 709 case CAN_MODE_START: 710 err = peak_usb_restart(dev); 711 if (err) 712 netdev_err(netdev, "couldn't start device (err %d)\n", 713 err); 714 break; 715 716 default: 717 return -EOPNOTSUPP; 718 } 719 720 return err; 721 } 722 723 /* 724 * candev callback used to set device nominal/arbitration bitrate. 725 */ 726 static int peak_usb_set_bittiming(struct net_device *netdev) 727 { 728 struct peak_usb_device *dev = netdev_priv(netdev); 729 const struct peak_usb_adapter *pa = dev->adapter; 730 731 if (pa->dev_set_bittiming) { 732 struct can_bittiming *bt = &dev->can.bittiming; 733 int err = pa->dev_set_bittiming(dev, bt); 734 735 if (err) 736 netdev_info(netdev, "couldn't set bitrate (err %d)\n", 737 err); 738 return err; 739 } 740 741 return 0; 742 } 743 744 /* 745 * candev callback used to set device data bitrate. 746 */ 747 static int peak_usb_set_data_bittiming(struct net_device *netdev) 748 { 749 struct peak_usb_device *dev = netdev_priv(netdev); 750 const struct peak_usb_adapter *pa = dev->adapter; 751 752 if (pa->dev_set_data_bittiming) { 753 struct can_bittiming *bt = &dev->can.data_bittiming; 754 int err = pa->dev_set_data_bittiming(dev, bt); 755 756 if (err) 757 netdev_info(netdev, 758 "couldn't set data bitrate (err %d)\n", 759 err); 760 761 return err; 762 } 763 764 return 0; 765 } 766 767 static const struct net_device_ops peak_usb_netdev_ops = { 768 .ndo_open = peak_usb_ndo_open, 769 .ndo_stop = peak_usb_ndo_stop, 770 .ndo_start_xmit = peak_usb_ndo_start_xmit, 771 .ndo_change_mtu = can_change_mtu, 772 }; 773 774 /* 775 * create one device which is attached to CAN controller #ctrl_idx of the 776 * usb adapter. 777 */ 778 static int peak_usb_create_dev(const struct peak_usb_adapter *peak_usb_adapter, 779 struct usb_interface *intf, int ctrl_idx) 780 { 781 struct usb_device *usb_dev = interface_to_usbdev(intf); 782 int sizeof_candev = peak_usb_adapter->sizeof_dev_private; 783 struct peak_usb_device *dev; 784 struct net_device *netdev; 785 int i, err; 786 u16 tmp16; 787 788 if (sizeof_candev < sizeof(struct peak_usb_device)) 789 sizeof_candev = sizeof(struct peak_usb_device); 790 791 netdev = alloc_candev(sizeof_candev, PCAN_USB_MAX_TX_URBS); 792 if (!netdev) { 793 dev_err(&intf->dev, "%s: couldn't alloc candev\n", 794 PCAN_USB_DRIVER_NAME); 795 return -ENOMEM; 796 } 797 798 dev = netdev_priv(netdev); 799 800 /* allocate a buffer large enough to send commands */ 801 dev->cmd_buf = kzalloc(PCAN_USB_MAX_CMD_LEN, GFP_KERNEL); 802 if (!dev->cmd_buf) { 803 err = -ENOMEM; 804 goto lbl_free_candev; 805 } 806 807 dev->udev = usb_dev; 808 dev->netdev = netdev; 809 dev->adapter = peak_usb_adapter; 810 dev->ctrl_idx = ctrl_idx; 811 dev->state = PCAN_USB_STATE_CONNECTED; 812 813 dev->ep_msg_in = peak_usb_adapter->ep_msg_in; 814 dev->ep_msg_out = peak_usb_adapter->ep_msg_out[ctrl_idx]; 815 816 dev->can.clock = peak_usb_adapter->clock; 817 dev->can.bittiming_const = peak_usb_adapter->bittiming_const; 818 dev->can.do_set_bittiming = peak_usb_set_bittiming; 819 dev->can.data_bittiming_const = peak_usb_adapter->data_bittiming_const; 820 dev->can.do_set_data_bittiming = peak_usb_set_data_bittiming; 821 dev->can.do_set_mode = peak_usb_set_mode; 822 dev->can.do_get_berr_counter = peak_usb_adapter->do_get_berr_counter; 823 dev->can.ctrlmode_supported = peak_usb_adapter->ctrlmode_supported; 824 825 netdev->netdev_ops = &peak_usb_netdev_ops; 826 827 netdev->flags |= IFF_ECHO; /* we support local echo */ 828 829 /* add ethtool support */ 830 netdev->ethtool_ops = peak_usb_adapter->ethtool_ops; 831 832 init_usb_anchor(&dev->rx_submitted); 833 834 init_usb_anchor(&dev->tx_submitted); 835 atomic_set(&dev->active_tx_urbs, 0); 836 837 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) 838 dev->tx_contexts[i].echo_index = PCAN_USB_MAX_TX_URBS; 839 840 dev->prev_siblings = usb_get_intfdata(intf); 841 usb_set_intfdata(intf, dev); 842 843 SET_NETDEV_DEV(netdev, &intf->dev); 844 netdev->dev_id = ctrl_idx; 845 846 err = register_candev(netdev); 847 if (err) { 848 dev_err(&intf->dev, "couldn't register CAN device: %d\n", err); 849 goto lbl_restore_intf_data; 850 } 851 852 if (dev->prev_siblings) 853 (dev->prev_siblings)->next_siblings = dev; 854 855 /* keep hw revision into the netdevice */ 856 tmp16 = le16_to_cpu(usb_dev->descriptor.bcdDevice); 857 dev->device_rev = tmp16 >> 8; 858 859 if (dev->adapter->dev_init) { 860 err = dev->adapter->dev_init(dev); 861 if (err) 862 goto lbl_unregister_candev; 863 } 864 865 /* set bus off */ 866 if (dev->adapter->dev_set_bus) { 867 err = dev->adapter->dev_set_bus(dev, 0); 868 if (err) 869 goto adap_dev_free; 870 } 871 872 /* get device number early */ 873 if (dev->adapter->dev_get_device_id) 874 dev->adapter->dev_get_device_id(dev, &dev->device_number); 875 876 netdev_info(netdev, "attached to %s channel %u (device %u)\n", 877 peak_usb_adapter->name, ctrl_idx, dev->device_number); 878 879 return 0; 880 881 adap_dev_free: 882 if (dev->adapter->dev_free) 883 dev->adapter->dev_free(dev); 884 885 lbl_unregister_candev: 886 unregister_candev(netdev); 887 888 lbl_restore_intf_data: 889 usb_set_intfdata(intf, dev->prev_siblings); 890 kfree(dev->cmd_buf); 891 892 lbl_free_candev: 893 free_candev(netdev); 894 895 return err; 896 } 897 898 /* 899 * called by the usb core when the device is unplugged from the system 900 */ 901 static void peak_usb_disconnect(struct usb_interface *intf) 902 { 903 struct peak_usb_device *dev; 904 struct peak_usb_device *dev_prev_siblings; 905 906 /* unregister as many netdev devices as siblings */ 907 for (dev = usb_get_intfdata(intf); dev; dev = dev_prev_siblings) { 908 struct net_device *netdev = dev->netdev; 909 char name[IFNAMSIZ]; 910 911 dev_prev_siblings = dev->prev_siblings; 912 dev->state &= ~PCAN_USB_STATE_CONNECTED; 913 strlcpy(name, netdev->name, IFNAMSIZ); 914 915 unregister_netdev(netdev); 916 917 kfree(dev->cmd_buf); 918 dev->next_siblings = NULL; 919 if (dev->adapter->dev_free) 920 dev->adapter->dev_free(dev); 921 922 free_candev(netdev); 923 dev_info(&intf->dev, "%s removed\n", name); 924 } 925 926 usb_set_intfdata(intf, NULL); 927 } 928 929 /* 930 * probe function for new PEAK-System devices 931 */ 932 static int peak_usb_probe(struct usb_interface *intf, 933 const struct usb_device_id *id) 934 { 935 const struct peak_usb_adapter *peak_usb_adapter; 936 int i, err = -ENOMEM; 937 938 /* get corresponding PCAN-USB adapter */ 939 peak_usb_adapter = (const struct peak_usb_adapter *)id->driver_info; 940 941 /* got corresponding adapter: check if it handles current interface */ 942 if (peak_usb_adapter->intf_probe) { 943 err = peak_usb_adapter->intf_probe(intf); 944 if (err) 945 return err; 946 } 947 948 for (i = 0; i < peak_usb_adapter->ctrl_count; i++) { 949 err = peak_usb_create_dev(peak_usb_adapter, intf, i); 950 if (err) { 951 /* deregister already created devices */ 952 peak_usb_disconnect(intf); 953 break; 954 } 955 } 956 957 return err; 958 } 959 960 /* usb specific object needed to register this driver with the usb subsystem */ 961 static struct usb_driver peak_usb_driver = { 962 .name = PCAN_USB_DRIVER_NAME, 963 .disconnect = peak_usb_disconnect, 964 .probe = peak_usb_probe, 965 .id_table = peak_usb_table, 966 }; 967 968 static int __init peak_usb_init(void) 969 { 970 int err; 971 972 /* register this driver with the USB subsystem */ 973 err = usb_register(&peak_usb_driver); 974 if (err) 975 pr_err("%s: usb_register failed (err %d)\n", 976 PCAN_USB_DRIVER_NAME, err); 977 978 return err; 979 } 980 981 static int peak_usb_do_device_exit(struct device *d, void *arg) 982 { 983 struct usb_interface *intf = to_usb_interface(d); 984 struct peak_usb_device *dev; 985 986 /* stop as many netdev devices as siblings */ 987 for (dev = usb_get_intfdata(intf); dev; dev = dev->prev_siblings) { 988 struct net_device *netdev = dev->netdev; 989 990 if (netif_device_present(netdev)) 991 if (dev->adapter->dev_exit) 992 dev->adapter->dev_exit(dev); 993 } 994 995 return 0; 996 } 997 998 static void __exit peak_usb_exit(void) 999 { 1000 int err; 1001 1002 /* last chance do send any synchronous commands here */ 1003 err = driver_for_each_device(&peak_usb_driver.drvwrap.driver, NULL, 1004 NULL, peak_usb_do_device_exit); 1005 if (err) 1006 pr_err("%s: failed to stop all can devices (err %d)\n", 1007 PCAN_USB_DRIVER_NAME, err); 1008 1009 /* deregister this driver with the USB subsystem */ 1010 usb_deregister(&peak_usb_driver); 1011 1012 pr_info("%s: PCAN-USB interfaces driver unloaded\n", 1013 PCAN_USB_DRIVER_NAME); 1014 } 1015 1016 module_init(peak_usb_init); 1017 module_exit(peak_usb_exit); 1018