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