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 usb_free_urb(urb); 627 break; 628 } 629 630 /* Drop reference, 631 * USB core will take care of freeing it 632 */ 633 usb_free_urb(urb); 634 } 635 } 636 637 dm = kmalloc(sizeof(*dm), GFP_KERNEL); 638 if (!dm) 639 return -ENOMEM; 640 641 /* flags */ 642 ctrlmode = dev->can.ctrlmode; 643 dm->flags = 0; 644 645 if (ctrlmode & CAN_CTRLMODE_LOOPBACK) 646 dm->flags |= GS_CAN_MODE_LOOP_BACK; 647 else if (ctrlmode & CAN_CTRLMODE_LISTENONLY) 648 dm->flags |= GS_CAN_MODE_LISTEN_ONLY; 649 650 /* Controller is not allowed to retry TX 651 * this mode is unavailable on atmels uc3c hardware 652 */ 653 if (ctrlmode & CAN_CTRLMODE_ONE_SHOT) 654 dm->flags |= GS_CAN_MODE_ONE_SHOT; 655 656 if (ctrlmode & CAN_CTRLMODE_3_SAMPLES) 657 dm->flags |= GS_CAN_MODE_TRIPLE_SAMPLE; 658 659 /* finally start device */ 660 dm->mode = GS_CAN_MODE_START; 661 rc = usb_control_msg(interface_to_usbdev(dev->iface), 662 usb_sndctrlpipe(interface_to_usbdev(dev->iface), 0), 663 GS_USB_BREQ_MODE, 664 USB_DIR_OUT | USB_TYPE_VENDOR | 665 USB_RECIP_INTERFACE, 666 dev->channel, 667 0, 668 dm, 669 sizeof(*dm), 670 1000); 671 672 if (rc < 0) { 673 netdev_err(netdev, "Couldn't start device (err=%d)\n", rc); 674 kfree(dm); 675 return rc; 676 } 677 678 kfree(dm); 679 680 dev->can.state = CAN_STATE_ERROR_ACTIVE; 681 682 if (!(dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)) 683 netif_start_queue(netdev); 684 685 return 0; 686 } 687 688 static int gs_can_close(struct net_device *netdev) 689 { 690 int rc; 691 struct gs_can *dev = netdev_priv(netdev); 692 struct gs_usb *parent = dev->parent; 693 694 netif_stop_queue(netdev); 695 696 /* Stop polling */ 697 if (atomic_dec_and_test(&parent->active_channels)) 698 usb_kill_anchored_urbs(&parent->rx_submitted); 699 700 /* Stop sending URBs */ 701 usb_kill_anchored_urbs(&dev->tx_submitted); 702 atomic_set(&dev->active_tx_urbs, 0); 703 704 /* reset the device */ 705 rc = gs_cmd_reset(dev); 706 if (rc < 0) 707 netdev_warn(netdev, "Couldn't shutdown device (err=%d)", rc); 708 709 /* reset tx contexts */ 710 for (rc = 0; rc < GS_MAX_TX_URBS; rc++) { 711 dev->tx_context[rc].dev = dev; 712 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS; 713 } 714 715 /* close the netdev */ 716 close_candev(netdev); 717 718 return 0; 719 } 720 721 static const struct net_device_ops gs_usb_netdev_ops = { 722 .ndo_open = gs_can_open, 723 .ndo_stop = gs_can_close, 724 .ndo_start_xmit = gs_can_start_xmit, 725 .ndo_change_mtu = can_change_mtu, 726 }; 727 728 static int gs_usb_set_identify(struct net_device *netdev, bool do_identify) 729 { 730 struct gs_can *dev = netdev_priv(netdev); 731 struct gs_identify_mode *imode; 732 int rc; 733 734 imode = kmalloc(sizeof(*imode), GFP_KERNEL); 735 736 if (!imode) 737 return -ENOMEM; 738 739 if (do_identify) 740 imode->mode = GS_CAN_IDENTIFY_ON; 741 else 742 imode->mode = GS_CAN_IDENTIFY_OFF; 743 744 rc = usb_control_msg(interface_to_usbdev(dev->iface), 745 usb_sndctrlpipe(interface_to_usbdev(dev->iface), 746 0), 747 GS_USB_BREQ_IDENTIFY, 748 USB_DIR_OUT | USB_TYPE_VENDOR | 749 USB_RECIP_INTERFACE, 750 dev->channel, 751 0, 752 imode, 753 sizeof(*imode), 754 100); 755 756 kfree(imode); 757 758 return (rc > 0) ? 0 : rc; 759 } 760 761 /* blink LED's for finding the this interface */ 762 static int gs_usb_set_phys_id(struct net_device *dev, 763 enum ethtool_phys_id_state state) 764 { 765 int rc = 0; 766 767 switch (state) { 768 case ETHTOOL_ID_ACTIVE: 769 rc = gs_usb_set_identify(dev, GS_CAN_IDENTIFY_ON); 770 break; 771 case ETHTOOL_ID_INACTIVE: 772 rc = gs_usb_set_identify(dev, GS_CAN_IDENTIFY_OFF); 773 break; 774 default: 775 break; 776 } 777 778 return rc; 779 } 780 781 static const struct ethtool_ops gs_usb_ethtool_ops = { 782 .set_phys_id = gs_usb_set_phys_id, 783 }; 784 785 static struct gs_can *gs_make_candev(unsigned int channel, 786 struct usb_interface *intf, 787 struct gs_device_config *dconf) 788 { 789 struct gs_can *dev; 790 struct net_device *netdev; 791 int rc; 792 struct gs_device_bt_const *bt_const; 793 794 bt_const = kmalloc(sizeof(*bt_const), GFP_KERNEL); 795 if (!bt_const) 796 return ERR_PTR(-ENOMEM); 797 798 /* fetch bit timing constants */ 799 rc = usb_control_msg(interface_to_usbdev(intf), 800 usb_rcvctrlpipe(interface_to_usbdev(intf), 0), 801 GS_USB_BREQ_BT_CONST, 802 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 803 channel, 804 0, 805 bt_const, 806 sizeof(*bt_const), 807 1000); 808 809 if (rc < 0) { 810 dev_err(&intf->dev, 811 "Couldn't get bit timing const for channel (err=%d)\n", 812 rc); 813 kfree(bt_const); 814 return ERR_PTR(rc); 815 } 816 817 /* create netdev */ 818 netdev = alloc_candev(sizeof(struct gs_can), GS_MAX_TX_URBS); 819 if (!netdev) { 820 dev_err(&intf->dev, "Couldn't allocate candev\n"); 821 kfree(bt_const); 822 return ERR_PTR(-ENOMEM); 823 } 824 825 dev = netdev_priv(netdev); 826 827 netdev->netdev_ops = &gs_usb_netdev_ops; 828 829 netdev->flags |= IFF_ECHO; /* we support full roundtrip echo */ 830 831 /* dev settup */ 832 strcpy(dev->bt_const.name, "gs_usb"); 833 dev->bt_const.tseg1_min = bt_const->tseg1_min; 834 dev->bt_const.tseg1_max = bt_const->tseg1_max; 835 dev->bt_const.tseg2_min = bt_const->tseg2_min; 836 dev->bt_const.tseg2_max = bt_const->tseg2_max; 837 dev->bt_const.sjw_max = bt_const->sjw_max; 838 dev->bt_const.brp_min = bt_const->brp_min; 839 dev->bt_const.brp_max = bt_const->brp_max; 840 dev->bt_const.brp_inc = bt_const->brp_inc; 841 842 dev->udev = interface_to_usbdev(intf); 843 dev->iface = intf; 844 dev->netdev = netdev; 845 dev->channel = channel; 846 847 init_usb_anchor(&dev->tx_submitted); 848 atomic_set(&dev->active_tx_urbs, 0); 849 spin_lock_init(&dev->tx_ctx_lock); 850 for (rc = 0; rc < GS_MAX_TX_URBS; rc++) { 851 dev->tx_context[rc].dev = dev; 852 dev->tx_context[rc].echo_id = GS_MAX_TX_URBS; 853 } 854 855 /* can settup */ 856 dev->can.state = CAN_STATE_STOPPED; 857 dev->can.clock.freq = bt_const->fclk_can; 858 dev->can.bittiming_const = &dev->bt_const; 859 dev->can.do_set_bittiming = gs_usb_set_bittiming; 860 861 dev->can.ctrlmode_supported = 0; 862 863 if (bt_const->feature & GS_CAN_FEATURE_LISTEN_ONLY) 864 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY; 865 866 if (bt_const->feature & GS_CAN_FEATURE_LOOP_BACK) 867 dev->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK; 868 869 if (bt_const->feature & GS_CAN_FEATURE_TRIPLE_SAMPLE) 870 dev->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES; 871 872 if (bt_const->feature & GS_CAN_FEATURE_ONE_SHOT) 873 dev->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT; 874 875 SET_NETDEV_DEV(netdev, &intf->dev); 876 877 if (dconf->sw_version > 1) 878 if (bt_const->feature & GS_CAN_FEATURE_IDENTIFY) 879 netdev->ethtool_ops = &gs_usb_ethtool_ops; 880 881 kfree(bt_const); 882 883 rc = register_candev(dev->netdev); 884 if (rc) { 885 free_candev(dev->netdev); 886 dev_err(&intf->dev, "Couldn't register candev (err=%d)\n", rc); 887 return ERR_PTR(rc); 888 } 889 890 return dev; 891 } 892 893 static void gs_destroy_candev(struct gs_can *dev) 894 { 895 unregister_candev(dev->netdev); 896 usb_kill_anchored_urbs(&dev->tx_submitted); 897 free_candev(dev->netdev); 898 } 899 900 static int gs_usb_probe(struct usb_interface *intf, 901 const struct usb_device_id *id) 902 { 903 struct gs_usb *dev; 904 int rc = -ENOMEM; 905 unsigned int icount, i; 906 struct gs_host_config *hconf; 907 struct gs_device_config *dconf; 908 909 hconf = kmalloc(sizeof(*hconf), GFP_KERNEL); 910 if (!hconf) 911 return -ENOMEM; 912 913 hconf->byte_order = 0x0000beef; 914 915 /* send host config */ 916 rc = usb_control_msg(interface_to_usbdev(intf), 917 usb_sndctrlpipe(interface_to_usbdev(intf), 0), 918 GS_USB_BREQ_HOST_FORMAT, 919 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 920 1, 921 intf->altsetting[0].desc.bInterfaceNumber, 922 hconf, 923 sizeof(*hconf), 924 1000); 925 926 kfree(hconf); 927 928 if (rc < 0) { 929 dev_err(&intf->dev, "Couldn't send data format (err=%d)\n", 930 rc); 931 return rc; 932 } 933 934 dconf = kmalloc(sizeof(*dconf), GFP_KERNEL); 935 if (!dconf) 936 return -ENOMEM; 937 938 /* read device config */ 939 rc = usb_control_msg(interface_to_usbdev(intf), 940 usb_rcvctrlpipe(interface_to_usbdev(intf), 0), 941 GS_USB_BREQ_DEVICE_CONFIG, 942 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 943 1, 944 intf->altsetting[0].desc.bInterfaceNumber, 945 dconf, 946 sizeof(*dconf), 947 1000); 948 if (rc < 0) { 949 dev_err(&intf->dev, "Couldn't get device config: (err=%d)\n", 950 rc); 951 kfree(dconf); 952 return rc; 953 } 954 955 icount = dconf->icount + 1; 956 dev_info(&intf->dev, "Configuring for %d interfaces\n", icount); 957 958 if (icount > GS_MAX_INTF) { 959 dev_err(&intf->dev, 960 "Driver cannot handle more that %d CAN interfaces\n", 961 GS_MAX_INTF); 962 kfree(dconf); 963 return -EINVAL; 964 } 965 966 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 967 if (!dev) { 968 kfree(dconf); 969 return -ENOMEM; 970 } 971 972 init_usb_anchor(&dev->rx_submitted); 973 974 atomic_set(&dev->active_channels, 0); 975 976 usb_set_intfdata(intf, dev); 977 dev->udev = interface_to_usbdev(intf); 978 979 for (i = 0; i < icount; i++) { 980 dev->canch[i] = gs_make_candev(i, intf, dconf); 981 if (IS_ERR_OR_NULL(dev->canch[i])) { 982 /* save error code to return later */ 983 rc = PTR_ERR(dev->canch[i]); 984 985 /* on failure destroy previously created candevs */ 986 icount = i; 987 for (i = 0; i < icount; i++) 988 gs_destroy_candev(dev->canch[i]); 989 990 usb_kill_anchored_urbs(&dev->rx_submitted); 991 kfree(dconf); 992 kfree(dev); 993 return rc; 994 } 995 dev->canch[i]->parent = dev; 996 } 997 998 kfree(dconf); 999 1000 return 0; 1001 } 1002 1003 static void gs_usb_disconnect(struct usb_interface *intf) 1004 { 1005 unsigned i; 1006 struct gs_usb *dev = usb_get_intfdata(intf); 1007 usb_set_intfdata(intf, NULL); 1008 1009 if (!dev) { 1010 dev_err(&intf->dev, "Disconnect (nodata)\n"); 1011 return; 1012 } 1013 1014 for (i = 0; i < GS_MAX_INTF; i++) 1015 if (dev->canch[i]) 1016 gs_destroy_candev(dev->canch[i]); 1017 1018 usb_kill_anchored_urbs(&dev->rx_submitted); 1019 kfree(dev); 1020 } 1021 1022 static const struct usb_device_id gs_usb_table[] = { 1023 { USB_DEVICE_INTERFACE_NUMBER(USB_GSUSB_1_VENDOR_ID, 1024 USB_GSUSB_1_PRODUCT_ID, 0) }, 1025 { USB_DEVICE_INTERFACE_NUMBER(USB_CANDLELIGHT_VENDOR_ID, 1026 USB_CANDLELIGHT_PRODUCT_ID, 0) }, 1027 {} /* Terminating entry */ 1028 }; 1029 1030 MODULE_DEVICE_TABLE(usb, gs_usb_table); 1031 1032 static struct usb_driver gs_usb_driver = { 1033 .name = "gs_usb", 1034 .probe = gs_usb_probe, 1035 .disconnect = gs_usb_disconnect, 1036 .id_table = gs_usb_table, 1037 }; 1038 1039 module_usb_driver(gs_usb_driver); 1040 1041 MODULE_AUTHOR("Maximilian Schneider <mws@schneidersoft.net>"); 1042 MODULE_DESCRIPTION( 1043 "Socket CAN device driver for Geschwister Schneider Technologie-, " 1044 "Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces\n" 1045 "and bytewerk.org candleLight USB CAN interfaces."); 1046 MODULE_LICENSE("GPL v2"); 1047