drivers/net/can/usb/gs_usb.c

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