1 | // SPDX-License-Identifier: GPL-2.0 |
2 | |
3 | /* Driver for Theobroma Systems UCAN devices, Protocol Version 3 |
4 | * |
5 | * Copyright (C) 2018 Theobroma Systems Design und Consulting GmbH |
6 | * |
7 | * |
8 | * General Description: |
9 | * |
10 | * The USB Device uses three Endpoints: |
11 | * |
12 | * CONTROL Endpoint: Is used the setup the device (start, stop, |
13 | * info, configure). |
14 | * |
15 | * IN Endpoint: The device sends CAN Frame Messages and Device |
16 | * Information using the IN endpoint. |
17 | * |
18 | * OUT Endpoint: The driver sends configuration requests, and CAN |
19 | * Frames on the out endpoint. |
20 | * |
21 | * Error Handling: |
22 | * |
23 | * If error reporting is turned on the device encodes error into CAN |
24 | * error frames (see uapi/linux/can/error.h) and sends it using the |
25 | * IN Endpoint. The driver updates statistics and forward it. |
26 | */ |
27 | |
28 | #include <linux/can.h> |
29 | #include <linux/can/dev.h> |
30 | #include <linux/can/error.h> |
31 | #include <linux/ethtool.h> |
32 | #include <linux/module.h> |
33 | #include <linux/netdevice.h> |
34 | #include <linux/signal.h> |
35 | #include <linux/skbuff.h> |
36 | #include <linux/slab.h> |
37 | #include <linux/usb.h> |
38 | |
39 | #define UCAN_DRIVER_NAME "ucan" |
40 | #define UCAN_MAX_RX_URBS 8 |
41 | /* the CAN controller needs a while to enable/disable the bus */ |
42 | #define UCAN_USB_CTL_PIPE_TIMEOUT 1000 |
43 | /* this driver currently supports protocol version 3 only */ |
44 | #define UCAN_PROTOCOL_VERSION_MIN 3 |
45 | #define UCAN_PROTOCOL_VERSION_MAX 3 |
46 | |
47 | /* UCAN Message Definitions |
48 | * ------------------------ |
49 | * |
50 | * ucan_message_out_t and ucan_message_in_t define the messages |
51 | * transmitted on the OUT and IN endpoint. |
52 | * |
53 | * Multibyte fields are transmitted with little endianness |
54 | * |
55 | * INTR Endpoint: a single uint32_t storing the current space in the fifo |
56 | * |
57 | * OUT Endpoint: single message of type ucan_message_out_t is |
58 | * transmitted on the out endpoint |
59 | * |
60 | * IN Endpoint: multiple messages ucan_message_in_t concateted in |
61 | * the following way: |
62 | * |
63 | * m[n].len <=> the length if message n(including the header in bytes) |
64 | * m[n] is is aligned to a 4 byte boundary, hence |
65 | * offset(m[0]) := 0; |
66 | * offset(m[n+1]) := offset(m[n]) + (m[n].len + 3) & 3 |
67 | * |
68 | * this implies that |
69 | * offset(m[n]) % 4 <=> 0 |
70 | */ |
71 | |
72 | /* Device Global Commands */ |
73 | enum { |
74 | UCAN_DEVICE_GET_FW_STRING = 0, |
75 | }; |
76 | |
77 | /* UCAN Commands */ |
78 | enum { |
79 | /* start the can transceiver - val defines the operation mode */ |
80 | UCAN_COMMAND_START = 0, |
81 | /* cancel pending transmissions and stop the can transceiver */ |
82 | UCAN_COMMAND_STOP = 1, |
83 | /* send can transceiver into low-power sleep mode */ |
84 | UCAN_COMMAND_SLEEP = 2, |
85 | /* wake up can transceiver from low-power sleep mode */ |
86 | UCAN_COMMAND_WAKEUP = 3, |
87 | /* reset the can transceiver */ |
88 | UCAN_COMMAND_RESET = 4, |
89 | /* get piece of info from the can transceiver - subcmd defines what |
90 | * piece |
91 | */ |
92 | UCAN_COMMAND_GET = 5, |
93 | /* clear or disable hardware filter - subcmd defines which of the two */ |
94 | UCAN_COMMAND_FILTER = 6, |
95 | /* Setup bittiming */ |
96 | UCAN_COMMAND_SET_BITTIMING = 7, |
97 | /* recover from bus-off state */ |
98 | UCAN_COMMAND_RESTART = 8, |
99 | }; |
100 | |
101 | /* UCAN_COMMAND_START and UCAN_COMMAND_GET_INFO operation modes (bitmap). |
102 | * Undefined bits must be set to 0. |
103 | */ |
104 | enum { |
105 | UCAN_MODE_LOOPBACK = BIT(0), |
106 | UCAN_MODE_SILENT = BIT(1), |
107 | UCAN_MODE_3_SAMPLES = BIT(2), |
108 | UCAN_MODE_ONE_SHOT = BIT(3), |
109 | UCAN_MODE_BERR_REPORT = BIT(4), |
110 | }; |
111 | |
112 | /* UCAN_COMMAND_GET subcommands */ |
113 | enum { |
114 | UCAN_COMMAND_GET_INFO = 0, |
115 | UCAN_COMMAND_GET_PROTOCOL_VERSION = 1, |
116 | }; |
117 | |
118 | /* UCAN_COMMAND_FILTER subcommands */ |
119 | enum { |
120 | UCAN_FILTER_CLEAR = 0, |
121 | UCAN_FILTER_DISABLE = 1, |
122 | UCAN_FILTER_ENABLE = 2, |
123 | }; |
124 | |
125 | /* OUT endpoint message types */ |
126 | enum { |
127 | UCAN_OUT_TX = 2, /* transmit a CAN frame */ |
128 | }; |
129 | |
130 | /* IN endpoint message types */ |
131 | enum { |
132 | UCAN_IN_TX_COMPLETE = 1, /* CAN frame transmission completed */ |
133 | UCAN_IN_RX = 2, /* CAN frame received */ |
134 | }; |
135 | |
136 | struct ucan_ctl_cmd_start { |
137 | __le16 mode; /* OR-ing any of UCAN_MODE_* */ |
138 | } __packed; |
139 | |
140 | struct ucan_ctl_cmd_set_bittiming { |
141 | __le32 tq; /* Time quanta (TQ) in nanoseconds */ |
142 | __le16 brp; /* TQ Prescaler */ |
143 | __le16 sample_point; /* Samplepoint on tenth percent */ |
144 | u8 prop_seg; /* Propagation segment in TQs */ |
145 | u8 phase_seg1; /* Phase buffer segment 1 in TQs */ |
146 | u8 phase_seg2; /* Phase buffer segment 2 in TQs */ |
147 | u8 sjw; /* Synchronisation jump width in TQs */ |
148 | } __packed; |
149 | |
150 | struct ucan_ctl_cmd_device_info { |
151 | __le32 freq; /* Clock Frequency for tq generation */ |
152 | u8 tx_fifo; /* Size of the transmission fifo */ |
153 | u8 sjw_max; /* can_bittiming fields... */ |
154 | u8 tseg1_min; |
155 | u8 tseg1_max; |
156 | u8 tseg2_min; |
157 | u8 tseg2_max; |
158 | __le16 brp_inc; |
159 | __le32 brp_min; |
160 | __le32 brp_max; /* ...can_bittiming fields */ |
161 | __le16 ctrlmodes; /* supported control modes */ |
162 | __le16 hwfilter; /* Number of HW filter banks */ |
163 | __le16 rxmboxes; /* Number of receive Mailboxes */ |
164 | } __packed; |
165 | |
166 | struct ucan_ctl_cmd_get_protocol_version { |
167 | __le32 version; |
168 | } __packed; |
169 | |
170 | union ucan_ctl_payload { |
171 | /* Setup Bittiming |
172 | * bmRequest == UCAN_COMMAND_START |
173 | */ |
174 | struct ucan_ctl_cmd_start cmd_start; |
175 | /* Setup Bittiming |
176 | * bmRequest == UCAN_COMMAND_SET_BITTIMING |
177 | */ |
178 | struct ucan_ctl_cmd_set_bittiming cmd_set_bittiming; |
179 | /* Get Device Information |
180 | * bmRequest == UCAN_COMMAND_GET; wValue = UCAN_COMMAND_GET_INFO |
181 | */ |
182 | struct ucan_ctl_cmd_device_info cmd_get_device_info; |
183 | /* Get Protocol Version |
184 | * bmRequest == UCAN_COMMAND_GET; |
185 | * wValue = UCAN_COMMAND_GET_PROTOCOL_VERSION |
186 | */ |
187 | struct ucan_ctl_cmd_get_protocol_version cmd_get_protocol_version; |
188 | |
189 | u8 raw[128]; |
190 | } __packed; |
191 | |
192 | enum { |
193 | UCAN_TX_COMPLETE_SUCCESS = BIT(0), |
194 | }; |
195 | |
196 | /* Transmission Complete within ucan_message_in */ |
197 | struct ucan_tx_complete_entry_t { |
198 | u8 echo_index; |
199 | u8 flags; |
200 | } __packed __aligned(0x2); |
201 | |
202 | /* CAN Data message format within ucan_message_in/out */ |
203 | struct ucan_can_msg { |
204 | /* note DLC is computed by |
205 | * msg.len - sizeof (msg.len) |
206 | * - sizeof (msg.type) |
207 | * - sizeof (msg.can_msg.id) |
208 | */ |
209 | __le32 id; |
210 | |
211 | union { |
212 | u8 data[CAN_MAX_DLEN]; /* Data of CAN frames */ |
213 | u8 dlc; /* RTR dlc */ |
214 | }; |
215 | } __packed; |
216 | |
217 | /* OUT Endpoint, outbound messages */ |
218 | struct ucan_message_out { |
219 | __le16 len; /* Length of the content include header */ |
220 | u8 type; /* UCAN_OUT_TX and friends */ |
221 | u8 subtype; /* command sub type */ |
222 | |
223 | union { |
224 | /* Transmit CAN frame |
225 | * (type == UCAN_TX) && ((msg.can_msg.id & CAN_RTR_FLAG) == 0) |
226 | * subtype stores the echo id |
227 | */ |
228 | struct ucan_can_msg can_msg; |
229 | } msg; |
230 | } __packed __aligned(0x4); |
231 | |
232 | /* IN Endpoint, inbound messages */ |
233 | struct ucan_message_in { |
234 | __le16 len; /* Length of the content include header */ |
235 | u8 type; /* UCAN_IN_RX and friends */ |
236 | u8 subtype; /* command sub type */ |
237 | |
238 | union { |
239 | /* CAN Frame received |
240 | * (type == UCAN_IN_RX) |
241 | * && ((msg.can_msg.id & CAN_RTR_FLAG) == 0) |
242 | */ |
243 | struct ucan_can_msg can_msg; |
244 | |
245 | /* CAN transmission complete |
246 | * (type == UCAN_IN_TX_COMPLETE) |
247 | */ |
248 | DECLARE_FLEX_ARRAY(struct ucan_tx_complete_entry_t, |
249 | can_tx_complete_msg); |
250 | } __aligned(0x4) msg; |
251 | } __packed __aligned(0x4); |
252 | |
253 | /* Macros to calculate message lengths */ |
254 | #define UCAN_OUT_HDR_SIZE offsetof(struct ucan_message_out, msg) |
255 | |
256 | #define UCAN_IN_HDR_SIZE offsetof(struct ucan_message_in, msg) |
257 | #define UCAN_IN_LEN(member) (UCAN_OUT_HDR_SIZE + sizeof(member)) |
258 | |
259 | struct ucan_priv; |
260 | |
261 | /* Context Information for transmission URBs */ |
262 | struct ucan_urb_context { |
263 | struct ucan_priv *up; |
264 | bool allocated; |
265 | }; |
266 | |
267 | /* Information reported by the USB device */ |
268 | struct ucan_device_info { |
269 | struct can_bittiming_const bittiming_const; |
270 | u8 tx_fifo; |
271 | }; |
272 | |
273 | /* Driver private data */ |
274 | struct ucan_priv { |
275 | /* must be the first member */ |
276 | struct can_priv can; |
277 | |
278 | /* linux USB device structures */ |
279 | struct usb_device *udev; |
280 | struct net_device *netdev; |
281 | |
282 | /* lock for can->echo_skb (used around |
283 | * can_put/get/free_echo_skb |
284 | */ |
285 | spinlock_t echo_skb_lock; |
286 | |
287 | /* usb device information */ |
288 | u8 intf_index; |
289 | u8 in_ep_addr; |
290 | u8 out_ep_addr; |
291 | u16 in_ep_size; |
292 | |
293 | /* transmission and reception buffers */ |
294 | struct usb_anchor rx_urbs; |
295 | struct usb_anchor tx_urbs; |
296 | |
297 | union ucan_ctl_payload *ctl_msg_buffer; |
298 | struct ucan_device_info device_info; |
299 | |
300 | /* transmission control information and locks */ |
301 | spinlock_t context_lock; |
302 | unsigned int available_tx_urbs; |
303 | struct ucan_urb_context *context_array; |
304 | }; |
305 | |
306 | static u8 ucan_can_cc_dlc2len(struct ucan_can_msg *msg, u16 len) |
307 | { |
308 | if (le32_to_cpu(msg->id) & CAN_RTR_FLAG) |
309 | return can_cc_dlc2len(msg->dlc); |
310 | else |
311 | return can_cc_dlc2len(len - (UCAN_IN_HDR_SIZE + sizeof(msg->id))); |
312 | } |
313 | |
314 | static void ucan_release_context_array(struct ucan_priv *up) |
315 | { |
316 | if (!up->context_array) |
317 | return; |
318 | |
319 | /* lock is not needed because, driver is currently opening or closing */ |
320 | up->available_tx_urbs = 0; |
321 | |
322 | kfree(objp: up->context_array); |
323 | up->context_array = NULL; |
324 | } |
325 | |
326 | static int ucan_alloc_context_array(struct ucan_priv *up) |
327 | { |
328 | int i; |
329 | |
330 | /* release contexts if any */ |
331 | ucan_release_context_array(up); |
332 | |
333 | up->context_array = kcalloc(n: up->device_info.tx_fifo, |
334 | size: sizeof(*up->context_array), |
335 | GFP_KERNEL); |
336 | if (!up->context_array) { |
337 | netdev_err(dev: up->netdev, |
338 | format: "Not enough memory to allocate tx contexts\n" ); |
339 | return -ENOMEM; |
340 | } |
341 | |
342 | for (i = 0; i < up->device_info.tx_fifo; i++) { |
343 | up->context_array[i].allocated = false; |
344 | up->context_array[i].up = up; |
345 | } |
346 | |
347 | /* lock is not needed because, driver is currently opening */ |
348 | up->available_tx_urbs = up->device_info.tx_fifo; |
349 | |
350 | return 0; |
351 | } |
352 | |
353 | static struct ucan_urb_context *ucan_alloc_context(struct ucan_priv *up) |
354 | { |
355 | int i; |
356 | unsigned long flags; |
357 | struct ucan_urb_context *ret = NULL; |
358 | |
359 | if (WARN_ON_ONCE(!up->context_array)) |
360 | return NULL; |
361 | |
362 | /* execute context operation atomically */ |
363 | spin_lock_irqsave(&up->context_lock, flags); |
364 | |
365 | for (i = 0; i < up->device_info.tx_fifo; i++) { |
366 | if (!up->context_array[i].allocated) { |
367 | /* update context */ |
368 | ret = &up->context_array[i]; |
369 | up->context_array[i].allocated = true; |
370 | |
371 | /* stop queue if necessary */ |
372 | up->available_tx_urbs--; |
373 | if (!up->available_tx_urbs) |
374 | netif_stop_queue(dev: up->netdev); |
375 | |
376 | break; |
377 | } |
378 | } |
379 | |
380 | spin_unlock_irqrestore(lock: &up->context_lock, flags); |
381 | return ret; |
382 | } |
383 | |
384 | static bool ucan_release_context(struct ucan_priv *up, |
385 | struct ucan_urb_context *ctx) |
386 | { |
387 | unsigned long flags; |
388 | bool ret = false; |
389 | |
390 | if (WARN_ON_ONCE(!up->context_array)) |
391 | return false; |
392 | |
393 | /* execute context operation atomically */ |
394 | spin_lock_irqsave(&up->context_lock, flags); |
395 | |
396 | /* context was not allocated, maybe the device sent garbage */ |
397 | if (ctx->allocated) { |
398 | ctx->allocated = false; |
399 | |
400 | /* check if the queue needs to be woken */ |
401 | if (!up->available_tx_urbs) |
402 | netif_wake_queue(dev: up->netdev); |
403 | up->available_tx_urbs++; |
404 | |
405 | ret = true; |
406 | } |
407 | |
408 | spin_unlock_irqrestore(lock: &up->context_lock, flags); |
409 | return ret; |
410 | } |
411 | |
412 | static int ucan_ctrl_command_out(struct ucan_priv *up, |
413 | u8 cmd, u16 subcmd, u16 datalen) |
414 | { |
415 | return usb_control_msg(dev: up->udev, |
416 | usb_sndctrlpipe(up->udev, 0), |
417 | request: cmd, |
418 | USB_DIR_OUT | USB_TYPE_VENDOR | |
419 | USB_RECIP_INTERFACE, |
420 | value: subcmd, |
421 | index: up->intf_index, |
422 | data: up->ctl_msg_buffer, |
423 | size: datalen, |
424 | UCAN_USB_CTL_PIPE_TIMEOUT); |
425 | } |
426 | |
427 | static int ucan_device_request_in(struct ucan_priv *up, |
428 | u8 cmd, u16 subcmd, u16 datalen) |
429 | { |
430 | return usb_control_msg(dev: up->udev, |
431 | usb_rcvctrlpipe(up->udev, 0), |
432 | request: cmd, |
433 | USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, |
434 | value: subcmd, |
435 | index: 0, |
436 | data: up->ctl_msg_buffer, |
437 | size: datalen, |
438 | UCAN_USB_CTL_PIPE_TIMEOUT); |
439 | } |
440 | |
441 | /* Parse the device information structure reported by the device and |
442 | * setup private variables accordingly |
443 | */ |
444 | static void ucan_parse_device_info(struct ucan_priv *up, |
445 | struct ucan_ctl_cmd_device_info *device_info) |
446 | { |
447 | struct can_bittiming_const *bittiming = |
448 | &up->device_info.bittiming_const; |
449 | u16 ctrlmodes; |
450 | |
451 | /* store the data */ |
452 | up->can.clock.freq = le32_to_cpu(device_info->freq); |
453 | up->device_info.tx_fifo = device_info->tx_fifo; |
454 | strcpy(p: bittiming->name, q: "ucan" ); |
455 | bittiming->tseg1_min = device_info->tseg1_min; |
456 | bittiming->tseg1_max = device_info->tseg1_max; |
457 | bittiming->tseg2_min = device_info->tseg2_min; |
458 | bittiming->tseg2_max = device_info->tseg2_max; |
459 | bittiming->sjw_max = device_info->sjw_max; |
460 | bittiming->brp_min = le32_to_cpu(device_info->brp_min); |
461 | bittiming->brp_max = le32_to_cpu(device_info->brp_max); |
462 | bittiming->brp_inc = le16_to_cpu(device_info->brp_inc); |
463 | |
464 | ctrlmodes = le16_to_cpu(device_info->ctrlmodes); |
465 | |
466 | up->can.ctrlmode_supported = 0; |
467 | |
468 | if (ctrlmodes & UCAN_MODE_LOOPBACK) |
469 | up->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK; |
470 | if (ctrlmodes & UCAN_MODE_SILENT) |
471 | up->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY; |
472 | if (ctrlmodes & UCAN_MODE_3_SAMPLES) |
473 | up->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES; |
474 | if (ctrlmodes & UCAN_MODE_ONE_SHOT) |
475 | up->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT; |
476 | if (ctrlmodes & UCAN_MODE_BERR_REPORT) |
477 | up->can.ctrlmode_supported |= CAN_CTRLMODE_BERR_REPORTING; |
478 | } |
479 | |
480 | /* Handle a CAN error frame that we have received from the device. |
481 | * Returns true if the can state has changed. |
482 | */ |
483 | static bool ucan_handle_error_frame(struct ucan_priv *up, |
484 | struct ucan_message_in *m, |
485 | canid_t canid) |
486 | { |
487 | enum can_state new_state = up->can.state; |
488 | struct net_device_stats *net_stats = &up->netdev->stats; |
489 | struct can_device_stats *can_stats = &up->can.can_stats; |
490 | |
491 | if (canid & CAN_ERR_LOSTARB) |
492 | can_stats->arbitration_lost++; |
493 | |
494 | if (canid & CAN_ERR_BUSERROR) |
495 | can_stats->bus_error++; |
496 | |
497 | if (canid & CAN_ERR_ACK) |
498 | net_stats->tx_errors++; |
499 | |
500 | if (canid & CAN_ERR_BUSOFF) |
501 | new_state = CAN_STATE_BUS_OFF; |
502 | |
503 | /* controller problems, details in data[1] */ |
504 | if (canid & CAN_ERR_CRTL) { |
505 | u8 d1 = m->msg.can_msg.data[1]; |
506 | |
507 | if (d1 & CAN_ERR_CRTL_RX_OVERFLOW) |
508 | net_stats->rx_over_errors++; |
509 | |
510 | /* controller state bits: if multiple are set the worst wins */ |
511 | if (d1 & CAN_ERR_CRTL_ACTIVE) |
512 | new_state = CAN_STATE_ERROR_ACTIVE; |
513 | |
514 | if (d1 & (CAN_ERR_CRTL_RX_WARNING | CAN_ERR_CRTL_TX_WARNING)) |
515 | new_state = CAN_STATE_ERROR_WARNING; |
516 | |
517 | if (d1 & (CAN_ERR_CRTL_RX_PASSIVE | CAN_ERR_CRTL_TX_PASSIVE)) |
518 | new_state = CAN_STATE_ERROR_PASSIVE; |
519 | } |
520 | |
521 | /* protocol error, details in data[2] */ |
522 | if (canid & CAN_ERR_PROT) { |
523 | u8 d2 = m->msg.can_msg.data[2]; |
524 | |
525 | if (d2 & CAN_ERR_PROT_TX) |
526 | net_stats->tx_errors++; |
527 | else |
528 | net_stats->rx_errors++; |
529 | } |
530 | |
531 | /* no state change - we are done */ |
532 | if (up->can.state == new_state) |
533 | return false; |
534 | |
535 | /* we switched into a better state */ |
536 | if (up->can.state > new_state) { |
537 | up->can.state = new_state; |
538 | return true; |
539 | } |
540 | |
541 | /* we switched into a worse state */ |
542 | up->can.state = new_state; |
543 | switch (new_state) { |
544 | case CAN_STATE_BUS_OFF: |
545 | can_stats->bus_off++; |
546 | can_bus_off(dev: up->netdev); |
547 | break; |
548 | case CAN_STATE_ERROR_PASSIVE: |
549 | can_stats->error_passive++; |
550 | break; |
551 | case CAN_STATE_ERROR_WARNING: |
552 | can_stats->error_warning++; |
553 | break; |
554 | default: |
555 | break; |
556 | } |
557 | return true; |
558 | } |
559 | |
560 | /* Callback on reception of a can frame via the IN endpoint |
561 | * |
562 | * This function allocates an skb and transferres it to the Linux |
563 | * network stack |
564 | */ |
565 | static void ucan_rx_can_msg(struct ucan_priv *up, struct ucan_message_in *m) |
566 | { |
567 | int len; |
568 | canid_t canid; |
569 | struct can_frame *cf; |
570 | struct sk_buff *skb; |
571 | struct net_device_stats *stats = &up->netdev->stats; |
572 | |
573 | /* get the contents of the length field */ |
574 | len = le16_to_cpu(m->len); |
575 | |
576 | /* check sanity */ |
577 | if (len < UCAN_IN_HDR_SIZE + sizeof(m->msg.can_msg.id)) { |
578 | netdev_warn(dev: up->netdev, format: "invalid input message len: %d\n" , len); |
579 | return; |
580 | } |
581 | |
582 | /* handle error frames */ |
583 | canid = le32_to_cpu(m->msg.can_msg.id); |
584 | if (canid & CAN_ERR_FLAG) { |
585 | bool busstate_changed = ucan_handle_error_frame(up, m, canid); |
586 | |
587 | /* if berr-reporting is off only state changes get through */ |
588 | if (!(up->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) && |
589 | !busstate_changed) |
590 | return; |
591 | } else { |
592 | canid_t canid_mask; |
593 | /* compute the mask for canid */ |
594 | canid_mask = CAN_RTR_FLAG; |
595 | if (canid & CAN_EFF_FLAG) |
596 | canid_mask |= CAN_EFF_MASK | CAN_EFF_FLAG; |
597 | else |
598 | canid_mask |= CAN_SFF_MASK; |
599 | |
600 | if (canid & ~canid_mask) |
601 | netdev_warn(dev: up->netdev, |
602 | format: "unexpected bits set (canid %x, mask %x)" , |
603 | canid, canid_mask); |
604 | |
605 | canid &= canid_mask; |
606 | } |
607 | |
608 | /* allocate skb */ |
609 | skb = alloc_can_skb(dev: up->netdev, cf: &cf); |
610 | if (!skb) |
611 | return; |
612 | |
613 | /* fill the can frame */ |
614 | cf->can_id = canid; |
615 | |
616 | /* compute DLC taking RTR_FLAG into account */ |
617 | cf->len = ucan_can_cc_dlc2len(msg: &m->msg.can_msg, len); |
618 | |
619 | /* copy the payload of non RTR frames */ |
620 | if (!(cf->can_id & CAN_RTR_FLAG) || (cf->can_id & CAN_ERR_FLAG)) |
621 | memcpy(cf->data, m->msg.can_msg.data, cf->len); |
622 | |
623 | /* don't count error frames as real packets */ |
624 | if (!(cf->can_id & CAN_ERR_FLAG)) { |
625 | stats->rx_packets++; |
626 | if (!(cf->can_id & CAN_RTR_FLAG)) |
627 | stats->rx_bytes += cf->len; |
628 | } |
629 | |
630 | /* pass it to Linux */ |
631 | netif_rx(skb); |
632 | } |
633 | |
634 | /* callback indicating completed transmission */ |
635 | static void ucan_tx_complete_msg(struct ucan_priv *up, |
636 | struct ucan_message_in *m) |
637 | { |
638 | unsigned long flags; |
639 | u16 count, i; |
640 | u8 echo_index; |
641 | u16 len = le16_to_cpu(m->len); |
642 | |
643 | struct ucan_urb_context *context; |
644 | |
645 | if (len < UCAN_IN_HDR_SIZE || (len % 2 != 0)) { |
646 | netdev_err(dev: up->netdev, format: "invalid tx complete length\n" ); |
647 | return; |
648 | } |
649 | |
650 | count = (len - UCAN_IN_HDR_SIZE) / 2; |
651 | for (i = 0; i < count; i++) { |
652 | /* we did not submit such echo ids */ |
653 | echo_index = m->msg.can_tx_complete_msg[i].echo_index; |
654 | if (echo_index >= up->device_info.tx_fifo) { |
655 | up->netdev->stats.tx_errors++; |
656 | netdev_err(dev: up->netdev, |
657 | format: "invalid echo_index %d received\n" , |
658 | echo_index); |
659 | continue; |
660 | } |
661 | |
662 | /* gather information from the context */ |
663 | context = &up->context_array[echo_index]; |
664 | |
665 | /* Release context and restart queue if necessary. |
666 | * Also check if the context was allocated |
667 | */ |
668 | if (!ucan_release_context(up, ctx: context)) |
669 | continue; |
670 | |
671 | spin_lock_irqsave(&up->echo_skb_lock, flags); |
672 | if (m->msg.can_tx_complete_msg[i].flags & |
673 | UCAN_TX_COMPLETE_SUCCESS) { |
674 | /* update statistics */ |
675 | up->netdev->stats.tx_packets++; |
676 | up->netdev->stats.tx_bytes += |
677 | can_get_echo_skb(dev: up->netdev, idx: echo_index, NULL); |
678 | } else { |
679 | up->netdev->stats.tx_dropped++; |
680 | can_free_echo_skb(dev: up->netdev, idx: echo_index, NULL); |
681 | } |
682 | spin_unlock_irqrestore(lock: &up->echo_skb_lock, flags); |
683 | } |
684 | } |
685 | |
686 | /* callback on reception of a USB message */ |
687 | static void ucan_read_bulk_callback(struct urb *urb) |
688 | { |
689 | int ret; |
690 | int pos; |
691 | struct ucan_priv *up = urb->context; |
692 | struct net_device *netdev = up->netdev; |
693 | struct ucan_message_in *m; |
694 | |
695 | /* the device is not up and the driver should not receive any |
696 | * data on the bulk in pipe |
697 | */ |
698 | if (WARN_ON(!up->context_array)) { |
699 | usb_free_coherent(dev: up->udev, |
700 | size: up->in_ep_size, |
701 | addr: urb->transfer_buffer, |
702 | dma: urb->transfer_dma); |
703 | return; |
704 | } |
705 | |
706 | /* check URB status */ |
707 | switch (urb->status) { |
708 | case 0: |
709 | break; |
710 | case -ENOENT: |
711 | case -EPIPE: |
712 | case -EPROTO: |
713 | case -ESHUTDOWN: |
714 | case -ETIME: |
715 | /* urb is not resubmitted -> free dma data */ |
716 | usb_free_coherent(dev: up->udev, |
717 | size: up->in_ep_size, |
718 | addr: urb->transfer_buffer, |
719 | dma: urb->transfer_dma); |
720 | netdev_dbg(up->netdev, "not resubmitting urb; status: %d\n" , |
721 | urb->status); |
722 | return; |
723 | default: |
724 | goto resubmit; |
725 | } |
726 | |
727 | /* sanity check */ |
728 | if (!netif_device_present(dev: netdev)) |
729 | return; |
730 | |
731 | /* iterate over input */ |
732 | pos = 0; |
733 | while (pos < urb->actual_length) { |
734 | int len; |
735 | |
736 | /* check sanity (length of header) */ |
737 | if ((urb->actual_length - pos) < UCAN_IN_HDR_SIZE) { |
738 | netdev_warn(dev: up->netdev, |
739 | format: "invalid message (short; no hdr; l:%d)\n" , |
740 | urb->actual_length); |
741 | goto resubmit; |
742 | } |
743 | |
744 | /* setup the message address */ |
745 | m = (struct ucan_message_in *) |
746 | ((u8 *)urb->transfer_buffer + pos); |
747 | len = le16_to_cpu(m->len); |
748 | |
749 | /* check sanity (length of content) */ |
750 | if (urb->actual_length - pos < len) { |
751 | netdev_warn(dev: up->netdev, |
752 | format: "invalid message (short; no data; l:%d)\n" , |
753 | urb->actual_length); |
754 | print_hex_dump(KERN_WARNING, |
755 | prefix_str: "raw data: " , |
756 | prefix_type: DUMP_PREFIX_ADDRESS, |
757 | rowsize: 16, |
758 | groupsize: 1, |
759 | buf: urb->transfer_buffer, |
760 | len: urb->actual_length, |
761 | ascii: true); |
762 | |
763 | goto resubmit; |
764 | } |
765 | |
766 | switch (m->type) { |
767 | case UCAN_IN_RX: |
768 | ucan_rx_can_msg(up, m); |
769 | break; |
770 | case UCAN_IN_TX_COMPLETE: |
771 | ucan_tx_complete_msg(up, m); |
772 | break; |
773 | default: |
774 | netdev_warn(dev: up->netdev, |
775 | format: "invalid message (type; t:%d)\n" , |
776 | m->type); |
777 | break; |
778 | } |
779 | |
780 | /* proceed to next message */ |
781 | pos += len; |
782 | /* align to 4 byte boundary */ |
783 | pos = round_up(pos, 4); |
784 | } |
785 | |
786 | resubmit: |
787 | /* resubmit urb when done */ |
788 | usb_fill_bulk_urb(urb, dev: up->udev, |
789 | usb_rcvbulkpipe(up->udev, |
790 | up->in_ep_addr), |
791 | transfer_buffer: urb->transfer_buffer, |
792 | buffer_length: up->in_ep_size, |
793 | complete_fn: ucan_read_bulk_callback, |
794 | context: up); |
795 | |
796 | usb_anchor_urb(urb, anchor: &up->rx_urbs); |
797 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
798 | |
799 | if (ret < 0) { |
800 | netdev_err(dev: up->netdev, |
801 | format: "failed resubmitting read bulk urb: %d\n" , |
802 | ret); |
803 | |
804 | usb_unanchor_urb(urb); |
805 | usb_free_coherent(dev: up->udev, |
806 | size: up->in_ep_size, |
807 | addr: urb->transfer_buffer, |
808 | dma: urb->transfer_dma); |
809 | |
810 | if (ret == -ENODEV) |
811 | netif_device_detach(dev: netdev); |
812 | } |
813 | } |
814 | |
815 | /* callback after transmission of a USB message */ |
816 | static void ucan_write_bulk_callback(struct urb *urb) |
817 | { |
818 | unsigned long flags; |
819 | struct ucan_priv *up; |
820 | struct ucan_urb_context *context = urb->context; |
821 | |
822 | /* get the urb context */ |
823 | if (WARN_ON_ONCE(!context)) |
824 | return; |
825 | |
826 | /* free up our allocated buffer */ |
827 | usb_free_coherent(dev: urb->dev, |
828 | size: sizeof(struct ucan_message_out), |
829 | addr: urb->transfer_buffer, |
830 | dma: urb->transfer_dma); |
831 | |
832 | up = context->up; |
833 | if (WARN_ON_ONCE(!up)) |
834 | return; |
835 | |
836 | /* sanity check */ |
837 | if (!netif_device_present(dev: up->netdev)) |
838 | return; |
839 | |
840 | /* transmission failed (USB - the device will not send a TX complete) */ |
841 | if (urb->status) { |
842 | netdev_warn(dev: up->netdev, |
843 | format: "failed to transmit USB message to device: %d\n" , |
844 | urb->status); |
845 | |
846 | /* update counters an cleanup */ |
847 | spin_lock_irqsave(&up->echo_skb_lock, flags); |
848 | can_free_echo_skb(dev: up->netdev, idx: context - up->context_array, NULL); |
849 | spin_unlock_irqrestore(lock: &up->echo_skb_lock, flags); |
850 | |
851 | up->netdev->stats.tx_dropped++; |
852 | |
853 | /* release context and restart the queue if necessary */ |
854 | if (!ucan_release_context(up, ctx: context)) |
855 | netdev_err(dev: up->netdev, |
856 | format: "urb failed, failed to release context\n" ); |
857 | } |
858 | } |
859 | |
860 | static void ucan_cleanup_rx_urbs(struct ucan_priv *up, struct urb **urbs) |
861 | { |
862 | int i; |
863 | |
864 | for (i = 0; i < UCAN_MAX_RX_URBS; i++) { |
865 | if (urbs[i]) { |
866 | usb_unanchor_urb(urb: urbs[i]); |
867 | usb_free_coherent(dev: up->udev, |
868 | size: up->in_ep_size, |
869 | addr: urbs[i]->transfer_buffer, |
870 | dma: urbs[i]->transfer_dma); |
871 | usb_free_urb(urb: urbs[i]); |
872 | } |
873 | } |
874 | |
875 | memset(urbs, 0, sizeof(*urbs) * UCAN_MAX_RX_URBS); |
876 | } |
877 | |
878 | static int ucan_prepare_and_anchor_rx_urbs(struct ucan_priv *up, |
879 | struct urb **urbs) |
880 | { |
881 | int i; |
882 | |
883 | memset(urbs, 0, sizeof(*urbs) * UCAN_MAX_RX_URBS); |
884 | |
885 | for (i = 0; i < UCAN_MAX_RX_URBS; i++) { |
886 | void *buf; |
887 | |
888 | urbs[i] = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
889 | if (!urbs[i]) |
890 | goto err; |
891 | |
892 | buf = usb_alloc_coherent(dev: up->udev, |
893 | size: up->in_ep_size, |
894 | GFP_KERNEL, dma: &urbs[i]->transfer_dma); |
895 | if (!buf) { |
896 | /* cleanup this urb */ |
897 | usb_free_urb(urb: urbs[i]); |
898 | urbs[i] = NULL; |
899 | goto err; |
900 | } |
901 | |
902 | usb_fill_bulk_urb(urb: urbs[i], dev: up->udev, |
903 | usb_rcvbulkpipe(up->udev, |
904 | up->in_ep_addr), |
905 | transfer_buffer: buf, |
906 | buffer_length: up->in_ep_size, |
907 | complete_fn: ucan_read_bulk_callback, |
908 | context: up); |
909 | |
910 | urbs[i]->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
911 | |
912 | usb_anchor_urb(urb: urbs[i], anchor: &up->rx_urbs); |
913 | } |
914 | return 0; |
915 | |
916 | err: |
917 | /* cleanup other unsubmitted urbs */ |
918 | ucan_cleanup_rx_urbs(up, urbs); |
919 | return -ENOMEM; |
920 | } |
921 | |
922 | /* Submits rx urbs with the semantic: Either submit all, or cleanup |
923 | * everything. I case of errors submitted urbs are killed and all urbs in |
924 | * the array are freed. I case of no errors every entry in the urb |
925 | * array is set to NULL. |
926 | */ |
927 | static int ucan_submit_rx_urbs(struct ucan_priv *up, struct urb **urbs) |
928 | { |
929 | int i, ret; |
930 | |
931 | /* Iterate over all urbs to submit. On success remove the urb |
932 | * from the list. |
933 | */ |
934 | for (i = 0; i < UCAN_MAX_RX_URBS; i++) { |
935 | ret = usb_submit_urb(urb: urbs[i], GFP_KERNEL); |
936 | if (ret) { |
937 | netdev_err(dev: up->netdev, |
938 | format: "could not submit urb; code: %d\n" , |
939 | ret); |
940 | goto err; |
941 | } |
942 | |
943 | /* Anchor URB and drop reference, USB core will take |
944 | * care of freeing it |
945 | */ |
946 | usb_free_urb(urb: urbs[i]); |
947 | urbs[i] = NULL; |
948 | } |
949 | return 0; |
950 | |
951 | err: |
952 | /* Cleanup unsubmitted urbs */ |
953 | ucan_cleanup_rx_urbs(up, urbs); |
954 | |
955 | /* Kill urbs that are already submitted */ |
956 | usb_kill_anchored_urbs(anchor: &up->rx_urbs); |
957 | |
958 | return ret; |
959 | } |
960 | |
961 | /* Open the network device */ |
962 | static int ucan_open(struct net_device *netdev) |
963 | { |
964 | int ret, ret_cleanup; |
965 | u16 ctrlmode; |
966 | struct urb *urbs[UCAN_MAX_RX_URBS]; |
967 | struct ucan_priv *up = netdev_priv(dev: netdev); |
968 | |
969 | ret = ucan_alloc_context_array(up); |
970 | if (ret) |
971 | return ret; |
972 | |
973 | /* Allocate and prepare IN URBS - allocated and anchored |
974 | * urbs are stored in urbs[] for clean |
975 | */ |
976 | ret = ucan_prepare_and_anchor_rx_urbs(up, urbs); |
977 | if (ret) |
978 | goto err_contexts; |
979 | |
980 | /* Check the control mode */ |
981 | ctrlmode = 0; |
982 | if (up->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) |
983 | ctrlmode |= UCAN_MODE_LOOPBACK; |
984 | if (up->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) |
985 | ctrlmode |= UCAN_MODE_SILENT; |
986 | if (up->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES) |
987 | ctrlmode |= UCAN_MODE_3_SAMPLES; |
988 | if (up->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT) |
989 | ctrlmode |= UCAN_MODE_ONE_SHOT; |
990 | |
991 | /* Enable this in any case - filtering is down within the |
992 | * receive path |
993 | */ |
994 | ctrlmode |= UCAN_MODE_BERR_REPORT; |
995 | up->ctl_msg_buffer->cmd_start.mode = cpu_to_le16(ctrlmode); |
996 | |
997 | /* Driver is ready to receive data - start the USB device */ |
998 | ret = ucan_ctrl_command_out(up, cmd: UCAN_COMMAND_START, subcmd: 0, datalen: 2); |
999 | if (ret < 0) { |
1000 | netdev_err(dev: up->netdev, |
1001 | format: "could not start device, code: %d\n" , |
1002 | ret); |
1003 | goto err_reset; |
1004 | } |
1005 | |
1006 | /* Call CAN layer open */ |
1007 | ret = open_candev(dev: netdev); |
1008 | if (ret) |
1009 | goto err_stop; |
1010 | |
1011 | /* Driver is ready to receive data. Submit RX URBS */ |
1012 | ret = ucan_submit_rx_urbs(up, urbs); |
1013 | if (ret) |
1014 | goto err_stop; |
1015 | |
1016 | up->can.state = CAN_STATE_ERROR_ACTIVE; |
1017 | |
1018 | /* Start the network queue */ |
1019 | netif_start_queue(dev: netdev); |
1020 | |
1021 | return 0; |
1022 | |
1023 | err_stop: |
1024 | /* The device have started already stop it */ |
1025 | ret_cleanup = ucan_ctrl_command_out(up, cmd: UCAN_COMMAND_STOP, subcmd: 0, datalen: 0); |
1026 | if (ret_cleanup < 0) |
1027 | netdev_err(dev: up->netdev, |
1028 | format: "could not stop device, code: %d\n" , |
1029 | ret_cleanup); |
1030 | |
1031 | err_reset: |
1032 | /* The device might have received data, reset it for |
1033 | * consistent state |
1034 | */ |
1035 | ret_cleanup = ucan_ctrl_command_out(up, cmd: UCAN_COMMAND_RESET, subcmd: 0, datalen: 0); |
1036 | if (ret_cleanup < 0) |
1037 | netdev_err(dev: up->netdev, |
1038 | format: "could not reset device, code: %d\n" , |
1039 | ret_cleanup); |
1040 | |
1041 | /* clean up unsubmitted urbs */ |
1042 | ucan_cleanup_rx_urbs(up, urbs); |
1043 | |
1044 | err_contexts: |
1045 | ucan_release_context_array(up); |
1046 | return ret; |
1047 | } |
1048 | |
1049 | static struct urb *ucan_prepare_tx_urb(struct ucan_priv *up, |
1050 | struct ucan_urb_context *context, |
1051 | struct can_frame *cf, |
1052 | u8 echo_index) |
1053 | { |
1054 | int mlen; |
1055 | struct urb *urb; |
1056 | struct ucan_message_out *m; |
1057 | |
1058 | /* create a URB, and a buffer for it, and copy the data to the URB */ |
1059 | urb = usb_alloc_urb(iso_packets: 0, GFP_ATOMIC); |
1060 | if (!urb) { |
1061 | netdev_err(dev: up->netdev, format: "no memory left for URBs\n" ); |
1062 | return NULL; |
1063 | } |
1064 | |
1065 | m = usb_alloc_coherent(dev: up->udev, |
1066 | size: sizeof(struct ucan_message_out), |
1067 | GFP_ATOMIC, |
1068 | dma: &urb->transfer_dma); |
1069 | if (!m) { |
1070 | netdev_err(dev: up->netdev, format: "no memory left for USB buffer\n" ); |
1071 | usb_free_urb(urb); |
1072 | return NULL; |
1073 | } |
1074 | |
1075 | /* build the USB message */ |
1076 | m->type = UCAN_OUT_TX; |
1077 | m->msg.can_msg.id = cpu_to_le32(cf->can_id); |
1078 | |
1079 | if (cf->can_id & CAN_RTR_FLAG) { |
1080 | mlen = UCAN_OUT_HDR_SIZE + |
1081 | offsetof(struct ucan_can_msg, dlc) + |
1082 | sizeof(m->msg.can_msg.dlc); |
1083 | m->msg.can_msg.dlc = cf->len; |
1084 | } else { |
1085 | mlen = UCAN_OUT_HDR_SIZE + |
1086 | sizeof(m->msg.can_msg.id) + cf->len; |
1087 | memcpy(m->msg.can_msg.data, cf->data, cf->len); |
1088 | } |
1089 | m->len = cpu_to_le16(mlen); |
1090 | |
1091 | m->subtype = echo_index; |
1092 | |
1093 | /* build the urb */ |
1094 | usb_fill_bulk_urb(urb, dev: up->udev, |
1095 | usb_sndbulkpipe(up->udev, |
1096 | up->out_ep_addr), |
1097 | transfer_buffer: m, buffer_length: mlen, complete_fn: ucan_write_bulk_callback, context); |
1098 | urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; |
1099 | |
1100 | return urb; |
1101 | } |
1102 | |
1103 | static void ucan_clean_up_tx_urb(struct ucan_priv *up, struct urb *urb) |
1104 | { |
1105 | usb_free_coherent(dev: up->udev, size: sizeof(struct ucan_message_out), |
1106 | addr: urb->transfer_buffer, dma: urb->transfer_dma); |
1107 | usb_free_urb(urb); |
1108 | } |
1109 | |
1110 | /* callback when Linux needs to send a can frame */ |
1111 | static netdev_tx_t ucan_start_xmit(struct sk_buff *skb, |
1112 | struct net_device *netdev) |
1113 | { |
1114 | unsigned long flags; |
1115 | int ret; |
1116 | u8 echo_index; |
1117 | struct urb *urb; |
1118 | struct ucan_urb_context *context; |
1119 | struct ucan_priv *up = netdev_priv(dev: netdev); |
1120 | struct can_frame *cf = (struct can_frame *)skb->data; |
1121 | |
1122 | /* check skb */ |
1123 | if (can_dev_dropped_skb(dev: netdev, skb)) |
1124 | return NETDEV_TX_OK; |
1125 | |
1126 | /* allocate a context and slow down tx path, if fifo state is low */ |
1127 | context = ucan_alloc_context(up); |
1128 | echo_index = context - up->context_array; |
1129 | |
1130 | if (WARN_ON_ONCE(!context)) |
1131 | return NETDEV_TX_BUSY; |
1132 | |
1133 | /* prepare urb for transmission */ |
1134 | urb = ucan_prepare_tx_urb(up, context, cf, echo_index); |
1135 | if (!urb) |
1136 | goto drop; |
1137 | |
1138 | /* put the skb on can loopback stack */ |
1139 | spin_lock_irqsave(&up->echo_skb_lock, flags); |
1140 | can_put_echo_skb(skb, dev: up->netdev, idx: echo_index, frame_len: 0); |
1141 | spin_unlock_irqrestore(lock: &up->echo_skb_lock, flags); |
1142 | |
1143 | /* transmit it */ |
1144 | usb_anchor_urb(urb, anchor: &up->tx_urbs); |
1145 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
1146 | |
1147 | /* cleanup urb */ |
1148 | if (ret) { |
1149 | /* on error, clean up */ |
1150 | usb_unanchor_urb(urb); |
1151 | ucan_clean_up_tx_urb(up, urb); |
1152 | if (!ucan_release_context(up, ctx: context)) |
1153 | netdev_err(dev: up->netdev, |
1154 | format: "xmit err: failed to release context\n" ); |
1155 | |
1156 | /* remove the skb from the echo stack - this also |
1157 | * frees the skb |
1158 | */ |
1159 | spin_lock_irqsave(&up->echo_skb_lock, flags); |
1160 | can_free_echo_skb(dev: up->netdev, idx: echo_index, NULL); |
1161 | spin_unlock_irqrestore(lock: &up->echo_skb_lock, flags); |
1162 | |
1163 | if (ret == -ENODEV) { |
1164 | netif_device_detach(dev: up->netdev); |
1165 | } else { |
1166 | netdev_warn(dev: up->netdev, |
1167 | format: "xmit err: failed to submit urb %d\n" , |
1168 | ret); |
1169 | up->netdev->stats.tx_dropped++; |
1170 | } |
1171 | return NETDEV_TX_OK; |
1172 | } |
1173 | |
1174 | netif_trans_update(dev: netdev); |
1175 | |
1176 | /* release ref, as we do not need the urb anymore */ |
1177 | usb_free_urb(urb); |
1178 | |
1179 | return NETDEV_TX_OK; |
1180 | |
1181 | drop: |
1182 | if (!ucan_release_context(up, ctx: context)) |
1183 | netdev_err(dev: up->netdev, |
1184 | format: "xmit drop: failed to release context\n" ); |
1185 | dev_kfree_skb(skb); |
1186 | up->netdev->stats.tx_dropped++; |
1187 | |
1188 | return NETDEV_TX_OK; |
1189 | } |
1190 | |
1191 | /* Device goes down |
1192 | * |
1193 | * Clean up used resources |
1194 | */ |
1195 | static int ucan_close(struct net_device *netdev) |
1196 | { |
1197 | int ret; |
1198 | struct ucan_priv *up = netdev_priv(dev: netdev); |
1199 | |
1200 | up->can.state = CAN_STATE_STOPPED; |
1201 | |
1202 | /* stop sending data */ |
1203 | usb_kill_anchored_urbs(anchor: &up->tx_urbs); |
1204 | |
1205 | /* stop receiving data */ |
1206 | usb_kill_anchored_urbs(anchor: &up->rx_urbs); |
1207 | |
1208 | /* stop and reset can device */ |
1209 | ret = ucan_ctrl_command_out(up, cmd: UCAN_COMMAND_STOP, subcmd: 0, datalen: 0); |
1210 | if (ret < 0) |
1211 | netdev_err(dev: up->netdev, |
1212 | format: "could not stop device, code: %d\n" , |
1213 | ret); |
1214 | |
1215 | ret = ucan_ctrl_command_out(up, cmd: UCAN_COMMAND_RESET, subcmd: 0, datalen: 0); |
1216 | if (ret < 0) |
1217 | netdev_err(dev: up->netdev, |
1218 | format: "could not reset device, code: %d\n" , |
1219 | ret); |
1220 | |
1221 | netif_stop_queue(dev: netdev); |
1222 | |
1223 | ucan_release_context_array(up); |
1224 | |
1225 | close_candev(dev: up->netdev); |
1226 | return 0; |
1227 | } |
1228 | |
1229 | /* CAN driver callbacks */ |
1230 | static const struct net_device_ops ucan_netdev_ops = { |
1231 | .ndo_open = ucan_open, |
1232 | .ndo_stop = ucan_close, |
1233 | .ndo_start_xmit = ucan_start_xmit, |
1234 | .ndo_change_mtu = can_change_mtu, |
1235 | }; |
1236 | |
1237 | static const struct ethtool_ops ucan_ethtool_ops = { |
1238 | .get_ts_info = ethtool_op_get_ts_info, |
1239 | }; |
1240 | |
1241 | /* Request to set bittiming |
1242 | * |
1243 | * This function generates an USB set bittiming message and transmits |
1244 | * it to the device |
1245 | */ |
1246 | static int ucan_set_bittiming(struct net_device *netdev) |
1247 | { |
1248 | int ret; |
1249 | struct ucan_priv *up = netdev_priv(dev: netdev); |
1250 | struct ucan_ctl_cmd_set_bittiming *cmd_set_bittiming; |
1251 | |
1252 | cmd_set_bittiming = &up->ctl_msg_buffer->cmd_set_bittiming; |
1253 | cmd_set_bittiming->tq = cpu_to_le32(up->can.bittiming.tq); |
1254 | cmd_set_bittiming->brp = cpu_to_le16(up->can.bittiming.brp); |
1255 | cmd_set_bittiming->sample_point = |
1256 | cpu_to_le16(up->can.bittiming.sample_point); |
1257 | cmd_set_bittiming->prop_seg = up->can.bittiming.prop_seg; |
1258 | cmd_set_bittiming->phase_seg1 = up->can.bittiming.phase_seg1; |
1259 | cmd_set_bittiming->phase_seg2 = up->can.bittiming.phase_seg2; |
1260 | cmd_set_bittiming->sjw = up->can.bittiming.sjw; |
1261 | |
1262 | ret = ucan_ctrl_command_out(up, cmd: UCAN_COMMAND_SET_BITTIMING, subcmd: 0, |
1263 | datalen: sizeof(*cmd_set_bittiming)); |
1264 | return (ret < 0) ? ret : 0; |
1265 | } |
1266 | |
1267 | /* Restart the device to get it out of BUS-OFF state. |
1268 | * Called when the user runs "ip link set can1 type can restart". |
1269 | */ |
1270 | static int ucan_set_mode(struct net_device *netdev, enum can_mode mode) |
1271 | { |
1272 | int ret; |
1273 | unsigned long flags; |
1274 | struct ucan_priv *up = netdev_priv(dev: netdev); |
1275 | |
1276 | switch (mode) { |
1277 | case CAN_MODE_START: |
1278 | netdev_dbg(up->netdev, "restarting device\n" ); |
1279 | |
1280 | ret = ucan_ctrl_command_out(up, cmd: UCAN_COMMAND_RESTART, subcmd: 0, datalen: 0); |
1281 | up->can.state = CAN_STATE_ERROR_ACTIVE; |
1282 | |
1283 | /* check if queue can be restarted, |
1284 | * up->available_tx_urbs must be protected by the |
1285 | * lock |
1286 | */ |
1287 | spin_lock_irqsave(&up->context_lock, flags); |
1288 | |
1289 | if (up->available_tx_urbs > 0) |
1290 | netif_wake_queue(dev: up->netdev); |
1291 | |
1292 | spin_unlock_irqrestore(lock: &up->context_lock, flags); |
1293 | |
1294 | return ret; |
1295 | default: |
1296 | return -EOPNOTSUPP; |
1297 | } |
1298 | } |
1299 | |
1300 | /* Probe the device, reset it and gather general device information */ |
1301 | static int ucan_probe(struct usb_interface *intf, |
1302 | const struct usb_device_id *id) |
1303 | { |
1304 | int ret; |
1305 | int i; |
1306 | u32 protocol_version; |
1307 | struct usb_device *udev; |
1308 | struct net_device *netdev; |
1309 | struct usb_host_interface *iface_desc; |
1310 | struct ucan_priv *up; |
1311 | struct usb_endpoint_descriptor *ep; |
1312 | u16 in_ep_size; |
1313 | u16 out_ep_size; |
1314 | u8 in_ep_addr; |
1315 | u8 out_ep_addr; |
1316 | union ucan_ctl_payload *ctl_msg_buffer; |
1317 | char firmware_str[sizeof(union ucan_ctl_payload) + 1]; |
1318 | |
1319 | udev = interface_to_usbdev(intf); |
1320 | |
1321 | /* Stage 1 - Interface Parsing |
1322 | * --------------------------- |
1323 | * |
1324 | * Identifie the device USB interface descriptor and its |
1325 | * endpoints. Probing is aborted on errors. |
1326 | */ |
1327 | |
1328 | /* check if the interface is sane */ |
1329 | iface_desc = intf->cur_altsetting; |
1330 | if (!iface_desc) |
1331 | return -ENODEV; |
1332 | |
1333 | dev_info(&udev->dev, |
1334 | "%s: probing device on interface #%d\n" , |
1335 | UCAN_DRIVER_NAME, |
1336 | iface_desc->desc.bInterfaceNumber); |
1337 | |
1338 | /* interface sanity check */ |
1339 | if (iface_desc->desc.bNumEndpoints != 2) { |
1340 | dev_err(&udev->dev, |
1341 | "%s: invalid EP count (%d)" , |
1342 | UCAN_DRIVER_NAME, iface_desc->desc.bNumEndpoints); |
1343 | goto err_firmware_needs_update; |
1344 | } |
1345 | |
1346 | /* check interface endpoints */ |
1347 | in_ep_addr = 0; |
1348 | out_ep_addr = 0; |
1349 | in_ep_size = 0; |
1350 | out_ep_size = 0; |
1351 | for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) { |
1352 | ep = &iface_desc->endpoint[i].desc; |
1353 | |
1354 | if (((ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) != 0) && |
1355 | ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == |
1356 | USB_ENDPOINT_XFER_BULK)) { |
1357 | /* In Endpoint */ |
1358 | in_ep_addr = ep->bEndpointAddress; |
1359 | in_ep_addr &= USB_ENDPOINT_NUMBER_MASK; |
1360 | in_ep_size = le16_to_cpu(ep->wMaxPacketSize); |
1361 | } else if (((ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == |
1362 | 0) && |
1363 | ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == |
1364 | USB_ENDPOINT_XFER_BULK)) { |
1365 | /* Out Endpoint */ |
1366 | out_ep_addr = ep->bEndpointAddress; |
1367 | out_ep_addr &= USB_ENDPOINT_NUMBER_MASK; |
1368 | out_ep_size = le16_to_cpu(ep->wMaxPacketSize); |
1369 | } |
1370 | } |
1371 | |
1372 | /* check if interface is sane */ |
1373 | if (!in_ep_addr || !out_ep_addr) { |
1374 | dev_err(&udev->dev, "%s: invalid endpoint configuration\n" , |
1375 | UCAN_DRIVER_NAME); |
1376 | goto err_firmware_needs_update; |
1377 | } |
1378 | if (in_ep_size < sizeof(struct ucan_message_in)) { |
1379 | dev_err(&udev->dev, "%s: invalid in_ep MaxPacketSize\n" , |
1380 | UCAN_DRIVER_NAME); |
1381 | goto err_firmware_needs_update; |
1382 | } |
1383 | if (out_ep_size < sizeof(struct ucan_message_out)) { |
1384 | dev_err(&udev->dev, "%s: invalid out_ep MaxPacketSize\n" , |
1385 | UCAN_DRIVER_NAME); |
1386 | goto err_firmware_needs_update; |
1387 | } |
1388 | |
1389 | /* Stage 2 - Device Identification |
1390 | * ------------------------------- |
1391 | * |
1392 | * The device interface seems to be a ucan device. Do further |
1393 | * compatibility checks. On error probing is aborted, on |
1394 | * success this stage leaves the ctl_msg_buffer with the |
1395 | * reported contents of a GET_INFO command (supported |
1396 | * bittimings, tx_fifo depth). This information is used in |
1397 | * Stage 3 for the final driver initialisation. |
1398 | */ |
1399 | |
1400 | /* Prepare Memory for control transfers */ |
1401 | ctl_msg_buffer = devm_kzalloc(dev: &udev->dev, |
1402 | size: sizeof(union ucan_ctl_payload), |
1403 | GFP_KERNEL); |
1404 | if (!ctl_msg_buffer) { |
1405 | dev_err(&udev->dev, |
1406 | "%s: failed to allocate control pipe memory\n" , |
1407 | UCAN_DRIVER_NAME); |
1408 | return -ENOMEM; |
1409 | } |
1410 | |
1411 | /* get protocol version |
1412 | * |
1413 | * note: ucan_ctrl_command_* wrappers cannot be used yet |
1414 | * because `up` is initialised in Stage 3 |
1415 | */ |
1416 | ret = usb_control_msg(dev: udev, |
1417 | usb_rcvctrlpipe(udev, 0), |
1418 | request: UCAN_COMMAND_GET, |
1419 | USB_DIR_IN | USB_TYPE_VENDOR | |
1420 | USB_RECIP_INTERFACE, |
1421 | value: UCAN_COMMAND_GET_PROTOCOL_VERSION, |
1422 | index: iface_desc->desc.bInterfaceNumber, |
1423 | data: ctl_msg_buffer, |
1424 | size: sizeof(union ucan_ctl_payload), |
1425 | UCAN_USB_CTL_PIPE_TIMEOUT); |
1426 | |
1427 | /* older firmware version do not support this command - those |
1428 | * are not supported by this drive |
1429 | */ |
1430 | if (ret != 4) { |
1431 | dev_err(&udev->dev, |
1432 | "%s: could not read protocol version, ret=%d\n" , |
1433 | UCAN_DRIVER_NAME, ret); |
1434 | if (ret >= 0) |
1435 | ret = -EINVAL; |
1436 | goto err_firmware_needs_update; |
1437 | } |
1438 | |
1439 | /* this driver currently supports protocol version 3 only */ |
1440 | protocol_version = |
1441 | le32_to_cpu(ctl_msg_buffer->cmd_get_protocol_version.version); |
1442 | if (protocol_version < UCAN_PROTOCOL_VERSION_MIN || |
1443 | protocol_version > UCAN_PROTOCOL_VERSION_MAX) { |
1444 | dev_err(&udev->dev, |
1445 | "%s: device protocol version %d is not supported\n" , |
1446 | UCAN_DRIVER_NAME, protocol_version); |
1447 | goto err_firmware_needs_update; |
1448 | } |
1449 | |
1450 | /* request the device information and store it in ctl_msg_buffer |
1451 | * |
1452 | * note: ucan_ctrl_command_* wrappers cannot be used yet |
1453 | * because `up` is initialised in Stage 3 |
1454 | */ |
1455 | ret = usb_control_msg(dev: udev, |
1456 | usb_rcvctrlpipe(udev, 0), |
1457 | request: UCAN_COMMAND_GET, |
1458 | USB_DIR_IN | USB_TYPE_VENDOR | |
1459 | USB_RECIP_INTERFACE, |
1460 | value: UCAN_COMMAND_GET_INFO, |
1461 | index: iface_desc->desc.bInterfaceNumber, |
1462 | data: ctl_msg_buffer, |
1463 | size: sizeof(ctl_msg_buffer->cmd_get_device_info), |
1464 | UCAN_USB_CTL_PIPE_TIMEOUT); |
1465 | |
1466 | if (ret < 0) { |
1467 | dev_err(&udev->dev, "%s: failed to retrieve device info\n" , |
1468 | UCAN_DRIVER_NAME); |
1469 | goto err_firmware_needs_update; |
1470 | } |
1471 | if (ret < sizeof(ctl_msg_buffer->cmd_get_device_info)) { |
1472 | dev_err(&udev->dev, "%s: device reported invalid device info\n" , |
1473 | UCAN_DRIVER_NAME); |
1474 | goto err_firmware_needs_update; |
1475 | } |
1476 | if (ctl_msg_buffer->cmd_get_device_info.tx_fifo == 0) { |
1477 | dev_err(&udev->dev, |
1478 | "%s: device reported invalid tx-fifo size\n" , |
1479 | UCAN_DRIVER_NAME); |
1480 | goto err_firmware_needs_update; |
1481 | } |
1482 | |
1483 | /* Stage 3 - Driver Initialisation |
1484 | * ------------------------------- |
1485 | * |
1486 | * Register device to Linux, prepare private structures and |
1487 | * reset the device. |
1488 | */ |
1489 | |
1490 | /* allocate driver resources */ |
1491 | netdev = alloc_candev(sizeof(struct ucan_priv), |
1492 | ctl_msg_buffer->cmd_get_device_info.tx_fifo); |
1493 | if (!netdev) { |
1494 | dev_err(&udev->dev, |
1495 | "%s: cannot allocate candev\n" , UCAN_DRIVER_NAME); |
1496 | return -ENOMEM; |
1497 | } |
1498 | |
1499 | up = netdev_priv(dev: netdev); |
1500 | |
1501 | /* initialize data */ |
1502 | up->udev = udev; |
1503 | up->netdev = netdev; |
1504 | up->intf_index = iface_desc->desc.bInterfaceNumber; |
1505 | up->in_ep_addr = in_ep_addr; |
1506 | up->out_ep_addr = out_ep_addr; |
1507 | up->in_ep_size = in_ep_size; |
1508 | up->ctl_msg_buffer = ctl_msg_buffer; |
1509 | up->context_array = NULL; |
1510 | up->available_tx_urbs = 0; |
1511 | |
1512 | up->can.state = CAN_STATE_STOPPED; |
1513 | up->can.bittiming_const = &up->device_info.bittiming_const; |
1514 | up->can.do_set_bittiming = ucan_set_bittiming; |
1515 | up->can.do_set_mode = &ucan_set_mode; |
1516 | spin_lock_init(&up->context_lock); |
1517 | spin_lock_init(&up->echo_skb_lock); |
1518 | netdev->netdev_ops = &ucan_netdev_ops; |
1519 | netdev->ethtool_ops = &ucan_ethtool_ops; |
1520 | |
1521 | usb_set_intfdata(intf, data: up); |
1522 | SET_NETDEV_DEV(netdev, &intf->dev); |
1523 | |
1524 | /* parse device information |
1525 | * the data retrieved in Stage 2 is still available in |
1526 | * up->ctl_msg_buffer |
1527 | */ |
1528 | ucan_parse_device_info(up, device_info: &ctl_msg_buffer->cmd_get_device_info); |
1529 | |
1530 | /* just print some device information - if available */ |
1531 | ret = ucan_device_request_in(up, cmd: UCAN_DEVICE_GET_FW_STRING, subcmd: 0, |
1532 | datalen: sizeof(union ucan_ctl_payload)); |
1533 | if (ret > 0) { |
1534 | /* copy string while ensuring zero termination */ |
1535 | strscpy(firmware_str, up->ctl_msg_buffer->raw, |
1536 | sizeof(union ucan_ctl_payload) + 1); |
1537 | } else { |
1538 | strcpy(p: firmware_str, q: "unknown" ); |
1539 | } |
1540 | |
1541 | /* device is compatible, reset it */ |
1542 | ret = ucan_ctrl_command_out(up, cmd: UCAN_COMMAND_RESET, subcmd: 0, datalen: 0); |
1543 | if (ret < 0) |
1544 | goto err_free_candev; |
1545 | |
1546 | init_usb_anchor(anchor: &up->rx_urbs); |
1547 | init_usb_anchor(anchor: &up->tx_urbs); |
1548 | |
1549 | up->can.state = CAN_STATE_STOPPED; |
1550 | |
1551 | /* register the device */ |
1552 | ret = register_candev(dev: netdev); |
1553 | if (ret) |
1554 | goto err_free_candev; |
1555 | |
1556 | /* initialisation complete, log device info */ |
1557 | netdev_info(dev: up->netdev, format: "registered device\n" ); |
1558 | netdev_info(dev: up->netdev, format: "firmware string: %s\n" , firmware_str); |
1559 | |
1560 | /* success */ |
1561 | return 0; |
1562 | |
1563 | err_free_candev: |
1564 | free_candev(dev: netdev); |
1565 | return ret; |
1566 | |
1567 | err_firmware_needs_update: |
1568 | dev_err(&udev->dev, |
1569 | "%s: probe failed; try to update the device firmware\n" , |
1570 | UCAN_DRIVER_NAME); |
1571 | return -ENODEV; |
1572 | } |
1573 | |
1574 | /* disconnect the device */ |
1575 | static void ucan_disconnect(struct usb_interface *intf) |
1576 | { |
1577 | struct ucan_priv *up = usb_get_intfdata(intf); |
1578 | |
1579 | usb_set_intfdata(intf, NULL); |
1580 | |
1581 | if (up) { |
1582 | unregister_candev(dev: up->netdev); |
1583 | free_candev(dev: up->netdev); |
1584 | } |
1585 | } |
1586 | |
1587 | static struct usb_device_id ucan_table[] = { |
1588 | /* Mule (soldered onto compute modules) */ |
1589 | {USB_DEVICE_INTERFACE_NUMBER(0x2294, 0x425a, 0)}, |
1590 | /* Seal (standalone USB stick) */ |
1591 | {USB_DEVICE_INTERFACE_NUMBER(0x2294, 0x425b, 0)}, |
1592 | {} /* Terminating entry */ |
1593 | }; |
1594 | |
1595 | MODULE_DEVICE_TABLE(usb, ucan_table); |
1596 | /* driver callbacks */ |
1597 | static struct usb_driver ucan_driver = { |
1598 | .name = UCAN_DRIVER_NAME, |
1599 | .probe = ucan_probe, |
1600 | .disconnect = ucan_disconnect, |
1601 | .id_table = ucan_table, |
1602 | }; |
1603 | |
1604 | module_usb_driver(ucan_driver); |
1605 | |
1606 | MODULE_LICENSE("GPL v2" ); |
1607 | MODULE_AUTHOR("Martin Elshuber <martin.elshuber@theobroma-systems.com>" ); |
1608 | MODULE_AUTHOR("Jakob Unterwurzacher <jakob.unterwurzacher@theobroma-systems.com>" ); |
1609 | MODULE_DESCRIPTION("Driver for Theobroma Systems UCAN devices" ); |
1610 | |