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