Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/* SocketCAN driver for Microchip CAN BUS Analyzer Tool
3 *
4 * Copyright (C) 2017 Mobica Limited
5 *
6 * This driver is inspired by the 4.6.2 version of net/can/usb/usb_8dev.c
7 */
8
9#include <asm/unaligned.h>
10#include <linux/can.h>
11#include <linux/can/dev.h>
12#include <linux/can/error.h>
13#include <linux/ethtool.h>
14#include <linux/module.h>
15#include <linux/netdevice.h>
16#include <linux/signal.h>
17#include <linux/slab.h>
18#include <linux/usb.h>
19
20/* vendor and product id */
21#define MCBA_MODULE_NAME "mcba_usb"
22#define MCBA_VENDOR_ID 0x04d8
23#define MCBA_PRODUCT_ID 0x0a30
24
25/* driver constants */
26#define MCBA_MAX_RX_URBS 20
27#define MCBA_MAX_TX_URBS 20
28#define MCBA_CTX_FREE MCBA_MAX_TX_URBS
29
30/* RX buffer must be bigger than msg size since at the
31 * beginning USB messages are stacked.
32 */
33#define MCBA_USB_RX_BUFF_SIZE 64
34#define MCBA_USB_TX_BUFF_SIZE (sizeof(struct mcba_usb_msg))
35
36/* Microchip command id */
37#define MBCA_CMD_RECEIVE_MESSAGE 0xE3
38#define MBCA_CMD_I_AM_ALIVE_FROM_CAN 0xF5
39#define MBCA_CMD_I_AM_ALIVE_FROM_USB 0xF7
40#define MBCA_CMD_CHANGE_BIT_RATE 0xA1
41#define MBCA_CMD_TRANSMIT_MESSAGE_EV 0xA3
42#define MBCA_CMD_SETUP_TERMINATION_RESISTANCE 0xA8
43#define MBCA_CMD_READ_FW_VERSION 0xA9
44#define MBCA_CMD_NOTHING_TO_SEND 0xFF
45#define MBCA_CMD_TRANSMIT_MESSAGE_RSP 0xE2
46
47#define MCBA_VER_REQ_USB 1
48#define MCBA_VER_REQ_CAN 2
49
50/* Drive the CAN_RES signal LOW "0" to activate R24 and R25 */
51#define MCBA_VER_TERMINATION_ON 0
52#define MCBA_VER_TERMINATION_OFF 1
53
54#define MCBA_SIDL_EXID_MASK 0x8
55#define MCBA_DLC_MASK 0xf
56#define MCBA_DLC_RTR_MASK 0x40
57
58#define MCBA_CAN_STATE_WRN_TH 95
59#define MCBA_CAN_STATE_ERR_PSV_TH 127
60
61#define MCBA_TERMINATION_DISABLED CAN_TERMINATION_DISABLED
62#define MCBA_TERMINATION_ENABLED 120
63
64struct mcba_usb_ctx {
65 struct mcba_priv *priv;
66 u32 ndx;
67 bool can;
68};
69
70/* Structure to hold all of our device specific stuff */
71struct mcba_priv {
72 struct can_priv can; /* must be the first member */
73 struct sk_buff *echo_skb[MCBA_MAX_TX_URBS];
74 struct mcba_usb_ctx tx_context[MCBA_MAX_TX_URBS];
75 struct usb_device *udev;
76 struct net_device *netdev;
77 struct usb_anchor tx_submitted;
78 struct usb_anchor rx_submitted;
79 struct can_berr_counter bec;
80 bool usb_ka_first_pass;
81 bool can_ka_first_pass;
82 bool can_speed_check;
83 atomic_t free_ctx_cnt;
84 void *rxbuf[MCBA_MAX_RX_URBS];
85 dma_addr_t rxbuf_dma[MCBA_MAX_RX_URBS];
86 int rx_pipe;
87 int tx_pipe;
88};
89
90/* CAN frame */
91struct __packed mcba_usb_msg_can {
92 u8 cmd_id;
93 __be16 eid;
94 __be16 sid;
95 u8 dlc;
96 u8 data[8];
97 u8 timestamp[4];
98 u8 checksum;
99};
100
101/* command frame */
102struct __packed mcba_usb_msg {
103 u8 cmd_id;
104 u8 unused[18];
105};
106
107struct __packed mcba_usb_msg_ka_usb {
108 u8 cmd_id;
109 u8 termination_state;
110 u8 soft_ver_major;
111 u8 soft_ver_minor;
112 u8 unused[15];
113};
114
115struct __packed mcba_usb_msg_ka_can {
116 u8 cmd_id;
117 u8 tx_err_cnt;
118 u8 rx_err_cnt;
119 u8 rx_buff_ovfl;
120 u8 tx_bus_off;
121 __be16 can_bitrate;
122 __le16 rx_lost;
123 u8 can_stat;
124 u8 soft_ver_major;
125 u8 soft_ver_minor;
126 u8 debug_mode;
127 u8 test_complete;
128 u8 test_result;
129 u8 unused[4];
130};
131
132struct __packed mcba_usb_msg_change_bitrate {
133 u8 cmd_id;
134 __be16 bitrate;
135 u8 unused[16];
136};
137
138struct __packed mcba_usb_msg_termination {
139 u8 cmd_id;
140 u8 termination;
141 u8 unused[17];
142};
143
144struct __packed mcba_usb_msg_fw_ver {
145 u8 cmd_id;
146 u8 pic;
147 u8 unused[17];
148};
149
150static const struct usb_device_id mcba_usb_table[] = {
151 { USB_DEVICE(MCBA_VENDOR_ID, MCBA_PRODUCT_ID) },
152 {} /* Terminating entry */
153};
154
155MODULE_DEVICE_TABLE(usb, mcba_usb_table);
156
157static const u16 mcba_termination[] = { MCBA_TERMINATION_DISABLED,
158 MCBA_TERMINATION_ENABLED };
159
160static const u32 mcba_bitrate[] = { 20000, 33333, 50000, 80000, 83333,
161 100000, 125000, 150000, 175000, 200000,
162 225000, 250000, 275000, 300000, 500000,
163 625000, 800000, 1000000 };
164
165static inline void mcba_init_ctx(struct mcba_priv *priv)
166{
167 int i = 0;
168
169 for (i = 0; i < MCBA_MAX_TX_URBS; i++) {
170 priv->tx_context[i].ndx = MCBA_CTX_FREE;
171 priv->tx_context[i].priv = priv;
172 }
173
174 atomic_set(&priv->free_ctx_cnt, ARRAY_SIZE(priv->tx_context));
175}
176
177static inline struct mcba_usb_ctx *mcba_usb_get_free_ctx(struct mcba_priv *priv,
178 struct can_frame *cf)
179{
180 int i = 0;
181 struct mcba_usb_ctx *ctx = NULL;
182
183 for (i = 0; i < MCBA_MAX_TX_URBS; i++) {
184 if (priv->tx_context[i].ndx == MCBA_CTX_FREE) {
185 ctx = &priv->tx_context[i];
186 ctx->ndx = i;
187
188 if (cf)
189 ctx->can = true;
190 else
191 ctx->can = false;
192
193 atomic_dec(&priv->free_ctx_cnt);
194 break;
195 }
196 }
197
198 if (!atomic_read(&priv->free_ctx_cnt))
199 /* That was the last free ctx. Slow down tx path */
200 netif_stop_queue(priv->netdev);
201
202 return ctx;
203}
204
205/* mcba_usb_free_ctx and mcba_usb_get_free_ctx are executed by different
206 * threads. The order of execution in below function is important.
207 */
208static inline void mcba_usb_free_ctx(struct mcba_usb_ctx *ctx)
209{
210 /* Increase number of free ctxs before freeing ctx */
211 atomic_inc(&ctx->priv->free_ctx_cnt);
212
213 ctx->ndx = MCBA_CTX_FREE;
214
215 /* Wake up the queue once ctx is marked free */
216 netif_wake_queue(ctx->priv->netdev);
217}
218
219static void mcba_usb_write_bulk_callback(struct urb *urb)
220{
221 struct mcba_usb_ctx *ctx = urb->context;
222 struct net_device *netdev;
223
224 WARN_ON(!ctx);
225
226 netdev = ctx->priv->netdev;
227
228 /* free up our allocated buffer */
229 usb_free_coherent(urb->dev, urb->transfer_buffer_length,
230 urb->transfer_buffer, urb->transfer_dma);
231
232 if (ctx->can) {
233 if (!netif_device_present(netdev))
234 return;
235
236 netdev->stats.tx_packets++;
237 netdev->stats.tx_bytes += can_get_echo_skb(netdev, ctx->ndx,
238 NULL);
239 }
240
241 if (urb->status)
242 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
243
244 /* Release the context */
245 mcba_usb_free_ctx(ctx);
246}
247
248/* Send data to device */
249static netdev_tx_t mcba_usb_xmit(struct mcba_priv *priv,
250 struct mcba_usb_msg *usb_msg,
251 struct mcba_usb_ctx *ctx)
252{
253 struct urb *urb;
254 u8 *buf;
255 int err;
256
257 /* create a URB, and a buffer for it, and copy the data to the URB */
258 urb = usb_alloc_urb(0, GFP_ATOMIC);
259 if (!urb)
260 return -ENOMEM;
261
262 buf = usb_alloc_coherent(priv->udev, MCBA_USB_TX_BUFF_SIZE, GFP_ATOMIC,
263 &urb->transfer_dma);
264 if (!buf) {
265 err = -ENOMEM;
266 goto nomembuf;
267 }
268
269 memcpy(buf, usb_msg, MCBA_USB_TX_BUFF_SIZE);
270
271 usb_fill_bulk_urb(urb, priv->udev, priv->tx_pipe, buf, MCBA_USB_TX_BUFF_SIZE,
272 mcba_usb_write_bulk_callback, ctx);
273
274 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
275 usb_anchor_urb(urb, &priv->tx_submitted);
276
277 err = usb_submit_urb(urb, GFP_ATOMIC);
278 if (unlikely(err))
279 goto failed;
280
281 /* Release our reference to this URB, the USB core will eventually free
282 * it entirely.
283 */
284 usb_free_urb(urb);
285
286 return 0;
287
288failed:
289 usb_unanchor_urb(urb);
290 usb_free_coherent(priv->udev, MCBA_USB_TX_BUFF_SIZE, buf,
291 urb->transfer_dma);
292
293 if (err == -ENODEV)
294 netif_device_detach(priv->netdev);
295 else
296 netdev_warn(priv->netdev, "failed tx_urb %d\n", err);
297
298nomembuf:
299 usb_free_urb(urb);
300
301 return err;
302}
303
304/* Send data to device */
305static netdev_tx_t mcba_usb_start_xmit(struct sk_buff *skb,
306 struct net_device *netdev)
307{
308 struct mcba_priv *priv = netdev_priv(netdev);
309 struct can_frame *cf = (struct can_frame *)skb->data;
310 struct mcba_usb_ctx *ctx = NULL;
311 struct net_device_stats *stats = &priv->netdev->stats;
312 u16 sid;
313 int err;
314 struct mcba_usb_msg_can usb_msg = {
315 .cmd_id = MBCA_CMD_TRANSMIT_MESSAGE_EV
316 };
317
318 if (can_dev_dropped_skb(netdev, skb))
319 return NETDEV_TX_OK;
320
321 ctx = mcba_usb_get_free_ctx(priv, cf);
322 if (!ctx)
323 return NETDEV_TX_BUSY;
324
325 if (cf->can_id & CAN_EFF_FLAG) {
326 /* SIDH | SIDL | EIDH | EIDL
327 * 28 - 21 | 20 19 18 x x x 17 16 | 15 - 8 | 7 - 0
328 */
329 sid = MCBA_SIDL_EXID_MASK;
330 /* store 28-18 bits */
331 sid |= (cf->can_id & 0x1ffc0000) >> 13;
332 /* store 17-16 bits */
333 sid |= (cf->can_id & 0x30000) >> 16;
334 put_unaligned_be16(sid, &usb_msg.sid);
335
336 /* store 15-0 bits */
337 put_unaligned_be16(cf->can_id & 0xffff, &usb_msg.eid);
338 } else {
339 /* SIDH | SIDL
340 * 10 - 3 | 2 1 0 x x x x x
341 */
342 put_unaligned_be16((cf->can_id & CAN_SFF_MASK) << 5,
343 &usb_msg.sid);
344 usb_msg.eid = 0;
345 }
346
347 usb_msg.dlc = cf->len;
348
349 memcpy(usb_msg.data, cf->data, usb_msg.dlc);
350
351 if (cf->can_id & CAN_RTR_FLAG)
352 usb_msg.dlc |= MCBA_DLC_RTR_MASK;
353
354 can_put_echo_skb(skb, priv->netdev, ctx->ndx, 0);
355
356 err = mcba_usb_xmit(priv, (struct mcba_usb_msg *)&usb_msg, ctx);
357 if (err)
358 goto xmit_failed;
359
360 return NETDEV_TX_OK;
361
362xmit_failed:
363 can_free_echo_skb(priv->netdev, ctx->ndx, NULL);
364 mcba_usb_free_ctx(ctx);
365 stats->tx_dropped++;
366
367 return NETDEV_TX_OK;
368}
369
370/* Send cmd to device */
371static void mcba_usb_xmit_cmd(struct mcba_priv *priv,
372 struct mcba_usb_msg *usb_msg)
373{
374 struct mcba_usb_ctx *ctx = NULL;
375 int err;
376
377 ctx = mcba_usb_get_free_ctx(priv, NULL);
378 if (!ctx) {
379 netdev_err(priv->netdev,
380 "Lack of free ctx. Sending (%d) cmd aborted",
381 usb_msg->cmd_id);
382
383 return;
384 }
385
386 err = mcba_usb_xmit(priv, usb_msg, ctx);
387 if (err)
388 netdev_err(priv->netdev, "Failed to send cmd (%d)",
389 usb_msg->cmd_id);
390}
391
392static void mcba_usb_xmit_change_bitrate(struct mcba_priv *priv, u16 bitrate)
393{
394 struct mcba_usb_msg_change_bitrate usb_msg = {
395 .cmd_id = MBCA_CMD_CHANGE_BIT_RATE
396 };
397
398 put_unaligned_be16(bitrate, &usb_msg.bitrate);
399
400 mcba_usb_xmit_cmd(priv, (struct mcba_usb_msg *)&usb_msg);
401}
402
403static void mcba_usb_xmit_read_fw_ver(struct mcba_priv *priv, u8 pic)
404{
405 struct mcba_usb_msg_fw_ver usb_msg = {
406 .cmd_id = MBCA_CMD_READ_FW_VERSION,
407 .pic = pic
408 };
409
410 mcba_usb_xmit_cmd(priv, (struct mcba_usb_msg *)&usb_msg);
411}
412
413static void mcba_usb_process_can(struct mcba_priv *priv,
414 struct mcba_usb_msg_can *msg)
415{
416 struct can_frame *cf;
417 struct sk_buff *skb;
418 struct net_device_stats *stats = &priv->netdev->stats;
419 u16 sid;
420
421 skb = alloc_can_skb(priv->netdev, &cf);
422 if (!skb)
423 return;
424
425 sid = get_unaligned_be16(&msg->sid);
426
427 if (sid & MCBA_SIDL_EXID_MASK) {
428 /* SIDH | SIDL | EIDH | EIDL
429 * 28 - 21 | 20 19 18 x x x 17 16 | 15 - 8 | 7 - 0
430 */
431 cf->can_id = CAN_EFF_FLAG;
432
433 /* store 28-18 bits */
434 cf->can_id |= (sid & 0xffe0) << 13;
435 /* store 17-16 bits */
436 cf->can_id |= (sid & 3) << 16;
437 /* store 15-0 bits */
438 cf->can_id |= get_unaligned_be16(&msg->eid);
439 } else {
440 /* SIDH | SIDL
441 * 10 - 3 | 2 1 0 x x x x x
442 */
443 cf->can_id = (sid & 0xffe0) >> 5;
444 }
445
446 cf->len = can_cc_dlc2len(msg->dlc & MCBA_DLC_MASK);
447
448 if (msg->dlc & MCBA_DLC_RTR_MASK) {
449 cf->can_id |= CAN_RTR_FLAG;
450 } else {
451 memcpy(cf->data, msg->data, cf->len);
452
453 stats->rx_bytes += cf->len;
454 }
455 stats->rx_packets++;
456
457 netif_rx(skb);
458}
459
460static void mcba_usb_process_ka_usb(struct mcba_priv *priv,
461 struct mcba_usb_msg_ka_usb *msg)
462{
463 if (unlikely(priv->usb_ka_first_pass)) {
464 netdev_info(priv->netdev, "PIC USB version %u.%u\n",
465 msg->soft_ver_major, msg->soft_ver_minor);
466
467 priv->usb_ka_first_pass = false;
468 }
469
470 if (msg->termination_state == MCBA_VER_TERMINATION_ON)
471 priv->can.termination = MCBA_TERMINATION_ENABLED;
472 else
473 priv->can.termination = MCBA_TERMINATION_DISABLED;
474}
475
476static u32 convert_can2host_bitrate(struct mcba_usb_msg_ka_can *msg)
477{
478 const u32 bitrate = get_unaligned_be16(&msg->can_bitrate);
479
480 if ((bitrate == 33) || (bitrate == 83))
481 return bitrate * 1000 + 333;
482 else
483 return bitrate * 1000;
484}
485
486static void mcba_usb_process_ka_can(struct mcba_priv *priv,
487 struct mcba_usb_msg_ka_can *msg)
488{
489 if (unlikely(priv->can_ka_first_pass)) {
490 netdev_info(priv->netdev, "PIC CAN version %u.%u\n",
491 msg->soft_ver_major, msg->soft_ver_minor);
492
493 priv->can_ka_first_pass = false;
494 }
495
496 if (unlikely(priv->can_speed_check)) {
497 const u32 bitrate = convert_can2host_bitrate(msg);
498
499 priv->can_speed_check = false;
500
501 if (bitrate != priv->can.bittiming.bitrate)
502 netdev_err(
503 priv->netdev,
504 "Wrong bitrate reported by the device (%u). Expected %u",
505 bitrate, priv->can.bittiming.bitrate);
506 }
507
508 priv->bec.txerr = msg->tx_err_cnt;
509 priv->bec.rxerr = msg->rx_err_cnt;
510
511 if (msg->tx_bus_off)
512 priv->can.state = CAN_STATE_BUS_OFF;
513
514 else if ((priv->bec.txerr > MCBA_CAN_STATE_ERR_PSV_TH) ||
515 (priv->bec.rxerr > MCBA_CAN_STATE_ERR_PSV_TH))
516 priv->can.state = CAN_STATE_ERROR_PASSIVE;
517
518 else if ((priv->bec.txerr > MCBA_CAN_STATE_WRN_TH) ||
519 (priv->bec.rxerr > MCBA_CAN_STATE_WRN_TH))
520 priv->can.state = CAN_STATE_ERROR_WARNING;
521}
522
523static void mcba_usb_process_rx(struct mcba_priv *priv,
524 struct mcba_usb_msg *msg)
525{
526 switch (msg->cmd_id) {
527 case MBCA_CMD_I_AM_ALIVE_FROM_CAN:
528 mcba_usb_process_ka_can(priv,
529 (struct mcba_usb_msg_ka_can *)msg);
530 break;
531
532 case MBCA_CMD_I_AM_ALIVE_FROM_USB:
533 mcba_usb_process_ka_usb(priv,
534 (struct mcba_usb_msg_ka_usb *)msg);
535 break;
536
537 case MBCA_CMD_RECEIVE_MESSAGE:
538 mcba_usb_process_can(priv, (struct mcba_usb_msg_can *)msg);
539 break;
540
541 case MBCA_CMD_NOTHING_TO_SEND:
542 /* Side effect of communication between PIC_USB and PIC_CAN.
543 * PIC_CAN is telling us that it has nothing to send
544 */
545 break;
546
547 case MBCA_CMD_TRANSMIT_MESSAGE_RSP:
548 /* Transmission response from the device containing timestamp */
549 break;
550
551 default:
552 netdev_warn(priv->netdev, "Unsupported msg (0x%X)",
553 msg->cmd_id);
554 break;
555 }
556}
557
558/* Callback for reading data from device
559 *
560 * Check urb status, call read function and resubmit urb read operation.
561 */
562static void mcba_usb_read_bulk_callback(struct urb *urb)
563{
564 struct mcba_priv *priv = urb->context;
565 struct net_device *netdev;
566 int retval;
567 int pos = 0;
568
569 netdev = priv->netdev;
570
571 if (!netif_device_present(netdev))
572 return;
573
574 switch (urb->status) {
575 case 0: /* success */
576 break;
577
578 case -ENOENT:
579 case -EPIPE:
580 case -EPROTO:
581 case -ESHUTDOWN:
582 return;
583
584 default:
585 netdev_info(netdev, "Rx URB aborted (%d)\n", urb->status);
586
587 goto resubmit_urb;
588 }
589
590 while (pos < urb->actual_length) {
591 struct mcba_usb_msg *msg;
592
593 if (pos + sizeof(struct mcba_usb_msg) > urb->actual_length) {
594 netdev_err(priv->netdev, "format error\n");
595 break;
596 }
597
598 msg = (struct mcba_usb_msg *)(urb->transfer_buffer + pos);
599 mcba_usb_process_rx(priv, msg);
600
601 pos += sizeof(struct mcba_usb_msg);
602 }
603
604resubmit_urb:
605
606 usb_fill_bulk_urb(urb, priv->udev,
607 priv->rx_pipe,
608 urb->transfer_buffer, MCBA_USB_RX_BUFF_SIZE,
609 mcba_usb_read_bulk_callback, priv);
610
611 retval = usb_submit_urb(urb, GFP_ATOMIC);
612
613 if (retval == -ENODEV)
614 netif_device_detach(netdev);
615 else if (retval)
616 netdev_err(netdev, "failed resubmitting read bulk urb: %d\n",
617 retval);
618}
619
620/* Start USB device */
621static int mcba_usb_start(struct mcba_priv *priv)
622{
623 struct net_device *netdev = priv->netdev;
624 int err, i;
625
626 mcba_init_ctx(priv);
627
628 for (i = 0; i < MCBA_MAX_RX_URBS; i++) {
629 struct urb *urb = NULL;
630 u8 *buf;
631 dma_addr_t buf_dma;
632
633 /* create a URB, and a buffer for it */
634 urb = usb_alloc_urb(0, GFP_KERNEL);
635 if (!urb) {
636 err = -ENOMEM;
637 break;
638 }
639
640 buf = usb_alloc_coherent(priv->udev, MCBA_USB_RX_BUFF_SIZE,
641 GFP_KERNEL, &buf_dma);
642 if (!buf) {
643 netdev_err(netdev, "No memory left for USB buffer\n");
644 usb_free_urb(urb);
645 err = -ENOMEM;
646 break;
647 }
648
649 urb->transfer_dma = buf_dma;
650
651 usb_fill_bulk_urb(urb, priv->udev,
652 priv->rx_pipe,
653 buf, MCBA_USB_RX_BUFF_SIZE,
654 mcba_usb_read_bulk_callback, priv);
655 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
656 usb_anchor_urb(urb, &priv->rx_submitted);
657
658 err = usb_submit_urb(urb, GFP_KERNEL);
659 if (err) {
660 usb_unanchor_urb(urb);
661 usb_free_coherent(priv->udev, MCBA_USB_RX_BUFF_SIZE,
662 buf, buf_dma);
663 usb_free_urb(urb);
664 break;
665 }
666
667 priv->rxbuf[i] = buf;
668 priv->rxbuf_dma[i] = buf_dma;
669
670 /* Drop reference, USB core will take care of freeing it */
671 usb_free_urb(urb);
672 }
673
674 /* Did we submit any URBs */
675 if (i == 0) {
676 netdev_warn(netdev, "couldn't setup read URBs\n");
677 return err;
678 }
679
680 /* Warn if we've couldn't transmit all the URBs */
681 if (i < MCBA_MAX_RX_URBS)
682 netdev_warn(netdev, "rx performance may be slow\n");
683
684 mcba_usb_xmit_read_fw_ver(priv, MCBA_VER_REQ_USB);
685 mcba_usb_xmit_read_fw_ver(priv, MCBA_VER_REQ_CAN);
686
687 return err;
688}
689
690/* Open USB device */
691static int mcba_usb_open(struct net_device *netdev)
692{
693 struct mcba_priv *priv = netdev_priv(netdev);
694 int err;
695
696 /* common open */
697 err = open_candev(netdev);
698 if (err)
699 return err;
700
701 priv->can_speed_check = true;
702 priv->can.state = CAN_STATE_ERROR_ACTIVE;
703
704 netif_start_queue(netdev);
705
706 return 0;
707}
708
709static void mcba_urb_unlink(struct mcba_priv *priv)
710{
711 int i;
712
713 usb_kill_anchored_urbs(&priv->rx_submitted);
714
715 for (i = 0; i < MCBA_MAX_RX_URBS; ++i)
716 usb_free_coherent(priv->udev, MCBA_USB_RX_BUFF_SIZE,
717 priv->rxbuf[i], priv->rxbuf_dma[i]);
718
719 usb_kill_anchored_urbs(&priv->tx_submitted);
720}
721
722/* Close USB device */
723static int mcba_usb_close(struct net_device *netdev)
724{
725 struct mcba_priv *priv = netdev_priv(netdev);
726
727 priv->can.state = CAN_STATE_STOPPED;
728
729 netif_stop_queue(netdev);
730
731 /* Stop polling */
732 mcba_urb_unlink(priv);
733
734 close_candev(netdev);
735
736 return 0;
737}
738
739/* Set network device mode
740 *
741 * Maybe we should leave this function empty, because the device
742 * set mode variable with open command.
743 */
744static int mcba_net_set_mode(struct net_device *netdev, enum can_mode mode)
745{
746 return 0;
747}
748
749static int mcba_net_get_berr_counter(const struct net_device *netdev,
750 struct can_berr_counter *bec)
751{
752 struct mcba_priv *priv = netdev_priv(netdev);
753
754 bec->txerr = priv->bec.txerr;
755 bec->rxerr = priv->bec.rxerr;
756
757 return 0;
758}
759
760static const struct net_device_ops mcba_netdev_ops = {
761 .ndo_open = mcba_usb_open,
762 .ndo_stop = mcba_usb_close,
763 .ndo_start_xmit = mcba_usb_start_xmit,
764};
765
766static const struct ethtool_ops mcba_ethtool_ops = {
767 .get_ts_info = ethtool_op_get_ts_info,
768};
769
770/* Microchip CANBUS has hardcoded bittiming values by default.
771 * This function sends request via USB to change the speed and align bittiming
772 * values for presentation purposes only
773 */
774static int mcba_net_set_bittiming(struct net_device *netdev)
775{
776 struct mcba_priv *priv = netdev_priv(netdev);
777 const u16 bitrate_kbps = priv->can.bittiming.bitrate / 1000;
778
779 mcba_usb_xmit_change_bitrate(priv, bitrate_kbps);
780
781 return 0;
782}
783
784static int mcba_set_termination(struct net_device *netdev, u16 term)
785{
786 struct mcba_priv *priv = netdev_priv(netdev);
787 struct mcba_usb_msg_termination usb_msg = {
788 .cmd_id = MBCA_CMD_SETUP_TERMINATION_RESISTANCE
789 };
790
791 if (term == MCBA_TERMINATION_ENABLED)
792 usb_msg.termination = MCBA_VER_TERMINATION_ON;
793 else
794 usb_msg.termination = MCBA_VER_TERMINATION_OFF;
795
796 mcba_usb_xmit_cmd(priv, (struct mcba_usb_msg *)&usb_msg);
797
798 return 0;
799}
800
801static int mcba_usb_probe(struct usb_interface *intf,
802 const struct usb_device_id *id)
803{
804 struct net_device *netdev;
805 struct mcba_priv *priv;
806 int err;
807 struct usb_device *usbdev = interface_to_usbdev(intf);
808 struct usb_endpoint_descriptor *in, *out;
809
810 err = usb_find_common_endpoints(intf->cur_altsetting, &in, &out, NULL, NULL);
811 if (err) {
812 dev_err(&intf->dev, "Can't find endpoints\n");
813 return err;
814 }
815
816 netdev = alloc_candev(sizeof(struct mcba_priv), MCBA_MAX_TX_URBS);
817 if (!netdev) {
818 dev_err(&intf->dev, "Couldn't alloc candev\n");
819 return -ENOMEM;
820 }
821
822 priv = netdev_priv(netdev);
823
824 priv->udev = usbdev;
825 priv->netdev = netdev;
826 priv->usb_ka_first_pass = true;
827 priv->can_ka_first_pass = true;
828 priv->can_speed_check = false;
829
830 init_usb_anchor(&priv->rx_submitted);
831 init_usb_anchor(&priv->tx_submitted);
832
833 usb_set_intfdata(intf, priv);
834
835 /* Init CAN device */
836 priv->can.state = CAN_STATE_STOPPED;
837 priv->can.termination_const = mcba_termination;
838 priv->can.termination_const_cnt = ARRAY_SIZE(mcba_termination);
839 priv->can.bitrate_const = mcba_bitrate;
840 priv->can.bitrate_const_cnt = ARRAY_SIZE(mcba_bitrate);
841
842 priv->can.do_set_termination = mcba_set_termination;
843 priv->can.do_set_mode = mcba_net_set_mode;
844 priv->can.do_get_berr_counter = mcba_net_get_berr_counter;
845 priv->can.do_set_bittiming = mcba_net_set_bittiming;
846
847 netdev->netdev_ops = &mcba_netdev_ops;
848 netdev->ethtool_ops = &mcba_ethtool_ops;
849
850 netdev->flags |= IFF_ECHO; /* we support local echo */
851
852 SET_NETDEV_DEV(netdev, &intf->dev);
853
854 err = register_candev(netdev);
855 if (err) {
856 netdev_err(netdev, "couldn't register CAN device: %d\n", err);
857
858 goto cleanup_free_candev;
859 }
860
861 priv->rx_pipe = usb_rcvbulkpipe(priv->udev, in->bEndpointAddress);
862 priv->tx_pipe = usb_sndbulkpipe(priv->udev, out->bEndpointAddress);
863
864 /* Start USB dev only if we have successfully registered CAN device */
865 err = mcba_usb_start(priv);
866 if (err) {
867 if (err == -ENODEV)
868 netif_device_detach(priv->netdev);
869
870 netdev_warn(netdev, "couldn't start device: %d\n", err);
871
872 goto cleanup_unregister_candev;
873 }
874
875 dev_info(&intf->dev, "Microchip CAN BUS Analyzer connected\n");
876
877 return 0;
878
879cleanup_unregister_candev:
880 unregister_candev(priv->netdev);
881
882cleanup_free_candev:
883 free_candev(netdev);
884
885 return err;
886}
887
888/* Called by the usb core when driver is unloaded or device is removed */
889static void mcba_usb_disconnect(struct usb_interface *intf)
890{
891 struct mcba_priv *priv = usb_get_intfdata(intf);
892
893 usb_set_intfdata(intf, NULL);
894
895 netdev_info(priv->netdev, "device disconnected\n");
896
897 unregister_candev(priv->netdev);
898 mcba_urb_unlink(priv);
899 free_candev(priv->netdev);
900}
901
902static struct usb_driver mcba_usb_driver = {
903 .name = MCBA_MODULE_NAME,
904 .probe = mcba_usb_probe,
905 .disconnect = mcba_usb_disconnect,
906 .id_table = mcba_usb_table,
907};
908
909module_usb_driver(mcba_usb_driver);
910
911MODULE_AUTHOR("Remigiusz Kołłątaj <remigiusz.kollataj@mobica.com>");
912MODULE_DESCRIPTION("SocketCAN driver for Microchip CAN BUS Analyzer Tool");
913MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0-only
2/* SocketCAN driver for Microchip CAN BUS Analyzer Tool
3 *
4 * Copyright (C) 2017 Mobica Limited
5 *
6 * This driver is inspired by the 4.6.2 version of net/can/usb/usb_8dev.c
7 */
8
9#include <asm/unaligned.h>
10#include <linux/can.h>
11#include <linux/can/dev.h>
12#include <linux/can/error.h>
13#include <linux/can/led.h>
14#include <linux/module.h>
15#include <linux/netdevice.h>
16#include <linux/signal.h>
17#include <linux/slab.h>
18#include <linux/usb.h>
19
20/* vendor and product id */
21#define MCBA_MODULE_NAME "mcba_usb"
22#define MCBA_VENDOR_ID 0x04d8
23#define MCBA_PRODUCT_ID 0x0a30
24
25/* driver constants */
26#define MCBA_MAX_RX_URBS 20
27#define MCBA_MAX_TX_URBS 20
28#define MCBA_CTX_FREE MCBA_MAX_TX_URBS
29
30/* RX buffer must be bigger than msg size since at the
31 * beginning USB messages are stacked.
32 */
33#define MCBA_USB_RX_BUFF_SIZE 64
34#define MCBA_USB_TX_BUFF_SIZE (sizeof(struct mcba_usb_msg))
35
36/* MCBA endpoint numbers */
37#define MCBA_USB_EP_IN 1
38#define MCBA_USB_EP_OUT 1
39
40/* Microchip command id */
41#define MBCA_CMD_RECEIVE_MESSAGE 0xE3
42#define MBCA_CMD_I_AM_ALIVE_FROM_CAN 0xF5
43#define MBCA_CMD_I_AM_ALIVE_FROM_USB 0xF7
44#define MBCA_CMD_CHANGE_BIT_RATE 0xA1
45#define MBCA_CMD_TRANSMIT_MESSAGE_EV 0xA3
46#define MBCA_CMD_SETUP_TERMINATION_RESISTANCE 0xA8
47#define MBCA_CMD_READ_FW_VERSION 0xA9
48#define MBCA_CMD_NOTHING_TO_SEND 0xFF
49#define MBCA_CMD_TRANSMIT_MESSAGE_RSP 0xE2
50
51#define MCBA_VER_REQ_USB 1
52#define MCBA_VER_REQ_CAN 2
53
54#define MCBA_SIDL_EXID_MASK 0x8
55#define MCBA_DLC_MASK 0xf
56#define MCBA_DLC_RTR_MASK 0x40
57
58#define MCBA_CAN_STATE_WRN_TH 95
59#define MCBA_CAN_STATE_ERR_PSV_TH 127
60
61#define MCBA_TERMINATION_DISABLED CAN_TERMINATION_DISABLED
62#define MCBA_TERMINATION_ENABLED 120
63
64struct mcba_usb_ctx {
65 struct mcba_priv *priv;
66 u32 ndx;
67 u8 dlc;
68 bool can;
69};
70
71/* Structure to hold all of our device specific stuff */
72struct mcba_priv {
73 struct can_priv can; /* must be the first member */
74 struct sk_buff *echo_skb[MCBA_MAX_TX_URBS];
75 struct mcba_usb_ctx tx_context[MCBA_MAX_TX_URBS];
76 struct usb_device *udev;
77 struct net_device *netdev;
78 struct usb_anchor tx_submitted;
79 struct usb_anchor rx_submitted;
80 struct can_berr_counter bec;
81 bool usb_ka_first_pass;
82 bool can_ka_first_pass;
83 bool can_speed_check;
84 atomic_t free_ctx_cnt;
85 void *rxbuf[MCBA_MAX_RX_URBS];
86 dma_addr_t rxbuf_dma[MCBA_MAX_RX_URBS];
87};
88
89/* CAN frame */
90struct __packed mcba_usb_msg_can {
91 u8 cmd_id;
92 __be16 eid;
93 __be16 sid;
94 u8 dlc;
95 u8 data[8];
96 u8 timestamp[4];
97 u8 checksum;
98};
99
100/* command frame */
101struct __packed mcba_usb_msg {
102 u8 cmd_id;
103 u8 unused[18];
104};
105
106struct __packed mcba_usb_msg_ka_usb {
107 u8 cmd_id;
108 u8 termination_state;
109 u8 soft_ver_major;
110 u8 soft_ver_minor;
111 u8 unused[15];
112};
113
114struct __packed mcba_usb_msg_ka_can {
115 u8 cmd_id;
116 u8 tx_err_cnt;
117 u8 rx_err_cnt;
118 u8 rx_buff_ovfl;
119 u8 tx_bus_off;
120 __be16 can_bitrate;
121 __le16 rx_lost;
122 u8 can_stat;
123 u8 soft_ver_major;
124 u8 soft_ver_minor;
125 u8 debug_mode;
126 u8 test_complete;
127 u8 test_result;
128 u8 unused[4];
129};
130
131struct __packed mcba_usb_msg_change_bitrate {
132 u8 cmd_id;
133 __be16 bitrate;
134 u8 unused[16];
135};
136
137struct __packed mcba_usb_msg_termination {
138 u8 cmd_id;
139 u8 termination;
140 u8 unused[17];
141};
142
143struct __packed mcba_usb_msg_fw_ver {
144 u8 cmd_id;
145 u8 pic;
146 u8 unused[17];
147};
148
149static const struct usb_device_id mcba_usb_table[] = {
150 { USB_DEVICE(MCBA_VENDOR_ID, MCBA_PRODUCT_ID) },
151 {} /* Terminating entry */
152};
153
154MODULE_DEVICE_TABLE(usb, mcba_usb_table);
155
156static const u16 mcba_termination[] = { MCBA_TERMINATION_DISABLED,
157 MCBA_TERMINATION_ENABLED };
158
159static const u32 mcba_bitrate[] = { 20000, 33333, 50000, 80000, 83333,
160 100000, 125000, 150000, 175000, 200000,
161 225000, 250000, 275000, 300000, 500000,
162 625000, 800000, 1000000 };
163
164static inline void mcba_init_ctx(struct mcba_priv *priv)
165{
166 int i = 0;
167
168 for (i = 0; i < MCBA_MAX_TX_URBS; i++) {
169 priv->tx_context[i].ndx = MCBA_CTX_FREE;
170 priv->tx_context[i].priv = priv;
171 }
172
173 atomic_set(&priv->free_ctx_cnt, ARRAY_SIZE(priv->tx_context));
174}
175
176static inline struct mcba_usb_ctx *mcba_usb_get_free_ctx(struct mcba_priv *priv,
177 struct can_frame *cf)
178{
179 int i = 0;
180 struct mcba_usb_ctx *ctx = NULL;
181
182 for (i = 0; i < MCBA_MAX_TX_URBS; i++) {
183 if (priv->tx_context[i].ndx == MCBA_CTX_FREE) {
184 ctx = &priv->tx_context[i];
185 ctx->ndx = i;
186
187 if (cf) {
188 ctx->can = true;
189 ctx->dlc = cf->len;
190 } else {
191 ctx->can = false;
192 ctx->dlc = 0;
193 }
194
195 atomic_dec(&priv->free_ctx_cnt);
196 break;
197 }
198 }
199
200 if (!atomic_read(&priv->free_ctx_cnt))
201 /* That was the last free ctx. Slow down tx path */
202 netif_stop_queue(priv->netdev);
203
204 return ctx;
205}
206
207/* mcba_usb_free_ctx and mcba_usb_get_free_ctx are executed by different
208 * threads. The order of execution in below function is important.
209 */
210static inline void mcba_usb_free_ctx(struct mcba_usb_ctx *ctx)
211{
212 /* Increase number of free ctxs before freeing ctx */
213 atomic_inc(&ctx->priv->free_ctx_cnt);
214
215 ctx->ndx = MCBA_CTX_FREE;
216
217 /* Wake up the queue once ctx is marked free */
218 netif_wake_queue(ctx->priv->netdev);
219}
220
221static void mcba_usb_write_bulk_callback(struct urb *urb)
222{
223 struct mcba_usb_ctx *ctx = urb->context;
224 struct net_device *netdev;
225
226 WARN_ON(!ctx);
227
228 netdev = ctx->priv->netdev;
229
230 /* free up our allocated buffer */
231 usb_free_coherent(urb->dev, urb->transfer_buffer_length,
232 urb->transfer_buffer, urb->transfer_dma);
233
234 if (ctx->can) {
235 if (!netif_device_present(netdev))
236 return;
237
238 netdev->stats.tx_packets++;
239 netdev->stats.tx_bytes += ctx->dlc;
240
241 can_led_event(netdev, CAN_LED_EVENT_TX);
242 can_get_echo_skb(netdev, ctx->ndx, NULL);
243 }
244
245 if (urb->status)
246 netdev_info(netdev, "Tx URB aborted (%d)\n", urb->status);
247
248 /* Release the context */
249 mcba_usb_free_ctx(ctx);
250}
251
252/* Send data to device */
253static netdev_tx_t mcba_usb_xmit(struct mcba_priv *priv,
254 struct mcba_usb_msg *usb_msg,
255 struct mcba_usb_ctx *ctx)
256{
257 struct urb *urb;
258 u8 *buf;
259 int err;
260
261 /* create a URB, and a buffer for it, and copy the data to the URB */
262 urb = usb_alloc_urb(0, GFP_ATOMIC);
263 if (!urb)
264 return -ENOMEM;
265
266 buf = usb_alloc_coherent(priv->udev, MCBA_USB_TX_BUFF_SIZE, GFP_ATOMIC,
267 &urb->transfer_dma);
268 if (!buf) {
269 err = -ENOMEM;
270 goto nomembuf;
271 }
272
273 memcpy(buf, usb_msg, MCBA_USB_TX_BUFF_SIZE);
274
275 usb_fill_bulk_urb(urb, priv->udev,
276 usb_sndbulkpipe(priv->udev, MCBA_USB_EP_OUT), buf,
277 MCBA_USB_TX_BUFF_SIZE, mcba_usb_write_bulk_callback,
278 ctx);
279
280 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
281 usb_anchor_urb(urb, &priv->tx_submitted);
282
283 err = usb_submit_urb(urb, GFP_ATOMIC);
284 if (unlikely(err))
285 goto failed;
286
287 /* Release our reference to this URB, the USB core will eventually free
288 * it entirely.
289 */
290 usb_free_urb(urb);
291
292 return 0;
293
294failed:
295 usb_unanchor_urb(urb);
296 usb_free_coherent(priv->udev, MCBA_USB_TX_BUFF_SIZE, buf,
297 urb->transfer_dma);
298
299 if (err == -ENODEV)
300 netif_device_detach(priv->netdev);
301 else
302 netdev_warn(priv->netdev, "failed tx_urb %d\n", err);
303
304nomembuf:
305 usb_free_urb(urb);
306
307 return err;
308}
309
310/* Send data to device */
311static netdev_tx_t mcba_usb_start_xmit(struct sk_buff *skb,
312 struct net_device *netdev)
313{
314 struct mcba_priv *priv = netdev_priv(netdev);
315 struct can_frame *cf = (struct can_frame *)skb->data;
316 struct mcba_usb_ctx *ctx = NULL;
317 struct net_device_stats *stats = &priv->netdev->stats;
318 u16 sid;
319 int err;
320 struct mcba_usb_msg_can usb_msg = {
321 .cmd_id = MBCA_CMD_TRANSMIT_MESSAGE_EV
322 };
323
324 if (can_dropped_invalid_skb(netdev, skb))
325 return NETDEV_TX_OK;
326
327 ctx = mcba_usb_get_free_ctx(priv, cf);
328 if (!ctx)
329 return NETDEV_TX_BUSY;
330
331 if (cf->can_id & CAN_EFF_FLAG) {
332 /* SIDH | SIDL | EIDH | EIDL
333 * 28 - 21 | 20 19 18 x x x 17 16 | 15 - 8 | 7 - 0
334 */
335 sid = MCBA_SIDL_EXID_MASK;
336 /* store 28-18 bits */
337 sid |= (cf->can_id & 0x1ffc0000) >> 13;
338 /* store 17-16 bits */
339 sid |= (cf->can_id & 0x30000) >> 16;
340 put_unaligned_be16(sid, &usb_msg.sid);
341
342 /* store 15-0 bits */
343 put_unaligned_be16(cf->can_id & 0xffff, &usb_msg.eid);
344 } else {
345 /* SIDH | SIDL
346 * 10 - 3 | 2 1 0 x x x x x
347 */
348 put_unaligned_be16((cf->can_id & CAN_SFF_MASK) << 5,
349 &usb_msg.sid);
350 usb_msg.eid = 0;
351 }
352
353 usb_msg.dlc = cf->len;
354
355 memcpy(usb_msg.data, cf->data, usb_msg.dlc);
356
357 if (cf->can_id & CAN_RTR_FLAG)
358 usb_msg.dlc |= MCBA_DLC_RTR_MASK;
359
360 can_put_echo_skb(skb, priv->netdev, ctx->ndx, 0);
361
362 err = mcba_usb_xmit(priv, (struct mcba_usb_msg *)&usb_msg, ctx);
363 if (err)
364 goto xmit_failed;
365
366 return NETDEV_TX_OK;
367
368xmit_failed:
369 can_free_echo_skb(priv->netdev, ctx->ndx, NULL);
370 mcba_usb_free_ctx(ctx);
371 dev_kfree_skb(skb);
372 stats->tx_dropped++;
373
374 return NETDEV_TX_OK;
375}
376
377/* Send cmd to device */
378static void mcba_usb_xmit_cmd(struct mcba_priv *priv,
379 struct mcba_usb_msg *usb_msg)
380{
381 struct mcba_usb_ctx *ctx = NULL;
382 int err;
383
384 ctx = mcba_usb_get_free_ctx(priv, NULL);
385 if (!ctx) {
386 netdev_err(priv->netdev,
387 "Lack of free ctx. Sending (%d) cmd aborted",
388 usb_msg->cmd_id);
389
390 return;
391 }
392
393 err = mcba_usb_xmit(priv, usb_msg, ctx);
394 if (err)
395 netdev_err(priv->netdev, "Failed to send cmd (%d)",
396 usb_msg->cmd_id);
397}
398
399static void mcba_usb_xmit_change_bitrate(struct mcba_priv *priv, u16 bitrate)
400{
401 struct mcba_usb_msg_change_bitrate usb_msg = {
402 .cmd_id = MBCA_CMD_CHANGE_BIT_RATE
403 };
404
405 put_unaligned_be16(bitrate, &usb_msg.bitrate);
406
407 mcba_usb_xmit_cmd(priv, (struct mcba_usb_msg *)&usb_msg);
408}
409
410static void mcba_usb_xmit_read_fw_ver(struct mcba_priv *priv, u8 pic)
411{
412 struct mcba_usb_msg_fw_ver usb_msg = {
413 .cmd_id = MBCA_CMD_READ_FW_VERSION,
414 .pic = pic
415 };
416
417 mcba_usb_xmit_cmd(priv, (struct mcba_usb_msg *)&usb_msg);
418}
419
420static void mcba_usb_process_can(struct mcba_priv *priv,
421 struct mcba_usb_msg_can *msg)
422{
423 struct can_frame *cf;
424 struct sk_buff *skb;
425 struct net_device_stats *stats = &priv->netdev->stats;
426 u16 sid;
427
428 skb = alloc_can_skb(priv->netdev, &cf);
429 if (!skb)
430 return;
431
432 sid = get_unaligned_be16(&msg->sid);
433
434 if (sid & MCBA_SIDL_EXID_MASK) {
435 /* SIDH | SIDL | EIDH | EIDL
436 * 28 - 21 | 20 19 18 x x x 17 16 | 15 - 8 | 7 - 0
437 */
438 cf->can_id = CAN_EFF_FLAG;
439
440 /* store 28-18 bits */
441 cf->can_id |= (sid & 0xffe0) << 13;
442 /* store 17-16 bits */
443 cf->can_id |= (sid & 3) << 16;
444 /* store 15-0 bits */
445 cf->can_id |= get_unaligned_be16(&msg->eid);
446 } else {
447 /* SIDH | SIDL
448 * 10 - 3 | 2 1 0 x x x x x
449 */
450 cf->can_id = (sid & 0xffe0) >> 5;
451 }
452
453 if (msg->dlc & MCBA_DLC_RTR_MASK)
454 cf->can_id |= CAN_RTR_FLAG;
455
456 cf->len = can_cc_dlc2len(msg->dlc & MCBA_DLC_MASK);
457
458 memcpy(cf->data, msg->data, cf->len);
459
460 stats->rx_packets++;
461 stats->rx_bytes += cf->len;
462
463 can_led_event(priv->netdev, CAN_LED_EVENT_RX);
464 netif_rx(skb);
465}
466
467static void mcba_usb_process_ka_usb(struct mcba_priv *priv,
468 struct mcba_usb_msg_ka_usb *msg)
469{
470 if (unlikely(priv->usb_ka_first_pass)) {
471 netdev_info(priv->netdev, "PIC USB version %u.%u\n",
472 msg->soft_ver_major, msg->soft_ver_minor);
473
474 priv->usb_ka_first_pass = false;
475 }
476
477 if (msg->termination_state)
478 priv->can.termination = MCBA_TERMINATION_ENABLED;
479 else
480 priv->can.termination = MCBA_TERMINATION_DISABLED;
481}
482
483static u32 convert_can2host_bitrate(struct mcba_usb_msg_ka_can *msg)
484{
485 const u32 bitrate = get_unaligned_be16(&msg->can_bitrate);
486
487 if ((bitrate == 33) || (bitrate == 83))
488 return bitrate * 1000 + 333;
489 else
490 return bitrate * 1000;
491}
492
493static void mcba_usb_process_ka_can(struct mcba_priv *priv,
494 struct mcba_usb_msg_ka_can *msg)
495{
496 if (unlikely(priv->can_ka_first_pass)) {
497 netdev_info(priv->netdev, "PIC CAN version %u.%u\n",
498 msg->soft_ver_major, msg->soft_ver_minor);
499
500 priv->can_ka_first_pass = false;
501 }
502
503 if (unlikely(priv->can_speed_check)) {
504 const u32 bitrate = convert_can2host_bitrate(msg);
505
506 priv->can_speed_check = false;
507
508 if (bitrate != priv->can.bittiming.bitrate)
509 netdev_err(
510 priv->netdev,
511 "Wrong bitrate reported by the device (%u). Expected %u",
512 bitrate, priv->can.bittiming.bitrate);
513 }
514
515 priv->bec.txerr = msg->tx_err_cnt;
516 priv->bec.rxerr = msg->rx_err_cnt;
517
518 if (msg->tx_bus_off)
519 priv->can.state = CAN_STATE_BUS_OFF;
520
521 else if ((priv->bec.txerr > MCBA_CAN_STATE_ERR_PSV_TH) ||
522 (priv->bec.rxerr > MCBA_CAN_STATE_ERR_PSV_TH))
523 priv->can.state = CAN_STATE_ERROR_PASSIVE;
524
525 else if ((priv->bec.txerr > MCBA_CAN_STATE_WRN_TH) ||
526 (priv->bec.rxerr > MCBA_CAN_STATE_WRN_TH))
527 priv->can.state = CAN_STATE_ERROR_WARNING;
528}
529
530static void mcba_usb_process_rx(struct mcba_priv *priv,
531 struct mcba_usb_msg *msg)
532{
533 switch (msg->cmd_id) {
534 case MBCA_CMD_I_AM_ALIVE_FROM_CAN:
535 mcba_usb_process_ka_can(priv,
536 (struct mcba_usb_msg_ka_can *)msg);
537 break;
538
539 case MBCA_CMD_I_AM_ALIVE_FROM_USB:
540 mcba_usb_process_ka_usb(priv,
541 (struct mcba_usb_msg_ka_usb *)msg);
542 break;
543
544 case MBCA_CMD_RECEIVE_MESSAGE:
545 mcba_usb_process_can(priv, (struct mcba_usb_msg_can *)msg);
546 break;
547
548 case MBCA_CMD_NOTHING_TO_SEND:
549 /* Side effect of communication between PIC_USB and PIC_CAN.
550 * PIC_CAN is telling us that it has nothing to send
551 */
552 break;
553
554 case MBCA_CMD_TRANSMIT_MESSAGE_RSP:
555 /* Transmission response from the device containing timestamp */
556 break;
557
558 default:
559 netdev_warn(priv->netdev, "Unsupported msg (0x%X)",
560 msg->cmd_id);
561 break;
562 }
563}
564
565/* Callback for reading data from device
566 *
567 * Check urb status, call read function and resubmit urb read operation.
568 */
569static void mcba_usb_read_bulk_callback(struct urb *urb)
570{
571 struct mcba_priv *priv = urb->context;
572 struct net_device *netdev;
573 int retval;
574 int pos = 0;
575
576 netdev = priv->netdev;
577
578 if (!netif_device_present(netdev))
579 return;
580
581 switch (urb->status) {
582 case 0: /* success */
583 break;
584
585 case -ENOENT:
586 case -EPIPE:
587 case -EPROTO:
588 case -ESHUTDOWN:
589 return;
590
591 default:
592 netdev_info(netdev, "Rx URB aborted (%d)\n", urb->status);
593
594 goto resubmit_urb;
595 }
596
597 while (pos < urb->actual_length) {
598 struct mcba_usb_msg *msg;
599
600 if (pos + sizeof(struct mcba_usb_msg) > urb->actual_length) {
601 netdev_err(priv->netdev, "format error\n");
602 break;
603 }
604
605 msg = (struct mcba_usb_msg *)(urb->transfer_buffer + pos);
606 mcba_usb_process_rx(priv, msg);
607
608 pos += sizeof(struct mcba_usb_msg);
609 }
610
611resubmit_urb:
612
613 usb_fill_bulk_urb(urb, priv->udev,
614 usb_rcvbulkpipe(priv->udev, MCBA_USB_EP_OUT),
615 urb->transfer_buffer, MCBA_USB_RX_BUFF_SIZE,
616 mcba_usb_read_bulk_callback, priv);
617
618 retval = usb_submit_urb(urb, GFP_ATOMIC);
619
620 if (retval == -ENODEV)
621 netif_device_detach(netdev);
622 else if (retval)
623 netdev_err(netdev, "failed resubmitting read bulk urb: %d\n",
624 retval);
625}
626
627/* Start USB device */
628static int mcba_usb_start(struct mcba_priv *priv)
629{
630 struct net_device *netdev = priv->netdev;
631 int err, i;
632
633 mcba_init_ctx(priv);
634
635 for (i = 0; i < MCBA_MAX_RX_URBS; i++) {
636 struct urb *urb = NULL;
637 u8 *buf;
638 dma_addr_t buf_dma;
639
640 /* create a URB, and a buffer for it */
641 urb = usb_alloc_urb(0, GFP_KERNEL);
642 if (!urb) {
643 err = -ENOMEM;
644 break;
645 }
646
647 buf = usb_alloc_coherent(priv->udev, MCBA_USB_RX_BUFF_SIZE,
648 GFP_KERNEL, &buf_dma);
649 if (!buf) {
650 netdev_err(netdev, "No memory left for USB buffer\n");
651 usb_free_urb(urb);
652 err = -ENOMEM;
653 break;
654 }
655
656 urb->transfer_dma = buf_dma;
657
658 usb_fill_bulk_urb(urb, priv->udev,
659 usb_rcvbulkpipe(priv->udev, MCBA_USB_EP_IN),
660 buf, MCBA_USB_RX_BUFF_SIZE,
661 mcba_usb_read_bulk_callback, priv);
662 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
663 usb_anchor_urb(urb, &priv->rx_submitted);
664
665 err = usb_submit_urb(urb, GFP_KERNEL);
666 if (err) {
667 usb_unanchor_urb(urb);
668 usb_free_coherent(priv->udev, MCBA_USB_RX_BUFF_SIZE,
669 buf, buf_dma);
670 usb_free_urb(urb);
671 break;
672 }
673
674 priv->rxbuf[i] = buf;
675 priv->rxbuf_dma[i] = buf_dma;
676
677 /* Drop reference, USB core will take care of freeing it */
678 usb_free_urb(urb);
679 }
680
681 /* Did we submit any URBs */
682 if (i == 0) {
683 netdev_warn(netdev, "couldn't setup read URBs\n");
684 return err;
685 }
686
687 /* Warn if we've couldn't transmit all the URBs */
688 if (i < MCBA_MAX_RX_URBS)
689 netdev_warn(netdev, "rx performance may be slow\n");
690
691 mcba_usb_xmit_read_fw_ver(priv, MCBA_VER_REQ_USB);
692 mcba_usb_xmit_read_fw_ver(priv, MCBA_VER_REQ_CAN);
693
694 return err;
695}
696
697/* Open USB device */
698static int mcba_usb_open(struct net_device *netdev)
699{
700 struct mcba_priv *priv = netdev_priv(netdev);
701 int err;
702
703 /* common open */
704 err = open_candev(netdev);
705 if (err)
706 return err;
707
708 priv->can_speed_check = true;
709 priv->can.state = CAN_STATE_ERROR_ACTIVE;
710
711 can_led_event(netdev, CAN_LED_EVENT_OPEN);
712 netif_start_queue(netdev);
713
714 return 0;
715}
716
717static void mcba_urb_unlink(struct mcba_priv *priv)
718{
719 int i;
720
721 usb_kill_anchored_urbs(&priv->rx_submitted);
722
723 for (i = 0; i < MCBA_MAX_RX_URBS; ++i)
724 usb_free_coherent(priv->udev, MCBA_USB_RX_BUFF_SIZE,
725 priv->rxbuf[i], priv->rxbuf_dma[i]);
726
727 usb_kill_anchored_urbs(&priv->tx_submitted);
728}
729
730/* Close USB device */
731static int mcba_usb_close(struct net_device *netdev)
732{
733 struct mcba_priv *priv = netdev_priv(netdev);
734
735 priv->can.state = CAN_STATE_STOPPED;
736
737 netif_stop_queue(netdev);
738
739 /* Stop polling */
740 mcba_urb_unlink(priv);
741
742 close_candev(netdev);
743 can_led_event(netdev, CAN_LED_EVENT_STOP);
744
745 return 0;
746}
747
748/* Set network device mode
749 *
750 * Maybe we should leave this function empty, because the device
751 * set mode variable with open command.
752 */
753static int mcba_net_set_mode(struct net_device *netdev, enum can_mode mode)
754{
755 return 0;
756}
757
758static int mcba_net_get_berr_counter(const struct net_device *netdev,
759 struct can_berr_counter *bec)
760{
761 struct mcba_priv *priv = netdev_priv(netdev);
762
763 bec->txerr = priv->bec.txerr;
764 bec->rxerr = priv->bec.rxerr;
765
766 return 0;
767}
768
769static const struct net_device_ops mcba_netdev_ops = {
770 .ndo_open = mcba_usb_open,
771 .ndo_stop = mcba_usb_close,
772 .ndo_start_xmit = mcba_usb_start_xmit,
773};
774
775/* Microchip CANBUS has hardcoded bittiming values by default.
776 * This function sends request via USB to change the speed and align bittiming
777 * values for presentation purposes only
778 */
779static int mcba_net_set_bittiming(struct net_device *netdev)
780{
781 struct mcba_priv *priv = netdev_priv(netdev);
782 const u16 bitrate_kbps = priv->can.bittiming.bitrate / 1000;
783
784 mcba_usb_xmit_change_bitrate(priv, bitrate_kbps);
785
786 return 0;
787}
788
789static int mcba_set_termination(struct net_device *netdev, u16 term)
790{
791 struct mcba_priv *priv = netdev_priv(netdev);
792 struct mcba_usb_msg_termination usb_msg = {
793 .cmd_id = MBCA_CMD_SETUP_TERMINATION_RESISTANCE
794 };
795
796 if (term == MCBA_TERMINATION_ENABLED)
797 usb_msg.termination = 1;
798 else
799 usb_msg.termination = 0;
800
801 mcba_usb_xmit_cmd(priv, (struct mcba_usb_msg *)&usb_msg);
802
803 return 0;
804}
805
806static int mcba_usb_probe(struct usb_interface *intf,
807 const struct usb_device_id *id)
808{
809 struct net_device *netdev;
810 struct mcba_priv *priv;
811 int err;
812 struct usb_device *usbdev = interface_to_usbdev(intf);
813
814 netdev = alloc_candev(sizeof(struct mcba_priv), MCBA_MAX_TX_URBS);
815 if (!netdev) {
816 dev_err(&intf->dev, "Couldn't alloc candev\n");
817 return -ENOMEM;
818 }
819
820 priv = netdev_priv(netdev);
821
822 priv->udev = usbdev;
823 priv->netdev = netdev;
824 priv->usb_ka_first_pass = true;
825 priv->can_ka_first_pass = true;
826 priv->can_speed_check = false;
827
828 init_usb_anchor(&priv->rx_submitted);
829 init_usb_anchor(&priv->tx_submitted);
830
831 usb_set_intfdata(intf, priv);
832
833 /* Init CAN device */
834 priv->can.state = CAN_STATE_STOPPED;
835 priv->can.termination_const = mcba_termination;
836 priv->can.termination_const_cnt = ARRAY_SIZE(mcba_termination);
837 priv->can.bitrate_const = mcba_bitrate;
838 priv->can.bitrate_const_cnt = ARRAY_SIZE(mcba_bitrate);
839
840 priv->can.do_set_termination = mcba_set_termination;
841 priv->can.do_set_mode = mcba_net_set_mode;
842 priv->can.do_get_berr_counter = mcba_net_get_berr_counter;
843 priv->can.do_set_bittiming = mcba_net_set_bittiming;
844
845 netdev->netdev_ops = &mcba_netdev_ops;
846
847 netdev->flags |= IFF_ECHO; /* we support local echo */
848
849 SET_NETDEV_DEV(netdev, &intf->dev);
850
851 err = register_candev(netdev);
852 if (err) {
853 netdev_err(netdev, "couldn't register CAN device: %d\n", err);
854
855 goto cleanup_free_candev;
856 }
857
858 devm_can_led_init(netdev);
859
860 /* Start USB dev only if we have successfully registered CAN device */
861 err = mcba_usb_start(priv);
862 if (err) {
863 if (err == -ENODEV)
864 netif_device_detach(priv->netdev);
865
866 netdev_warn(netdev, "couldn't start device: %d\n", err);
867
868 goto cleanup_unregister_candev;
869 }
870
871 dev_info(&intf->dev, "Microchip CAN BUS Analyzer connected\n");
872
873 return 0;
874
875cleanup_unregister_candev:
876 unregister_candev(priv->netdev);
877
878cleanup_free_candev:
879 free_candev(netdev);
880
881 return err;
882}
883
884/* Called by the usb core when driver is unloaded or device is removed */
885static void mcba_usb_disconnect(struct usb_interface *intf)
886{
887 struct mcba_priv *priv = usb_get_intfdata(intf);
888
889 usb_set_intfdata(intf, NULL);
890
891 netdev_info(priv->netdev, "device disconnected\n");
892
893 unregister_candev(priv->netdev);
894 mcba_urb_unlink(priv);
895 free_candev(priv->netdev);
896}
897
898static struct usb_driver mcba_usb_driver = {
899 .name = MCBA_MODULE_NAME,
900 .probe = mcba_usb_probe,
901 .disconnect = mcba_usb_disconnect,
902 .id_table = mcba_usb_table,
903};
904
905module_usb_driver(mcba_usb_driver);
906
907MODULE_AUTHOR("Remigiusz Kołłątaj <remigiusz.kollataj@mobica.com>");
908MODULE_DESCRIPTION("SocketCAN driver for Microchip CAN BUS Analyzer Tool");
909MODULE_LICENSE("GPL v2");