2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License as
4 * published by the Free Software Foundation version 2.
6 * Parts of this driver are based on the following:
7 * - Kvaser linux leaf driver (version 4.78)
8 * - CAN driver for esd CAN-USB/2
10 * Copyright (C) 2002-2006 KVASER AB, Sweden. All rights reserved.
11 * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
12 * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be>
15 #include <linux/completion.h>
16 #include <linux/module.h>
17 #include <linux/netdevice.h>
18 #include <linux/usb.h>
20 #include <linux/can.h>
21 #include <linux/can/dev.h>
22 #include <linux/can/error.h>
24 #define MAX_TX_URBS 16
26 #define START_TIMEOUT 1000 /* msecs */
27 #define STOP_TIMEOUT 1000 /* msecs */
28 #define USB_SEND_TIMEOUT 1000 /* msecs */
29 #define USB_RECV_TIMEOUT 1000 /* msecs */
30 #define RX_BUFFER_SIZE 3072
31 #define CAN_USB_CLOCK 8000000
32 #define MAX_NET_DEVICES 3
34 /* Kvaser USB devices */
35 #define KVASER_VENDOR_ID 0x0bfd
36 #define USB_LEAF_DEVEL_PRODUCT_ID 10
37 #define USB_LEAF_LITE_PRODUCT_ID 11
38 #define USB_LEAF_PRO_PRODUCT_ID 12
39 #define USB_LEAF_SPRO_PRODUCT_ID 14
40 #define USB_LEAF_PRO_LS_PRODUCT_ID 15
41 #define USB_LEAF_PRO_SWC_PRODUCT_ID 16
42 #define USB_LEAF_PRO_LIN_PRODUCT_ID 17
43 #define USB_LEAF_SPRO_LS_PRODUCT_ID 18
44 #define USB_LEAF_SPRO_SWC_PRODUCT_ID 19
45 #define USB_MEMO2_DEVEL_PRODUCT_ID 22
46 #define USB_MEMO2_HSHS_PRODUCT_ID 23
47 #define USB_UPRO_HSHS_PRODUCT_ID 24
48 #define USB_LEAF_LITE_GI_PRODUCT_ID 25
49 #define USB_LEAF_PRO_OBDII_PRODUCT_ID 26
50 #define USB_MEMO2_HSLS_PRODUCT_ID 27
51 #define USB_LEAF_LITE_CH_PRODUCT_ID 28
52 #define USB_BLACKBIRD_SPRO_PRODUCT_ID 29
53 #define USB_OEM_MERCURY_PRODUCT_ID 34
54 #define USB_OEM_LEAF_PRODUCT_ID 35
55 #define USB_CAN_R_PRODUCT_ID 39
57 /* USB devices features */
58 #define KVASER_HAS_SILENT_MODE BIT(0)
59 #define KVASER_HAS_TXRX_ERRORS BIT(1)
61 /* Message header size */
62 #define MSG_HEADER_LEN 2
64 /* Can message flags */
65 #define MSG_FLAG_ERROR_FRAME BIT(0)
66 #define MSG_FLAG_OVERRUN BIT(1)
67 #define MSG_FLAG_NERR BIT(2)
68 #define MSG_FLAG_WAKEUP BIT(3)
69 #define MSG_FLAG_REMOTE_FRAME BIT(4)
70 #define MSG_FLAG_RESERVED BIT(5)
71 #define MSG_FLAG_TX_ACK BIT(6)
72 #define MSG_FLAG_TX_REQUEST BIT(7)
75 #define M16C_STATE_BUS_RESET BIT(0)
76 #define M16C_STATE_BUS_ERROR BIT(4)
77 #define M16C_STATE_BUS_PASSIVE BIT(5)
78 #define M16C_STATE_BUS_OFF BIT(6)
81 #define CMD_RX_STD_MESSAGE 12
82 #define CMD_TX_STD_MESSAGE 13
83 #define CMD_RX_EXT_MESSAGE 14
84 #define CMD_TX_EXT_MESSAGE 15
85 #define CMD_SET_BUS_PARAMS 16
86 #define CMD_GET_BUS_PARAMS 17
87 #define CMD_GET_BUS_PARAMS_REPLY 18
88 #define CMD_GET_CHIP_STATE 19
89 #define CMD_CHIP_STATE_EVENT 20
90 #define CMD_SET_CTRL_MODE 21
91 #define CMD_GET_CTRL_MODE 22
92 #define CMD_GET_CTRL_MODE_REPLY 23
93 #define CMD_RESET_CHIP 24
94 #define CMD_RESET_CARD 25
95 #define CMD_START_CHIP 26
96 #define CMD_START_CHIP_REPLY 27
97 #define CMD_STOP_CHIP 28
98 #define CMD_STOP_CHIP_REPLY 29
99 #define CMD_GET_CARD_INFO2 32
100 #define CMD_GET_CARD_INFO 34
101 #define CMD_GET_CARD_INFO_REPLY 35
102 #define CMD_GET_SOFTWARE_INFO 38
103 #define CMD_GET_SOFTWARE_INFO_REPLY 39
104 #define CMD_ERROR_EVENT 45
105 #define CMD_FLUSH_QUEUE 48
106 #define CMD_RESET_ERROR_COUNTER 49
107 #define CMD_TX_ACKNOWLEDGE 50
108 #define CMD_CAN_ERROR_EVENT 51
109 #define CMD_USB_THROTTLE 77
110 #define CMD_LOG_MESSAGE 106
113 #define M16C_EF_ACKE BIT(0)
114 #define M16C_EF_CRCE BIT(1)
115 #define M16C_EF_FORME BIT(2)
116 #define M16C_EF_STFE BIT(3)
117 #define M16C_EF_BITE0 BIT(4)
118 #define M16C_EF_BITE1 BIT(5)
119 #define M16C_EF_RCVE BIT(6)
120 #define M16C_EF_TRE BIT(7)
122 /* bittiming parameters */
123 #define KVASER_USB_TSEG1_MIN 1
124 #define KVASER_USB_TSEG1_MAX 16
125 #define KVASER_USB_TSEG2_MIN 1
126 #define KVASER_USB_TSEG2_MAX 8
127 #define KVASER_USB_SJW_MAX 4
128 #define KVASER_USB_BRP_MIN 1
129 #define KVASER_USB_BRP_MAX 64
130 #define KVASER_USB_BRP_INC 1
133 #define KVASER_CTRL_MODE_NORMAL 1
134 #define KVASER_CTRL_MODE_SILENT 2
135 #define KVASER_CTRL_MODE_SELFRECEPTION 3
136 #define KVASER_CTRL_MODE_OFF 4
139 #define KVASER_EXTENDED_FRAME BIT(31)
141 struct kvaser_msg_simple
{
146 struct kvaser_msg_cardinfo
{
149 __le32 serial_number
;
151 __le32 clock_resolution
;
159 struct kvaser_msg_cardinfo2
{
163 __le32 oem_unlock_code
;
166 struct kvaser_msg_softinfo
{
171 __le16 max_outstanding_tx
;
175 struct kvaser_msg_busparams
{
185 struct kvaser_msg_tx_can
{
193 struct kvaser_msg_rx_can
{
200 struct kvaser_msg_chip_state_event
{
210 struct kvaser_msg_tx_acknowledge
{
218 struct kvaser_msg_error_event
{
230 struct kvaser_msg_ctrl_mode
{
237 struct kvaser_msg_flush_queue
{
244 struct kvaser_msg_log_message
{
258 struct kvaser_msg_simple simple
;
259 struct kvaser_msg_cardinfo cardinfo
;
260 struct kvaser_msg_cardinfo2 cardinfo2
;
261 struct kvaser_msg_softinfo softinfo
;
262 struct kvaser_msg_busparams busparams
;
263 struct kvaser_msg_tx_can tx_can
;
264 struct kvaser_msg_rx_can rx_can
;
265 struct kvaser_msg_chip_state_event chip_state_event
;
266 struct kvaser_msg_tx_acknowledge tx_acknowledge
;
267 struct kvaser_msg_error_event error_event
;
268 struct kvaser_msg_ctrl_mode ctrl_mode
;
269 struct kvaser_msg_flush_queue flush_queue
;
270 struct kvaser_msg_log_message log_message
;
274 struct kvaser_usb_tx_urb_context
{
275 struct kvaser_usb_net_priv
*priv
;
281 struct usb_device
*udev
;
282 struct kvaser_usb_net_priv
*nets
[MAX_NET_DEVICES
];
284 struct usb_endpoint_descriptor
*bulk_in
, *bulk_out
;
285 struct usb_anchor rx_submitted
;
288 unsigned int nchannels
;
291 void *rxbuf
[MAX_RX_URBS
];
292 dma_addr_t rxbuf_dma
[MAX_RX_URBS
];
295 struct kvaser_usb_net_priv
{
298 atomic_t active_tx_urbs
;
299 struct usb_anchor tx_submitted
;
300 struct kvaser_usb_tx_urb_context tx_contexts
[MAX_TX_URBS
];
302 struct completion start_comp
, stop_comp
;
304 struct kvaser_usb
*dev
;
305 struct net_device
*netdev
;
308 struct can_berr_counter bec
;
311 static const struct usb_device_id kvaser_usb_table
[] = {
312 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_DEVEL_PRODUCT_ID
) },
313 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_LITE_PRODUCT_ID
) },
314 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_PRO_PRODUCT_ID
),
315 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
316 KVASER_HAS_SILENT_MODE
},
317 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_SPRO_PRODUCT_ID
),
318 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
319 KVASER_HAS_SILENT_MODE
},
320 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_PRO_LS_PRODUCT_ID
),
321 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
322 KVASER_HAS_SILENT_MODE
},
323 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_PRO_SWC_PRODUCT_ID
),
324 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
325 KVASER_HAS_SILENT_MODE
},
326 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_PRO_LIN_PRODUCT_ID
),
327 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
328 KVASER_HAS_SILENT_MODE
},
329 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_SPRO_LS_PRODUCT_ID
),
330 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
331 KVASER_HAS_SILENT_MODE
},
332 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_SPRO_SWC_PRODUCT_ID
),
333 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
334 KVASER_HAS_SILENT_MODE
},
335 { USB_DEVICE(KVASER_VENDOR_ID
, USB_MEMO2_DEVEL_PRODUCT_ID
),
336 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
337 KVASER_HAS_SILENT_MODE
},
338 { USB_DEVICE(KVASER_VENDOR_ID
, USB_MEMO2_HSHS_PRODUCT_ID
),
339 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
340 KVASER_HAS_SILENT_MODE
},
341 { USB_DEVICE(KVASER_VENDOR_ID
, USB_UPRO_HSHS_PRODUCT_ID
),
342 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
343 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_LITE_GI_PRODUCT_ID
) },
344 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_PRO_OBDII_PRODUCT_ID
),
345 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
346 KVASER_HAS_SILENT_MODE
},
347 { USB_DEVICE(KVASER_VENDOR_ID
, USB_MEMO2_HSLS_PRODUCT_ID
),
348 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
349 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_LITE_CH_PRODUCT_ID
),
350 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
351 { USB_DEVICE(KVASER_VENDOR_ID
, USB_BLACKBIRD_SPRO_PRODUCT_ID
),
352 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
353 { USB_DEVICE(KVASER_VENDOR_ID
, USB_OEM_MERCURY_PRODUCT_ID
),
354 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
355 { USB_DEVICE(KVASER_VENDOR_ID
, USB_OEM_LEAF_PRODUCT_ID
),
356 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
357 { USB_DEVICE(KVASER_VENDOR_ID
, USB_CAN_R_PRODUCT_ID
),
358 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
361 MODULE_DEVICE_TABLE(usb
, kvaser_usb_table
);
363 static inline int kvaser_usb_send_msg(const struct kvaser_usb
*dev
,
364 struct kvaser_msg
*msg
)
368 return usb_bulk_msg(dev
->udev
,
369 usb_sndbulkpipe(dev
->udev
,
370 dev
->bulk_out
->bEndpointAddress
),
371 msg
, msg
->len
, &actual_len
,
375 static int kvaser_usb_wait_msg(const struct kvaser_usb
*dev
, u8 id
,
376 struct kvaser_msg
*msg
)
378 struct kvaser_msg
*tmp
;
384 buf
= kzalloc(RX_BUFFER_SIZE
, GFP_KERNEL
);
388 err
= usb_bulk_msg(dev
->udev
,
389 usb_rcvbulkpipe(dev
->udev
,
390 dev
->bulk_in
->bEndpointAddress
),
391 buf
, RX_BUFFER_SIZE
, &actual_len
,
396 while (pos
<= actual_len
- MSG_HEADER_LEN
) {
402 if (pos
+ tmp
->len
> actual_len
) {
403 dev_err(dev
->udev
->dev
.parent
, "Format error\n");
408 memcpy(msg
, tmp
, tmp
->len
);
423 static int kvaser_usb_send_simple_msg(const struct kvaser_usb
*dev
,
424 u8 msg_id
, int channel
)
426 struct kvaser_msg
*msg
;
429 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
434 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_simple
);
435 msg
->u
.simple
.channel
= channel
;
436 msg
->u
.simple
.tid
= 0xff;
438 rc
= kvaser_usb_send_msg(dev
, msg
);
444 static int kvaser_usb_get_software_info(struct kvaser_usb
*dev
)
446 struct kvaser_msg msg
;
449 err
= kvaser_usb_send_simple_msg(dev
, CMD_GET_SOFTWARE_INFO
, 0);
453 err
= kvaser_usb_wait_msg(dev
, CMD_GET_SOFTWARE_INFO_REPLY
, &msg
);
457 dev
->fw_version
= le32_to_cpu(msg
.u
.softinfo
.fw_version
);
462 static int kvaser_usb_get_card_info(struct kvaser_usb
*dev
)
464 struct kvaser_msg msg
;
467 err
= kvaser_usb_send_simple_msg(dev
, CMD_GET_CARD_INFO
, 0);
471 err
= kvaser_usb_wait_msg(dev
, CMD_GET_CARD_INFO_REPLY
, &msg
);
475 dev
->nchannels
= msg
.u
.cardinfo
.nchannels
;
476 if (dev
->nchannels
> MAX_NET_DEVICES
)
482 static void kvaser_usb_tx_acknowledge(const struct kvaser_usb
*dev
,
483 const struct kvaser_msg
*msg
)
485 struct net_device_stats
*stats
;
486 struct kvaser_usb_tx_urb_context
*context
;
487 struct kvaser_usb_net_priv
*priv
;
489 struct can_frame
*cf
;
490 u8 channel
= msg
->u
.tx_acknowledge
.channel
;
491 u8 tid
= msg
->u
.tx_acknowledge
.tid
;
493 if (channel
>= dev
->nchannels
) {
494 dev_err(dev
->udev
->dev
.parent
,
495 "Invalid channel number (%d)\n", channel
);
499 priv
= dev
->nets
[channel
];
501 if (!netif_device_present(priv
->netdev
))
504 stats
= &priv
->netdev
->stats
;
506 context
= &priv
->tx_contexts
[tid
% MAX_TX_URBS
];
508 /* Sometimes the state change doesn't come after a bus-off event */
509 if (priv
->can
.restart_ms
&&
510 (priv
->can
.state
>= CAN_STATE_BUS_OFF
)) {
511 skb
= alloc_can_err_skb(priv
->netdev
, &cf
);
513 cf
->can_id
|= CAN_ERR_RESTARTED
;
517 stats
->rx_bytes
+= cf
->can_dlc
;
519 netdev_err(priv
->netdev
,
520 "No memory left for err_skb\n");
523 priv
->can
.can_stats
.restarts
++;
524 netif_carrier_on(priv
->netdev
);
526 priv
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
530 stats
->tx_bytes
+= context
->dlc
;
531 can_get_echo_skb(priv
->netdev
, context
->echo_index
);
533 context
->echo_index
= MAX_TX_URBS
;
534 atomic_dec(&priv
->active_tx_urbs
);
536 netif_wake_queue(priv
->netdev
);
539 static void kvaser_usb_simple_msg_callback(struct urb
*urb
)
541 struct net_device
*netdev
= urb
->context
;
543 kfree(urb
->transfer_buffer
);
546 netdev_warn(netdev
, "urb status received: %d\n",
550 static int kvaser_usb_simple_msg_async(struct kvaser_usb_net_priv
*priv
,
553 struct kvaser_usb
*dev
= priv
->dev
;
554 struct net_device
*netdev
= priv
->netdev
;
555 struct kvaser_msg
*msg
;
560 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
562 netdev_err(netdev
, "No memory left for URBs\n");
566 buf
= kmalloc(sizeof(struct kvaser_msg
), GFP_ATOMIC
);
572 msg
= (struct kvaser_msg
*)buf
;
573 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_simple
);
575 msg
->u
.simple
.channel
= priv
->channel
;
577 usb_fill_bulk_urb(urb
, dev
->udev
,
578 usb_sndbulkpipe(dev
->udev
,
579 dev
->bulk_out
->bEndpointAddress
),
581 kvaser_usb_simple_msg_callback
, priv
);
582 usb_anchor_urb(urb
, &priv
->tx_submitted
);
584 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
586 netdev_err(netdev
, "Error transmitting URB\n");
587 usb_unanchor_urb(urb
);
598 static void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv
*priv
)
602 usb_kill_anchored_urbs(&priv
->tx_submitted
);
603 atomic_set(&priv
->active_tx_urbs
, 0);
605 for (i
= 0; i
< MAX_TX_URBS
; i
++)
606 priv
->tx_contexts
[i
].echo_index
= MAX_TX_URBS
;
609 static void kvaser_usb_rx_error(const struct kvaser_usb
*dev
,
610 const struct kvaser_msg
*msg
)
612 struct can_frame
*cf
;
614 struct net_device_stats
*stats
;
615 struct kvaser_usb_net_priv
*priv
;
616 unsigned int new_state
;
617 u8 channel
, status
, txerr
, rxerr
, error_factor
;
620 case CMD_CAN_ERROR_EVENT
:
621 channel
= msg
->u
.error_event
.channel
;
622 status
= msg
->u
.error_event
.status
;
623 txerr
= msg
->u
.error_event
.tx_errors_count
;
624 rxerr
= msg
->u
.error_event
.rx_errors_count
;
625 error_factor
= msg
->u
.error_event
.error_factor
;
627 case CMD_LOG_MESSAGE
:
628 channel
= msg
->u
.log_message
.channel
;
629 status
= msg
->u
.log_message
.data
[0];
630 txerr
= msg
->u
.log_message
.data
[2];
631 rxerr
= msg
->u
.log_message
.data
[3];
632 error_factor
= msg
->u
.log_message
.data
[1];
634 case CMD_CHIP_STATE_EVENT
:
635 channel
= msg
->u
.chip_state_event
.channel
;
636 status
= msg
->u
.chip_state_event
.status
;
637 txerr
= msg
->u
.chip_state_event
.tx_errors_count
;
638 rxerr
= msg
->u
.chip_state_event
.rx_errors_count
;
642 dev_err(dev
->udev
->dev
.parent
, "Invalid msg id (%d)\n",
647 if (channel
>= dev
->nchannels
) {
648 dev_err(dev
->udev
->dev
.parent
,
649 "Invalid channel number (%d)\n", channel
);
653 priv
= dev
->nets
[channel
];
654 stats
= &priv
->netdev
->stats
;
656 if (status
& M16C_STATE_BUS_RESET
) {
657 kvaser_usb_unlink_tx_urbs(priv
);
661 skb
= alloc_can_err_skb(priv
->netdev
, &cf
);
667 new_state
= priv
->can
.state
;
669 netdev_dbg(priv
->netdev
, "Error status: 0x%02x\n", status
);
671 if (status
& M16C_STATE_BUS_OFF
) {
672 cf
->can_id
|= CAN_ERR_BUSOFF
;
674 priv
->can
.can_stats
.bus_off
++;
675 if (!priv
->can
.restart_ms
)
676 kvaser_usb_simple_msg_async(priv
, CMD_STOP_CHIP
);
678 netif_carrier_off(priv
->netdev
);
680 new_state
= CAN_STATE_BUS_OFF
;
681 } else if (status
& M16C_STATE_BUS_PASSIVE
) {
682 if (priv
->can
.state
!= CAN_STATE_ERROR_PASSIVE
) {
683 cf
->can_id
|= CAN_ERR_CRTL
;
686 cf
->data
[1] = (txerr
> rxerr
)
687 ? CAN_ERR_CRTL_TX_PASSIVE
688 : CAN_ERR_CRTL_RX_PASSIVE
;
690 cf
->data
[1] = CAN_ERR_CRTL_TX_PASSIVE
|
691 CAN_ERR_CRTL_RX_PASSIVE
;
693 priv
->can
.can_stats
.error_passive
++;
696 new_state
= CAN_STATE_ERROR_PASSIVE
;
699 if (status
== M16C_STATE_BUS_ERROR
) {
700 if ((priv
->can
.state
< CAN_STATE_ERROR_WARNING
) &&
701 ((txerr
>= 96) || (rxerr
>= 96))) {
702 cf
->can_id
|= CAN_ERR_CRTL
;
703 cf
->data
[1] = (txerr
> rxerr
)
704 ? CAN_ERR_CRTL_TX_WARNING
705 : CAN_ERR_CRTL_RX_WARNING
;
707 priv
->can
.can_stats
.error_warning
++;
708 new_state
= CAN_STATE_ERROR_WARNING
;
709 } else if (priv
->can
.state
> CAN_STATE_ERROR_ACTIVE
) {
710 cf
->can_id
|= CAN_ERR_PROT
;
711 cf
->data
[2] = CAN_ERR_PROT_ACTIVE
;
713 new_state
= CAN_STATE_ERROR_ACTIVE
;
718 cf
->can_id
|= CAN_ERR_PROT
;
719 cf
->data
[2] = CAN_ERR_PROT_ACTIVE
;
721 new_state
= CAN_STATE_ERROR_ACTIVE
;
724 if (priv
->can
.restart_ms
&&
725 (priv
->can
.state
>= CAN_STATE_BUS_OFF
) &&
726 (new_state
< CAN_STATE_BUS_OFF
)) {
727 cf
->can_id
|= CAN_ERR_RESTARTED
;
728 netif_carrier_on(priv
->netdev
);
730 priv
->can
.can_stats
.restarts
++;
734 priv
->can
.can_stats
.bus_error
++;
737 cf
->can_id
|= CAN_ERR_BUSERROR
| CAN_ERR_PROT
;
739 if (error_factor
& M16C_EF_ACKE
)
740 cf
->data
[3] |= (CAN_ERR_PROT_LOC_ACK
);
741 if (error_factor
& M16C_EF_CRCE
)
742 cf
->data
[3] |= (CAN_ERR_PROT_LOC_CRC_SEQ
|
743 CAN_ERR_PROT_LOC_CRC_DEL
);
744 if (error_factor
& M16C_EF_FORME
)
745 cf
->data
[2] |= CAN_ERR_PROT_FORM
;
746 if (error_factor
& M16C_EF_STFE
)
747 cf
->data
[2] |= CAN_ERR_PROT_STUFF
;
748 if (error_factor
& M16C_EF_BITE0
)
749 cf
->data
[2] |= CAN_ERR_PROT_BIT0
;
750 if (error_factor
& M16C_EF_BITE1
)
751 cf
->data
[2] |= CAN_ERR_PROT_BIT1
;
752 if (error_factor
& M16C_EF_TRE
)
753 cf
->data
[2] |= CAN_ERR_PROT_TX
;
759 priv
->bec
.txerr
= txerr
;
760 priv
->bec
.rxerr
= rxerr
;
762 priv
->can
.state
= new_state
;
767 stats
->rx_bytes
+= cf
->can_dlc
;
770 static void kvaser_usb_rx_can_err(const struct kvaser_usb_net_priv
*priv
,
771 const struct kvaser_msg
*msg
)
773 struct can_frame
*cf
;
775 struct net_device_stats
*stats
= &priv
->netdev
->stats
;
777 if (msg
->u
.rx_can
.flag
& (MSG_FLAG_ERROR_FRAME
|
779 netdev_err(priv
->netdev
, "Unknow error (flags: 0x%02x)\n",
786 if (msg
->u
.rx_can
.flag
& MSG_FLAG_OVERRUN
) {
787 skb
= alloc_can_err_skb(priv
->netdev
, &cf
);
793 cf
->can_id
|= CAN_ERR_CRTL
;
794 cf
->data
[1] = CAN_ERR_CRTL_RX_OVERFLOW
;
796 stats
->rx_over_errors
++;
802 stats
->rx_bytes
+= cf
->can_dlc
;
806 static void kvaser_usb_rx_can_msg(const struct kvaser_usb
*dev
,
807 const struct kvaser_msg
*msg
)
809 struct kvaser_usb_net_priv
*priv
;
810 struct can_frame
*cf
;
812 struct net_device_stats
*stats
;
813 u8 channel
= msg
->u
.rx_can
.channel
;
815 if (channel
>= dev
->nchannels
) {
816 dev_err(dev
->udev
->dev
.parent
,
817 "Invalid channel number (%d)\n", channel
);
821 priv
= dev
->nets
[channel
];
822 stats
= &priv
->netdev
->stats
;
824 if ((msg
->u
.rx_can
.flag
& MSG_FLAG_ERROR_FRAME
) &&
825 (msg
->id
== CMD_LOG_MESSAGE
)) {
826 kvaser_usb_rx_error(dev
, msg
);
828 } else if (msg
->u
.rx_can
.flag
& (MSG_FLAG_ERROR_FRAME
|
831 kvaser_usb_rx_can_err(priv
, msg
);
833 } else if (msg
->u
.rx_can
.flag
& ~MSG_FLAG_REMOTE_FRAME
) {
834 netdev_warn(priv
->netdev
,
835 "Unhandled frame (flags: 0x%02x)",
840 skb
= alloc_can_skb(priv
->netdev
, &cf
);
846 if (msg
->id
== CMD_LOG_MESSAGE
) {
847 cf
->can_id
= le32_to_cpu(msg
->u
.log_message
.id
);
848 if (cf
->can_id
& KVASER_EXTENDED_FRAME
)
849 cf
->can_id
&= CAN_EFF_MASK
| CAN_EFF_FLAG
;
851 cf
->can_id
&= CAN_SFF_MASK
;
853 cf
->can_dlc
= get_can_dlc(msg
->u
.log_message
.dlc
);
855 if (msg
->u
.log_message
.flags
& MSG_FLAG_REMOTE_FRAME
)
856 cf
->can_id
|= CAN_RTR_FLAG
;
858 memcpy(cf
->data
, &msg
->u
.log_message
.data
,
861 cf
->can_id
= ((msg
->u
.rx_can
.msg
[0] & 0x1f) << 6) |
862 (msg
->u
.rx_can
.msg
[1] & 0x3f);
864 if (msg
->id
== CMD_RX_EXT_MESSAGE
) {
866 cf
->can_id
|= ((msg
->u
.rx_can
.msg
[2] & 0x0f) << 14) |
867 ((msg
->u
.rx_can
.msg
[3] & 0xff) << 6) |
868 (msg
->u
.rx_can
.msg
[4] & 0x3f);
869 cf
->can_id
|= CAN_EFF_FLAG
;
872 cf
->can_dlc
= get_can_dlc(msg
->u
.rx_can
.msg
[5]);
874 if (msg
->u
.rx_can
.flag
& MSG_FLAG_REMOTE_FRAME
)
875 cf
->can_id
|= CAN_RTR_FLAG
;
877 memcpy(cf
->data
, &msg
->u
.rx_can
.msg
[6],
884 stats
->rx_bytes
+= cf
->can_dlc
;
887 static void kvaser_usb_start_chip_reply(const struct kvaser_usb
*dev
,
888 const struct kvaser_msg
*msg
)
890 struct kvaser_usb_net_priv
*priv
;
891 u8 channel
= msg
->u
.simple
.channel
;
893 if (channel
>= dev
->nchannels
) {
894 dev_err(dev
->udev
->dev
.parent
,
895 "Invalid channel number (%d)\n", channel
);
899 priv
= dev
->nets
[channel
];
901 if (completion_done(&priv
->start_comp
) &&
902 netif_queue_stopped(priv
->netdev
)) {
903 netif_wake_queue(priv
->netdev
);
905 netif_start_queue(priv
->netdev
);
906 complete(&priv
->start_comp
);
910 static void kvaser_usb_stop_chip_reply(const struct kvaser_usb
*dev
,
911 const struct kvaser_msg
*msg
)
913 struct kvaser_usb_net_priv
*priv
;
914 u8 channel
= msg
->u
.simple
.channel
;
916 if (channel
>= dev
->nchannels
) {
917 dev_err(dev
->udev
->dev
.parent
,
918 "Invalid channel number (%d)\n", channel
);
922 priv
= dev
->nets
[channel
];
924 complete(&priv
->stop_comp
);
927 static void kvaser_usb_handle_message(const struct kvaser_usb
*dev
,
928 const struct kvaser_msg
*msg
)
931 case CMD_START_CHIP_REPLY
:
932 kvaser_usb_start_chip_reply(dev
, msg
);
935 case CMD_STOP_CHIP_REPLY
:
936 kvaser_usb_stop_chip_reply(dev
, msg
);
939 case CMD_RX_STD_MESSAGE
:
940 case CMD_RX_EXT_MESSAGE
:
941 case CMD_LOG_MESSAGE
:
942 kvaser_usb_rx_can_msg(dev
, msg
);
945 case CMD_CHIP_STATE_EVENT
:
946 case CMD_CAN_ERROR_EVENT
:
947 kvaser_usb_rx_error(dev
, msg
);
950 case CMD_TX_ACKNOWLEDGE
:
951 kvaser_usb_tx_acknowledge(dev
, msg
);
955 dev_warn(dev
->udev
->dev
.parent
,
956 "Unhandled message (%d)\n", msg
->id
);
961 static void kvaser_usb_read_bulk_callback(struct urb
*urb
)
963 struct kvaser_usb
*dev
= urb
->context
;
964 struct kvaser_msg
*msg
;
968 switch (urb
->status
) {
975 dev_info(dev
->udev
->dev
.parent
, "Rx URB aborted (%d)\n",
980 while (pos
<= urb
->actual_length
- MSG_HEADER_LEN
) {
981 msg
= urb
->transfer_buffer
+ pos
;
986 if (pos
+ msg
->len
> urb
->actual_length
) {
987 dev_err(dev
->udev
->dev
.parent
, "Format error\n");
991 kvaser_usb_handle_message(dev
, msg
);
997 usb_fill_bulk_urb(urb
, dev
->udev
,
998 usb_rcvbulkpipe(dev
->udev
,
999 dev
->bulk_in
->bEndpointAddress
),
1000 urb
->transfer_buffer
, RX_BUFFER_SIZE
,
1001 kvaser_usb_read_bulk_callback
, dev
);
1003 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
1004 if (err
== -ENODEV
) {
1005 for (i
= 0; i
< dev
->nchannels
; i
++) {
1009 netif_device_detach(dev
->nets
[i
]->netdev
);
1012 dev_err(dev
->udev
->dev
.parent
,
1013 "Failed resubmitting read bulk urb: %d\n", err
);
1019 static int kvaser_usb_setup_rx_urbs(struct kvaser_usb
*dev
)
1023 if (dev
->rxinitdone
)
1026 for (i
= 0; i
< MAX_RX_URBS
; i
++) {
1027 struct urb
*urb
= NULL
;
1031 urb
= usb_alloc_urb(0, GFP_KERNEL
);
1033 dev_warn(dev
->udev
->dev
.parent
,
1034 "No memory left for URBs\n");
1039 buf
= usb_alloc_coherent(dev
->udev
, RX_BUFFER_SIZE
,
1040 GFP_KERNEL
, &buf_dma
);
1042 dev_warn(dev
->udev
->dev
.parent
,
1043 "No memory left for USB buffer\n");
1049 usb_fill_bulk_urb(urb
, dev
->udev
,
1050 usb_rcvbulkpipe(dev
->udev
,
1051 dev
->bulk_in
->bEndpointAddress
),
1052 buf
, RX_BUFFER_SIZE
,
1053 kvaser_usb_read_bulk_callback
,
1055 urb
->transfer_dma
= buf_dma
;
1056 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1057 usb_anchor_urb(urb
, &dev
->rx_submitted
);
1059 err
= usb_submit_urb(urb
, GFP_KERNEL
);
1061 usb_unanchor_urb(urb
);
1062 usb_free_coherent(dev
->udev
, RX_BUFFER_SIZE
, buf
,
1068 dev
->rxbuf
[i
] = buf
;
1069 dev
->rxbuf_dma
[i
] = buf_dma
;
1075 dev_warn(dev
->udev
->dev
.parent
,
1076 "Cannot setup read URBs, error %d\n", err
);
1078 } else if (i
< MAX_RX_URBS
) {
1079 dev_warn(dev
->udev
->dev
.parent
,
1080 "RX performances may be slow\n");
1083 dev
->rxinitdone
= true;
1088 static int kvaser_usb_set_opt_mode(const struct kvaser_usb_net_priv
*priv
)
1090 struct kvaser_msg
*msg
;
1093 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
1097 msg
->id
= CMD_SET_CTRL_MODE
;
1098 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_ctrl_mode
);
1099 msg
->u
.ctrl_mode
.tid
= 0xff;
1100 msg
->u
.ctrl_mode
.channel
= priv
->channel
;
1102 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_LISTENONLY
)
1103 msg
->u
.ctrl_mode
.ctrl_mode
= KVASER_CTRL_MODE_SILENT
;
1105 msg
->u
.ctrl_mode
.ctrl_mode
= KVASER_CTRL_MODE_NORMAL
;
1107 rc
= kvaser_usb_send_msg(priv
->dev
, msg
);
1113 static int kvaser_usb_start_chip(struct kvaser_usb_net_priv
*priv
)
1117 init_completion(&priv
->start_comp
);
1119 err
= kvaser_usb_send_simple_msg(priv
->dev
, CMD_START_CHIP
,
1124 if (!wait_for_completion_timeout(&priv
->start_comp
,
1125 msecs_to_jiffies(START_TIMEOUT
)))
1131 static int kvaser_usb_open(struct net_device
*netdev
)
1133 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1134 struct kvaser_usb
*dev
= priv
->dev
;
1137 err
= open_candev(netdev
);
1141 err
= kvaser_usb_setup_rx_urbs(dev
);
1145 err
= kvaser_usb_set_opt_mode(priv
);
1149 err
= kvaser_usb_start_chip(priv
);
1151 netdev_warn(netdev
, "Cannot start device, error %d\n", err
);
1155 priv
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
1160 close_candev(netdev
);
1164 static void kvaser_usb_unlink_all_urbs(struct kvaser_usb
*dev
)
1168 usb_kill_anchored_urbs(&dev
->rx_submitted
);
1170 for (i
= 0; i
< MAX_RX_URBS
; i
++)
1171 usb_free_coherent(dev
->udev
, RX_BUFFER_SIZE
,
1175 for (i
= 0; i
< MAX_NET_DEVICES
; i
++) {
1176 struct kvaser_usb_net_priv
*priv
= dev
->nets
[i
];
1179 kvaser_usb_unlink_tx_urbs(priv
);
1183 static int kvaser_usb_stop_chip(struct kvaser_usb_net_priv
*priv
)
1187 init_completion(&priv
->stop_comp
);
1189 err
= kvaser_usb_send_simple_msg(priv
->dev
, CMD_STOP_CHIP
,
1194 if (!wait_for_completion_timeout(&priv
->stop_comp
,
1195 msecs_to_jiffies(STOP_TIMEOUT
)))
1201 static int kvaser_usb_flush_queue(struct kvaser_usb_net_priv
*priv
)
1203 struct kvaser_msg
*msg
;
1206 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
1210 msg
->id
= CMD_FLUSH_QUEUE
;
1211 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_flush_queue
);
1212 msg
->u
.flush_queue
.channel
= priv
->channel
;
1213 msg
->u
.flush_queue
.flags
= 0x00;
1215 rc
= kvaser_usb_send_msg(priv
->dev
, msg
);
1221 static int kvaser_usb_close(struct net_device
*netdev
)
1223 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1224 struct kvaser_usb
*dev
= priv
->dev
;
1227 netif_stop_queue(netdev
);
1229 err
= kvaser_usb_flush_queue(priv
);
1231 netdev_warn(netdev
, "Cannot flush queue, error %d\n", err
);
1233 if (kvaser_usb_send_simple_msg(dev
, CMD_RESET_CHIP
, priv
->channel
))
1234 netdev_warn(netdev
, "Cannot reset card, error %d\n", err
);
1236 err
= kvaser_usb_stop_chip(priv
);
1238 netdev_warn(netdev
, "Cannot stop device, error %d\n", err
);
1240 priv
->can
.state
= CAN_STATE_STOPPED
;
1241 close_candev(priv
->netdev
);
1246 static void kvaser_usb_write_bulk_callback(struct urb
*urb
)
1248 struct kvaser_usb_tx_urb_context
*context
= urb
->context
;
1249 struct kvaser_usb_net_priv
*priv
;
1250 struct net_device
*netdev
;
1252 if (WARN_ON(!context
))
1255 priv
= context
->priv
;
1256 netdev
= priv
->netdev
;
1258 kfree(urb
->transfer_buffer
);
1260 if (!netif_device_present(netdev
))
1264 netdev_info(netdev
, "Tx URB aborted (%d)\n", urb
->status
);
1267 static netdev_tx_t
kvaser_usb_start_xmit(struct sk_buff
*skb
,
1268 struct net_device
*netdev
)
1270 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1271 struct kvaser_usb
*dev
= priv
->dev
;
1272 struct net_device_stats
*stats
= &netdev
->stats
;
1273 struct can_frame
*cf
= (struct can_frame
*)skb
->data
;
1274 struct kvaser_usb_tx_urb_context
*context
= NULL
;
1277 struct kvaser_msg
*msg
;
1279 int ret
= NETDEV_TX_OK
;
1281 if (can_dropped_invalid_skb(netdev
, skb
))
1282 return NETDEV_TX_OK
;
1284 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
1286 netdev_err(netdev
, "No memory left for URBs\n");
1287 stats
->tx_dropped
++;
1291 buf
= kmalloc(sizeof(struct kvaser_msg
), GFP_ATOMIC
);
1293 stats
->tx_dropped
++;
1298 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_tx_can
);
1299 msg
->u
.tx_can
.flags
= 0;
1300 msg
->u
.tx_can
.channel
= priv
->channel
;
1302 if (cf
->can_id
& CAN_EFF_FLAG
) {
1303 msg
->id
= CMD_TX_EXT_MESSAGE
;
1304 msg
->u
.tx_can
.msg
[0] = (cf
->can_id
>> 24) & 0x1f;
1305 msg
->u
.tx_can
.msg
[1] = (cf
->can_id
>> 18) & 0x3f;
1306 msg
->u
.tx_can
.msg
[2] = (cf
->can_id
>> 14) & 0x0f;
1307 msg
->u
.tx_can
.msg
[3] = (cf
->can_id
>> 6) & 0xff;
1308 msg
->u
.tx_can
.msg
[4] = cf
->can_id
& 0x3f;
1310 msg
->id
= CMD_TX_STD_MESSAGE
;
1311 msg
->u
.tx_can
.msg
[0] = (cf
->can_id
>> 6) & 0x1f;
1312 msg
->u
.tx_can
.msg
[1] = cf
->can_id
& 0x3f;
1315 msg
->u
.tx_can
.msg
[5] = cf
->can_dlc
;
1316 memcpy(&msg
->u
.tx_can
.msg
[6], cf
->data
, cf
->can_dlc
);
1318 if (cf
->can_id
& CAN_RTR_FLAG
)
1319 msg
->u
.tx_can
.flags
|= MSG_FLAG_REMOTE_FRAME
;
1321 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_contexts
); i
++) {
1322 if (priv
->tx_contexts
[i
].echo_index
== MAX_TX_URBS
) {
1323 context
= &priv
->tx_contexts
[i
];
1329 netdev_warn(netdev
, "cannot find free context\n");
1330 ret
= NETDEV_TX_BUSY
;
1334 context
->priv
= priv
;
1335 context
->echo_index
= i
;
1336 context
->dlc
= cf
->can_dlc
;
1338 msg
->u
.tx_can
.tid
= context
->echo_index
;
1340 usb_fill_bulk_urb(urb
, dev
->udev
,
1341 usb_sndbulkpipe(dev
->udev
,
1342 dev
->bulk_out
->bEndpointAddress
),
1344 kvaser_usb_write_bulk_callback
, context
);
1345 usb_anchor_urb(urb
, &priv
->tx_submitted
);
1347 can_put_echo_skb(skb
, netdev
, context
->echo_index
);
1349 atomic_inc(&priv
->active_tx_urbs
);
1351 if (atomic_read(&priv
->active_tx_urbs
) >= MAX_TX_URBS
)
1352 netif_stop_queue(netdev
);
1354 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
1355 if (unlikely(err
)) {
1356 can_free_echo_skb(netdev
, context
->echo_index
);
1358 skb
= NULL
; /* set to NULL to avoid double free in
1359 * dev_kfree_skb(skb) */
1361 atomic_dec(&priv
->active_tx_urbs
);
1362 usb_unanchor_urb(urb
);
1364 stats
->tx_dropped
++;
1367 netif_device_detach(netdev
);
1369 netdev_warn(netdev
, "Failed tx_urb %d\n", err
);
1376 return NETDEV_TX_OK
;
1387 static const struct net_device_ops kvaser_usb_netdev_ops
= {
1388 .ndo_open
= kvaser_usb_open
,
1389 .ndo_stop
= kvaser_usb_close
,
1390 .ndo_start_xmit
= kvaser_usb_start_xmit
,
1393 static const struct can_bittiming_const kvaser_usb_bittiming_const
= {
1394 .name
= "kvaser_usb",
1395 .tseg1_min
= KVASER_USB_TSEG1_MIN
,
1396 .tseg1_max
= KVASER_USB_TSEG1_MAX
,
1397 .tseg2_min
= KVASER_USB_TSEG2_MIN
,
1398 .tseg2_max
= KVASER_USB_TSEG2_MAX
,
1399 .sjw_max
= KVASER_USB_SJW_MAX
,
1400 .brp_min
= KVASER_USB_BRP_MIN
,
1401 .brp_max
= KVASER_USB_BRP_MAX
,
1402 .brp_inc
= KVASER_USB_BRP_INC
,
1405 static int kvaser_usb_set_bittiming(struct net_device
*netdev
)
1407 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1408 struct can_bittiming
*bt
= &priv
->can
.bittiming
;
1409 struct kvaser_usb
*dev
= priv
->dev
;
1410 struct kvaser_msg
*msg
;
1413 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
1417 msg
->id
= CMD_SET_BUS_PARAMS
;
1418 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_busparams
);
1419 msg
->u
.busparams
.channel
= priv
->channel
;
1420 msg
->u
.busparams
.tid
= 0xff;
1421 msg
->u
.busparams
.bitrate
= cpu_to_le32(bt
->bitrate
);
1422 msg
->u
.busparams
.sjw
= bt
->sjw
;
1423 msg
->u
.busparams
.tseg1
= bt
->prop_seg
+ bt
->phase_seg1
;
1424 msg
->u
.busparams
.tseg2
= bt
->phase_seg2
;
1426 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_3_SAMPLES
)
1427 msg
->u
.busparams
.no_samp
= 3;
1429 msg
->u
.busparams
.no_samp
= 1;
1431 rc
= kvaser_usb_send_msg(dev
, msg
);
1437 static int kvaser_usb_set_mode(struct net_device
*netdev
,
1440 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1444 case CAN_MODE_START
:
1445 err
= kvaser_usb_simple_msg_async(priv
, CMD_START_CHIP
);
1456 static int kvaser_usb_get_berr_counter(const struct net_device
*netdev
,
1457 struct can_berr_counter
*bec
)
1459 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1466 static void kvaser_usb_remove_interfaces(struct kvaser_usb
*dev
)
1470 for (i
= 0; i
< dev
->nchannels
; i
++) {
1474 unregister_netdev(dev
->nets
[i
]->netdev
);
1477 kvaser_usb_unlink_all_urbs(dev
);
1479 for (i
= 0; i
< dev
->nchannels
; i
++) {
1483 free_candev(dev
->nets
[i
]->netdev
);
1487 static int kvaser_usb_init_one(struct usb_interface
*intf
,
1488 const struct usb_device_id
*id
, int channel
)
1490 struct kvaser_usb
*dev
= usb_get_intfdata(intf
);
1491 struct net_device
*netdev
;
1492 struct kvaser_usb_net_priv
*priv
;
1495 netdev
= alloc_candev(sizeof(*priv
), MAX_TX_URBS
);
1497 dev_err(&intf
->dev
, "Cannot alloc candev\n");
1501 priv
= netdev_priv(netdev
);
1503 init_completion(&priv
->start_comp
);
1504 init_completion(&priv
->stop_comp
);
1506 init_usb_anchor(&priv
->tx_submitted
);
1507 atomic_set(&priv
->active_tx_urbs
, 0);
1509 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_contexts
); i
++)
1510 priv
->tx_contexts
[i
].echo_index
= MAX_TX_URBS
;
1513 priv
->netdev
= netdev
;
1514 priv
->channel
= channel
;
1516 priv
->can
.state
= CAN_STATE_STOPPED
;
1517 priv
->can
.clock
.freq
= CAN_USB_CLOCK
;
1518 priv
->can
.bittiming_const
= &kvaser_usb_bittiming_const
;
1519 priv
->can
.do_set_bittiming
= kvaser_usb_set_bittiming
;
1520 priv
->can
.do_set_mode
= kvaser_usb_set_mode
;
1521 if (id
->driver_info
& KVASER_HAS_TXRX_ERRORS
)
1522 priv
->can
.do_get_berr_counter
= kvaser_usb_get_berr_counter
;
1523 priv
->can
.ctrlmode_supported
= CAN_CTRLMODE_3_SAMPLES
;
1524 if (id
->driver_info
& KVASER_HAS_SILENT_MODE
)
1525 priv
->can
.ctrlmode_supported
|= CAN_CTRLMODE_LISTENONLY
;
1527 netdev
->flags
|= IFF_ECHO
;
1529 netdev
->netdev_ops
= &kvaser_usb_netdev_ops
;
1531 SET_NETDEV_DEV(netdev
, &intf
->dev
);
1533 dev
->nets
[channel
] = priv
;
1535 err
= register_candev(netdev
);
1537 dev_err(&intf
->dev
, "Failed to register can device\n");
1538 free_candev(netdev
);
1539 dev
->nets
[channel
] = NULL
;
1543 netdev_dbg(netdev
, "device registered\n");
1548 static int kvaser_usb_get_endpoints(const struct usb_interface
*intf
,
1549 struct usb_endpoint_descriptor
**in
,
1550 struct usb_endpoint_descriptor
**out
)
1552 const struct usb_host_interface
*iface_desc
;
1553 struct usb_endpoint_descriptor
*endpoint
;
1556 iface_desc
= &intf
->altsetting
[0];
1558 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
1559 endpoint
= &iface_desc
->endpoint
[i
].desc
;
1561 if (!*in
&& usb_endpoint_is_bulk_in(endpoint
))
1564 if (!*out
&& usb_endpoint_is_bulk_out(endpoint
))
1567 /* use first bulk endpoint for in and out */
1575 static int kvaser_usb_probe(struct usb_interface
*intf
,
1576 const struct usb_device_id
*id
)
1578 struct kvaser_usb
*dev
;
1582 dev
= devm_kzalloc(&intf
->dev
, sizeof(*dev
), GFP_KERNEL
);
1586 err
= kvaser_usb_get_endpoints(intf
, &dev
->bulk_in
, &dev
->bulk_out
);
1588 dev_err(&intf
->dev
, "Cannot get usb endpoint(s)");
1592 dev
->udev
= interface_to_usbdev(intf
);
1594 init_usb_anchor(&dev
->rx_submitted
);
1596 usb_set_intfdata(intf
, dev
);
1598 for (i
= 0; i
< MAX_NET_DEVICES
; i
++)
1599 kvaser_usb_send_simple_msg(dev
, CMD_RESET_CHIP
, i
);
1601 err
= kvaser_usb_get_software_info(dev
);
1604 "Cannot get software infos, error %d\n", err
);
1608 err
= kvaser_usb_get_card_info(dev
);
1611 "Cannot get card infos, error %d\n", err
);
1615 dev_dbg(&intf
->dev
, "Firmware version: %d.%d.%d\n",
1616 ((dev
->fw_version
>> 24) & 0xff),
1617 ((dev
->fw_version
>> 16) & 0xff),
1618 (dev
->fw_version
& 0xffff));
1620 for (i
= 0; i
< dev
->nchannels
; i
++) {
1621 err
= kvaser_usb_init_one(intf
, id
, i
);
1623 kvaser_usb_remove_interfaces(dev
);
1631 static void kvaser_usb_disconnect(struct usb_interface
*intf
)
1633 struct kvaser_usb
*dev
= usb_get_intfdata(intf
);
1635 usb_set_intfdata(intf
, NULL
);
1640 kvaser_usb_remove_interfaces(dev
);
1643 static struct usb_driver kvaser_usb_driver
= {
1644 .name
= "kvaser_usb",
1645 .probe
= kvaser_usb_probe
,
1646 .disconnect
= kvaser_usb_disconnect
,
1647 .id_table
= kvaser_usb_table
,
1650 module_usb_driver(kvaser_usb_driver
);
1652 MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
1653 MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices");
1654 MODULE_LICENSE("GPL v2");