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