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 | |
64 | struct 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 */ |
71 | struct 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 */ |
91 | struct __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 */ |
102 | struct __packed mcba_usb_msg { |
103 | u8 cmd_id; |
104 | u8 unused[18]; |
105 | }; |
106 | |
107 | struct __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 | |
115 | struct __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 | |
132 | struct __packed mcba_usb_msg_change_bitrate { |
133 | u8 cmd_id; |
134 | __be16 bitrate; |
135 | u8 unused[16]; |
136 | }; |
137 | |
138 | struct __packed mcba_usb_msg_termination { |
139 | u8 cmd_id; |
140 | u8 termination; |
141 | u8 unused[17]; |
142 | }; |
143 | |
144 | struct __packed mcba_usb_msg_fw_ver { |
145 | u8 cmd_id; |
146 | u8 pic; |
147 | u8 unused[17]; |
148 | }; |
149 | |
150 | static const struct usb_device_id mcba_usb_table[] = { |
151 | { USB_DEVICE(MCBA_VENDOR_ID, MCBA_PRODUCT_ID) }, |
152 | {} /* Terminating entry */ |
153 | }; |
154 | |
155 | MODULE_DEVICE_TABLE(usb, mcba_usb_table); |
156 | |
157 | static const u16 mcba_termination[] = { MCBA_TERMINATION_DISABLED, |
158 | MCBA_TERMINATION_ENABLED }; |
159 | |
160 | static 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 | |
165 | static 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(v: &priv->free_ctx_cnt, ARRAY_SIZE(priv->tx_context)); |
175 | } |
176 | |
177 | static 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(v: &priv->free_ctx_cnt); |
194 | break; |
195 | } |
196 | } |
197 | |
198 | if (!atomic_read(v: &priv->free_ctx_cnt)) |
199 | /* That was the last free ctx. Slow down tx path */ |
200 | netif_stop_queue(dev: 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 | */ |
208 | static inline void mcba_usb_free_ctx(struct mcba_usb_ctx *ctx) |
209 | { |
210 | /* Increase number of free ctxs before freeing ctx */ |
211 | atomic_inc(v: &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(dev: ctx->priv->netdev); |
217 | } |
218 | |
219 | static 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(dev: urb->dev, size: urb->transfer_buffer_length, |
230 | addr: urb->transfer_buffer, dma: urb->transfer_dma); |
231 | |
232 | if (ctx->can) { |
233 | if (!netif_device_present(dev: netdev)) |
234 | return; |
235 | |
236 | netdev->stats.tx_packets++; |
237 | netdev->stats.tx_bytes += can_get_echo_skb(dev: netdev, idx: ctx->ndx, |
238 | NULL); |
239 | } |
240 | |
241 | if (urb->status) |
242 | netdev_info(dev: netdev, format: "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 */ |
249 | static 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(iso_packets: 0, GFP_ATOMIC); |
259 | if (!urb) |
260 | return -ENOMEM; |
261 | |
262 | buf = usb_alloc_coherent(dev: priv->udev, MCBA_USB_TX_BUFF_SIZE, GFP_ATOMIC, |
263 | dma: &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, dev: priv->udev, pipe: priv->tx_pipe, transfer_buffer: buf, MCBA_USB_TX_BUFF_SIZE, |
272 | complete_fn: mcba_usb_write_bulk_callback, context: ctx); |
273 | |
274 | urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
275 | usb_anchor_urb(urb, anchor: &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 | |
288 | failed: |
289 | usb_unanchor_urb(urb); |
290 | usb_free_coherent(dev: priv->udev, MCBA_USB_TX_BUFF_SIZE, addr: buf, |
291 | dma: urb->transfer_dma); |
292 | |
293 | if (err == -ENODEV) |
294 | netif_device_detach(dev: priv->netdev); |
295 | else |
296 | netdev_warn(dev: priv->netdev, format: "failed tx_urb %d\n" , err); |
297 | |
298 | nomembuf: |
299 | usb_free_urb(urb); |
300 | |
301 | return err; |
302 | } |
303 | |
304 | /* Send data to device */ |
305 | static netdev_tx_t mcba_usb_start_xmit(struct sk_buff *skb, |
306 | struct net_device *netdev) |
307 | { |
308 | struct mcba_priv *priv = netdev_priv(dev: 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(dev: 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(val: sid, p: &usb_msg.sid); |
335 | |
336 | /* store 15-0 bits */ |
337 | put_unaligned_be16(val: cf->can_id & 0xffff, p: &usb_msg.eid); |
338 | } else { |
339 | /* SIDH | SIDL |
340 | * 10 - 3 | 2 1 0 x x x x x |
341 | */ |
342 | put_unaligned_be16(val: (cf->can_id & CAN_SFF_MASK) << 5, |
343 | p: &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, dev: priv->netdev, idx: ctx->ndx, frame_len: 0); |
355 | |
356 | err = mcba_usb_xmit(priv, usb_msg: (struct mcba_usb_msg *)&usb_msg, ctx); |
357 | if (err) |
358 | goto xmit_failed; |
359 | |
360 | return NETDEV_TX_OK; |
361 | |
362 | xmit_failed: |
363 | can_free_echo_skb(dev: priv->netdev, idx: 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 */ |
371 | static 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(dev: priv->netdev, |
380 | format: "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(dev: priv->netdev, format: "Failed to send cmd (%d)" , |
389 | usb_msg->cmd_id); |
390 | } |
391 | |
392 | static 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(val: bitrate, p: &usb_msg.bitrate); |
399 | |
400 | mcba_usb_xmit_cmd(priv, usb_msg: (struct mcba_usb_msg *)&usb_msg); |
401 | } |
402 | |
403 | static 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, usb_msg: (struct mcba_usb_msg *)&usb_msg); |
411 | } |
412 | |
413 | static 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(dev: priv->netdev, cf: &cf); |
422 | if (!skb) |
423 | return; |
424 | |
425 | sid = get_unaligned_be16(p: &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(p: &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 | |
460 | static 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(dev: priv->netdev, format: "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 | |
476 | static u32 convert_can2host_bitrate(struct mcba_usb_msg_ka_can *msg) |
477 | { |
478 | const u32 bitrate = get_unaligned_be16(p: &msg->can_bitrate); |
479 | |
480 | if ((bitrate == 33) || (bitrate == 83)) |
481 | return bitrate * 1000 + 333; |
482 | else |
483 | return bitrate * 1000; |
484 | } |
485 | |
486 | static 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(dev: priv->netdev, format: "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 | dev: priv->netdev, |
504 | format: "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 | |
523 | static 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 | msg: (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 | msg: (struct mcba_usb_msg_ka_usb *)msg); |
535 | break; |
536 | |
537 | case MBCA_CMD_RECEIVE_MESSAGE: |
538 | mcba_usb_process_can(priv, msg: (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(dev: priv->netdev, format: "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 | */ |
562 | static 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(dev: 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(dev: netdev, format: "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(dev: priv->netdev, format: "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 | |
604 | resubmit_urb: |
605 | |
606 | usb_fill_bulk_urb(urb, dev: priv->udev, |
607 | pipe: priv->rx_pipe, |
608 | transfer_buffer: urb->transfer_buffer, MCBA_USB_RX_BUFF_SIZE, |
609 | complete_fn: mcba_usb_read_bulk_callback, context: priv); |
610 | |
611 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
612 | |
613 | if (retval == -ENODEV) |
614 | netif_device_detach(dev: netdev); |
615 | else if (retval) |
616 | netdev_err(dev: netdev, format: "failed resubmitting read bulk urb: %d\n" , |
617 | retval); |
618 | } |
619 | |
620 | /* Start USB device */ |
621 | static 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(iso_packets: 0, GFP_KERNEL); |
635 | if (!urb) { |
636 | err = -ENOMEM; |
637 | break; |
638 | } |
639 | |
640 | buf = usb_alloc_coherent(dev: priv->udev, MCBA_USB_RX_BUFF_SIZE, |
641 | GFP_KERNEL, dma: &buf_dma); |
642 | if (!buf) { |
643 | netdev_err(dev: netdev, format: "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, dev: priv->udev, |
652 | pipe: priv->rx_pipe, |
653 | transfer_buffer: buf, MCBA_USB_RX_BUFF_SIZE, |
654 | complete_fn: mcba_usb_read_bulk_callback, context: priv); |
655 | urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
656 | usb_anchor_urb(urb, anchor: &priv->rx_submitted); |
657 | |
658 | err = usb_submit_urb(urb, GFP_KERNEL); |
659 | if (err) { |
660 | usb_unanchor_urb(urb); |
661 | usb_free_coherent(dev: priv->udev, MCBA_USB_RX_BUFF_SIZE, |
662 | addr: buf, dma: 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(dev: netdev, format: "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(dev: netdev, format: "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 */ |
691 | static int mcba_usb_open(struct net_device *netdev) |
692 | { |
693 | struct mcba_priv *priv = netdev_priv(dev: netdev); |
694 | int err; |
695 | |
696 | /* common open */ |
697 | err = open_candev(dev: 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(dev: netdev); |
705 | |
706 | return 0; |
707 | } |
708 | |
709 | static void mcba_urb_unlink(struct mcba_priv *priv) |
710 | { |
711 | int i; |
712 | |
713 | usb_kill_anchored_urbs(anchor: &priv->rx_submitted); |
714 | |
715 | for (i = 0; i < MCBA_MAX_RX_URBS; ++i) |
716 | usb_free_coherent(dev: priv->udev, MCBA_USB_RX_BUFF_SIZE, |
717 | addr: priv->rxbuf[i], dma: priv->rxbuf_dma[i]); |
718 | |
719 | usb_kill_anchored_urbs(anchor: &priv->tx_submitted); |
720 | } |
721 | |
722 | /* Close USB device */ |
723 | static int mcba_usb_close(struct net_device *netdev) |
724 | { |
725 | struct mcba_priv *priv = netdev_priv(dev: netdev); |
726 | |
727 | priv->can.state = CAN_STATE_STOPPED; |
728 | |
729 | netif_stop_queue(dev: netdev); |
730 | |
731 | /* Stop polling */ |
732 | mcba_urb_unlink(priv); |
733 | |
734 | close_candev(dev: 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 | */ |
744 | static int mcba_net_set_mode(struct net_device *netdev, enum can_mode mode) |
745 | { |
746 | return 0; |
747 | } |
748 | |
749 | static 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(dev: netdev); |
753 | |
754 | bec->txerr = priv->bec.txerr; |
755 | bec->rxerr = priv->bec.rxerr; |
756 | |
757 | return 0; |
758 | } |
759 | |
760 | static 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 | |
766 | static 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 | */ |
774 | static int mcba_net_set_bittiming(struct net_device *netdev) |
775 | { |
776 | struct mcba_priv *priv = netdev_priv(dev: netdev); |
777 | const u16 bitrate_kbps = priv->can.bittiming.bitrate / 1000; |
778 | |
779 | mcba_usb_xmit_change_bitrate(priv, bitrate: bitrate_kbps); |
780 | |
781 | return 0; |
782 | } |
783 | |
784 | static int mcba_set_termination(struct net_device *netdev, u16 term) |
785 | { |
786 | struct mcba_priv *priv = netdev_priv(dev: 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, usb_msg: (struct mcba_usb_msg *)&usb_msg); |
797 | |
798 | return 0; |
799 | } |
800 | |
801 | static 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(alt: intf->cur_altsetting, bulk_in: &in, bulk_out: &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(dev: 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(anchor: &priv->rx_submitted); |
831 | init_usb_anchor(anchor: &priv->tx_submitted); |
832 | |
833 | usb_set_intfdata(intf, data: 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(dev: netdev); |
855 | if (err) { |
856 | netdev_err(dev: netdev, format: "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(dev: priv->netdev); |
869 | |
870 | netdev_warn(dev: netdev, format: "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 | |
879 | cleanup_unregister_candev: |
880 | unregister_candev(dev: priv->netdev); |
881 | |
882 | cleanup_free_candev: |
883 | free_candev(dev: netdev); |
884 | |
885 | return err; |
886 | } |
887 | |
888 | /* Called by the usb core when driver is unloaded or device is removed */ |
889 | static 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(dev: priv->netdev, format: "device disconnected\n" ); |
896 | |
897 | unregister_candev(dev: priv->netdev); |
898 | mcba_urb_unlink(priv); |
899 | free_candev(dev: priv->netdev); |
900 | } |
901 | |
902 | static 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 | |
909 | module_usb_driver(mcba_usb_driver); |
910 | |
911 | MODULE_AUTHOR("Remigiusz Kołłątaj <remigiusz.kollataj@mobica.com>" ); |
912 | MODULE_DESCRIPTION("SocketCAN driver for Microchip CAN BUS Analyzer Tool" ); |
913 | MODULE_LICENSE("GPL v2" ); |
914 | |