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