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
56 #define USB_LEAF_LITE_V2_PRODUCT_ID 288
57 #define USB_MINI_PCIE_HS_PRODUCT_ID 289
59 /* USB devices features */
60 #define KVASER_HAS_SILENT_MODE BIT(0)
61 #define KVASER_HAS_TXRX_ERRORS BIT(1)
63 /* Message header size */
64 #define MSG_HEADER_LEN 2
66 /* Can message flags */
67 #define MSG_FLAG_ERROR_FRAME BIT(0)
68 #define MSG_FLAG_OVERRUN BIT(1)
69 #define MSG_FLAG_NERR BIT(2)
70 #define MSG_FLAG_WAKEUP BIT(3)
71 #define MSG_FLAG_REMOTE_FRAME BIT(4)
72 #define MSG_FLAG_RESERVED BIT(5)
73 #define MSG_FLAG_TX_ACK BIT(6)
74 #define MSG_FLAG_TX_REQUEST BIT(7)
77 #define M16C_STATE_BUS_RESET BIT(0)
78 #define M16C_STATE_BUS_ERROR BIT(4)
79 #define M16C_STATE_BUS_PASSIVE BIT(5)
80 #define M16C_STATE_BUS_OFF BIT(6)
83 #define CMD_RX_STD_MESSAGE 12
84 #define CMD_TX_STD_MESSAGE 13
85 #define CMD_RX_EXT_MESSAGE 14
86 #define CMD_TX_EXT_MESSAGE 15
87 #define CMD_SET_BUS_PARAMS 16
88 #define CMD_GET_BUS_PARAMS 17
89 #define CMD_GET_BUS_PARAMS_REPLY 18
90 #define CMD_GET_CHIP_STATE 19
91 #define CMD_CHIP_STATE_EVENT 20
92 #define CMD_SET_CTRL_MODE 21
93 #define CMD_GET_CTRL_MODE 22
94 #define CMD_GET_CTRL_MODE_REPLY 23
95 #define CMD_RESET_CHIP 24
96 #define CMD_RESET_CARD 25
97 #define CMD_START_CHIP 26
98 #define CMD_START_CHIP_REPLY 27
99 #define CMD_STOP_CHIP 28
100 #define CMD_STOP_CHIP_REPLY 29
101 #define CMD_GET_CARD_INFO2 32
102 #define CMD_GET_CARD_INFO 34
103 #define CMD_GET_CARD_INFO_REPLY 35
104 #define CMD_GET_SOFTWARE_INFO 38
105 #define CMD_GET_SOFTWARE_INFO_REPLY 39
106 #define CMD_ERROR_EVENT 45
107 #define CMD_FLUSH_QUEUE 48
108 #define CMD_RESET_ERROR_COUNTER 49
109 #define CMD_TX_ACKNOWLEDGE 50
110 #define CMD_CAN_ERROR_EVENT 51
111 #define CMD_USB_THROTTLE 77
112 #define CMD_LOG_MESSAGE 106
115 #define M16C_EF_ACKE BIT(0)
116 #define M16C_EF_CRCE BIT(1)
117 #define M16C_EF_FORME BIT(2)
118 #define M16C_EF_STFE BIT(3)
119 #define M16C_EF_BITE0 BIT(4)
120 #define M16C_EF_BITE1 BIT(5)
121 #define M16C_EF_RCVE BIT(6)
122 #define M16C_EF_TRE BIT(7)
124 /* bittiming parameters */
125 #define KVASER_USB_TSEG1_MIN 1
126 #define KVASER_USB_TSEG1_MAX 16
127 #define KVASER_USB_TSEG2_MIN 1
128 #define KVASER_USB_TSEG2_MAX 8
129 #define KVASER_USB_SJW_MAX 4
130 #define KVASER_USB_BRP_MIN 1
131 #define KVASER_USB_BRP_MAX 64
132 #define KVASER_USB_BRP_INC 1
135 #define KVASER_CTRL_MODE_NORMAL 1
136 #define KVASER_CTRL_MODE_SILENT 2
137 #define KVASER_CTRL_MODE_SELFRECEPTION 3
138 #define KVASER_CTRL_MODE_OFF 4
141 #define KVASER_EXTENDED_FRAME BIT(31)
143 struct kvaser_msg_simple
{
148 struct kvaser_msg_cardinfo
{
151 __le32 serial_number
;
153 __le32 clock_resolution
;
161 struct kvaser_msg_cardinfo2
{
165 __le32 oem_unlock_code
;
168 struct kvaser_msg_softinfo
{
173 __le16 max_outstanding_tx
;
177 struct kvaser_msg_busparams
{
187 struct kvaser_msg_tx_can
{
195 struct kvaser_msg_rx_can
{
202 struct kvaser_msg_chip_state_event
{
212 struct kvaser_msg_tx_acknowledge
{
220 struct kvaser_msg_error_event
{
232 struct kvaser_msg_ctrl_mode
{
239 struct kvaser_msg_flush_queue
{
246 struct kvaser_msg_log_message
{
260 struct kvaser_msg_simple simple
;
261 struct kvaser_msg_cardinfo cardinfo
;
262 struct kvaser_msg_cardinfo2 cardinfo2
;
263 struct kvaser_msg_softinfo softinfo
;
264 struct kvaser_msg_busparams busparams
;
265 struct kvaser_msg_tx_can tx_can
;
266 struct kvaser_msg_rx_can rx_can
;
267 struct kvaser_msg_chip_state_event chip_state_event
;
268 struct kvaser_msg_tx_acknowledge tx_acknowledge
;
269 struct kvaser_msg_error_event error_event
;
270 struct kvaser_msg_ctrl_mode ctrl_mode
;
271 struct kvaser_msg_flush_queue flush_queue
;
272 struct kvaser_msg_log_message log_message
;
276 struct kvaser_usb_error_summary
{
277 u8 channel
, status
, txerr
, rxerr
, error_factor
;
280 struct kvaser_usb_tx_urb_context
{
281 struct kvaser_usb_net_priv
*priv
;
287 struct usb_device
*udev
;
288 struct kvaser_usb_net_priv
*nets
[MAX_NET_DEVICES
];
290 struct usb_endpoint_descriptor
*bulk_in
, *bulk_out
;
291 struct usb_anchor rx_submitted
;
294 unsigned int nchannels
;
297 void *rxbuf
[MAX_RX_URBS
];
298 dma_addr_t rxbuf_dma
[MAX_RX_URBS
];
301 struct kvaser_usb_net_priv
{
304 atomic_t active_tx_urbs
;
305 struct usb_anchor tx_submitted
;
306 struct kvaser_usb_tx_urb_context tx_contexts
[MAX_TX_URBS
];
308 struct completion start_comp
, stop_comp
;
310 struct kvaser_usb
*dev
;
311 struct net_device
*netdev
;
314 struct can_berr_counter bec
;
317 static const struct usb_device_id kvaser_usb_table
[] = {
318 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_DEVEL_PRODUCT_ID
) },
319 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_LITE_PRODUCT_ID
) },
320 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_PRO_PRODUCT_ID
),
321 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
322 KVASER_HAS_SILENT_MODE
},
323 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_SPRO_PRODUCT_ID
),
324 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
325 KVASER_HAS_SILENT_MODE
},
326 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_PRO_LS_PRODUCT_ID
),
327 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
328 KVASER_HAS_SILENT_MODE
},
329 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_PRO_SWC_PRODUCT_ID
),
330 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
331 KVASER_HAS_SILENT_MODE
},
332 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_PRO_LIN_PRODUCT_ID
),
333 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
334 KVASER_HAS_SILENT_MODE
},
335 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_SPRO_LS_PRODUCT_ID
),
336 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
337 KVASER_HAS_SILENT_MODE
},
338 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_SPRO_SWC_PRODUCT_ID
),
339 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
340 KVASER_HAS_SILENT_MODE
},
341 { USB_DEVICE(KVASER_VENDOR_ID
, USB_MEMO2_DEVEL_PRODUCT_ID
),
342 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
343 KVASER_HAS_SILENT_MODE
},
344 { USB_DEVICE(KVASER_VENDOR_ID
, USB_MEMO2_HSHS_PRODUCT_ID
),
345 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
346 KVASER_HAS_SILENT_MODE
},
347 { USB_DEVICE(KVASER_VENDOR_ID
, USB_UPRO_HSHS_PRODUCT_ID
),
348 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
349 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_LITE_GI_PRODUCT_ID
) },
350 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_PRO_OBDII_PRODUCT_ID
),
351 .driver_info
= KVASER_HAS_TXRX_ERRORS
|
352 KVASER_HAS_SILENT_MODE
},
353 { USB_DEVICE(KVASER_VENDOR_ID
, USB_MEMO2_HSLS_PRODUCT_ID
),
354 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
355 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_LITE_CH_PRODUCT_ID
),
356 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
357 { USB_DEVICE(KVASER_VENDOR_ID
, USB_BLACKBIRD_SPRO_PRODUCT_ID
),
358 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
359 { USB_DEVICE(KVASER_VENDOR_ID
, USB_OEM_MERCURY_PRODUCT_ID
),
360 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
361 { USB_DEVICE(KVASER_VENDOR_ID
, USB_OEM_LEAF_PRODUCT_ID
),
362 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
363 { USB_DEVICE(KVASER_VENDOR_ID
, USB_CAN_R_PRODUCT_ID
),
364 .driver_info
= KVASER_HAS_TXRX_ERRORS
},
365 { USB_DEVICE(KVASER_VENDOR_ID
, USB_LEAF_LITE_V2_PRODUCT_ID
) },
366 { USB_DEVICE(KVASER_VENDOR_ID
, USB_MINI_PCIE_HS_PRODUCT_ID
) },
369 MODULE_DEVICE_TABLE(usb
, kvaser_usb_table
);
371 static inline int kvaser_usb_send_msg(const struct kvaser_usb
*dev
,
372 struct kvaser_msg
*msg
)
376 return usb_bulk_msg(dev
->udev
,
377 usb_sndbulkpipe(dev
->udev
,
378 dev
->bulk_out
->bEndpointAddress
),
379 msg
, msg
->len
, &actual_len
,
383 static int kvaser_usb_wait_msg(const struct kvaser_usb
*dev
, u8 id
,
384 struct kvaser_msg
*msg
)
386 struct kvaser_msg
*tmp
;
391 unsigned long to
= jiffies
+ msecs_to_jiffies(USB_RECV_TIMEOUT
);
393 buf
= kzalloc(RX_BUFFER_SIZE
, GFP_KERNEL
);
398 err
= usb_bulk_msg(dev
->udev
,
399 usb_rcvbulkpipe(dev
->udev
,
400 dev
->bulk_in
->bEndpointAddress
),
401 buf
, RX_BUFFER_SIZE
, &actual_len
,
407 while (pos
<= actual_len
- MSG_HEADER_LEN
) {
413 if (pos
+ tmp
->len
> actual_len
) {
414 dev_err(dev
->udev
->dev
.parent
,
420 memcpy(msg
, tmp
, tmp
->len
);
426 } while (time_before(jiffies
, to
));
436 static int kvaser_usb_send_simple_msg(const struct kvaser_usb
*dev
,
437 u8 msg_id
, int channel
)
439 struct kvaser_msg
*msg
;
442 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
447 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_simple
);
448 msg
->u
.simple
.channel
= channel
;
449 msg
->u
.simple
.tid
= 0xff;
451 rc
= kvaser_usb_send_msg(dev
, msg
);
457 static int kvaser_usb_get_software_info(struct kvaser_usb
*dev
)
459 struct kvaser_msg msg
;
462 err
= kvaser_usb_send_simple_msg(dev
, CMD_GET_SOFTWARE_INFO
, 0);
466 err
= kvaser_usb_wait_msg(dev
, CMD_GET_SOFTWARE_INFO_REPLY
, &msg
);
470 dev
->fw_version
= le32_to_cpu(msg
.u
.softinfo
.fw_version
);
475 static int kvaser_usb_get_card_info(struct kvaser_usb
*dev
)
477 struct kvaser_msg msg
;
480 err
= kvaser_usb_send_simple_msg(dev
, CMD_GET_CARD_INFO
, 0);
484 err
= kvaser_usb_wait_msg(dev
, CMD_GET_CARD_INFO_REPLY
, &msg
);
488 dev
->nchannels
= msg
.u
.cardinfo
.nchannels
;
489 if (dev
->nchannels
> MAX_NET_DEVICES
)
495 static void kvaser_usb_tx_acknowledge(const struct kvaser_usb
*dev
,
496 const struct kvaser_msg
*msg
)
498 struct net_device_stats
*stats
;
499 struct kvaser_usb_tx_urb_context
*context
;
500 struct kvaser_usb_net_priv
*priv
;
502 struct can_frame
*cf
;
503 u8 channel
= msg
->u
.tx_acknowledge
.channel
;
504 u8 tid
= msg
->u
.tx_acknowledge
.tid
;
506 if (channel
>= dev
->nchannels
) {
507 dev_err(dev
->udev
->dev
.parent
,
508 "Invalid channel number (%d)\n", channel
);
512 priv
= dev
->nets
[channel
];
514 if (!netif_device_present(priv
->netdev
))
517 stats
= &priv
->netdev
->stats
;
519 context
= &priv
->tx_contexts
[tid
% MAX_TX_URBS
];
521 /* Sometimes the state change doesn't come after a bus-off event */
522 if (priv
->can
.restart_ms
&&
523 (priv
->can
.state
>= CAN_STATE_BUS_OFF
)) {
524 skb
= alloc_can_err_skb(priv
->netdev
, &cf
);
526 cf
->can_id
|= CAN_ERR_RESTARTED
;
529 stats
->rx_bytes
+= cf
->can_dlc
;
532 netdev_err(priv
->netdev
,
533 "No memory left for err_skb\n");
536 priv
->can
.can_stats
.restarts
++;
537 netif_carrier_on(priv
->netdev
);
539 priv
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
543 stats
->tx_bytes
+= context
->dlc
;
544 can_get_echo_skb(priv
->netdev
, context
->echo_index
);
546 context
->echo_index
= MAX_TX_URBS
;
547 atomic_dec(&priv
->active_tx_urbs
);
549 netif_wake_queue(priv
->netdev
);
552 static void kvaser_usb_simple_msg_callback(struct urb
*urb
)
554 struct net_device
*netdev
= urb
->context
;
556 kfree(urb
->transfer_buffer
);
559 netdev_warn(netdev
, "urb status received: %d\n",
563 static int kvaser_usb_simple_msg_async(struct kvaser_usb_net_priv
*priv
,
566 struct kvaser_usb
*dev
= priv
->dev
;
567 struct net_device
*netdev
= priv
->netdev
;
568 struct kvaser_msg
*msg
;
573 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
575 netdev_err(netdev
, "No memory left for URBs\n");
579 buf
= kmalloc(sizeof(struct kvaser_msg
), GFP_ATOMIC
);
585 msg
= (struct kvaser_msg
*)buf
;
586 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_simple
);
588 msg
->u
.simple
.channel
= priv
->channel
;
590 usb_fill_bulk_urb(urb
, dev
->udev
,
591 usb_sndbulkpipe(dev
->udev
,
592 dev
->bulk_out
->bEndpointAddress
),
594 kvaser_usb_simple_msg_callback
, netdev
);
595 usb_anchor_urb(urb
, &priv
->tx_submitted
);
597 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
599 netdev_err(netdev
, "Error transmitting URB\n");
600 usb_unanchor_urb(urb
);
611 static void kvaser_usb_unlink_tx_urbs(struct kvaser_usb_net_priv
*priv
)
615 usb_kill_anchored_urbs(&priv
->tx_submitted
);
616 atomic_set(&priv
->active_tx_urbs
, 0);
618 for (i
= 0; i
< MAX_TX_URBS
; i
++)
619 priv
->tx_contexts
[i
].echo_index
= MAX_TX_URBS
;
622 static void kvaser_usb_rx_error_update_can_state(struct kvaser_usb_net_priv
*priv
,
623 const struct kvaser_usb_error_summary
*es
,
624 struct can_frame
*cf
)
626 struct net_device_stats
*stats
;
627 enum can_state cur_state
, new_state
, tx_state
, rx_state
;
629 netdev_dbg(priv
->netdev
, "Error status: 0x%02x\n", es
->status
);
631 stats
= &priv
->netdev
->stats
;
632 new_state
= cur_state
= priv
->can
.state
;
634 if (es
->status
& (M16C_STATE_BUS_OFF
| M16C_STATE_BUS_RESET
))
635 new_state
= CAN_STATE_BUS_OFF
;
636 else if (es
->status
& M16C_STATE_BUS_PASSIVE
)
637 new_state
= CAN_STATE_ERROR_PASSIVE
;
638 else if (es
->status
& M16C_STATE_BUS_ERROR
) {
639 if ((es
->txerr
>= 256) || (es
->rxerr
>= 256))
640 new_state
= CAN_STATE_BUS_OFF
;
641 else if ((es
->txerr
>= 128) || (es
->rxerr
>= 128))
642 new_state
= CAN_STATE_ERROR_PASSIVE
;
643 else if ((es
->txerr
>= 96) || (es
->rxerr
>= 96))
644 new_state
= CAN_STATE_ERROR_WARNING
;
645 else if (cur_state
> CAN_STATE_ERROR_ACTIVE
)
646 new_state
= CAN_STATE_ERROR_ACTIVE
;
650 new_state
= CAN_STATE_ERROR_ACTIVE
;
652 if (new_state
!= cur_state
) {
653 tx_state
= (es
->txerr
>= es
->rxerr
) ? new_state
: 0;
654 rx_state
= (es
->txerr
<= es
->rxerr
) ? new_state
: 0;
656 can_change_state(priv
->netdev
, cf
, tx_state
, rx_state
);
659 if (priv
->can
.restart_ms
&&
660 (cur_state
>= CAN_STATE_BUS_OFF
) &&
661 (new_state
< CAN_STATE_BUS_OFF
)) {
662 priv
->can
.can_stats
.restarts
++;
665 if (es
->error_factor
) {
666 priv
->can
.can_stats
.bus_error
++;
670 priv
->bec
.txerr
= es
->txerr
;
671 priv
->bec
.rxerr
= es
->rxerr
;
674 static void kvaser_usb_rx_error(const struct kvaser_usb
*dev
,
675 const struct kvaser_msg
*msg
)
677 struct can_frame
*cf
, tmp_cf
= { .can_id
= CAN_ERR_FLAG
, .can_dlc
= CAN_ERR_DLC
};
679 struct net_device_stats
*stats
;
680 struct kvaser_usb_net_priv
*priv
;
681 struct kvaser_usb_error_summary es
= { };
682 enum can_state old_state
, new_state
;
685 case CMD_CAN_ERROR_EVENT
:
686 es
.channel
= msg
->u
.error_event
.channel
;
687 es
.status
= msg
->u
.error_event
.status
;
688 es
.txerr
= msg
->u
.error_event
.tx_errors_count
;
689 es
.rxerr
= msg
->u
.error_event
.rx_errors_count
;
690 es
.error_factor
= msg
->u
.error_event
.error_factor
;
692 case CMD_LOG_MESSAGE
:
693 es
.channel
= msg
->u
.log_message
.channel
;
694 es
.status
= msg
->u
.log_message
.data
[0];
695 es
.txerr
= msg
->u
.log_message
.data
[2];
696 es
.rxerr
= msg
->u
.log_message
.data
[3];
697 es
.error_factor
= msg
->u
.log_message
.data
[1];
699 case CMD_CHIP_STATE_EVENT
:
700 es
.channel
= msg
->u
.chip_state_event
.channel
;
701 es
.status
= msg
->u
.chip_state_event
.status
;
702 es
.txerr
= msg
->u
.chip_state_event
.tx_errors_count
;
703 es
.rxerr
= msg
->u
.chip_state_event
.rx_errors_count
;
707 dev_err(dev
->udev
->dev
.parent
, "Invalid msg id (%d)\n",
712 if (es
.channel
>= dev
->nchannels
) {
713 dev_err(dev
->udev
->dev
.parent
,
714 "Invalid channel number (%d)\n", es
.channel
);
718 priv
= dev
->nets
[es
.channel
];
719 stats
= &priv
->netdev
->stats
;
721 /* Update all of the can interface's state and error counters before
722 * trying any memory allocation that can actually fail with -ENOMEM.
724 * We send a temporary stack-allocated error can frame to
725 * can_change_state() for the very same reason.
727 * TODO: Split can_change_state() responsibility between updating the
728 * can interface's state and counters, and the setting up of can error
729 * frame ID and data to userspace. Remove stack allocation afterwards.
731 old_state
= priv
->can
.state
;
732 kvaser_usb_rx_error_update_can_state(priv
, &es
, &tmp_cf
);
733 new_state
= priv
->can
.state
;
735 skb
= alloc_can_err_skb(priv
->netdev
, &cf
);
740 memcpy(cf
, &tmp_cf
, sizeof(*cf
));
742 if (new_state
!= old_state
) {
744 (M16C_STATE_BUS_OFF
| M16C_STATE_BUS_RESET
)) {
745 if (!priv
->can
.restart_ms
)
746 kvaser_usb_simple_msg_async(priv
, CMD_STOP_CHIP
);
747 netif_carrier_off(priv
->netdev
);
750 if (priv
->can
.restart_ms
&&
751 (old_state
>= CAN_STATE_BUS_OFF
) &&
752 (new_state
< CAN_STATE_BUS_OFF
)) {
753 cf
->can_id
|= CAN_ERR_RESTARTED
;
754 netif_carrier_on(priv
->netdev
);
758 if (es
.error_factor
) {
759 cf
->can_id
|= CAN_ERR_BUSERROR
| CAN_ERR_PROT
;
761 if (es
.error_factor
& M16C_EF_ACKE
)
762 cf
->data
[3] |= (CAN_ERR_PROT_LOC_ACK
);
763 if (es
.error_factor
& M16C_EF_CRCE
)
764 cf
->data
[3] |= (CAN_ERR_PROT_LOC_CRC_SEQ
|
765 CAN_ERR_PROT_LOC_CRC_DEL
);
766 if (es
.error_factor
& M16C_EF_FORME
)
767 cf
->data
[2] |= CAN_ERR_PROT_FORM
;
768 if (es
.error_factor
& M16C_EF_STFE
)
769 cf
->data
[2] |= CAN_ERR_PROT_STUFF
;
770 if (es
.error_factor
& M16C_EF_BITE0
)
771 cf
->data
[2] |= CAN_ERR_PROT_BIT0
;
772 if (es
.error_factor
& M16C_EF_BITE1
)
773 cf
->data
[2] |= CAN_ERR_PROT_BIT1
;
774 if (es
.error_factor
& M16C_EF_TRE
)
775 cf
->data
[2] |= CAN_ERR_PROT_TX
;
778 cf
->data
[6] = es
.txerr
;
779 cf
->data
[7] = es
.rxerr
;
782 stats
->rx_bytes
+= cf
->can_dlc
;
786 static void kvaser_usb_rx_can_err(const struct kvaser_usb_net_priv
*priv
,
787 const struct kvaser_msg
*msg
)
789 struct can_frame
*cf
;
791 struct net_device_stats
*stats
= &priv
->netdev
->stats
;
793 if (msg
->u
.rx_can
.flag
& (MSG_FLAG_ERROR_FRAME
|
795 netdev_err(priv
->netdev
, "Unknow error (flags: 0x%02x)\n",
802 if (msg
->u
.rx_can
.flag
& MSG_FLAG_OVERRUN
) {
803 stats
->rx_over_errors
++;
806 skb
= alloc_can_err_skb(priv
->netdev
, &cf
);
812 cf
->can_id
|= CAN_ERR_CRTL
;
813 cf
->data
[1] = CAN_ERR_CRTL_RX_OVERFLOW
;
816 stats
->rx_bytes
+= cf
->can_dlc
;
821 static void kvaser_usb_rx_can_msg(const struct kvaser_usb
*dev
,
822 const struct kvaser_msg
*msg
)
824 struct kvaser_usb_net_priv
*priv
;
825 struct can_frame
*cf
;
827 struct net_device_stats
*stats
;
828 u8 channel
= msg
->u
.rx_can
.channel
;
830 if (channel
>= dev
->nchannels
) {
831 dev_err(dev
->udev
->dev
.parent
,
832 "Invalid channel number (%d)\n", channel
);
836 priv
= dev
->nets
[channel
];
837 stats
= &priv
->netdev
->stats
;
839 if ((msg
->u
.rx_can
.flag
& MSG_FLAG_ERROR_FRAME
) &&
840 (msg
->id
== CMD_LOG_MESSAGE
)) {
841 kvaser_usb_rx_error(dev
, msg
);
843 } else if (msg
->u
.rx_can
.flag
& (MSG_FLAG_ERROR_FRAME
|
846 kvaser_usb_rx_can_err(priv
, msg
);
848 } else if (msg
->u
.rx_can
.flag
& ~MSG_FLAG_REMOTE_FRAME
) {
849 netdev_warn(priv
->netdev
,
850 "Unhandled frame (flags: 0x%02x)",
855 skb
= alloc_can_skb(priv
->netdev
, &cf
);
861 if (msg
->id
== CMD_LOG_MESSAGE
) {
862 cf
->can_id
= le32_to_cpu(msg
->u
.log_message
.id
);
863 if (cf
->can_id
& KVASER_EXTENDED_FRAME
)
864 cf
->can_id
&= CAN_EFF_MASK
| CAN_EFF_FLAG
;
866 cf
->can_id
&= CAN_SFF_MASK
;
868 cf
->can_dlc
= get_can_dlc(msg
->u
.log_message
.dlc
);
870 if (msg
->u
.log_message
.flags
& MSG_FLAG_REMOTE_FRAME
)
871 cf
->can_id
|= CAN_RTR_FLAG
;
873 memcpy(cf
->data
, &msg
->u
.log_message
.data
,
876 cf
->can_id
= ((msg
->u
.rx_can
.msg
[0] & 0x1f) << 6) |
877 (msg
->u
.rx_can
.msg
[1] & 0x3f);
879 if (msg
->id
== CMD_RX_EXT_MESSAGE
) {
881 cf
->can_id
|= ((msg
->u
.rx_can
.msg
[2] & 0x0f) << 14) |
882 ((msg
->u
.rx_can
.msg
[3] & 0xff) << 6) |
883 (msg
->u
.rx_can
.msg
[4] & 0x3f);
884 cf
->can_id
|= CAN_EFF_FLAG
;
887 cf
->can_dlc
= get_can_dlc(msg
->u
.rx_can
.msg
[5]);
889 if (msg
->u
.rx_can
.flag
& MSG_FLAG_REMOTE_FRAME
)
890 cf
->can_id
|= CAN_RTR_FLAG
;
892 memcpy(cf
->data
, &msg
->u
.rx_can
.msg
[6],
897 stats
->rx_bytes
+= cf
->can_dlc
;
901 static void kvaser_usb_start_chip_reply(const struct kvaser_usb
*dev
,
902 const struct kvaser_msg
*msg
)
904 struct kvaser_usb_net_priv
*priv
;
905 u8 channel
= msg
->u
.simple
.channel
;
907 if (channel
>= dev
->nchannels
) {
908 dev_err(dev
->udev
->dev
.parent
,
909 "Invalid channel number (%d)\n", channel
);
913 priv
= dev
->nets
[channel
];
915 if (completion_done(&priv
->start_comp
) &&
916 netif_queue_stopped(priv
->netdev
)) {
917 netif_wake_queue(priv
->netdev
);
919 netif_start_queue(priv
->netdev
);
920 complete(&priv
->start_comp
);
924 static void kvaser_usb_stop_chip_reply(const struct kvaser_usb
*dev
,
925 const struct kvaser_msg
*msg
)
927 struct kvaser_usb_net_priv
*priv
;
928 u8 channel
= msg
->u
.simple
.channel
;
930 if (channel
>= dev
->nchannels
) {
931 dev_err(dev
->udev
->dev
.parent
,
932 "Invalid channel number (%d)\n", channel
);
936 priv
= dev
->nets
[channel
];
938 complete(&priv
->stop_comp
);
941 static void kvaser_usb_handle_message(const struct kvaser_usb
*dev
,
942 const struct kvaser_msg
*msg
)
945 case CMD_START_CHIP_REPLY
:
946 kvaser_usb_start_chip_reply(dev
, msg
);
949 case CMD_STOP_CHIP_REPLY
:
950 kvaser_usb_stop_chip_reply(dev
, msg
);
953 case CMD_RX_STD_MESSAGE
:
954 case CMD_RX_EXT_MESSAGE
:
955 case CMD_LOG_MESSAGE
:
956 kvaser_usb_rx_can_msg(dev
, msg
);
959 case CMD_CHIP_STATE_EVENT
:
960 case CMD_CAN_ERROR_EVENT
:
961 kvaser_usb_rx_error(dev
, msg
);
964 case CMD_TX_ACKNOWLEDGE
:
965 kvaser_usb_tx_acknowledge(dev
, msg
);
969 dev_warn(dev
->udev
->dev
.parent
,
970 "Unhandled message (%d)\n", msg
->id
);
975 static void kvaser_usb_read_bulk_callback(struct urb
*urb
)
977 struct kvaser_usb
*dev
= urb
->context
;
978 struct kvaser_msg
*msg
;
982 switch (urb
->status
) {
989 dev_info(dev
->udev
->dev
.parent
, "Rx URB aborted (%d)\n",
994 while (pos
<= urb
->actual_length
- MSG_HEADER_LEN
) {
995 msg
= urb
->transfer_buffer
+ pos
;
1000 if (pos
+ msg
->len
> urb
->actual_length
) {
1001 dev_err(dev
->udev
->dev
.parent
, "Format error\n");
1005 kvaser_usb_handle_message(dev
, msg
);
1011 usb_fill_bulk_urb(urb
, dev
->udev
,
1012 usb_rcvbulkpipe(dev
->udev
,
1013 dev
->bulk_in
->bEndpointAddress
),
1014 urb
->transfer_buffer
, RX_BUFFER_SIZE
,
1015 kvaser_usb_read_bulk_callback
, dev
);
1017 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
1018 if (err
== -ENODEV
) {
1019 for (i
= 0; i
< dev
->nchannels
; i
++) {
1023 netif_device_detach(dev
->nets
[i
]->netdev
);
1026 dev_err(dev
->udev
->dev
.parent
,
1027 "Failed resubmitting read bulk urb: %d\n", err
);
1033 static int kvaser_usb_setup_rx_urbs(struct kvaser_usb
*dev
)
1037 if (dev
->rxinitdone
)
1040 for (i
= 0; i
< MAX_RX_URBS
; i
++) {
1041 struct urb
*urb
= NULL
;
1045 urb
= usb_alloc_urb(0, GFP_KERNEL
);
1047 dev_warn(dev
->udev
->dev
.parent
,
1048 "No memory left for URBs\n");
1053 buf
= usb_alloc_coherent(dev
->udev
, RX_BUFFER_SIZE
,
1054 GFP_KERNEL
, &buf_dma
);
1056 dev_warn(dev
->udev
->dev
.parent
,
1057 "No memory left for USB buffer\n");
1063 usb_fill_bulk_urb(urb
, dev
->udev
,
1064 usb_rcvbulkpipe(dev
->udev
,
1065 dev
->bulk_in
->bEndpointAddress
),
1066 buf
, RX_BUFFER_SIZE
,
1067 kvaser_usb_read_bulk_callback
,
1069 urb
->transfer_dma
= buf_dma
;
1070 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1071 usb_anchor_urb(urb
, &dev
->rx_submitted
);
1073 err
= usb_submit_urb(urb
, GFP_KERNEL
);
1075 usb_unanchor_urb(urb
);
1076 usb_free_coherent(dev
->udev
, RX_BUFFER_SIZE
, buf
,
1082 dev
->rxbuf
[i
] = buf
;
1083 dev
->rxbuf_dma
[i
] = buf_dma
;
1089 dev_warn(dev
->udev
->dev
.parent
,
1090 "Cannot setup read URBs, error %d\n", err
);
1092 } else if (i
< MAX_RX_URBS
) {
1093 dev_warn(dev
->udev
->dev
.parent
,
1094 "RX performances may be slow\n");
1097 dev
->rxinitdone
= true;
1102 static int kvaser_usb_set_opt_mode(const struct kvaser_usb_net_priv
*priv
)
1104 struct kvaser_msg
*msg
;
1107 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
1111 msg
->id
= CMD_SET_CTRL_MODE
;
1112 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_ctrl_mode
);
1113 msg
->u
.ctrl_mode
.tid
= 0xff;
1114 msg
->u
.ctrl_mode
.channel
= priv
->channel
;
1116 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_LISTENONLY
)
1117 msg
->u
.ctrl_mode
.ctrl_mode
= KVASER_CTRL_MODE_SILENT
;
1119 msg
->u
.ctrl_mode
.ctrl_mode
= KVASER_CTRL_MODE_NORMAL
;
1121 rc
= kvaser_usb_send_msg(priv
->dev
, msg
);
1127 static int kvaser_usb_start_chip(struct kvaser_usb_net_priv
*priv
)
1131 init_completion(&priv
->start_comp
);
1133 err
= kvaser_usb_send_simple_msg(priv
->dev
, CMD_START_CHIP
,
1138 if (!wait_for_completion_timeout(&priv
->start_comp
,
1139 msecs_to_jiffies(START_TIMEOUT
)))
1145 static int kvaser_usb_open(struct net_device
*netdev
)
1147 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1148 struct kvaser_usb
*dev
= priv
->dev
;
1151 err
= open_candev(netdev
);
1155 err
= kvaser_usb_setup_rx_urbs(dev
);
1159 err
= kvaser_usb_set_opt_mode(priv
);
1163 err
= kvaser_usb_start_chip(priv
);
1165 netdev_warn(netdev
, "Cannot start device, error %d\n", err
);
1169 priv
->can
.state
= CAN_STATE_ERROR_ACTIVE
;
1174 close_candev(netdev
);
1178 static void kvaser_usb_unlink_all_urbs(struct kvaser_usb
*dev
)
1182 usb_kill_anchored_urbs(&dev
->rx_submitted
);
1184 for (i
= 0; i
< MAX_RX_URBS
; i
++)
1185 usb_free_coherent(dev
->udev
, RX_BUFFER_SIZE
,
1189 for (i
= 0; i
< MAX_NET_DEVICES
; i
++) {
1190 struct kvaser_usb_net_priv
*priv
= dev
->nets
[i
];
1193 kvaser_usb_unlink_tx_urbs(priv
);
1197 static int kvaser_usb_stop_chip(struct kvaser_usb_net_priv
*priv
)
1201 init_completion(&priv
->stop_comp
);
1203 err
= kvaser_usb_send_simple_msg(priv
->dev
, CMD_STOP_CHIP
,
1208 if (!wait_for_completion_timeout(&priv
->stop_comp
,
1209 msecs_to_jiffies(STOP_TIMEOUT
)))
1215 static int kvaser_usb_flush_queue(struct kvaser_usb_net_priv
*priv
)
1217 struct kvaser_msg
*msg
;
1220 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
1224 msg
->id
= CMD_FLUSH_QUEUE
;
1225 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_flush_queue
);
1226 msg
->u
.flush_queue
.channel
= priv
->channel
;
1227 msg
->u
.flush_queue
.flags
= 0x00;
1229 rc
= kvaser_usb_send_msg(priv
->dev
, msg
);
1235 static int kvaser_usb_close(struct net_device
*netdev
)
1237 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1238 struct kvaser_usb
*dev
= priv
->dev
;
1241 netif_stop_queue(netdev
);
1243 err
= kvaser_usb_flush_queue(priv
);
1245 netdev_warn(netdev
, "Cannot flush queue, error %d\n", err
);
1247 if (kvaser_usb_send_simple_msg(dev
, CMD_RESET_CHIP
, priv
->channel
))
1248 netdev_warn(netdev
, "Cannot reset card, error %d\n", err
);
1250 err
= kvaser_usb_stop_chip(priv
);
1252 netdev_warn(netdev
, "Cannot stop device, error %d\n", err
);
1254 /* reset tx contexts */
1255 kvaser_usb_unlink_tx_urbs(priv
);
1257 priv
->can
.state
= CAN_STATE_STOPPED
;
1258 close_candev(priv
->netdev
);
1263 static void kvaser_usb_write_bulk_callback(struct urb
*urb
)
1265 struct kvaser_usb_tx_urb_context
*context
= urb
->context
;
1266 struct kvaser_usb_net_priv
*priv
;
1267 struct net_device
*netdev
;
1269 if (WARN_ON(!context
))
1272 priv
= context
->priv
;
1273 netdev
= priv
->netdev
;
1275 kfree(urb
->transfer_buffer
);
1277 if (!netif_device_present(netdev
))
1281 netdev_info(netdev
, "Tx URB aborted (%d)\n", urb
->status
);
1284 static netdev_tx_t
kvaser_usb_start_xmit(struct sk_buff
*skb
,
1285 struct net_device
*netdev
)
1287 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1288 struct kvaser_usb
*dev
= priv
->dev
;
1289 struct net_device_stats
*stats
= &netdev
->stats
;
1290 struct can_frame
*cf
= (struct can_frame
*)skb
->data
;
1291 struct kvaser_usb_tx_urb_context
*context
= NULL
;
1294 struct kvaser_msg
*msg
;
1296 int ret
= NETDEV_TX_OK
;
1298 if (can_dropped_invalid_skb(netdev
, skb
))
1299 return NETDEV_TX_OK
;
1301 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
1303 netdev_err(netdev
, "No memory left for URBs\n");
1304 stats
->tx_dropped
++;
1306 return NETDEV_TX_OK
;
1309 buf
= kmalloc(sizeof(struct kvaser_msg
), GFP_ATOMIC
);
1311 stats
->tx_dropped
++;
1317 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_tx_can
);
1318 msg
->u
.tx_can
.flags
= 0;
1319 msg
->u
.tx_can
.channel
= priv
->channel
;
1321 if (cf
->can_id
& CAN_EFF_FLAG
) {
1322 msg
->id
= CMD_TX_EXT_MESSAGE
;
1323 msg
->u
.tx_can
.msg
[0] = (cf
->can_id
>> 24) & 0x1f;
1324 msg
->u
.tx_can
.msg
[1] = (cf
->can_id
>> 18) & 0x3f;
1325 msg
->u
.tx_can
.msg
[2] = (cf
->can_id
>> 14) & 0x0f;
1326 msg
->u
.tx_can
.msg
[3] = (cf
->can_id
>> 6) & 0xff;
1327 msg
->u
.tx_can
.msg
[4] = cf
->can_id
& 0x3f;
1329 msg
->id
= CMD_TX_STD_MESSAGE
;
1330 msg
->u
.tx_can
.msg
[0] = (cf
->can_id
>> 6) & 0x1f;
1331 msg
->u
.tx_can
.msg
[1] = cf
->can_id
& 0x3f;
1334 msg
->u
.tx_can
.msg
[5] = cf
->can_dlc
;
1335 memcpy(&msg
->u
.tx_can
.msg
[6], cf
->data
, cf
->can_dlc
);
1337 if (cf
->can_id
& CAN_RTR_FLAG
)
1338 msg
->u
.tx_can
.flags
|= MSG_FLAG_REMOTE_FRAME
;
1340 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_contexts
); i
++) {
1341 if (priv
->tx_contexts
[i
].echo_index
== MAX_TX_URBS
) {
1342 context
= &priv
->tx_contexts
[i
];
1347 /* This should never happen; it implies a flow control bug */
1349 netdev_warn(netdev
, "cannot find free context\n");
1350 ret
= NETDEV_TX_BUSY
;
1354 context
->priv
= priv
;
1355 context
->echo_index
= i
;
1356 context
->dlc
= cf
->can_dlc
;
1358 msg
->u
.tx_can
.tid
= context
->echo_index
;
1360 usb_fill_bulk_urb(urb
, dev
->udev
,
1361 usb_sndbulkpipe(dev
->udev
,
1362 dev
->bulk_out
->bEndpointAddress
),
1364 kvaser_usb_write_bulk_callback
, context
);
1365 usb_anchor_urb(urb
, &priv
->tx_submitted
);
1367 can_put_echo_skb(skb
, netdev
, context
->echo_index
);
1369 atomic_inc(&priv
->active_tx_urbs
);
1371 if (atomic_read(&priv
->active_tx_urbs
) >= MAX_TX_URBS
)
1372 netif_stop_queue(netdev
);
1374 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
1375 if (unlikely(err
)) {
1376 can_free_echo_skb(netdev
, context
->echo_index
);
1378 atomic_dec(&priv
->active_tx_urbs
);
1379 usb_unanchor_urb(urb
);
1381 stats
->tx_dropped
++;
1384 netif_device_detach(netdev
);
1386 netdev_warn(netdev
, "Failed tx_urb %d\n", err
);
1393 return NETDEV_TX_OK
;
1402 static const struct net_device_ops kvaser_usb_netdev_ops
= {
1403 .ndo_open
= kvaser_usb_open
,
1404 .ndo_stop
= kvaser_usb_close
,
1405 .ndo_start_xmit
= kvaser_usb_start_xmit
,
1406 .ndo_change_mtu
= can_change_mtu
,
1409 static const struct can_bittiming_const kvaser_usb_bittiming_const
= {
1410 .name
= "kvaser_usb",
1411 .tseg1_min
= KVASER_USB_TSEG1_MIN
,
1412 .tseg1_max
= KVASER_USB_TSEG1_MAX
,
1413 .tseg2_min
= KVASER_USB_TSEG2_MIN
,
1414 .tseg2_max
= KVASER_USB_TSEG2_MAX
,
1415 .sjw_max
= KVASER_USB_SJW_MAX
,
1416 .brp_min
= KVASER_USB_BRP_MIN
,
1417 .brp_max
= KVASER_USB_BRP_MAX
,
1418 .brp_inc
= KVASER_USB_BRP_INC
,
1421 static int kvaser_usb_set_bittiming(struct net_device
*netdev
)
1423 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1424 struct can_bittiming
*bt
= &priv
->can
.bittiming
;
1425 struct kvaser_usb
*dev
= priv
->dev
;
1426 struct kvaser_msg
*msg
;
1429 msg
= kmalloc(sizeof(*msg
), GFP_KERNEL
);
1433 msg
->id
= CMD_SET_BUS_PARAMS
;
1434 msg
->len
= MSG_HEADER_LEN
+ sizeof(struct kvaser_msg_busparams
);
1435 msg
->u
.busparams
.channel
= priv
->channel
;
1436 msg
->u
.busparams
.tid
= 0xff;
1437 msg
->u
.busparams
.bitrate
= cpu_to_le32(bt
->bitrate
);
1438 msg
->u
.busparams
.sjw
= bt
->sjw
;
1439 msg
->u
.busparams
.tseg1
= bt
->prop_seg
+ bt
->phase_seg1
;
1440 msg
->u
.busparams
.tseg2
= bt
->phase_seg2
;
1442 if (priv
->can
.ctrlmode
& CAN_CTRLMODE_3_SAMPLES
)
1443 msg
->u
.busparams
.no_samp
= 3;
1445 msg
->u
.busparams
.no_samp
= 1;
1447 rc
= kvaser_usb_send_msg(dev
, msg
);
1453 static int kvaser_usb_set_mode(struct net_device
*netdev
,
1456 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1460 case CAN_MODE_START
:
1461 err
= kvaser_usb_simple_msg_async(priv
, CMD_START_CHIP
);
1472 static int kvaser_usb_get_berr_counter(const struct net_device
*netdev
,
1473 struct can_berr_counter
*bec
)
1475 struct kvaser_usb_net_priv
*priv
= netdev_priv(netdev
);
1482 static void kvaser_usb_remove_interfaces(struct kvaser_usb
*dev
)
1486 for (i
= 0; i
< dev
->nchannels
; i
++) {
1490 unregister_netdev(dev
->nets
[i
]->netdev
);
1493 kvaser_usb_unlink_all_urbs(dev
);
1495 for (i
= 0; i
< dev
->nchannels
; i
++) {
1499 free_candev(dev
->nets
[i
]->netdev
);
1503 static int kvaser_usb_init_one(struct usb_interface
*intf
,
1504 const struct usb_device_id
*id
, int channel
)
1506 struct kvaser_usb
*dev
= usb_get_intfdata(intf
);
1507 struct net_device
*netdev
;
1508 struct kvaser_usb_net_priv
*priv
;
1511 err
= kvaser_usb_send_simple_msg(dev
, CMD_RESET_CHIP
, channel
);
1515 netdev
= alloc_candev(sizeof(*priv
), MAX_TX_URBS
);
1517 dev_err(&intf
->dev
, "Cannot alloc candev\n");
1521 priv
= netdev_priv(netdev
);
1523 init_completion(&priv
->start_comp
);
1524 init_completion(&priv
->stop_comp
);
1526 init_usb_anchor(&priv
->tx_submitted
);
1527 atomic_set(&priv
->active_tx_urbs
, 0);
1529 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_contexts
); i
++)
1530 priv
->tx_contexts
[i
].echo_index
= MAX_TX_URBS
;
1533 priv
->netdev
= netdev
;
1534 priv
->channel
= channel
;
1536 priv
->can
.state
= CAN_STATE_STOPPED
;
1537 priv
->can
.clock
.freq
= CAN_USB_CLOCK
;
1538 priv
->can
.bittiming_const
= &kvaser_usb_bittiming_const
;
1539 priv
->can
.do_set_bittiming
= kvaser_usb_set_bittiming
;
1540 priv
->can
.do_set_mode
= kvaser_usb_set_mode
;
1541 if (id
->driver_info
& KVASER_HAS_TXRX_ERRORS
)
1542 priv
->can
.do_get_berr_counter
= kvaser_usb_get_berr_counter
;
1543 priv
->can
.ctrlmode_supported
= CAN_CTRLMODE_3_SAMPLES
;
1544 if (id
->driver_info
& KVASER_HAS_SILENT_MODE
)
1545 priv
->can
.ctrlmode_supported
|= CAN_CTRLMODE_LISTENONLY
;
1547 netdev
->flags
|= IFF_ECHO
;
1549 netdev
->netdev_ops
= &kvaser_usb_netdev_ops
;
1551 SET_NETDEV_DEV(netdev
, &intf
->dev
);
1552 netdev
->dev_id
= channel
;
1554 dev
->nets
[channel
] = priv
;
1556 err
= register_candev(netdev
);
1558 dev_err(&intf
->dev
, "Failed to register can device\n");
1559 free_candev(netdev
);
1560 dev
->nets
[channel
] = NULL
;
1564 netdev_dbg(netdev
, "device registered\n");
1569 static int kvaser_usb_get_endpoints(const struct usb_interface
*intf
,
1570 struct usb_endpoint_descriptor
**in
,
1571 struct usb_endpoint_descriptor
**out
)
1573 const struct usb_host_interface
*iface_desc
;
1574 struct usb_endpoint_descriptor
*endpoint
;
1577 iface_desc
= &intf
->altsetting
[0];
1579 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
1580 endpoint
= &iface_desc
->endpoint
[i
].desc
;
1582 if (!*in
&& usb_endpoint_is_bulk_in(endpoint
))
1585 if (!*out
&& usb_endpoint_is_bulk_out(endpoint
))
1588 /* use first bulk endpoint for in and out */
1596 static int kvaser_usb_probe(struct usb_interface
*intf
,
1597 const struct usb_device_id
*id
)
1599 struct kvaser_usb
*dev
;
1603 dev
= devm_kzalloc(&intf
->dev
, sizeof(*dev
), GFP_KERNEL
);
1607 err
= kvaser_usb_get_endpoints(intf
, &dev
->bulk_in
, &dev
->bulk_out
);
1609 dev_err(&intf
->dev
, "Cannot get usb endpoint(s)");
1613 dev
->udev
= interface_to_usbdev(intf
);
1615 init_usb_anchor(&dev
->rx_submitted
);
1617 usb_set_intfdata(intf
, dev
);
1619 /* On some x86 laptops, plugging a Kvaser device again after
1620 * an unplug makes the firmware always ignore the very first
1621 * command. For such a case, provide some room for retries
1622 * instead of completely exiting the driver.
1625 err
= kvaser_usb_get_software_info(dev
);
1626 } while (--retry
&& err
== -ETIMEDOUT
);
1630 "Cannot get software infos, error %d\n", err
);
1634 err
= kvaser_usb_get_card_info(dev
);
1637 "Cannot get card infos, error %d\n", err
);
1641 dev_dbg(&intf
->dev
, "Firmware version: %d.%d.%d\n",
1642 ((dev
->fw_version
>> 24) & 0xff),
1643 ((dev
->fw_version
>> 16) & 0xff),
1644 (dev
->fw_version
& 0xffff));
1646 for (i
= 0; i
< dev
->nchannels
; i
++) {
1647 err
= kvaser_usb_init_one(intf
, id
, i
);
1649 kvaser_usb_remove_interfaces(dev
);
1657 static void kvaser_usb_disconnect(struct usb_interface
*intf
)
1659 struct kvaser_usb
*dev
= usb_get_intfdata(intf
);
1661 usb_set_intfdata(intf
, NULL
);
1666 kvaser_usb_remove_interfaces(dev
);
1669 static struct usb_driver kvaser_usb_driver
= {
1670 .name
= "kvaser_usb",
1671 .probe
= kvaser_usb_probe
,
1672 .disconnect
= kvaser_usb_disconnect
,
1673 .id_table
= kvaser_usb_table
,
1676 module_usb_driver(kvaser_usb_driver
);
1678 MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
1679 MODULE_DESCRIPTION("CAN driver for Kvaser CAN/USB devices");
1680 MODULE_LICENSE("GPL v2");