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 ×tamp, 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, ×tamp); 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"); 1494