drivers/net/can/usb/peak_usb/pcan_usb_core.c

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