2 * CAN driver for PEAK System PCAN-USB adapter
3 * Derived from the PCAN project file driver/src/pcan_usb.c
5 * Copyright (C) 2003-2010 PEAK System-Technik GmbH
6 * Copyright (C) 2011-2012 Stephane Grosjean <s.grosjean@peak-system.com>
8 * Many thanks to Klaus Hitschler <klaus.hitschler@gmx.de>
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.
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.
19 #include <linux/netdevice.h>
20 #include <linux/usb.h>
21 #include <linux/module.h>
23 #include <linux/can.h>
24 #include <linux/can/dev.h>
25 #include <linux/can/error.h>
27 #include "pcan_usb_core.h"
29 MODULE_SUPPORTED_DEVICE("PEAK-System PCAN-USB adapter");
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)
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)
45 /* PCAN-USB command timeout (ms.) */
46 #define PCAN_USB_COMMAND_TIMEOUT 1000
48 /* PCAN-USB startup timeout (ms.) */
49 #define PCAN_USB_STARTUP_TIMEOUT 10
51 /* PCAN-USB rx/tx buffers size */
52 #define PCAN_USB_RX_BUFFER_SIZE 64
53 #define PCAN_USB_TX_BUFFER_SIZE 64
55 #define PCAN_USB_MSG_HEADER_LEN 2
57 /* PCAN-USB adapter internal clock (MHz) */
58 #define PCAN_USB_CRYSTAL_HZ 16000000
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)
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
78 #define SJA1000_MODE_NORMAL 0x00
79 #define SJA1000_MODE_INIT 0x01
82 * tick duration = 42.666 us =>
83 * (tick_number * 44739243) >> 20 ~ (tick_number * 42666) / 1000
86 #define PCAN_USB_TS_DIV_SHIFTER 20
87 #define PCAN_USB_TS_US_PER_TICK 44739243
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
96 /* private to PCAN-USB adapter */
98 struct peak_usb_device dev;
99 struct peak_time_ref time_ref;
100 struct timer_list restart_timer;
103 /* incoming message context for decoding */
104 struct pcan_usb_msg_context {
112 struct net_device *netdev;
113 struct pcan_usb *pdev;
119 static int pcan_usb_send_cmd(struct peak_usb_device *dev, u8 f, u8 n, u8 *p)
124 /* usb device unregistered? */
125 if (!(dev->state & PCAN_USB_STATE_CONNECTED))
128 dev->cmd_buf[PCAN_USB_CMD_FUNC] = f;
129 dev->cmd_buf[PCAN_USB_CMD_NUM] = n;
132 memcpy(dev->cmd_buf + PCAN_USB_CMD_ARGS,
133 p, PCAN_USB_CMD_ARGS_LEN);
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);
140 netdev_err(dev->netdev,
141 "sending cmd f=0x%x n=0x%x failure: %d\n",
147 * send a command then wait for its response
149 static int pcan_usb_wait_rsp(struct peak_usb_device *dev, u8 f, u8 n, u8 *p)
154 /* usb device unregistered? */
155 if (!(dev->state & PCAN_USB_STATE_CONNECTED))
158 /* first, send command */
159 err = pcan_usb_send_cmd(dev, f, n, NULL);
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);
168 netdev_err(dev->netdev,
169 "waiting rsp f=0x%x n=0x%x failure: %d\n", f, n, err);
171 memcpy(p, dev->cmd_buf + PCAN_USB_CMD_ARGS,
172 PCAN_USB_CMD_ARGS_LEN);
177 static int pcan_usb_set_sja1000(struct peak_usb_device *dev, u8 mode)
179 u8 args[PCAN_USB_CMD_ARGS_LEN] = {
183 return pcan_usb_send_cmd(dev, 9, 2, args);
186 static int pcan_usb_set_bus(struct peak_usb_device *dev, u8 onoff)
188 u8 args[PCAN_USB_CMD_ARGS_LEN] = {
192 return pcan_usb_send_cmd(dev, 3, 2, args);
195 static int pcan_usb_set_silent(struct peak_usb_device *dev, u8 onoff)
197 u8 args[PCAN_USB_CMD_ARGS_LEN] = {
201 return pcan_usb_send_cmd(dev, 3, 3, args);
204 static int pcan_usb_set_ext_vcc(struct peak_usb_device *dev, u8 onoff)
206 u8 args[PCAN_USB_CMD_ARGS_LEN] = {
210 return pcan_usb_send_cmd(dev, 10, 2, args);
214 * set bittiming value to can
216 static int pcan_usb_set_bittiming(struct peak_usb_device *dev,
217 struct can_bittiming *bt)
219 u8 args[PCAN_USB_CMD_ARGS_LEN];
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)
228 netdev_info(dev->netdev, "setting BTR0=0x%02x BTR1=0x%02x\n",
234 return pcan_usb_send_cmd(dev, 1, 2, args);
240 static int pcan_usb_write_mode(struct peak_usb_device *dev, u8 onoff)
244 err = pcan_usb_set_bus(dev, onoff);
249 err = pcan_usb_set_sja1000(dev, SJA1000_MODE_INIT);
251 /* the PCAN-USB needs time to init */
252 set_current_state(TASK_INTERRUPTIBLE);
253 schedule_timeout(msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT));
260 * handle end of waiting for the device to reset
262 static void pcan_usb_restart(struct timer_list *t)
264 struct pcan_usb *pdev = from_timer(pdev, t, restart_timer);
265 struct peak_usb_device *dev = &pdev->dev;
267 /* notify candev and netdev */
268 peak_usb_restart_complete(dev);
272 * handle the submission of the restart urb
274 static void pcan_usb_restart_pending(struct urb *urb)
276 struct pcan_usb *pdev = urb->context;
278 /* the PCAN-USB needs time to restart */
279 mod_timer(&pdev->restart_timer,
280 jiffies + msecs_to_jiffies(PCAN_USB_STARTUP_TIMEOUT));
282 /* can delete usb resources */
283 peak_usb_async_complete(urb);
287 * handle asynchronous restart
289 static int pcan_usb_restart_async(struct peak_usb_device *dev, struct urb *urb,
292 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
294 if (timer_pending(&pdev->restart_timer))
298 buf[PCAN_USB_CMD_FUNC] = 3;
299 buf[PCAN_USB_CMD_NUM] = 2;
300 buf[PCAN_USB_CMD_ARGS] = 1;
302 usb_fill_bulk_urb(urb, dev->udev,
303 usb_sndbulkpipe(dev->udev, PCAN_USB_EP_CMDOUT),
304 buf, PCAN_USB_CMD_LEN,
305 pcan_usb_restart_pending, pdev);
307 return usb_submit_urb(urb, GFP_ATOMIC);
311 * read serial number from device
313 static int pcan_usb_get_serial(struct peak_usb_device *dev, u32 *serial_number)
315 u8 args[PCAN_USB_CMD_ARGS_LEN];
318 err = pcan_usb_wait_rsp(dev, 6, 1, args);
320 netdev_err(dev->netdev, "getting serial failure: %d\n", err);
321 } else if (serial_number) {
324 memcpy(&tmp32, args, 4);
325 *serial_number = le32_to_cpu(tmp32);
332 * read device id from device
334 static int pcan_usb_get_device_id(struct peak_usb_device *dev, u32 *device_id)
336 u8 args[PCAN_USB_CMD_ARGS_LEN];
339 err = pcan_usb_wait_rsp(dev, 4, 1, args);
341 netdev_err(dev->netdev, "getting device id failure: %d\n", err);
343 *device_id = args[0];
349 * update current time ref with received timestamp
351 static int pcan_usb_update_ts(struct pcan_usb_msg_context *mc)
355 if ((mc->ptr+2) > mc->end)
358 memcpy(&tmp16, mc->ptr, 2);
360 mc->ts16 = le16_to_cpu(tmp16);
363 peak_usb_update_ts_now(&mc->pdev->time_ref, mc->ts16);
365 peak_usb_set_ts_now(&mc->pdev->time_ref, mc->ts16);
371 * decode received timestamp
373 static int pcan_usb_decode_ts(struct pcan_usb_msg_context *mc, u8 first_packet)
375 /* only 1st packet supplies a word timestamp */
379 if ((mc->ptr + 2) > mc->end)
382 memcpy(&tmp16, mc->ptr, 2);
385 mc->ts16 = le16_to_cpu(tmp16);
386 mc->prev_ts8 = mc->ts16 & 0x00ff;
390 if ((mc->ptr + 1) > mc->end)
395 if (ts8 < mc->prev_ts8)
406 static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n,
410 struct can_frame *cf;
411 enum can_state new_state;
413 /* ignore this error until 1st ts received */
414 if (n == PCAN_USB_ERROR_QOVR)
415 if (!mc->pdev->time_ref.tick_count)
418 new_state = mc->pdev->dev.can.state;
420 switch (mc->pdev->dev.can.state) {
421 case CAN_STATE_ERROR_ACTIVE:
422 if (n & PCAN_USB_ERROR_BUS_LIGHT) {
423 new_state = CAN_STATE_ERROR_WARNING;
426 /* else: fall through */
428 case CAN_STATE_ERROR_WARNING:
429 if (n & PCAN_USB_ERROR_BUS_HEAVY) {
430 new_state = CAN_STATE_ERROR_PASSIVE;
433 if (n & PCAN_USB_ERROR_BUS_OFF) {
434 new_state = CAN_STATE_BUS_OFF;
437 if (n & (PCAN_USB_ERROR_RXQOVR | PCAN_USB_ERROR_QOVR)) {
439 * trick to bypass next comparison and process other
442 new_state = CAN_STATE_MAX;
445 if ((n & PCAN_USB_ERROR_BUS_LIGHT) == 0) {
446 /* no error (back to active state) */
447 mc->pdev->dev.can.state = CAN_STATE_ERROR_ACTIVE;
452 case CAN_STATE_ERROR_PASSIVE:
453 if (n & PCAN_USB_ERROR_BUS_OFF) {
454 new_state = CAN_STATE_BUS_OFF;
457 if (n & PCAN_USB_ERROR_BUS_LIGHT) {
458 new_state = CAN_STATE_ERROR_WARNING;
461 if (n & (PCAN_USB_ERROR_RXQOVR | PCAN_USB_ERROR_QOVR)) {
463 * trick to bypass next comparison and process other
466 new_state = CAN_STATE_MAX;
470 if ((n & PCAN_USB_ERROR_BUS_HEAVY) == 0) {
471 /* no error (back to active state) */
472 mc->pdev->dev.can.state = CAN_STATE_ERROR_ACTIVE;
478 /* do nothing waiting for restart */
482 /* donot post any error if current state didn't change */
483 if (mc->pdev->dev.can.state == new_state)
486 /* allocate an skb to store the error frame */
487 skb = alloc_can_err_skb(mc->netdev, &cf);
492 case CAN_STATE_BUS_OFF:
493 cf->can_id |= CAN_ERR_BUSOFF;
494 mc->pdev->dev.can.can_stats.bus_off++;
495 can_bus_off(mc->netdev);
498 case CAN_STATE_ERROR_PASSIVE:
499 cf->can_id |= CAN_ERR_CRTL;
500 cf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE |
501 CAN_ERR_CRTL_RX_PASSIVE;
502 mc->pdev->dev.can.can_stats.error_passive++;
505 case CAN_STATE_ERROR_WARNING:
506 cf->can_id |= CAN_ERR_CRTL;
507 cf->data[1] |= CAN_ERR_CRTL_TX_WARNING |
508 CAN_ERR_CRTL_RX_WARNING;
509 mc->pdev->dev.can.can_stats.error_warning++;
513 /* CAN_STATE_MAX (trick to handle other errors) */
514 cf->can_id |= CAN_ERR_CRTL;
515 cf->data[1] |= CAN_ERR_CRTL_RX_OVERFLOW;
516 mc->netdev->stats.rx_over_errors++;
517 mc->netdev->stats.rx_errors++;
519 new_state = mc->pdev->dev.can.state;
523 mc->pdev->dev.can.state = new_state;
525 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
526 struct skb_shared_hwtstamps *hwts = skb_hwtstamps(skb);
528 peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16,
532 mc->netdev->stats.rx_packets++;
533 mc->netdev->stats.rx_bytes += cf->can_dlc;
540 * decode non-data usb message
542 static int pcan_usb_decode_status(struct pcan_usb_msg_context *mc,
545 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;
549 /* check whether function and number can be read */
550 if ((mc->ptr + 2) > mc->end)
553 f = mc->ptr[PCAN_USB_CMD_FUNC];
554 n = mc->ptr[PCAN_USB_CMD_NUM];
555 mc->ptr += PCAN_USB_CMD_ARGS;
557 if (status_len & PCAN_USB_STATUSLEN_TIMESTAMP) {
558 int err = pcan_usb_decode_ts(mc, !mc->rec_idx);
565 case PCAN_USB_REC_ERROR:
566 err = pcan_usb_decode_error(mc, n, status_len);
571 case PCAN_USB_REC_ANALOG:
572 /* analog values (ignored) */
576 case PCAN_USB_REC_BUSLOAD:
577 /* bus load (ignored) */
581 case PCAN_USB_REC_TS:
583 if (pcan_usb_update_ts(mc))
587 case PCAN_USB_REC_BUSEVT:
588 /* error frame/bus event */
589 if (n & PCAN_USB_ERROR_TXQFULL)
590 netdev_dbg(mc->netdev, "device Tx queue full)\n");
593 netdev_err(mc->netdev, "unexpected function %u\n", f);
597 if ((mc->ptr + rec_len) > mc->end)
606 * decode data usb message
608 static int pcan_usb_decode_data(struct pcan_usb_msg_context *mc, u8 status_len)
610 u8 rec_len = status_len & PCAN_USB_STATUSLEN_DLC;
612 struct can_frame *cf;
613 struct skb_shared_hwtstamps *hwts;
615 skb = alloc_can_skb(mc->netdev, &cf);
619 if (status_len & PCAN_USB_STATUSLEN_EXT_ID) {
622 if ((mc->ptr + 4) > mc->end)
625 memcpy(&tmp32, mc->ptr, 4);
628 cf->can_id = (le32_to_cpu(tmp32) >> 3) | CAN_EFF_FLAG;
632 if ((mc->ptr + 2) > mc->end)
635 memcpy(&tmp16, mc->ptr, 2);
638 cf->can_id = le16_to_cpu(tmp16) >> 5;
641 cf->can_dlc = get_can_dlc(rec_len);
643 /* first data packet timestamp is a word */
644 if (pcan_usb_decode_ts(mc, !mc->rec_data_idx))
648 memset(cf->data, 0x0, sizeof(cf->data));
649 if (status_len & PCAN_USB_STATUSLEN_RTR) {
650 cf->can_id |= CAN_RTR_FLAG;
652 if ((mc->ptr + rec_len) > mc->end)
655 memcpy(cf->data, mc->ptr, cf->can_dlc);
659 /* convert timestamp into kernel time */
660 hwts = skb_hwtstamps(skb);
661 peak_usb_get_ts_time(&mc->pdev->time_ref, mc->ts16, &hwts->hwtstamp);
663 /* update statistics */
664 mc->netdev->stats.rx_packets++;
665 mc->netdev->stats.rx_bytes += cf->can_dlc;
677 * process incoming message
679 static int pcan_usb_decode_msg(struct peak_usb_device *dev, u8 *ibuf, u32 lbuf)
681 struct pcan_usb_msg_context mc = {
683 .ptr = ibuf + PCAN_USB_MSG_HEADER_LEN,
685 .netdev = dev->netdev,
686 .pdev = container_of(dev, struct pcan_usb, dev),
690 for (err = 0; mc.rec_idx < mc.rec_cnt && !err; mc.rec_idx++) {
693 /* handle status and error frames here */
694 if (sl & PCAN_USB_STATUSLEN_INTERNAL) {
695 err = pcan_usb_decode_status(&mc, sl);
696 /* handle normal can frames here */
698 err = pcan_usb_decode_data(&mc, sl);
707 * process any incoming buffer
709 static int pcan_usb_decode_buf(struct peak_usb_device *dev, struct urb *urb)
713 if (urb->actual_length > PCAN_USB_MSG_HEADER_LEN) {
714 err = pcan_usb_decode_msg(dev, urb->transfer_buffer,
717 } else if (urb->actual_length > 0) {
718 netdev_err(dev->netdev, "usb message length error (%u)\n",
727 * process outgoing packet
729 static int pcan_usb_encode_msg(struct peak_usb_device *dev, struct sk_buff *skb,
730 u8 *obuf, size_t *size)
732 struct net_device *netdev = dev->netdev;
733 struct net_device_stats *stats = &netdev->stats;
734 struct can_frame *cf = (struct can_frame *)skb->data;
740 pc = obuf + PCAN_USB_MSG_HEADER_LEN;
742 /* status/len byte */
744 if (cf->can_id & CAN_RTR_FLAG)
745 *pc |= PCAN_USB_STATUSLEN_RTR;
748 if (cf->can_id & CAN_EFF_FLAG) {
749 __le32 tmp32 = cpu_to_le32((cf->can_id & CAN_ERR_MASK) << 3);
751 *pc |= PCAN_USB_STATUSLEN_EXT_ID;
752 memcpy(++pc, &tmp32, 4);
755 __le16 tmp16 = cpu_to_le16((cf->can_id & CAN_ERR_MASK) << 5);
757 memcpy(++pc, &tmp16, 2);
762 if (!(cf->can_id & CAN_RTR_FLAG)) {
763 memcpy(pc, cf->data, cf->can_dlc);
767 obuf[(*size)-1] = (u8)(stats->tx_packets & 0xff);
775 static int pcan_usb_start(struct peak_usb_device *dev)
777 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
779 /* number of bits used in timestamps read from adapter struct */
780 peak_usb_init_time_ref(&pdev->time_ref, &pcan_usb);
782 /* if revision greater than 3, can put silent mode on/off */
783 if (dev->device_rev > 3) {
786 err = pcan_usb_set_silent(dev,
787 dev->can.ctrlmode & CAN_CTRLMODE_LISTENONLY);
792 return pcan_usb_set_ext_vcc(dev, 0);
795 static int pcan_usb_init(struct peak_usb_device *dev)
797 struct pcan_usb *pdev = container_of(dev, struct pcan_usb, dev);
801 /* initialize a timer needed to wait for hardware restart */
802 timer_setup(&pdev->restart_timer, pcan_usb_restart, 0);
805 * explicit use of dev_xxx() instead of netdev_xxx() here:
806 * information displayed are related to the device itself, not
807 * to the canx netdevice.
809 err = pcan_usb_get_serial(dev, &serial_number);
811 dev_err(dev->netdev->dev.parent,
812 "unable to read %s serial number (err %d)\n",
817 dev_info(dev->netdev->dev.parent,
818 "PEAK-System %s adapter hwrev %u serial %08X (%u channel)\n",
819 pcan_usb.name, dev->device_rev, serial_number,
820 pcan_usb.ctrl_count);
826 * probe function for new PCAN-USB usb interface
828 static int pcan_usb_probe(struct usb_interface *intf)
830 struct usb_host_interface *if_desc;
833 if_desc = intf->altsetting;
835 /* check interface endpoint addresses */
836 for (i = 0; i < if_desc->desc.bNumEndpoints; i++) {
837 struct usb_endpoint_descriptor *ep = &if_desc->endpoint[i].desc;
839 switch (ep->bEndpointAddress) {
840 case PCAN_USB_EP_CMDOUT:
841 case PCAN_USB_EP_CMDIN:
842 case PCAN_USB_EP_MSGOUT:
843 case PCAN_USB_EP_MSGIN:
854 * describe the PCAN-USB adapter
856 static const struct can_bittiming_const pcan_usb_const = {
868 const struct peak_usb_adapter pcan_usb = {
870 .device_id = PCAN_USB_PRODUCT_ID,
872 .ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_LISTENONLY,
874 .freq = PCAN_USB_CRYSTAL_HZ / 2 ,
876 .bittiming_const = &pcan_usb_const,
878 /* size of device private data */
879 .sizeof_dev_private = sizeof(struct pcan_usb),
881 /* timestamps usage */
883 .ts_period = 24575, /* calibration period in ts. */
884 .us_per_ts_scale = PCAN_USB_TS_US_PER_TICK, /* us=(ts*scale) */
885 .us_per_ts_shift = PCAN_USB_TS_DIV_SHIFTER, /* >> shift */
887 /* give here messages in/out endpoints */
888 .ep_msg_in = PCAN_USB_EP_MSGIN,
889 .ep_msg_out = {PCAN_USB_EP_MSGOUT},
891 /* size of rx/tx usb buffers */
892 .rx_buffer_size = PCAN_USB_RX_BUFFER_SIZE,
893 .tx_buffer_size = PCAN_USB_TX_BUFFER_SIZE,
895 /* device callbacks */
896 .intf_probe = pcan_usb_probe,
897 .dev_init = pcan_usb_init,
898 .dev_set_bus = pcan_usb_write_mode,
899 .dev_set_bittiming = pcan_usb_set_bittiming,
900 .dev_get_device_id = pcan_usb_get_device_id,
901 .dev_decode_buf = pcan_usb_decode_buf,
902 .dev_encode_msg = pcan_usb_encode_msg,
903 .dev_start = pcan_usb_start,
904 .dev_restart_async = pcan_usb_restart_async,