Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
pcan_usb.c
Go to the documentation of this file.
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 <[email protected]>
7  *
8  * Many thanks to Klaus Hitschler <[email protected]>
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 {
101 };
102 
103 /* incoming message context for decoding */
107  u8 *ptr;
108  u8 *end;
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)
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,
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,
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,
173 
174  return err;
175 }
176 
177 static int pcan_usb_set_sja1000(struct peak_usb_device *dev, u8 mode)
178 {
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 {
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 {
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 {
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 {
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 */
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 */
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,
278 
279  /* can delete usb resources */
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 {
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  */
331 static int pcan_usb_get_device_id(struct peak_usb_device *dev, u32 *device_id)
332 {
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  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  */
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 
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) {
420  if (n & PCAN_USB_ERROR_BUS_LIGHT) {
421  new_state = CAN_STATE_ERROR_WARNING;
422  break;
423  }
424 
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  }
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 
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  }
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 
495  cf->can_id |= CAN_ERR_CRTL;
496  cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE |
498  mc->pdev->dev.can.can_stats.error_passive++;
499  break;
500 
502  cf->can_id |= CAN_ERR_CRTL;
503  cf->data[1] |= CAN_ERR_CRTL_TX_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  */
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 
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  */
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, rec_len);
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  */
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)
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 
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 */
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);
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  */
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 };