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
,
271 static void gs_update_state(struct gs_can
*dev
, struct can_frame
*cf
)
273 struct can_device_stats
*can_stats
= &dev
->can
.can_stats
;
275 if (cf
->can_id
& CAN_ERR_RESTARTED
) {
276 dev
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
277 can_stats
->restarts
++;
278 } else if (cf
->can_id
& CAN_ERR_BUSOFF
) {
279 dev
->can
.state
= CAN_STATE_BUS_OFF
;
280 can_stats
->bus_off
++;
281 } else if (cf
->can_id
& CAN_ERR_CRTL
) {
282 if ((cf
->data
[1] & CAN_ERR_CRTL_TX_WARNING
) ||
283 (cf
->data
[1] & CAN_ERR_CRTL_RX_WARNING
)) {
284 dev
->can
.state
= CAN_STATE_ERROR_WARNING
;
285 can_stats
->error_warning
++;
286 } else if ((cf
->data
[1] & CAN_ERR_CRTL_TX_PASSIVE
) ||
287 (cf
->data
[1] & CAN_ERR_CRTL_RX_PASSIVE
)) {
288 dev
->can
.state
= CAN_STATE_ERROR_PASSIVE
;
289 can_stats
->error_passive
++;
291 dev
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
296 static void gs_usb_receive_bulk_callback(struct urb
*urb
)
298 struct gs_usb
*usbcan
= urb
->context
;
300 struct net_device
*netdev
;
302 struct net_device_stats
*stats
;
303 struct gs_host_frame
*hf
= urb
->transfer_buffer
;
304 struct gs_tx_context
*txc
;
305 struct can_frame
*cf
;
310 switch (urb
->status
) {
311 case 0: /* success */
317 /* do not resubmit aborted urbs. eg: when device goes down */
321 /* device reports out of range channel id */
322 if (hf
->channel
>= GS_MAX_INTF
)
325 dev
= usbcan
->canch
[hf
->channel
];
327 netdev
= dev
->netdev
;
328 stats
= &netdev
->stats
;
330 if (!netif_device_present(netdev
))
333 if (hf
->echo_id
== -1) { /* normal rx */
334 skb
= alloc_can_skb(dev
->netdev
, &cf
);
338 cf
->can_id
= hf
->can_id
;
340 cf
->can_dlc
= get_can_dlc(hf
->can_dlc
);
341 memcpy(cf
->data
, hf
->data
, 8);
343 /* ERROR frames tell us information about the controller */
344 if (hf
->can_id
& CAN_ERR_FLAG
)
345 gs_update_state(dev
, cf
);
347 netdev
->stats
.rx_packets
++;
348 netdev
->stats
.rx_bytes
+= hf
->can_dlc
;
351 } else { /* echo_id == hf->echo_id */
352 if (hf
->echo_id
>= GS_MAX_TX_URBS
) {
354 "Unexpected out of range echo id %d\n",
359 netdev
->stats
.tx_packets
++;
360 netdev
->stats
.tx_bytes
+= hf
->can_dlc
;
362 txc
= gs_get_tx_context(dev
, hf
->echo_id
);
364 /* bad devices send bad echo_ids. */
367 "Unexpected unused echo id %d\n",
372 can_get_echo_skb(netdev
, hf
->echo_id
);
374 gs_free_tx_context(txc
);
376 netif_wake_queue(netdev
);
379 if (hf
->flags
& GS_CAN_FLAG_OVERFLOW
) {
380 skb
= alloc_can_err_skb(netdev
, &cf
);
384 cf
->can_id
|= CAN_ERR_CRTL
;
385 cf
->can_dlc
= CAN_ERR_DLC
;
386 cf
->data
[1] = CAN_ERR_CRTL_RX_OVERFLOW
;
387 stats
->rx_over_errors
++;
393 usb_fill_bulk_urb(urb
,
395 usb_rcvbulkpipe(usbcan
->udev
, GSUSB_ENDPOINT_IN
),
397 sizeof(struct gs_host_frame
),
398 gs_usb_receive_bulk_callback
,
402 rc
= usb_submit_urb(urb
, GFP_ATOMIC
);
404 /* USB failure take down all interfaces */
406 for (rc
= 0; rc
< GS_MAX_INTF
; rc
++) {
407 if (usbcan
->canch
[rc
])
408 netif_device_detach(usbcan
->canch
[rc
]->netdev
);
413 static int gs_usb_set_bittiming(struct net_device
*netdev
)
415 struct gs_can
*dev
= netdev_priv(netdev
);
416 struct can_bittiming
*bt
= &dev
->can
.bittiming
;
417 struct usb_interface
*intf
= dev
->iface
;
419 struct gs_device_bittiming
*dbt
;
421 dbt
= kmalloc(sizeof(*dbt
), GFP_KERNEL
);
425 dbt
->prop_seg
= bt
->prop_seg
;
426 dbt
->phase_seg1
= bt
->phase_seg1
;
427 dbt
->phase_seg2
= bt
->phase_seg2
;
431 /* request bit timings */
432 rc
= usb_control_msg(interface_to_usbdev(intf
),
433 usb_sndctrlpipe(interface_to_usbdev(intf
), 0),
434 GS_USB_BREQ_BITTIMING
,
435 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
445 dev_err(netdev
->dev
.parent
, "Couldn't set bittimings (err=%d)",
451 static void gs_usb_xmit_callback(struct urb
*urb
)
453 struct gs_tx_context
*txc
= urb
->context
;
454 struct gs_can
*dev
= txc
->dev
;
455 struct net_device
*netdev
= dev
->netdev
;
458 netdev_info(netdev
, "usb xmit fail %d\n", txc
->echo_id
);
460 usb_free_coherent(urb
->dev
,
461 urb
->transfer_buffer_length
,
462 urb
->transfer_buffer
,
465 atomic_dec(&dev
->active_tx_urbs
);
467 if (!netif_device_present(netdev
))
470 if (netif_queue_stopped(netdev
))
471 netif_wake_queue(netdev
);
474 static netdev_tx_t
gs_can_start_xmit(struct sk_buff
*skb
,
475 struct net_device
*netdev
)
477 struct gs_can
*dev
= netdev_priv(netdev
);
478 struct net_device_stats
*stats
= &dev
->netdev
->stats
;
480 struct gs_host_frame
*hf
;
481 struct can_frame
*cf
;
484 struct gs_tx_context
*txc
;
486 if (can_dropped_invalid_skb(netdev
, skb
))
489 /* find an empty context to keep track of transmission */
490 txc
= gs_alloc_tx_context(dev
);
492 return NETDEV_TX_BUSY
;
494 /* create a URB, and a buffer for it */
495 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
499 hf
= usb_alloc_coherent(dev
->udev
, sizeof(*hf
), GFP_ATOMIC
,
502 netdev_err(netdev
, "No memory left for USB buffer\n");
508 if (idx
>= GS_MAX_TX_URBS
) {
509 netdev_err(netdev
, "Invalid tx context %d\n", idx
);
514 hf
->channel
= dev
->channel
;
516 cf
= (struct can_frame
*)skb
->data
;
518 hf
->can_id
= cf
->can_id
;
519 hf
->can_dlc
= cf
->can_dlc
;
520 memcpy(hf
->data
, cf
->data
, cf
->can_dlc
);
522 usb_fill_bulk_urb(urb
, dev
->udev
,
523 usb_sndbulkpipe(dev
->udev
, GSUSB_ENDPOINT_OUT
),
526 gs_usb_xmit_callback
,
529 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
530 usb_anchor_urb(urb
, &dev
->tx_submitted
);
532 can_put_echo_skb(skb
, netdev
, idx
);
534 atomic_inc(&dev
->active_tx_urbs
);
536 rc
= usb_submit_urb(urb
, GFP_ATOMIC
);
537 if (unlikely(rc
)) { /* usb send failed */
538 atomic_dec(&dev
->active_tx_urbs
);
540 can_free_echo_skb(netdev
, idx
);
541 gs_free_tx_context(txc
);
543 usb_unanchor_urb(urb
);
544 usb_free_coherent(dev
->udev
,
550 netif_device_detach(netdev
);
552 netdev_err(netdev
, "usb_submit failed (err=%d)\n", rc
);
556 /* Slow down tx path */
557 if (atomic_read(&dev
->active_tx_urbs
) >= GS_MAX_TX_URBS
)
558 netif_stop_queue(netdev
);
561 /* let usb core take care of this urb */
567 usb_free_coherent(dev
->udev
,
575 gs_free_tx_context(txc
);
581 static int gs_can_open(struct net_device
*netdev
)
583 struct gs_can
*dev
= netdev_priv(netdev
);
584 struct gs_usb
*parent
= dev
->parent
;
586 struct gs_device_mode
*dm
;
589 rc
= open_candev(netdev
);
593 if (atomic_add_return(1, &parent
->active_channels
) == 1) {
594 for (i
= 0; i
< GS_MAX_RX_URBS
; i
++) {
599 urb
= usb_alloc_urb(0, GFP_KERNEL
);
603 /* alloc rx buffer */
604 buf
= usb_alloc_coherent(dev
->udev
,
605 sizeof(struct gs_host_frame
),
610 "No memory left for USB buffer\n");
615 /* fill, anchor, and submit rx urb */
616 usb_fill_bulk_urb(urb
,
618 usb_rcvbulkpipe(dev
->udev
,
621 sizeof(struct gs_host_frame
),
622 gs_usb_receive_bulk_callback
,
624 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
626 usb_anchor_urb(urb
, &parent
->rx_submitted
);
628 rc
= usb_submit_urb(urb
, GFP_KERNEL
);
631 netif_device_detach(dev
->netdev
);
634 "usb_submit failed (err=%d)\n",
637 usb_unanchor_urb(urb
);
642 * USB core will take care of freeing it
648 dm
= kmalloc(sizeof(*dm
), GFP_KERNEL
);
653 ctrlmode
= dev
->can
.ctrlmode
;
656 if (ctrlmode
& CAN_CTRLMODE_LOOPBACK
)
657 dm
->flags
|= GS_CAN_MODE_LOOP_BACK
;
658 else if (ctrlmode
& CAN_CTRLMODE_LISTENONLY
)
659 dm
->flags
|= GS_CAN_MODE_LISTEN_ONLY
;
661 /* Controller is not allowed to retry TX
662 * this mode is unavailable on atmels uc3c hardware
664 if (ctrlmode
& CAN_CTRLMODE_ONE_SHOT
)
665 dm
->flags
|= GS_CAN_MODE_ONE_SHOT
;
667 if (ctrlmode
& CAN_CTRLMODE_3_SAMPLES
)
668 dm
->flags
|= GS_CAN_MODE_TRIPLE_SAMPLE
;
670 /* finally start device */
671 dm
->mode
= GS_CAN_MODE_START
;
672 rc
= usb_control_msg(interface_to_usbdev(dev
->iface
),
673 usb_sndctrlpipe(interface_to_usbdev(dev
->iface
), 0),
675 USB_DIR_OUT
| USB_TYPE_VENDOR
|
684 netdev_err(netdev
, "Couldn't start device (err=%d)\n", rc
);
691 dev
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
693 if (!(dev
->can
.ctrlmode
& CAN_CTRLMODE_LISTENONLY
))
694 netif_start_queue(netdev
);
699 static int gs_can_close(struct net_device
*netdev
)
702 struct gs_can
*dev
= netdev_priv(netdev
);
703 struct gs_usb
*parent
= dev
->parent
;
705 netif_stop_queue(netdev
);
708 if (atomic_dec_and_test(&parent
->active_channels
))
709 usb_kill_anchored_urbs(&parent
->rx_submitted
);
711 /* Stop sending URBs */
712 usb_kill_anchored_urbs(&dev
->tx_submitted
);
713 atomic_set(&dev
->active_tx_urbs
, 0);
715 /* reset the device */
716 rc
= gs_cmd_reset(parent
, dev
);
718 netdev_warn(netdev
, "Couldn't shutdown device (err=%d)", rc
);
720 /* reset tx contexts */
721 for (rc
= 0; rc
< GS_MAX_TX_URBS
; rc
++) {
722 dev
->tx_context
[rc
].dev
= dev
;
723 dev
->tx_context
[rc
].echo_id
= GS_MAX_TX_URBS
;
726 /* close the netdev */
727 close_candev(netdev
);
732 static const struct net_device_ops gs_usb_netdev_ops
= {
733 .ndo_open
= gs_can_open
,
734 .ndo_stop
= gs_can_close
,
735 .ndo_start_xmit
= gs_can_start_xmit
,
736 .ndo_change_mtu
= can_change_mtu
,
739 static int gs_usb_set_identify(struct net_device
*netdev
, bool do_identify
)
741 struct gs_can
*dev
= netdev_priv(netdev
);
742 struct gs_identify_mode
*imode
;
745 imode
= kmalloc(sizeof(*imode
), GFP_KERNEL
);
751 imode
->mode
= GS_CAN_IDENTIFY_ON
;
753 imode
->mode
= GS_CAN_IDENTIFY_OFF
;
755 rc
= usb_control_msg(interface_to_usbdev(dev
->iface
),
756 usb_sndctrlpipe(interface_to_usbdev(dev
->iface
),
758 GS_USB_BREQ_IDENTIFY
,
759 USB_DIR_OUT
| USB_TYPE_VENDOR
|
769 return (rc
> 0) ? 0 : rc
;
772 /* blink LED's for finding the this interface */
773 static int gs_usb_set_phys_id(struct net_device
*dev
,
774 enum ethtool_phys_id_state state
)
779 case ETHTOOL_ID_ACTIVE
:
780 rc
= gs_usb_set_identify(dev
, GS_CAN_IDENTIFY_ON
);
782 case ETHTOOL_ID_INACTIVE
:
783 rc
= gs_usb_set_identify(dev
, GS_CAN_IDENTIFY_OFF
);
792 static const struct ethtool_ops gs_usb_ethtool_ops
= {
793 .set_phys_id
= gs_usb_set_phys_id
,
796 static struct gs_can
*gs_make_candev(unsigned int channel
,
797 struct usb_interface
*intf
,
798 struct gs_device_config
*dconf
)
801 struct net_device
*netdev
;
803 struct gs_device_bt_const
*bt_const
;
805 bt_const
= kmalloc(sizeof(*bt_const
), GFP_KERNEL
);
807 return ERR_PTR(-ENOMEM
);
809 /* fetch bit timing constants */
810 rc
= usb_control_msg(interface_to_usbdev(intf
),
811 usb_rcvctrlpipe(interface_to_usbdev(intf
), 0),
812 GS_USB_BREQ_BT_CONST
,
813 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
822 "Couldn't get bit timing const for channel (err=%d)\n",
829 netdev
= alloc_candev(sizeof(struct gs_can
), GS_MAX_TX_URBS
);
831 dev_err(&intf
->dev
, "Couldn't allocate candev\n");
833 return ERR_PTR(-ENOMEM
);
836 dev
= netdev_priv(netdev
);
838 netdev
->netdev_ops
= &gs_usb_netdev_ops
;
840 netdev
->flags
|= IFF_ECHO
; /* we support full roundtrip echo */
843 strcpy(dev
->bt_const
.name
, "gs_usb");
844 dev
->bt_const
.tseg1_min
= bt_const
->tseg1_min
;
845 dev
->bt_const
.tseg1_max
= bt_const
->tseg1_max
;
846 dev
->bt_const
.tseg2_min
= bt_const
->tseg2_min
;
847 dev
->bt_const
.tseg2_max
= bt_const
->tseg2_max
;
848 dev
->bt_const
.sjw_max
= bt_const
->sjw_max
;
849 dev
->bt_const
.brp_min
= bt_const
->brp_min
;
850 dev
->bt_const
.brp_max
= bt_const
->brp_max
;
851 dev
->bt_const
.brp_inc
= bt_const
->brp_inc
;
853 dev
->udev
= interface_to_usbdev(intf
);
855 dev
->netdev
= netdev
;
856 dev
->channel
= channel
;
858 init_usb_anchor(&dev
->tx_submitted
);
859 atomic_set(&dev
->active_tx_urbs
, 0);
860 spin_lock_init(&dev
->tx_ctx_lock
);
861 for (rc
= 0; rc
< GS_MAX_TX_URBS
; rc
++) {
862 dev
->tx_context
[rc
].dev
= dev
;
863 dev
->tx_context
[rc
].echo_id
= GS_MAX_TX_URBS
;
867 dev
->can
.state
= CAN_STATE_STOPPED
;
868 dev
->can
.clock
.freq
= bt_const
->fclk_can
;
869 dev
->can
.bittiming_const
= &dev
->bt_const
;
870 dev
->can
.do_set_bittiming
= gs_usb_set_bittiming
;
872 dev
->can
.ctrlmode_supported
= 0;
874 if (bt_const
->feature
& GS_CAN_FEATURE_LISTEN_ONLY
)
875 dev
->can
.ctrlmode_supported
|= CAN_CTRLMODE_LISTENONLY
;
877 if (bt_const
->feature
& GS_CAN_FEATURE_LOOP_BACK
)
878 dev
->can
.ctrlmode_supported
|= CAN_CTRLMODE_LOOPBACK
;
880 if (bt_const
->feature
& GS_CAN_FEATURE_TRIPLE_SAMPLE
)
881 dev
->can
.ctrlmode_supported
|= CAN_CTRLMODE_3_SAMPLES
;
883 if (bt_const
->feature
& GS_CAN_FEATURE_ONE_SHOT
)
884 dev
->can
.ctrlmode_supported
|= CAN_CTRLMODE_ONE_SHOT
;
886 SET_NETDEV_DEV(netdev
, &intf
->dev
);
888 if (dconf
->sw_version
> 1)
889 if (bt_const
->feature
& GS_CAN_FEATURE_IDENTIFY
)
890 netdev
->ethtool_ops
= &gs_usb_ethtool_ops
;
894 rc
= register_candev(dev
->netdev
);
896 free_candev(dev
->netdev
);
897 dev_err(&intf
->dev
, "Couldn't register candev (err=%d)\n", rc
);
904 static void gs_destroy_candev(struct gs_can
*dev
)
906 unregister_candev(dev
->netdev
);
907 usb_kill_anchored_urbs(&dev
->tx_submitted
);
908 free_candev(dev
->netdev
);
911 static int gs_usb_probe(struct usb_interface
*intf
,
912 const struct usb_device_id
*id
)
916 unsigned int icount
, i
;
917 struct gs_host_config
*hconf
;
918 struct gs_device_config
*dconf
;
920 hconf
= kmalloc(sizeof(*hconf
), GFP_KERNEL
);
924 hconf
->byte_order
= 0x0000beef;
926 /* send host config */
927 rc
= usb_control_msg(interface_to_usbdev(intf
),
928 usb_sndctrlpipe(interface_to_usbdev(intf
), 0),
929 GS_USB_BREQ_HOST_FORMAT
,
930 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
932 intf
->altsetting
[0].desc
.bInterfaceNumber
,
940 dev_err(&intf
->dev
, "Couldn't send data format (err=%d)\n",
945 dconf
= kmalloc(sizeof(*dconf
), GFP_KERNEL
);
949 /* read device config */
950 rc
= usb_control_msg(interface_to_usbdev(intf
),
951 usb_rcvctrlpipe(interface_to_usbdev(intf
), 0),
952 GS_USB_BREQ_DEVICE_CONFIG
,
953 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_INTERFACE
,
955 intf
->altsetting
[0].desc
.bInterfaceNumber
,
960 dev_err(&intf
->dev
, "Couldn't get device config: (err=%d)\n",
966 icount
= dconf
->icount
+ 1;
967 dev_info(&intf
->dev
, "Configuring for %d interfaces\n", icount
);
969 if (icount
> GS_MAX_INTF
) {
971 "Driver cannot handle more that %d CAN interfaces\n",
977 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
983 init_usb_anchor(&dev
->rx_submitted
);
985 atomic_set(&dev
->active_channels
, 0);
987 usb_set_intfdata(intf
, dev
);
988 dev
->udev
= interface_to_usbdev(intf
);
990 for (i
= 0; i
< icount
; i
++) {
991 dev
->canch
[i
] = gs_make_candev(i
, intf
, dconf
);
992 if (IS_ERR_OR_NULL(dev
->canch
[i
])) {
993 /* save error code to return later */
994 rc
= PTR_ERR(dev
->canch
[i
]);
996 /* on failure destroy previously created candevs */
998 for (i
= 0; i
< icount
; i
++)
999 gs_destroy_candev(dev
->canch
[i
]);
1001 usb_kill_anchored_urbs(&dev
->rx_submitted
);
1006 dev
->canch
[i
]->parent
= dev
;
1014 static void gs_usb_disconnect(struct usb_interface
*intf
)
1017 struct gs_usb
*dev
= usb_get_intfdata(intf
);
1018 usb_set_intfdata(intf
, NULL
);
1021 dev_err(&intf
->dev
, "Disconnect (nodata)\n");
1025 for (i
= 0; i
< GS_MAX_INTF
; i
++)
1027 gs_destroy_candev(dev
->canch
[i
]);
1029 usb_kill_anchored_urbs(&dev
->rx_submitted
);
1033 static const struct usb_device_id gs_usb_table
[] = {
1034 { USB_DEVICE_INTERFACE_NUMBER(USB_GSUSB_1_VENDOR_ID
,
1035 USB_GSUSB_1_PRODUCT_ID
, 0) },
1036 { USB_DEVICE_INTERFACE_NUMBER(USB_CANDLELIGHT_VENDOR_ID
,
1037 USB_CANDLELIGHT_PRODUCT_ID
, 0) },
1038 {} /* Terminating entry */
1041 MODULE_DEVICE_TABLE(usb
, gs_usb_table
);
1043 static struct usb_driver gs_usb_driver
= {
1045 .probe
= gs_usb_probe
,
1046 .disconnect
= gs_usb_disconnect
,
1047 .id_table
= gs_usb_table
,
1050 module_usb_driver(gs_usb_driver
);
1052 MODULE_AUTHOR("Maximilian Schneider <mws@schneidersoft.net>");
1054 "Socket CAN device driver for Geschwister Schneider Technologie-, "
1055 "Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces\n"
1056 "and bytewerk.org candleLight USB CAN interfaces.");
1057 MODULE_LICENSE("GPL v2");