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