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/init.h> 13 #include <linux/signal.h> 14 #include <linux/module.h> 15 #include <linux/netdevice.h> 16 #include <linux/usb.h> 17 18 #include <linux/can.h> 19 #include <linux/can/dev.h> 20 #include <linux/can/error.h> 21 22 /* Device specific constants */ 23 #define USB_GSUSB_1_VENDOR_ID 0x1d50 24 #define USB_GSUSB_1_PRODUCT_ID 0x606f 25 26 #define USB_CANDLELIGHT_VENDOR_ID 0x1209 27 #define USB_CANDLELIGHT_PRODUCT_ID 0x2323 28 29 #define GSUSB_ENDPOINT_IN 1 30 #define GSUSB_ENDPOINT_OUT 2 31 32 /* Device specific constants */ 33 enum gs_usb_breq { 34 GS_USB_BREQ_HOST_FORMAT = 0, 35 GS_USB_BREQ_BITTIMING, 36 GS_USB_BREQ_MODE, 37 GS_USB_BREQ_BERR, 38 GS_USB_BREQ_BT_CONST, 39 GS_USB_BREQ_DEVICE_CONFIG, 40 GS_USB_BREQ_TIMESTAMP, 41 GS_USB_BREQ_IDENTIFY, 42 }; 43 44 enum gs_can_mode { 45 /* reset a channel. turns it off */ 46 GS_CAN_MODE_RESET = 0, 47 /* starts a channel */ 48 GS_CAN_MODE_START 49 }; 50 51 enum gs_can_state { 52 GS_CAN_STATE_ERROR_ACTIVE = 0, 53 GS_CAN_STATE_ERROR_WARNING, 54 GS_CAN_STATE_ERROR_PASSIVE, 55 GS_CAN_STATE_BUS_OFF, 56 GS_CAN_STATE_STOPPED, 57 GS_CAN_STATE_SLEEPING 58 }; 59 60 enum gs_can_identify_mode { 61 GS_CAN_IDENTIFY_OFF = 0, 62 GS_CAN_IDENTIFY_ON 63 }; 64 65 /* data types passed between host and device */ 66 struct gs_host_config { 67 u32 byte_order; 68 } __packed; 69 /* All data exchanged between host and device is exchanged in host byte order, 70 * thanks to the struct gs_host_config byte_order member, which is sent first 71 * to indicate the desired byte order. 72 */ 73 74 struct gs_device_config { 75 u8 reserved1; 76 u8 reserved2; 77 u8 reserved3; 78 u8 icount; 79 u32 sw_version; 80 u32 hw_version; 81 } __packed; 82 83 #define GS_CAN_MODE_NORMAL 0 84 #define GS_CAN_MODE_LISTEN_ONLY BIT(0) 85 #define GS_CAN_MODE_LOOP_BACK BIT(1) 86 #define GS_CAN_MODE_TRIPLE_SAMPLE BIT(2) 87 #define GS_CAN_MODE_ONE_SHOT BIT(3) 88 89 struct gs_device_mode { 90 u32 mode; 91 u32 flags; 92 } __packed; 93 94 struct gs_device_state { 95 u32 state; 96 u32 rxerr; 97 u32 txerr; 98 } __packed; 99 100 struct gs_device_bittiming { 101 u32 prop_seg; 102 u32 phase_seg1; 103 u32 phase_seg2; 104 u32 sjw; 105 u32 brp; 106 } __packed; 107 108 struct gs_identify_mode { 109 u32 mode; 110 } __packed; 111 112 #define GS_CAN_FEATURE_LISTEN_ONLY BIT(0) 113 #define GS_CAN_FEATURE_LOOP_BACK BIT(1) 114 #define GS_CAN_FEATURE_TRIPLE_SAMPLE BIT(2) 115 #define GS_CAN_FEATURE_ONE_SHOT BIT(3) 116 #define GS_CAN_FEATURE_HW_TIMESTAMP BIT(4) 117 #define GS_CAN_FEATURE_IDENTIFY BIT(5) 118 119 struct gs_device_bt_const { 120 u32 feature; 121 u32 fclk_can; 122 u32 tseg1_min; 123 u32 tseg1_max; 124 u32 tseg2_min; 125 u32 tseg2_max; 126 u32 sjw_max; 127 u32 brp_min; 128 u32 brp_max; 129 u32 brp_inc; 130 } __packed; 131 132 #define GS_CAN_FLAG_OVERFLOW 1 133 134 struct gs_host_frame { 135 u32 echo_id; 136 u32 can_id; 137 138 u8 can_dlc; 139 u8 channel; 140 u8 flags; 141 u8 reserved; 142 143 u8 data[8]; 144 } __packed; 145 /* The GS USB devices make use of the same flags and masks as in 146 * linux/can.h and linux/can/error.h, and no additional mapping is necessary. 147 */ 148 149 /* Only send a max of GS_MAX_TX_URBS frames per channel at a time. */ 150 #define GS_MAX_TX_URBS 10 151 /* Only launch a max of GS_MAX_RX_URBS usb requests at a time. */ 152 #define GS_MAX_RX_URBS 30 153 /* Maximum number of interfaces the driver supports per device. 154 * Current hardware only supports 2 interfaces. The future may vary. 155 */ 156 #define GS_MAX_INTF 2 157 158 struct gs_tx_context { 159 struct gs_can *dev; 160 unsigned int echo_id; 161 }; 162 163 struct gs_can { 164 struct can_priv can; /* must be the first member */ 165 166 struct gs_usb *parent; 167 168 struct net_device *netdev; 169 struct usb_device *udev; 170 struct usb_interface *iface; 171 172 struct can_bittiming_const bt_const; 173 unsigned int channel; /* channel number */ 174 175 /* This lock prevents a race condition between xmit and receive. */ 176 spinlock_t tx_ctx_lock; 177 struct gs_tx_context tx_context[GS_MAX_TX_URBS]; 178 179 struct usb_anchor tx_submitted; 180 atomic_t active_tx_urbs; 181 }; 182 183 /* usb interface struct */ 184 struct gs_usb { 185 struct gs_can *canch[GS_MAX_INTF]; 186 struct usb_anchor rx_submitted; 187 atomic_t active_channels; 188 struct usb_device *udev; 189 }; 190 191 /* 'allocate' a tx context. 192 * returns a valid tx context or NULL if there is no space. 193 */ 194 static struct gs_tx_context *gs_alloc_tx_context(struct gs_can *dev) 195 { 196 int i = 0; 197 unsigned long flags; 198 199 spin_lock_irqsave(&dev->tx_ctx_lock, flags); 200 201 for (; i < GS_MAX_TX_URBS; i++) { 202 if (dev->tx_context[i].echo_id == GS_MAX_TX_URBS) { 203 dev->tx_context[i].echo_id = i; 204 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags); 205 return &dev->tx_context[i]; 206 } 207 } 208 209 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags); 210 return NULL; 211 } 212 213 /* releases a tx context 214 */ 215 static void gs_free_tx_context(struct gs_tx_context *txc) 216 { 217 txc->echo_id = GS_MAX_TX_URBS; 218 } 219 220 /* Get a tx context by id. 221 */ 222 static struct gs_tx_context *gs_get_tx_context(struct gs_can *dev, 223 unsigned int id) 224 { 225 unsigned long flags; 226 227 if (id < GS_MAX_TX_URBS) { 228 spin_lock_irqsave(&dev->tx_ctx_lock, flags); 229 if (dev->tx_context[id].echo_id == id) { 230 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags); 231 return &dev->tx_context[id]; 232 } 233 spin_unlock_irqrestore(&dev->tx_ctx_lock, flags); 234 } 235 return NULL; 236 } 237 238 static int gs_cmd_reset(struct gs_can *gsdev) 239 { 240 struct gs_device_mode *dm; 241 struct usb_interface *intf = gsdev->iface; 242 int rc; 243 244 dm = kzalloc(sizeof(*dm), GFP_KERNEL); 245 if (!dm) 246 return -ENOMEM; 247 248 dm->mode = GS_CAN_MODE_RESET; 249 250 rc = usb_control_msg(interface_to_usbdev(intf), 251 usb_sndctrlpipe(interface_to_usbdev(intf), 0), 252 GS_USB_BREQ_MODE, 253 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 254 gsdev->channel, 255 0, 256 dm, 257 sizeof(*dm), 258 1000); 259 260 kfree(dm); 261 262 return rc; 263 } 264 265 static void gs_update_state(struct gs_can *dev, struct can_frame *cf) 266 { 267 struct can_device_stats *can_stats = &dev->can.can_stats; 268 269 if (cf->can_id & CAN_ERR_RESTARTED) { 270 dev->can.state = CAN_STATE_ERROR_ACTIVE; 271 can_stats->restarts++; 272 } else if (cf->can_id & CAN_ERR_BUSOFF) { 273 dev->can.state = CAN_STATE_BUS_OFF; 274 can_stats->bus_off++; 275 } else if (cf->can_id & CAN_ERR_CRTL) { 276 if ((cf->data[1] & CAN_ERR_CRTL_TX_WARNING) || 277 (cf->data[1] & CAN_ERR_CRTL_RX_WARNING)) { 278 dev->can.state = CAN_STATE_ERROR_WARNING; 279 can_stats->error_warning++; 280 } else if ((cf->data[1] & CAN_ERR_CRTL_TX_PASSIVE) || 281 (cf->data[1] & CAN_ERR_CRTL_RX_PASSIVE)) { 282 dev->can.state = CAN_STATE_ERROR_PASSIVE; 283 can_stats->error_passive++; 284 } else { 285 dev->can.state = CAN_STATE_ERROR_ACTIVE; 286 } 287 } 288 } 289 290 static void gs_usb_receive_bulk_callback(struct urb *urb) 291 { 292 struct gs_usb *usbcan = urb->context; 293 struct gs_can *dev; 294 struct net_device *netdev; 295 int rc; 296 struct net_device_stats *stats; 297 struct gs_host_frame *hf = urb->transfer_buffer; 298 struct gs_tx_context *txc; 299 struct can_frame *cf; 300 struct sk_buff *skb; 301 302 BUG_ON(!usbcan); 303 304 switch (urb->status) { 305 case 0: /* success */ 306 break; 307 case -ENOENT: 308 case -ESHUTDOWN: 309 return; 310 default: 311 /* do not resubmit aborted urbs. eg: when device goes down */ 312 return; 313 } 314 315 /* device reports out of range channel id */ 316 if (hf->channel >= GS_MAX_INTF) 317 goto resubmit_urb; 318 319 dev = usbcan->canch[hf->channel]; 320 321 netdev = dev->netdev; 322 stats = &netdev->stats; 323 324 if (!netif_device_present(netdev)) 325 return; 326 327 if (hf->echo_id == -1) { /* normal rx */ 328 skb = alloc_can_skb(dev->netdev, &cf); 329 if (!skb) 330 return; 331 332 cf->can_id = hf->can_id; 333 334 cf->can_dlc = get_can_dlc(hf->can_dlc); 335 memcpy(cf->data, hf->data, 8); 336 337 /* ERROR frames tell us information about the controller */ 338 if (hf->can_id & CAN_ERR_FLAG) 339 gs_update_state(dev, cf); 340 341 netdev->stats.rx_packets++; 342 netdev->stats.rx_bytes += hf->can_dlc; 343 344 netif_rx(skb); 345 } else { /* echo_id == hf->echo_id */ 346 if (hf->echo_id >= GS_MAX_TX_URBS) { 347 netdev_err(netdev, 348 "Unexpected out of range echo id %d\n", 349 hf->echo_id); 350 goto resubmit_urb; 351 } 352 353 netdev->stats.tx_packets++; 354 netdev->stats.tx_bytes += hf->can_dlc; 355 356 txc = gs_get_tx_context(dev, hf->echo_id); 357 358 /* bad devices send bad echo_ids. */ 359 if (!txc) { 360 netdev_err(netdev, 361 "Unexpected unused echo id %d\n", 362 hf->echo_id); 363 goto resubmit_urb; 364 } 365 366 can_get_echo_skb(netdev, hf->echo_id); 367 368 gs_free_tx_context(txc); 369 370 atomic_dec(&dev->active_tx_urbs); 371 372 netif_wake_queue(netdev); 373 } 374 375 if (hf->flags & GS_CAN_FLAG_OVERFLOW) { 376 skb = alloc_can_err_skb(netdev, &cf); 377 if (!skb) 378 goto resubmit_urb; 379 380 cf->can_id |= CAN_ERR_CRTL; 381 cf->can_dlc = CAN_ERR_DLC; 382 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 383 stats->rx_over_errors++; 384 stats->rx_errors++; 385 netif_rx(skb); 386 } 387 388 resubmit_urb: 389 usb_fill_bulk_urb(urb, 390 usbcan->udev, 391 usb_rcvbulkpipe(usbcan->udev, GSUSB_ENDPOINT_IN), 392 hf, 393 sizeof(struct gs_host_frame), 394 gs_usb_receive_bulk_callback, 395 usbcan 396 ); 397 398 rc = usb_submit_urb(urb, GFP_ATOMIC); 399 400 /* USB failure take down all interfaces */ 401 if (rc == -ENODEV) { 402 for (rc = 0; rc < GS_MAX_INTF; rc++) { 403 if (usbcan->canch[rc]) 404 netif_device_detach(usbcan->canch[rc]->netdev); 405 } 406 } 407 } 408 409 static int gs_usb_set_bittiming(struct net_device *netdev) 410 { 411 struct gs_can *dev = netdev_priv(netdev); 412 struct can_bittiming *bt = &dev->can.bittiming; 413 struct usb_interface *intf = dev->iface; 414 int rc; 415 struct gs_device_bittiming *dbt; 416 417 dbt = kmalloc(sizeof(*dbt), GFP_KERNEL); 418 if (!dbt) 419 return -ENOMEM; 420 421 dbt->prop_seg = bt->prop_seg; 422 dbt->phase_seg1 = bt->phase_seg1; 423 dbt->phase_seg2 = bt->phase_seg2; 424 dbt->sjw = bt->sjw; 425 dbt->brp = bt->brp; 426 427 /* request bit timings */ 428 rc = usb_control_msg(interface_to_usbdev(intf), 429 usb_sndctrlpipe(interface_to_usbdev(intf), 0), 430 GS_USB_BREQ_BITTIMING, 431 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 432 dev->channel, 433 0, 434 dbt, 435 sizeof(*dbt), 436 1000); 437 438 kfree(dbt); 439 440 if (rc < 0) 441 dev_err(netdev->dev.parent, "Couldn't set bittimings (err=%d)", 442 rc); 443 444 return (rc > 0) ? 0 : rc; 445 } 446 447 static void gs_usb_xmit_callback(struct urb *urb) 448 { 449 struct gs_tx_context *txc = urb->context; 450 struct gs_can *dev = txc->dev; 451 struct net_device *netdev = dev->netdev; 452 453 if (urb->status) 454 netdev_info(netdev, "usb xmit fail %d\n", txc->echo_id); 455 456 usb_free_coherent(urb->dev, 457 urb->transfer_buffer_length, 458 urb->transfer_buffer, 459 urb->transfer_dma); 460 } 461 462 static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb, 463 struct net_device *netdev) 464 { 465 struct gs_can *dev = netdev_priv(netdev); 466 struct net_device_stats *stats = &dev->netdev->stats; 467 struct urb *urb; 468 struct gs_host_frame *hf; 469 struct can_frame *cf; 470 int rc; 471 unsigned int idx; 472 struct gs_tx_context *txc; 473 474 if (can_dropped_invalid_skb(netdev, skb)) 475 return NETDEV_TX_OK; 476 477 /* find an empty context to keep track of transmission */ 478 txc = gs_alloc_tx_context(dev); 479 if (!txc) 480 return NETDEV_TX_BUSY; 481 482 /* create a URB, and a buffer for it */ 483 urb = usb_alloc_urb(0, GFP_ATOMIC); 484 if (!urb) 485 goto nomem_urb; 486 487 hf = usb_alloc_coherent(dev->udev, sizeof(*hf), GFP_ATOMIC, 488 &urb->transfer_dma); 489 if (!hf) { 490 netdev_err(netdev, "No memory left for USB buffer\n"); 491 goto nomem_hf; 492 } 493 494 idx = txc->echo_id; 495 496 if (idx >= GS_MAX_TX_URBS) { 497 netdev_err(netdev, "Invalid tx context %d\n", idx); 498 goto badidx; 499 } 500 501 hf->echo_id = idx; 502 hf->channel = dev->channel; 503 504 cf = (struct can_frame *)skb->data; 505 506 hf->can_id = cf->can_id; 507 hf->can_dlc = cf->can_dlc; 508 memcpy(hf->data, cf->data, cf->can_dlc); 509 510 usb_fill_bulk_urb(urb, dev->udev, 511 usb_sndbulkpipe(dev->udev, GSUSB_ENDPOINT_OUT), 512 hf, 513 sizeof(*hf), 514 gs_usb_xmit_callback, 515 txc); 516 517 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 518 usb_anchor_urb(urb, &dev->tx_submitted); 519 520 can_put_echo_skb(skb, netdev, idx); 521 522 atomic_inc(&dev->active_tx_urbs); 523 524 rc = usb_submit_urb(urb, GFP_ATOMIC); 525 if (unlikely(rc)) { /* usb send failed */ 526 atomic_dec(&dev->active_tx_urbs); 527 528 can_free_echo_skb(netdev, idx); 529 gs_free_tx_context(txc); 530 531 usb_unanchor_urb(urb); 532 usb_free_coherent(dev->udev, 533 sizeof(*hf), 534 hf, 535 urb->transfer_dma); 536 537 if (rc == -ENODEV) { 538 netif_device_detach(netdev); 539 } else { 540 netdev_err(netdev, "usb_submit failed (err=%d)\n", rc); 541 stats->tx_dropped++; 542 } 543 } else { 544 /* Slow down tx path */ 545 if (atomic_read(&dev->active_tx_urbs) >= GS_MAX_TX_URBS) 546 netif_stop_queue(netdev); 547 } 548 549 /* let usb core take care of this urb */ 550 usb_free_urb(urb); 551 552 return NETDEV_TX_OK; 553 554 badidx: 555 usb_free_coherent(dev->udev, 556 sizeof(*hf), 557 hf, 558 urb->transfer_dma); 559 nomem_hf: 560 usb_free_urb(urb); 561 562 nomem_urb: 563 gs_free_tx_context(txc); 564 dev_kfree_skb(skb); 565 stats->tx_dropped++; 566 return NETDEV_TX_OK; 567 } 568 569 static int gs_can_open(struct net_device *netdev) 570 { 571 struct gs_can *dev = netdev_priv(netdev); 572 struct gs_usb *parent = dev->parent; 573 int rc, i; 574 struct gs_device_mode *dm; 575 u32 ctrlmode; 576 577 rc = open_candev(netdev); 578 if (rc) 579 return rc; 580 581 if (atomic_add_return(1, &parent->active_channels) == 1) { 582 for (i = 0; i < GS_MAX_RX_URBS; i++) { 583 struct urb *urb; 584 u8 *buf; 585 586 /* alloc rx urb */ 587 urb = usb_alloc_urb(0, GFP_KERNEL); 588 if (!urb) 589 return -ENOMEM; 590 591 /* alloc rx buffer */ 592 buf = usb_alloc_coherent(dev->udev, 593 sizeof(struct gs_host_frame), 594 GFP_KERNEL, 595 &urb->transfer_dma); 596 if (!buf) { 597 netdev_err(netdev, 598 "No memory left for USB buffer\n"); 599 usb_free_urb(urb); 600 return -ENOMEM; 601 } 602 603 /* fill, anchor, and submit rx urb */ 604 usb_fill_bulk_urb(urb, 605 dev->udev, 606 usb_rcvbulkpipe(dev->udev, 607 GSUSB_ENDPOINT_IN), 608 buf, 609 sizeof(struct gs_host_frame), 610 gs_usb_receive_bulk_callback, 611 parent); 612 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 613 614 usb_anchor_urb(urb, &parent->rx_submitted); 615 616 rc = usb_submit_urb(urb, GFP_KERNEL); 617 if (rc) { 618 if (rc == -ENODEV) 619 netif_device_detach(dev->netdev); 620 621 netdev_err(netdev, 622 "usb_submit failed (err=%d)\n", 623 rc); 624 625 usb_unanchor_urb(urb); 626 break; 627 } 628 629 /* Drop reference, 630 * USB core will take care of freeing it 631 */ 632 usb_free_urb(urb); 633 } 634 } 635 636 dm = kmalloc(sizeof(*dm), GFP_KERNEL); 637 if (!dm) 638 return -ENOMEM; 639 640 /* flags */ 641 ctrlmode = dev->can.ctrlmode; 642 dm->flags = 0; 643 644 if (ctrlmode & CAN_CTRLMODE_LOOPBACK) 645 dm->flags |= GS_CAN_MODE_LOOP_BACK; 646 else if (ctrlmode & CAN_CTRLMODE_LISTENONLY) 647 dm->flags |= GS_CAN_MODE_LISTEN_ONLY; 648 649 /* Controller is not allowed to retry TX 650 * this mode is unavailable on atmels uc3c hardware 651 */ 652 if (ctrlmode & CAN_CTRLMODE_ONE_SHOT) 653 dm->flags |= GS_CAN_MODE_ONE_SHOT; 654 655 if (ctrlmode & CAN_CTRLMODE_3_SAMPLES) 656 dm->flags |= GS_CAN_MODE_TRIPLE_SAMPLE; 657 658 /* finally start device */ 659 dm->mode = GS_CAN_MODE_START; 660 rc = usb_control_msg(interface_to_usbdev(dev->iface), 661 usb_sndctrlpipe(interface_to_usbdev(dev->iface), 0), 662 GS_USB_BREQ_MODE, 663 USB_DIR_OUT | USB_TYPE_VENDOR | 664 USB_RECIP_INTERFACE, 665 dev->channel, 666 0, 667 dm, 668 sizeof(*dm), 669 1000); 670 671 if (rc < 0) { 672 netdev_err(netdev, "Couldn't start device (err=%d)\n", rc); 673 kfree(dm); 674 return rc; 675 } 676 677 kfree(dm); 678 679 dev->can.state = CAN_STATE_ERROR_ACTIVE; 680 681 if (!(dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)) 682 netif_start_queue(netdev); 683 684 return 0; 685 } 686 687 static int gs_can_close(struct net_device *netdev) 688 { 689 int rc; 690 struct gs_can *dev = netdev_priv(netdev); 691 struct gs_usb *parent = dev->parent; 692 693 netif_stop_queue(netdev); 694 695 /* Stop polling */ 696 if (atomic_dec_and_test(&parent->active_channels)) 697 usb_kill_anchored_urbs(&parent->rx_submitted); 698 699 /* Stop sending URBs */ 700 usb_kill_anchored_urbs(&dev->tx_submitted); 701 atomic_set(&dev->active_tx_urbs, 0); 702 703 /* reset the device */ 704 rc = gs_cmd_reset(dev); 705 if (rc < 0) 706 netdev_warn(netdev, "Couldn't shutdown device (err=%d)", rc); 707 708 /* reset tx contexts */ 709 for (rc = 0; rc < GS_MAX_TX_URBS; rc++) { 710 dev->tx_context[rc].dev = dev; 711 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS; 712 } 713 714 /* close the netdev */ 715 close_candev(netdev); 716 717 return 0; 718 } 719 720 static const struct net_device_ops gs_usb_netdev_ops = { 721 .ndo_open = gs_can_open, 722 .ndo_stop = gs_can_close, 723 .ndo_start_xmit = gs_can_start_xmit, 724 .ndo_change_mtu = can_change_mtu, 725 }; 726 727 static int gs_usb_set_identify(struct net_device *netdev, bool do_identify) 728 { 729 struct gs_can *dev = netdev_priv(netdev); 730 struct gs_identify_mode *imode; 731 int rc; 732 733 imode = kmalloc(sizeof(*imode), GFP_KERNEL); 734 735 if (!imode) 736 return -ENOMEM; 737 738 if (do_identify) 739 imode->mode = GS_CAN_IDENTIFY_ON; 740 else 741 imode->mode = GS_CAN_IDENTIFY_OFF; 742 743 rc = usb_control_msg(interface_to_usbdev(dev->iface), 744 usb_sndctrlpipe(interface_to_usbdev(dev->iface), 745 0), 746 GS_USB_BREQ_IDENTIFY, 747 USB_DIR_OUT | USB_TYPE_VENDOR | 748 USB_RECIP_INTERFACE, 749 dev->channel, 750 0, 751 imode, 752 sizeof(*imode), 753 100); 754 755 kfree(imode); 756 757 return (rc > 0) ? 0 : rc; 758 } 759 760 /* blink LED's for finding the this interface */ 761 static int gs_usb_set_phys_id(struct net_device *dev, 762 enum ethtool_phys_id_state state) 763 { 764 int rc = 0; 765 766 switch (state) { 767 case ETHTOOL_ID_ACTIVE: 768 rc = gs_usb_set_identify(dev, GS_CAN_IDENTIFY_ON); 769 break; 770 case ETHTOOL_ID_INACTIVE: 771 rc = gs_usb_set_identify(dev, GS_CAN_IDENTIFY_OFF); 772 break; 773 default: 774 break; 775 } 776 777 return rc; 778 } 779 780 static const struct ethtool_ops gs_usb_ethtool_ops = { 781 .set_phys_id = gs_usb_set_phys_id, 782 }; 783 784 static struct gs_can *gs_make_candev(unsigned int channel, 785 struct usb_interface *intf, 786 struct gs_device_config *dconf) 787 { 788 struct gs_can *dev; 789 struct net_device *netdev; 790 int rc; 791 struct gs_device_bt_const *bt_const; 792 793 bt_const = kmalloc(sizeof(*bt_const), GFP_KERNEL); 794 if (!bt_const) 795 return ERR_PTR(-ENOMEM); 796 797 /* fetch bit timing constants */ 798 rc = usb_control_msg(interface_to_usbdev(intf), 799 usb_rcvctrlpipe(interface_to_usbdev(intf), 0), 800 GS_USB_BREQ_BT_CONST, 801 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 802 channel, 803 0, 804 bt_const, 805 sizeof(*bt_const), 806 1000); 807 808 if (rc < 0) { 809 dev_err(&intf->dev, 810 "Couldn't get bit timing const for channel (err=%d)\n", 811 rc); 812 kfree(bt_const); 813 return ERR_PTR(rc); 814 } 815 816 /* create netdev */ 817 netdev = alloc_candev(sizeof(struct gs_can), GS_MAX_TX_URBS); 818 if (!netdev) { 819 dev_err(&intf->dev, "Couldn't allocate candev\n"); 820 kfree(bt_const); 821 return ERR_PTR(-ENOMEM); 822 } 823 824 dev = netdev_priv(netdev); 825 826 netdev->netdev_ops = &gs_usb_netdev_ops; 827 828 netdev->flags |= IFF_ECHO; /* we support full roundtrip echo */ 829 830 /* dev settup */ 831 strcpy(dev->bt_const.name, "gs_usb"); 832 dev->bt_const.tseg1_min = bt_const->tseg1_min; 833 dev->bt_const.tseg1_max = bt_const->tseg1_max; 834 dev->bt_const.tseg2_min = bt_const->tseg2_min; 835 dev->bt_const.tseg2_max = bt_const->tseg2_max; 836 dev->bt_const.sjw_max = bt_const->sjw_max; 837 dev->bt_const.brp_min = bt_const->brp_min; 838 dev->bt_const.brp_max = bt_const->brp_max; 839 dev->bt_const.brp_inc = bt_const->brp_inc; 840 841 dev->udev = interface_to_usbdev(intf); 842 dev->iface = intf; 843 dev->netdev = netdev; 844 dev->channel = channel; 845 846 init_usb_anchor(&dev->tx_submitted); 847 atomic_set(&dev->active_tx_urbs, 0); 848 spin_lock_init(&dev->tx_ctx_lock); 849 for (rc = 0; rc < GS_MAX_TX_URBS; rc++) { 850 dev->tx_context[rc].dev = dev; 851 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS; 852 } 853 854 /* can settup */ 855 dev->can.state = CAN_STATE_STOPPED; 856 dev->can.clock.freq = bt_const->fclk_can; 857 dev->can.bittiming_const = &dev->bt_const; 858 dev->can.do_set_bittiming = gs_usb_set_bittiming; 859 860 dev->can.ctrlmode_supported = 0; 861 862 if (bt_const->feature & GS_CAN_FEATURE_LISTEN_ONLY) 863 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY; 864 865 if (bt_const->feature & GS_CAN_FEATURE_LOOP_BACK) 866 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK; 867 868 if (bt_const->feature & GS_CAN_FEATURE_TRIPLE_SAMPLE) 869 dev->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES; 870 871 if (bt_const->feature & GS_CAN_FEATURE_ONE_SHOT) 872 dev->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT; 873 874 SET_NETDEV_DEV(netdev, &intf->dev); 875 876 if (dconf->sw_version > 1) 877 if (bt_const->feature & GS_CAN_FEATURE_IDENTIFY) 878 netdev->ethtool_ops = &gs_usb_ethtool_ops; 879 880 kfree(bt_const); 881 882 rc = register_candev(dev->netdev); 883 if (rc) { 884 free_candev(dev->netdev); 885 dev_err(&intf->dev, "Couldn't register candev (err=%d)\n", rc); 886 return ERR_PTR(rc); 887 } 888 889 return dev; 890 } 891 892 static void gs_destroy_candev(struct gs_can *dev) 893 { 894 unregister_candev(dev->netdev); 895 usb_kill_anchored_urbs(&dev->tx_submitted); 896 free_candev(dev->netdev); 897 } 898 899 static int gs_usb_probe(struct usb_interface *intf, 900 const struct usb_device_id *id) 901 { 902 struct gs_usb *dev; 903 int rc = -ENOMEM; 904 unsigned int icount, i; 905 struct gs_host_config *hconf; 906 struct gs_device_config *dconf; 907 908 hconf = kmalloc(sizeof(*hconf), GFP_KERNEL); 909 if (!hconf) 910 return -ENOMEM; 911 912 hconf->byte_order = 0x0000beef; 913 914 /* send host config */ 915 rc = usb_control_msg(interface_to_usbdev(intf), 916 usb_sndctrlpipe(interface_to_usbdev(intf), 0), 917 GS_USB_BREQ_HOST_FORMAT, 918 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 919 1, 920 intf->altsetting[0].desc.bInterfaceNumber, 921 hconf, 922 sizeof(*hconf), 923 1000); 924 925 kfree(hconf); 926 927 if (rc < 0) { 928 dev_err(&intf->dev, "Couldn't send data format (err=%d)\n", 929 rc); 930 return rc; 931 } 932 933 dconf = kmalloc(sizeof(*dconf), GFP_KERNEL); 934 if (!dconf) 935 return -ENOMEM; 936 937 /* read device config */ 938 rc = usb_control_msg(interface_to_usbdev(intf), 939 usb_rcvctrlpipe(interface_to_usbdev(intf), 0), 940 GS_USB_BREQ_DEVICE_CONFIG, 941 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 942 1, 943 intf->altsetting[0].desc.bInterfaceNumber, 944 dconf, 945 sizeof(*dconf), 946 1000); 947 if (rc < 0) { 948 dev_err(&intf->dev, "Couldn't get device config: (err=%d)\n", 949 rc); 950 kfree(dconf); 951 return rc; 952 } 953 954 icount = dconf->icount + 1; 955 dev_info(&intf->dev, "Configuring for %d interfaces\n", icount); 956 957 if (icount > GS_MAX_INTF) { 958 dev_err(&intf->dev, 959 "Driver cannot handle more that %d CAN interfaces\n", 960 GS_MAX_INTF); 961 kfree(dconf); 962 return -EINVAL; 963 } 964 965 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 966 if (!dev) { 967 kfree(dconf); 968 return -ENOMEM; 969 } 970 971 init_usb_anchor(&dev->rx_submitted); 972 973 atomic_set(&dev->active_channels, 0); 974 975 usb_set_intfdata(intf, dev); 976 dev->udev = interface_to_usbdev(intf); 977 978 for (i = 0; i < icount; i++) { 979 dev->canch[i] = gs_make_candev(i, intf, dconf); 980 if (IS_ERR_OR_NULL(dev->canch[i])) { 981 /* save error code to return later */ 982 rc = PTR_ERR(dev->canch[i]); 983 984 /* on failure destroy previously created candevs */ 985 icount = i; 986 for (i = 0; i < icount; i++) 987 gs_destroy_candev(dev->canch[i]); 988 989 usb_kill_anchored_urbs(&dev->rx_submitted); 990 kfree(dconf); 991 kfree(dev); 992 return rc; 993 } 994 dev->canch[i]->parent = dev; 995 } 996 997 kfree(dconf); 998 999 return 0; 1000 } 1001 1002 static void gs_usb_disconnect(struct usb_interface *intf) 1003 { 1004 unsigned i; 1005 struct gs_usb *dev = usb_get_intfdata(intf); 1006 usb_set_intfdata(intf, NULL); 1007 1008 if (!dev) { 1009 dev_err(&intf->dev, "Disconnect (nodata)\n"); 1010 return; 1011 } 1012 1013 for (i = 0; i < GS_MAX_INTF; i++) 1014 if (dev->canch[i]) 1015 gs_destroy_candev(dev->canch[i]); 1016 1017 usb_kill_anchored_urbs(&dev->rx_submitted); 1018 kfree(dev); 1019 } 1020 1021 static const struct usb_device_id gs_usb_table[] = { 1022 { USB_DEVICE_INTERFACE_NUMBER(USB_GSUSB_1_VENDOR_ID, 1023 USB_GSUSB_1_PRODUCT_ID, 0) }, 1024 { USB_DEVICE_INTERFACE_NUMBER(USB_CANDLELIGHT_VENDOR_ID, 1025 USB_CANDLELIGHT_PRODUCT_ID, 0) }, 1026 {} /* Terminating entry */ 1027 }; 1028 1029 MODULE_DEVICE_TABLE(usb, gs_usb_table); 1030 1031 static struct usb_driver gs_usb_driver = { 1032 .name = "gs_usb", 1033 .probe = gs_usb_probe, 1034 .disconnect = gs_usb_disconnect, 1035 .id_table = gs_usb_table, 1036 }; 1037 1038 module_usb_driver(gs_usb_driver); 1039 1040 MODULE_AUTHOR("Maximilian Schneider <mws@schneidersoft.net>"); 1041 MODULE_DESCRIPTION( 1042 "Socket CAN device driver for Geschwister Schneider Technologie-, " 1043 "Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces\n" 1044 "and bytewerk.org candleLight USB CAN interfaces."); 1045 MODULE_LICENSE("GPL v2"); 1046