drivers/net/can/usb/gs_usb.c

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