1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * CAN driver for PEAK System PCAN-USB adapter
4  * Derived from the PCAN project file driver/src/pcan_usb.c
5  *
6  * Copyright (C) 2003-2010 PEAK System-Technik GmbH
7  * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>
8  *
9  * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
10  */
11 #include <linux/netdevice.h>
12 #include <linux/usb.h>
13 #include <linux/module.h>
14 #include <linux/ethtool.h>
15 
16 #include <linux/can.h>
17 #include <linux/can/dev.h>
18 #include <linux/can/error.h>
19 
20 #include "pcan_usb_core.h"
21 
22 /* PCAN-USB Endpoints */
23 #define PCAN_USB_EP_CMDOUT		1
24 #define PCAN_USB_EP_CMDIN		(PCAN_USB_EP_CMDOUT | USB_DIR_IN)
25 #define PCAN_USB_EP_MSGOUT		2
26 #define PCAN_USB_EP_MSGIN		(PCAN_USB_EP_MSGOUT | USB_DIR_IN)
27 
28 /* PCAN-USB command struct */
29 #define PCAN_USB_CMD_FUNC		0
30 #define PCAN_USB_CMD_NUM		1
31 #define PCAN_USB_CMD_ARGS		2
32 #define PCAN_USB_CMD_ARGS_LEN		14
33 #define PCAN_USB_CMD_LEN		(PCAN_USB_CMD_ARGS + \
34 					 PCAN_USB_CMD_ARGS_LEN)
35 
36 /* PCAN-USB commands */
37 #define PCAN_USB_CMD_BITRATE	1
38 #define PCAN_USB_CMD_SET_BUS	3
39 #define PCAN_USB_CMD_DEVID	4
40 #define PCAN_USB_CMD_SN		6
41 #define PCAN_USB_CMD_REGISTER	9
42 #define PCAN_USB_CMD_EXT_VCC	10
43 #define PCAN_USB_CMD_ERR_FR	11
44 #define PCAN_USB_CMD_LED	12
45 
46 /* PCAN_USB_CMD_SET_BUS number arg */
47 #define PCAN_USB_BUS_XCVER		2
48 #define PCAN_USB_BUS_SILENT_MODE	3
49 
50 /* PCAN_USB_CMD_xxx functions */
51 #define PCAN_USB_GET		1
52 #define PCAN_USB_SET		2
53 
54 /* PCAN-USB command timeout (ms.) */
55 #define PCAN_USB_COMMAND_TIMEOUT	1000
56 
57 /* PCAN-USB startup timeout (ms.) */
58 #define PCAN_USB_STARTUP_TIMEOUT	10
59 
60 /* PCAN-USB rx/tx buffers size */
61 #define PCAN_USB_RX_BUFFER_SIZE		64
62 #define PCAN_USB_TX_BUFFER_SIZE		64
63 
64 #define PCAN_USB_MSG_HEADER_LEN		2
65 
66 #define PCAN_USB_MSG_TX_CAN		2	/* Tx msg is a CAN frame */
67 
68 /* PCAN-USB adapter internal clock (MHz) */
69 #define PCAN_USB_CRYSTAL_HZ		16000000
70 
71 /* PCAN-USB USB message record status/len field */
72 #define PCAN_USB_STATUSLEN_TIMESTAMP	(1 << 7)
73 #define PCAN_USB_STATUSLEN_INTERNAL	(1 << 6)
74 #define PCAN_USB_STATUSLEN_EXT_ID	(1 << 5)
75 #define PCAN_USB_STATUSLEN_RTR		(1 << 4)
76 #define PCAN_USB_STATUSLEN_DLC		(0xf)
77 
78 /* PCAN-USB 4.1 CAN Id tx extended flags */
79 #define PCAN_USB_TX_SRR			0x01	/* SJA1000 SRR command */
80 #define PCAN_USB_TX_AT			0x02	/* SJA1000 AT command */
81 
82 /* PCAN-USB error flags */
83 #define PCAN_USB_ERROR_TXFULL		0x01
84 #define PCAN_USB_ERROR_RXQOVR		0x02
85 #define PCAN_USB_ERROR_BUS_LIGHT	0x04
86 #define PCAN_USB_ERROR_BUS_HEAVY	0x08
87 #define PCAN_USB_ERROR_BUS_OFF		0x10
88 #define PCAN_USB_ERROR_RXQEMPTY		0x20
89 #define PCAN_USB_ERROR_QOVR		0x40
90 #define PCAN_USB_ERROR_TXQFULL		0x80
91 
92 #define PCAN_USB_ERROR_BUS		(PCAN_USB_ERROR_BUS_LIGHT | \
93 					 PCAN_USB_ERROR_BUS_HEAVY | \
94 					 PCAN_USB_ERROR_BUS_OFF)
95 
96 /* SJA1000 modes */
97 #define SJA1000_MODE_NORMAL		0x00
98 #define SJA1000_MODE_INIT		0x01
99 
100 /*
101  * tick duration = 42.666 us =>
102  * (tick_number * 44739243) >> 20 ~ (tick_number * 42666) / 1000
103  * accuracy = 10^-7
104  */
105 #define PCAN_USB_TS_DIV_SHIFTER		20
106 #define PCAN_USB_TS_US_PER_TICK		44739243
107 
108 /* PCAN-USB messages record types */
109 #define PCAN_USB_REC_ERROR		1
110 #define PCAN_USB_REC_ANALOG		2
111 #define PCAN_USB_REC_BUSLOAD		3
112 #define PCAN_USB_REC_TS			4
113 #define PCAN_USB_REC_BUSEVT		5
114 
115 /* CAN bus events notifications selection mask */
116 #define PCAN_USB_ERR_RXERR		0x02	/* ask for rxerr counter */
117 #define PCAN_USB_ERR_TXERR		0x04	/* ask for txerr counter */
118 
119 /* This mask generates an usb packet each time the state of the bus changes.
120  * In other words, its interest is to know which side among rx and tx is
121  * responsible of the change of the bus state.
122  */
123 #define PCAN_USB_BERR_MASK	(PCAN_USB_ERR_RXERR | PCAN_USB_ERR_TXERR)
124 
125 /* identify bus event packets with rx/tx error counters */
126 #define PCAN_USB_ERR_CNT_DEC		0x00	/* counters are decreasing */
127 #define PCAN_USB_ERR_CNT_INC		0x80	/* counters are increasing */
128 
129 /* private to PCAN-USB adapter */
130 struct pcan_usb {
131 	struct peak_usb_device dev;
132 	struct peak_time_ref time_ref;
133 	struct timer_list restart_timer;
134 	struct can_berr_counter bec;
135 };
136 
137 /* incoming message context for decoding */
138 struct pcan_usb_msg_context {
139 	u16 ts16;
140 	u8 prev_ts8;
141 	u8 *ptr;
142 	u8 *end;
143 	u8 rec_cnt;
144 	u8 rec_idx;
145 	u8 rec_ts_idx;
146 	struct net_device *netdev;
147 	struct pcan_usb *pdev;
148 };
149 
150 /*
151  * send a command
152  */
153 static int pcan_usb_send_cmd(struct peak_usb_device *dev, u8 f, u8 n, u8 *p)
154 {
155 	int err;
156 	int actual_length;
157 
158 	/* usb device unregistered? */
159 	if (!(dev->state & PCAN_USB_STATE_CONNECTED))
160 		return 0;
161 
162 	dev->cmd_buf[PCAN_USB_CMD_FUNC] = f;
163 	dev->cmd_buf[PCAN_USB_CMD_NUM] = n;
164 
165 	if (p)
166 		memcpy(dev->cmd_buf + PCAN_USB_CMD_ARGS,
167 			p, PCAN_USB_CMD_ARGS_LEN);
168 
169 	err = usb_bulk_msg(dev->udev,
170 			usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT),
171 			dev->cmd_buf, PCAN_USB_CMD_LEN, &actual_length,
172 			PCAN_USB_COMMAND_TIMEOUT);
173 	if (err)
174 		netdev_err(dev->netdev,
175 			"sending cmd f=0x%x n=0x%x failure: %d\n",
176 			f, n, err);
177 	return err;
178 }
179 
180 /*
181  * send a command then wait for its response
182  */
183 static int pcan_usb_wait_rsp(struct peak_usb_device *dev, u8 f, u8 n, u8 *p)
184 {
185 	int err;
186 	int actual_length;
187 
188 	/* usb device unregistered? */
189 	if (!(dev->state & PCAN_USB_STATE_CONNECTED))
190 		return 0;
191 
192 	/* first, send command */
193 	err = pcan_usb_send_cmd(dev, f, n, NULL);
194 	if (err)
195 		return err;
196 
197 	err = usb_bulk_msg(dev->udev,
198 		usb_rcvbulkpipe(dev->udev, PCAN_USB_EP_CMDIN),
199 		dev->cmd_buf, PCAN_USB_CMD_LEN, &actual_length,
200 		PCAN_USB_COMMAND_TIMEOUT);
201 	if (err)
202 		netdev_err(dev->netdev,
203 			"waiting rsp f=0x%x n=0x%x failure: %d\n", f, n, err);
204 	else if (p)
205 		memcpy(p, dev->cmd_buf + PCAN_USB_CMD_ARGS,
206 			PCAN_USB_CMD_ARGS_LEN);
207 
208 	return err;
209 }
210 
211 static int pcan_usb_set_sja1000(struct peak_usb_device *dev, u8 mode)
212 {
213 	u8 args[PCAN_USB_CMD_ARGS_LEN] = {
214 		[1] = mode,
215 	};
216 
217 	return pcan_usb_send_cmd(dev, PCAN_USB_CMD_REGISTER, PCAN_USB_SET,
218 				 args);
219 }
220 
221 static int pcan_usb_set_bus(struct peak_usb_device *dev, u8 onoff)
222 {
223 	u8 args[PCAN_USB_CMD_ARGS_LEN] = {
224 		[0] = !!onoff,
225 	};
226 
227 	return pcan_usb_send_cmd(dev, PCAN_USB_CMD_SET_BUS, PCAN_USB_BUS_XCVER,
228 				 args);
229 }
230 
231 static int pcan_usb_set_silent(struct peak_usb_device *dev, u8 onoff)
232 {
233 	u8 args[PCAN_USB_CMD_ARGS_LEN] = {
234 		[0] = !!onoff,
235 	};
236 
237 	return pcan_usb_send_cmd(dev, PCAN_USB_CMD_SET_BUS,
238 				 PCAN_USB_BUS_SILENT_MODE, args);
239 }
240 
241 /* send the cmd to be notified from bus errors */
242 static int pcan_usb_set_err_frame(struct peak_usb_device *dev, u8 err_mask)
243 {
244 	u8 args[PCAN_USB_CMD_ARGS_LEN] = {
245 		[0] = err_mask,
246 	};
247 
248 	return pcan_usb_send_cmd(dev, PCAN_USB_CMD_ERR_FR, PCAN_USB_SET, args);
249 }
250 
251 static int pcan_usb_set_ext_vcc(struct peak_usb_device *dev, u8 onoff)
252 {
253 	u8 args[PCAN_USB_CMD_ARGS_LEN] = {
254 		[0] = !!onoff,
255 	};
256 
257 	return pcan_usb_send_cmd(dev, PCAN_USB_CMD_EXT_VCC, PCAN_USB_SET, args);
258 }
259 
260 static int pcan_usb_set_led(struct peak_usb_device *dev, u8 onoff)
261 {
262 	u8 args[PCAN_USB_CMD_ARGS_LEN] = {
263 		[0] = !!onoff,
264 	};
265 
266 	return pcan_usb_send_cmd(dev, PCAN_USB_CMD_LED, PCAN_USB_SET, args);
267 }
268 
269 /*
270  * set bittiming value to can
271  */
272 static int pcan_usb_set_bittiming(struct peak_usb_device *dev,
273 				  struct can_bittiming *bt)
274 {
275 	u8 args[PCAN_USB_CMD_ARGS_LEN];
276 	u8 btr0, btr1;
277 
278 	btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);
279 	btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |
280 		(((bt->phase_seg2 - 1) & 0x7) << 4);
281 	if (dev->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
282 		btr1 |= 0x80;
283 
284 	netdev_info(dev->netdev, "setting BTR0=0x%02x BTR1=0x%02x\n",
285 		btr0, btr1);
286 
287 	args[0] = btr1;
288 	args[1] = btr0;
289 
290 	return pcan_usb_send_cmd(dev, PCAN_USB_CMD_BITRATE, PCAN_USB_SET, args);
291 }
292 
293 /*
294  * init/reset can
295  */
296 static int pcan_usb_write_mode(struct peak_usb_device *dev, u8 onoff)
297 {
298 	int err;
299 
300 	err = pcan_usb_set_bus(dev, onoff);
301 	if (err)
302 		return err;
303 
304 	if (!onoff) {
305 		err = pcan_usb_set_sja1000(dev, SJA1000_MODE_INIT);
306 	} else {
307 		/* the PCAN-USB needs time to init */
308 		set_current_state(TASK_INTERRUPTIBLE);
309 		schedule_timeout(msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT));
310 	}
311 
312 	return err;
313 }
314 
315 /*
316  * handle end of waiting for the device to reset
317  */
318 static void pcan_usb_restart(struct timer_list *t)
319 {
320 	struct pcan_usb *pdev = from_timer(pdev, t, restart_timer);
321 	struct peak_usb_device *dev = &pdev->dev;
322 
323 	/* notify candev and netdev */
324 	peak_usb_restart_complete(dev);
325 }
326 
327 /*
328  * handle the submission of the restart urb
329  */
330 static void pcan_usb_restart_pending(struct urb *urb)
331 {
332 	struct pcan_usb *pdev = urb->context;
333 
334 	/* the PCAN-USB needs time to restart */
335 	mod_timer(&pdev->restart_timer,
336 			jiffies + msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT));
337 
338 	/* can delete usb resources */
339 	peak_usb_async_complete(urb);
340 }
341 
342 /*
343  * handle asynchronous restart
344  */
345 static int pcan_usb_restart_async(struct peak_usb_device *dev, struct urb *urb,
346 				  u8 *buf)
347 {
348 	struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
349 
350 	if (timer_pending(&pdev->restart_timer))
351 		return -EBUSY;
352 
353 	/* set bus on */
354 	buf[PCAN_USB_CMD_FUNC] = 3;
355 	buf[PCAN_USB_CMD_NUM] = 2;
356 	buf[PCAN_USB_CMD_ARGS] = 1;
357 
358 	usb_fill_bulk_urb(urb, dev->udev,
359 			usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT),
360 			buf, PCAN_USB_CMD_LEN,
361 			pcan_usb_restart_pending, pdev);
362 
363 	return usb_submit_urb(urb, GFP_ATOMIC);
364 }
365 
366 /*
367  * read serial number from device
368  */
369 static int pcan_usb_get_serial(struct peak_usb_device *dev, u32 *serial_number)
370 {
371 	u8 args[PCAN_USB_CMD_ARGS_LEN];
372 	int err;
373 
374 	err = pcan_usb_wait_rsp(dev, PCAN_USB_CMD_SN, PCAN_USB_GET, args);
375 	if (err)
376 		return err;
377 	*serial_number = le32_to_cpup((__le32 *)args);
378 
379 	return 0;
380 }
381 
382 /*
383  * read device id from device
384  */
385 static int pcan_usb_get_device_id(struct peak_usb_device *dev, u32 *device_id)
386 {
387 	u8 args[PCAN_USB_CMD_ARGS_LEN];
388 	int err;
389 
390 	err = pcan_usb_wait_rsp(dev, PCAN_USB_CMD_DEVID, PCAN_USB_GET, args);
391 	if (err)
392 		netdev_err(dev->netdev, "getting device id failure: %d\n", err);
393 
394 	else
395 		*device_id = args[0];
396 
397 	return err;
398 }
399 
400 /*
401  * update current time ref with received timestamp
402  */
403 static int pcan_usb_update_ts(struct pcan_usb_msg_context *mc)
404 {
405 	if ((mc->ptr + 2) > mc->end)
406 		return -EINVAL;
407 
408 	mc->ts16 = get_unaligned_le16(mc->ptr);
409 
410 	if (mc->rec_idx > 0)
411 		peak_usb_update_ts_now(&mc->pdev->time_ref, mc->ts16);
412 	else
413 		peak_usb_set_ts_now(&mc->pdev->time_ref, mc->ts16);
414 
415 	return 0;
416 }
417 
418 /*
419  * decode received timestamp
420  */
421 static int pcan_usb_decode_ts(struct pcan_usb_msg_context *mc, u8 first_packet)
422 {
423 	/* only 1st packet supplies a word timestamp */
424 	if (first_packet) {
425 		if ((mc->ptr + 2) > mc->end)
426 			return -EINVAL;
427 
428 		mc->ts16 = get_unaligned_le16(mc->ptr);
429 		mc->prev_ts8 = mc->ts16 & 0x00ff;
430 
431 		mc->ptr += 2;
432 	} else {
433 		u8 ts8;
434 
435 		if ((mc->ptr + 1) > mc->end)
436 			return -EINVAL;
437 
438 		ts8 = *mc->ptr++;
439 
440 		if (ts8 < mc->prev_ts8)
441 			mc->ts16 += 0x100;
442 
443 		mc->ts16 &= 0xff00;
444 		mc->ts16 |= ts8;
445 		mc->prev_ts8 = ts8;
446 	}
447 
448 	return 0;
449 }
450 
451 static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n,
452 				 u8 status_len)
453 {
454 	struct sk_buff *skb;
455 	struct can_frame *cf;
456 	enum can_state new_state = CAN_STATE_ERROR_ACTIVE;
457 
458 	/* ignore this error until 1st ts received */
459 	if (n == PCAN_USB_ERROR_QOVR)
460 		if (!mc->pdev->time_ref.tick_count)
461 			return 0;
462 
463 	/* allocate an skb to store the error frame */
464 	skb = alloc_can_err_skb(mc->netdev, &cf);
465 
466 	if (n & PCAN_USB_ERROR_RXQOVR) {
467 		/* data overrun interrupt */
468 		netdev_dbg(mc->netdev, "data overrun interrupt\n");
469 		mc->netdev->stats.rx_over_errors++;
470 		mc->netdev->stats.rx_errors++;
471 		if (cf) {
472 			cf->can_id |= CAN_ERR_CRTL;
473 			cf->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
474 		}
475 	}
476 
477 	if (n & PCAN_USB_ERROR_TXQFULL)
478 		netdev_dbg(mc->netdev, "device Tx queue full)\n");
479 
480 	if (n & PCAN_USB_ERROR_BUS_OFF) {
481 		new_state = CAN_STATE_BUS_OFF;
482 	} else if (n & PCAN_USB_ERROR_BUS_HEAVY) {
483 		new_state = ((mc->pdev->bec.txerr >= 128) ||
484 			     (mc->pdev->bec.rxerr >= 128)) ?
485 				CAN_STATE_ERROR_PASSIVE :
486 				CAN_STATE_ERROR_WARNING;
487 	} else {
488 		new_state = CAN_STATE_ERROR_ACTIVE;
489 	}
490 
491 	/* handle change of state */
492 	if (new_state != mc->pdev->dev.can.state) {
493 		enum can_state tx_state =
494 			(mc->pdev->bec.txerr >= mc->pdev->bec.rxerr) ?
495 				new_state : 0;
496 		enum can_state rx_state =
497 			(mc->pdev->bec.txerr <= mc->pdev->bec.rxerr) ?
498 				new_state : 0;
499 
500 		can_change_state(mc->netdev, cf, tx_state, rx_state);
501 
502 		if (new_state == CAN_STATE_BUS_OFF) {
503 			can_bus_off(mc->netdev);
504 		} else if (cf && (cf->can_id & CAN_ERR_CRTL)) {
505 			/* Supply TX/RX error counters in case of
506 			 * controller error.
507 			 */
508 			cf->data[6] = mc->pdev->bec.txerr;
509 			cf->data[7] = mc->pdev->bec.rxerr;
510 		}
511 	}
512 
513 	if (!skb)
514 		return -ENOMEM;
515 
516 	if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
517 		struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb);
518 
519 		peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16,
520 				     &hwts->hwtstamp);
521 	}
522 
523 	mc->netdev->stats.rx_packets++;
524 	mc->netdev->stats.rx_bytes += cf->len;
525 	netif_rx(skb);
526 
527 	return 0;
528 }
529 
530 /* decode bus event usb packet: first byte contains rxerr while 2nd one contains
531  * txerr.
532  */
533 static int pcan_usb_handle_bus_evt(struct pcan_usb_msg_context *mc, u8 ir)
534 {
535 	struct pcan_usb *pdev = mc->pdev;
536 
537 	/* acccording to the content of the packet */
538 	switch (ir) {
539 	case PCAN_USB_ERR_CNT_DEC:
540 	case PCAN_USB_ERR_CNT_INC:
541 
542 		/* save rx/tx error counters from in the device context */
543 		pdev->bec.rxerr = mc->ptr[1];
544 		pdev->bec.txerr = mc->ptr[2];
545 		break;
546 
547 	default:
548 		/* reserved */
549 		break;
550 	}
551 
552 	return 0;
553 }
554 
555 /*
556  * decode non-data usb message
557  */
558 static int pcan_usb_decode_status(struct pcan_usb_msg_context *mc,
559 				  u8 status_len)
560 {
561 	u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;
562 	u8 f, n;
563 	int err;
564 
565 	/* check whether function and number can be read */
566 	if ((mc->ptr + 2) > mc->end)
567 		return -EINVAL;
568 
569 	f = mc->ptr[PCAN_USB_CMD_FUNC];
570 	n = mc->ptr[PCAN_USB_CMD_NUM];
571 	mc->ptr += PCAN_USB_CMD_ARGS;
572 
573 	if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
574 		int err = pcan_usb_decode_ts(mc, !mc->rec_ts_idx);
575 
576 		if (err)
577 			return err;
578 
579 		/* Next packet in the buffer will have a timestamp on a single
580 		 * byte
581 		 */
582 		mc->rec_ts_idx++;
583 	}
584 
585 	switch (f) {
586 	case PCAN_USB_REC_ERROR:
587 		err = pcan_usb_decode_error(mc, n, status_len);
588 		if (err)
589 			return err;
590 		break;
591 
592 	case PCAN_USB_REC_ANALOG:
593 		/* analog values (ignored) */
594 		rec_len = 2;
595 		break;
596 
597 	case PCAN_USB_REC_BUSLOAD:
598 		/* bus load (ignored) */
599 		rec_len = 1;
600 		break;
601 
602 	case PCAN_USB_REC_TS:
603 		/* only timestamp */
604 		if (pcan_usb_update_ts(mc))
605 			return -EINVAL;
606 		break;
607 
608 	case PCAN_USB_REC_BUSEVT:
609 		/* bus event notifications (get rxerr/txerr) */
610 		err = pcan_usb_handle_bus_evt(mc, n);
611 		if (err)
612 			return err;
613 		break;
614 	default:
615 		netdev_err(mc->netdev, "unexpected function %u\n", f);
616 		break;
617 	}
618 
619 	if ((mc->ptr + rec_len) > mc->end)
620 		return -EINVAL;
621 
622 	mc->ptr += rec_len;
623 
624 	return 0;
625 }
626 
627 /*
628  * decode data usb message
629  */
630 static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len)
631 {
632 	u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;
633 	struct sk_buff *skb;
634 	struct can_frame *cf;
635 	struct skb_shared_hwtstamps *hwts;
636 	u32 can_id_flags;
637 
638 	skb = alloc_can_skb(mc->netdev, &cf);
639 	if (!skb)
640 		return -ENOMEM;
641 
642 	if (status_len & PCAN_USB_STATUSLEN_EXT_ID) {
643 		if ((mc->ptr + 4) > mc->end)
644 			goto decode_failed;
645 
646 		can_id_flags = get_unaligned_le32(mc->ptr);
647 		cf->can_id = can_id_flags >> 3 | CAN_EFF_FLAG;
648 		mc->ptr += 4;
649 	} else {
650 		if ((mc->ptr + 2) > mc->end)
651 			goto decode_failed;
652 
653 		can_id_flags = get_unaligned_le16(mc->ptr);
654 		cf->can_id = can_id_flags >> 5;
655 		mc->ptr += 2;
656 	}
657 
658 	can_frame_set_cc_len(cf, rec_len, mc->pdev->dev.can.ctrlmode);
659 
660 	/* Only first packet timestamp is a word */
661 	if (pcan_usb_decode_ts(mc, !mc->rec_ts_idx))
662 		goto decode_failed;
663 
664 	/* Next packet in the buffer will have a timestamp on a single byte */
665 	mc->rec_ts_idx++;
666 
667 	/* read data */
668 	memset(cf->data, 0x0, sizeof(cf->data));
669 	if (status_len & PCAN_USB_STATUSLEN_RTR) {
670 		cf->can_id |= CAN_RTR_FLAG;
671 	} else {
672 		if ((mc->ptr + rec_len) > mc->end)
673 			goto decode_failed;
674 
675 		memcpy(cf->data, mc->ptr, cf->len);
676 		mc->ptr += rec_len;
677 
678 		/* Ignore next byte (client private id) if SRR bit is set */
679 		if (can_id_flags & PCAN_USB_TX_SRR)
680 			mc->ptr++;
681 	}
682 
683 	/* convert timestamp into kernel time */
684 	hwts = skb_hwtstamps(skb);
685 	peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16, &hwts->hwtstamp);
686 
687 	/* update statistics */
688 	mc->netdev->stats.rx_packets++;
689 	mc->netdev->stats.rx_bytes += cf->len;
690 	/* push the skb */
691 	netif_rx(skb);
692 
693 	return 0;
694 
695 decode_failed:
696 	dev_kfree_skb(skb);
697 	return -EINVAL;
698 }
699 
700 /*
701  * process incoming message
702  */
703 static int pcan_usb_decode_msg(struct peak_usb_device *dev, u8 *ibuf, u32 lbuf)
704 {
705 	struct pcan_usb_msg_context mc = {
706 		.rec_cnt = ibuf[1],
707 		.ptr = ibuf + PCAN_USB_MSG_HEADER_LEN,
708 		.end = ibuf + lbuf,
709 		.netdev = dev->netdev,
710 		.pdev = container_of(dev, struct pcan_usb, dev),
711 	};
712 	int err;
713 
714 	for (err = 0; mc.rec_idx < mc.rec_cnt && !err; mc.rec_idx++) {
715 		u8 sl = *mc.ptr++;
716 
717 		/* handle status and error frames here */
718 		if (sl & PCAN_USB_STATUSLEN_INTERNAL) {
719 			err = pcan_usb_decode_status(&mc, sl);
720 		/* handle normal can frames here */
721 		} else {
722 			err = pcan_usb_decode_data(&mc, sl);
723 		}
724 	}
725 
726 	return err;
727 }
728 
729 /*
730  * process any incoming buffer
731  */
732 static int pcan_usb_decode_buf(struct peak_usb_device *dev, struct urb *urb)
733 {
734 	int err = 0;
735 
736 	if (urb->actual_length > PCAN_USB_MSG_HEADER_LEN) {
737 		err = pcan_usb_decode_msg(dev, urb->transfer_buffer,
738 			urb->actual_length);
739 
740 	} else if (urb->actual_length > 0) {
741 		netdev_err(dev->netdev, "usb message length error (%u)\n",
742 			urb->actual_length);
743 		err = -EINVAL;
744 	}
745 
746 	return err;
747 }
748 
749 /*
750  * process outgoing packet
751  */
752 static int pcan_usb_encode_msg(struct peak_usb_device *dev, struct sk_buff *skb,
753 			       u8 *obuf, size_t *size)
754 {
755 	struct net_device *netdev = dev->netdev;
756 	struct net_device_stats *stats = &netdev->stats;
757 	struct can_frame *cf = (struct can_frame *)skb->data;
758 	u32 can_id_flags = cf->can_id & CAN_ERR_MASK;
759 	u8 *pc;
760 
761 	obuf[0] = PCAN_USB_MSG_TX_CAN;
762 	obuf[1] = 1;	/* only one CAN frame is stored in the packet */
763 
764 	pc = obuf + PCAN_USB_MSG_HEADER_LEN;
765 
766 	/* status/len byte */
767 	*pc = can_get_cc_dlc(cf, dev->can.ctrlmode);
768 
769 	if (cf->can_id & CAN_RTR_FLAG)
770 		*pc |= PCAN_USB_STATUSLEN_RTR;
771 
772 	/* can id */
773 	if (cf->can_id & CAN_EFF_FLAG) {
774 		*pc |= PCAN_USB_STATUSLEN_EXT_ID;
775 		pc++;
776 
777 		can_id_flags <<= 3;
778 
779 		if (dev->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
780 			can_id_flags |= PCAN_USB_TX_SRR;
781 
782 		if (dev->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
783 			can_id_flags |= PCAN_USB_TX_AT;
784 
785 		put_unaligned_le32(can_id_flags, pc);
786 		pc += 4;
787 	} else {
788 		pc++;
789 
790 		can_id_flags <<= 5;
791 
792 		if (dev->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
793 			can_id_flags |= PCAN_USB_TX_SRR;
794 
795 		if (dev->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
796 			can_id_flags |= PCAN_USB_TX_AT;
797 
798 		put_unaligned_le16(can_id_flags, pc);
799 		pc += 2;
800 	}
801 
802 	/* can data */
803 	if (!(cf->can_id & CAN_RTR_FLAG)) {
804 		memcpy(pc, cf->data, cf->len);
805 		pc += cf->len;
806 	}
807 
808 	/* SRR bit needs a writer id (useless here) */
809 	if (can_id_flags & PCAN_USB_TX_SRR)
810 		*pc++ = 0x80;
811 
812 	obuf[(*size)-1] = (u8)(stats->tx_packets & 0xff);
813 
814 	return 0;
815 }
816 
817 /* socket callback used to copy berr counters values received through USB */
818 static int pcan_usb_get_berr_counter(const struct net_device *netdev,
819 				     struct can_berr_counter *bec)
820 {
821 	struct peak_usb_device *dev = netdev_priv(netdev);
822 	struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
823 
824 	*bec = pdev->bec;
825 
826 	/* must return 0 */
827 	return 0;
828 }
829 
830 /*
831  * start interface
832  */
833 static int pcan_usb_start(struct peak_usb_device *dev)
834 {
835 	struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
836 	int err;
837 
838 	/* number of bits used in timestamps read from adapter struct */
839 	peak_usb_init_time_ref(&pdev->time_ref, &pcan_usb);
840 
841 	pdev->bec.rxerr = 0;
842 	pdev->bec.txerr = 0;
843 
844 	/* be notified on error counter changes (if requested by user) */
845 	if (dev->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) {
846 		err = pcan_usb_set_err_frame(dev, PCAN_USB_BERR_MASK);
847 		if (err)
848 			netdev_warn(dev->netdev,
849 				    "Asking for BERR reporting error %u\n",
850 				    err);
851 	}
852 
853 	/* if revision greater than 3, can put silent mode on/off */
854 	if (dev->device_rev > 3) {
855 		err = pcan_usb_set_silent(dev,
856 				dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY);
857 		if (err)
858 			return err;
859 	}
860 
861 	return pcan_usb_set_ext_vcc(dev, 0);
862 }
863 
864 static int pcan_usb_init(struct peak_usb_device *dev)
865 {
866 	struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
867 	u32 serial_number;
868 	int err;
869 
870 	/* initialize a timer needed to wait for hardware restart */
871 	timer_setup(&pdev->restart_timer, pcan_usb_restart, 0);
872 
873 	/*
874 	 * explicit use of dev_xxx() instead of netdev_xxx() here:
875 	 * information displayed are related to the device itself, not
876 	 * to the canx netdevice.
877 	 */
878 	err = pcan_usb_get_serial(dev, &serial_number);
879 	if (err) {
880 		dev_err(dev->netdev->dev.parent,
881 			"unable to read %s serial number (err %d)\n",
882 			pcan_usb.name, err);
883 		return err;
884 	}
885 
886 	/* Since rev 4.1, PCAN-USB is able to make single-shot as well as
887 	 * looped back frames.
888 	 */
889 	if (dev->device_rev >= 41) {
890 		struct can_priv *priv = netdev_priv(dev->netdev);
891 
892 		priv->ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT |
893 					    CAN_CTRLMODE_LOOPBACK;
894 	} else {
895 		dev_info(dev->netdev->dev.parent,
896 			 "Firmware update available. Please contact support@peak-system.com\n");
897 	}
898 
899 	dev_info(dev->netdev->dev.parent,
900 		 "PEAK-System %s adapter hwrev %u serial %08X (%u channel)\n",
901 		 pcan_usb.name, dev->device_rev, serial_number,
902 		 pcan_usb.ctrl_count);
903 
904 	return 0;
905 }
906 
907 /*
908  * probe function for new PCAN-USB usb interface
909  */
910 static int pcan_usb_probe(struct usb_interface *intf)
911 {
912 	struct usb_host_interface *if_desc;
913 	int i;
914 
915 	if_desc = intf->altsetting;
916 
917 	/* check interface endpoint addresses */
918 	for (i = 0; i < if_desc->desc.bNumEndpoints; i++) {
919 		struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc;
920 
921 		switch (ep->bEndpointAddress) {
922 		case PCAN_USB_EP_CMDOUT:
923 		case PCAN_USB_EP_CMDIN:
924 		case PCAN_USB_EP_MSGOUT:
925 		case PCAN_USB_EP_MSGIN:
926 			break;
927 		default:
928 			return -ENODEV;
929 		}
930 	}
931 
932 	return 0;
933 }
934 
935 static int pcan_usb_set_phys_id(struct net_device *netdev,
936 				enum ethtool_phys_id_state state)
937 {
938 	struct peak_usb_device *dev = netdev_priv(netdev);
939 	int err = 0;
940 
941 	switch (state) {
942 	case ETHTOOL_ID_ACTIVE:
943 		/* call ON/OFF twice a second */
944 		return 2;
945 
946 	case ETHTOOL_ID_OFF:
947 		err = pcan_usb_set_led(dev, 0);
948 		break;
949 
950 	case ETHTOOL_ID_ON:
951 		fallthrough;
952 
953 	case ETHTOOL_ID_INACTIVE:
954 		/* restore LED default */
955 		err = pcan_usb_set_led(dev, 1);
956 		break;
957 
958 	default:
959 		break;
960 	}
961 
962 	return err;
963 }
964 
965 static const struct ethtool_ops pcan_usb_ethtool_ops = {
966 	.set_phys_id = pcan_usb_set_phys_id,
967 };
968 
969 /*
970  * describe the PCAN-USB adapter
971  */
972 static const struct can_bittiming_const pcan_usb_const = {
973 	.name = "pcan_usb",
974 	.tseg1_min = 1,
975 	.tseg1_max = 16,
976 	.tseg2_min = 1,
977 	.tseg2_max = 8,
978 	.sjw_max = 4,
979 	.brp_min = 1,
980 	.brp_max = 64,
981 	.brp_inc = 1,
982 };
983 
984 const struct peak_usb_adapter pcan_usb = {
985 	.name = "PCAN-USB",
986 	.device_id = PCAN_USB_PRODUCT_ID,
987 	.ctrl_count = 1,
988 	.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_LISTENONLY |
989 			      CAN_CTRLMODE_BERR_REPORTING |
990 			      CAN_CTRLMODE_CC_LEN8_DLC,
991 	.clock = {
992 		.freq = PCAN_USB_CRYSTAL_HZ / 2,
993 	},
994 	.bittiming_const = &pcan_usb_const,
995 
996 	/* size of device private data */
997 	.sizeof_dev_private = sizeof(struct pcan_usb),
998 
999 	.ethtool_ops = &pcan_usb_ethtool_ops,
1000 
1001 	/* timestamps usage */
1002 	.ts_used_bits = 16,
1003 	.us_per_ts_scale = PCAN_USB_TS_US_PER_TICK, /* us=(ts*scale) */
1004 	.us_per_ts_shift = PCAN_USB_TS_DIV_SHIFTER, /*  >> shift     */
1005 
1006 	/* give here messages in/out endpoints */
1007 	.ep_msg_in = PCAN_USB_EP_MSGIN,
1008 	.ep_msg_out = {PCAN_USB_EP_MSGOUT},
1009 
1010 	/* size of rx/tx usb buffers */
1011 	.rx_buffer_size = PCAN_USB_RX_BUFFER_SIZE,
1012 	.tx_buffer_size = PCAN_USB_TX_BUFFER_SIZE,
1013 
1014 	/* device callbacks */
1015 	.intf_probe = pcan_usb_probe,
1016 	.dev_init = pcan_usb_init,
1017 	.dev_set_bus = pcan_usb_write_mode,
1018 	.dev_set_bittiming = pcan_usb_set_bittiming,
1019 	.dev_get_device_id = pcan_usb_get_device_id,
1020 	.dev_decode_buf = pcan_usb_decode_buf,
1021 	.dev_encode_msg = pcan_usb_encode_msg,
1022 	.dev_start = pcan_usb_start,
1023 	.dev_restart_async = pcan_usb_restart_async,
1024 	.do_get_berr_counter = pcan_usb_get_berr_counter,
1025 };
1026