Loading...
Note: File does not exist in v4.6.
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 */
73enum {
74 UCAN_DEVICE_GET_FW_STRING = 0,
75};
76
77/* UCAN Commands */
78enum {
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 */
104enum {
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 */
113enum {
114 UCAN_COMMAND_GET_INFO = 0,
115 UCAN_COMMAND_GET_PROTOCOL_VERSION = 1,
116};
117
118/* UCAN_COMMAND_FILTER subcommands */
119enum {
120 UCAN_FILTER_CLEAR = 0,
121 UCAN_FILTER_DISABLE = 1,
122 UCAN_FILTER_ENABLE = 2,
123};
124
125/* OUT endpoint message types */
126enum {
127 UCAN_OUT_TX = 2, /* transmit a CAN frame */
128};
129
130/* IN endpoint message types */
131enum {
132 UCAN_IN_TX_COMPLETE = 1, /* CAN frame transmission completed */
133 UCAN_IN_RX = 2, /* CAN frame received */
134};
135
136struct ucan_ctl_cmd_start {
137 __le16 mode; /* OR-ing any of UCAN_MODE_* */
138} __packed;
139
140struct 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
150struct 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
166struct ucan_ctl_cmd_get_protocol_version {
167 __le32 version;
168} __packed;
169
170union 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
192enum {
193 UCAN_TX_COMPLETE_SUCCESS = BIT(0),
194};
195
196/* Transmission Complete within ucan_message_in */
197struct 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 */
203struct 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 */
218struct 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 */
233struct 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
259struct ucan_priv;
260
261/* Context Information for transmission URBs */
262struct ucan_urb_context {
263 struct ucan_priv *up;
264 bool allocated;
265};
266
267/* Information reported by the USB device */
268struct ucan_device_info {
269 struct can_bittiming_const bittiming_const;
270 u8 tx_fifo;
271};
272
273/* Driver private data */
274struct 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
306static 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
314static 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(up->context_array);
323 up->context_array = NULL;
324}
325
326static 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(up->device_info.tx_fifo,
334 sizeof(*up->context_array),
335 GFP_KERNEL);
336 if (!up->context_array) {
337 netdev_err(up->netdev,
338 "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
353static 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(up->netdev);
375
376 break;
377 }
378 }
379
380 spin_unlock_irqrestore(&up->context_lock, flags);
381 return ret;
382}
383
384static 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(up->netdev);
403 up->available_tx_urbs++;
404
405 ret = true;
406 }
407
408 spin_unlock_irqrestore(&up->context_lock, flags);
409 return ret;
410}
411
412static int ucan_ctrl_command_out(struct ucan_priv *up,
413 u8 cmd, u16 subcmd, u16 datalen)
414{
415 return usb_control_msg(up->udev,
416 usb_sndctrlpipe(up->udev, 0),
417 cmd,
418 USB_DIR_OUT | USB_TYPE_VENDOR |
419 USB_RECIP_INTERFACE,
420 subcmd,
421 up->intf_index,
422 up->ctl_msg_buffer,
423 datalen,
424 UCAN_USB_CTL_PIPE_TIMEOUT);
425}
426
427static int ucan_device_request_in(struct ucan_priv *up,
428 u8 cmd, u16 subcmd, u16 datalen)
429{
430 return usb_control_msg(up->udev,
431 usb_rcvctrlpipe(up->udev, 0),
432 cmd,
433 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
434 subcmd,
435 0,
436 up->ctl_msg_buffer,
437 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 */
444static 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(bittiming->name, "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 */
483static 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(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 */
565static 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(up->netdev, "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(up->netdev,
602 "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(up->netdev, &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(&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 */
635static 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(up->netdev, "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(up->netdev,
657 "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, 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(up->netdev, echo_index, NULL);
678 } else {
679 up->netdev->stats.tx_dropped++;
680 can_free_echo_skb(up->netdev, echo_index, NULL);
681 }
682 spin_unlock_irqrestore(&up->echo_skb_lock, flags);
683 }
684}
685
686/* callback on reception of a USB message */
687static 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(up->udev,
700 up->in_ep_size,
701 urb->transfer_buffer,
702 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(up->udev,
717 up->in_ep_size,
718 urb->transfer_buffer,
719 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(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(up->netdev,
739 "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(up->netdev,
752 "invalid message (short; no data; l:%d)\n",
753 urb->actual_length);
754 print_hex_dump(KERN_WARNING,
755 "raw data: ",
756 DUMP_PREFIX_ADDRESS,
757 16,
758 1,
759 urb->transfer_buffer,
760 urb->actual_length,
761 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(up->netdev,
775 "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
786resubmit:
787 /* resubmit urb when done */
788 usb_fill_bulk_urb(urb, up->udev,
789 usb_rcvbulkpipe(up->udev,
790 up->in_ep_addr),
791 urb->transfer_buffer,
792 up->in_ep_size,
793 ucan_read_bulk_callback,
794 up);
795
796 usb_anchor_urb(urb, &up->rx_urbs);
797 ret = usb_submit_urb(urb, GFP_ATOMIC);
798
799 if (ret < 0) {
800 netdev_err(up->netdev,
801 "failed resubmitting read bulk urb: %d\n",
802 ret);
803
804 usb_unanchor_urb(urb);
805 usb_free_coherent(up->udev,
806 up->in_ep_size,
807 urb->transfer_buffer,
808 urb->transfer_dma);
809
810 if (ret == -ENODEV)
811 netif_device_detach(netdev);
812 }
813}
814
815/* callback after transmission of a USB message */
816static 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(urb->dev,
828 sizeof(struct ucan_message_out),
829 urb->transfer_buffer,
830 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(up->netdev))
838 return;
839
840 /* transmission failed (USB - the device will not send a TX complete) */
841 if (urb->status) {
842 netdev_warn(up->netdev,
843 "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(up->netdev, context - up->context_array, NULL);
849 spin_unlock_irqrestore(&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, context))
855 netdev_err(up->netdev,
856 "urb failed, failed to release context\n");
857 }
858}
859
860static 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(urbs[i]);
867 usb_free_coherent(up->udev,
868 up->in_ep_size,
869 urbs[i]->transfer_buffer,
870 urbs[i]->transfer_dma);
871 usb_free_urb(urbs[i]);
872 }
873 }
874
875 memset(urbs, 0, sizeof(*urbs) * UCAN_MAX_RX_URBS);
876}
877
878static 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(0, GFP_KERNEL);
889 if (!urbs[i])
890 goto err;
891
892 buf = usb_alloc_coherent(up->udev,
893 up->in_ep_size,
894 GFP_KERNEL, &urbs[i]->transfer_dma);
895 if (!buf) {
896 /* cleanup this urb */
897 usb_free_urb(urbs[i]);
898 urbs[i] = NULL;
899 goto err;
900 }
901
902 usb_fill_bulk_urb(urbs[i], up->udev,
903 usb_rcvbulkpipe(up->udev,
904 up->in_ep_addr),
905 buf,
906 up->in_ep_size,
907 ucan_read_bulk_callback,
908 up);
909
910 urbs[i]->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
911
912 usb_anchor_urb(urbs[i], &up->rx_urbs);
913 }
914 return 0;
915
916err:
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 */
927static 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(urbs[i], GFP_KERNEL);
936 if (ret) {
937 netdev_err(up->netdev,
938 "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(urbs[i]);
947 urbs[i] = NULL;
948 }
949 return 0;
950
951err:
952 /* Cleanup unsubmitted urbs */
953 ucan_cleanup_rx_urbs(up, urbs);
954
955 /* Kill urbs that are already submitted */
956 usb_kill_anchored_urbs(&up->rx_urbs);
957
958 return ret;
959}
960
961/* Open the network device */
962static 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(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, UCAN_COMMAND_START, 0, 2);
999 if (ret < 0) {
1000 netdev_err(up->netdev,
1001 "could not start device, code: %d\n",
1002 ret);
1003 goto err_reset;
1004 }
1005
1006 /* Call CAN layer open */
1007 ret = open_candev(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(netdev);
1020
1021 return 0;
1022
1023err_stop:
1024 /* The device have started already stop it */
1025 ret_cleanup = ucan_ctrl_command_out(up, UCAN_COMMAND_STOP, 0, 0);
1026 if (ret_cleanup < 0)
1027 netdev_err(up->netdev,
1028 "could not stop device, code: %d\n",
1029 ret_cleanup);
1030
1031err_reset:
1032 /* The device might have received data, reset it for
1033 * consistent state
1034 */
1035 ret_cleanup = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0);
1036 if (ret_cleanup < 0)
1037 netdev_err(up->netdev,
1038 "could not reset device, code: %d\n",
1039 ret_cleanup);
1040
1041 /* clean up unsubmitted urbs */
1042 ucan_cleanup_rx_urbs(up, urbs);
1043
1044err_contexts:
1045 ucan_release_context_array(up);
1046 return ret;
1047}
1048
1049static 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(0, GFP_ATOMIC);
1060 if (!urb) {
1061 netdev_err(up->netdev, "no memory left for URBs\n");
1062 return NULL;
1063 }
1064
1065 m = usb_alloc_coherent(up->udev,
1066 sizeof(struct ucan_message_out),
1067 GFP_ATOMIC,
1068 &urb->transfer_dma);
1069 if (!m) {
1070 netdev_err(up->netdev, "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, up->udev,
1095 usb_sndbulkpipe(up->udev,
1096 up->out_ep_addr),
1097 m, mlen, ucan_write_bulk_callback, context);
1098 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1099
1100 return urb;
1101}
1102
1103static void ucan_clean_up_tx_urb(struct ucan_priv *up, struct urb *urb)
1104{
1105 usb_free_coherent(up->udev, sizeof(struct ucan_message_out),
1106 urb->transfer_buffer, urb->transfer_dma);
1107 usb_free_urb(urb);
1108}
1109
1110/* callback when Linux needs to send a can frame */
1111static 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(netdev);
1120 struct can_frame *cf = (struct can_frame *)skb->data;
1121
1122 /* check skb */
1123 if (can_dev_dropped_skb(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, up->netdev, echo_index, 0);
1141 spin_unlock_irqrestore(&up->echo_skb_lock, flags);
1142
1143 /* transmit it */
1144 usb_anchor_urb(urb, &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, context))
1153 netdev_err(up->netdev,
1154 "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(up->netdev, echo_index, NULL);
1161 spin_unlock_irqrestore(&up->echo_skb_lock, flags);
1162
1163 if (ret == -ENODEV) {
1164 netif_device_detach(up->netdev);
1165 } else {
1166 netdev_warn(up->netdev,
1167 "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(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
1181drop:
1182 if (!ucan_release_context(up, context))
1183 netdev_err(up->netdev,
1184 "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 */
1195static int ucan_close(struct net_device *netdev)
1196{
1197 int ret;
1198 struct ucan_priv *up = netdev_priv(netdev);
1199
1200 up->can.state = CAN_STATE_STOPPED;
1201
1202 /* stop sending data */
1203 usb_kill_anchored_urbs(&up->tx_urbs);
1204
1205 /* stop receiving data */
1206 usb_kill_anchored_urbs(&up->rx_urbs);
1207
1208 /* stop and reset can device */
1209 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_STOP, 0, 0);
1210 if (ret < 0)
1211 netdev_err(up->netdev,
1212 "could not stop device, code: %d\n",
1213 ret);
1214
1215 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0);
1216 if (ret < 0)
1217 netdev_err(up->netdev,
1218 "could not reset device, code: %d\n",
1219 ret);
1220
1221 netif_stop_queue(netdev);
1222
1223 ucan_release_context_array(up);
1224
1225 close_candev(up->netdev);
1226 return 0;
1227}
1228
1229/* CAN driver callbacks */
1230static 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
1237static 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 */
1246static int ucan_set_bittiming(struct net_device *netdev)
1247{
1248 int ret;
1249 struct ucan_priv *up = netdev_priv(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, UCAN_COMMAND_SET_BITTIMING, 0,
1263 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 */
1270static 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(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, UCAN_COMMAND_RESTART, 0, 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(up->netdev);
1291
1292 spin_unlock_irqrestore(&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 */
1301static 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(&udev->dev,
1402 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(udev,
1417 usb_rcvctrlpipe(udev, 0),
1418 UCAN_COMMAND_GET,
1419 USB_DIR_IN | USB_TYPE_VENDOR |
1420 USB_RECIP_INTERFACE,
1421 UCAN_COMMAND_GET_PROTOCOL_VERSION,
1422 iface_desc->desc.bInterfaceNumber,
1423 ctl_msg_buffer,
1424 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(udev,
1456 usb_rcvctrlpipe(udev, 0),
1457 UCAN_COMMAND_GET,
1458 USB_DIR_IN | USB_TYPE_VENDOR |
1459 USB_RECIP_INTERFACE,
1460 UCAN_COMMAND_GET_INFO,
1461 iface_desc->desc.bInterfaceNumber,
1462 ctl_msg_buffer,
1463 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(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, 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, &ctl_msg_buffer->cmd_get_device_info);
1529
1530 /* just print some device information - if available */
1531 ret = ucan_device_request_in(up, UCAN_DEVICE_GET_FW_STRING, 0,
1532 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(firmware_str, "unknown");
1539 }
1540
1541 /* device is compatible, reset it */
1542 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0);
1543 if (ret < 0)
1544 goto err_free_candev;
1545
1546 init_usb_anchor(&up->rx_urbs);
1547 init_usb_anchor(&up->tx_urbs);
1548
1549 up->can.state = CAN_STATE_STOPPED;
1550
1551 /* register the device */
1552 ret = register_candev(netdev);
1553 if (ret)
1554 goto err_free_candev;
1555
1556 /* initialisation complete, log device info */
1557 netdev_info(up->netdev, "registered device\n");
1558 netdev_info(up->netdev, "firmware string: %s\n", firmware_str);
1559
1560 /* success */
1561 return 0;
1562
1563err_free_candev:
1564 free_candev(netdev);
1565 return ret;
1566
1567err_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 */
1575static 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(up->netdev);
1583 free_candev(up->netdev);
1584 }
1585}
1586
1587static 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
1595MODULE_DEVICE_TABLE(usb, ucan_table);
1596/* driver callbacks */
1597static 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
1604module_usb_driver(ucan_driver);
1605
1606MODULE_LICENSE("GPL v2");
1607MODULE_AUTHOR("Martin Elshuber <martin.elshuber@theobroma-systems.com>");
1608MODULE_AUTHOR("Jakob Unterwurzacher <jakob.unterwurzacher@theobroma-systems.com>");
1609MODULE_DESCRIPTION("Driver for Theobroma Systems UCAN devices");