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