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