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