xref: /linux/drivers/net/can/usb/ucan.c (revision a1c613ae4c322ddd58d5a8539dbfba2a0380a8c0)
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 
ucan_can_cc_dlc2len(struct ucan_can_msg * msg,u16 len)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 
ucan_release_context_array(struct ucan_priv * up)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(up->context_array);
323 	up->context_array = NULL;
324 }
325 
ucan_alloc_context_array(struct ucan_priv * up)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(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 
ucan_alloc_context(struct ucan_priv * up)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(up->netdev);
375 
376 			break;
377 		}
378 	}
379 
380 	spin_unlock_irqrestore(&up->context_lock, flags);
381 	return ret;
382 }
383 
ucan_release_context(struct ucan_priv * up,struct ucan_urb_context * ctx)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(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 
ucan_ctrl_command_out(struct ucan_priv * up,u8 cmd,u16 subcmd,u16 datalen)412 static 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 
ucan_device_request_in(struct ucan_priv * up,u8 cmd,u16 subcmd,u16 datalen)427 static 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  */
ucan_parse_device_info(struct ucan_priv * up,struct ucan_ctl_cmd_device_info * device_info)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(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  */
ucan_handle_error_frame(struct ucan_priv * up,struct ucan_message_in * m,canid_t canid)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(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  */
ucan_rx_can_msg(struct ucan_priv * up,struct ucan_message_in * m)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(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 */
ucan_tx_complete_msg(struct ucan_priv * up,struct ucan_message_in * m)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(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 */
ucan_read_bulk_callback(struct urb * urb)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(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 
786 resubmit:
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 */
ucan_write_bulk_callback(struct urb * urb)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(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 
ucan_cleanup_rx_urbs(struct ucan_priv * up,struct urb ** urbs)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(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 
ucan_prepare_and_anchor_rx_urbs(struct ucan_priv * up,struct urb ** urbs)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(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 
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  */
ucan_submit_rx_urbs(struct ucan_priv * up,struct urb ** urbs)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(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 
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(&up->rx_urbs);
957 
958 	return ret;
959 }
960 
961 /* Open the network device */
ucan_open(struct net_device * netdev)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(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 
1023 err_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 
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, 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 
1044 err_contexts:
1045 	ucan_release_context_array(up);
1046 	return ret;
1047 }
1048 
ucan_prepare_tx_urb(struct ucan_priv * up,struct ucan_urb_context * context,struct can_frame * cf,u8 echo_index)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(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 
ucan_clean_up_tx_urb(struct ucan_priv * up,struct urb * urb)1103 static 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 */
ucan_start_xmit(struct sk_buff * skb,struct net_device * netdev)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(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 
1181 drop:
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  */
ucan_close(struct net_device * netdev)1195 static 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 */
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  */
ucan_set_bittiming(struct net_device * netdev)1246 static 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  */
ucan_set_mode(struct net_device * netdev,enum can_mode mode)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(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 */
ucan_probe(struct usb_interface * intf,const struct usb_device_id * id)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(&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 
1563 err_free_candev:
1564 	free_candev(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 */
ucan_disconnect(struct usb_interface * intf)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(up->netdev);
1583 		free_candev(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