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 */
pcan_usb_send_cmd(struct peak_usb_device * dev,u8 f,u8 n,u8 * p)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 */
pcan_usb_wait_rsp(struct peak_usb_device * dev,u8 f,u8 n,u8 * p)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
pcan_usb_set_sja1000(struct peak_usb_device * dev,u8 mode)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
pcan_usb_set_bus(struct peak_usb_device * dev,u8 onoff)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
pcan_usb_set_silent(struct peak_usb_device * dev,u8 onoff)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
pcan_usb_set_ext_vcc(struct peak_usb_device * dev,u8 onoff)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 */
pcan_usb_set_bittiming(struct peak_usb_device * dev,struct can_bittiming * bt)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 */
pcan_usb_write_mode(struct peak_usb_device * dev,u8 onoff)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 */
pcan_usb_restart(unsigned long arg)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 */
pcan_usb_restart_pending(struct urb * urb)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 */
pcan_usb_restart_async(struct peak_usb_device * dev,struct urb * urb,u8 * buf)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 */
pcan_usb_get_serial(struct peak_usb_device * dev,u32 * serial_number)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 u32 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 */
pcan_usb_get_device_id(struct peak_usb_device * dev,u32 * device_id)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 */
pcan_usb_update_ts(struct pcan_usb_msg_context * mc)348 static int pcan_usb_update_ts(struct pcan_usb_msg_context *mc)
349 {
350 u16 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 */
pcan_usb_decode_ts(struct pcan_usb_msg_context * mc,u8 first_packet)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 u16 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
pcan_usb_decode_error(struct pcan_usb_msg_context * mc,u8 n,u8 status_len)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 can_bus_off(mc->netdev);
492 break;
493
494 case CAN_STATE_ERROR_PASSIVE:
495 cf->can_id |= CAN_ERR_CRTL;
496 cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE |
497 CAN_ERR_CRTL_RX_PASSIVE;
498 mc->pdev->dev.can.can_stats.error_passive++;
499 break;
500
501 case CAN_STATE_ERROR_WARNING:
502 cf->can_id |= CAN_ERR_CRTL;
503 cf->data[1] |= CAN_ERR_CRTL_TX_WARNING |
504 CAN_ERR_CRTL_RX_WARNING;
505 mc->pdev->dev.can.can_stats.error_warning++;
506 break;
507
508 default:
509 /* CAN_STATE_MAX (trick to handle other errors) */
510 cf->can_id |= CAN_ERR_CRTL;
511 cf->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
512 mc->netdev->stats.rx_over_errors++;
513 mc->netdev->stats.rx_errors++;
514
515 new_state = mc->pdev->dev.can.state;
516 break;
517 }
518
519 mc->pdev->dev.can.state = new_state;
520
521 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
522 struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb);
523
524 peak_usb_get_ts_tv(&mc->pdev->time_ref, mc->ts16, &tv);
525 hwts->hwtstamp = timeval_to_ktime(tv);
526 }
527
528 netif_rx(skb);
529 mc->netdev->stats.rx_packets++;
530 mc->netdev->stats.rx_bytes += cf->can_dlc;
531
532 return 0;
533 }
534
535 /*
536 * decode non-data usb message
537 */
pcan_usb_decode_status(struct pcan_usb_msg_context * mc,u8 status_len)538 static int pcan_usb_decode_status(struct pcan_usb_msg_context *mc,
539 u8 status_len)
540 {
541 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;
542 u8 f, n;
543 int err;
544
545 /* check whether function and number can be read */
546 if ((mc->ptr + 2) > mc->end)
547 return -EINVAL;
548
549 f = mc->ptr[PCAN_USB_CMD_FUNC];
550 n = mc->ptr[PCAN_USB_CMD_NUM];
551 mc->ptr += PCAN_USB_CMD_ARGS;
552
553 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
554 int err = pcan_usb_decode_ts(mc, !mc->rec_idx);
555
556 if (err)
557 return err;
558 }
559
560 switch (f) {
561 case PCAN_USB_REC_ERROR:
562 err = pcan_usb_decode_error(mc, n, status_len);
563 if (err)
564 return err;
565 break;
566
567 case PCAN_USB_REC_ANALOG:
568 /* analog values (ignored) */
569 rec_len = 2;
570 break;
571
572 case PCAN_USB_REC_BUSLOAD:
573 /* bus load (ignored) */
574 rec_len = 1;
575 break;
576
577 case PCAN_USB_REC_TS:
578 /* only timestamp */
579 if (pcan_usb_update_ts(mc))
580 return -EINVAL;
581 break;
582
583 case PCAN_USB_REC_BUSEVT:
584 /* error frame/bus event */
585 if (n & PCAN_USB_ERROR_TXQFULL)
586 netdev_dbg(mc->netdev, "device Tx queue full)\n");
587 break;
588 default:
589 netdev_err(mc->netdev, "unexpected function %u\n", f);
590 break;
591 }
592
593 if ((mc->ptr + rec_len) > mc->end)
594 return -EINVAL;
595
596 mc->ptr += rec_len;
597
598 return 0;
599 }
600
601 /*
602 * decode data usb message
603 */
pcan_usb_decode_data(struct pcan_usb_msg_context * mc,u8 status_len)604 static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len)
605 {
606 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;
607 struct sk_buff *skb;
608 struct can_frame *cf;
609 struct timeval tv;
610 struct skb_shared_hwtstamps *hwts;
611
612 skb = alloc_can_skb(mc->netdev, &cf);
613 if (!skb)
614 return -ENOMEM;
615
616 if (status_len & PCAN_USB_STATUSLEN_EXT_ID) {
617 u32 tmp32;
618
619 if ((mc->ptr + 4) > mc->end)
620 goto decode_failed;
621
622 memcpy(&tmp32, mc->ptr, 4);
623 mc->ptr += 4;
624
625 cf->can_id = le32_to_cpu(tmp32 >> 3) | CAN_EFF_FLAG;
626 } else {
627 u16 tmp16;
628
629 if ((mc->ptr + 2) > mc->end)
630 goto decode_failed;
631
632 memcpy(&tmp16, mc->ptr, 2);
633 mc->ptr += 2;
634
635 cf->can_id = le16_to_cpu(tmp16 >> 5);
636 }
637
638 cf->can_dlc = get_can_dlc(rec_len);
639
640 /* first data packet timestamp is a word */
641 if (pcan_usb_decode_ts(mc, !mc->rec_data_idx))
642 goto decode_failed;
643
644 /* read data */
645 memset(cf->data, 0x0, sizeof(cf->data));
646 if (status_len & PCAN_USB_STATUSLEN_RTR) {
647 cf->can_id |= CAN_RTR_FLAG;
648 } else {
649 if ((mc->ptr + rec_len) > mc->end)
650 goto decode_failed;
651
652 memcpy(cf->data, mc->ptr, cf->can_dlc);
653 mc->ptr += rec_len;
654 }
655
656 /* convert timestamp into kernel time */
657 peak_usb_get_ts_tv(&mc->pdev->time_ref, mc->ts16, &tv);
658 hwts = skb_hwtstamps(skb);
659 hwts->hwtstamp = timeval_to_ktime(tv);
660
661 /* push the skb */
662 netif_rx(skb);
663
664 /* update statistics */
665 mc->netdev->stats.rx_packets++;
666 mc->netdev->stats.rx_bytes += cf->can_dlc;
667
668 return 0;
669
670 decode_failed:
671 dev_kfree_skb(skb);
672 return -EINVAL;
673 }
674
675 /*
676 * process incoming message
677 */
pcan_usb_decode_msg(struct peak_usb_device * dev,u8 * ibuf,u32 lbuf)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 */
pcan_usb_decode_buf(struct peak_usb_device * dev,struct urb * urb)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 */
pcan_usb_encode_msg(struct peak_usb_device * dev,struct sk_buff * skb,u8 * obuf,size_t * size)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 */
pcan_usb_start(struct peak_usb_device * dev)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
pcan_usb_init(struct peak_usb_device * dev)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 */
pcan_usb_probe(struct usb_interface * intf)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 struct peak_usb_adapter pcan_usb = {
858 .name = "PCAN-USB",
859 .device_id = PCAN_USB_PRODUCT_ID,
860 .ctrl_count = 1,
861 .clock = {
862 .freq = PCAN_USB_CRYSTAL_HZ / 2 ,
863 },
864 .bittiming_const = {
865 .name = "pcan_usb",
866 .tseg1_min = 1,
867 .tseg1_max = 16,
868 .tseg2_min = 1,
869 .tseg2_max = 8,
870 .sjw_max = 4,
871 .brp_min = 1,
872 .brp_max = 64,
873 .brp_inc = 1,
874 },
875
876 /* size of device private data */
877 .sizeof_dev_private = sizeof(struct pcan_usb),
878
879 /* timestamps usage */
880 .ts_used_bits = 16,
881 .ts_period = 24575, /* calibration period in ts. */
882 .us_per_ts_scale = PCAN_USB_TS_US_PER_TICK, /* us=(ts*scale) */
883 .us_per_ts_shift = PCAN_USB_TS_DIV_SHIFTER, /* >> shift */
884
885 /* give here messages in/out endpoints */
886 .ep_msg_in = PCAN_USB_EP_MSGIN,
887 .ep_msg_out = {PCAN_USB_EP_MSGOUT},
888
889 /* size of rx/tx usb buffers */
890 .rx_buffer_size = PCAN_USB_RX_BUFFER_SIZE,
891 .tx_buffer_size = PCAN_USB_TX_BUFFER_SIZE,
892
893 /* device callbacks */
894 .intf_probe = pcan_usb_probe,
895 .dev_init = pcan_usb_init,
896 .dev_set_bus = pcan_usb_write_mode,
897 .dev_set_bittiming = pcan_usb_set_bittiming,
898 .dev_get_device_id = pcan_usb_get_device_id,
899 .dev_decode_buf = pcan_usb_decode_buf,
900 .dev_encode_msg = pcan_usb_encode_msg,
901 .dev_start = pcan_usb_start,
902 .dev_restart_async = pcan_usb_restart_async,
903 };
904