1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * CAN driver for "8 devices" USB2CAN converter |
4 | * |
5 | * Copyright (C) 2012 Bernd Krumboeck (krumboeck@universalnet.at) |
6 | * |
7 | * This driver is inspired by the 3.2.0 version of drivers/net/can/usb/ems_usb.c |
8 | * and drivers/net/can/usb/esd_usb2.c |
9 | * |
10 | * Many thanks to Gerhard Bertelsmann (info@gerhard-bertelsmann.de) |
11 | * for testing and fixing this driver. Also many thanks to "8 devices", |
12 | * who were very cooperative and answered my questions. |
13 | */ |
14 | |
15 | #include <linux/ethtool.h> |
16 | #include <linux/signal.h> |
17 | #include <linux/slab.h> |
18 | #include <linux/module.h> |
19 | #include <linux/netdevice.h> |
20 | #include <linux/usb.h> |
21 | |
22 | #include <linux/can.h> |
23 | #include <linux/can/dev.h> |
24 | #include <linux/can/error.h> |
25 | |
26 | /* driver constants */ |
27 | #define MAX_RX_URBS 20 |
28 | #define MAX_TX_URBS 20 |
29 | #define RX_BUFFER_SIZE 64 |
30 | |
31 | /* vendor and product id */ |
32 | #define USB_8DEV_VENDOR_ID 0x0483 |
33 | #define USB_8DEV_PRODUCT_ID 0x1234 |
34 | |
35 | /* endpoints */ |
36 | enum usb_8dev_endpoint { |
37 | USB_8DEV_ENDP_DATA_RX = 1, |
38 | USB_8DEV_ENDP_DATA_TX, |
39 | USB_8DEV_ENDP_CMD_RX, |
40 | USB_8DEV_ENDP_CMD_TX |
41 | }; |
42 | |
43 | /* device CAN clock */ |
44 | #define USB_8DEV_ABP_CLOCK 32000000 |
45 | |
46 | /* setup flags */ |
47 | #define USB_8DEV_SILENT 0x01 |
48 | #define USB_8DEV_LOOPBACK 0x02 |
49 | #define USB_8DEV_DISABLE_AUTO_RESTRANS 0x04 |
50 | #define USB_8DEV_STATUS_FRAME 0x08 |
51 | |
52 | /* commands */ |
53 | enum usb_8dev_cmd { |
54 | USB_8DEV_RESET = 1, |
55 | USB_8DEV_OPEN, |
56 | USB_8DEV_CLOSE, |
57 | USB_8DEV_SET_SPEED, |
58 | USB_8DEV_SET_MASK_FILTER, |
59 | USB_8DEV_GET_STATUS, |
60 | USB_8DEV_GET_STATISTICS, |
61 | USB_8DEV_GET_SERIAL, |
62 | USB_8DEV_GET_SOFTW_VER, |
63 | USB_8DEV_GET_HARDW_VER, |
64 | USB_8DEV_RESET_TIMESTAMP, |
65 | USB_8DEV_GET_SOFTW_HARDW_VER |
66 | }; |
67 | |
68 | /* command options */ |
69 | #define USB_8DEV_BAUD_MANUAL 0x09 |
70 | #define USB_8DEV_CMD_START 0x11 |
71 | #define USB_8DEV_CMD_END 0x22 |
72 | |
73 | #define USB_8DEV_CMD_SUCCESS 0 |
74 | #define USB_8DEV_CMD_ERROR 255 |
75 | |
76 | #define USB_8DEV_CMD_TIMEOUT 1000 |
77 | |
78 | /* frames */ |
79 | #define USB_8DEV_DATA_START 0x55 |
80 | #define USB_8DEV_DATA_END 0xAA |
81 | |
82 | #define USB_8DEV_TYPE_CAN_FRAME 0 |
83 | #define USB_8DEV_TYPE_ERROR_FRAME 3 |
84 | |
85 | #define USB_8DEV_EXTID 0x01 |
86 | #define USB_8DEV_RTR 0x02 |
87 | #define USB_8DEV_ERR_FLAG 0x04 |
88 | |
89 | /* status */ |
90 | #define USB_8DEV_STATUSMSG_OK 0x00 /* Normal condition. */ |
91 | #define USB_8DEV_STATUSMSG_OVERRUN 0x01 /* Overrun occurred when sending */ |
92 | #define USB_8DEV_STATUSMSG_BUSLIGHT 0x02 /* Error counter has reached 96 */ |
93 | #define USB_8DEV_STATUSMSG_BUSHEAVY 0x03 /* Error count. has reached 128 */ |
94 | #define USB_8DEV_STATUSMSG_BUSOFF 0x04 /* Device is in BUSOFF */ |
95 | #define USB_8DEV_STATUSMSG_STUFF 0x20 /* Stuff Error */ |
96 | #define USB_8DEV_STATUSMSG_FORM 0x21 /* Form Error */ |
97 | #define USB_8DEV_STATUSMSG_ACK 0x23 /* Ack Error */ |
98 | #define USB_8DEV_STATUSMSG_BIT0 0x24 /* Bit1 Error */ |
99 | #define USB_8DEV_STATUSMSG_BIT1 0x25 /* Bit0 Error */ |
100 | #define USB_8DEV_STATUSMSG_CRC 0x27 /* CRC Error */ |
101 | |
102 | #define USB_8DEV_RP_MASK 0x7F /* Mask for Receive Error Bit */ |
103 | |
104 | |
105 | /* table of devices that work with this driver */ |
106 | static const struct usb_device_id usb_8dev_table[] = { |
107 | { USB_DEVICE(USB_8DEV_VENDOR_ID, USB_8DEV_PRODUCT_ID) }, |
108 | { } /* Terminating entry */ |
109 | }; |
110 | |
111 | MODULE_DEVICE_TABLE(usb, usb_8dev_table); |
112 | |
113 | struct usb_8dev_tx_urb_context { |
114 | struct usb_8dev_priv *priv; |
115 | |
116 | u32 echo_index; |
117 | }; |
118 | |
119 | /* Structure to hold all of our device specific stuff */ |
120 | struct usb_8dev_priv { |
121 | struct can_priv can; /* must be the first member */ |
122 | |
123 | struct usb_device *udev; |
124 | struct net_device *netdev; |
125 | |
126 | atomic_t active_tx_urbs; |
127 | struct usb_anchor tx_submitted; |
128 | struct usb_8dev_tx_urb_context tx_contexts[MAX_TX_URBS]; |
129 | |
130 | struct usb_anchor rx_submitted; |
131 | |
132 | struct can_berr_counter bec; |
133 | |
134 | u8 *cmd_msg_buffer; |
135 | |
136 | struct mutex usb_8dev_cmd_lock; |
137 | void *rxbuf[MAX_RX_URBS]; |
138 | dma_addr_t rxbuf_dma[MAX_RX_URBS]; |
139 | }; |
140 | |
141 | /* tx frame */ |
142 | struct __packed usb_8dev_tx_msg { |
143 | u8 begin; |
144 | u8 flags; /* RTR and EXT_ID flag */ |
145 | __be32 id; /* upper 3 bits not used */ |
146 | u8 dlc; /* data length code 0-8 bytes */ |
147 | u8 data[8]; /* 64-bit data */ |
148 | u8 end; |
149 | }; |
150 | |
151 | /* rx frame */ |
152 | struct __packed usb_8dev_rx_msg { |
153 | u8 begin; |
154 | u8 type; /* frame type */ |
155 | u8 flags; /* RTR and EXT_ID flag */ |
156 | __be32 id; /* upper 3 bits not used */ |
157 | u8 dlc; /* data length code 0-8 bytes */ |
158 | u8 data[8]; /* 64-bit data */ |
159 | __be32 timestamp; /* 32-bit timestamp */ |
160 | u8 end; |
161 | }; |
162 | |
163 | /* command frame */ |
164 | struct __packed usb_8dev_cmd_msg { |
165 | u8 begin; |
166 | u8 channel; /* unknown - always 0 */ |
167 | u8 command; /* command to execute */ |
168 | u8 opt1; /* optional parameter / return value */ |
169 | u8 opt2; /* optional parameter 2 */ |
170 | u8 data[10]; /* optional parameter and data */ |
171 | u8 end; |
172 | }; |
173 | |
174 | static int usb_8dev_send_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size) |
175 | { |
176 | int actual_length; |
177 | |
178 | return usb_bulk_msg(usb_dev: priv->udev, |
179 | usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_TX), |
180 | data: msg, len: size, actual_length: &actual_length, USB_8DEV_CMD_TIMEOUT); |
181 | } |
182 | |
183 | static int usb_8dev_wait_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size, |
184 | int *actual_length) |
185 | { |
186 | return usb_bulk_msg(usb_dev: priv->udev, |
187 | usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_RX), |
188 | data: msg, len: size, actual_length, USB_8DEV_CMD_TIMEOUT); |
189 | } |
190 | |
191 | /* Send command to device and receive result. |
192 | * Command was successful when opt1 = 0. |
193 | */ |
194 | static int usb_8dev_send_cmd(struct usb_8dev_priv *priv, |
195 | struct usb_8dev_cmd_msg *out, |
196 | struct usb_8dev_cmd_msg *in) |
197 | { |
198 | int err; |
199 | int num_bytes_read; |
200 | struct net_device *netdev; |
201 | |
202 | netdev = priv->netdev; |
203 | |
204 | out->begin = USB_8DEV_CMD_START; |
205 | out->end = USB_8DEV_CMD_END; |
206 | |
207 | mutex_lock(&priv->usb_8dev_cmd_lock); |
208 | |
209 | memcpy(priv->cmd_msg_buffer, out, |
210 | sizeof(struct usb_8dev_cmd_msg)); |
211 | |
212 | err = usb_8dev_send_cmd_msg(priv, msg: priv->cmd_msg_buffer, |
213 | size: sizeof(struct usb_8dev_cmd_msg)); |
214 | if (err < 0) { |
215 | netdev_err(dev: netdev, format: "sending command message failed\n" ); |
216 | goto failed; |
217 | } |
218 | |
219 | err = usb_8dev_wait_cmd_msg(priv, msg: priv->cmd_msg_buffer, |
220 | size: sizeof(struct usb_8dev_cmd_msg), |
221 | actual_length: &num_bytes_read); |
222 | if (err < 0) { |
223 | netdev_err(dev: netdev, format: "no command message answer\n" ); |
224 | goto failed; |
225 | } |
226 | |
227 | memcpy(in, priv->cmd_msg_buffer, sizeof(struct usb_8dev_cmd_msg)); |
228 | |
229 | if (in->begin != USB_8DEV_CMD_START || in->end != USB_8DEV_CMD_END || |
230 | num_bytes_read != 16 || in->opt1 != 0) |
231 | err = -EPROTO; |
232 | |
233 | failed: |
234 | mutex_unlock(lock: &priv->usb_8dev_cmd_lock); |
235 | return err; |
236 | } |
237 | |
238 | /* Send open command to device */ |
239 | static int usb_8dev_cmd_open(struct usb_8dev_priv *priv) |
240 | { |
241 | struct can_bittiming *bt = &priv->can.bittiming; |
242 | struct usb_8dev_cmd_msg outmsg; |
243 | struct usb_8dev_cmd_msg inmsg; |
244 | u32 ctrlmode = priv->can.ctrlmode; |
245 | u32 flags = USB_8DEV_STATUS_FRAME; |
246 | __be32 beflags; |
247 | __be16 bebrp; |
248 | |
249 | memset(&outmsg, 0, sizeof(outmsg)); |
250 | outmsg.command = USB_8DEV_OPEN; |
251 | outmsg.opt1 = USB_8DEV_BAUD_MANUAL; |
252 | outmsg.data[0] = bt->prop_seg + bt->phase_seg1; |
253 | outmsg.data[1] = bt->phase_seg2; |
254 | outmsg.data[2] = bt->sjw; |
255 | |
256 | /* BRP */ |
257 | bebrp = cpu_to_be16((u16)bt->brp); |
258 | memcpy(&outmsg.data[3], &bebrp, sizeof(bebrp)); |
259 | |
260 | /* flags */ |
261 | if (ctrlmode & CAN_CTRLMODE_LOOPBACK) |
262 | flags |= USB_8DEV_LOOPBACK; |
263 | if (ctrlmode & CAN_CTRLMODE_LISTENONLY) |
264 | flags |= USB_8DEV_SILENT; |
265 | if (ctrlmode & CAN_CTRLMODE_ONE_SHOT) |
266 | flags |= USB_8DEV_DISABLE_AUTO_RESTRANS; |
267 | |
268 | beflags = cpu_to_be32(flags); |
269 | memcpy(&outmsg.data[5], &beflags, sizeof(beflags)); |
270 | |
271 | return usb_8dev_send_cmd(priv, out: &outmsg, in: &inmsg); |
272 | } |
273 | |
274 | /* Send close command to device */ |
275 | static int usb_8dev_cmd_close(struct usb_8dev_priv *priv) |
276 | { |
277 | struct usb_8dev_cmd_msg inmsg; |
278 | struct usb_8dev_cmd_msg outmsg = { |
279 | .channel = 0, |
280 | .command = USB_8DEV_CLOSE, |
281 | .opt1 = 0, |
282 | .opt2 = 0 |
283 | }; |
284 | |
285 | return usb_8dev_send_cmd(priv, out: &outmsg, in: &inmsg); |
286 | } |
287 | |
288 | /* Get firmware and hardware version */ |
289 | static int usb_8dev_cmd_version(struct usb_8dev_priv *priv, u32 *res) |
290 | { |
291 | struct usb_8dev_cmd_msg inmsg; |
292 | struct usb_8dev_cmd_msg outmsg = { |
293 | .channel = 0, |
294 | .command = USB_8DEV_GET_SOFTW_HARDW_VER, |
295 | .opt1 = 0, |
296 | .opt2 = 0 |
297 | }; |
298 | |
299 | int err = usb_8dev_send_cmd(priv, out: &outmsg, in: &inmsg); |
300 | if (err) |
301 | return err; |
302 | |
303 | *res = be32_to_cpup(p: (__be32 *)inmsg.data); |
304 | |
305 | return err; |
306 | } |
307 | |
308 | /* Set network device mode |
309 | * |
310 | * Maybe we should leave this function empty, because the device |
311 | * set mode variable with open command. |
312 | */ |
313 | static int usb_8dev_set_mode(struct net_device *netdev, enum can_mode mode) |
314 | { |
315 | struct usb_8dev_priv *priv = netdev_priv(dev: netdev); |
316 | int err = 0; |
317 | |
318 | switch (mode) { |
319 | case CAN_MODE_START: |
320 | err = usb_8dev_cmd_open(priv); |
321 | if (err) |
322 | netdev_warn(dev: netdev, format: "couldn't start device" ); |
323 | break; |
324 | |
325 | default: |
326 | return -EOPNOTSUPP; |
327 | } |
328 | |
329 | return err; |
330 | } |
331 | |
332 | /* Read error/status frames */ |
333 | static void usb_8dev_rx_err_msg(struct usb_8dev_priv *priv, |
334 | struct usb_8dev_rx_msg *msg) |
335 | { |
336 | struct can_frame *cf; |
337 | struct sk_buff *skb; |
338 | struct net_device_stats *stats = &priv->netdev->stats; |
339 | |
340 | /* Error message: |
341 | * byte 0: Status |
342 | * byte 1: bit 7: Receive Passive |
343 | * byte 1: bit 0-6: Receive Error Counter |
344 | * byte 2: Transmit Error Counter |
345 | * byte 3: Always 0 (maybe reserved for future use) |
346 | */ |
347 | |
348 | u8 state = msg->data[0]; |
349 | u8 rxerr = msg->data[1] & USB_8DEV_RP_MASK; |
350 | u8 txerr = msg->data[2]; |
351 | int rx_errors = 0; |
352 | int tx_errors = 0; |
353 | |
354 | skb = alloc_can_err_skb(dev: priv->netdev, cf: &cf); |
355 | if (!skb) |
356 | return; |
357 | |
358 | switch (state) { |
359 | case USB_8DEV_STATUSMSG_OK: |
360 | priv->can.state = CAN_STATE_ERROR_ACTIVE; |
361 | cf->can_id |= CAN_ERR_PROT; |
362 | cf->data[2] = CAN_ERR_PROT_ACTIVE; |
363 | break; |
364 | case USB_8DEV_STATUSMSG_BUSOFF: |
365 | priv->can.state = CAN_STATE_BUS_OFF; |
366 | cf->can_id |= CAN_ERR_BUSOFF; |
367 | priv->can.can_stats.bus_off++; |
368 | can_bus_off(dev: priv->netdev); |
369 | break; |
370 | case USB_8DEV_STATUSMSG_OVERRUN: |
371 | case USB_8DEV_STATUSMSG_BUSLIGHT: |
372 | case USB_8DEV_STATUSMSG_BUSHEAVY: |
373 | cf->can_id |= CAN_ERR_CRTL; |
374 | break; |
375 | default: |
376 | priv->can.state = CAN_STATE_ERROR_WARNING; |
377 | cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; |
378 | priv->can.can_stats.bus_error++; |
379 | break; |
380 | } |
381 | |
382 | switch (state) { |
383 | case USB_8DEV_STATUSMSG_OK: |
384 | case USB_8DEV_STATUSMSG_BUSOFF: |
385 | break; |
386 | case USB_8DEV_STATUSMSG_ACK: |
387 | cf->can_id |= CAN_ERR_ACK; |
388 | tx_errors = 1; |
389 | break; |
390 | case USB_8DEV_STATUSMSG_CRC: |
391 | cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; |
392 | rx_errors = 1; |
393 | break; |
394 | case USB_8DEV_STATUSMSG_BIT0: |
395 | cf->data[2] |= CAN_ERR_PROT_BIT0; |
396 | tx_errors = 1; |
397 | break; |
398 | case USB_8DEV_STATUSMSG_BIT1: |
399 | cf->data[2] |= CAN_ERR_PROT_BIT1; |
400 | tx_errors = 1; |
401 | break; |
402 | case USB_8DEV_STATUSMSG_FORM: |
403 | cf->data[2] |= CAN_ERR_PROT_FORM; |
404 | rx_errors = 1; |
405 | break; |
406 | case USB_8DEV_STATUSMSG_STUFF: |
407 | cf->data[2] |= CAN_ERR_PROT_STUFF; |
408 | rx_errors = 1; |
409 | break; |
410 | case USB_8DEV_STATUSMSG_OVERRUN: |
411 | cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; |
412 | stats->rx_over_errors++; |
413 | rx_errors = 1; |
414 | break; |
415 | case USB_8DEV_STATUSMSG_BUSLIGHT: |
416 | priv->can.state = CAN_STATE_ERROR_WARNING; |
417 | cf->data[1] = (txerr > rxerr) ? |
418 | CAN_ERR_CRTL_TX_WARNING : |
419 | CAN_ERR_CRTL_RX_WARNING; |
420 | priv->can.can_stats.error_warning++; |
421 | break; |
422 | case USB_8DEV_STATUSMSG_BUSHEAVY: |
423 | priv->can.state = CAN_STATE_ERROR_PASSIVE; |
424 | cf->data[1] = (txerr > rxerr) ? |
425 | CAN_ERR_CRTL_TX_PASSIVE : |
426 | CAN_ERR_CRTL_RX_PASSIVE; |
427 | priv->can.can_stats.error_passive++; |
428 | break; |
429 | default: |
430 | netdev_warn(dev: priv->netdev, |
431 | format: "Unknown status/error message (%d)\n" , state); |
432 | break; |
433 | } |
434 | |
435 | if (tx_errors) { |
436 | cf->data[2] |= CAN_ERR_PROT_TX; |
437 | stats->tx_errors++; |
438 | } |
439 | |
440 | if (rx_errors) |
441 | stats->rx_errors++; |
442 | if (priv->can.state != CAN_STATE_BUS_OFF) { |
443 | cf->can_id |= CAN_ERR_CNT; |
444 | cf->data[6] = txerr; |
445 | cf->data[7] = rxerr; |
446 | } |
447 | |
448 | priv->bec.txerr = txerr; |
449 | priv->bec.rxerr = rxerr; |
450 | |
451 | netif_rx(skb); |
452 | } |
453 | |
454 | /* Read data and status frames */ |
455 | static void usb_8dev_rx_can_msg(struct usb_8dev_priv *priv, |
456 | struct usb_8dev_rx_msg *msg) |
457 | { |
458 | struct can_frame *cf; |
459 | struct sk_buff *skb; |
460 | struct net_device_stats *stats = &priv->netdev->stats; |
461 | |
462 | if (msg->type == USB_8DEV_TYPE_ERROR_FRAME && |
463 | msg->flags == USB_8DEV_ERR_FLAG) { |
464 | usb_8dev_rx_err_msg(priv, msg); |
465 | } else if (msg->type == USB_8DEV_TYPE_CAN_FRAME) { |
466 | skb = alloc_can_skb(dev: priv->netdev, cf: &cf); |
467 | if (!skb) |
468 | return; |
469 | |
470 | cf->can_id = be32_to_cpu(msg->id); |
471 | can_frame_set_cc_len(cf, dlc: msg->dlc & 0xF, ctrlmode: priv->can.ctrlmode); |
472 | |
473 | if (msg->flags & USB_8DEV_EXTID) |
474 | cf->can_id |= CAN_EFF_FLAG; |
475 | |
476 | if (msg->flags & USB_8DEV_RTR) { |
477 | cf->can_id |= CAN_RTR_FLAG; |
478 | } else { |
479 | memcpy(cf->data, msg->data, cf->len); |
480 | stats->rx_bytes += cf->len; |
481 | } |
482 | stats->rx_packets++; |
483 | |
484 | netif_rx(skb); |
485 | } else { |
486 | netdev_warn(dev: priv->netdev, format: "frame type %d unknown" , |
487 | msg->type); |
488 | } |
489 | |
490 | } |
491 | |
492 | /* Callback for reading data from device |
493 | * |
494 | * Check urb status, call read function and resubmit urb read operation. |
495 | */ |
496 | static void usb_8dev_read_bulk_callback(struct urb *urb) |
497 | { |
498 | struct usb_8dev_priv *priv = urb->context; |
499 | struct net_device *netdev; |
500 | int retval; |
501 | int pos = 0; |
502 | |
503 | netdev = priv->netdev; |
504 | |
505 | if (!netif_device_present(dev: netdev)) |
506 | return; |
507 | |
508 | switch (urb->status) { |
509 | case 0: /* success */ |
510 | break; |
511 | |
512 | case -ENOENT: |
513 | case -EPIPE: |
514 | case -EPROTO: |
515 | case -ESHUTDOWN: |
516 | return; |
517 | |
518 | default: |
519 | netdev_info(dev: netdev, format: "Rx URB aborted (%d)\n" , |
520 | urb->status); |
521 | goto resubmit_urb; |
522 | } |
523 | |
524 | while (pos < urb->actual_length) { |
525 | struct usb_8dev_rx_msg *msg; |
526 | |
527 | if (pos + sizeof(struct usb_8dev_rx_msg) > urb->actual_length) { |
528 | netdev_err(dev: priv->netdev, format: "format error\n" ); |
529 | break; |
530 | } |
531 | |
532 | msg = (struct usb_8dev_rx_msg *)(urb->transfer_buffer + pos); |
533 | usb_8dev_rx_can_msg(priv, msg); |
534 | |
535 | pos += sizeof(struct usb_8dev_rx_msg); |
536 | } |
537 | |
538 | resubmit_urb: |
539 | usb_fill_bulk_urb(urb, dev: priv->udev, |
540 | usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_RX), |
541 | transfer_buffer: urb->transfer_buffer, RX_BUFFER_SIZE, |
542 | complete_fn: usb_8dev_read_bulk_callback, context: priv); |
543 | |
544 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
545 | |
546 | if (retval == -ENODEV) |
547 | netif_device_detach(dev: netdev); |
548 | else if (retval) |
549 | netdev_err(dev: netdev, |
550 | format: "failed resubmitting read bulk urb: %d\n" , retval); |
551 | } |
552 | |
553 | /* Callback handler for write operations |
554 | * |
555 | * Free allocated buffers, check transmit status and |
556 | * calculate statistic. |
557 | */ |
558 | static void usb_8dev_write_bulk_callback(struct urb *urb) |
559 | { |
560 | struct usb_8dev_tx_urb_context *context = urb->context; |
561 | struct usb_8dev_priv *priv; |
562 | struct net_device *netdev; |
563 | |
564 | BUG_ON(!context); |
565 | |
566 | priv = context->priv; |
567 | netdev = priv->netdev; |
568 | |
569 | /* free up our allocated buffer */ |
570 | usb_free_coherent(dev: urb->dev, size: urb->transfer_buffer_length, |
571 | addr: urb->transfer_buffer, dma: urb->transfer_dma); |
572 | |
573 | atomic_dec(v: &priv->active_tx_urbs); |
574 | |
575 | if (!netif_device_present(dev: netdev)) |
576 | return; |
577 | |
578 | if (urb->status) |
579 | netdev_info(dev: netdev, format: "Tx URB aborted (%d)\n" , |
580 | urb->status); |
581 | |
582 | netdev->stats.tx_packets++; |
583 | netdev->stats.tx_bytes += can_get_echo_skb(dev: netdev, idx: context->echo_index, NULL); |
584 | |
585 | /* Release context */ |
586 | context->echo_index = MAX_TX_URBS; |
587 | |
588 | netif_wake_queue(dev: netdev); |
589 | } |
590 | |
591 | /* Send data to device */ |
592 | static netdev_tx_t usb_8dev_start_xmit(struct sk_buff *skb, |
593 | struct net_device *netdev) |
594 | { |
595 | struct usb_8dev_priv *priv = netdev_priv(dev: netdev); |
596 | struct net_device_stats *stats = &netdev->stats; |
597 | struct can_frame *cf = (struct can_frame *) skb->data; |
598 | struct usb_8dev_tx_msg *msg; |
599 | struct urb *urb; |
600 | struct usb_8dev_tx_urb_context *context = NULL; |
601 | u8 *buf; |
602 | int i, err; |
603 | size_t size = sizeof(struct usb_8dev_tx_msg); |
604 | |
605 | if (can_dev_dropped_skb(dev: netdev, skb)) |
606 | return NETDEV_TX_OK; |
607 | |
608 | /* create a URB, and a buffer for it, and copy the data to the URB */ |
609 | urb = usb_alloc_urb(iso_packets: 0, GFP_ATOMIC); |
610 | if (!urb) |
611 | goto nomem; |
612 | |
613 | buf = usb_alloc_coherent(dev: priv->udev, size, GFP_ATOMIC, |
614 | dma: &urb->transfer_dma); |
615 | if (!buf) { |
616 | netdev_err(dev: netdev, format: "No memory left for USB buffer\n" ); |
617 | goto nomembuf; |
618 | } |
619 | |
620 | memset(buf, 0, size); |
621 | |
622 | msg = (struct usb_8dev_tx_msg *)buf; |
623 | msg->begin = USB_8DEV_DATA_START; |
624 | msg->flags = 0x00; |
625 | |
626 | if (cf->can_id & CAN_RTR_FLAG) |
627 | msg->flags |= USB_8DEV_RTR; |
628 | |
629 | if (cf->can_id & CAN_EFF_FLAG) |
630 | msg->flags |= USB_8DEV_EXTID; |
631 | |
632 | msg->id = cpu_to_be32(cf->can_id & CAN_ERR_MASK); |
633 | msg->dlc = can_get_cc_dlc(cf, ctrlmode: priv->can.ctrlmode); |
634 | memcpy(msg->data, cf->data, cf->len); |
635 | msg->end = USB_8DEV_DATA_END; |
636 | |
637 | for (i = 0; i < MAX_TX_URBS; i++) { |
638 | if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) { |
639 | context = &priv->tx_contexts[i]; |
640 | break; |
641 | } |
642 | } |
643 | |
644 | /* May never happen! When this happens we'd more URBs in flight as |
645 | * allowed (MAX_TX_URBS). |
646 | */ |
647 | if (!context) |
648 | goto nofreecontext; |
649 | |
650 | context->priv = priv; |
651 | context->echo_index = i; |
652 | |
653 | usb_fill_bulk_urb(urb, dev: priv->udev, |
654 | usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_TX), |
655 | transfer_buffer: buf, buffer_length: size, complete_fn: usb_8dev_write_bulk_callback, context); |
656 | urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
657 | usb_anchor_urb(urb, anchor: &priv->tx_submitted); |
658 | |
659 | can_put_echo_skb(skb, dev: netdev, idx: context->echo_index, frame_len: 0); |
660 | |
661 | atomic_inc(v: &priv->active_tx_urbs); |
662 | |
663 | err = usb_submit_urb(urb, GFP_ATOMIC); |
664 | if (unlikely(err)) { |
665 | can_free_echo_skb(dev: netdev, idx: context->echo_index, NULL); |
666 | |
667 | usb_unanchor_urb(urb); |
668 | usb_free_coherent(dev: priv->udev, size, addr: buf, dma: urb->transfer_dma); |
669 | |
670 | atomic_dec(v: &priv->active_tx_urbs); |
671 | |
672 | if (err == -ENODEV) |
673 | netif_device_detach(dev: netdev); |
674 | else |
675 | netdev_warn(dev: netdev, format: "failed tx_urb %d\n" , err); |
676 | stats->tx_dropped++; |
677 | } else if (atomic_read(v: &priv->active_tx_urbs) >= MAX_TX_URBS) |
678 | /* Slow down tx path */ |
679 | netif_stop_queue(dev: netdev); |
680 | |
681 | /* Release our reference to this URB, the USB core will eventually free |
682 | * it entirely. |
683 | */ |
684 | usb_free_urb(urb); |
685 | |
686 | return NETDEV_TX_OK; |
687 | |
688 | nofreecontext: |
689 | usb_free_coherent(dev: priv->udev, size, addr: buf, dma: urb->transfer_dma); |
690 | usb_free_urb(urb); |
691 | |
692 | netdev_warn(dev: netdev, format: "couldn't find free context" ); |
693 | |
694 | return NETDEV_TX_BUSY; |
695 | |
696 | nomembuf: |
697 | usb_free_urb(urb); |
698 | |
699 | nomem: |
700 | dev_kfree_skb(skb); |
701 | stats->tx_dropped++; |
702 | |
703 | return NETDEV_TX_OK; |
704 | } |
705 | |
706 | static int usb_8dev_get_berr_counter(const struct net_device *netdev, |
707 | struct can_berr_counter *bec) |
708 | { |
709 | struct usb_8dev_priv *priv = netdev_priv(dev: netdev); |
710 | |
711 | bec->txerr = priv->bec.txerr; |
712 | bec->rxerr = priv->bec.rxerr; |
713 | |
714 | return 0; |
715 | } |
716 | |
717 | /* Start USB device */ |
718 | static int usb_8dev_start(struct usb_8dev_priv *priv) |
719 | { |
720 | struct net_device *netdev = priv->netdev; |
721 | int err, i; |
722 | |
723 | for (i = 0; i < MAX_RX_URBS; i++) { |
724 | struct urb *urb = NULL; |
725 | u8 *buf; |
726 | dma_addr_t buf_dma; |
727 | |
728 | /* create a URB, and a buffer for it */ |
729 | urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
730 | if (!urb) { |
731 | err = -ENOMEM; |
732 | break; |
733 | } |
734 | |
735 | buf = usb_alloc_coherent(dev: priv->udev, RX_BUFFER_SIZE, GFP_KERNEL, |
736 | dma: &buf_dma); |
737 | if (!buf) { |
738 | netdev_err(dev: netdev, format: "No memory left for USB buffer\n" ); |
739 | usb_free_urb(urb); |
740 | err = -ENOMEM; |
741 | break; |
742 | } |
743 | |
744 | urb->transfer_dma = buf_dma; |
745 | |
746 | usb_fill_bulk_urb(urb, dev: priv->udev, |
747 | usb_rcvbulkpipe(priv->udev, |
748 | USB_8DEV_ENDP_DATA_RX), |
749 | transfer_buffer: buf, RX_BUFFER_SIZE, |
750 | complete_fn: usb_8dev_read_bulk_callback, context: priv); |
751 | urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
752 | usb_anchor_urb(urb, anchor: &priv->rx_submitted); |
753 | |
754 | err = usb_submit_urb(urb, GFP_KERNEL); |
755 | if (err) { |
756 | usb_unanchor_urb(urb); |
757 | usb_free_coherent(dev: priv->udev, RX_BUFFER_SIZE, addr: buf, |
758 | dma: urb->transfer_dma); |
759 | usb_free_urb(urb); |
760 | break; |
761 | } |
762 | |
763 | priv->rxbuf[i] = buf; |
764 | priv->rxbuf_dma[i] = buf_dma; |
765 | |
766 | /* Drop reference, USB core will take care of freeing it */ |
767 | usb_free_urb(urb); |
768 | } |
769 | |
770 | /* Did we submit any URBs */ |
771 | if (i == 0) { |
772 | netdev_warn(dev: netdev, format: "couldn't setup read URBs\n" ); |
773 | return err; |
774 | } |
775 | |
776 | /* Warn if we've couldn't transmit all the URBs */ |
777 | if (i < MAX_RX_URBS) |
778 | netdev_warn(dev: netdev, format: "rx performance may be slow\n" ); |
779 | |
780 | err = usb_8dev_cmd_open(priv); |
781 | if (err) |
782 | goto failed; |
783 | |
784 | priv->can.state = CAN_STATE_ERROR_ACTIVE; |
785 | |
786 | return 0; |
787 | |
788 | failed: |
789 | if (err == -ENODEV) |
790 | netif_device_detach(dev: priv->netdev); |
791 | |
792 | netdev_warn(dev: netdev, format: "couldn't submit control: %d\n" , err); |
793 | |
794 | return err; |
795 | } |
796 | |
797 | /* Open USB device */ |
798 | static int usb_8dev_open(struct net_device *netdev) |
799 | { |
800 | struct usb_8dev_priv *priv = netdev_priv(dev: netdev); |
801 | int err; |
802 | |
803 | /* common open */ |
804 | err = open_candev(dev: netdev); |
805 | if (err) |
806 | return err; |
807 | |
808 | /* finally start device */ |
809 | err = usb_8dev_start(priv); |
810 | if (err) { |
811 | if (err == -ENODEV) |
812 | netif_device_detach(dev: priv->netdev); |
813 | |
814 | netdev_warn(dev: netdev, format: "couldn't start device: %d\n" , |
815 | err); |
816 | |
817 | close_candev(dev: netdev); |
818 | |
819 | return err; |
820 | } |
821 | |
822 | netif_start_queue(dev: netdev); |
823 | |
824 | return 0; |
825 | } |
826 | |
827 | static void unlink_all_urbs(struct usb_8dev_priv *priv) |
828 | { |
829 | int i; |
830 | |
831 | usb_kill_anchored_urbs(anchor: &priv->rx_submitted); |
832 | |
833 | for (i = 0; i < MAX_RX_URBS; ++i) |
834 | usb_free_coherent(dev: priv->udev, RX_BUFFER_SIZE, |
835 | addr: priv->rxbuf[i], dma: priv->rxbuf_dma[i]); |
836 | |
837 | usb_kill_anchored_urbs(anchor: &priv->tx_submitted); |
838 | atomic_set(v: &priv->active_tx_urbs, i: 0); |
839 | |
840 | for (i = 0; i < MAX_TX_URBS; i++) |
841 | priv->tx_contexts[i].echo_index = MAX_TX_URBS; |
842 | } |
843 | |
844 | /* Close USB device */ |
845 | static int usb_8dev_close(struct net_device *netdev) |
846 | { |
847 | struct usb_8dev_priv *priv = netdev_priv(dev: netdev); |
848 | int err = 0; |
849 | |
850 | /* Send CLOSE command to CAN controller */ |
851 | err = usb_8dev_cmd_close(priv); |
852 | if (err) |
853 | netdev_warn(dev: netdev, format: "couldn't stop device" ); |
854 | |
855 | priv->can.state = CAN_STATE_STOPPED; |
856 | |
857 | netif_stop_queue(dev: netdev); |
858 | |
859 | /* Stop polling */ |
860 | unlink_all_urbs(priv); |
861 | |
862 | close_candev(dev: netdev); |
863 | |
864 | return err; |
865 | } |
866 | |
867 | static const struct net_device_ops usb_8dev_netdev_ops = { |
868 | .ndo_open = usb_8dev_open, |
869 | .ndo_stop = usb_8dev_close, |
870 | .ndo_start_xmit = usb_8dev_start_xmit, |
871 | .ndo_change_mtu = can_change_mtu, |
872 | }; |
873 | |
874 | static const struct ethtool_ops usb_8dev_ethtool_ops = { |
875 | .get_ts_info = ethtool_op_get_ts_info, |
876 | }; |
877 | |
878 | static const struct can_bittiming_const usb_8dev_bittiming_const = { |
879 | .name = KBUILD_MODNAME, |
880 | .tseg1_min = 1, |
881 | .tseg1_max = 16, |
882 | .tseg2_min = 1, |
883 | .tseg2_max = 8, |
884 | .sjw_max = 4, |
885 | .brp_min = 1, |
886 | .brp_max = 1024, |
887 | .brp_inc = 1, |
888 | }; |
889 | |
890 | /* Probe USB device |
891 | * |
892 | * Check device and firmware. |
893 | * Set supported modes and bittiming constants. |
894 | * Allocate some memory. |
895 | */ |
896 | static int usb_8dev_probe(struct usb_interface *intf, |
897 | const struct usb_device_id *id) |
898 | { |
899 | struct net_device *netdev; |
900 | struct usb_8dev_priv *priv; |
901 | int i, err = -ENOMEM; |
902 | u32 version; |
903 | char buf[18]; |
904 | struct usb_device *usbdev = interface_to_usbdev(intf); |
905 | |
906 | /* product id looks strange, better we also check iProduct string */ |
907 | if (usb_string(dev: usbdev, index: usbdev->descriptor.iProduct, buf, |
908 | size: sizeof(buf)) > 0 && strcmp(buf, "USB2CAN converter" )) { |
909 | dev_info(&usbdev->dev, "ignoring: not an USB2CAN converter\n" ); |
910 | return -ENODEV; |
911 | } |
912 | |
913 | netdev = alloc_candev(sizeof(struct usb_8dev_priv), MAX_TX_URBS); |
914 | if (!netdev) { |
915 | dev_err(&intf->dev, "Couldn't alloc candev\n" ); |
916 | return -ENOMEM; |
917 | } |
918 | |
919 | priv = netdev_priv(dev: netdev); |
920 | |
921 | priv->udev = usbdev; |
922 | priv->netdev = netdev; |
923 | |
924 | priv->can.state = CAN_STATE_STOPPED; |
925 | priv->can.clock.freq = USB_8DEV_ABP_CLOCK; |
926 | priv->can.bittiming_const = &usb_8dev_bittiming_const; |
927 | priv->can.do_set_mode = usb_8dev_set_mode; |
928 | priv->can.do_get_berr_counter = usb_8dev_get_berr_counter; |
929 | priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | |
930 | CAN_CTRLMODE_LISTENONLY | |
931 | CAN_CTRLMODE_ONE_SHOT | |
932 | CAN_CTRLMODE_CC_LEN8_DLC; |
933 | |
934 | netdev->netdev_ops = &usb_8dev_netdev_ops; |
935 | netdev->ethtool_ops = &usb_8dev_ethtool_ops; |
936 | |
937 | netdev->flags |= IFF_ECHO; /* we support local echo */ |
938 | |
939 | init_usb_anchor(anchor: &priv->rx_submitted); |
940 | |
941 | init_usb_anchor(anchor: &priv->tx_submitted); |
942 | atomic_set(v: &priv->active_tx_urbs, i: 0); |
943 | |
944 | for (i = 0; i < MAX_TX_URBS; i++) |
945 | priv->tx_contexts[i].echo_index = MAX_TX_URBS; |
946 | |
947 | priv->cmd_msg_buffer = devm_kzalloc(dev: &intf->dev, size: sizeof(struct usb_8dev_cmd_msg), |
948 | GFP_KERNEL); |
949 | if (!priv->cmd_msg_buffer) |
950 | goto cleanup_candev; |
951 | |
952 | usb_set_intfdata(intf, data: priv); |
953 | |
954 | SET_NETDEV_DEV(netdev, &intf->dev); |
955 | |
956 | mutex_init(&priv->usb_8dev_cmd_lock); |
957 | |
958 | err = register_candev(dev: netdev); |
959 | if (err) { |
960 | netdev_err(dev: netdev, |
961 | format: "couldn't register CAN device: %d\n" , err); |
962 | goto cleanup_candev; |
963 | } |
964 | |
965 | err = usb_8dev_cmd_version(priv, res: &version); |
966 | if (err) { |
967 | netdev_err(dev: netdev, format: "can't get firmware version\n" ); |
968 | goto cleanup_unregister_candev; |
969 | } else { |
970 | netdev_info(dev: netdev, |
971 | format: "firmware: %d.%d, hardware: %d.%d\n" , |
972 | (version>>24) & 0xff, (version>>16) & 0xff, |
973 | (version>>8) & 0xff, version & 0xff); |
974 | } |
975 | |
976 | return 0; |
977 | |
978 | cleanup_unregister_candev: |
979 | unregister_netdev(dev: priv->netdev); |
980 | |
981 | cleanup_candev: |
982 | free_candev(dev: netdev); |
983 | |
984 | return err; |
985 | |
986 | } |
987 | |
988 | /* Called by the usb core when driver is unloaded or device is removed */ |
989 | static void usb_8dev_disconnect(struct usb_interface *intf) |
990 | { |
991 | struct usb_8dev_priv *priv = usb_get_intfdata(intf); |
992 | |
993 | usb_set_intfdata(intf, NULL); |
994 | |
995 | if (priv) { |
996 | netdev_info(dev: priv->netdev, format: "device disconnected\n" ); |
997 | |
998 | unregister_netdev(dev: priv->netdev); |
999 | unlink_all_urbs(priv); |
1000 | free_candev(dev: priv->netdev); |
1001 | } |
1002 | |
1003 | } |
1004 | |
1005 | static struct usb_driver usb_8dev_driver = { |
1006 | .name = KBUILD_MODNAME, |
1007 | .probe = usb_8dev_probe, |
1008 | .disconnect = usb_8dev_disconnect, |
1009 | .id_table = usb_8dev_table, |
1010 | }; |
1011 | |
1012 | module_usb_driver(usb_8dev_driver); |
1013 | |
1014 | MODULE_AUTHOR("Bernd Krumboeck <krumboeck@universalnet.at>" ); |
1015 | MODULE_DESCRIPTION("CAN driver for 8 devices USB2CAN interfaces" ); |
1016 | MODULE_LICENSE("GPL v2" ); |
1017 | |