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