drivers/net/can/usb/gs_usb.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* CAN driver for Geschwister Schneider USB/CAN devices
   3  * and bytewerk.org candleLight USB CAN interfaces.
   4  *
   5  * Copyright (C) 2013-2016 Geschwister Schneider Technologie-,
   6  * Entwicklungs- und Vertriebs UG (Haftungsbeschränkt).
   7  * Copyright (C) 2016 Hubert Denkmair
   8  *
   9  * Many thanks to all socketcan devs!
  10  */
  11
  12 #include <linux/ethtool.h>
  13 #include <linux/init.h>
  14 #include <linux/signal.h>
  15 #include <linux/module.h>
  16 #include <linux/netdevice.h>
  17 #include <linux/usb.h>
  18
  19 #include <linux/can.h>
  20 #include <linux/can/dev.h>
  21 #include <linux/can/error.h>
  22
  23 /* Device specific constants */
  24 #define USB_GSUSB_1_VENDOR_ID      0x1d50
  25 #define USB_GSUSB_1_PRODUCT_ID     0x606f
  26
  27 #define USB_CANDLELIGHT_VENDOR_ID  0x1209
  28 #define USB_CANDLELIGHT_PRODUCT_ID 0x2323
  29
  30 #define GSUSB_ENDPOINT_IN          1
  31 #define GSUSB_ENDPOINT_OUT         2
  32
  33 /* Device specific constants */
  34 enum gs_usb_breq {
  35         GS_USB_BREQ_HOST_FORMAT = 0,
  36         GS_USB_BREQ_BITTIMING,
  37         GS_USB_BREQ_MODE,
  38         GS_USB_BREQ_BERR,
  39         GS_USB_BREQ_BT_CONST,
  40         GS_USB_BREQ_DEVICE_CONFIG,
  41         GS_USB_BREQ_TIMESTAMP,
  42         GS_USB_BREQ_IDENTIFY,
  43 };
  44
  45 enum gs_can_mode {
  46         /* reset a channel. turns it off */
  47         GS_CAN_MODE_RESET = 0,
  48         /* starts a channel */
  49         GS_CAN_MODE_START
  50 };
  51
  52 enum gs_can_state {
  53         GS_CAN_STATE_ERROR_ACTIVE = 0,
  54         GS_CAN_STATE_ERROR_WARNING,
  55         GS_CAN_STATE_ERROR_PASSIVE,
  56         GS_CAN_STATE_BUS_OFF,
  57         GS_CAN_STATE_STOPPED,
  58         GS_CAN_STATE_SLEEPING
  59 };
  60
  61 enum gs_can_identify_mode {
  62         GS_CAN_IDENTIFY_OFF = 0,
  63         GS_CAN_IDENTIFY_ON
  64 };
  65
  66 /* data types passed between host and device */
  67
  68 /* The firmware on the original USB2CAN by Geschwister Schneider
  69  * Technologie Entwicklungs- und Vertriebs UG exchanges all data
  70  * between the host and the device in host byte order. This is done
  71  * with the struct gs_host_config::byte_order member, which is sent
  72  * first to indicate the desired byte order.
  73  *
  74  * The widely used open source firmware candleLight doesn't support
  75  * this feature and exchanges the data in little endian byte order.
  76  */
  77 struct gs_host_config {
  78         __le32 byte_order;
  79 } __packed;
  80
  81 struct gs_device_config {
  82         u8 reserved1;
  83         u8 reserved2;
  84         u8 reserved3;
  85         u8 icount;
  86         __le32 sw_version;
  87         __le32 hw_version;
  88 } __packed;
  89
  90 #define GS_CAN_MODE_NORMAL               0
  91 #define GS_CAN_MODE_LISTEN_ONLY          BIT(0)
  92 #define GS_CAN_MODE_LOOP_BACK            BIT(1)
  93 #define GS_CAN_MODE_TRIPLE_SAMPLE        BIT(2)
  94 #define GS_CAN_MODE_ONE_SHOT             BIT(3)
  95
  96 struct gs_device_mode {
  97         __le32 mode;
  98         __le32 flags;
  99 } __packed;
 100
 101 struct gs_device_state {
 102         __le32 state;
 103         __le32 rxerr;
 104         __le32 txerr;
 105 } __packed;
 106
 107 struct gs_device_bittiming {
 108         __le32 prop_seg;
 109         __le32 phase_seg1;
 110         __le32 phase_seg2;
 111         __le32 sjw;
 112         __le32 brp;
 113 } __packed;
 114
 115 struct gs_identify_mode {
 116         __le32 mode;
 117 } __packed;
 118
 119 #define GS_CAN_FEATURE_LISTEN_ONLY      BIT(0)
 120 #define GS_CAN_FEATURE_LOOP_BACK        BIT(1)
 121 #define GS_CAN_FEATURE_TRIPLE_SAMPLE    BIT(2)
 122 #define GS_CAN_FEATURE_ONE_SHOT         BIT(3)
 123 #define GS_CAN_FEATURE_HW_TIMESTAMP     BIT(4)
 124 #define GS_CAN_FEATURE_IDENTIFY         BIT(5)
 125
 126 struct gs_device_bt_const {
 127         __le32 feature;
 128         __le32 fclk_can;
 129         __le32 tseg1_min;
 130         __le32 tseg1_max;
 131         __le32 tseg2_min;
 132         __le32 tseg2_max;
 133         __le32 sjw_max;
 134         __le32 brp_min;
 135         __le32 brp_max;
 136         __le32 brp_inc;
 137 } __packed;
 138
 139 #define GS_CAN_FLAG_OVERFLOW 1
 140
 141 struct gs_host_frame {
 142         u32 echo_id;
 143         __le32 can_id;
 144
 145         u8 can_dlc;
 146         u8 channel;
 147         u8 flags;
 148         u8 reserved;
 149
 150         u8 data[8];
 151 } __packed;
 152 /* The GS USB devices make use of the same flags and masks as in
 153  * linux/can.h and linux/can/error.h, and no additional mapping is necessary.
 154  */
 155
 156 /* Only send a max of GS_MAX_TX_URBS frames per channel at a time. */
 157 #define GS_MAX_TX_URBS 10
 158 /* Only launch a max of GS_MAX_RX_URBS usb requests at a time. */
 159 #define GS_MAX_RX_URBS 30
 160 /* Maximum number of interfaces the driver supports per device.
 161  * Current hardware only supports 2 interfaces. The future may vary.
 162  */
 163 #define GS_MAX_INTF 2
 164
 165 struct gs_tx_context {
 166         struct gs_can *dev;
 167         unsigned int echo_id;
 168 };
 169
 170 struct gs_can {
 171         struct can_priv can; /* must be the first member */
 172
 173         struct gs_usb *parent;
 174
 175         struct net_device *netdev;
 176         struct usb_device *udev;
 177         struct usb_interface *iface;
 178
 179         struct can_bittiming_const bt_const;
 180         unsigned int channel;   /* channel number */
 181
 182         /* This lock prevents a race condition between xmit and receive. */
 183         spinlock_t tx_ctx_lock;
 184         struct gs_tx_context tx_context[GS_MAX_TX_URBS];
 185
 186         struct usb_anchor tx_submitted;
 187         atomic_t active_tx_urbs;
 188 };
 189
 190 /* usb interface struct */
 191 struct gs_usb {
 192         struct gs_can *canch[GS_MAX_INTF];
 193         struct usb_anchor rx_submitted;
 194         atomic_t active_channels;
 195         struct usb_device *udev;
 196 };
 197
 198 /* 'allocate' a tx context.
 199  * returns a valid tx context or NULL if there is no space.
 200  */
 201 static struct gs_tx_context *gs_alloc_tx_context(struct gs_can *dev)
 202 {
 203         int i = 0;
 204         unsigned long flags;
 205
 206         spin_lock_irqsave(&dev->tx_ctx_lock, flags);
 207
 208         for (; i < GS_MAX_TX_URBS; i++) {
 209                 if (dev->tx_context[i].echo_id == GS_MAX_TX_URBS) {
 210                         dev->tx_context[i].echo_id = i;
 211                         spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
 212                         return &dev->tx_context[i];
 213                 }
 214         }
 215
 216         spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
 217         return NULL;
 218 }
 219
 220 /* releases a tx context
 221  */
 222 static void gs_free_tx_context(struct gs_tx_context *txc)
 223 {
 224         txc->echo_id = GS_MAX_TX_URBS;
 225 }
 226
 227 /* Get a tx context by id.
 228  */
 229 static struct gs_tx_context *gs_get_tx_context(struct gs_can *dev,
 230                                                unsigned int id)
 231 {
 232         unsigned long flags;
 233
 234         if (id < GS_MAX_TX_URBS) {
 235                 spin_lock_irqsave(&dev->tx_ctx_lock, flags);
 236                 if (dev->tx_context[id].echo_id == id) {
 237                         spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
 238                         return &dev->tx_context[id];
 239                 }
 240                 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
 241         }
 242         return NULL;
 243 }
 244
 245 static int gs_cmd_reset(struct gs_can *gsdev)
 246 {
 247         struct gs_device_mode *dm;
 248         struct usb_interface *intf = gsdev->iface;
 249         int rc;
 250
 251         dm = kzalloc(sizeof(*dm), GFP_KERNEL);
 252         if (!dm)
 253                 return -ENOMEM;
 254
 255         dm->mode = GS_CAN_MODE_RESET;
 256
 257         rc = usb_control_msg(interface_to_usbdev(intf),
 258                              usb_sndctrlpipe(interface_to_usbdev(intf), 0),
 259                              GS_USB_BREQ_MODE,
 260                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 261                              gsdev->channel,
 262                              0,
 263                              dm,
 264                              sizeof(*dm),
 265                              1000);
 266
 267         kfree(dm);
 268
 269         return rc;
 270 }
 271
 272 static void gs_update_state(struct gs_can *dev, struct can_frame *cf)
 273 {
 274         struct can_device_stats *can_stats = &dev->can.can_stats;
 275
 276         if (cf->can_id & CAN_ERR_RESTARTED) {
 277                 dev->can.state = CAN_STATE_ERROR_ACTIVE;
 278                 can_stats->restarts++;
 279         } else if (cf->can_id & CAN_ERR_BUSOFF) {
 280                 dev->can.state = CAN_STATE_BUS_OFF;
 281                 can_stats->bus_off++;
 282         } else if (cf->can_id & CAN_ERR_CRTL) {
 283                 if ((cf->data[1] & CAN_ERR_CRTL_TX_WARNING) ||
 284                     (cf->data[1] & CAN_ERR_CRTL_RX_WARNING)) {
 285                         dev->can.state = CAN_STATE_ERROR_WARNING;
 286                         can_stats->error_warning++;
 287                 } else if ((cf->data[1] & CAN_ERR_CRTL_TX_PASSIVE) ||
 288                            (cf->data[1] & CAN_ERR_CRTL_RX_PASSIVE)) {
 289                         dev->can.state = CAN_STATE_ERROR_PASSIVE;
 290                         can_stats->error_passive++;
 291                 } else {
 292                         dev->can.state = CAN_STATE_ERROR_ACTIVE;
 293                 }
 294         }
 295 }
 296
 297 static void gs_usb_receive_bulk_callback(struct urb *urb)
 298 {
 299         struct gs_usb *usbcan = urb->context;
 300         struct gs_can *dev;
 301         struct net_device *netdev;
 302         int rc;
 303         struct net_device_stats *stats;
 304         struct gs_host_frame *hf = urb->transfer_buffer;
 305         struct gs_tx_context *txc;
 306         struct can_frame *cf;
 307         struct sk_buff *skb;
 308
 309         BUG_ON(!usbcan);
 310
 311         switch (urb->status) {
 312         case 0: /* success */
 313                 break;
 314         case -ENOENT:
 315         case -ESHUTDOWN:
 316                 return;
 317         default:
 318                 /* do not resubmit aborted urbs. eg: when device goes down */
 319                 return;
 320         }
 321
 322         /* device reports out of range channel id */
 323         if (hf->channel >= GS_MAX_INTF)
 324                 goto resubmit_urb;
 325
 326         dev = usbcan->canch[hf->channel];
 327
 328         netdev = dev->netdev;
 329         stats = &netdev->stats;
 330
 331         if (!netif_device_present(netdev))
 332                 return;
 333
 334         if (hf->echo_id == -1) { /* normal rx */
 335                 skb = alloc_can_skb(dev->netdev, &cf);
 336                 if (!skb)
 337                         return;
 338
 339                 cf->can_id = le32_to_cpu(hf->can_id);
 340
 341                 can_frame_set_cc_len(cf, hf->can_dlc, dev->can.ctrlmode);
 342                 memcpy(cf->data, hf->data, 8);
 343
 344                 /* ERROR frames tell us information about the controller */
 345                 if (le32_to_cpu(hf->can_id) & CAN_ERR_FLAG)
 346                         gs_update_state(dev, cf);
 347
 348                 netdev->stats.rx_packets++;
 349                 netdev->stats.rx_bytes += hf->can_dlc;
 350
 351                 netif_rx(skb);
 352         } else { /* echo_id == hf->echo_id */
 353                 if (hf->echo_id >= GS_MAX_TX_URBS) {
 354                         netdev_err(netdev,
 355                                    "Unexpected out of range echo id %u\n",
 356                                    hf->echo_id);
 357                         goto resubmit_urb;
 358                 }
 359
 360                 netdev->stats.tx_packets++;
 361                 netdev->stats.tx_bytes += hf->can_dlc;
 362
 363                 txc = gs_get_tx_context(dev, hf->echo_id);
 364
 365                 /* bad devices send bad echo_ids. */
 366                 if (!txc) {
 367                         netdev_err(netdev,
 368                                    "Unexpected unused echo id %u\n",
 369                                    hf->echo_id);
 370                         goto resubmit_urb;
 371                 }
 372
 373                 can_get_echo_skb(netdev, hf->echo_id, NULL);
 374
 375                 gs_free_tx_context(txc);
 376
 377                 atomic_dec(&dev->active_tx_urbs);
 378
 379                 netif_wake_queue(netdev);
 380         }
 381
 382         if (hf->flags & GS_CAN_FLAG_OVERFLOW) {
 383                 skb = alloc_can_err_skb(netdev, &cf);
 384                 if (!skb)
 385                         goto resubmit_urb;
 386
 387                 cf->can_id |= CAN_ERR_CRTL;
 388                 cf->len = CAN_ERR_DLC;
 389                 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 390                 stats->rx_over_errors++;
 391                 stats->rx_errors++;
 392                 netif_rx(skb);
 393         }
 394
 395  resubmit_urb:
 396         usb_fill_bulk_urb(urb,
 397                           usbcan->udev,
 398                           usb_rcvbulkpipe(usbcan->udev, GSUSB_ENDPOINT_IN),
 399                           hf,
 400                           sizeof(struct gs_host_frame),
 401                           gs_usb_receive_bulk_callback,
 402                           usbcan
 403                           );
 404
 405         rc = usb_submit_urb(urb, GFP_ATOMIC);
 406
 407         /* USB failure take down all interfaces */
 408         if (rc == -ENODEV) {
 409                 for (rc = 0; rc < GS_MAX_INTF; rc++) {
 410                         if (usbcan->canch[rc])
 411                                 netif_device_detach(usbcan->canch[rc]->netdev);
 412                 }
 413         }
 414 }
 415
 416 static int gs_usb_set_bittiming(struct net_device *netdev)
 417 {
 418         struct gs_can *dev = netdev_priv(netdev);
 419         struct can_bittiming *bt = &dev->can.bittiming;
 420         struct usb_interface *intf = dev->iface;
 421         int rc;
 422         struct gs_device_bittiming *dbt;
 423
 424         dbt = kmalloc(sizeof(*dbt), GFP_KERNEL);
 425         if (!dbt)
 426                 return -ENOMEM;
 427
 428         dbt->prop_seg = cpu_to_le32(bt->prop_seg);
 429         dbt->phase_seg1 = cpu_to_le32(bt->phase_seg1);
 430         dbt->phase_seg2 = cpu_to_le32(bt->phase_seg2);
 431         dbt->sjw = cpu_to_le32(bt->sjw);
 432         dbt->brp = cpu_to_le32(bt->brp);
 433
 434         /* request bit timings */
 435         rc = usb_control_msg(interface_to_usbdev(intf),
 436                              usb_sndctrlpipe(interface_to_usbdev(intf), 0),
 437                              GS_USB_BREQ_BITTIMING,
 438                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 439                              dev->channel,
 440                              0,
 441                              dbt,
 442                              sizeof(*dbt),
 443                              1000);
 444
 445         kfree(dbt);
 446
 447         if (rc < 0)
 448                 dev_err(netdev->dev.parent, "Couldn't set bittimings (err=%d)",
 449                         rc);
 450
 451         return (rc > 0) ? 0 : rc;
 452 }
 453
 454 static void gs_usb_xmit_callback(struct urb *urb)
 455 {
 456         struct gs_tx_context *txc = urb->context;
 457         struct gs_can *dev = txc->dev;
 458         struct net_device *netdev = dev->netdev;
 459
 460         if (urb->status)
 461                 netdev_info(netdev, "usb xmit fail %u\n", txc->echo_id);
 462
 463         usb_free_coherent(urb->dev,
 464                           urb->transfer_buffer_length,
 465                           urb->transfer_buffer,
 466                           urb->transfer_dma);
 467 }
 468
 469 static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb,
 470                                      struct net_device *netdev)
 471 {
 472         struct gs_can *dev = netdev_priv(netdev);
 473         struct net_device_stats *stats = &dev->netdev->stats;
 474         struct urb *urb;
 475         struct gs_host_frame *hf;
 476         struct can_frame *cf;
 477         int rc;
 478         unsigned int idx;
 479         struct gs_tx_context *txc;
 480
 481         if (can_dropped_invalid_skb(netdev, skb))
 482                 return NETDEV_TX_OK;
 483
 484         /* find an empty context to keep track of transmission */
 485         txc = gs_alloc_tx_context(dev);
 486         if (!txc)
 487                 return NETDEV_TX_BUSY;
 488
 489         /* create a URB, and a buffer for it */
 490         urb = usb_alloc_urb(0, GFP_ATOMIC);
 491         if (!urb)
 492                 goto nomem_urb;
 493
 494         hf = usb_alloc_coherent(dev->udev, sizeof(*hf), GFP_ATOMIC,
 495                                 &urb->transfer_dma);
 496         if (!hf) {
 497                 netdev_err(netdev, "No memory left for USB buffer\n");
 498                 goto nomem_hf;
 499         }
 500
 501         idx = txc->echo_id;
 502
 503         if (idx >= GS_MAX_TX_URBS) {
 504                 netdev_err(netdev, "Invalid tx context %u\n", idx);
 505                 goto badidx;
 506         }
 507
 508         hf->echo_id = idx;
 509         hf->channel = dev->channel;
 510
 511         cf = (struct can_frame *)skb->data;
 512
 513         hf->can_id = cpu_to_le32(cf->can_id);
 514         hf->can_dlc = can_get_cc_dlc(cf, dev->can.ctrlmode);
 515
 516         memcpy(hf->data, cf->data, cf->len);
 517
 518         usb_fill_bulk_urb(urb, dev->udev,
 519                           usb_sndbulkpipe(dev->udev, GSUSB_ENDPOINT_OUT),
 520                           hf,
 521                           sizeof(*hf),
 522                           gs_usb_xmit_callback,
 523                           txc);
 524
 525         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 526         usb_anchor_urb(urb, &dev->tx_submitted);
 527
 528         can_put_echo_skb(skb, netdev, idx, 0);
 529
 530         atomic_inc(&dev->active_tx_urbs);
 531
 532         rc = usb_submit_urb(urb, GFP_ATOMIC);
 533         if (unlikely(rc)) {                     /* usb send failed */
 534                 atomic_dec(&dev->active_tx_urbs);
 535
 536                 can_free_echo_skb(netdev, idx, NULL);
 537                 gs_free_tx_context(txc);
 538
 539                 usb_unanchor_urb(urb);
 540                 usb_free_coherent(dev->udev,
 541                                   sizeof(*hf),
 542                                   hf,
 543                                   urb->transfer_dma);
 544
 545                 if (rc == -ENODEV) {
 546                         netif_device_detach(netdev);
 547                 } else {
 548                         netdev_err(netdev, "usb_submit failed (err=%d)\n", rc);
 549                         stats->tx_dropped++;
 550                 }
 551         } else {
 552                 /* Slow down tx path */
 553                 if (atomic_read(&dev->active_tx_urbs) >= GS_MAX_TX_URBS)
 554                         netif_stop_queue(netdev);
 555         }
 556
 557         /* let usb core take care of this urb */
 558         usb_free_urb(urb);
 559
 560         return NETDEV_TX_OK;
 561
 562  badidx:
 563         usb_free_coherent(dev->udev,
 564                           sizeof(*hf),
 565                           hf,
 566                           urb->transfer_dma);
 567  nomem_hf:
 568         usb_free_urb(urb);
 569
 570  nomem_urb:
 571         gs_free_tx_context(txc);
 572         dev_kfree_skb(skb);
 573         stats->tx_dropped++;
 574         return NETDEV_TX_OK;
 575 }
 576
 577 static int gs_can_open(struct net_device *netdev)
 578 {
 579         struct gs_can *dev = netdev_priv(netdev);
 580         struct gs_usb *parent = dev->parent;
 581         int rc, i;
 582         struct gs_device_mode *dm;
 583         u32 ctrlmode;
 584         u32 flags = 0;
 585
 586         rc = open_candev(netdev);
 587         if (rc)
 588                 return rc;
 589
 590         if (atomic_add_return(1, &parent->active_channels) == 1) {
 591                 for (i = 0; i < GS_MAX_RX_URBS; i++) {
 592                         struct urb *urb;
 593                         u8 *buf;
 594
 595                         /* alloc rx urb */
 596                         urb = usb_alloc_urb(0, GFP_KERNEL);
 597                         if (!urb)
 598                                 return -ENOMEM;
 599
 600                         /* alloc rx buffer */
 601                         buf = usb_alloc_coherent(dev->udev,
 602                                                  sizeof(struct gs_host_frame),
 603                                                  GFP_KERNEL,
 604                                                  &urb->transfer_dma);
 605                         if (!buf) {
 606                                 netdev_err(netdev,
 607                                            "No memory left for USB buffer\n");
 608                                 usb_free_urb(urb);
 609                                 return -ENOMEM;
 610                         }
 611
 612                         /* fill, anchor, and submit rx urb */
 613                         usb_fill_bulk_urb(urb,
 614                                           dev->udev,
 615                                           usb_rcvbulkpipe(dev->udev,
 616                                                           GSUSB_ENDPOINT_IN),
 617                                           buf,
 618                                           sizeof(struct gs_host_frame),
 619                                           gs_usb_receive_bulk_callback,
 620                                           parent);
 621                         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 622
 623                         usb_anchor_urb(urb, &parent->rx_submitted);
 624
 625                         rc = usb_submit_urb(urb, GFP_KERNEL);
 626                         if (rc) {
 627                                 if (rc == -ENODEV)
 628                                         netif_device_detach(dev->netdev);
 629
 630                                 netdev_err(netdev,
 631                                            "usb_submit failed (err=%d)\n",
 632                                            rc);
 633
 634                                 usb_unanchor_urb(urb);
 635                                 usb_free_urb(urb);
 636                                 break;
 637                         }
 638
 639                         /* Drop reference,
 640                          * USB core will take care of freeing it
 641                          */
 642                         usb_free_urb(urb);
 643                 }
 644         }
 645
 646         dm = kmalloc(sizeof(*dm), GFP_KERNEL);
 647         if (!dm)
 648                 return -ENOMEM;
 649
 650         /* flags */
 651         ctrlmode = dev->can.ctrlmode;
 652
 653         if (ctrlmode & CAN_CTRLMODE_LOOPBACK)
 654                 flags |= GS_CAN_MODE_LOOP_BACK;
 655         else if (ctrlmode & CAN_CTRLMODE_LISTENONLY)
 656                 flags |= GS_CAN_MODE_LISTEN_ONLY;
 657
 658         /* Controller is not allowed to retry TX
 659          * this mode is unavailable on atmels uc3c hardware
 660          */
 661         if (ctrlmode & CAN_CTRLMODE_ONE_SHOT)
 662                 flags |= GS_CAN_MODE_ONE_SHOT;
 663
 664         if (ctrlmode & CAN_CTRLMODE_3_SAMPLES)
 665                 flags |= GS_CAN_MODE_TRIPLE_SAMPLE;
 666
 667         /* finally start device */
 668         dm->mode = cpu_to_le32(GS_CAN_MODE_START);
 669         dm->flags = cpu_to_le32(flags);
 670         rc = usb_control_msg(interface_to_usbdev(dev->iface),
 671                              usb_sndctrlpipe(interface_to_usbdev(dev->iface), 0),
 672                              GS_USB_BREQ_MODE,
 673                              USB_DIR_OUT | USB_TYPE_VENDOR |
 674                              USB_RECIP_INTERFACE,
 675                              dev->channel,
 676                              0,
 677                              dm,
 678                              sizeof(*dm),
 679                              1000);
 680
 681         if (rc < 0) {
 682                 netdev_err(netdev, "Couldn't start device (err=%d)\n", rc);
 683                 kfree(dm);
 684                 return rc;
 685         }
 686
 687         kfree(dm);
 688
 689         dev->can.state = CAN_STATE_ERROR_ACTIVE;
 690
 691         if (!(dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY))
 692                 netif_start_queue(netdev);
 693
 694         return 0;
 695 }
 696
 697 static int gs_can_close(struct net_device *netdev)
 698 {
 699         int rc;
 700         struct gs_can *dev = netdev_priv(netdev);
 701         struct gs_usb *parent = dev->parent;
 702
 703         netif_stop_queue(netdev);
 704
 705         /* Stop polling */
 706         if (atomic_dec_and_test(&parent->active_channels))
 707                 usb_kill_anchored_urbs(&parent->rx_submitted);
 708
 709         /* Stop sending URBs */
 710         usb_kill_anchored_urbs(&dev->tx_submitted);
 711         atomic_set(&dev->active_tx_urbs, 0);
 712
 713         /* reset the device */
 714         rc = gs_cmd_reset(dev);
 715         if (rc < 0)
 716                 netdev_warn(netdev, "Couldn't shutdown device (err=%d)", rc);
 717
 718         /* reset tx contexts */
 719         for (rc = 0; rc < GS_MAX_TX_URBS; rc++) {
 720                 dev->tx_context[rc].dev = dev;
 721                 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS;
 722         }
 723
 724         /* close the netdev */
 725         close_candev(netdev);
 726
 727         return 0;
 728 }
 729
 730 static const struct net_device_ops gs_usb_netdev_ops = {
 731         .ndo_open = gs_can_open,
 732         .ndo_stop = gs_can_close,
 733         .ndo_start_xmit = gs_can_start_xmit,
 734         .ndo_change_mtu = can_change_mtu,
 735 };
 736
 737 static int gs_usb_set_identify(struct net_device *netdev, bool do_identify)
 738 {
 739         struct gs_can *dev = netdev_priv(netdev);
 740         struct gs_identify_mode *imode;
 741         int rc;
 742
 743         imode = kmalloc(sizeof(*imode), GFP_KERNEL);
 744
 745         if (!imode)
 746                 return -ENOMEM;
 747
 748         if (do_identify)
 749                 imode->mode = cpu_to_le32(GS_CAN_IDENTIFY_ON);
 750         else
 751                 imode->mode = cpu_to_le32(GS_CAN_IDENTIFY_OFF);
 752
 753         rc = usb_control_msg(interface_to_usbdev(dev->iface),
 754                              usb_sndctrlpipe(interface_to_usbdev(dev->iface),
 755                                              0),
 756                              GS_USB_BREQ_IDENTIFY,
 757                              USB_DIR_OUT | USB_TYPE_VENDOR |
 758                              USB_RECIP_INTERFACE,
 759                              dev->channel,
 760                              0,
 761                              imode,
 762                              sizeof(*imode),
 763                              100);
 764
 765         kfree(imode);
 766
 767         return (rc > 0) ? 0 : rc;
 768 }
 769
 770 /* blink LED's for finding the this interface */
 771 static int gs_usb_set_phys_id(struct net_device *dev,
 772                               enum ethtool_phys_id_state state)
 773 {
 774         int rc = 0;
 775
 776         switch (state) {
 777         case ETHTOOL_ID_ACTIVE:
 778                 rc = gs_usb_set_identify(dev, GS_CAN_IDENTIFY_ON);
 779                 break;
 780         case ETHTOOL_ID_INACTIVE:
 781                 rc = gs_usb_set_identify(dev, GS_CAN_IDENTIFY_OFF);
 782                 break;
 783         default:
 784                 break;
 785         }
 786
 787         return rc;
 788 }
 789
 790 static const struct ethtool_ops gs_usb_ethtool_ops = {
 791         .set_phys_id = gs_usb_set_phys_id,
 792 };
 793
 794 static struct gs_can *gs_make_candev(unsigned int channel,
 795                                      struct usb_interface *intf,
 796                                      struct gs_device_config *dconf)
 797 {
 798         struct gs_can *dev;
 799         struct net_device *netdev;
 800         int rc;
 801         struct gs_device_bt_const *bt_const;
 802         u32 feature;
 803
 804         bt_const = kmalloc(sizeof(*bt_const), GFP_KERNEL);
 805         if (!bt_const)
 806                 return ERR_PTR(-ENOMEM);
 807
 808         /* fetch bit timing constants */
 809         rc = usb_control_msg(interface_to_usbdev(intf),
 810                              usb_rcvctrlpipe(interface_to_usbdev(intf), 0),
 811                              GS_USB_BREQ_BT_CONST,
 812                              USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 813                              channel,
 814                              0,
 815                              bt_const,
 816                              sizeof(*bt_const),
 817                              1000);
 818
 819         if (rc < 0) {
 820                 dev_err(&intf->dev,
 821                         "Couldn't get bit timing const for channel (err=%d)\n",
 822                         rc);
 823                 kfree(bt_const);
 824                 return ERR_PTR(rc);
 825         }
 826
 827         /* create netdev */
 828         netdev = alloc_candev(sizeof(struct gs_can), GS_MAX_TX_URBS);
 829         if (!netdev) {
 830                 dev_err(&intf->dev, "Couldn't allocate candev\n");
 831                 kfree(bt_const);
 832                 return ERR_PTR(-ENOMEM);
 833         }
 834
 835         dev = netdev_priv(netdev);
 836
 837         netdev->netdev_ops = &gs_usb_netdev_ops;
 838
 839         netdev->flags |= IFF_ECHO; /* we support full roundtrip echo */
 840
 841         /* dev setup */
 842         strcpy(dev->bt_const.name, "gs_usb");
 843         dev->bt_const.tseg1_min = le32_to_cpu(bt_const->tseg1_min);
 844         dev->bt_const.tseg1_max = le32_to_cpu(bt_const->tseg1_max);
 845         dev->bt_const.tseg2_min = le32_to_cpu(bt_const->tseg2_min);
 846         dev->bt_const.tseg2_max = le32_to_cpu(bt_const->tseg2_max);
 847         dev->bt_const.sjw_max = le32_to_cpu(bt_const->sjw_max);
 848         dev->bt_const.brp_min = le32_to_cpu(bt_const->brp_min);
 849         dev->bt_const.brp_max = le32_to_cpu(bt_const->brp_max);
 850         dev->bt_const.brp_inc = le32_to_cpu(bt_const->brp_inc);
 851
 852         dev->udev = interface_to_usbdev(intf);
 853         dev->iface = intf;
 854         dev->netdev = netdev;
 855         dev->channel = channel;
 856
 857         init_usb_anchor(&dev->tx_submitted);
 858         atomic_set(&dev->active_tx_urbs, 0);
 859         spin_lock_init(&dev->tx_ctx_lock);
 860         for (rc = 0; rc < GS_MAX_TX_URBS; rc++) {
 861                 dev->tx_context[rc].dev = dev;
 862                 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS;
 863         }
 864
 865         /* can setup */
 866         dev->can.state = CAN_STATE_STOPPED;
 867         dev->can.clock.freq = le32_to_cpu(bt_const->fclk_can);
 868         dev->can.bittiming_const = &dev->bt_const;
 869         dev->can.do_set_bittiming = gs_usb_set_bittiming;
 870
 871         dev->can.ctrlmode_supported = CAN_CTRLMODE_CC_LEN8_DLC;
 872
 873         feature = le32_to_cpu(bt_const->feature);
 874         if (feature & GS_CAN_FEATURE_LISTEN_ONLY)
 875                 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY;
 876
 877         if (feature & GS_CAN_FEATURE_LOOP_BACK)
 878                 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK;
 879
 880         if (feature & GS_CAN_FEATURE_TRIPLE_SAMPLE)
 881                 dev->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
 882
 883         if (feature & GS_CAN_FEATURE_ONE_SHOT)
 884                 dev->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT;
 885
 886         SET_NETDEV_DEV(netdev, &intf->dev);
 887
 888         if (le32_to_cpu(dconf->sw_version) > 1)
 889                 if (feature & GS_CAN_FEATURE_IDENTIFY)
 890                         netdev->ethtool_ops = &gs_usb_ethtool_ops;
 891
 892         kfree(bt_const);
 893
 894         rc = register_candev(dev->netdev);
 895         if (rc) {
 896                 free_candev(dev->netdev);
 897                 dev_err(&intf->dev, "Couldn't register candev (err=%d)\n", rc);
 898                 return ERR_PTR(rc);
 899         }
 900
 901         return dev;
 902 }
 903
 904 static void gs_destroy_candev(struct gs_can *dev)
 905 {
 906         unregister_candev(dev->netdev);
 907         usb_kill_anchored_urbs(&dev->tx_submitted);
 908         free_candev(dev->netdev);
 909 }
 910
 911 static int gs_usb_probe(struct usb_interface *intf,
 912                         const struct usb_device_id *id)
 913 {
 914         struct gs_usb *dev;
 915         int rc = -ENOMEM;
 916         unsigned int icount, i;
 917         struct gs_host_config *hconf;
 918         struct gs_device_config *dconf;
 919
 920         hconf = kmalloc(sizeof(*hconf), GFP_KERNEL);
 921         if (!hconf)
 922                 return -ENOMEM;
 923
 924         hconf->byte_order = cpu_to_le32(0x0000beef);
 925
 926         /* send host config */
 927         rc = usb_control_msg(interface_to_usbdev(intf),
 928                              usb_sndctrlpipe(interface_to_usbdev(intf), 0),
 929                              GS_USB_BREQ_HOST_FORMAT,
 930                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 931                              1,
 932                              intf->cur_altsetting->desc.bInterfaceNumber,
 933                              hconf,
 934                              sizeof(*hconf),
 935                              1000);
 936
 937         kfree(hconf);
 938
 939         if (rc < 0) {
 940                 dev_err(&intf->dev, "Couldn't send data format (err=%d)\n",
 941                         rc);
 942                 return rc;
 943         }
 944
 945         dconf = kmalloc(sizeof(*dconf), GFP_KERNEL);
 946         if (!dconf)
 947                 return -ENOMEM;
 948
 949         /* read device config */
 950         rc = usb_control_msg(interface_to_usbdev(intf),
 951                              usb_rcvctrlpipe(interface_to_usbdev(intf), 0),
 952                              GS_USB_BREQ_DEVICE_CONFIG,
 953                              USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 954                              1,
 955                              intf->cur_altsetting->desc.bInterfaceNumber,
 956                              dconf,
 957                              sizeof(*dconf),
 958                              1000);
 959         if (rc < 0) {
 960                 dev_err(&intf->dev, "Couldn't get device config: (err=%d)\n",
 961                         rc);
 962                 kfree(dconf);
 963                 return rc;
 964         }
 965
 966         icount = dconf->icount + 1;
 967         dev_info(&intf->dev, "Configuring for %u interfaces\n", icount);
 968
 969         if (icount > GS_MAX_INTF) {
 970                 dev_err(&intf->dev,
 971                         "Driver cannot handle more that %u CAN interfaces\n",
 972                         GS_MAX_INTF);
 973                 kfree(dconf);
 974                 return -EINVAL;
 975         }
 976
 977         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 978         if (!dev) {
 979                 kfree(dconf);
 980                 return -ENOMEM;
 981         }
 982
 983         init_usb_anchor(&dev->rx_submitted);
 984
 985         atomic_set(&dev->active_channels, 0);
 986
 987         usb_set_intfdata(intf, dev);
 988         dev->udev = interface_to_usbdev(intf);
 989
 990         for (i = 0; i < icount; i++) {
 991                 dev->canch[i] = gs_make_candev(i, intf, dconf);
 992                 if (IS_ERR_OR_NULL(dev->canch[i])) {
 993                         /* save error code to return later */
 994                         rc = PTR_ERR(dev->canch[i]);
 995
 996                         /* on failure destroy previously created candevs */
 997                         icount = i;
 998                         for (i = 0; i < icount; i++)
 999                                 gs_destroy_candev(dev->canch[i]);
1000
1001                         usb_kill_anchored_urbs(&dev->rx_submitted);
1002                         kfree(dconf);
1003                         kfree(dev);
1004                         return rc;
1005                 }
1006                 dev->canch[i]->parent = dev;
1007         }
1008
1009         kfree(dconf);
1010
1011         return 0;
1012 }
1013
1014 static void gs_usb_disconnect(struct usb_interface *intf)
1015 {
1016         unsigned i;
1017         struct gs_usb *dev = usb_get_intfdata(intf);
1018         usb_set_intfdata(intf, NULL);
1019
1020         if (!dev) {
1021                 dev_err(&intf->dev, "Disconnect (nodata)\n");
1022                 return;
1023         }
1024
1025         for (i = 0; i < GS_MAX_INTF; i++)
1026                 if (dev->canch[i])
1027                         gs_destroy_candev(dev->canch[i]);
1028
1029         usb_kill_anchored_urbs(&dev->rx_submitted);
1030         kfree(dev);
1031 }
1032
1033 static const struct usb_device_id gs_usb_table[] = {
1034         { USB_DEVICE_INTERFACE_NUMBER(USB_GSUSB_1_VENDOR_ID,
1035                                       USB_GSUSB_1_PRODUCT_ID, 0) },
1036         { USB_DEVICE_INTERFACE_NUMBER(USB_CANDLELIGHT_VENDOR_ID,
1037                                       USB_CANDLELIGHT_PRODUCT_ID, 0) },
1038         {} /* Terminating entry */
1039 };
1040
1041 MODULE_DEVICE_TABLE(usb, gs_usb_table);
1042
1043 static struct usb_driver gs_usb_driver = {
1044         .name       = "gs_usb",
1045         .probe      = gs_usb_probe,
1046         .disconnect = gs_usb_disconnect,
1047         .id_table   = gs_usb_table,
1048 };
1049
1050 module_usb_driver(gs_usb_driver);
1051
1052 MODULE_AUTHOR("Maximilian Schneider <[email protected]>");
1053 MODULE_DESCRIPTION(
1054 "Socket CAN device driver for Geschwister Schneider Technologie-, "
1055 "Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces\n"
1056 "and bytewerk.org candleLight USB CAN interfaces.");
1057 MODULE_LICENSE("GPL v2");