1 /* CAN driver for Geschwister Schneider USB/CAN devices
2 * and bytewerk.org candleLight USB CAN interfaces.
4 * Copyright (C) 2013-2016 Geschwister Schneider Technologie-,
5 * Entwicklungs- und Vertriebs UG (Haftungsbeschränkt).
6 * Copyright (C) 2016 Hubert Denkmair
8 * Many thanks to all socketcan devs!
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published
12 * by the Free Software Foundation; version 2 of the License.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
20 #include <linux/init.h>
21 #include <linux/signal.h>
22 #include <linux/module.h>
23 #include <linux/netdevice.h>
24 #include <linux/usb.h>
26 #include <linux/can.h>
27 #include <linux/can/dev.h>
28 #include <linux/can/error.h>
30 /* Device specific constants */
31 #define USB_GSUSB_1_VENDOR_ID 0x1d50
32 #define USB_GSUSB_1_PRODUCT_ID 0x606f
34 #define USB_CANDLELIGHT_VENDOR_ID 0x1209
35 #define USB_CANDLELIGHT_PRODUCT_ID 0x2323
37 #define GSUSB_ENDPOINT_IN 1
38 #define GSUSB_ENDPOINT_OUT 2
40 /* Device specific constants */
42 GS_USB_BREQ_HOST_FORMAT
= 0,
43 GS_USB_BREQ_BITTIMING
,
47 GS_USB_BREQ_DEVICE_CONFIG
,
48 GS_USB_BREQ_TIMESTAMP
,
53 /* reset a channel. turns it off */
54 GS_CAN_MODE_RESET
= 0,
55 /* starts a channel */
60 GS_CAN_STATE_ERROR_ACTIVE
= 0,
61 GS_CAN_STATE_ERROR_WARNING
,
62 GS_CAN_STATE_ERROR_PASSIVE
,
68 enum gs_can_identify_mode
{
69 GS_CAN_IDENTIFY_OFF
= 0,
73 /* data types passed between host and device */
74 struct gs_host_config
{
77 /* All data exchanged between host and device is exchanged in host byte order,
78 * thanks to the struct gs_host_config byte_order member, which is sent first
79 * to indicate the desired byte order.
82 struct gs_device_config
{
91 #define GS_CAN_MODE_NORMAL 0
92 #define GS_CAN_MODE_LISTEN_ONLY BIT(0)
93 #define GS_CAN_MODE_LOOP_BACK BIT(1)
94 #define GS_CAN_MODE_TRIPLE_SAMPLE BIT(2)
95 #define GS_CAN_MODE_ONE_SHOT BIT(3)
97 struct gs_device_mode
{
102 struct gs_device_state
{
108 struct gs_device_bittiming
{
116 struct gs_identify_mode
{
120 #define GS_CAN_FEATURE_LISTEN_ONLY BIT(0)
121 #define GS_CAN_FEATURE_LOOP_BACK BIT(1)
122 #define GS_CAN_FEATURE_TRIPLE_SAMPLE BIT(2)
123 #define GS_CAN_FEATURE_ONE_SHOT BIT(3)
124 #define GS_CAN_FEATURE_HW_TIMESTAMP BIT(4)
125 #define GS_CAN_FEATURE_IDENTIFY BIT(5)
127 struct gs_device_bt_const
{
140 #define GS_CAN_FLAG_OVERFLOW 1
142 struct gs_host_frame
{
153 /* The GS USB devices make use of the same flags and masks as in
154 * linux/can.h and linux/can/error.h, and no additional mapping is necessary.
157 /* Only send a max of GS_MAX_TX_URBS frames per channel at a time. */
158 #define GS_MAX_TX_URBS 10
159 /* Only launch a max of GS_MAX_RX_URBS usb requests at a time. */
160 #define GS_MAX_RX_URBS 30
161 /* Maximum number of interfaces the driver supports per device.
162 * Current hardware only supports 2 interfaces. The future may vary.
164 #define GS_MAX_INTF 2
166 struct gs_tx_context
{
168 unsigned int echo_id
;
172 struct can_priv can
; /* must be the first member */
174 struct gs_usb
*parent
;
176 struct net_device
*netdev
;
177 struct usb_device
*udev
;
178 struct usb_interface
*iface
;
180 struct can_bittiming_const bt_const
;
181 unsigned int channel
; /* channel number */
183 /* This lock prevents a race condition between xmit and receive. */
184 spinlock_t tx_ctx_lock
;
185 struct gs_tx_context tx_context
[GS_MAX_TX_URBS
];
187 struct usb_anchor tx_submitted
;
188 atomic_t active_tx_urbs
;
191 /* usb interface struct */
193 struct gs_can
*canch
[GS_MAX_INTF
];
194 struct usb_anchor rx_submitted
;
195 atomic_t active_channels
;
196 struct usb_device
*udev
;
199 /* 'allocate' a tx context.
200 * returns a valid tx context or NULL if there is no space.
202 static struct gs_tx_context
*gs_alloc_tx_context(struct gs_can
*dev
)
207 spin_lock_irqsave(&dev
->tx_ctx_lock
, flags
);
209 for (; i
< GS_MAX_TX_URBS
; i
++) {
210 if (dev
->tx_context
[i
].echo_id
== GS_MAX_TX_URBS
) {
211 dev
->tx_context
[i
].echo_id
= i
;
212 spin_unlock_irqrestore(&dev
->tx_ctx_lock
, flags
);
213 return &dev
->tx_context
[i
];
217 spin_unlock_irqrestore(&dev
->tx_ctx_lock
, flags
);
221 /* releases a tx context
223 static void gs_free_tx_context(struct gs_tx_context
*txc
)
225 txc
->echo_id
= GS_MAX_TX_URBS
;
228 /* Get a tx context by id.
230 static struct gs_tx_context
*gs_get_tx_context(struct gs_can
*dev
,
235 if (id
< GS_MAX_TX_URBS
) {
236 spin_lock_irqsave(&dev
->tx_ctx_lock
, flags
);
237 if (dev
->tx_context
[id
].echo_id
== id
) {
238 spin_unlock_irqrestore(&dev
->tx_ctx_lock
, flags
);
239 return &dev
->tx_context
[id
];
241 spin_unlock_irqrestore(&dev
->tx_ctx_lock
, flags
);
246 static int gs_cmd_reset(struct gs_usb
*gsusb
, struct gs_can
*gsdev
)
248 struct gs_device_mode
*dm
;
249 struct usb_interface
*intf
= gsdev
->iface
;
252 dm
= kzalloc(sizeof(*dm
), GFP_KERNEL
);
256 dm
->mode
= GS_CAN_MODE_RESET
;
258 rc
= usb_control_msg(interface_to_usbdev(intf
),
259 usb_sndctrlpipe(interface_to_usbdev(intf
), 0),
261 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
273 static void gs_update_state(struct gs_can
*dev
, struct can_frame
*cf
)
275 struct can_device_stats
*can_stats
= &dev
->can
.can_stats
;
277 if (cf
->can_id
& CAN_ERR_RESTARTED
) {
278 dev
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
279 can_stats
->restarts
++;
280 } else if (cf
->can_id
& CAN_ERR_BUSOFF
) {
281 dev
->can
.state
= CAN_STATE_BUS_OFF
;
282 can_stats
->bus_off
++;
283 } else if (cf
->can_id
& CAN_ERR_CRTL
) {
284 if ((cf
->data
[1] & CAN_ERR_CRTL_TX_WARNING
) ||
285 (cf
->data
[1] & CAN_ERR_CRTL_RX_WARNING
)) {
286 dev
->can
.state
= CAN_STATE_ERROR_WARNING
;
287 can_stats
->error_warning
++;
288 } else if ((cf
->data
[1] & CAN_ERR_CRTL_TX_PASSIVE
) ||
289 (cf
->data
[1] & CAN_ERR_CRTL_RX_PASSIVE
)) {
290 dev
->can
.state
= CAN_STATE_ERROR_PASSIVE
;
291 can_stats
->error_passive
++;
293 dev
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
298 static void gs_usb_receive_bulk_callback(struct urb
*urb
)
300 struct gs_usb
*usbcan
= urb
->context
;
302 struct net_device
*netdev
;
304 struct net_device_stats
*stats
;
305 struct gs_host_frame
*hf
= urb
->transfer_buffer
;
306 struct gs_tx_context
*txc
;
307 struct can_frame
*cf
;
312 switch (urb
->status
) {
313 case 0: /* success */
319 /* do not resubmit aborted urbs. eg: when device goes down */
323 /* device reports out of range channel id */
324 if (hf
->channel
>= GS_MAX_INTF
)
327 dev
= usbcan
->canch
[hf
->channel
];
329 netdev
= dev
->netdev
;
330 stats
= &netdev
->stats
;
332 if (!netif_device_present(netdev
))
335 if (hf
->echo_id
== -1) { /* normal rx */
336 skb
= alloc_can_skb(dev
->netdev
, &cf
);
340 cf
->can_id
= hf
->can_id
;
342 cf
->can_dlc
= get_can_dlc(hf
->can_dlc
);
343 memcpy(cf
->data
, hf
->data
, 8);
345 /* ERROR frames tell us information about the controller */
346 if (hf
->can_id
& CAN_ERR_FLAG
)
347 gs_update_state(dev
, cf
);
349 netdev
->stats
.rx_packets
++;
350 netdev
->stats
.rx_bytes
+= hf
->can_dlc
;
353 } else { /* echo_id == hf->echo_id */
354 if (hf
->echo_id
>= GS_MAX_TX_URBS
) {
356 "Unexpected out of range echo id %d\n",
361 netdev
->stats
.tx_packets
++;
362 netdev
->stats
.tx_bytes
+= hf
->can_dlc
;
364 txc
= gs_get_tx_context(dev
, hf
->echo_id
);
366 /* bad devices send bad echo_ids. */
369 "Unexpected unused echo id %d\n",
374 can_get_echo_skb(netdev
, hf
->echo_id
);
376 gs_free_tx_context(txc
);
378 netif_wake_queue(netdev
);
381 if (hf
->flags
& GS_CAN_FLAG_OVERFLOW
) {
382 skb
= alloc_can_err_skb(netdev
, &cf
);
386 cf
->can_id
|= CAN_ERR_CRTL
;
387 cf
->can_dlc
= CAN_ERR_DLC
;
388 cf
->data
[1] = CAN_ERR_CRTL_RX_OVERFLOW
;
389 stats
->rx_over_errors
++;
395 usb_fill_bulk_urb(urb
,
397 usb_rcvbulkpipe(usbcan
->udev
, GSUSB_ENDPOINT_IN
),
399 sizeof(struct gs_host_frame
),
400 gs_usb_receive_bulk_callback
,
404 rc
= usb_submit_urb(urb
, GFP_ATOMIC
);
406 /* USB failure take down all interfaces */
408 for (rc
= 0; rc
< GS_MAX_INTF
; rc
++) {
409 if (usbcan
->canch
[rc
])
410 netif_device_detach(usbcan
->canch
[rc
]->netdev
);
415 static int gs_usb_set_bittiming(struct net_device
*netdev
)
417 struct gs_can
*dev
= netdev_priv(netdev
);
418 struct can_bittiming
*bt
= &dev
->can
.bittiming
;
419 struct usb_interface
*intf
= dev
->iface
;
421 struct gs_device_bittiming
*dbt
;
423 dbt
= kmalloc(sizeof(*dbt
), GFP_KERNEL
);
427 dbt
->prop_seg
= bt
->prop_seg
;
428 dbt
->phase_seg1
= bt
->phase_seg1
;
429 dbt
->phase_seg2
= bt
->phase_seg2
;
433 /* request bit timings */
434 rc
= usb_control_msg(interface_to_usbdev(intf
),
435 usb_sndctrlpipe(interface_to_usbdev(intf
), 0),
436 GS_USB_BREQ_BITTIMING
,
437 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
447 dev_err(netdev
->dev
.parent
, "Couldn't set bittimings (err=%d)",
453 static void gs_usb_xmit_callback(struct urb
*urb
)
455 struct gs_tx_context
*txc
= urb
->context
;
456 struct gs_can
*dev
= txc
->dev
;
457 struct net_device
*netdev
= dev
->netdev
;
460 netdev_info(netdev
, "usb xmit fail %d\n", txc
->echo_id
);
462 usb_free_coherent(urb
->dev
,
463 urb
->transfer_buffer_length
,
464 urb
->transfer_buffer
,
467 atomic_dec(&dev
->active_tx_urbs
);
469 if (!netif_device_present(netdev
))
472 if (netif_queue_stopped(netdev
))
473 netif_wake_queue(netdev
);
476 static netdev_tx_t
gs_can_start_xmit(struct sk_buff
*skb
,
477 struct net_device
*netdev
)
479 struct gs_can
*dev
= netdev_priv(netdev
);
480 struct net_device_stats
*stats
= &dev
->netdev
->stats
;
482 struct gs_host_frame
*hf
;
483 struct can_frame
*cf
;
486 struct gs_tx_context
*txc
;
488 if (can_dropped_invalid_skb(netdev
, skb
))
491 /* find an empty context to keep track of transmission */
492 txc
= gs_alloc_tx_context(dev
);
494 return NETDEV_TX_BUSY
;
496 /* create a URB, and a buffer for it */
497 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
501 hf
= usb_alloc_coherent(dev
->udev
, sizeof(*hf
), GFP_ATOMIC
,
504 netdev_err(netdev
, "No memory left for USB buffer\n");
510 if (idx
>= GS_MAX_TX_URBS
) {
511 netdev_err(netdev
, "Invalid tx context %d\n", idx
);
516 hf
->channel
= dev
->channel
;
518 cf
= (struct can_frame
*)skb
->data
;
520 hf
->can_id
= cf
->can_id
;
521 hf
->can_dlc
= cf
->can_dlc
;
522 memcpy(hf
->data
, cf
->data
, cf
->can_dlc
);
524 usb_fill_bulk_urb(urb
, dev
->udev
,
525 usb_sndbulkpipe(dev
->udev
, GSUSB_ENDPOINT_OUT
),
528 gs_usb_xmit_callback
,
531 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
532 usb_anchor_urb(urb
, &dev
->tx_submitted
);
534 can_put_echo_skb(skb
, netdev
, idx
);
536 atomic_inc(&dev
->active_tx_urbs
);
538 rc
= usb_submit_urb(urb
, GFP_ATOMIC
);
539 if (unlikely(rc
)) { /* usb send failed */
540 atomic_dec(&dev
->active_tx_urbs
);
542 can_free_echo_skb(netdev
, idx
);
543 gs_free_tx_context(txc
);
545 usb_unanchor_urb(urb
);
546 usb_free_coherent(dev
->udev
,
552 netif_device_detach(netdev
);
554 netdev_err(netdev
, "usb_submit failed (err=%d)\n", rc
);
558 /* Slow down tx path */
559 if (atomic_read(&dev
->active_tx_urbs
) >= GS_MAX_TX_URBS
)
560 netif_stop_queue(netdev
);
563 /* let usb core take care of this urb */
569 usb_free_coherent(dev
->udev
,
577 gs_free_tx_context(txc
);
583 static int gs_can_open(struct net_device
*netdev
)
585 struct gs_can
*dev
= netdev_priv(netdev
);
586 struct gs_usb
*parent
= dev
->parent
;
588 struct gs_device_mode
*dm
;
591 rc
= open_candev(netdev
);
595 if (atomic_add_return(1, &parent
->active_channels
) == 1) {
596 for (i
= 0; i
< GS_MAX_RX_URBS
; i
++) {
601 urb
= usb_alloc_urb(0, GFP_KERNEL
);
605 /* alloc rx buffer */
606 buf
= usb_alloc_coherent(dev
->udev
,
607 sizeof(struct gs_host_frame
),
612 "No memory left for USB buffer\n");
617 /* fill, anchor, and submit rx urb */
618 usb_fill_bulk_urb(urb
,
620 usb_rcvbulkpipe(dev
->udev
,
623 sizeof(struct gs_host_frame
),
624 gs_usb_receive_bulk_callback
,
626 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
628 usb_anchor_urb(urb
, &parent
->rx_submitted
);
630 rc
= usb_submit_urb(urb
, GFP_KERNEL
);
633 netif_device_detach(dev
->netdev
);
636 "usb_submit failed (err=%d)\n",
639 usb_unanchor_urb(urb
);
644 * USB core will take care of freeing it
650 dm
= kmalloc(sizeof(*dm
), GFP_KERNEL
);
655 ctrlmode
= dev
->can
.ctrlmode
;
658 if (ctrlmode
& CAN_CTRLMODE_LOOPBACK
)
659 dm
->flags
|= GS_CAN_MODE_LOOP_BACK
;
660 else if (ctrlmode
& CAN_CTRLMODE_LISTENONLY
)
661 dm
->flags
|= GS_CAN_MODE_LISTEN_ONLY
;
663 /* Controller is not allowed to retry TX
664 * this mode is unavailable on atmels uc3c hardware
666 if (ctrlmode
& CAN_CTRLMODE_ONE_SHOT
)
667 dm
->flags
|= GS_CAN_MODE_ONE_SHOT
;
669 if (ctrlmode
& CAN_CTRLMODE_3_SAMPLES
)
670 dm
->flags
|= GS_CAN_MODE_TRIPLE_SAMPLE
;
672 /* finally start device */
673 dm
->mode
= GS_CAN_MODE_START
;
674 rc
= usb_control_msg(interface_to_usbdev(dev
->iface
),
675 usb_sndctrlpipe(interface_to_usbdev(dev
->iface
), 0),
677 USB_DIR_OUT
| USB_TYPE_VENDOR
|
686 netdev_err(netdev
, "Couldn't start device (err=%d)\n", rc
);
693 dev
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
695 if (!(dev
->can
.ctrlmode
& CAN_CTRLMODE_LISTENONLY
))
696 netif_start_queue(netdev
);
701 static int gs_can_close(struct net_device
*netdev
)
704 struct gs_can
*dev
= netdev_priv(netdev
);
705 struct gs_usb
*parent
= dev
->parent
;
707 netif_stop_queue(netdev
);
710 if (atomic_dec_and_test(&parent
->active_channels
))
711 usb_kill_anchored_urbs(&parent
->rx_submitted
);
713 /* Stop sending URBs */
714 usb_kill_anchored_urbs(&dev
->tx_submitted
);
715 atomic_set(&dev
->active_tx_urbs
, 0);
717 /* reset the device */
718 rc
= gs_cmd_reset(parent
, dev
);
720 netdev_warn(netdev
, "Couldn't shutdown device (err=%d)", rc
);
722 /* reset tx contexts */
723 for (rc
= 0; rc
< GS_MAX_TX_URBS
; rc
++) {
724 dev
->tx_context
[rc
].dev
= dev
;
725 dev
->tx_context
[rc
].echo_id
= GS_MAX_TX_URBS
;
728 /* close the netdev */
729 close_candev(netdev
);
734 static const struct net_device_ops gs_usb_netdev_ops
= {
735 .ndo_open
= gs_can_open
,
736 .ndo_stop
= gs_can_close
,
737 .ndo_start_xmit
= gs_can_start_xmit
,
738 .ndo_change_mtu
= can_change_mtu
,
741 static int gs_usb_set_identify(struct net_device
*netdev
, bool do_identify
)
743 struct gs_can
*dev
= netdev_priv(netdev
);
744 struct gs_identify_mode
*imode
;
747 imode
= kmalloc(sizeof(*imode
), GFP_KERNEL
);
753 imode
->mode
= GS_CAN_IDENTIFY_ON
;
755 imode
->mode
= GS_CAN_IDENTIFY_OFF
;
757 rc
= usb_control_msg(interface_to_usbdev(dev
->iface
),
758 usb_sndctrlpipe(interface_to_usbdev(dev
->iface
),
760 GS_USB_BREQ_IDENTIFY
,
761 USB_DIR_OUT
| USB_TYPE_VENDOR
|
771 return (rc
> 0) ? 0 : rc
;
774 /* blink LED's for finding the this interface */
775 static int gs_usb_set_phys_id(struct net_device
*dev
,
776 enum ethtool_phys_id_state state
)
781 case ETHTOOL_ID_ACTIVE
:
782 rc
= gs_usb_set_identify(dev
, GS_CAN_IDENTIFY_ON
);
784 case ETHTOOL_ID_INACTIVE
:
785 rc
= gs_usb_set_identify(dev
, GS_CAN_IDENTIFY_OFF
);
794 static const struct ethtool_ops gs_usb_ethtool_ops
= {
795 .set_phys_id
= gs_usb_set_phys_id
,
798 static struct gs_can
*gs_make_candev(unsigned int channel
,
799 struct usb_interface
*intf
,
800 struct gs_device_config
*dconf
)
803 struct net_device
*netdev
;
805 struct gs_device_bt_const
*bt_const
;
807 bt_const
= kmalloc(sizeof(*bt_const
), GFP_KERNEL
);
809 return ERR_PTR(-ENOMEM
);
811 /* fetch bit timing constants */
812 rc
= usb_control_msg(interface_to_usbdev(intf
),
813 usb_rcvctrlpipe(interface_to_usbdev(intf
), 0),
814 GS_USB_BREQ_BT_CONST
,
815 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
824 "Couldn't get bit timing const for channel (err=%d)\n",
831 netdev
= alloc_candev(sizeof(struct gs_can
), GS_MAX_TX_URBS
);
833 dev_err(&intf
->dev
, "Couldn't allocate candev\n");
835 return ERR_PTR(-ENOMEM
);
838 dev
= netdev_priv(netdev
);
840 netdev
->netdev_ops
= &gs_usb_netdev_ops
;
842 netdev
->flags
|= IFF_ECHO
; /* we support full roundtrip echo */
845 strcpy(dev
->bt_const
.name
, "gs_usb");
846 dev
->bt_const
.tseg1_min
= bt_const
->tseg1_min
;
847 dev
->bt_const
.tseg1_max
= bt_const
->tseg1_max
;
848 dev
->bt_const
.tseg2_min
= bt_const
->tseg2_min
;
849 dev
->bt_const
.tseg2_max
= bt_const
->tseg2_max
;
850 dev
->bt_const
.sjw_max
= bt_const
->sjw_max
;
851 dev
->bt_const
.brp_min
= bt_const
->brp_min
;
852 dev
->bt_const
.brp_max
= bt_const
->brp_max
;
853 dev
->bt_const
.brp_inc
= bt_const
->brp_inc
;
855 dev
->udev
= interface_to_usbdev(intf
);
857 dev
->netdev
= netdev
;
858 dev
->channel
= channel
;
860 init_usb_anchor(&dev
->tx_submitted
);
861 atomic_set(&dev
->active_tx_urbs
, 0);
862 spin_lock_init(&dev
->tx_ctx_lock
);
863 for (rc
= 0; rc
< GS_MAX_TX_URBS
; rc
++) {
864 dev
->tx_context
[rc
].dev
= dev
;
865 dev
->tx_context
[rc
].echo_id
= GS_MAX_TX_URBS
;
869 dev
->can
.state
= CAN_STATE_STOPPED
;
870 dev
->can
.clock
.freq
= bt_const
->fclk_can
;
871 dev
->can
.bittiming_const
= &dev
->bt_const
;
872 dev
->can
.do_set_bittiming
= gs_usb_set_bittiming
;
874 dev
->can
.ctrlmode_supported
= 0;
876 if (bt_const
->feature
& GS_CAN_FEATURE_LISTEN_ONLY
)
877 dev
->can
.ctrlmode_supported
|= CAN_CTRLMODE_LISTENONLY
;
879 if (bt_const
->feature
& GS_CAN_FEATURE_LOOP_BACK
)
880 dev
->can
.ctrlmode_supported
|= CAN_CTRLMODE_LOOPBACK
;
882 if (bt_const
->feature
& GS_CAN_FEATURE_TRIPLE_SAMPLE
)
883 dev
->can
.ctrlmode_supported
|= CAN_CTRLMODE_3_SAMPLES
;
885 if (bt_const
->feature
& GS_CAN_FEATURE_ONE_SHOT
)
886 dev
->can
.ctrlmode_supported
|= CAN_CTRLMODE_ONE_SHOT
;
888 SET_NETDEV_DEV(netdev
, &intf
->dev
);
890 if (dconf
->sw_version
> 1)
891 if (bt_const
->feature
& GS_CAN_FEATURE_IDENTIFY
)
892 netdev
->ethtool_ops
= &gs_usb_ethtool_ops
;
896 rc
= register_candev(dev
->netdev
);
898 free_candev(dev
->netdev
);
899 dev_err(&intf
->dev
, "Couldn't register candev (err=%d)\n", rc
);
906 static void gs_destroy_candev(struct gs_can
*dev
)
908 unregister_candev(dev
->netdev
);
909 usb_kill_anchored_urbs(&dev
->tx_submitted
);
910 free_candev(dev
->netdev
);
913 static int gs_usb_probe(struct usb_interface
*intf
,
914 const struct usb_device_id
*id
)
918 unsigned int icount
, i
;
919 struct gs_host_config
*hconf
;
920 struct gs_device_config
*dconf
;
922 hconf
= kmalloc(sizeof(*hconf
), GFP_KERNEL
);
926 hconf
->byte_order
= 0x0000beef;
928 /* send host config */
929 rc
= usb_control_msg(interface_to_usbdev(intf
),
930 usb_sndctrlpipe(interface_to_usbdev(intf
), 0),
931 GS_USB_BREQ_HOST_FORMAT
,
932 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
934 intf
->altsetting
[0].desc
.bInterfaceNumber
,
942 dev_err(&intf
->dev
, "Couldn't send data format (err=%d)\n",
947 dconf
= kmalloc(sizeof(*dconf
), GFP_KERNEL
);
951 /* read device config */
952 rc
= usb_control_msg(interface_to_usbdev(intf
),
953 usb_rcvctrlpipe(interface_to_usbdev(intf
), 0),
954 GS_USB_BREQ_DEVICE_CONFIG
,
955 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
957 intf
->altsetting
[0].desc
.bInterfaceNumber
,
962 dev_err(&intf
->dev
, "Couldn't get device config: (err=%d)\n",
968 icount
= dconf
->icount
+ 1;
969 dev_info(&intf
->dev
, "Configuring for %d interfaces\n", icount
);
971 if (icount
> GS_MAX_INTF
) {
973 "Driver cannot handle more that %d CAN interfaces\n",
979 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
985 init_usb_anchor(&dev
->rx_submitted
);
987 atomic_set(&dev
->active_channels
, 0);
989 usb_set_intfdata(intf
, dev
);
990 dev
->udev
= interface_to_usbdev(intf
);
992 for (i
= 0; i
< icount
; i
++) {
993 dev
->canch
[i
] = gs_make_candev(i
, intf
, dconf
);
994 if (IS_ERR_OR_NULL(dev
->canch
[i
])) {
995 /* save error code to return later */
996 rc
= PTR_ERR(dev
->canch
[i
]);
998 /* on failure destroy previously created candevs */
1000 for (i
= 0; i
< icount
; i
++)
1001 gs_destroy_candev(dev
->canch
[i
]);
1003 usb_kill_anchored_urbs(&dev
->rx_submitted
);
1008 dev
->canch
[i
]->parent
= dev
;
1016 static void gs_usb_disconnect(struct usb_interface
*intf
)
1019 struct gs_usb
*dev
= usb_get_intfdata(intf
);
1020 usb_set_intfdata(intf
, NULL
);
1023 dev_err(&intf
->dev
, "Disconnect (nodata)\n");
1027 for (i
= 0; i
< GS_MAX_INTF
; i
++)
1029 gs_destroy_candev(dev
->canch
[i
]);
1031 usb_kill_anchored_urbs(&dev
->rx_submitted
);
1035 static const struct usb_device_id gs_usb_table
[] = {
1036 { USB_DEVICE_INTERFACE_NUMBER(USB_GSUSB_1_VENDOR_ID
,
1037 USB_GSUSB_1_PRODUCT_ID
, 0) },
1038 { USB_DEVICE_INTERFACE_NUMBER(USB_CANDLELIGHT_VENDOR_ID
,
1039 USB_CANDLELIGHT_PRODUCT_ID
, 0) },
1040 {} /* Terminating entry */
1043 MODULE_DEVICE_TABLE(usb
, gs_usb_table
);
1045 static struct usb_driver gs_usb_driver
= {
1047 .probe
= gs_usb_probe
,
1048 .disconnect
= gs_usb_disconnect
,
1049 .id_table
= gs_usb_table
,
1052 module_usb_driver(gs_usb_driver
);
1054 MODULE_AUTHOR("Maximilian Schneider <mws@schneidersoft.net>");
1056 "Socket CAN device driver for Geschwister Schneider Technologie-, "
1057 "Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces\n"
1058 "and bytewerk.org candleLight USB CAN interfaces.");
1059 MODULE_LICENSE("GPL v2");