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