pcan_usb_core.c revision 09da6c5f60ad2e2018366e47192a9ddbccfb3ac5
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 return err; 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 failed; 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 failed; 485 } 486 487 dev->can.state = CAN_STATE_ERROR_ACTIVE; 488 489 return 0; 490 491failed: 492 if (err == -ENODEV) 493 netif_device_detach(dev->netdev); 494 495 netdev_warn(netdev, "couldn't submit control: %d\n", err); 496 497 return err; 498} 499 500/* 501 * called by netdev to open the corresponding CAN interface. 502 */ 503static int peak_usb_ndo_open(struct net_device *netdev) 504{ 505 struct peak_usb_device *dev = netdev_priv(netdev); 506 int err; 507 508 /* common open */ 509 err = open_candev(netdev); 510 if (err) 511 return err; 512 513 /* finally start device */ 514 err = peak_usb_start(dev); 515 if (err) { 516 netdev_err(netdev, "couldn't start device: %d\n", err); 517 close_candev(netdev); 518 return err; 519 } 520 521 netif_start_queue(netdev); 522 523 return 0; 524} 525 526/* 527 * unlink in-flight Rx and Tx urbs and free their memory. 528 */ 529static void peak_usb_unlink_all_urbs(struct peak_usb_device *dev) 530{ 531 int i; 532 533 /* free all Rx (submitted) urbs */ 534 usb_kill_anchored_urbs(&dev->rx_submitted); 535 536 /* free unsubmitted Tx urbs first */ 537 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) { 538 struct urb *urb = dev->tx_contexts[i].urb; 539 540 if (!urb || 541 dev->tx_contexts[i].echo_index != PCAN_USB_MAX_TX_URBS) { 542 /* 543 * this urb is already released or always submitted, 544 * let usb core free by itself 545 */ 546 continue; 547 } 548 549 usb_free_urb(urb); 550 dev->tx_contexts[i].urb = NULL; 551 } 552 553 /* then free all submitted Tx urbs */ 554 usb_kill_anchored_urbs(&dev->tx_submitted); 555 atomic_set(&dev->active_tx_urbs, 0); 556} 557 558/* 559 * called by netdev to close the corresponding CAN interface. 560 */ 561static int peak_usb_ndo_stop(struct net_device *netdev) 562{ 563 struct peak_usb_device *dev = netdev_priv(netdev); 564 565 dev->state &= ~PCAN_USB_STATE_STARTED; 566 netif_stop_queue(netdev); 567 568 /* unlink all pending urbs and free used memory */ 569 peak_usb_unlink_all_urbs(dev); 570 571 if (dev->adapter->dev_stop) 572 dev->adapter->dev_stop(dev); 573 574 close_candev(netdev); 575 576 dev->can.state = CAN_STATE_STOPPED; 577 578 /* can set bus off now */ 579 if (dev->adapter->dev_set_bus) { 580 int err = dev->adapter->dev_set_bus(dev, 0); 581 if (err) 582 return err; 583 } 584 585 return 0; 586} 587 588/* 589 * handle end of waiting for the device to reset 590 */ 591void peak_usb_restart_complete(struct peak_usb_device *dev) 592{ 593 /* finally MUST update can state */ 594 dev->can.state = CAN_STATE_ERROR_ACTIVE; 595 596 /* netdev queue can be awaken now */ 597 netif_wake_queue(dev->netdev); 598} 599 600void peak_usb_async_complete(struct urb *urb) 601{ 602 kfree(urb->transfer_buffer); 603 usb_free_urb(urb); 604} 605 606/* 607 * device (auto-)restart mechanism runs in a timer context => 608 * MUST handle restart with asynchronous usb transfers 609 */ 610static int peak_usb_restart(struct peak_usb_device *dev) 611{ 612 struct urb *urb; 613 int err; 614 u8 *buf; 615 616 /* 617 * if device doesn't define any asynchronous restart handler, simply 618 * wake the netdev queue up 619 */ 620 if (!dev->adapter->dev_restart_async) { 621 peak_usb_restart_complete(dev); 622 return 0; 623 } 624 625 /* first allocate a urb to handle the asynchronous steps */ 626 urb = usb_alloc_urb(0, GFP_ATOMIC); 627 if (!urb) { 628 netdev_err(dev->netdev, "no memory left for urb\n"); 629 return -ENOMEM; 630 } 631 632 /* also allocate enough space for the commands to send */ 633 buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_ATOMIC); 634 if (!buf) { 635 usb_free_urb(urb); 636 return -ENOMEM; 637 } 638 639 /* call the device specific handler for the restart */ 640 err = dev->adapter->dev_restart_async(dev, urb, buf); 641 if (!err) 642 return 0; 643 644 kfree(buf); 645 usb_free_urb(urb); 646 647 return err; 648} 649 650/* 651 * candev callback used to change CAN mode. 652 * Warning: this is called from a timer context! 653 */ 654static int peak_usb_set_mode(struct net_device *netdev, enum can_mode mode) 655{ 656 struct peak_usb_device *dev = netdev_priv(netdev); 657 int err = 0; 658 659 switch (mode) { 660 case CAN_MODE_START: 661 err = peak_usb_restart(dev); 662 if (err) 663 netdev_err(netdev, "couldn't start device (err %d)\n", 664 err); 665 break; 666 667 default: 668 return -EOPNOTSUPP; 669 } 670 671 return err; 672} 673 674/* 675 * candev callback used to set device bitrate. 676 */ 677static int peak_usb_set_bittiming(struct net_device *netdev) 678{ 679 struct peak_usb_device *dev = netdev_priv(netdev); 680 struct can_bittiming *bt = &dev->can.bittiming; 681 682 if (dev->adapter->dev_set_bittiming) { 683 int err = dev->adapter->dev_set_bittiming(dev, bt); 684 685 if (err) 686 netdev_info(netdev, "couldn't set bitrate (err %d)\n", 687 err); 688 return err; 689 } 690 691 return 0; 692} 693 694static const struct net_device_ops peak_usb_netdev_ops = { 695 .ndo_open = peak_usb_ndo_open, 696 .ndo_stop = peak_usb_ndo_stop, 697 .ndo_start_xmit = peak_usb_ndo_start_xmit, 698}; 699 700/* 701 * create one device which is attached to CAN controller #ctrl_idx of the 702 * usb adapter. 703 */ 704static int peak_usb_create_dev(struct peak_usb_adapter *peak_usb_adapter, 705 struct usb_interface *intf, int ctrl_idx) 706{ 707 struct usb_device *usb_dev = interface_to_usbdev(intf); 708 int sizeof_candev = peak_usb_adapter->sizeof_dev_private; 709 struct peak_usb_device *dev; 710 struct net_device *netdev; 711 int i, err; 712 u16 tmp16; 713 714 if (sizeof_candev < sizeof(struct peak_usb_device)) 715 sizeof_candev = sizeof(struct peak_usb_device); 716 717 netdev = alloc_candev(sizeof_candev, PCAN_USB_MAX_TX_URBS); 718 if (!netdev) { 719 dev_err(&intf->dev, "%s: couldn't alloc candev\n", 720 PCAN_USB_DRIVER_NAME); 721 return -ENOMEM; 722 } 723 724 dev = netdev_priv(netdev); 725 726 /* allocate a buffer large enough to send commands */ 727 dev->cmd_buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_KERNEL); 728 if (!dev->cmd_buf) { 729 err = -ENOMEM; 730 goto lbl_set_intf_data; 731 } 732 733 dev->udev = usb_dev; 734 dev->netdev = netdev; 735 dev->adapter = peak_usb_adapter; 736 dev->ctrl_idx = ctrl_idx; 737 dev->state = PCAN_USB_STATE_CONNECTED; 738 739 dev->ep_msg_in = peak_usb_adapter->ep_msg_in; 740 dev->ep_msg_out = peak_usb_adapter->ep_msg_out[ctrl_idx]; 741 742 dev->can.clock = peak_usb_adapter->clock; 743 dev->can.bittiming_const = &peak_usb_adapter->bittiming_const; 744 dev->can.do_set_bittiming = peak_usb_set_bittiming; 745 dev->can.do_set_mode = peak_usb_set_mode; 746 dev->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | 747 CAN_CTRLMODE_LISTENONLY; 748 749 netdev->netdev_ops = &peak_usb_netdev_ops; 750 751 netdev->flags |= IFF_ECHO; /* we support local echo */ 752 753 init_usb_anchor(&dev->rx_submitted); 754 755 init_usb_anchor(&dev->tx_submitted); 756 atomic_set(&dev->active_tx_urbs, 0); 757 758 for (i = 0; i < PCAN_USB_MAX_TX_URBS; i++) 759 dev->tx_contexts[i].echo_index = PCAN_USB_MAX_TX_URBS; 760 761 dev->prev_siblings = usb_get_intfdata(intf); 762 usb_set_intfdata(intf, dev); 763 764 SET_NETDEV_DEV(netdev, &intf->dev); 765 766 err = register_candev(netdev); 767 if (err) { 768 dev_err(&intf->dev, "couldn't register CAN device: %d\n", err); 769 goto lbl_free_cmd_buf; 770 } 771 772 if (dev->prev_siblings) 773 (dev->prev_siblings)->next_siblings = dev; 774 775 /* keep hw revision into the netdevice */ 776 tmp16 = le16_to_cpu(usb_dev->descriptor.bcdDevice); 777 dev->device_rev = tmp16 >> 8; 778 779 if (dev->adapter->dev_init) { 780 err = dev->adapter->dev_init(dev); 781 if (err) 782 goto lbl_free_cmd_buf; 783 } 784 785 /* set bus off */ 786 if (dev->adapter->dev_set_bus) { 787 err = dev->adapter->dev_set_bus(dev, 0); 788 if (err) 789 goto lbl_free_cmd_buf; 790 } 791 792 /* get device number early */ 793 if (dev->adapter->dev_get_device_id) 794 dev->adapter->dev_get_device_id(dev, &dev->device_number); 795 796 netdev_info(netdev, "attached to %s channel %u (device %u)\n", 797 peak_usb_adapter->name, ctrl_idx, dev->device_number); 798 799 return 0; 800 801lbl_free_cmd_buf: 802 kfree(dev->cmd_buf); 803 804lbl_set_intf_data: 805 usb_set_intfdata(intf, dev->prev_siblings); 806 free_candev(netdev); 807 808 return err; 809} 810 811/* 812 * called by the usb core when the device is unplugged from the system 813 */ 814static void peak_usb_disconnect(struct usb_interface *intf) 815{ 816 struct peak_usb_device *dev; 817 818 /* unregister as many netdev devices as siblings */ 819 for (dev = usb_get_intfdata(intf); dev; dev = dev->prev_siblings) { 820 struct net_device *netdev = dev->netdev; 821 char name[IFNAMSIZ]; 822 823 dev->state &= ~PCAN_USB_STATE_CONNECTED; 824 strncpy(name, netdev->name, IFNAMSIZ); 825 826 unregister_netdev(netdev); 827 free_candev(netdev); 828 829 kfree(dev->cmd_buf); 830 dev->next_siblings = NULL; 831 if (dev->adapter->dev_free) 832 dev->adapter->dev_free(dev); 833 834 dev_info(&intf->dev, "%s removed\n", name); 835 } 836 837 usb_set_intfdata(intf, NULL); 838} 839 840/* 841 * probe function for new PEAK-System devices 842 */ 843static int peak_usb_probe(struct usb_interface *intf, 844 const struct usb_device_id *id) 845{ 846 struct usb_device *usb_dev = interface_to_usbdev(intf); 847 struct peak_usb_adapter *peak_usb_adapter, **pp; 848 int i, err = -ENOMEM; 849 850 usb_dev = interface_to_usbdev(intf); 851 852 /* get corresponding PCAN-USB adapter */ 853 for (pp = peak_usb_adapters_list; *pp; pp++) 854 if ((*pp)->device_id == usb_dev->descriptor.idProduct) 855 break; 856 857 peak_usb_adapter = *pp; 858 if (!peak_usb_adapter) { 859 /* should never come except device_id bad usage in this file */ 860 pr_err("%s: didn't find device id. 0x%x in devices list\n", 861 PCAN_USB_DRIVER_NAME, usb_dev->descriptor.idProduct); 862 return -ENODEV; 863 } 864 865 /* got corresponding adapter: check if it handles current interface */ 866 if (peak_usb_adapter->intf_probe) { 867 err = peak_usb_adapter->intf_probe(intf); 868 if (err) 869 return err; 870 } 871 872 for (i = 0; i < peak_usb_adapter->ctrl_count; i++) { 873 err = peak_usb_create_dev(peak_usb_adapter, intf, i); 874 if (err) { 875 /* deregister already created devices */ 876 peak_usb_disconnect(intf); 877 break; 878 } 879 } 880 881 return err; 882} 883 884/* usb specific object needed to register this driver with the usb subsystem */ 885static struct usb_driver peak_usb_driver = { 886 .name = PCAN_USB_DRIVER_NAME, 887 .disconnect = peak_usb_disconnect, 888 .probe = peak_usb_probe, 889 .id_table = peak_usb_table, 890}; 891 892static int __init peak_usb_init(void) 893{ 894 int err; 895 896 /* register this driver with the USB subsystem */ 897 err = usb_register(&peak_usb_driver); 898 if (err) 899 pr_err("%s: usb_register failed (err %d)\n", 900 PCAN_USB_DRIVER_NAME, err); 901 902 return err; 903} 904 905static int peak_usb_do_device_exit(struct device *d, void *arg) 906{ 907 struct usb_interface *intf = to_usb_interface(d); 908 struct peak_usb_device *dev; 909 910 /* stop as many netdev devices as siblings */ 911 for (dev = usb_get_intfdata(intf); dev; dev = dev->prev_siblings) { 912 struct net_device *netdev = dev->netdev; 913 914 if (netif_device_present(netdev)) 915 if (dev->adapter->dev_exit) 916 dev->adapter->dev_exit(dev); 917 } 918 919 return 0; 920} 921 922static void __exit peak_usb_exit(void) 923{ 924 int err; 925 926 /* last chance do send any synchronous commands here */ 927 err = driver_for_each_device(&peak_usb_driver.drvwrap.driver, NULL, 928 NULL, peak_usb_do_device_exit); 929 if (err) 930 pr_err("%s: failed to stop all can devices (err %d)\n", 931 PCAN_USB_DRIVER_NAME, err); 932 933 /* deregister this driver with the USB subsystem */ 934 usb_deregister(&peak_usb_driver); 935 936 pr_info("%s: PCAN-USB interfaces driver unloaded\n", 937 PCAN_USB_DRIVER_NAME); 938} 939 940module_init(peak_usb_init); 941module_exit(peak_usb_exit); 942