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