?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / net / can / usb / kvaser_usb / kvaser_usb_leaf.c
blob1b9957f12459a9780ac9e94a73fa773cca6483de
1 // SPDX-License-Identifier: GPL-2.0
2 /* Parts of this driver are based on the following:
3 * - Kvaser linux leaf driver (version 4.78)
4 * - CAN driver for esd CAN-USB/2
5 * - Kvaser linux usbcanII driver (version 5.3)
6 *
7 * Copyright (C) 2002-2018 KVASER AB, Sweden. All rights reserved.
8 * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
9 * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be>
10 * Copyright (C) 2015 Valeo S.A.
11 */
12
13 #include <linux/completion.h>
14 #include <linux/device.h>
15 #include <linux/gfp.h>
16 #include <linux/jiffies.h>
17 #include <linux/kernel.h>
18 #include <linux/netdevice.h>
19 #include <linux/spinlock.h>
20 #include <linux/string.h>
21 #include <linux/types.h>
22 #include <linux/usb.h>
23
24 #include <linux/can.h>
25 #include <linux/can/dev.h>
26 #include <linux/can/error.h>
27 #include <linux/can/netlink.h>
28
29 #include "kvaser_usb.h"
30
31 /* Forward declaration */
32 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg;
33
34 #define CAN_USB_CLOCK 8000000
35 #define MAX_USBCAN_NET_DEVICES 2
36
37 /* Command header size */
38 #define CMD_HEADER_LEN 2
39
40 /* Kvaser CAN message flags */
41 #define MSG_FLAG_ERROR_FRAME BIT(0)
42 #define MSG_FLAG_OVERRUN BIT(1)
43 #define MSG_FLAG_NERR BIT(2)
44 #define MSG_FLAG_WAKEUP BIT(3)
45 #define MSG_FLAG_REMOTE_FRAME BIT(4)
46 #define MSG_FLAG_RESERVED BIT(5)
47 #define MSG_FLAG_TX_ACK BIT(6)
48 #define MSG_FLAG_TX_REQUEST BIT(7)
49
50 /* CAN states (M16C CxSTRH register) */
51 #define M16C_STATE_BUS_RESET BIT(0)
52 #define M16C_STATE_BUS_ERROR BIT(4)
53 #define M16C_STATE_BUS_PASSIVE BIT(5)
54 #define M16C_STATE_BUS_OFF BIT(6)
55
56 /* Leaf/usbcan command ids */
57 #define CMD_RX_STD_MESSAGE 12
58 #define CMD_TX_STD_MESSAGE 13
59 #define CMD_RX_EXT_MESSAGE 14
60 #define CMD_TX_EXT_MESSAGE 15
61 #define CMD_SET_BUS_PARAMS 16
62 #define CMD_CHIP_STATE_EVENT 20
63 #define CMD_SET_CTRL_MODE 21
64 #define CMD_RESET_CHIP 24
65 #define CMD_START_CHIP 26
66 #define CMD_START_CHIP_REPLY 27
67 #define CMD_STOP_CHIP 28
68 #define CMD_STOP_CHIP_REPLY 29
69
70 #define CMD_USBCAN_CLOCK_OVERFLOW_EVENT 33
71
72 #define CMD_GET_CARD_INFO 34
73 #define CMD_GET_CARD_INFO_REPLY 35
74 #define CMD_GET_SOFTWARE_INFO 38
75 #define CMD_GET_SOFTWARE_INFO_REPLY 39
76 #define CMD_FLUSH_QUEUE 48
77 #define CMD_TX_ACKNOWLEDGE 50
78 #define CMD_CAN_ERROR_EVENT 51
79 #define CMD_FLUSH_QUEUE_REPLY 68
80
81 #define CMD_LEAF_LOG_MESSAGE 106
82
83 /* error factors */
84 #define M16C_EF_ACKE BIT(0)
85 #define M16C_EF_CRCE BIT(1)
86 #define M16C_EF_FORME BIT(2)
87 #define M16C_EF_STFE BIT(3)
88 #define M16C_EF_BITE0 BIT(4)
89 #define M16C_EF_BITE1 BIT(5)
90 #define M16C_EF_RCVE BIT(6)
91 #define M16C_EF_TRE BIT(7)
92
93 /* Only Leaf-based devices can report M16C error factors,
94 * thus define our own error status flags for USBCANII
95 */
96 #define USBCAN_ERROR_STATE_NONE 0
97 #define USBCAN_ERROR_STATE_TX_ERROR BIT(0)
98 #define USBCAN_ERROR_STATE_RX_ERROR BIT(1)
99 #define USBCAN_ERROR_STATE_BUSERROR BIT(2)
100
101 /* bittiming parameters */
102 #define KVASER_USB_TSEG1_MIN 1
103 #define KVASER_USB_TSEG1_MAX 16
104 #define KVASER_USB_TSEG2_MIN 1
105 #define KVASER_USB_TSEG2_MAX 8
106 #define KVASER_USB_SJW_MAX 4
107 #define KVASER_USB_BRP_MIN 1
108 #define KVASER_USB_BRP_MAX 64
109 #define KVASER_USB_BRP_INC 1
110
111 /* ctrl modes */
112 #define KVASER_CTRL_MODE_NORMAL 1
113 #define KVASER_CTRL_MODE_SILENT 2
114 #define KVASER_CTRL_MODE_SELFRECEPTION 3
115 #define KVASER_CTRL_MODE_OFF 4
116
117 /* Extended CAN identifier flag */
118 #define KVASER_EXTENDED_FRAME BIT(31)
119
120 struct kvaser_cmd_simple {
121 u8 tid;
122 u8 channel;
123 } __packed;
124
125 struct kvaser_cmd_cardinfo {
126 u8 tid;
127 u8 nchannels;
128 __le32 serial_number;
129 __le32 padding0;
130 __le32 clock_resolution;
131 __le32 mfgdate;
132 u8 ean[8];
133 u8 hw_revision;
134 union {
135 struct {
136 u8 usb_hs_mode;
137 } __packed leaf1;
138 struct {
139 u8 padding;
140 } __packed usbcan1;
141 } __packed;
142 __le16 padding1;
143 } __packed;
144
145 struct leaf_cmd_softinfo {
146 u8 tid;
147 u8 padding0;
148 __le32 sw_options;
149 __le32 fw_version;
150 __le16 max_outstanding_tx;
151 __le16 padding1[9];
152 } __packed;
153
154 struct usbcan_cmd_softinfo {
155 u8 tid;
156 u8 fw_name[5];
157 __le16 max_outstanding_tx;
158 u8 padding[6];
159 __le32 fw_version;
160 __le16 checksum;
161 __le16 sw_options;
162 } __packed;
163
164 struct kvaser_cmd_busparams {
165 u8 tid;
166 u8 channel;
167 __le32 bitrate;
168 u8 tseg1;
169 u8 tseg2;
170 u8 sjw;
171 u8 no_samp;
172 } __packed;
173
174 struct kvaser_cmd_tx_can {
175 u8 channel;
176 u8 tid;
177 u8 data[14];
178 union {
179 struct {
180 u8 padding;
181 u8 flags;
182 } __packed leaf;
183 struct {
184 u8 flags;
185 u8 padding;
186 } __packed usbcan;
187 } __packed;
188 } __packed;
189
190 struct kvaser_cmd_rx_can_header {
191 u8 channel;
192 u8 flag;
193 } __packed;
194
195 struct leaf_cmd_rx_can {
196 u8 channel;
197 u8 flag;
198
199 __le16 time[3];
200 u8 data[14];
201 } __packed;
202
203 struct usbcan_cmd_rx_can {
204 u8 channel;
205 u8 flag;
206
207 u8 data[14];
208 __le16 time;
209 } __packed;
210
211 struct leaf_cmd_chip_state_event {
212 u8 tid;
213 u8 channel;
214
215 __le16 time[3];
216 u8 tx_errors_count;
217 u8 rx_errors_count;
218
219 u8 status;
220 u8 padding[3];
221 } __packed;
222
223 struct usbcan_cmd_chip_state_event {
224 u8 tid;
225 u8 channel;
226
227 u8 tx_errors_count;
228 u8 rx_errors_count;
229 __le16 time;
230
231 u8 status;
232 u8 padding[3];
233 } __packed;
234
235 struct kvaser_cmd_tx_acknowledge_header {
236 u8 channel;
237 u8 tid;
238 } __packed;
239
240 struct leaf_cmd_error_event {
241 u8 tid;
242 u8 flags;
243 __le16 time[3];
244 u8 channel;
245 u8 padding;
246 u8 tx_errors_count;
247 u8 rx_errors_count;
248 u8 status;
249 u8 error_factor;
250 } __packed;
251
252 struct usbcan_cmd_error_event {
253 u8 tid;
254 u8 padding;
255 u8 tx_errors_count_ch0;
256 u8 rx_errors_count_ch0;
257 u8 tx_errors_count_ch1;
258 u8 rx_errors_count_ch1;
259 u8 status_ch0;
260 u8 status_ch1;
261 __le16 time;
262 } __packed;
263
264 struct kvaser_cmd_ctrl_mode {
265 u8 tid;
266 u8 channel;
267 u8 ctrl_mode;
268 u8 padding[3];
269 } __packed;
270
271 struct kvaser_cmd_flush_queue {
272 u8 tid;
273 u8 channel;
274 u8 flags;
275 u8 padding[3];
276 } __packed;
277
278 struct leaf_cmd_log_message {
279 u8 channel;
280 u8 flags;
281 __le16 time[3];
282 u8 dlc;
283 u8 time_offset;
284 __le32 id;
285 u8 data[8];
286 } __packed;
287
288 struct kvaser_cmd {
289 u8 len;
290 u8 id;
291 union {
292 struct kvaser_cmd_simple simple;
293 struct kvaser_cmd_cardinfo cardinfo;
294 struct kvaser_cmd_busparams busparams;
295
296 struct kvaser_cmd_rx_can_header rx_can_header;
297 struct kvaser_cmd_tx_acknowledge_header tx_acknowledge_header;
298
299 union {
300 struct leaf_cmd_softinfo softinfo;
301 struct leaf_cmd_rx_can rx_can;
302 struct leaf_cmd_chip_state_event chip_state_event;
303 struct leaf_cmd_error_event error_event;
304 struct leaf_cmd_log_message log_message;
305 } __packed leaf;
306
307 union {
308 struct usbcan_cmd_softinfo softinfo;
309 struct usbcan_cmd_rx_can rx_can;
310 struct usbcan_cmd_chip_state_event chip_state_event;
311 struct usbcan_cmd_error_event error_event;
312 } __packed usbcan;
313
314 struct kvaser_cmd_tx_can tx_can;
315 struct kvaser_cmd_ctrl_mode ctrl_mode;
316 struct kvaser_cmd_flush_queue flush_queue;
317 } u;
318 } __packed;
319
320 /* Summary of a kvaser error event, for a unified Leaf/Usbcan error
321 * handling. Some discrepancies between the two families exist:
322 *
323 * - USBCAN firmware does not report M16C "error factors"
324 * - USBCAN controllers has difficulties reporting if the raised error
325 * event is for ch0 or ch1. They leave such arbitration to the OS
326 * driver by letting it compare error counters with previous values
327 * and decide the error event's channel. Thus for USBCAN, the channel
328 * field is only advisory.
329 */
330 struct kvaser_usb_err_summary {
331 u8 channel, status, txerr, rxerr;
332 union {
333 struct {
334 u8 error_factor;
335 } leaf;
336 struct {
337 u8 other_ch_status;
338 u8 error_state;
339 } usbcan;
340 };
341 };
342
343 static void *
344 kvaser_usb_leaf_frame_to_cmd(const struct kvaser_usb_net_priv *priv,
345 const struct sk_buff *skb, int *frame_len,
346 int *cmd_len, u16 transid)
347 {
348 struct kvaser_usb *dev = priv->dev;
349 struct kvaser_cmd *cmd;
350 u8 *cmd_tx_can_flags = NULL; /* GCC */
351 struct can_frame *cf = (struct can_frame *)skb->data;
352
353 *frame_len = cf->can_dlc;
354
355 cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);
356 if (cmd) {
357 cmd->u.tx_can.tid = transid & 0xff;
358 cmd->len = *cmd_len = CMD_HEADER_LEN +
359 sizeof(struct kvaser_cmd_tx_can);
360 cmd->u.tx_can.channel = priv->channel;
361
362 switch (dev->card_data.leaf.family) {
363 case KVASER_LEAF:
364 cmd_tx_can_flags = &cmd->u.tx_can.leaf.flags;
365 break;
366 case KVASER_USBCAN:
367 cmd_tx_can_flags = &cmd->u.tx_can.usbcan.flags;
368 break;
369 }
370
371 *cmd_tx_can_flags = 0;
372
373 if (cf->can_id & CAN_EFF_FLAG) {
374 cmd->id = CMD_TX_EXT_MESSAGE;
375 cmd->u.tx_can.data[0] = (cf->can_id >> 24) & 0x1f;
376 cmd->u.tx_can.data[1] = (cf->can_id >> 18) & 0x3f;
377 cmd->u.tx_can.data[2] = (cf->can_id >> 14) & 0x0f;
378 cmd->u.tx_can.data[3] = (cf->can_id >> 6) & 0xff;
379 cmd->u.tx_can.data[4] = cf->can_id & 0x3f;
380 } else {
381 cmd->id = CMD_TX_STD_MESSAGE;
382 cmd->u.tx_can.data[0] = (cf->can_id >> 6) & 0x1f;
383 cmd->u.tx_can.data[1] = cf->can_id & 0x3f;
384 }
385
386 cmd->u.tx_can.data[5] = cf->can_dlc;
387 memcpy(&cmd->u.tx_can.data[6], cf->data, cf->can_dlc);
388
389 if (cf->can_id & CAN_RTR_FLAG)
390 *cmd_tx_can_flags |= MSG_FLAG_REMOTE_FRAME;
391 }
392 return cmd;
393 }
394
395 static int kvaser_usb_leaf_wait_cmd(const struct kvaser_usb *dev, u8 id,
396 struct kvaser_cmd *cmd)
397 {
398 struct kvaser_cmd *tmp;
399 void *buf;
400 int actual_len;
401 int err;
402 int pos;
403 unsigned long to = jiffies + msecs_to_jiffies(KVASER_USB_TIMEOUT);
404
405 buf = kzalloc(KVASER_USB_RX_BUFFER_SIZE, GFP_KERNEL);
406 if (!buf)
407 return -ENOMEM;
408
409 do {
410 err = kvaser_usb_recv_cmd(dev, buf, KVASER_USB_RX_BUFFER_SIZE,
411 &actual_len);
412 if (err < 0)
413 goto end;
414
415 pos = 0;
416 while (pos <= actual_len - CMD_HEADER_LEN) {
417 tmp = buf + pos;
418
419 /* Handle commands crossing the USB endpoint max packet
420 * size boundary. Check kvaser_usb_read_bulk_callback()
421 * for further details.
422 */
423 if (tmp->len == 0) {
424 pos = round_up(pos,
425 le16_to_cpu
426 (dev->bulk_in->wMaxPacketSize));
427 continue;
428 }
429
430 if (pos + tmp->len > actual_len) {
431 dev_err_ratelimited(&dev->intf->dev,
432 "Format error\n");
433 break;
434 }
435
436 if (tmp->id == id) {
437 memcpy(cmd, tmp, tmp->len);
438 goto end;
439 }
440
441 pos += tmp->len;
442 }
443 } while (time_before(jiffies, to));
444
445 err = -EINVAL;
446
447 end:
448 kfree(buf);
449
450 return err;
451 }
452
453 static int kvaser_usb_leaf_send_simple_cmd(const struct kvaser_usb *dev,
454 u8 cmd_id, int channel)
455 {
456 struct kvaser_cmd *cmd;
457 int rc;
458
459 cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
460 if (!cmd)
461 return -ENOMEM;
462
463 cmd->id = cmd_id;
464 cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple);
465 cmd->u.simple.channel = channel;
466 cmd->u.simple.tid = 0xff;
467
468 rc = kvaser_usb_send_cmd(dev, cmd, cmd->len);
469
470 kfree(cmd);
471 return rc;
472 }
473
474 static int kvaser_usb_leaf_get_software_info_inner(struct kvaser_usb *dev)
475 {
476 struct kvaser_cmd cmd;
477 int err;
478
479 err = kvaser_usb_leaf_send_simple_cmd(dev, CMD_GET_SOFTWARE_INFO, 0);
480 if (err)
481 return err;
482
483 err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_SOFTWARE_INFO_REPLY, &cmd);
484 if (err)
485 return err;
486
487 switch (dev->card_data.leaf.family) {
488 case KVASER_LEAF:
489 dev->fw_version = le32_to_cpu(cmd.u.leaf.softinfo.fw_version);
490 dev->max_tx_urbs =
491 le16_to_cpu(cmd.u.leaf.softinfo.max_outstanding_tx);
492 break;
493 case KVASER_USBCAN:
494 dev->fw_version = le32_to_cpu(cmd.u.usbcan.softinfo.fw_version);
495 dev->max_tx_urbs =
496 le16_to_cpu(cmd.u.usbcan.softinfo.max_outstanding_tx);
497 break;
498 }
499
500 return 0;
501 }
502
503 static int kvaser_usb_leaf_get_software_info(struct kvaser_usb *dev)
504 {
505 int err;
506 int retry = 3;
507
508 /* On some x86 laptops, plugging a Kvaser device again after
509 * an unplug makes the firmware always ignore the very first
510 * command. For such a case, provide some room for retries
511 * instead of completely exiting the driver.
512 */
513 do {
514 err = kvaser_usb_leaf_get_software_info_inner(dev);
515 } while (--retry && err == -ETIMEDOUT);
516
517 return err;
518 }
519
520 static int kvaser_usb_leaf_get_card_info(struct kvaser_usb *dev)
521 {
522 struct kvaser_cmd cmd;
523 int err;
524
525 err = kvaser_usb_leaf_send_simple_cmd(dev, CMD_GET_CARD_INFO, 0);
526 if (err)
527 return err;
528
529 err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_CARD_INFO_REPLY, &cmd);
530 if (err)
531 return err;
532
533 dev->nchannels = cmd.u.cardinfo.nchannels;
534 if (dev->nchannels > KVASER_USB_MAX_NET_DEVICES ||
535 (dev->card_data.leaf.family == KVASER_USBCAN &&
536 dev->nchannels > MAX_USBCAN_NET_DEVICES))
537 return -EINVAL;
538
539 return 0;
540 }
541
542 static void kvaser_usb_leaf_tx_acknowledge(const struct kvaser_usb *dev,
543 const struct kvaser_cmd *cmd)
544 {
545 struct net_device_stats *stats;
546 struct kvaser_usb_tx_urb_context *context;
547 struct kvaser_usb_net_priv *priv;
548 unsigned long flags;
549 u8 channel, tid;
550
551 channel = cmd->u.tx_acknowledge_header.channel;
552 tid = cmd->u.tx_acknowledge_header.tid;
553
554 if (channel >= dev->nchannels) {
555 dev_err(&dev->intf->dev,
556 "Invalid channel number (%d)\n", channel);
557 return;
558 }
559
560 priv = dev->nets[channel];
561
562 if (!netif_device_present(priv->netdev))
563 return;
564
565 stats = &priv->netdev->stats;
566
567 context = &priv->tx_contexts[tid % dev->max_tx_urbs];
568
569 /* Sometimes the state change doesn't come after a bus-off event */
570 if (priv->can.restart_ms && priv->can.state >= CAN_STATE_BUS_OFF) {
571 struct sk_buff *skb;
572 struct can_frame *cf;
573
574 skb = alloc_can_err_skb(priv->netdev, &cf);
575 if (skb) {
576 cf->can_id |= CAN_ERR_RESTARTED;
577
578 stats->rx_packets++;
579 stats->rx_bytes += cf->can_dlc;
580 netif_rx(skb);
581 } else {
582 netdev_err(priv->netdev,
583 "No memory left for err_skb\n");
584 }
585
586 priv->can.can_stats.restarts++;
587 netif_carrier_on(priv->netdev);
588
589 priv->can.state = CAN_STATE_ERROR_ACTIVE;
590 }
591
592 stats->tx_packets++;
593 stats->tx_bytes += context->dlc;
594
595 spin_lock_irqsave(&priv->tx_contexts_lock, flags);
596
597 can_get_echo_skb(priv->netdev, context->echo_index);
598 context->echo_index = dev->max_tx_urbs;
599 --priv->active_tx_contexts;
600 netif_wake_queue(priv->netdev);
601
602 spin_unlock_irqrestore(&priv->tx_contexts_lock, flags);
603 }
604
605 static int kvaser_usb_leaf_simple_cmd_async(struct kvaser_usb_net_priv *priv,
606 u8 cmd_id)
607 {
608 struct kvaser_cmd *cmd;
609 int err;
610
611 cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
612 if (!cmd)
613 return -ENOMEM;
614
615 cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple);
616 cmd->id = cmd_id;
617 cmd->u.simple.channel = priv->channel;
618
619 err = kvaser_usb_send_cmd_async(priv, cmd, cmd->len);
620 if (err)
621 kfree(cmd);
622
623 return err;
624 }
625
626 static void
627 kvaser_usb_leaf_rx_error_update_can_state(struct kvaser_usb_net_priv *priv,
628 const struct kvaser_usb_err_summary *es,
629 struct can_frame *cf)
630 {
631 struct kvaser_usb *dev = priv->dev;
632 struct net_device_stats *stats = &priv->netdev->stats;
633 enum can_state cur_state, new_state, tx_state, rx_state;
634
635 netdev_dbg(priv->netdev, "Error status: 0x%02x\n", es->status);
636
637 new_state = priv->can.state;
638 cur_state = priv->can.state;
639
640 if (es->status & (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
641 new_state = CAN_STATE_BUS_OFF;
642 } else if (es->status & M16C_STATE_BUS_PASSIVE) {
643 new_state = CAN_STATE_ERROR_PASSIVE;
644 } else if (es->status & M16C_STATE_BUS_ERROR) {
645 /* Guard against spurious error events after a busoff */
646 if (cur_state < CAN_STATE_BUS_OFF) {
647 if (es->txerr >= 128 || es->rxerr >= 128)
648 new_state = CAN_STATE_ERROR_PASSIVE;
649 else if (es->txerr >= 96 || es->rxerr >= 96)
650 new_state = CAN_STATE_ERROR_WARNING;
651 else if (cur_state > CAN_STATE_ERROR_ACTIVE)
652 new_state = CAN_STATE_ERROR_ACTIVE;
653 }
654 }
655
656 if (!es->status)
657 new_state = CAN_STATE_ERROR_ACTIVE;
658
659 if (new_state != cur_state) {
660 tx_state = (es->txerr >= es->rxerr) ? new_state : 0;
661 rx_state = (es->txerr <= es->rxerr) ? new_state : 0;
662
663 can_change_state(priv->netdev, cf, tx_state, rx_state);
664 }
665
666 if (priv->can.restart_ms &&
667 cur_state >= CAN_STATE_BUS_OFF &&
668 new_state < CAN_STATE_BUS_OFF)
669 priv->can.can_stats.restarts++;
670
671 switch (dev->card_data.leaf.family) {
672 case KVASER_LEAF:
673 if (es->leaf.error_factor) {
674 priv->can.can_stats.bus_error++;
675 stats->rx_errors++;
676 }
677 break;
678 case KVASER_USBCAN:
679 if (es->usbcan.error_state & USBCAN_ERROR_STATE_TX_ERROR)
680 stats->tx_errors++;
681 if (es->usbcan.error_state & USBCAN_ERROR_STATE_RX_ERROR)
682 stats->rx_errors++;
683 if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR)
684 priv->can.can_stats.bus_error++;
685 break;
686 }
687
688 priv->bec.txerr = es->txerr;
689 priv->bec.rxerr = es->rxerr;
690 }
691
692 static void kvaser_usb_leaf_rx_error(const struct kvaser_usb *dev,
693 const struct kvaser_usb_err_summary *es)
694 {
695 struct can_frame *cf;
696 struct can_frame tmp_cf = { .can_id = CAN_ERR_FLAG,
697 .can_dlc = CAN_ERR_DLC };
698 struct sk_buff *skb;
699 struct net_device_stats *stats;
700 struct kvaser_usb_net_priv *priv;
701 enum can_state old_state, new_state;
702
703 if (es->channel >= dev->nchannels) {
704 dev_err(&dev->intf->dev,
705 "Invalid channel number (%d)\n", es->channel);
706 return;
707 }
708
709 priv = dev->nets[es->channel];
710 stats = &priv->netdev->stats;
711
712 /* Update all of the CAN interface's state and error counters before
713 * trying any memory allocation that can actually fail with -ENOMEM.
714 *
715 * We send a temporary stack-allocated error CAN frame to
716 * can_change_state() for the very same reason.
717 *
718 * TODO: Split can_change_state() responsibility between updating the
719 * CAN interface's state and counters, and the setting up of CAN error
720 * frame ID and data to userspace. Remove stack allocation afterwards.
721 */
722 old_state = priv->can.state;
723 kvaser_usb_leaf_rx_error_update_can_state(priv, es, &tmp_cf);
724 new_state = priv->can.state;
725
726 skb = alloc_can_err_skb(priv->netdev, &cf);
727 if (!skb) {
728 stats->rx_dropped++;
729 return;
730 }
731 memcpy(cf, &tmp_cf, sizeof(*cf));
732
733 if (new_state != old_state) {
734 if (es->status &
735 (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
736 if (!priv->can.restart_ms)
737 kvaser_usb_leaf_simple_cmd_async(priv,
738 CMD_STOP_CHIP);
739 netif_carrier_off(priv->netdev);
740 }
741
742 if (priv->can.restart_ms &&
743 old_state >= CAN_STATE_BUS_OFF &&
744 new_state < CAN_STATE_BUS_OFF) {
745 cf->can_id |= CAN_ERR_RESTARTED;
746 netif_carrier_on(priv->netdev);
747 }
748 }
749
750 switch (dev->card_data.leaf.family) {
751 case KVASER_LEAF:
752 if (es->leaf.error_factor) {
753 cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT;
754
755 if (es->leaf.error_factor & M16C_EF_ACKE)
756 cf->data[3] = CAN_ERR_PROT_LOC_ACK;
757 if (es->leaf.error_factor & M16C_EF_CRCE)
758 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
759 if (es->leaf.error_factor & M16C_EF_FORME)
760 cf->data[2] |= CAN_ERR_PROT_FORM;
761 if (es->leaf.error_factor & M16C_EF_STFE)
762 cf->data[2] |= CAN_ERR_PROT_STUFF;
763 if (es->leaf.error_factor & M16C_EF_BITE0)
764 cf->data[2] |= CAN_ERR_PROT_BIT0;
765 if (es->leaf.error_factor & M16C_EF_BITE1)
766 cf->data[2] |= CAN_ERR_PROT_BIT1;
767 if (es->leaf.error_factor & M16C_EF_TRE)
768 cf->data[2] |= CAN_ERR_PROT_TX;
769 }
770 break;
771 case KVASER_USBCAN:
772 if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR)
773 cf->can_id |= CAN_ERR_BUSERROR;
774 break;
775 }
776
777 cf->data[6] = es->txerr;
778 cf->data[7] = es->rxerr;
779
780 stats->rx_packets++;
781 stats->rx_bytes += cf->can_dlc;
782 netif_rx(skb);
783 }
784
785 /* For USBCAN, report error to userspace if the channels's errors counter
786 * has changed, or we're the only channel seeing a bus error state.
787 */
788 static void
789 kvaser_usb_leaf_usbcan_conditionally_rx_error(const struct kvaser_usb *dev,
790 struct kvaser_usb_err_summary *es)
791 {
792 struct kvaser_usb_net_priv *priv;
793 unsigned int channel;
794 bool report_error;
795
796 channel = es->channel;
797 if (channel >= dev->nchannels) {
798 dev_err(&dev->intf->dev,
799 "Invalid channel number (%d)\n", channel);
800 return;
801 }
802
803 priv = dev->nets[channel];
804 report_error = false;
805
806 if (es->txerr != priv->bec.txerr) {
807 es->usbcan.error_state |= USBCAN_ERROR_STATE_TX_ERROR;
808 report_error = true;
809 }
810 if (es->rxerr != priv->bec.rxerr) {
811 es->usbcan.error_state |= USBCAN_ERROR_STATE_RX_ERROR;
812 report_error = true;
813 }
814 if ((es->status & M16C_STATE_BUS_ERROR) &&
815 !(es->usbcan.other_ch_status & M16C_STATE_BUS_ERROR)) {
816 es->usbcan.error_state |= USBCAN_ERROR_STATE_BUSERROR;
817 report_error = true;
818 }
819
820 if (report_error)
821 kvaser_usb_leaf_rx_error(dev, es);
822 }
823
824 static void kvaser_usb_leaf_usbcan_rx_error(const struct kvaser_usb *dev,
825 const struct kvaser_cmd *cmd)
826 {
827 struct kvaser_usb_err_summary es = { };
828
829 switch (cmd->id) {
830 /* Sometimes errors are sent as unsolicited chip state events */
831 case CMD_CHIP_STATE_EVENT:
832 es.channel = cmd->u.usbcan.chip_state_event.channel;
833 es.status = cmd->u.usbcan.chip_state_event.status;
834 es.txerr = cmd->u.usbcan.chip_state_event.tx_errors_count;
835 es.rxerr = cmd->u.usbcan.chip_state_event.rx_errors_count;
836 kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
837 break;
838
839 case CMD_CAN_ERROR_EVENT:
840 es.channel = 0;
841 es.status = cmd->u.usbcan.error_event.status_ch0;
842 es.txerr = cmd->u.usbcan.error_event.tx_errors_count_ch0;
843 es.rxerr = cmd->u.usbcan.error_event.rx_errors_count_ch0;
844 es.usbcan.other_ch_status =
845 cmd->u.usbcan.error_event.status_ch1;
846 kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
847
848 /* The USBCAN firmware supports up to 2 channels.
849 * Now that ch0 was checked, check if ch1 has any errors.
850 */
851 if (dev->nchannels == MAX_USBCAN_NET_DEVICES) {
852 es.channel = 1;
853 es.status = cmd->u.usbcan.error_event.status_ch1;
854 es.txerr =
855 cmd->u.usbcan.error_event.tx_errors_count_ch1;
856 es.rxerr =
857 cmd->u.usbcan.error_event.rx_errors_count_ch1;
858 es.usbcan.other_ch_status =
859 cmd->u.usbcan.error_event.status_ch0;
860 kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
861 }
862 break;
863
864 default:
865 dev_err(&dev->intf->dev, "Invalid cmd id (%d)\n", cmd->id);
866 }
867 }
868
869 static void kvaser_usb_leaf_leaf_rx_error(const struct kvaser_usb *dev,
870 const struct kvaser_cmd *cmd)
871 {
872 struct kvaser_usb_err_summary es = { };
873
874 switch (cmd->id) {
875 case CMD_CAN_ERROR_EVENT:
876 es.channel = cmd->u.leaf.error_event.channel;
877 es.status = cmd->u.leaf.error_event.status;
878 es.txerr = cmd->u.leaf.error_event.tx_errors_count;
879 es.rxerr = cmd->u.leaf.error_event.rx_errors_count;
880 es.leaf.error_factor = cmd->u.leaf.error_event.error_factor;
881 break;
882 case CMD_LEAF_LOG_MESSAGE:
883 es.channel = cmd->u.leaf.log_message.channel;
884 es.status = cmd->u.leaf.log_message.data[0];
885 es.txerr = cmd->u.leaf.log_message.data[2];
886 es.rxerr = cmd->u.leaf.log_message.data[3];
887 es.leaf.error_factor = cmd->u.leaf.log_message.data[1];
888 break;
889 case CMD_CHIP_STATE_EVENT:
890 es.channel = cmd->u.leaf.chip_state_event.channel;
891 es.status = cmd->u.leaf.chip_state_event.status;
892 es.txerr = cmd->u.leaf.chip_state_event.tx_errors_count;
893 es.rxerr = cmd->u.leaf.chip_state_event.rx_errors_count;
894 es.leaf.error_factor = 0;
895 break;
896 default:
897 dev_err(&dev->intf->dev, "Invalid cmd id (%d)\n", cmd->id);
898 return;
899 }
900
901 kvaser_usb_leaf_rx_error(dev, &es);
902 }
903
904 static void kvaser_usb_leaf_rx_can_err(const struct kvaser_usb_net_priv *priv,
905 const struct kvaser_cmd *cmd)
906 {
907 if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
908 MSG_FLAG_NERR)) {
909 struct net_device_stats *stats = &priv->netdev->stats;
910
911 netdev_err(priv->netdev, "Unknown error (flags: 0x%02x)\n",
912 cmd->u.rx_can_header.flag);
913
914 stats->rx_errors++;
915 return;
916 }
917
918 if (cmd->u.rx_can_header.flag & MSG_FLAG_OVERRUN)
919 kvaser_usb_can_rx_over_error(priv->netdev);
920 }
921
922 static void kvaser_usb_leaf_rx_can_msg(const struct kvaser_usb *dev,
923 const struct kvaser_cmd *cmd)
924 {
925 struct kvaser_usb_net_priv *priv;
926 struct can_frame *cf;
927 struct sk_buff *skb;
928 struct net_device_stats *stats;
929 u8 channel = cmd->u.rx_can_header.channel;
930 const u8 *rx_data = NULL; /* GCC */
931
932 if (channel >= dev->nchannels) {
933 dev_err(&dev->intf->dev,
934 "Invalid channel number (%d)\n", channel);
935 return;
936 }
937
938 priv = dev->nets[channel];
939 stats = &priv->netdev->stats;
940
941 if ((cmd->u.rx_can_header.flag & MSG_FLAG_ERROR_FRAME) &&
942 (dev->card_data.leaf.family == KVASER_LEAF &&
943 cmd->id == CMD_LEAF_LOG_MESSAGE)) {
944 kvaser_usb_leaf_leaf_rx_error(dev, cmd);
945 return;
946 } else if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
947 MSG_FLAG_NERR |
948 MSG_FLAG_OVERRUN)) {
949 kvaser_usb_leaf_rx_can_err(priv, cmd);
950 return;
951 } else if (cmd->u.rx_can_header.flag & ~MSG_FLAG_REMOTE_FRAME) {
952 netdev_warn(priv->netdev,
953 "Unhandled frame (flags: 0x%02x)\n",
954 cmd->u.rx_can_header.flag);
955 return;
956 }
957
958 switch (dev->card_data.leaf.family) {
959 case KVASER_LEAF:
960 rx_data = cmd->u.leaf.rx_can.data;
961 break;
962 case KVASER_USBCAN:
963 rx_data = cmd->u.usbcan.rx_can.data;
964 break;
965 }
966
967 skb = alloc_can_skb(priv->netdev, &cf);
968 if (!skb) {
969 stats->rx_dropped++;
970 return;
971 }
972
973 if (dev->card_data.leaf.family == KVASER_LEAF && cmd->id ==
974 CMD_LEAF_LOG_MESSAGE) {
975 cf->can_id = le32_to_cpu(cmd->u.leaf.log_message.id);
976 if (cf->can_id & KVASER_EXTENDED_FRAME)
977 cf->can_id &= CAN_EFF_MASK | CAN_EFF_FLAG;
978 else
979 cf->can_id &= CAN_SFF_MASK;
980
981 cf->can_dlc = get_can_dlc(cmd->u.leaf.log_message.dlc);
982
983 if (cmd->u.leaf.log_message.flags & MSG_FLAG_REMOTE_FRAME)
984 cf->can_id |= CAN_RTR_FLAG;
985 else
986 memcpy(cf->data, &cmd->u.leaf.log_message.data,
987 cf->can_dlc);
988 } else {
989 cf->can_id = ((rx_data[0] & 0x1f) << 6) | (rx_data[1] & 0x3f);
990
991 if (cmd->id == CMD_RX_EXT_MESSAGE) {
992 cf->can_id <<= 18;
993 cf->can_id |= ((rx_data[2] & 0x0f) << 14) |
994 ((rx_data[3] & 0xff) << 6) |
995 (rx_data[4] & 0x3f);
996 cf->can_id |= CAN_EFF_FLAG;
997 }
998
999 cf->can_dlc = get_can_dlc(rx_data[5]);
1000
1001 if (cmd->u.rx_can_header.flag & MSG_FLAG_REMOTE_FRAME)
1002 cf->can_id |= CAN_RTR_FLAG;
1003 else
1004 memcpy(cf->data, &rx_data[6], cf->can_dlc);
1005 }
1006
1007 stats->rx_packets++;
1008 stats->rx_bytes += cf->can_dlc;
1009 netif_rx(skb);
1010 }
1011
1012 static void kvaser_usb_leaf_start_chip_reply(const struct kvaser_usb *dev,
1013 const struct kvaser_cmd *cmd)
1014 {
1015 struct kvaser_usb_net_priv *priv;
1016 u8 channel = cmd->u.simple.channel;
1017
1018 if (channel >= dev->nchannels) {
1019 dev_err(&dev->intf->dev,
1020 "Invalid channel number (%d)\n", channel);
1021 return;
1022 }
1023
1024 priv = dev->nets[channel];
1025
1026 if (completion_done(&priv->start_comp) &&
1027 netif_queue_stopped(priv->netdev)) {
1028 netif_wake_queue(priv->netdev);
1029 } else {
1030 netif_start_queue(priv->netdev);
1031 complete(&priv->start_comp);
1032 }
1033 }
1034
1035 static void kvaser_usb_leaf_stop_chip_reply(const struct kvaser_usb *dev,
1036 const struct kvaser_cmd *cmd)
1037 {
1038 struct kvaser_usb_net_priv *priv;
1039 u8 channel = cmd->u.simple.channel;
1040
1041 if (channel >= dev->nchannels) {
1042 dev_err(&dev->intf->dev,
1043 "Invalid channel number (%d)\n", channel);
1044 return;
1045 }
1046
1047 priv = dev->nets[channel];
1048
1049 complete(&priv->stop_comp);
1050 }
1051
1052 static void kvaser_usb_leaf_handle_command(const struct kvaser_usb *dev,
1053 const struct kvaser_cmd *cmd)
1054 {
1055 switch (cmd->id) {
1056 case CMD_START_CHIP_REPLY:
1057 kvaser_usb_leaf_start_chip_reply(dev, cmd);
1058 break;
1059
1060 case CMD_STOP_CHIP_REPLY:
1061 kvaser_usb_leaf_stop_chip_reply(dev, cmd);
1062 break;
1063
1064 case CMD_RX_STD_MESSAGE:
1065 case CMD_RX_EXT_MESSAGE:
1066 kvaser_usb_leaf_rx_can_msg(dev, cmd);
1067 break;
1068
1069 case CMD_LEAF_LOG_MESSAGE:
1070 if (dev->card_data.leaf.family != KVASER_LEAF)
1071 goto warn;
1072 kvaser_usb_leaf_rx_can_msg(dev, cmd);
1073 break;
1074
1075 case CMD_CHIP_STATE_EVENT:
1076 case CMD_CAN_ERROR_EVENT:
1077 if (dev->card_data.leaf.family == KVASER_LEAF)
1078 kvaser_usb_leaf_leaf_rx_error(dev, cmd);
1079 else
1080 kvaser_usb_leaf_usbcan_rx_error(dev, cmd);
1081 break;
1082
1083 case CMD_TX_ACKNOWLEDGE:
1084 kvaser_usb_leaf_tx_acknowledge(dev, cmd);
1085 break;
1086
1087 /* Ignored commands */
1088 case CMD_USBCAN_CLOCK_OVERFLOW_EVENT:
1089 if (dev->card_data.leaf.family != KVASER_USBCAN)
1090 goto warn;
1091 break;
1092
1093 case CMD_FLUSH_QUEUE_REPLY:
1094 if (dev->card_data.leaf.family != KVASER_LEAF)
1095 goto warn;
1096 break;
1097
1098 default:
1099 warn: dev_warn(&dev->intf->dev, "Unhandled command (%d)\n", cmd->id);
1100 break;
1101 }
1102 }
1103
1104 static void kvaser_usb_leaf_read_bulk_callback(struct kvaser_usb *dev,
1105 void *buf, int len)
1106 {
1107 struct kvaser_cmd *cmd;
1108 int pos = 0;
1109
1110 while (pos <= len - CMD_HEADER_LEN) {
1111 cmd = buf + pos;
1112
1113 /* The Kvaser firmware can only read and write commands that
1114 * does not cross the USB's endpoint wMaxPacketSize boundary.
1115 * If a follow-up command crosses such boundary, firmware puts
1116 * a placeholder zero-length command in its place then aligns
1117 * the real command to the next max packet size.
1118 *
1119 * Handle such cases or we're going to miss a significant
1120 * number of events in case of a heavy rx load on the bus.
1121 */
1122 if (cmd->len == 0) {
1123 pos = round_up(pos, le16_to_cpu
1124 (dev->bulk_in->wMaxPacketSize));
1125 continue;
1126 }
1127
1128 if (pos + cmd->len > len) {
1129 dev_err_ratelimited(&dev->intf->dev, "Format error\n");
1130 break;
1131 }
1132
1133 kvaser_usb_leaf_handle_command(dev, cmd);
1134 pos += cmd->len;
1135 }
1136 }
1137
1138 static int kvaser_usb_leaf_set_opt_mode(const struct kvaser_usb_net_priv *priv)
1139 {
1140 struct kvaser_cmd *cmd;
1141 int rc;
1142
1143 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1144 if (!cmd)
1145 return -ENOMEM;
1146
1147 cmd->id = CMD_SET_CTRL_MODE;
1148 cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_ctrl_mode);
1149 cmd->u.ctrl_mode.tid = 0xff;
1150 cmd->u.ctrl_mode.channel = priv->channel;
1151
1152 if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1153 cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT;
1154 else
1155 cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL;
1156
1157 rc = kvaser_usb_send_cmd(priv->dev, cmd, cmd->len);
1158
1159 kfree(cmd);
1160 return rc;
1161 }
1162
1163 static int kvaser_usb_leaf_start_chip(struct kvaser_usb_net_priv *priv)
1164 {
1165 int err;
1166
1167 init_completion(&priv->start_comp);
1168
1169 err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_START_CHIP,
1170 priv->channel);
1171 if (err)
1172 return err;
1173
1174 if (!wait_for_completion_timeout(&priv->start_comp,
1175 msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1176 return -ETIMEDOUT;
1177
1178 return 0;
1179 }
1180
1181 static int kvaser_usb_leaf_stop_chip(struct kvaser_usb_net_priv *priv)
1182 {
1183 int err;
1184
1185 init_completion(&priv->stop_comp);
1186
1187 err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_STOP_CHIP,
1188 priv->channel);
1189 if (err)
1190 return err;
1191
1192 if (!wait_for_completion_timeout(&priv->stop_comp,
1193 msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1194 return -ETIMEDOUT;
1195
1196 return 0;
1197 }
1198
1199 static int kvaser_usb_leaf_reset_chip(struct kvaser_usb *dev, int channel)
1200 {
1201 return kvaser_usb_leaf_send_simple_cmd(dev, CMD_RESET_CHIP, channel);
1202 }
1203
1204 static int kvaser_usb_leaf_flush_queue(struct kvaser_usb_net_priv *priv)
1205 {
1206 struct kvaser_cmd *cmd;
1207 int rc;
1208
1209 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1210 if (!cmd)
1211 return -ENOMEM;
1212
1213 cmd->id = CMD_FLUSH_QUEUE;
1214 cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_flush_queue);
1215 cmd->u.flush_queue.channel = priv->channel;
1216 cmd->u.flush_queue.flags = 0x00;
1217
1218 rc = kvaser_usb_send_cmd(priv->dev, cmd, cmd->len);
1219
1220 kfree(cmd);
1221 return rc;
1222 }
1223
1224 static int kvaser_usb_leaf_init_card(struct kvaser_usb *dev)
1225 {
1226 struct kvaser_usb_dev_card_data *card_data = &dev->card_data;
1227
1228 dev->cfg = &kvaser_usb_leaf_dev_cfg;
1229 card_data->ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
1230
1231 return 0;
1232 }
1233
1234 static const struct can_bittiming_const kvaser_usb_leaf_bittiming_const = {
1235 .name = "kvaser_usb",
1236 .tseg1_min = KVASER_USB_TSEG1_MIN,
1237 .tseg1_max = KVASER_USB_TSEG1_MAX,
1238 .tseg2_min = KVASER_USB_TSEG2_MIN,
1239 .tseg2_max = KVASER_USB_TSEG2_MAX,
1240 .sjw_max = KVASER_USB_SJW_MAX,
1241 .brp_min = KVASER_USB_BRP_MIN,
1242 .brp_max = KVASER_USB_BRP_MAX,
1243 .brp_inc = KVASER_USB_BRP_INC,
1244 };
1245
1246 static int kvaser_usb_leaf_set_bittiming(struct net_device *netdev)
1247 {
1248 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1249 struct can_bittiming *bt = &priv->can.bittiming;
1250 struct kvaser_usb *dev = priv->dev;
1251 struct kvaser_cmd *cmd;
1252 int rc;
1253
1254 cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
1255 if (!cmd)
1256 return -ENOMEM;
1257
1258 cmd->id = CMD_SET_BUS_PARAMS;
1259 cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_busparams);
1260 cmd->u.busparams.channel = priv->channel;
1261 cmd->u.busparams.tid = 0xff;
1262 cmd->u.busparams.bitrate = cpu_to_le32(bt->bitrate);
1263 cmd->u.busparams.sjw = bt->sjw;
1264 cmd->u.busparams.tseg1 = bt->prop_seg + bt->phase_seg1;
1265 cmd->u.busparams.tseg2 = bt->phase_seg2;
1266
1267 if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
1268 cmd->u.busparams.no_samp = 3;
1269 else
1270 cmd->u.busparams.no_samp = 1;
1271
1272 rc = kvaser_usb_send_cmd(dev, cmd, cmd->len);
1273
1274 kfree(cmd);
1275 return rc;
1276 }
1277
1278 static int kvaser_usb_leaf_set_mode(struct net_device *netdev,
1279 enum can_mode mode)
1280 {
1281 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1282 int err;
1283
1284 switch (mode) {
1285 case CAN_MODE_START:
1286 err = kvaser_usb_leaf_simple_cmd_async(priv, CMD_START_CHIP);
1287 if (err)
1288 return err;
1289 break;
1290 default:
1291 return -EOPNOTSUPP;
1292 }
1293
1294 return 0;
1295 }
1296
1297 static int kvaser_usb_leaf_get_berr_counter(const struct net_device *netdev,
1298 struct can_berr_counter *bec)
1299 {
1300 struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1301
1302 *bec = priv->bec;
1303
1304 return 0;
1305 }
1306
1307 static int kvaser_usb_leaf_setup_endpoints(struct kvaser_usb *dev)
1308 {
1309 const struct usb_host_interface *iface_desc;
1310 struct usb_endpoint_descriptor *endpoint;
1311 int i;
1312
1313 iface_desc = dev->intf->cur_altsetting;
1314
1315 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1316 endpoint = &iface_desc->endpoint[i].desc;
1317
1318 if (!dev->bulk_in && usb_endpoint_is_bulk_in(endpoint))
1319 dev->bulk_in = endpoint;
1320
1321 if (!dev->bulk_out && usb_endpoint_is_bulk_out(endpoint))
1322 dev->bulk_out = endpoint;
1323
1324 /* use first bulk endpoint for in and out */
1325 if (dev->bulk_in && dev->bulk_out)
1326 return 0;
1327 }
1328
1329 return -ENODEV;
1330 }
1331
1332 const struct kvaser_usb_dev_ops kvaser_usb_leaf_dev_ops = {
1333 .dev_set_mode = kvaser_usb_leaf_set_mode,
1334 .dev_set_bittiming = kvaser_usb_leaf_set_bittiming,
1335 .dev_set_data_bittiming = NULL,
1336 .dev_get_berr_counter = kvaser_usb_leaf_get_berr_counter,
1337 .dev_setup_endpoints = kvaser_usb_leaf_setup_endpoints,
1338 .dev_init_card = kvaser_usb_leaf_init_card,
1339 .dev_get_software_info = kvaser_usb_leaf_get_software_info,
1340 .dev_get_software_details = NULL,
1341 .dev_get_card_info = kvaser_usb_leaf_get_card_info,
1342 .dev_get_capabilities = NULL,
1343 .dev_set_opt_mode = kvaser_usb_leaf_set_opt_mode,
1344 .dev_start_chip = kvaser_usb_leaf_start_chip,
1345 .dev_stop_chip = kvaser_usb_leaf_stop_chip,
1346 .dev_reset_chip = kvaser_usb_leaf_reset_chip,
1347 .dev_flush_queue = kvaser_usb_leaf_flush_queue,
1348 .dev_read_bulk_callback = kvaser_usb_leaf_read_bulk_callback,
1349 .dev_frame_to_cmd = kvaser_usb_leaf_frame_to_cmd,
1350 };
1351
1352 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg = {
1353 .clock = {
1354 .freq = CAN_USB_CLOCK,
1355 },
1356 .timestamp_freq = 1,
1357 .bittiming_const = &kvaser_usb_leaf_bittiming_const,
1358 };
Linux with added FPC-III support