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