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
;
383 unsigned long to
= jiffies
+ msecs_to_jiffies(USB_RECV_TIMEOUT
);
385 buf
= kzalloc(RX_BUFFER_SIZE
, GFP_KERNEL
);
390 err
= usb_bulk_msg(dev
->udev
,
391 usb_rcvbulkpipe(dev
->udev
,
392 dev
->bulk_in
->bEndpointAddress
),
393 buf
, RX_BUFFER_SIZE
, &actual_len
,
399 while (pos
<= actual_len
- MSG_HEADER_LEN
) {
405 if (pos
+ tmp
->len
> actual_len
) {
406 dev_err(dev
->udev
->dev
.parent
,
412 memcpy(msg
, tmp
, tmp
->len
);
418 } while (time_before(jiffies
, to
));
428 static int kvaser_usb_send_simple_msg(const struct kvaser_usb
*dev
,
429 u8 msg_id
, int channel
)
431 struct kvaser_msg
*msg
;
434 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
439 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_simple
);
440 msg
->u
.simple
.channel
= channel
;
441 msg
->u
.simple
.tid
= 0xff;
443 rc
= kvaser_usb_send_msg(dev
, msg
);
449 static int kvaser_usb_get_software_info(struct kvaser_usb
*dev
)
451 struct kvaser_msg msg
;
454 err
= kvaser_usb_send_simple_msg(dev
, CMD_GET_SOFTWARE_INFO
, 0);
458 err
= kvaser_usb_wait_msg(dev
, CMD_GET_SOFTWARE_INFO_REPLY
, &msg
);
462 dev
->fw_version
= le32_to_cpu(msg
.u
.softinfo
.fw_version
);
467 static int kvaser_usb_get_card_info(struct kvaser_usb
*dev
)
469 struct kvaser_msg msg
;
472 err
= kvaser_usb_send_simple_msg(dev
, CMD_GET_CARD_INFO
, 0);
476 err
= kvaser_usb_wait_msg(dev
, CMD_GET_CARD_INFO_REPLY
, &msg
);
480 dev
->nchannels
= msg
.u
.cardinfo
.nchannels
;
481 if (dev
->nchannels
> MAX_NET_DEVICES
)
487 static void kvaser_usb_tx_acknowledge(const struct kvaser_usb
*dev
,
488 const struct kvaser_msg
*msg
)
490 struct net_device_stats
*stats
;
491 struct kvaser_usb_tx_urb_context
*context
;
492 struct kvaser_usb_net_priv
*priv
;
494 struct can_frame
*cf
;
495 u8 channel
= msg
->u
.tx_acknowledge
.channel
;
496 u8 tid
= msg
->u
.tx_acknowledge
.tid
;
498 if (channel
>= dev
->nchannels
) {
499 dev_err(dev
->udev
->dev
.parent
,
500 "Invalid channel number (%d)\n", channel
);
504 priv
= dev
->nets
[channel
];
506 if (!netif_device_present(priv
->netdev
))
509 stats
= &priv
->netdev
->stats
;
511 context
= &priv
->tx_contexts
[tid
% MAX_TX_URBS
];
513 /* Sometimes the state change doesn't come after a bus-off event */
514 if (priv
->can
.restart_ms
&&
515 (priv
->can
.state
>= CAN_STATE_BUS_OFF
)) {
516 skb
= alloc_can_err_skb(priv
->netdev
, &cf
);
518 cf
->can_id
|= CAN_ERR_RESTARTED
;
522 stats
->rx_bytes
+= cf
->can_dlc
;
524 netdev_err(priv
->netdev
,
525 "No memory left for err_skb\n");
528 priv
->can
.can_stats
.restarts
++;
529 netif_carrier_on(priv
->netdev
);
531 priv
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
535 stats
->tx_bytes
+= context
->dlc
;
536 can_get_echo_skb(priv
->netdev
, context
->echo_index
);
538 context
->echo_index
= MAX_TX_URBS
;
539 atomic_dec(&priv
->active_tx_urbs
);
541 netif_wake_queue(priv
->netdev
);
544 static void kvaser_usb_simple_msg_callback(struct urb
*urb
)
546 struct net_device
*netdev
= urb
->context
;
548 kfree(urb
->transfer_buffer
);
551 netdev_warn(netdev
, "urb status received: %d\n",
555 static int kvaser_usb_simple_msg_async(struct kvaser_usb_net_priv
*priv
,
558 struct kvaser_usb
*dev
= priv
->dev
;
559 struct net_device
*netdev
= priv
->netdev
;
560 struct kvaser_msg
*msg
;
565 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
567 netdev_err(netdev
, "No memory left for URBs\n");
571 buf
= kmalloc(sizeof(struct kvaser_msg
), GFP_ATOMIC
);
577 msg
= (struct kvaser_msg
*)buf
;
578 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_simple
);
580 msg
->u
.simple
.channel
= priv
->channel
;
582 usb_fill_bulk_urb(urb
, dev
->udev
,
583 usb_sndbulkpipe(dev
->udev
,
584 dev
->bulk_out
->bEndpointAddress
),
586 kvaser_usb_simple_msg_callback
, priv
);
587 usb_anchor_urb(urb
, &priv
->tx_submitted
);
589 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
591 netdev_err(netdev
, "Error transmitting URB\n");
592 usb_unanchor_urb(urb
);
603 static void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv
*priv
)
607 usb_kill_anchored_urbs(&priv
->tx_submitted
);
608 atomic_set(&priv
->active_tx_urbs
, 0);
610 for (i
= 0; i
< MAX_TX_URBS
; i
++)
611 priv
->tx_contexts
[i
].echo_index
= MAX_TX_URBS
;
614 static void kvaser_usb_rx_error(const struct kvaser_usb
*dev
,
615 const struct kvaser_msg
*msg
)
617 struct can_frame
*cf
;
619 struct net_device_stats
*stats
;
620 struct kvaser_usb_net_priv
*priv
;
621 unsigned int new_state
;
622 u8 channel
, status
, txerr
, rxerr
, error_factor
;
625 case CMD_CAN_ERROR_EVENT
:
626 channel
= msg
->u
.error_event
.channel
;
627 status
= msg
->u
.error_event
.status
;
628 txerr
= msg
->u
.error_event
.tx_errors_count
;
629 rxerr
= msg
->u
.error_event
.rx_errors_count
;
630 error_factor
= msg
->u
.error_event
.error_factor
;
632 case CMD_LOG_MESSAGE
:
633 channel
= msg
->u
.log_message
.channel
;
634 status
= msg
->u
.log_message
.data
[0];
635 txerr
= msg
->u
.log_message
.data
[2];
636 rxerr
= msg
->u
.log_message
.data
[3];
637 error_factor
= msg
->u
.log_message
.data
[1];
639 case CMD_CHIP_STATE_EVENT
:
640 channel
= msg
->u
.chip_state_event
.channel
;
641 status
= msg
->u
.chip_state_event
.status
;
642 txerr
= msg
->u
.chip_state_event
.tx_errors_count
;
643 rxerr
= msg
->u
.chip_state_event
.rx_errors_count
;
647 dev_err(dev
->udev
->dev
.parent
, "Invalid msg id (%d)\n",
652 if (channel
>= dev
->nchannels
) {
653 dev_err(dev
->udev
->dev
.parent
,
654 "Invalid channel number (%d)\n", channel
);
658 priv
= dev
->nets
[channel
];
659 stats
= &priv
->netdev
->stats
;
661 if (status
& M16C_STATE_BUS_RESET
) {
662 kvaser_usb_unlink_tx_urbs(priv
);
666 skb
= alloc_can_err_skb(priv
->netdev
, &cf
);
672 new_state
= priv
->can
.state
;
674 netdev_dbg(priv
->netdev
, "Error status: 0x%02x\n", status
);
676 if (status
& M16C_STATE_BUS_OFF
) {
677 cf
->can_id
|= CAN_ERR_BUSOFF
;
679 priv
->can
.can_stats
.bus_off
++;
680 if (!priv
->can
.restart_ms
)
681 kvaser_usb_simple_msg_async(priv
, CMD_STOP_CHIP
);
683 netif_carrier_off(priv
->netdev
);
685 new_state
= CAN_STATE_BUS_OFF
;
686 } else if (status
& M16C_STATE_BUS_PASSIVE
) {
687 if (priv
->can
.state
!= CAN_STATE_ERROR_PASSIVE
) {
688 cf
->can_id
|= CAN_ERR_CRTL
;
691 cf
->data
[1] = (txerr
> rxerr
)
692 ? CAN_ERR_CRTL_TX_PASSIVE
693 : CAN_ERR_CRTL_RX_PASSIVE
;
695 cf
->data
[1] = CAN_ERR_CRTL_TX_PASSIVE
|
696 CAN_ERR_CRTL_RX_PASSIVE
;
698 priv
->can
.can_stats
.error_passive
++;
701 new_state
= CAN_STATE_ERROR_PASSIVE
;
704 if (status
== M16C_STATE_BUS_ERROR
) {
705 if ((priv
->can
.state
< CAN_STATE_ERROR_WARNING
) &&
706 ((txerr
>= 96) || (rxerr
>= 96))) {
707 cf
->can_id
|= CAN_ERR_CRTL
;
708 cf
->data
[1] = (txerr
> rxerr
)
709 ? CAN_ERR_CRTL_TX_WARNING
710 : CAN_ERR_CRTL_RX_WARNING
;
712 priv
->can
.can_stats
.error_warning
++;
713 new_state
= CAN_STATE_ERROR_WARNING
;
714 } else if (priv
->can
.state
> CAN_STATE_ERROR_ACTIVE
) {
715 cf
->can_id
|= CAN_ERR_PROT
;
716 cf
->data
[2] = CAN_ERR_PROT_ACTIVE
;
718 new_state
= CAN_STATE_ERROR_ACTIVE
;
723 cf
->can_id
|= CAN_ERR_PROT
;
724 cf
->data
[2] = CAN_ERR_PROT_ACTIVE
;
726 new_state
= CAN_STATE_ERROR_ACTIVE
;
729 if (priv
->can
.restart_ms
&&
730 (priv
->can
.state
>= CAN_STATE_BUS_OFF
) &&
731 (new_state
< CAN_STATE_BUS_OFF
)) {
732 cf
->can_id
|= CAN_ERR_RESTARTED
;
733 netif_carrier_on(priv
->netdev
);
735 priv
->can
.can_stats
.restarts
++;
739 priv
->can
.can_stats
.bus_error
++;
742 cf
->can_id
|= CAN_ERR_BUSERROR
| CAN_ERR_PROT
;
744 if (error_factor
& M16C_EF_ACKE
)
745 cf
->data
[3] |= (CAN_ERR_PROT_LOC_ACK
);
746 if (error_factor
& M16C_EF_CRCE
)
747 cf
->data
[3] |= (CAN_ERR_PROT_LOC_CRC_SEQ
|
748 CAN_ERR_PROT_LOC_CRC_DEL
);
749 if (error_factor
& M16C_EF_FORME
)
750 cf
->data
[2] |= CAN_ERR_PROT_FORM
;
751 if (error_factor
& M16C_EF_STFE
)
752 cf
->data
[2] |= CAN_ERR_PROT_STUFF
;
753 if (error_factor
& M16C_EF_BITE0
)
754 cf
->data
[2] |= CAN_ERR_PROT_BIT0
;
755 if (error_factor
& M16C_EF_BITE1
)
756 cf
->data
[2] |= CAN_ERR_PROT_BIT1
;
757 if (error_factor
& M16C_EF_TRE
)
758 cf
->data
[2] |= CAN_ERR_PROT_TX
;
764 priv
->bec
.txerr
= txerr
;
765 priv
->bec
.rxerr
= rxerr
;
767 priv
->can
.state
= new_state
;
772 stats
->rx_bytes
+= cf
->can_dlc
;
775 static void kvaser_usb_rx_can_err(const struct kvaser_usb_net_priv
*priv
,
776 const struct kvaser_msg
*msg
)
778 struct can_frame
*cf
;
780 struct net_device_stats
*stats
= &priv
->netdev
->stats
;
782 if (msg
->u
.rx_can
.flag
& (MSG_FLAG_ERROR_FRAME
|
784 netdev_err(priv
->netdev
, "Unknow error (flags: 0x%02x)\n",
791 if (msg
->u
.rx_can
.flag
& MSG_FLAG_OVERRUN
) {
792 skb
= alloc_can_err_skb(priv
->netdev
, &cf
);
798 cf
->can_id
|= CAN_ERR_CRTL
;
799 cf
->data
[1] = CAN_ERR_CRTL_RX_OVERFLOW
;
801 stats
->rx_over_errors
++;
807 stats
->rx_bytes
+= cf
->can_dlc
;
811 static void kvaser_usb_rx_can_msg(const struct kvaser_usb
*dev
,
812 const struct kvaser_msg
*msg
)
814 struct kvaser_usb_net_priv
*priv
;
815 struct can_frame
*cf
;
817 struct net_device_stats
*stats
;
818 u8 channel
= msg
->u
.rx_can
.channel
;
820 if (channel
>= dev
->nchannels
) {
821 dev_err(dev
->udev
->dev
.parent
,
822 "Invalid channel number (%d)\n", channel
);
826 priv
= dev
->nets
[channel
];
827 stats
= &priv
->netdev
->stats
;
829 if ((msg
->u
.rx_can
.flag
& MSG_FLAG_ERROR_FRAME
) &&
830 (msg
->id
== CMD_LOG_MESSAGE
)) {
831 kvaser_usb_rx_error(dev
, msg
);
833 } else if (msg
->u
.rx_can
.flag
& (MSG_FLAG_ERROR_FRAME
|
836 kvaser_usb_rx_can_err(priv
, msg
);
838 } else if (msg
->u
.rx_can
.flag
& ~MSG_FLAG_REMOTE_FRAME
) {
839 netdev_warn(priv
->netdev
,
840 "Unhandled frame (flags: 0x%02x)",
845 skb
= alloc_can_skb(priv
->netdev
, &cf
);
851 if (msg
->id
== CMD_LOG_MESSAGE
) {
852 cf
->can_id
= le32_to_cpu(msg
->u
.log_message
.id
);
853 if (cf
->can_id
& KVASER_EXTENDED_FRAME
)
854 cf
->can_id
&= CAN_EFF_MASK
| CAN_EFF_FLAG
;
856 cf
->can_id
&= CAN_SFF_MASK
;
858 cf
->can_dlc
= get_can_dlc(msg
->u
.log_message
.dlc
);
860 if (msg
->u
.log_message
.flags
& MSG_FLAG_REMOTE_FRAME
)
861 cf
->can_id
|= CAN_RTR_FLAG
;
863 memcpy(cf
->data
, &msg
->u
.log_message
.data
,
866 cf
->can_id
= ((msg
->u
.rx_can
.msg
[0] & 0x1f) << 6) |
867 (msg
->u
.rx_can
.msg
[1] & 0x3f);
869 if (msg
->id
== CMD_RX_EXT_MESSAGE
) {
871 cf
->can_id
|= ((msg
->u
.rx_can
.msg
[2] & 0x0f) << 14) |
872 ((msg
->u
.rx_can
.msg
[3] & 0xff) << 6) |
873 (msg
->u
.rx_can
.msg
[4] & 0x3f);
874 cf
->can_id
|= CAN_EFF_FLAG
;
877 cf
->can_dlc
= get_can_dlc(msg
->u
.rx_can
.msg
[5]);
879 if (msg
->u
.rx_can
.flag
& MSG_FLAG_REMOTE_FRAME
)
880 cf
->can_id
|= CAN_RTR_FLAG
;
882 memcpy(cf
->data
, &msg
->u
.rx_can
.msg
[6],
889 stats
->rx_bytes
+= cf
->can_dlc
;
892 static void kvaser_usb_start_chip_reply(const struct kvaser_usb
*dev
,
893 const struct kvaser_msg
*msg
)
895 struct kvaser_usb_net_priv
*priv
;
896 u8 channel
= msg
->u
.simple
.channel
;
898 if (channel
>= dev
->nchannels
) {
899 dev_err(dev
->udev
->dev
.parent
,
900 "Invalid channel number (%d)\n", channel
);
904 priv
= dev
->nets
[channel
];
906 if (completion_done(&priv
->start_comp
) &&
907 netif_queue_stopped(priv
->netdev
)) {
908 netif_wake_queue(priv
->netdev
);
910 netif_start_queue(priv
->netdev
);
911 complete(&priv
->start_comp
);
915 static void kvaser_usb_stop_chip_reply(const struct kvaser_usb
*dev
,
916 const struct kvaser_msg
*msg
)
918 struct kvaser_usb_net_priv
*priv
;
919 u8 channel
= msg
->u
.simple
.channel
;
921 if (channel
>= dev
->nchannels
) {
922 dev_err(dev
->udev
->dev
.parent
,
923 "Invalid channel number (%d)\n", channel
);
927 priv
= dev
->nets
[channel
];
929 complete(&priv
->stop_comp
);
932 static void kvaser_usb_handle_message(const struct kvaser_usb
*dev
,
933 const struct kvaser_msg
*msg
)
936 case CMD_START_CHIP_REPLY
:
937 kvaser_usb_start_chip_reply(dev
, msg
);
940 case CMD_STOP_CHIP_REPLY
:
941 kvaser_usb_stop_chip_reply(dev
, msg
);
944 case CMD_RX_STD_MESSAGE
:
945 case CMD_RX_EXT_MESSAGE
:
946 case CMD_LOG_MESSAGE
:
947 kvaser_usb_rx_can_msg(dev
, msg
);
950 case CMD_CHIP_STATE_EVENT
:
951 case CMD_CAN_ERROR_EVENT
:
952 kvaser_usb_rx_error(dev
, msg
);
955 case CMD_TX_ACKNOWLEDGE
:
956 kvaser_usb_tx_acknowledge(dev
, msg
);
960 dev_warn(dev
->udev
->dev
.parent
,
961 "Unhandled message (%d)\n", msg
->id
);
966 static void kvaser_usb_read_bulk_callback(struct urb
*urb
)
968 struct kvaser_usb
*dev
= urb
->context
;
969 struct kvaser_msg
*msg
;
973 switch (urb
->status
) {
980 dev_info(dev
->udev
->dev
.parent
, "Rx URB aborted (%d)\n",
985 while (pos
<= urb
->actual_length
- MSG_HEADER_LEN
) {
986 msg
= urb
->transfer_buffer
+ pos
;
991 if (pos
+ msg
->len
> urb
->actual_length
) {
992 dev_err(dev
->udev
->dev
.parent
, "Format error\n");
996 kvaser_usb_handle_message(dev
, msg
);
1002 usb_fill_bulk_urb(urb
, dev
->udev
,
1003 usb_rcvbulkpipe(dev
->udev
,
1004 dev
->bulk_in
->bEndpointAddress
),
1005 urb
->transfer_buffer
, RX_BUFFER_SIZE
,
1006 kvaser_usb_read_bulk_callback
, dev
);
1008 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
1009 if (err
== -ENODEV
) {
1010 for (i
= 0; i
< dev
->nchannels
; i
++) {
1014 netif_device_detach(dev
->nets
[i
]->netdev
);
1017 dev_err(dev
->udev
->dev
.parent
,
1018 "Failed resubmitting read bulk urb: %d\n", err
);
1024 static int kvaser_usb_setup_rx_urbs(struct kvaser_usb
*dev
)
1028 if (dev
->rxinitdone
)
1031 for (i
= 0; i
< MAX_RX_URBS
; i
++) {
1032 struct urb
*urb
= NULL
;
1036 urb
= usb_alloc_urb(0, GFP_KERNEL
);
1038 dev_warn(dev
->udev
->dev
.parent
,
1039 "No memory left for URBs\n");
1044 buf
= usb_alloc_coherent(dev
->udev
, RX_BUFFER_SIZE
,
1045 GFP_KERNEL
, &buf_dma
);
1047 dev_warn(dev
->udev
->dev
.parent
,
1048 "No memory left for USB buffer\n");
1054 usb_fill_bulk_urb(urb
, dev
->udev
,
1055 usb_rcvbulkpipe(dev
->udev
,
1056 dev
->bulk_in
->bEndpointAddress
),
1057 buf
, RX_BUFFER_SIZE
,
1058 kvaser_usb_read_bulk_callback
,
1060 urb
->transfer_dma
= buf_dma
;
1061 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1062 usb_anchor_urb(urb
, &dev
->rx_submitted
);
1064 err
= usb_submit_urb(urb
, GFP_KERNEL
);
1066 usb_unanchor_urb(urb
);
1067 usb_free_coherent(dev
->udev
, RX_BUFFER_SIZE
, buf
,
1073 dev
->rxbuf
[i
] = buf
;
1074 dev
->rxbuf_dma
[i
] = buf_dma
;
1080 dev_warn(dev
->udev
->dev
.parent
,
1081 "Cannot setup read URBs, error %d\n", err
);
1083 } else if (i
< MAX_RX_URBS
) {
1084 dev_warn(dev
->udev
->dev
.parent
,
1085 "RX performances may be slow\n");
1088 dev
->rxinitdone
= true;
1093 static int kvaser_usb_set_opt_mode(const struct kvaser_usb_net_priv
*priv
)
1095 struct kvaser_msg
*msg
;
1098 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
1102 msg
->id
= CMD_SET_CTRL_MODE
;
1103 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_ctrl_mode
);
1104 msg
->u
.ctrl_mode
.tid
= 0xff;
1105 msg
->u
.ctrl_mode
.channel
= priv
->channel
;
1107 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_LISTENONLY
)
1108 msg
->u
.ctrl_mode
.ctrl_mode
= KVASER_CTRL_MODE_SILENT
;
1110 msg
->u
.ctrl_mode
.ctrl_mode
= KVASER_CTRL_MODE_NORMAL
;
1112 rc
= kvaser_usb_send_msg(priv
->dev
, msg
);
1118 static int kvaser_usb_start_chip(struct kvaser_usb_net_priv
*priv
)
1122 init_completion(&priv
->start_comp
);
1124 err
= kvaser_usb_send_simple_msg(priv
->dev
, CMD_START_CHIP
,
1129 if (!wait_for_completion_timeout(&priv
->start_comp
,
1130 msecs_to_jiffies(START_TIMEOUT
)))
1136 static int kvaser_usb_open(struct net_device
*netdev
)
1138 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1139 struct kvaser_usb
*dev
= priv
->dev
;
1142 err
= open_candev(netdev
);
1146 err
= kvaser_usb_setup_rx_urbs(dev
);
1150 err
= kvaser_usb_set_opt_mode(priv
);
1154 err
= kvaser_usb_start_chip(priv
);
1156 netdev_warn(netdev
, "Cannot start device, error %d\n", err
);
1160 priv
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
1165 close_candev(netdev
);
1169 static void kvaser_usb_unlink_all_urbs(struct kvaser_usb
*dev
)
1173 usb_kill_anchored_urbs(&dev
->rx_submitted
);
1175 for (i
= 0; i
< MAX_RX_URBS
; i
++)
1176 usb_free_coherent(dev
->udev
, RX_BUFFER_SIZE
,
1180 for (i
= 0; i
< MAX_NET_DEVICES
; i
++) {
1181 struct kvaser_usb_net_priv
*priv
= dev
->nets
[i
];
1184 kvaser_usb_unlink_tx_urbs(priv
);
1188 static int kvaser_usb_stop_chip(struct kvaser_usb_net_priv
*priv
)
1192 init_completion(&priv
->stop_comp
);
1194 err
= kvaser_usb_send_simple_msg(priv
->dev
, CMD_STOP_CHIP
,
1199 if (!wait_for_completion_timeout(&priv
->stop_comp
,
1200 msecs_to_jiffies(STOP_TIMEOUT
)))
1206 static int kvaser_usb_flush_queue(struct kvaser_usb_net_priv
*priv
)
1208 struct kvaser_msg
*msg
;
1211 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
1215 msg
->id
= CMD_FLUSH_QUEUE
;
1216 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_flush_queue
);
1217 msg
->u
.flush_queue
.channel
= priv
->channel
;
1218 msg
->u
.flush_queue
.flags
= 0x00;
1220 rc
= kvaser_usb_send_msg(priv
->dev
, msg
);
1226 static int kvaser_usb_close(struct net_device
*netdev
)
1228 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1229 struct kvaser_usb
*dev
= priv
->dev
;
1232 netif_stop_queue(netdev
);
1234 err
= kvaser_usb_flush_queue(priv
);
1236 netdev_warn(netdev
, "Cannot flush queue, error %d\n", err
);
1238 if (kvaser_usb_send_simple_msg(dev
, CMD_RESET_CHIP
, priv
->channel
))
1239 netdev_warn(netdev
, "Cannot reset card, error %d\n", err
);
1241 err
= kvaser_usb_stop_chip(priv
);
1243 netdev_warn(netdev
, "Cannot stop device, error %d\n", err
);
1245 priv
->can
.state
= CAN_STATE_STOPPED
;
1246 close_candev(priv
->netdev
);
1251 static void kvaser_usb_write_bulk_callback(struct urb
*urb
)
1253 struct kvaser_usb_tx_urb_context
*context
= urb
->context
;
1254 struct kvaser_usb_net_priv
*priv
;
1255 struct net_device
*netdev
;
1257 if (WARN_ON(!context
))
1260 priv
= context
->priv
;
1261 netdev
= priv
->netdev
;
1263 kfree(urb
->transfer_buffer
);
1265 if (!netif_device_present(netdev
))
1269 netdev_info(netdev
, "Tx URB aborted (%d)\n", urb
->status
);
1272 static netdev_tx_t
kvaser_usb_start_xmit(struct sk_buff
*skb
,
1273 struct net_device
*netdev
)
1275 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1276 struct kvaser_usb
*dev
= priv
->dev
;
1277 struct net_device_stats
*stats
= &netdev
->stats
;
1278 struct can_frame
*cf
= (struct can_frame
*)skb
->data
;
1279 struct kvaser_usb_tx_urb_context
*context
= NULL
;
1282 struct kvaser_msg
*msg
;
1284 int ret
= NETDEV_TX_OK
;
1286 if (can_dropped_invalid_skb(netdev
, skb
))
1287 return NETDEV_TX_OK
;
1289 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
1291 netdev_err(netdev
, "No memory left for URBs\n");
1292 stats
->tx_dropped
++;
1296 buf
= kmalloc(sizeof(struct kvaser_msg
), GFP_ATOMIC
);
1298 stats
->tx_dropped
++;
1303 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_tx_can
);
1304 msg
->u
.tx_can
.flags
= 0;
1305 msg
->u
.tx_can
.channel
= priv
->channel
;
1307 if (cf
->can_id
& CAN_EFF_FLAG
) {
1308 msg
->id
= CMD_TX_EXT_MESSAGE
;
1309 msg
->u
.tx_can
.msg
[0] = (cf
->can_id
>> 24) & 0x1f;
1310 msg
->u
.tx_can
.msg
[1] = (cf
->can_id
>> 18) & 0x3f;
1311 msg
->u
.tx_can
.msg
[2] = (cf
->can_id
>> 14) & 0x0f;
1312 msg
->u
.tx_can
.msg
[3] = (cf
->can_id
>> 6) & 0xff;
1313 msg
->u
.tx_can
.msg
[4] = cf
->can_id
& 0x3f;
1315 msg
->id
= CMD_TX_STD_MESSAGE
;
1316 msg
->u
.tx_can
.msg
[0] = (cf
->can_id
>> 6) & 0x1f;
1317 msg
->u
.tx_can
.msg
[1] = cf
->can_id
& 0x3f;
1320 msg
->u
.tx_can
.msg
[5] = cf
->can_dlc
;
1321 memcpy(&msg
->u
.tx_can
.msg
[6], cf
->data
, cf
->can_dlc
);
1323 if (cf
->can_id
& CAN_RTR_FLAG
)
1324 msg
->u
.tx_can
.flags
|= MSG_FLAG_REMOTE_FRAME
;
1326 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_contexts
); i
++) {
1327 if (priv
->tx_contexts
[i
].echo_index
== MAX_TX_URBS
) {
1328 context
= &priv
->tx_contexts
[i
];
1334 netdev_warn(netdev
, "cannot find free context\n");
1335 ret
= NETDEV_TX_BUSY
;
1339 context
->priv
= priv
;
1340 context
->echo_index
= i
;
1341 context
->dlc
= cf
->can_dlc
;
1343 msg
->u
.tx_can
.tid
= context
->echo_index
;
1345 usb_fill_bulk_urb(urb
, dev
->udev
,
1346 usb_sndbulkpipe(dev
->udev
,
1347 dev
->bulk_out
->bEndpointAddress
),
1349 kvaser_usb_write_bulk_callback
, context
);
1350 usb_anchor_urb(urb
, &priv
->tx_submitted
);
1352 can_put_echo_skb(skb
, netdev
, context
->echo_index
);
1354 atomic_inc(&priv
->active_tx_urbs
);
1356 if (atomic_read(&priv
->active_tx_urbs
) >= MAX_TX_URBS
)
1357 netif_stop_queue(netdev
);
1359 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
1360 if (unlikely(err
)) {
1361 can_free_echo_skb(netdev
, context
->echo_index
);
1363 skb
= NULL
; /* set to NULL to avoid double free in
1364 * dev_kfree_skb(skb) */
1366 atomic_dec(&priv
->active_tx_urbs
);
1367 usb_unanchor_urb(urb
);
1369 stats
->tx_dropped
++;
1372 netif_device_detach(netdev
);
1374 netdev_warn(netdev
, "Failed tx_urb %d\n", err
);
1381 return NETDEV_TX_OK
;
1392 static const struct net_device_ops kvaser_usb_netdev_ops
= {
1393 .ndo_open
= kvaser_usb_open
,
1394 .ndo_stop
= kvaser_usb_close
,
1395 .ndo_start_xmit
= kvaser_usb_start_xmit
,
1396 .ndo_change_mtu
= can_change_mtu
,
1399 static const struct can_bittiming_const kvaser_usb_bittiming_const
= {
1400 .name
= "kvaser_usb",
1401 .tseg1_min
= KVASER_USB_TSEG1_MIN
,
1402 .tseg1_max
= KVASER_USB_TSEG1_MAX
,
1403 .tseg2_min
= KVASER_USB_TSEG2_MIN
,
1404 .tseg2_max
= KVASER_USB_TSEG2_MAX
,
1405 .sjw_max
= KVASER_USB_SJW_MAX
,
1406 .brp_min
= KVASER_USB_BRP_MIN
,
1407 .brp_max
= KVASER_USB_BRP_MAX
,
1408 .brp_inc
= KVASER_USB_BRP_INC
,
1411 static int kvaser_usb_set_bittiming(struct net_device
*netdev
)
1413 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1414 struct can_bittiming
*bt
= &priv
->can
.bittiming
;
1415 struct kvaser_usb
*dev
= priv
->dev
;
1416 struct kvaser_msg
*msg
;
1419 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
1423 msg
->id
= CMD_SET_BUS_PARAMS
;
1424 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_busparams
);
1425 msg
->u
.busparams
.channel
= priv
->channel
;
1426 msg
->u
.busparams
.tid
= 0xff;
1427 msg
->u
.busparams
.bitrate
= cpu_to_le32(bt
->bitrate
);
1428 msg
->u
.busparams
.sjw
= bt
->sjw
;
1429 msg
->u
.busparams
.tseg1
= bt
->prop_seg
+ bt
->phase_seg1
;
1430 msg
->u
.busparams
.tseg2
= bt
->phase_seg2
;
1432 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_3_SAMPLES
)
1433 msg
->u
.busparams
.no_samp
= 3;
1435 msg
->u
.busparams
.no_samp
= 1;
1437 rc
= kvaser_usb_send_msg(dev
, msg
);
1443 static int kvaser_usb_set_mode(struct net_device
*netdev
,
1446 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1450 case CAN_MODE_START
:
1451 err
= kvaser_usb_simple_msg_async(priv
, CMD_START_CHIP
);
1462 static int kvaser_usb_get_berr_counter(const struct net_device
*netdev
,
1463 struct can_berr_counter
*bec
)
1465 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1472 static void kvaser_usb_remove_interfaces(struct kvaser_usb
*dev
)
1476 for (i
= 0; i
< dev
->nchannels
; i
++) {
1480 unregister_netdev(dev
->nets
[i
]->netdev
);
1483 kvaser_usb_unlink_all_urbs(dev
);
1485 for (i
= 0; i
< dev
->nchannels
; i
++) {
1489 free_candev(dev
->nets
[i
]->netdev
);
1493 static int kvaser_usb_init_one(struct usb_interface
*intf
,
1494 const struct usb_device_id
*id
, int channel
)
1496 struct kvaser_usb
*dev
= usb_get_intfdata(intf
);
1497 struct net_device
*netdev
;
1498 struct kvaser_usb_net_priv
*priv
;
1501 netdev
= alloc_candev(sizeof(*priv
), MAX_TX_URBS
);
1503 dev_err(&intf
->dev
, "Cannot alloc candev\n");
1507 priv
= netdev_priv(netdev
);
1509 init_completion(&priv
->start_comp
);
1510 init_completion(&priv
->stop_comp
);
1512 init_usb_anchor(&priv
->tx_submitted
);
1513 atomic_set(&priv
->active_tx_urbs
, 0);
1515 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_contexts
); i
++)
1516 priv
->tx_contexts
[i
].echo_index
= MAX_TX_URBS
;
1519 priv
->netdev
= netdev
;
1520 priv
->channel
= channel
;
1522 priv
->can
.state
= CAN_STATE_STOPPED
;
1523 priv
->can
.clock
.freq
= CAN_USB_CLOCK
;
1524 priv
->can
.bittiming_const
= &kvaser_usb_bittiming_const
;
1525 priv
->can
.do_set_bittiming
= kvaser_usb_set_bittiming
;
1526 priv
->can
.do_set_mode
= kvaser_usb_set_mode
;
1527 if (id
->driver_info
& KVASER_HAS_TXRX_ERRORS
)
1528 priv
->can
.do_get_berr_counter
= kvaser_usb_get_berr_counter
;
1529 priv
->can
.ctrlmode_supported
= CAN_CTRLMODE_3_SAMPLES
;
1530 if (id
->driver_info
& KVASER_HAS_SILENT_MODE
)
1531 priv
->can
.ctrlmode_supported
|= CAN_CTRLMODE_LISTENONLY
;
1533 netdev
->flags
|= IFF_ECHO
;
1535 netdev
->netdev_ops
= &kvaser_usb_netdev_ops
;
1537 SET_NETDEV_DEV(netdev
, &intf
->dev
);
1538 netdev
->dev_id
= channel
;
1540 dev
->nets
[channel
] = priv
;
1542 err
= register_candev(netdev
);
1544 dev_err(&intf
->dev
, "Failed to register can device\n");
1545 free_candev(netdev
);
1546 dev
->nets
[channel
] = NULL
;
1550 netdev_dbg(netdev
, "device registered\n");
1555 static int kvaser_usb_get_endpoints(const struct usb_interface
*intf
,
1556 struct usb_endpoint_descriptor
**in
,
1557 struct usb_endpoint_descriptor
**out
)
1559 const struct usb_host_interface
*iface_desc
;
1560 struct usb_endpoint_descriptor
*endpoint
;
1563 iface_desc
= &intf
->altsetting
[0];
1565 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
1566 endpoint
= &iface_desc
->endpoint
[i
].desc
;
1568 if (!*in
&& usb_endpoint_is_bulk_in(endpoint
))
1571 if (!*out
&& usb_endpoint_is_bulk_out(endpoint
))
1574 /* use first bulk endpoint for in and out */
1582 static int kvaser_usb_probe(struct usb_interface
*intf
,
1583 const struct usb_device_id
*id
)
1585 struct kvaser_usb
*dev
;
1589 dev
= devm_kzalloc(&intf
->dev
, sizeof(*dev
), GFP_KERNEL
);
1593 err
= kvaser_usb_get_endpoints(intf
, &dev
->bulk_in
, &dev
->bulk_out
);
1595 dev_err(&intf
->dev
, "Cannot get usb endpoint(s)");
1599 dev
->udev
= interface_to_usbdev(intf
);
1601 init_usb_anchor(&dev
->rx_submitted
);
1603 usb_set_intfdata(intf
, dev
);
1605 for (i
= 0; i
< MAX_NET_DEVICES
; i
++)
1606 kvaser_usb_send_simple_msg(dev
, CMD_RESET_CHIP
, i
);
1608 err
= kvaser_usb_get_software_info(dev
);
1611 "Cannot get software infos, error %d\n", err
);
1615 err
= kvaser_usb_get_card_info(dev
);
1618 "Cannot get card infos, error %d\n", err
);
1622 dev_dbg(&intf
->dev
, "Firmware version: %d.%d.%d\n",
1623 ((dev
->fw_version
>> 24) & 0xff),
1624 ((dev
->fw_version
>> 16) & 0xff),
1625 (dev
->fw_version
& 0xffff));
1627 for (i
= 0; i
< dev
->nchannels
; i
++) {
1628 err
= kvaser_usb_init_one(intf
, id
, i
);
1630 kvaser_usb_remove_interfaces(dev
);
1638 static void kvaser_usb_disconnect(struct usb_interface
*intf
)
1640 struct kvaser_usb
*dev
= usb_get_intfdata(intf
);
1642 usb_set_intfdata(intf
, NULL
);
1647 kvaser_usb_remove_interfaces(dev
);
1650 static struct usb_driver kvaser_usb_driver
= {
1651 .name
= "kvaser_usb",
1652 .probe
= kvaser_usb_probe
,
1653 .disconnect
= kvaser_usb_disconnect
,
1654 .id_table
= kvaser_usb_table
,
1657 module_usb_driver(kvaser_usb_driver
);
1659 MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
1660 MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices");
1661 MODULE_LICENSE("GPL v2");