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 u32 feature; 307 unsigned int hf_size_tx; 308 309 /* This lock prevents a race condition between xmit and receive. */ 310 spinlock_t tx_ctx_lock; 311 struct gs_tx_context tx_context[GS_MAX_TX_URBS]; 312 313 struct usb_anchor tx_submitted; 314 atomic_t active_tx_urbs; 315 }; 316 317 /* usb interface struct */ 318 struct gs_usb { 319 struct gs_can *canch[GS_MAX_INTF]; 320 struct usb_anchor rx_submitted; 321 struct usb_device *udev; 322 323 /* time counter for hardware timestamps */ 324 struct cyclecounter cc; 325 struct timecounter tc; 326 spinlock_t tc_lock; /* spinlock to guard access tc->cycle_last */ 327 struct delayed_work timestamp; 328 329 unsigned int hf_size_rx; 330 u8 active_channels; 331 }; 332 333 /* 'allocate' a tx context. 334 * returns a valid tx context or NULL if there is no space. 335 */ 336 static struct gs_tx_context *gs_alloc_tx_context(struct gs_can *dev) 337 { 338 int i = 0; 339 unsigned long flags; 340 341 spin_lock_irqsave(&dev->tx_ctx_lock, flags); 342 343 for (; i < GS_MAX_TX_URBS; i++) { 344 if (dev->tx_context[i].echo_id == GS_MAX_TX_URBS) { 345 dev->tx_context[i].echo_id = i; 346 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags); 347 return &dev->tx_context[i]; 348 } 349 } 350 351 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags); 352 return NULL; 353 } 354 355 /* releases a tx context 356 */ 357 static void gs_free_tx_context(struct gs_tx_context *txc) 358 { 359 txc->echo_id = GS_MAX_TX_URBS; 360 } 361 362 /* Get a tx context by id. 363 */ 364 static struct gs_tx_context *gs_get_tx_context(struct gs_can *dev, 365 unsigned int id) 366 { 367 unsigned long flags; 368 369 if (id < GS_MAX_TX_URBS) { 370 spin_lock_irqsave(&dev->tx_ctx_lock, flags); 371 if (dev->tx_context[id].echo_id == id) { 372 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags); 373 return &dev->tx_context[id]; 374 } 375 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags); 376 } 377 return NULL; 378 } 379 380 static int gs_cmd_reset(struct gs_can *dev) 381 { 382 struct gs_device_mode dm = { 383 .mode = GS_CAN_MODE_RESET, 384 }; 385 386 return usb_control_msg_send(dev->udev, 0, GS_USB_BREQ_MODE, 387 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 388 dev->channel, 0, &dm, sizeof(dm), 1000, 389 GFP_KERNEL); 390 } 391 392 static inline int gs_usb_get_timestamp(const struct gs_usb *parent, 393 u32 *timestamp_p) 394 { 395 __le32 timestamp; 396 int rc; 397 398 rc = usb_control_msg_recv(parent->udev, 0, GS_USB_BREQ_TIMESTAMP, 399 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 400 0, 0, 401 ×tamp, sizeof(timestamp), 402 USB_CTRL_GET_TIMEOUT, 403 GFP_KERNEL); 404 if (rc) 405 return rc; 406 407 *timestamp_p = le32_to_cpu(timestamp); 408 409 return 0; 410 } 411 412 static u64 gs_usb_timestamp_read(const struct cyclecounter *cc) __must_hold(&dev->tc_lock) 413 { 414 struct gs_usb *parent = container_of(cc, struct gs_usb, cc); 415 u32 timestamp = 0; 416 int err; 417 418 lockdep_assert_held(&parent->tc_lock); 419 420 /* drop lock for synchronous USB transfer */ 421 spin_unlock_bh(&parent->tc_lock); 422 err = gs_usb_get_timestamp(parent, ×tamp); 423 spin_lock_bh(&parent->tc_lock); 424 if (err) 425 dev_err(&parent->udev->dev, 426 "Error %d while reading timestamp. HW timestamps may be inaccurate.", 427 err); 428 429 return timestamp; 430 } 431 432 static void gs_usb_timestamp_work(struct work_struct *work) 433 { 434 struct delayed_work *delayed_work = to_delayed_work(work); 435 struct gs_usb *parent; 436 437 parent = container_of(delayed_work, struct gs_usb, timestamp); 438 spin_lock_bh(&parent->tc_lock); 439 timecounter_read(&parent->tc); 440 spin_unlock_bh(&parent->tc_lock); 441 442 schedule_delayed_work(&parent->timestamp, 443 GS_USB_TIMESTAMP_WORK_DELAY_SEC * HZ); 444 } 445 446 static void gs_usb_skb_set_timestamp(struct gs_can *dev, 447 struct sk_buff *skb, u32 timestamp) 448 { 449 struct skb_shared_hwtstamps *hwtstamps = skb_hwtstamps(skb); 450 struct gs_usb *parent = dev->parent; 451 u64 ns; 452 453 spin_lock_bh(&parent->tc_lock); 454 ns = timecounter_cyc2time(&parent->tc, timestamp); 455 spin_unlock_bh(&parent->tc_lock); 456 457 hwtstamps->hwtstamp = ns_to_ktime(ns); 458 } 459 460 static void gs_usb_timestamp_init(struct gs_usb *parent) 461 { 462 struct cyclecounter *cc = &parent->cc; 463 464 cc->read = gs_usb_timestamp_read; 465 cc->mask = CYCLECOUNTER_MASK(32); 466 cc->shift = 32 - bits_per(NSEC_PER_SEC / GS_USB_TIMESTAMP_TIMER_HZ); 467 cc->mult = clocksource_hz2mult(GS_USB_TIMESTAMP_TIMER_HZ, cc->shift); 468 469 spin_lock_init(&parent->tc_lock); 470 spin_lock_bh(&parent->tc_lock); 471 timecounter_init(&parent->tc, &parent->cc, ktime_get_real_ns()); 472 spin_unlock_bh(&parent->tc_lock); 473 474 INIT_DELAYED_WORK(&parent->timestamp, gs_usb_timestamp_work); 475 schedule_delayed_work(&parent->timestamp, 476 GS_USB_TIMESTAMP_WORK_DELAY_SEC * HZ); 477 } 478 479 static void gs_usb_timestamp_stop(struct gs_usb *parent) 480 { 481 cancel_delayed_work_sync(&parent->timestamp); 482 } 483 484 static void gs_update_state(struct gs_can *dev, struct can_frame *cf) 485 { 486 struct can_device_stats *can_stats = &dev->can.can_stats; 487 488 if (cf->can_id & CAN_ERR_RESTARTED) { 489 dev->can.state = CAN_STATE_ERROR_ACTIVE; 490 can_stats->restarts++; 491 } else if (cf->can_id & CAN_ERR_BUSOFF) { 492 dev->can.state = CAN_STATE_BUS_OFF; 493 can_stats->bus_off++; 494 } else if (cf->can_id & CAN_ERR_CRTL) { 495 if ((cf->data[1] & CAN_ERR_CRTL_TX_WARNING) || 496 (cf->data[1] & CAN_ERR_CRTL_RX_WARNING)) { 497 dev->can.state = CAN_STATE_ERROR_WARNING; 498 can_stats->error_warning++; 499 } else if ((cf->data[1] & CAN_ERR_CRTL_TX_PASSIVE) || 500 (cf->data[1] & CAN_ERR_CRTL_RX_PASSIVE)) { 501 dev->can.state = CAN_STATE_ERROR_PASSIVE; 502 can_stats->error_passive++; 503 } else { 504 dev->can.state = CAN_STATE_ERROR_ACTIVE; 505 } 506 } 507 } 508 509 static void gs_usb_set_timestamp(struct gs_can *dev, struct sk_buff *skb, 510 const struct gs_host_frame *hf) 511 { 512 u32 timestamp; 513 514 if (!(dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP)) 515 return; 516 517 if (hf->flags & GS_CAN_FLAG_FD) 518 timestamp = le32_to_cpu(hf->canfd_ts->timestamp_us); 519 else 520 timestamp = le32_to_cpu(hf->classic_can_ts->timestamp_us); 521 522 gs_usb_skb_set_timestamp(dev, skb, timestamp); 523 524 return; 525 } 526 527 static void gs_usb_receive_bulk_callback(struct urb *urb) 528 { 529 struct gs_usb *usbcan = urb->context; 530 struct gs_can *dev; 531 struct net_device *netdev; 532 int rc; 533 struct net_device_stats *stats; 534 struct gs_host_frame *hf = urb->transfer_buffer; 535 struct gs_tx_context *txc; 536 struct can_frame *cf; 537 struct canfd_frame *cfd; 538 struct sk_buff *skb; 539 540 BUG_ON(!usbcan); 541 542 switch (urb->status) { 543 case 0: /* success */ 544 break; 545 case -ENOENT: 546 case -ESHUTDOWN: 547 return; 548 default: 549 /* do not resubmit aborted urbs. eg: when device goes down */ 550 return; 551 } 552 553 /* device reports out of range channel id */ 554 if (hf->channel >= GS_MAX_INTF) 555 goto device_detach; 556 557 dev = usbcan->canch[hf->channel]; 558 559 netdev = dev->netdev; 560 stats = &netdev->stats; 561 562 if (!netif_device_present(netdev)) 563 return; 564 565 if (!netif_running(netdev)) 566 goto resubmit_urb; 567 568 if (hf->echo_id == -1) { /* normal rx */ 569 if (hf->flags & GS_CAN_FLAG_FD) { 570 skb = alloc_canfd_skb(dev->netdev, &cfd); 571 if (!skb) 572 return; 573 574 cfd->can_id = le32_to_cpu(hf->can_id); 575 cfd->len = can_fd_dlc2len(hf->can_dlc); 576 if (hf->flags & GS_CAN_FLAG_BRS) 577 cfd->flags |= CANFD_BRS; 578 if (hf->flags & GS_CAN_FLAG_ESI) 579 cfd->flags |= CANFD_ESI; 580 581 memcpy(cfd->data, hf->canfd->data, cfd->len); 582 } else { 583 skb = alloc_can_skb(dev->netdev, &cf); 584 if (!skb) 585 return; 586 587 cf->can_id = le32_to_cpu(hf->can_id); 588 can_frame_set_cc_len(cf, hf->can_dlc, dev->can.ctrlmode); 589 590 memcpy(cf->data, hf->classic_can->data, 8); 591 592 /* ERROR frames tell us information about the controller */ 593 if (le32_to_cpu(hf->can_id) & CAN_ERR_FLAG) 594 gs_update_state(dev, cf); 595 } 596 597 gs_usb_set_timestamp(dev, skb, hf); 598 599 netdev->stats.rx_packets++; 600 netdev->stats.rx_bytes += hf->can_dlc; 601 602 netif_rx(skb); 603 } else { /* echo_id == hf->echo_id */ 604 if (hf->echo_id >= GS_MAX_TX_URBS) { 605 netdev_err(netdev, 606 "Unexpected out of range echo id %u\n", 607 hf->echo_id); 608 goto resubmit_urb; 609 } 610 611 txc = gs_get_tx_context(dev, hf->echo_id); 612 613 /* bad devices send bad echo_ids. */ 614 if (!txc) { 615 netdev_err(netdev, 616 "Unexpected unused echo id %u\n", 617 hf->echo_id); 618 goto resubmit_urb; 619 } 620 621 skb = dev->can.echo_skb[hf->echo_id]; 622 gs_usb_set_timestamp(dev, skb, hf); 623 624 netdev->stats.tx_packets++; 625 netdev->stats.tx_bytes += can_get_echo_skb(netdev, hf->echo_id, 626 NULL); 627 628 gs_free_tx_context(txc); 629 630 atomic_dec(&dev->active_tx_urbs); 631 632 netif_wake_queue(netdev); 633 } 634 635 if (hf->flags & GS_CAN_FLAG_OVERFLOW) { 636 skb = alloc_can_err_skb(netdev, &cf); 637 if (!skb) 638 goto resubmit_urb; 639 640 cf->can_id |= CAN_ERR_CRTL; 641 cf->len = CAN_ERR_DLC; 642 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 643 stats->rx_over_errors++; 644 stats->rx_errors++; 645 netif_rx(skb); 646 } 647 648 resubmit_urb: 649 usb_fill_bulk_urb(urb, usbcan->udev, 650 usb_rcvbulkpipe(usbcan->udev, GS_USB_ENDPOINT_IN), 651 hf, dev->parent->hf_size_rx, 652 gs_usb_receive_bulk_callback, usbcan); 653 654 rc = usb_submit_urb(urb, GFP_ATOMIC); 655 656 /* USB failure take down all interfaces */ 657 if (rc == -ENODEV) { 658 device_detach: 659 for (rc = 0; rc < GS_MAX_INTF; rc++) { 660 if (usbcan->canch[rc]) 661 netif_device_detach(usbcan->canch[rc]->netdev); 662 } 663 } 664 } 665 666 static int gs_usb_set_bittiming(struct net_device *netdev) 667 { 668 struct gs_can *dev = netdev_priv(netdev); 669 struct can_bittiming *bt = &dev->can.bittiming; 670 struct gs_device_bittiming dbt = { 671 .prop_seg = cpu_to_le32(bt->prop_seg), 672 .phase_seg1 = cpu_to_le32(bt->phase_seg1), 673 .phase_seg2 = cpu_to_le32(bt->phase_seg2), 674 .sjw = cpu_to_le32(bt->sjw), 675 .brp = cpu_to_le32(bt->brp), 676 }; 677 678 /* request bit timings */ 679 return usb_control_msg_send(dev->udev, 0, GS_USB_BREQ_BITTIMING, 680 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 681 dev->channel, 0, &dbt, sizeof(dbt), 1000, 682 GFP_KERNEL); 683 } 684 685 static int gs_usb_set_data_bittiming(struct net_device *netdev) 686 { 687 struct gs_can *dev = netdev_priv(netdev); 688 struct can_bittiming *bt = &dev->can.data_bittiming; 689 struct gs_device_bittiming dbt = { 690 .prop_seg = cpu_to_le32(bt->prop_seg), 691 .phase_seg1 = cpu_to_le32(bt->phase_seg1), 692 .phase_seg2 = cpu_to_le32(bt->phase_seg2), 693 .sjw = cpu_to_le32(bt->sjw), 694 .brp = cpu_to_le32(bt->brp), 695 }; 696 u8 request = GS_USB_BREQ_DATA_BITTIMING; 697 698 if (dev->feature & GS_CAN_FEATURE_QUIRK_BREQ_CANTACT_PRO) 699 request = GS_USB_BREQ_QUIRK_CANTACT_PRO_DATA_BITTIMING; 700 701 /* request data bit timings */ 702 return usb_control_msg_send(dev->udev, 0, request, 703 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 704 dev->channel, 0, &dbt, sizeof(dbt), 1000, 705 GFP_KERNEL); 706 } 707 708 static void gs_usb_xmit_callback(struct urb *urb) 709 { 710 struct gs_tx_context *txc = urb->context; 711 struct gs_can *dev = txc->dev; 712 struct net_device *netdev = dev->netdev; 713 714 if (urb->status) 715 netdev_info(netdev, "usb xmit fail %u\n", txc->echo_id); 716 } 717 718 static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb, 719 struct net_device *netdev) 720 { 721 struct gs_can *dev = netdev_priv(netdev); 722 struct net_device_stats *stats = &dev->netdev->stats; 723 struct urb *urb; 724 struct gs_host_frame *hf; 725 struct can_frame *cf; 726 struct canfd_frame *cfd; 727 int rc; 728 unsigned int idx; 729 struct gs_tx_context *txc; 730 731 if (can_dev_dropped_skb(netdev, skb)) 732 return NETDEV_TX_OK; 733 734 /* find an empty context to keep track of transmission */ 735 txc = gs_alloc_tx_context(dev); 736 if (!txc) 737 return NETDEV_TX_BUSY; 738 739 /* create a URB, and a buffer for it */ 740 urb = usb_alloc_urb(0, GFP_ATOMIC); 741 if (!urb) 742 goto nomem_urb; 743 744 hf = kmalloc(dev->hf_size_tx, GFP_ATOMIC); 745 if (!hf) { 746 netdev_err(netdev, "No memory left for USB buffer\n"); 747 goto nomem_hf; 748 } 749 750 idx = txc->echo_id; 751 752 if (idx >= GS_MAX_TX_URBS) { 753 netdev_err(netdev, "Invalid tx context %u\n", idx); 754 goto badidx; 755 } 756 757 hf->echo_id = idx; 758 hf->channel = dev->channel; 759 hf->flags = 0; 760 hf->reserved = 0; 761 762 if (can_is_canfd_skb(skb)) { 763 cfd = (struct canfd_frame *)skb->data; 764 765 hf->can_id = cpu_to_le32(cfd->can_id); 766 hf->can_dlc = can_fd_len2dlc(cfd->len); 767 hf->flags |= GS_CAN_FLAG_FD; 768 if (cfd->flags & CANFD_BRS) 769 hf->flags |= GS_CAN_FLAG_BRS; 770 if (cfd->flags & CANFD_ESI) 771 hf->flags |= GS_CAN_FLAG_ESI; 772 773 memcpy(hf->canfd->data, cfd->data, cfd->len); 774 } else { 775 cf = (struct can_frame *)skb->data; 776 777 hf->can_id = cpu_to_le32(cf->can_id); 778 hf->can_dlc = can_get_cc_dlc(cf, dev->can.ctrlmode); 779 780 memcpy(hf->classic_can->data, cf->data, cf->len); 781 } 782 783 usb_fill_bulk_urb(urb, dev->udev, 784 usb_sndbulkpipe(dev->udev, GS_USB_ENDPOINT_OUT), 785 hf, dev->hf_size_tx, 786 gs_usb_xmit_callback, txc); 787 788 urb->transfer_flags |= URB_FREE_BUFFER; 789 usb_anchor_urb(urb, &dev->tx_submitted); 790 791 can_put_echo_skb(skb, netdev, idx, 0); 792 793 atomic_inc(&dev->active_tx_urbs); 794 795 rc = usb_submit_urb(urb, GFP_ATOMIC); 796 if (unlikely(rc)) { /* usb send failed */ 797 atomic_dec(&dev->active_tx_urbs); 798 799 can_free_echo_skb(netdev, idx, NULL); 800 gs_free_tx_context(txc); 801 802 usb_unanchor_urb(urb); 803 804 if (rc == -ENODEV) { 805 netif_device_detach(netdev); 806 } else { 807 netdev_err(netdev, "usb_submit failed (err=%d)\n", rc); 808 stats->tx_dropped++; 809 } 810 } else { 811 /* Slow down tx path */ 812 if (atomic_read(&dev->active_tx_urbs) >= GS_MAX_TX_URBS) 813 netif_stop_queue(netdev); 814 } 815 816 /* let usb core take care of this urb */ 817 usb_free_urb(urb); 818 819 return NETDEV_TX_OK; 820 821 badidx: 822 kfree(hf); 823 nomem_hf: 824 usb_free_urb(urb); 825 826 nomem_urb: 827 gs_free_tx_context(txc); 828 dev_kfree_skb(skb); 829 stats->tx_dropped++; 830 return NETDEV_TX_OK; 831 } 832 833 static int gs_can_open(struct net_device *netdev) 834 { 835 struct gs_can *dev = netdev_priv(netdev); 836 struct gs_usb *parent = dev->parent; 837 struct gs_device_mode dm = { 838 .mode = cpu_to_le32(GS_CAN_MODE_START), 839 }; 840 struct gs_host_frame *hf; 841 struct urb *urb = NULL; 842 u32 ctrlmode; 843 u32 flags = 0; 844 int rc, i; 845 846 rc = open_candev(netdev); 847 if (rc) 848 return rc; 849 850 ctrlmode = dev->can.ctrlmode; 851 if (ctrlmode & CAN_CTRLMODE_FD) { 852 if (dev->feature & GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX) 853 dev->hf_size_tx = struct_size(hf, canfd_quirk, 1); 854 else 855 dev->hf_size_tx = struct_size(hf, canfd, 1); 856 } else { 857 if (dev->feature & GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX) 858 dev->hf_size_tx = struct_size(hf, classic_can_quirk, 1); 859 else 860 dev->hf_size_tx = struct_size(hf, classic_can, 1); 861 } 862 863 if (!parent->active_channels) { 864 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP) 865 gs_usb_timestamp_init(parent); 866 867 for (i = 0; i < GS_MAX_RX_URBS; i++) { 868 u8 *buf; 869 870 /* alloc rx urb */ 871 urb = usb_alloc_urb(0, GFP_KERNEL); 872 if (!urb) { 873 rc = -ENOMEM; 874 goto out_usb_kill_anchored_urbs; 875 } 876 877 /* alloc rx buffer */ 878 buf = kmalloc(dev->parent->hf_size_rx, 879 GFP_KERNEL); 880 if (!buf) { 881 netdev_err(netdev, 882 "No memory left for USB buffer\n"); 883 rc = -ENOMEM; 884 goto out_usb_free_urb; 885 } 886 887 /* fill, anchor, and submit rx urb */ 888 usb_fill_bulk_urb(urb, 889 dev->udev, 890 usb_rcvbulkpipe(dev->udev, 891 GS_USB_ENDPOINT_IN), 892 buf, 893 dev->parent->hf_size_rx, 894 gs_usb_receive_bulk_callback, parent); 895 urb->transfer_flags |= URB_FREE_BUFFER; 896 897 usb_anchor_urb(urb, &parent->rx_submitted); 898 899 rc = usb_submit_urb(urb, GFP_KERNEL); 900 if (rc) { 901 if (rc == -ENODEV) 902 netif_device_detach(dev->netdev); 903 904 netdev_err(netdev, 905 "usb_submit failed (err=%d)\n", rc); 906 907 goto out_usb_unanchor_urb; 908 } 909 910 /* Drop reference, 911 * USB core will take care of freeing it 912 */ 913 usb_free_urb(urb); 914 } 915 } 916 917 /* flags */ 918 if (ctrlmode & CAN_CTRLMODE_LOOPBACK) 919 flags |= GS_CAN_MODE_LOOP_BACK; 920 921 if (ctrlmode & CAN_CTRLMODE_LISTENONLY) 922 flags |= GS_CAN_MODE_LISTEN_ONLY; 923 924 if (ctrlmode & CAN_CTRLMODE_3_SAMPLES) 925 flags |= GS_CAN_MODE_TRIPLE_SAMPLE; 926 927 if (ctrlmode & CAN_CTRLMODE_ONE_SHOT) 928 flags |= GS_CAN_MODE_ONE_SHOT; 929 930 if (ctrlmode & CAN_CTRLMODE_BERR_REPORTING) 931 flags |= GS_CAN_MODE_BERR_REPORTING; 932 933 if (ctrlmode & CAN_CTRLMODE_FD) 934 flags |= GS_CAN_MODE_FD; 935 936 /* if hardware supports timestamps, enable it */ 937 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP) 938 flags |= GS_CAN_MODE_HW_TIMESTAMP; 939 940 /* finally start device */ 941 dev->can.state = CAN_STATE_ERROR_ACTIVE; 942 dm.flags = cpu_to_le32(flags); 943 rc = usb_control_msg_send(dev->udev, 0, GS_USB_BREQ_MODE, 944 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 945 dev->channel, 0, &dm, sizeof(dm), 1000, 946 GFP_KERNEL); 947 if (rc) { 948 netdev_err(netdev, "Couldn't start device (err=%d)\n", rc); 949 dev->can.state = CAN_STATE_STOPPED; 950 951 goto out_usb_kill_anchored_urbs; 952 } 953 954 parent->active_channels++; 955 if (!(dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)) 956 netif_start_queue(netdev); 957 958 return 0; 959 960 out_usb_unanchor_urb: 961 usb_unanchor_urb(urb); 962 out_usb_free_urb: 963 usb_free_urb(urb); 964 out_usb_kill_anchored_urbs: 965 if (!parent->active_channels) { 966 usb_kill_anchored_urbs(&dev->tx_submitted); 967 968 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP) 969 gs_usb_timestamp_stop(parent); 970 } 971 972 close_candev(netdev); 973 974 return rc; 975 } 976 977 static int gs_usb_get_state(const struct net_device *netdev, 978 struct can_berr_counter *bec, 979 enum can_state *state) 980 { 981 struct gs_can *dev = netdev_priv(netdev); 982 struct gs_device_state ds; 983 int rc; 984 985 rc = usb_control_msg_recv(dev->udev, 0, GS_USB_BREQ_GET_STATE, 986 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 987 dev->channel, 0, 988 &ds, sizeof(ds), 989 USB_CTRL_GET_TIMEOUT, 990 GFP_KERNEL); 991 if (rc) 992 return rc; 993 994 if (le32_to_cpu(ds.state) >= CAN_STATE_MAX) 995 return -EOPNOTSUPP; 996 997 *state = le32_to_cpu(ds.state); 998 bec->txerr = le32_to_cpu(ds.txerr); 999 bec->rxerr = le32_to_cpu(ds.rxerr); 1000 1001 return 0; 1002 } 1003 1004 static int gs_usb_can_get_berr_counter(const struct net_device *netdev, 1005 struct can_berr_counter *bec) 1006 { 1007 enum can_state state; 1008 1009 return gs_usb_get_state(netdev, bec, &state); 1010 } 1011 1012 static int gs_can_close(struct net_device *netdev) 1013 { 1014 int rc; 1015 struct gs_can *dev = netdev_priv(netdev); 1016 struct gs_usb *parent = dev->parent; 1017 1018 netif_stop_queue(netdev); 1019 1020 /* Stop polling */ 1021 parent->active_channels--; 1022 if (!parent->active_channels) { 1023 usb_kill_anchored_urbs(&parent->rx_submitted); 1024 1025 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP) 1026 gs_usb_timestamp_stop(parent); 1027 } 1028 1029 /* Stop sending URBs */ 1030 usb_kill_anchored_urbs(&dev->tx_submitted); 1031 atomic_set(&dev->active_tx_urbs, 0); 1032 1033 dev->can.state = CAN_STATE_STOPPED; 1034 1035 /* reset the device */ 1036 rc = gs_cmd_reset(dev); 1037 if (rc < 0) 1038 netdev_warn(netdev, "Couldn't shutdown device (err=%d)", rc); 1039 1040 /* reset tx contexts */ 1041 for (rc = 0; rc < GS_MAX_TX_URBS; rc++) { 1042 dev->tx_context[rc].dev = dev; 1043 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS; 1044 } 1045 1046 /* close the netdev */ 1047 close_candev(netdev); 1048 1049 return 0; 1050 } 1051 1052 static int gs_can_eth_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) 1053 { 1054 const struct gs_can *dev = netdev_priv(netdev); 1055 1056 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP) 1057 return can_eth_ioctl_hwts(netdev, ifr, cmd); 1058 1059 return -EOPNOTSUPP; 1060 } 1061 1062 static const struct net_device_ops gs_usb_netdev_ops = { 1063 .ndo_open = gs_can_open, 1064 .ndo_stop = gs_can_close, 1065 .ndo_start_xmit = gs_can_start_xmit, 1066 .ndo_change_mtu = can_change_mtu, 1067 .ndo_eth_ioctl = gs_can_eth_ioctl, 1068 }; 1069 1070 static int gs_usb_set_identify(struct net_device *netdev, bool do_identify) 1071 { 1072 struct gs_can *dev = netdev_priv(netdev); 1073 struct gs_identify_mode imode; 1074 1075 if (do_identify) 1076 imode.mode = cpu_to_le32(GS_CAN_IDENTIFY_ON); 1077 else 1078 imode.mode = cpu_to_le32(GS_CAN_IDENTIFY_OFF); 1079 1080 return usb_control_msg_send(dev->udev, 0, GS_USB_BREQ_IDENTIFY, 1081 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 1082 dev->channel, 0, &imode, sizeof(imode), 100, 1083 GFP_KERNEL); 1084 } 1085 1086 /* blink LED's for finding the this interface */ 1087 static int gs_usb_set_phys_id(struct net_device *netdev, 1088 enum ethtool_phys_id_state state) 1089 { 1090 const struct gs_can *dev = netdev_priv(netdev); 1091 int rc = 0; 1092 1093 if (!(dev->feature & GS_CAN_FEATURE_IDENTIFY)) 1094 return -EOPNOTSUPP; 1095 1096 switch (state) { 1097 case ETHTOOL_ID_ACTIVE: 1098 rc = gs_usb_set_identify(netdev, GS_CAN_IDENTIFY_ON); 1099 break; 1100 case ETHTOOL_ID_INACTIVE: 1101 rc = gs_usb_set_identify(netdev, GS_CAN_IDENTIFY_OFF); 1102 break; 1103 default: 1104 break; 1105 } 1106 1107 return rc; 1108 } 1109 1110 static int gs_usb_get_ts_info(struct net_device *netdev, 1111 struct ethtool_ts_info *info) 1112 { 1113 struct gs_can *dev = netdev_priv(netdev); 1114 1115 /* report if device supports HW timestamps */ 1116 if (dev->feature & GS_CAN_FEATURE_HW_TIMESTAMP) 1117 return can_ethtool_op_get_ts_info_hwts(netdev, info); 1118 1119 return ethtool_op_get_ts_info(netdev, info); 1120 } 1121 1122 static const struct ethtool_ops gs_usb_ethtool_ops = { 1123 .set_phys_id = gs_usb_set_phys_id, 1124 .get_ts_info = gs_usb_get_ts_info, 1125 }; 1126 1127 static int gs_usb_get_termination(struct net_device *netdev, u16 *term) 1128 { 1129 struct gs_can *dev = netdev_priv(netdev); 1130 struct gs_device_termination_state term_state; 1131 int rc; 1132 1133 rc = usb_control_msg_recv(dev->udev, 0, GS_USB_BREQ_GET_TERMINATION, 1134 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 1135 dev->channel, 0, 1136 &term_state, sizeof(term_state), 1000, 1137 GFP_KERNEL); 1138 if (rc) 1139 return rc; 1140 1141 if (term_state.state == cpu_to_le32(GS_CAN_TERMINATION_STATE_ON)) 1142 *term = GS_USB_TERMINATION_ENABLED; 1143 else 1144 *term = GS_USB_TERMINATION_DISABLED; 1145 1146 return 0; 1147 } 1148 1149 static int gs_usb_set_termination(struct net_device *netdev, u16 term) 1150 { 1151 struct gs_can *dev = netdev_priv(netdev); 1152 struct gs_device_termination_state term_state; 1153 1154 if (term == GS_USB_TERMINATION_ENABLED) 1155 term_state.state = cpu_to_le32(GS_CAN_TERMINATION_STATE_ON); 1156 else 1157 term_state.state = cpu_to_le32(GS_CAN_TERMINATION_STATE_OFF); 1158 1159 return usb_control_msg_send(dev->udev, 0, GS_USB_BREQ_SET_TERMINATION, 1160 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 1161 dev->channel, 0, 1162 &term_state, sizeof(term_state), 1000, 1163 GFP_KERNEL); 1164 } 1165 1166 static const u16 gs_usb_termination_const[] = { 1167 GS_USB_TERMINATION_DISABLED, 1168 GS_USB_TERMINATION_ENABLED 1169 }; 1170 1171 static struct gs_can *gs_make_candev(unsigned int channel, 1172 struct usb_interface *intf, 1173 struct gs_device_config *dconf) 1174 { 1175 struct gs_can *dev; 1176 struct net_device *netdev; 1177 int rc; 1178 struct gs_device_bt_const_extended bt_const_extended; 1179 struct gs_device_bt_const bt_const; 1180 u32 feature; 1181 1182 /* fetch bit timing constants */ 1183 rc = usb_control_msg_recv(interface_to_usbdev(intf), 0, 1184 GS_USB_BREQ_BT_CONST, 1185 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 1186 channel, 0, &bt_const, sizeof(bt_const), 1000, 1187 GFP_KERNEL); 1188 1189 if (rc) { 1190 dev_err(&intf->dev, 1191 "Couldn't get bit timing const for channel %d (%pe)\n", 1192 channel, ERR_PTR(rc)); 1193 return ERR_PTR(rc); 1194 } 1195 1196 /* create netdev */ 1197 netdev = alloc_candev(sizeof(struct gs_can), GS_MAX_TX_URBS); 1198 if (!netdev) { 1199 dev_err(&intf->dev, "Couldn't allocate candev\n"); 1200 return ERR_PTR(-ENOMEM); 1201 } 1202 1203 dev = netdev_priv(netdev); 1204 1205 netdev->netdev_ops = &gs_usb_netdev_ops; 1206 netdev->ethtool_ops = &gs_usb_ethtool_ops; 1207 1208 netdev->flags |= IFF_ECHO; /* we support full roundtrip echo */ 1209 netdev->dev_id = channel; 1210 1211 /* dev setup */ 1212 strcpy(dev->bt_const.name, KBUILD_MODNAME); 1213 dev->bt_const.tseg1_min = le32_to_cpu(bt_const.tseg1_min); 1214 dev->bt_const.tseg1_max = le32_to_cpu(bt_const.tseg1_max); 1215 dev->bt_const.tseg2_min = le32_to_cpu(bt_const.tseg2_min); 1216 dev->bt_const.tseg2_max = le32_to_cpu(bt_const.tseg2_max); 1217 dev->bt_const.sjw_max = le32_to_cpu(bt_const.sjw_max); 1218 dev->bt_const.brp_min = le32_to_cpu(bt_const.brp_min); 1219 dev->bt_const.brp_max = le32_to_cpu(bt_const.brp_max); 1220 dev->bt_const.brp_inc = le32_to_cpu(bt_const.brp_inc); 1221 1222 dev->udev = interface_to_usbdev(intf); 1223 dev->netdev = netdev; 1224 dev->channel = channel; 1225 1226 init_usb_anchor(&dev->tx_submitted); 1227 atomic_set(&dev->active_tx_urbs, 0); 1228 spin_lock_init(&dev->tx_ctx_lock); 1229 for (rc = 0; rc < GS_MAX_TX_URBS; rc++) { 1230 dev->tx_context[rc].dev = dev; 1231 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS; 1232 } 1233 1234 /* can setup */ 1235 dev->can.state = CAN_STATE_STOPPED; 1236 dev->can.clock.freq = le32_to_cpu(bt_const.fclk_can); 1237 dev->can.bittiming_const = &dev->bt_const; 1238 dev->can.do_set_bittiming = gs_usb_set_bittiming; 1239 1240 dev->can.ctrlmode_supported = CAN_CTRLMODE_CC_LEN8_DLC; 1241 1242 feature = le32_to_cpu(bt_const.feature); 1243 dev->feature = FIELD_GET(GS_CAN_FEATURE_MASK, feature); 1244 if (feature & GS_CAN_FEATURE_LISTEN_ONLY) 1245 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY; 1246 1247 if (feature & GS_CAN_FEATURE_LOOP_BACK) 1248 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK; 1249 1250 if (feature & GS_CAN_FEATURE_TRIPLE_SAMPLE) 1251 dev->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES; 1252 1253 if (feature & GS_CAN_FEATURE_ONE_SHOT) 1254 dev->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT; 1255 1256 if (feature & GS_CAN_FEATURE_FD) { 1257 dev->can.ctrlmode_supported |= CAN_CTRLMODE_FD; 1258 /* The data bit timing will be overwritten, if 1259 * GS_CAN_FEATURE_BT_CONST_EXT is set. 1260 */ 1261 dev->can.data_bittiming_const = &dev->bt_const; 1262 dev->can.do_set_data_bittiming = gs_usb_set_data_bittiming; 1263 } 1264 1265 if (feature & GS_CAN_FEATURE_TERMINATION) { 1266 rc = gs_usb_get_termination(netdev, &dev->can.termination); 1267 if (rc) { 1268 dev->feature &= ~GS_CAN_FEATURE_TERMINATION; 1269 1270 dev_info(&intf->dev, 1271 "Disabling termination support for channel %d (%pe)\n", 1272 channel, ERR_PTR(rc)); 1273 } else { 1274 dev->can.termination_const = gs_usb_termination_const; 1275 dev->can.termination_const_cnt = ARRAY_SIZE(gs_usb_termination_const); 1276 dev->can.do_set_termination = gs_usb_set_termination; 1277 } 1278 } 1279 1280 if (feature & GS_CAN_FEATURE_BERR_REPORTING) 1281 dev->can.ctrlmode_supported |= CAN_CTRLMODE_BERR_REPORTING; 1282 1283 if (feature & GS_CAN_FEATURE_GET_STATE) 1284 dev->can.do_get_berr_counter = gs_usb_can_get_berr_counter; 1285 1286 /* The CANtact Pro from LinkLayer Labs is based on the 1287 * LPC54616 µC, which is affected by the NXP LPC USB transfer 1288 * erratum. However, the current firmware (version 2) doesn't 1289 * set the GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX bit. Set the 1290 * feature GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX to workaround 1291 * this issue. 1292 * 1293 * For the GS_USB_BREQ_DATA_BITTIMING USB control message the 1294 * CANtact Pro firmware uses a request value, which is already 1295 * used by the candleLight firmware for a different purpose 1296 * (GS_USB_BREQ_GET_USER_ID). Set the feature 1297 * GS_CAN_FEATURE_QUIRK_BREQ_CANTACT_PRO to workaround this 1298 * issue. 1299 */ 1300 if (dev->udev->descriptor.idVendor == cpu_to_le16(USB_GS_USB_1_VENDOR_ID) && 1301 dev->udev->descriptor.idProduct == cpu_to_le16(USB_GS_USB_1_PRODUCT_ID) && 1302 dev->udev->manufacturer && dev->udev->product && 1303 !strcmp(dev->udev->manufacturer, "LinkLayer Labs") && 1304 !strcmp(dev->udev->product, "CANtact Pro") && 1305 (le32_to_cpu(dconf->sw_version) <= 2)) 1306 dev->feature |= GS_CAN_FEATURE_REQ_USB_QUIRK_LPC546XX | 1307 GS_CAN_FEATURE_QUIRK_BREQ_CANTACT_PRO; 1308 1309 /* GS_CAN_FEATURE_IDENTIFY is only supported for sw_version > 1 */ 1310 if (!(le32_to_cpu(dconf->sw_version) > 1 && 1311 feature & GS_CAN_FEATURE_IDENTIFY)) 1312 dev->feature &= ~GS_CAN_FEATURE_IDENTIFY; 1313 1314 /* fetch extended bit timing constants if device has feature 1315 * GS_CAN_FEATURE_FD and GS_CAN_FEATURE_BT_CONST_EXT 1316 */ 1317 if (feature & GS_CAN_FEATURE_FD && 1318 feature & GS_CAN_FEATURE_BT_CONST_EXT) { 1319 rc = usb_control_msg_recv(interface_to_usbdev(intf), 0, 1320 GS_USB_BREQ_BT_CONST_EXT, 1321 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 1322 channel, 0, &bt_const_extended, 1323 sizeof(bt_const_extended), 1324 1000, GFP_KERNEL); 1325 if (rc) { 1326 dev_err(&intf->dev, 1327 "Couldn't get extended bit timing const for channel %d (%pe)\n", 1328 channel, ERR_PTR(rc)); 1329 goto out_free_candev; 1330 } 1331 1332 strcpy(dev->data_bt_const.name, KBUILD_MODNAME); 1333 dev->data_bt_const.tseg1_min = le32_to_cpu(bt_const_extended.dtseg1_min); 1334 dev->data_bt_const.tseg1_max = le32_to_cpu(bt_const_extended.dtseg1_max); 1335 dev->data_bt_const.tseg2_min = le32_to_cpu(bt_const_extended.dtseg2_min); 1336 dev->data_bt_const.tseg2_max = le32_to_cpu(bt_const_extended.dtseg2_max); 1337 dev->data_bt_const.sjw_max = le32_to_cpu(bt_const_extended.dsjw_max); 1338 dev->data_bt_const.brp_min = le32_to_cpu(bt_const_extended.dbrp_min); 1339 dev->data_bt_const.brp_max = le32_to_cpu(bt_const_extended.dbrp_max); 1340 dev->data_bt_const.brp_inc = le32_to_cpu(bt_const_extended.dbrp_inc); 1341 1342 dev->can.data_bittiming_const = &dev->data_bt_const; 1343 } 1344 1345 SET_NETDEV_DEV(netdev, &intf->dev); 1346 1347 rc = register_candev(dev->netdev); 1348 if (rc) { 1349 dev_err(&intf->dev, 1350 "Couldn't register candev for channel %d (%pe)\n", 1351 channel, ERR_PTR(rc)); 1352 goto out_free_candev; 1353 } 1354 1355 return dev; 1356 1357 out_free_candev: 1358 free_candev(dev->netdev); 1359 return ERR_PTR(rc); 1360 } 1361 1362 static void gs_destroy_candev(struct gs_can *dev) 1363 { 1364 unregister_candev(dev->netdev); 1365 usb_kill_anchored_urbs(&dev->tx_submitted); 1366 free_candev(dev->netdev); 1367 } 1368 1369 static int gs_usb_probe(struct usb_interface *intf, 1370 const struct usb_device_id *id) 1371 { 1372 struct usb_device *udev = interface_to_usbdev(intf); 1373 struct gs_host_frame *hf; 1374 struct gs_usb *dev; 1375 struct gs_host_config hconf = { 1376 .byte_order = cpu_to_le32(0x0000beef), 1377 }; 1378 struct gs_device_config dconf; 1379 unsigned int icount, i; 1380 int rc; 1381 1382 /* send host config */ 1383 rc = usb_control_msg_send(udev, 0, 1384 GS_USB_BREQ_HOST_FORMAT, 1385 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 1386 1, intf->cur_altsetting->desc.bInterfaceNumber, 1387 &hconf, sizeof(hconf), 1000, 1388 GFP_KERNEL); 1389 if (rc) { 1390 dev_err(&intf->dev, "Couldn't send data format (err=%d)\n", rc); 1391 return rc; 1392 } 1393 1394 /* read device config */ 1395 rc = usb_control_msg_recv(udev, 0, 1396 GS_USB_BREQ_DEVICE_CONFIG, 1397 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 1398 1, intf->cur_altsetting->desc.bInterfaceNumber, 1399 &dconf, sizeof(dconf), 1000, 1400 GFP_KERNEL); 1401 if (rc) { 1402 dev_err(&intf->dev, "Couldn't get device config: (err=%d)\n", 1403 rc); 1404 return rc; 1405 } 1406 1407 icount = dconf.icount + 1; 1408 dev_info(&intf->dev, "Configuring for %u interfaces\n", icount); 1409 1410 if (icount > GS_MAX_INTF) { 1411 dev_err(&intf->dev, 1412 "Driver cannot handle more that %u CAN interfaces\n", 1413 GS_MAX_INTF); 1414 return -EINVAL; 1415 } 1416 1417 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1418 if (!dev) 1419 return -ENOMEM; 1420 1421 init_usb_anchor(&dev->rx_submitted); 1422 1423 usb_set_intfdata(intf, dev); 1424 dev->udev = udev; 1425 1426 for (i = 0; i < icount; i++) { 1427 unsigned int hf_size_rx = 0; 1428 1429 dev->canch[i] = gs_make_candev(i, intf, &dconf); 1430 if (IS_ERR_OR_NULL(dev->canch[i])) { 1431 /* save error code to return later */ 1432 rc = PTR_ERR(dev->canch[i]); 1433 1434 /* on failure destroy previously created candevs */ 1435 icount = i; 1436 for (i = 0; i < icount; i++) 1437 gs_destroy_candev(dev->canch[i]); 1438 1439 usb_kill_anchored_urbs(&dev->rx_submitted); 1440 kfree(dev); 1441 return rc; 1442 } 1443 dev->canch[i]->parent = dev; 1444 1445 /* set RX packet size based on FD and if hardware 1446 * timestamps are supported. 1447 */ 1448 if (dev->canch[i]->can.ctrlmode_supported & CAN_CTRLMODE_FD) { 1449 if (dev->canch[i]->feature & GS_CAN_FEATURE_HW_TIMESTAMP) 1450 hf_size_rx = struct_size(hf, canfd_ts, 1); 1451 else 1452 hf_size_rx = struct_size(hf, canfd, 1); 1453 } else { 1454 if (dev->canch[i]->feature & GS_CAN_FEATURE_HW_TIMESTAMP) 1455 hf_size_rx = struct_size(hf, classic_can_ts, 1); 1456 else 1457 hf_size_rx = struct_size(hf, classic_can, 1); 1458 } 1459 dev->hf_size_rx = max(dev->hf_size_rx, hf_size_rx); 1460 } 1461 1462 return 0; 1463 } 1464 1465 static void gs_usb_disconnect(struct usb_interface *intf) 1466 { 1467 struct gs_usb *dev = usb_get_intfdata(intf); 1468 unsigned int i; 1469 1470 usb_set_intfdata(intf, NULL); 1471 1472 if (!dev) { 1473 dev_err(&intf->dev, "Disconnect (nodata)\n"); 1474 return; 1475 } 1476 1477 for (i = 0; i < GS_MAX_INTF; i++) 1478 if (dev->canch[i]) 1479 gs_destroy_candev(dev->canch[i]); 1480 1481 usb_kill_anchored_urbs(&dev->rx_submitted); 1482 kfree(dev); 1483 } 1484 1485 static const struct usb_device_id gs_usb_table[] = { 1486 { USB_DEVICE_INTERFACE_NUMBER(USB_GS_USB_1_VENDOR_ID, 1487 USB_GS_USB_1_PRODUCT_ID, 0) }, 1488 { USB_DEVICE_INTERFACE_NUMBER(USB_CANDLELIGHT_VENDOR_ID, 1489 USB_CANDLELIGHT_PRODUCT_ID, 0) }, 1490 { USB_DEVICE_INTERFACE_NUMBER(USB_CES_CANEXT_FD_VENDOR_ID, 1491 USB_CES_CANEXT_FD_PRODUCT_ID, 0) }, 1492 { USB_DEVICE_INTERFACE_NUMBER(USB_ABE_CANDEBUGGER_FD_VENDOR_ID, 1493 USB_ABE_CANDEBUGGER_FD_PRODUCT_ID, 0) }, 1494 {} /* Terminating entry */ 1495 }; 1496 1497 MODULE_DEVICE_TABLE(usb, gs_usb_table); 1498 1499 static struct usb_driver gs_usb_driver = { 1500 .name = KBUILD_MODNAME, 1501 .probe = gs_usb_probe, 1502 .disconnect = gs_usb_disconnect, 1503 .id_table = gs_usb_table, 1504 }; 1505 1506 module_usb_driver(gs_usb_driver); 1507 1508 MODULE_AUTHOR("Maximilian Schneider <mws@schneidersoft.net>"); 1509 MODULE_DESCRIPTION( 1510 "Socket CAN device driver for Geschwister Schneider Technologie-, " 1511 "Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces\n" 1512 "and bytewerk.org candleLight USB CAN interfaces."); 1513 MODULE_LICENSE("GPL v2"); 1514