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         void *rxbuf[GS_MAX_RX_URBS];
 272         dma_addr_t rxbuf_dma[GS_MAX_RX_URBS];
 273 };
 274
 275 /* usb interface struct */
 276 struct gs_usb {
 277         struct gs_can *canch[GS_MAX_INTF];
 278         struct usb_anchor rx_submitted;
 279         struct usb_device *udev;
 280         unsigned int hf_size_rx;
 281         u8 active_channels;
 282 };
 283
 284 /* 'allocate' a tx context.
 285  * returns a valid tx context or NULL if there is no space.
 286  */
 287 static struct gs_tx_context *gs_alloc_tx_context(struct gs_can *dev)
 288 {
 289         int i = 0;
 290         unsigned long flags;
 291
 292         spin_lock_irqsave(&dev->tx_ctx_lock, flags);
 293
 294         for (; i < GS_MAX_TX_URBS; i++) {
 295                 if (dev->tx_context[i].echo_id == GS_MAX_TX_URBS) {
 296                         dev->tx_context[i].echo_id = i;
 297                         spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
 298                         return &dev->tx_context[i];
 299                 }
 300         }
 301
 302         spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
 303         return NULL;
 304 }
 305
 306 /* releases a tx context
 307  */
 308 static void gs_free_tx_context(struct gs_tx_context *txc)
 309 {
 310         txc->echo_id = GS_MAX_TX_URBS;
 311 }
 312
 313 /* Get a tx context by id.
 314  */
 315 static struct gs_tx_context *gs_get_tx_context(struct gs_can *dev,
 316                                                unsigned int id)
 317 {
 318         unsigned long flags;
 319
 320         if (id < GS_MAX_TX_URBS) {
 321                 spin_lock_irqsave(&dev->tx_ctx_lock, flags);
 322                 if (dev->tx_context[id].echo_id == id) {
 323                         spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
 324                         return &dev->tx_context[id];
 325                 }
 326                 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags);
 327         }
 328         return NULL;
 329 }
 330
 331 static int gs_cmd_reset(struct gs_can *gsdev)
 332 {
 333         struct gs_device_mode *dm;
 334         struct usb_interface *intf = gsdev->iface;
 335         int rc;
 336
 337         dm = kzalloc(sizeof(*dm), GFP_KERNEL);
 338         if (!dm)
 339                 return -ENOMEM;
 340
 341         dm->mode = GS_CAN_MODE_RESET;
 342
 343         rc = usb_control_msg(interface_to_usbdev(intf),
 344                              usb_sndctrlpipe(interface_to_usbdev(intf), 0),
 345                              GS_USB_BREQ_MODE,
 346                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 347                              gsdev->channel, 0, dm, sizeof(*dm), 1000);
 348
 349         kfree(dm);
 350
 351         return rc;
 352 }
 353
 354 static void gs_update_state(struct gs_can *dev, struct can_frame *cf)
 355 {
 356         struct can_device_stats *can_stats = &dev->can.can_stats;
 357
 358         if (cf->can_id & CAN_ERR_RESTARTED) {
 359                 dev->can.state = CAN_STATE_ERROR_ACTIVE;
 360                 can_stats->restarts++;
 361         } else if (cf->can_id & CAN_ERR_BUSOFF) {
 362                 dev->can.state = CAN_STATE_BUS_OFF;
 363                 can_stats->bus_off++;
 364         } else if (cf->can_id & CAN_ERR_CRTL) {
 365                 if ((cf->data[1] & CAN_ERR_CRTL_TX_WARNING) ||
 366                     (cf->data[1] & CAN_ERR_CRTL_RX_WARNING)) {
 367                         dev->can.state = CAN_STATE_ERROR_WARNING;
 368                         can_stats->error_warning++;
 369                 } else if ((cf->data[1] & CAN_ERR_CRTL_TX_PASSIVE) ||
 370                            (cf->data[1] & CAN_ERR_CRTL_RX_PASSIVE)) {
 371                         dev->can.state = CAN_STATE_ERROR_PASSIVE;
 372                         can_stats->error_passive++;
 373                 } else {
 374                         dev->can.state = CAN_STATE_ERROR_ACTIVE;
 375                 }
 376         }
 377 }
 378
 379 static void gs_usb_receive_bulk_callback(struct urb *urb)
 380 {
 381         struct gs_usb *usbcan = urb->context;
 382         struct gs_can *dev;
 383         struct net_device *netdev;
 384         int rc;
 385         struct net_device_stats *stats;
 386         struct gs_host_frame *hf = urb->transfer_buffer;
 387         struct gs_tx_context *txc;
 388         struct can_frame *cf;
 389         struct canfd_frame *cfd;
 390         struct sk_buff *skb;
 391
 392         BUG_ON(!usbcan);
 393
 394         switch (urb->status) {
 395         case 0: /* success */
 396                 break;
 397         case -ENOENT:
 398         case -ESHUTDOWN:
 399                 return;
 400         default:
 401                 /* do not resubmit aborted urbs. eg: when device goes down */
 402                 return;
 403         }
 404
 405         /* device reports out of range channel id */
 406         if (hf->channel >= GS_MAX_INTF)
 407                 goto device_detach;
 408
 409         dev = usbcan->canch[hf->channel];
 410
 411         netdev = dev->netdev;
 412         stats = &netdev->stats;
 413
 414         if (!netif_device_present(netdev))
 415                 return;
 416
 417         if (hf->echo_id == -1) { /* normal rx */
 418                 if (hf->flags & GS_CAN_FLAG_FD) {
 419                         skb = alloc_canfd_skb(dev->netdev, &cfd);
 420                         if (!skb)
 421                                 return;
 422
 423                         cfd->can_id = le32_to_cpu(hf->can_id);
 424                         cfd->len = can_fd_dlc2len(hf->can_dlc);
 425                         if (hf->flags & GS_CAN_FLAG_BRS)
 426                                 cfd->flags |= CANFD_BRS;
 427                         if (hf->flags & GS_CAN_FLAG_ESI)
 428                                 cfd->flags |= CANFD_ESI;
 429
 430                         memcpy(cfd->data, hf->canfd->data, cfd->len);
 431                 } else {
 432                         skb = alloc_can_skb(dev->netdev, &cf);
 433                         if (!skb)
 434                                 return;
 435
 436                         cf->can_id = le32_to_cpu(hf->can_id);
 437                         can_frame_set_cc_len(cf, hf->can_dlc, dev->can.ctrlmode);
 438
 439                         memcpy(cf->data, hf->classic_can->data, 8);
 440
 441                         /* ERROR frames tell us information about the controller */
 442                         if (le32_to_cpu(hf->can_id) & CAN_ERR_FLAG)
 443                                 gs_update_state(dev, cf);
 444                 }
 445
 446                 netdev->stats.rx_packets++;
 447                 netdev->stats.rx_bytes += hf->can_dlc;
 448
 449                 netif_rx(skb);
 450         } else { /* echo_id == hf->echo_id */
 451                 if (hf->echo_id >= GS_MAX_TX_URBS) {
 452                         netdev_err(netdev,
 453                                    "Unexpected out of range echo id %u\n",
 454                                    hf->echo_id);
 455                         goto resubmit_urb;
 456                 }
 457
 458                 txc = gs_get_tx_context(dev, hf->echo_id);
 459
 460                 /* bad devices send bad echo_ids. */
 461                 if (!txc) {
 462                         netdev_err(netdev,
 463                                    "Unexpected unused echo id %u\n",
 464                                    hf->echo_id);
 465                         goto resubmit_urb;
 466                 }
 467
 468                 netdev->stats.tx_packets++;
 469                 netdev->stats.tx_bytes += can_get_echo_skb(netdev, hf->echo_id,
 470                                                            NULL);
 471
 472                 gs_free_tx_context(txc);
 473
 474                 atomic_dec(&dev->active_tx_urbs);
 475
 476                 netif_wake_queue(netdev);
 477         }
 478
 479         if (hf->flags & GS_CAN_FLAG_OVERFLOW) {
 480                 skb = alloc_can_err_skb(netdev, &cf);
 481                 if (!skb)
 482                         goto resubmit_urb;
 483
 484                 cf->can_id |= CAN_ERR_CRTL;
 485                 cf->len = CAN_ERR_DLC;
 486                 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
 487                 stats->rx_over_errors++;
 488                 stats->rx_errors++;
 489                 netif_rx(skb);
 490         }
 491
 492  resubmit_urb:
 493         usb_fill_bulk_urb(urb, usbcan->udev,
 494                           usb_rcvbulkpipe(usbcan->udev, GSUSB_ENDPOINT_IN),
 495                           hf, dev->parent->hf_size_rx,
 496                           gs_usb_receive_bulk_callback, usbcan);
 497
 498         rc = usb_submit_urb(urb, GFP_ATOMIC);
 499
 500         /* USB failure take down all interfaces */
 501         if (rc == -ENODEV) {
 502  device_detach:
 503                 for (rc = 0; rc < GS_MAX_INTF; rc++) {
 504                         if (usbcan->canch[rc])
 505                                 netif_device_detach(usbcan->canch[rc]->netdev);
 506                 }
 507         }
 508 }
 509
 510 static int gs_usb_set_bittiming(struct net_device *netdev)
 511 {
 512         struct gs_can *dev = netdev_priv(netdev);
 513         struct can_bittiming *bt = &dev->can.bittiming;
 514         struct usb_interface *intf = dev->iface;
 515         int rc;
 516         struct gs_device_bittiming *dbt;
 517
 518         dbt = kmalloc(sizeof(*dbt), GFP_KERNEL);
 519         if (!dbt)
 520                 return -ENOMEM;
 521
 522         dbt->prop_seg = cpu_to_le32(bt->prop_seg);
 523         dbt->phase_seg1 = cpu_to_le32(bt->phase_seg1);
 524         dbt->phase_seg2 = cpu_to_le32(bt->phase_seg2);
 525         dbt->sjw = cpu_to_le32(bt->sjw);
 526         dbt->brp = cpu_to_le32(bt->brp);
 527
 528         /* request bit timings */
 529         rc = usb_control_msg(interface_to_usbdev(intf),
 530                              usb_sndctrlpipe(interface_to_usbdev(intf), 0),
 531                              GS_USB_BREQ_BITTIMING,
 532                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 533                              dev->channel, 0, dbt, sizeof(*dbt), 1000);
 534
 535         kfree(dbt);
 536
 537         if (rc < 0)
 538                 dev_err(netdev->dev.parent, "Couldn't set bittimings (err=%d)",
 539                         rc);
 540
 541         return (rc > 0) ? 0 : rc;
 542 }
 543
 544 static int gs_usb_set_data_bittiming(struct net_device *netdev)
 545 {
 546         struct gs_can *dev = netdev_priv(netdev);
 547         struct can_bittiming *bt = &dev->can.data_bittiming;
 548         struct usb_interface *intf = dev->iface;
 549         struct gs_device_bittiming *dbt;
 550         u8 request = GS_USB_BREQ_DATA_BITTIMING;
 551         int rc;
 552
 553         dbt = kmalloc(sizeof(*dbt), GFP_KERNEL);
 554         if (!dbt)
 555                 return -ENOMEM;
 556
 557         dbt->prop_seg = cpu_to_le32(bt->prop_seg);
 558         dbt->phase_seg1 = cpu_to_le32(bt->phase_seg1);
 559         dbt->phase_seg2 = cpu_to_le32(bt->phase_seg2);
 560         dbt->sjw = cpu_to_le32(bt->sjw);
 561         dbt->brp = cpu_to_le32(bt->brp);
 562
 563         if (dev->feature & GS_CAN_FEATURE_QUIRK_BREQ_CANTACT_PRO)
 564                 request = GS_USB_BREQ_QUIRK_CANTACT_PRO_DATA_BITTIMING;
 565
 566         /* request bit timings */
 567         rc = usb_control_msg(interface_to_usbdev(intf),
 568                              usb_sndctrlpipe(interface_to_usbdev(intf), 0),
 569                              request,
 570                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 571                              dev->channel, 0, dbt, sizeof(*dbt), 1000);
 572
 573         kfree(dbt);
 574
 575         if (rc < 0)
 576                 dev_err(netdev->dev.parent,
 577                         "Couldn't set data bittimings (err=%d)", rc);
 578
 579         return (rc > 0) ? 0 : rc;
 580 }
 581
 582 static void gs_usb_xmit_callback(struct urb *urb)
 583 {
 584         struct gs_tx_context *txc = urb->context;
 585         struct gs_can *dev = txc->dev;
 586         struct net_device *netdev = dev->netdev;
 587
 588         if (urb->status)
 589                 netdev_info(netdev, "usb xmit fail %u\n", txc->echo_id);
 590
 591         usb_free_coherent(urb->dev, urb->transfer_buffer_length,
 592                           urb->transfer_buffer, urb->transfer_dma);
 593 }
 594
 595 static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb,
 596                                      struct net_device *netdev)
 597 {
 598         struct gs_can *dev = netdev_priv(netdev);
 599         struct net_device_stats *stats = &dev->netdev->stats;
 600         struct urb *urb;
 601         struct gs_host_frame *hf;
 602         struct can_frame *cf;
 603         struct canfd_frame *cfd;
 604         int rc;
 605         unsigned int idx;
 606         struct gs_tx_context *txc;
 607
 608         if (can_dropped_invalid_skb(netdev, skb))
 609                 return NETDEV_TX_OK;
 610
 611         /* find an empty context to keep track of transmission */
 612         txc = gs_alloc_tx_context(dev);
 613         if (!txc)
 614                 return NETDEV_TX_BUSY;
 615
 616         /* create a URB, and a buffer for it */
 617         urb = usb_alloc_urb(0, GFP_ATOMIC);
 618         if (!urb)
 619                 goto nomem_urb;
 620
 621         hf = usb_alloc_coherent(dev->udev, dev->hf_size_tx, GFP_ATOMIC,
 622                                 &urb->transfer_dma);
 623         if (!hf) {
 624                 netdev_err(netdev, "No memory left for USB buffer\n");
 625                 goto nomem_hf;
 626         }
 627
 628         idx = txc->echo_id;
 629
 630         if (idx >= GS_MAX_TX_URBS) {
 631                 netdev_err(netdev, "Invalid tx context %u\n", idx);
 632                 goto badidx;
 633         }
 634
 635         hf->echo_id = idx;
 636         hf->channel = dev->channel;
 637         hf->flags = 0;
 638         hf->reserved = 0;
 639
 640         if (can_is_canfd_skb(skb)) {
 641                 cfd = (struct canfd_frame *)skb->data;
 642
 643                 hf->can_id = cpu_to_le32(cfd->can_id);
 644                 hf->can_dlc = can_fd_len2dlc(cfd->len);
 645                 hf->flags |= GS_CAN_FLAG_FD;
 646                 if (cfd->flags & CANFD_BRS)
 647                         hf->flags |= GS_CAN_FLAG_BRS;
 648                 if (cfd->flags & CANFD_ESI)
 649                         hf->flags |= GS_CAN_FLAG_ESI;
 650
 651                 memcpy(hf->canfd->data, cfd->data, cfd->len);
 652         } else {
 653                 cf = (struct can_frame *)skb->data;
 654
 655                 hf->can_id = cpu_to_le32(cf->can_id);
 656                 hf->can_dlc = can_get_cc_dlc(cf, dev->can.ctrlmode);
 657
 658                 memcpy(hf->classic_can->data, cf->data, cf->len);
 659         }
 660
 661         usb_fill_bulk_urb(urb, dev->udev,
 662                           usb_sndbulkpipe(dev->udev, GSUSB_ENDPOINT_OUT),
 663                           hf, dev->hf_size_tx,
 664                           gs_usb_xmit_callback, txc);
 665
 666         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 667         usb_anchor_urb(urb, &dev->tx_submitted);
 668
 669         can_put_echo_skb(skb, netdev, idx, 0);
 670
 671         atomic_inc(&dev->active_tx_urbs);
 672
 673         rc = usb_submit_urb(urb, GFP_ATOMIC);
 674         if (unlikely(rc)) {                     /* usb send failed */
 675                 atomic_dec(&dev->active_tx_urbs);
 676
 677                 can_free_echo_skb(netdev, idx, NULL);
 678                 gs_free_tx_context(txc);
 679
 680                 usb_unanchor_urb(urb);
 681                 usb_free_coherent(dev->udev, urb->transfer_buffer_length,
 682                                   urb->transfer_buffer, urb->transfer_dma);
 683
 684                 if (rc == -ENODEV) {
 685                         netif_device_detach(netdev);
 686                 } else {
 687                         netdev_err(netdev, "usb_submit failed (err=%d)\n", rc);
 688                         stats->tx_dropped++;
 689                 }
 690         } else {
 691                 /* Slow down tx path */
 692                 if (atomic_read(&dev->active_tx_urbs) >= GS_MAX_TX_URBS)
 693                         netif_stop_queue(netdev);
 694         }
 695
 696         /* let usb core take care of this urb */
 697         usb_free_urb(urb);
 698
 699         return NETDEV_TX_OK;
 700
 701  badidx:
 702         usb_free_coherent(dev->udev, urb->transfer_buffer_length,
 703                           urb->transfer_buffer, urb->transfer_dma);
 704  nomem_hf:
 705         usb_free_urb(urb);
 706
 707  nomem_urb:
 708         gs_free_tx_context(txc);
 709         dev_kfree_skb(skb);
 710         stats->tx_dropped++;
 711         return NETDEV_TX_OK;
 712 }
 713
 714 static int gs_can_open(struct net_device *netdev)
 715 {
 716         struct gs_can *dev = netdev_priv(netdev);
 717         struct gs_usb *parent = dev->parent;
 718         int rc, i;
 719         struct gs_device_mode *dm;
 720         struct gs_host_frame *hf;
 721         u32 ctrlmode;
 722         u32 flags = 0;
 723
 724         rc = open_candev(netdev);
 725         if (rc)
 726                 return rc;
 727
 728         ctrlmode = dev->can.ctrlmode;
 729         if (ctrlmode & CAN_CTRLMODE_FD) {
 730                 flags |= GS_CAN_MODE_FD;
 731
 732                 if (dev->feature & GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX)
 733                         dev->hf_size_tx = struct_size(hf, canfd_quirk, 1);
 734                 else
 735                         dev->hf_size_tx = struct_size(hf, canfd, 1);
 736         } else {
 737                 if (dev->feature & GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX)
 738                         dev->hf_size_tx = struct_size(hf, classic_can_quirk, 1);
 739                 else
 740                         dev->hf_size_tx = struct_size(hf, classic_can, 1);
 741         }
 742
 743         if (!parent->active_channels) {
 744                 for (i = 0; i < GS_MAX_RX_URBS; i++) {
 745                         struct urb *urb;
 746                         u8 *buf;
 747                         dma_addr_t buf_dma;
 748
 749                         /* alloc rx urb */
 750                         urb = usb_alloc_urb(0, GFP_KERNEL);
 751                         if (!urb)
 752                                 return -ENOMEM;
 753
 754                         /* alloc rx buffer */
 755                         buf = usb_alloc_coherent(dev->udev,
 756                                                  dev->parent->hf_size_rx,
 757                                                  GFP_KERNEL,
 758                                                  &buf_dma);
 759                         if (!buf) {
 760                                 netdev_err(netdev,
 761                                            "No memory left for USB buffer\n");
 762                                 usb_free_urb(urb);
 763                                 return -ENOMEM;
 764                         }
 765
 766                         urb->transfer_dma = buf_dma;
 767
 768                         /* fill, anchor, and submit rx urb */
 769                         usb_fill_bulk_urb(urb,
 770                                           dev->udev,
 771                                           usb_rcvbulkpipe(dev->udev,
 772                                                           GSUSB_ENDPOINT_IN),
 773                                           buf,
 774                                           dev->parent->hf_size_rx,
 775                                           gs_usb_receive_bulk_callback, parent);
 776                         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 777
 778                         usb_anchor_urb(urb, &parent->rx_submitted);
 779
 780                         rc = usb_submit_urb(urb, GFP_KERNEL);
 781                         if (rc) {
 782                                 if (rc == -ENODEV)
 783                                         netif_device_detach(dev->netdev);
 784
 785                                 netdev_err(netdev,
 786                                            "usb_submit failed (err=%d)\n", rc);
 787
 788                                 usb_unanchor_urb(urb);
 789                                 usb_free_coherent(dev->udev,
 790                                                   sizeof(struct gs_host_frame),
 791                                                   buf,
 792                                                   buf_dma);
 793                                 usb_free_urb(urb);
 794                                 break;
 795                         }
 796
 797                         dev->rxbuf[i] = buf;
 798                         dev->rxbuf_dma[i] = buf_dma;
 799
 800                         /* Drop reference,
 801                          * USB core will take care of freeing it
 802                          */
 803                         usb_free_urb(urb);
 804                 }
 805         }
 806
 807         dm = kmalloc(sizeof(*dm), GFP_KERNEL);
 808         if (!dm)
 809                 return -ENOMEM;
 810
 811         /* flags */
 812         if (ctrlmode & CAN_CTRLMODE_LOOPBACK)
 813                 flags |= GS_CAN_MODE_LOOP_BACK;
 814         else if (ctrlmode & CAN_CTRLMODE_LISTENONLY)
 815                 flags |= GS_CAN_MODE_LISTEN_ONLY;
 816
 817         /* Controller is not allowed to retry TX
 818          * this mode is unavailable on atmels uc3c hardware
 819          */
 820         if (ctrlmode & CAN_CTRLMODE_ONE_SHOT)
 821                 flags |= GS_CAN_MODE_ONE_SHOT;
 822
 823         if (ctrlmode & CAN_CTRLMODE_3_SAMPLES)
 824                 flags |= GS_CAN_MODE_TRIPLE_SAMPLE;
 825
 826         /* finally start device */
 827         dm->mode = cpu_to_le32(GS_CAN_MODE_START);
 828         dm->flags = cpu_to_le32(flags);
 829         rc = usb_control_msg(interface_to_usbdev(dev->iface),
 830                              usb_sndctrlpipe(interface_to_usbdev(dev->iface), 0),
 831                              GS_USB_BREQ_MODE,
 832                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 833                              dev->channel, 0, dm, sizeof(*dm), 1000);
 834
 835         if (rc < 0) {
 836                 netdev_err(netdev, "Couldn't start device (err=%d)\n", rc);
 837                 kfree(dm);
 838                 return rc;
 839         }
 840
 841         kfree(dm);
 842
 843         dev->can.state = CAN_STATE_ERROR_ACTIVE;
 844
 845         parent->active_channels++;
 846         if (!(dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY))
 847                 netif_start_queue(netdev);
 848
 849         return 0;
 850 }
 851
 852 static int gs_can_close(struct net_device *netdev)
 853 {
 854         int rc;
 855         struct gs_can *dev = netdev_priv(netdev);
 856         struct gs_usb *parent = dev->parent;
 857         unsigned int i;
 858
 859         netif_stop_queue(netdev);
 860
 861         /* Stop polling */
 862         parent->active_channels--;
 863         if (!parent->active_channels) {
 864                 usb_kill_anchored_urbs(&parent->rx_submitted);
 865                 for (i = 0; i < GS_MAX_RX_URBS; i++)
 866                         usb_free_coherent(dev->udev,
 867                                           sizeof(struct gs_host_frame),
 868                                           dev->rxbuf[i],
 869                                           dev->rxbuf_dma[i]);
 870         }
 871
 872         /* Stop sending URBs */
 873         usb_kill_anchored_urbs(&dev->tx_submitted);
 874         atomic_set(&dev->active_tx_urbs, 0);
 875
 876         /* reset the device */
 877         rc = gs_cmd_reset(dev);
 878         if (rc < 0)
 879                 netdev_warn(netdev, "Couldn't shutdown device (err=%d)", rc);
 880
 881         /* reset tx contexts */
 882         for (rc = 0; rc < GS_MAX_TX_URBS; rc++) {
 883                 dev->tx_context[rc].dev = dev;
 884                 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS;
 885         }
 886
 887         /* close the netdev */
 888         close_candev(netdev);
 889
 890         return 0;
 891 }
 892
 893 static const struct net_device_ops gs_usb_netdev_ops = {
 894         .ndo_open = gs_can_open,
 895         .ndo_stop = gs_can_close,
 896         .ndo_start_xmit = gs_can_start_xmit,
 897         .ndo_change_mtu = can_change_mtu,
 898 };
 899
 900 static int gs_usb_set_identify(struct net_device *netdev, bool do_identify)
 901 {
 902         struct gs_can *dev = netdev_priv(netdev);
 903         struct gs_identify_mode *imode;
 904         int rc;
 905
 906         imode = kmalloc(sizeof(*imode), GFP_KERNEL);
 907
 908         if (!imode)
 909                 return -ENOMEM;
 910
 911         if (do_identify)
 912                 imode->mode = cpu_to_le32(GS_CAN_IDENTIFY_ON);
 913         else
 914                 imode->mode = cpu_to_le32(GS_CAN_IDENTIFY_OFF);
 915
 916         rc = usb_control_msg(interface_to_usbdev(dev->iface),
 917                              usb_sndctrlpipe(interface_to_usbdev(dev->iface), 0),
 918                              GS_USB_BREQ_IDENTIFY,
 919                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 920                              dev->channel, 0, imode, sizeof(*imode), 100);
 921
 922         kfree(imode);
 923
 924         return (rc > 0) ? 0 : rc;
 925 }
 926
 927 /* blink LED's for finding the this interface */
 928 static int gs_usb_set_phys_id(struct net_device *dev,
 929                               enum ethtool_phys_id_state state)
 930 {
 931         int rc = 0;
 932
 933         switch (state) {
 934         case ETHTOOL_ID_ACTIVE:
 935                 rc = gs_usb_set_identify(dev, GS_CAN_IDENTIFY_ON);
 936                 break;
 937         case ETHTOOL_ID_INACTIVE:
 938                 rc = gs_usb_set_identify(dev, GS_CAN_IDENTIFY_OFF);
 939                 break;
 940         default:
 941                 break;
 942         }
 943
 944         return rc;
 945 }
 946
 947 static const struct ethtool_ops gs_usb_ethtool_ops = {
 948         .set_phys_id = gs_usb_set_phys_id,
 949         .get_ts_info = ethtool_op_get_ts_info,
 950 };
 951
 952 static struct gs_can *gs_make_candev(unsigned int channel,
 953                                      struct usb_interface *intf,
 954                                      struct gs_device_config *dconf)
 955 {
 956         struct gs_can *dev;
 957         struct net_device *netdev;
 958         int rc;
 959         struct gs_device_bt_const *bt_const;
 960         struct gs_device_bt_const_extended *bt_const_extended;
 961         u32 feature;
 962
 963         bt_const = kmalloc(sizeof(*bt_const), GFP_KERNEL);
 964         if (!bt_const)
 965                 return ERR_PTR(-ENOMEM);
 966
 967         /* fetch bit timing constants */
 968         rc = usb_control_msg(interface_to_usbdev(intf),
 969                              usb_rcvctrlpipe(interface_to_usbdev(intf), 0),
 970                              GS_USB_BREQ_BT_CONST,
 971                              USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 972                              channel, 0, bt_const, sizeof(*bt_const), 1000);
 973
 974         if (rc < 0) {
 975                 dev_err(&intf->dev,
 976                         "Couldn't get bit timing const for channel (err=%d)\n",
 977                         rc);
 978                 kfree(bt_const);
 979                 return ERR_PTR(rc);
 980         }
 981
 982         /* create netdev */
 983         netdev = alloc_candev(sizeof(struct gs_can), GS_MAX_TX_URBS);
 984         if (!netdev) {
 985                 dev_err(&intf->dev, "Couldn't allocate candev\n");
 986                 kfree(bt_const);
 987                 return ERR_PTR(-ENOMEM);
 988         }
 989
 990         dev = netdev_priv(netdev);
 991
 992         netdev->netdev_ops = &gs_usb_netdev_ops;
 993         netdev->ethtool_ops = &gs_usb_ethtool_ops;
 994
 995         netdev->flags |= IFF_ECHO; /* we support full roundtrip echo */
 996
 997         /* dev setup */
 998         strcpy(dev->bt_const.name, KBUILD_MODNAME);
 999         dev->bt_const.tseg1_min = le32_to_cpu(bt_const->tseg1_min);
1000         dev->bt_const.tseg1_max = le32_to_cpu(bt_const->tseg1_max);
1001         dev->bt_const.tseg2_min = le32_to_cpu(bt_const->tseg2_min);
1002         dev->bt_const.tseg2_max = le32_to_cpu(bt_const->tseg2_max);
1003         dev->bt_const.sjw_max = le32_to_cpu(bt_const->sjw_max);
1004         dev->bt_const.brp_min = le32_to_cpu(bt_const->brp_min);
1005         dev->bt_const.brp_max = le32_to_cpu(bt_const->brp_max);
1006         dev->bt_const.brp_inc = le32_to_cpu(bt_const->brp_inc);
1007
1008         dev->udev = interface_to_usbdev(intf);
1009         dev->iface = intf;
1010         dev->netdev = netdev;
1011         dev->channel = channel;
1012
1013         init_usb_anchor(&dev->tx_submitted);
1014         atomic_set(&dev->active_tx_urbs, 0);
1015         spin_lock_init(&dev->tx_ctx_lock);
1016         for (rc = 0; rc < GS_MAX_TX_URBS; rc++) {
1017                 dev->tx_context[rc].dev = dev;
1018                 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS;
1019         }
1020
1021         /* can setup */
1022         dev->can.state = CAN_STATE_STOPPED;
1023         dev->can.clock.freq = le32_to_cpu(bt_const->fclk_can);
1024         dev->can.bittiming_const = &dev->bt_const;
1025         dev->can.do_set_bittiming = gs_usb_set_bittiming;
1026
1027         dev->can.ctrlmode_supported = CAN_CTRLMODE_CC_LEN8_DLC;
1028
1029         feature = le32_to_cpu(bt_const->feature);
1030         dev->feature = FIELD_GET(GS_CAN_FEATURE_MASK, feature);
1031         if (feature & GS_CAN_FEATURE_LISTEN_ONLY)
1032                 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY;
1033
1034         if (feature & GS_CAN_FEATURE_LOOP_BACK)
1035                 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK;
1036
1037         if (feature & GS_CAN_FEATURE_TRIPLE_SAMPLE)
1038                 dev->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
1039
1040         if (feature & GS_CAN_FEATURE_ONE_SHOT)
1041                 dev->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT;
1042
1043         if (feature & GS_CAN_FEATURE_FD) {
1044                 dev->can.ctrlmode_supported |= CAN_CTRLMODE_FD;
1045                 /* The data bit timing will be overwritten, if
1046                  * GS_CAN_FEATURE_BT_CONST_EXT is set.
1047                  */
1048                 dev->can.data_bittiming_const = &dev->bt_const;
1049                 dev->can.do_set_data_bittiming = gs_usb_set_data_bittiming;
1050         }
1051
1052         /* The CANtact Pro from LinkLayer Labs is based on the
1053          * LPC54616 µC, which is affected by the NXP LPC USB transfer
1054          * erratum. However, the current firmware (version 2) doesn't
1055          * set the GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX bit. Set the
1056          * feature GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX to workaround
1057          * this issue.
1058          *
1059          * For the GS_USB_BREQ_DATA_BITTIMING USB control message the
1060          * CANtact Pro firmware uses a request value, which is already
1061          * used by the candleLight firmware for a different purpose
1062          * (GS_USB_BREQ_GET_USER_ID). Set the feature
1063          * GS_CAN_FEATURE_QUIRK_BREQ_CANTACT_PRO to workaround this
1064          * issue.
1065          */
1066         if (dev->udev->descriptor.idVendor == cpu_to_le16(USB_GSUSB_1_VENDOR_ID) &&
1067             dev->udev->descriptor.idProduct == cpu_to_le16(USB_GSUSB_1_PRODUCT_ID) &&
1068             dev->udev->manufacturer && dev->udev->product &&
1069             !strcmp(dev->udev->manufacturer, "LinkLayer Labs") &&
1070             !strcmp(dev->udev->product, "CANtact Pro") &&
1071             (le32_to_cpu(dconf->sw_version) <= 2))
1072                 dev->feature |= GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX |
1073                         GS_CAN_FEATURE_QUIRK_BREQ_CANTACT_PRO;
1074
1075         if (le32_to_cpu(dconf->sw_version) > 1)
1076                 if (feature & GS_CAN_FEATURE_IDENTIFY)
1077                         netdev->ethtool_ops = &gs_usb_ethtool_ops;
1078
1079         kfree(bt_const);
1080
1081         /* fetch extended bit timing constants if device has feature
1082          * GS_CAN_FEATURE_FD and GS_CAN_FEATURE_BT_CONST_EXT
1083          */
1084         if (feature & GS_CAN_FEATURE_FD &&
1085             feature & GS_CAN_FEATURE_BT_CONST_EXT) {
1086                 bt_const_extended = kmalloc(sizeof(*bt_const_extended), GFP_KERNEL);
1087                 if (!bt_const_extended)
1088                         return ERR_PTR(-ENOMEM);
1089
1090                 rc = usb_control_msg(interface_to_usbdev(intf),
1091                                      usb_rcvctrlpipe(interface_to_usbdev(intf), 0),
1092                                      GS_USB_BREQ_BT_CONST_EXT,
1093                                      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1094                                      channel, 0, bt_const_extended,
1095                                      sizeof(*bt_const_extended),
1096                                      1000);
1097                 if (rc < 0) {
1098                         dev_err(&intf->dev,
1099                                 "Couldn't get extended bit timing const for channel (err=%d)\n",
1100                                 rc);
1101                         kfree(bt_const_extended);
1102                         return ERR_PTR(rc);
1103                 }
1104
1105                 strcpy(dev->data_bt_const.name, KBUILD_MODNAME);
1106                 dev->data_bt_const.tseg1_min = le32_to_cpu(bt_const_extended->dtseg1_min);
1107                 dev->data_bt_const.tseg1_max = le32_to_cpu(bt_const_extended->dtseg1_max);
1108                 dev->data_bt_const.tseg2_min = le32_to_cpu(bt_const_extended->dtseg2_min);
1109                 dev->data_bt_const.tseg2_max = le32_to_cpu(bt_const_extended->dtseg2_max);
1110                 dev->data_bt_const.sjw_max = le32_to_cpu(bt_const_extended->dsjw_max);
1111                 dev->data_bt_const.brp_min = le32_to_cpu(bt_const_extended->dbrp_min);
1112                 dev->data_bt_const.brp_max = le32_to_cpu(bt_const_extended->dbrp_max);
1113                 dev->data_bt_const.brp_inc = le32_to_cpu(bt_const_extended->dbrp_inc);
1114
1115                 dev->can.data_bittiming_const = &dev->data_bt_const;
1116
1117                 kfree(bt_const_extended);
1118         }
1119
1120         SET_NETDEV_DEV(netdev, &intf->dev);
1121
1122         rc = register_candev(dev->netdev);
1123         if (rc) {
1124                 free_candev(dev->netdev);
1125                 dev_err(&intf->dev, "Couldn't register candev (err=%d)\n", rc);
1126                 return ERR_PTR(rc);
1127         }
1128
1129         return dev;
1130 }
1131
1132 static void gs_destroy_candev(struct gs_can *dev)
1133 {
1134         unregister_candev(dev->netdev);
1135         usb_kill_anchored_urbs(&dev->tx_submitted);
1136         free_candev(dev->netdev);
1137 }
1138
1139 static int gs_usb_probe(struct usb_interface *intf,
1140                         const struct usb_device_id *id)
1141 {
1142         struct usb_device *udev = interface_to_usbdev(intf);
1143         struct gs_host_frame *hf;
1144         struct gs_usb *dev;
1145         int rc = -ENOMEM;
1146         unsigned int icount, i;
1147         struct gs_host_config *hconf;
1148         struct gs_device_config *dconf;
1149
1150         hconf = kmalloc(sizeof(*hconf), GFP_KERNEL);
1151         if (!hconf)
1152                 return -ENOMEM;
1153
1154         hconf->byte_order = cpu_to_le32(0x0000beef);
1155
1156         /* send host config */
1157         rc = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
1158                              GS_USB_BREQ_HOST_FORMAT,
1159                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1160                              1, intf->cur_altsetting->desc.bInterfaceNumber,
1161                              hconf, sizeof(*hconf), 1000);
1162
1163         kfree(hconf);
1164
1165         if (rc < 0) {
1166                 dev_err(&intf->dev, "Couldn't send data format (err=%d)\n", rc);
1167                 return rc;
1168         }
1169
1170         dconf = kmalloc(sizeof(*dconf), GFP_KERNEL);
1171         if (!dconf)
1172                 return -ENOMEM;
1173
1174         /* read device config */
1175         rc = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
1176                              GS_USB_BREQ_DEVICE_CONFIG,
1177                              USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
1178                              1, intf->cur_altsetting->desc.bInterfaceNumber,
1179                              dconf, sizeof(*dconf), 1000);
1180         if (rc < 0) {
1181                 dev_err(&intf->dev, "Couldn't get device config: (err=%d)\n",
1182                         rc);
1183                 kfree(dconf);
1184                 return rc;
1185         }
1186
1187         icount = dconf->icount + 1;
1188         dev_info(&intf->dev, "Configuring for %u interfaces\n", icount);
1189
1190         if (icount > GS_MAX_INTF) {
1191                 dev_err(&intf->dev,
1192                         "Driver cannot handle more that %u CAN interfaces\n",
1193                         GS_MAX_INTF);
1194                 kfree(dconf);
1195                 return -EINVAL;
1196         }
1197
1198         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1199         if (!dev) {
1200                 kfree(dconf);
1201                 return -ENOMEM;
1202         }
1203
1204         init_usb_anchor(&dev->rx_submitted);
1205         /* default to classic CAN, switch to CAN-FD if at least one of
1206          * our channels support CAN-FD.
1207          */
1208         dev->hf_size_rx = struct_size(hf, classic_can, 1);
1209
1210         usb_set_intfdata(intf, dev);
1211         dev->udev = udev;
1212
1213         for (i = 0; i < icount; i++) {
1214                 dev->canch[i] = gs_make_candev(i, intf, dconf);
1215                 if (IS_ERR_OR_NULL(dev->canch[i])) {
1216                         /* save error code to return later */
1217                         rc = PTR_ERR(dev->canch[i]);
1218
1219                         /* on failure destroy previously created candevs */
1220                         icount = i;
1221                         for (i = 0; i < icount; i++)
1222                                 gs_destroy_candev(dev->canch[i]);
1223
1224                         usb_kill_anchored_urbs(&dev->rx_submitted);
1225                         kfree(dconf);
1226                         kfree(dev);
1227                         return rc;
1228                 }
1229                 dev->canch[i]->parent = dev;
1230
1231                 if (dev->canch[i]->can.ctrlmode_supported & CAN_CTRLMODE_FD)
1232                         dev->hf_size_rx = struct_size(hf, canfd, 1);
1233         }
1234
1235         kfree(dconf);
1236
1237         return 0;
1238 }
1239
1240 static void gs_usb_disconnect(struct usb_interface *intf)
1241 {
1242         struct gs_usb *dev = usb_get_intfdata(intf);
1243         unsigned int i;
1244
1245         usb_set_intfdata(intf, NULL);
1246
1247         if (!dev) {
1248                 dev_err(&intf->dev, "Disconnect (nodata)\n");
1249                 return;
1250         }
1251
1252         for (i = 0; i < GS_MAX_INTF; i++)
1253                 if (dev->canch[i])
1254                         gs_destroy_candev(dev->canch[i]);
1255
1256         usb_kill_anchored_urbs(&dev->rx_submitted);
1257         kfree(dev);
1258 }
1259
1260 static const struct usb_device_id gs_usb_table[] = {
1261         { USB_DEVICE_INTERFACE_NUMBER(USB_GSUSB_1_VENDOR_ID,
1262                                       USB_GSUSB_1_PRODUCT_ID, 0) },
1263         { USB_DEVICE_INTERFACE_NUMBER(USB_CANDLELIGHT_VENDOR_ID,
1264                                       USB_CANDLELIGHT_PRODUCT_ID, 0) },
1265         { USB_DEVICE_INTERFACE_NUMBER(USB_CES_CANEXT_FD_VENDOR_ID,
1266                                       USB_CES_CANEXT_FD_PRODUCT_ID, 0) },
1267         { USB_DEVICE_INTERFACE_NUMBER(USB_ABE_CANDEBUGGER_FD_VENDOR_ID,
1268                                       USB_ABE_CANDEBUGGER_FD_PRODUCT_ID, 0) },
1269         {} /* Terminating entry */
1270 };
1271
1272 MODULE_DEVICE_TABLE(usb, gs_usb_table);
1273
1274 static struct usb_driver gs_usb_driver = {
1275         .name = KBUILD_MODNAME,
1276         .probe = gs_usb_probe,
1277         .disconnect = gs_usb_disconnect,
1278         .id_table = gs_usb_table,
1279 };
1280
1281 module_usb_driver(gs_usb_driver);
1282
1283 MODULE_AUTHOR("Maximilian Schneider <[email protected]>");
1284 MODULE_DESCRIPTION(
1285 "Socket CAN device driver for Geschwister Schneider Technologie-, "
1286 "Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces\n"
1287 "and bytewerk.org candleLight USB CAN interfaces.");
1288 MODULE_LICENSE("GPL v2");