1 // SPDX-License-Identifier: GPL-2.0-only
3 * CAN driver for "8 devices" USB2CAN converter
5 * Copyright (C) 2012 Bernd Krumboeck (krumboeck@universalnet.at)
7 * This driver is inspired by the 3.2.0 version of drivers/net/can/usb/ems_usb.c
8 * and drivers/net/can/usb/esd_usb2.c
10 * Many thanks to Gerhard Bertelsmann (info@gerhard-bertelsmann.de)
11 * for testing and fixing this driver. Also many thanks to "8 devices",
12 * who were very cooperative and answered my questions.
15 #include <linux/signal.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/netdevice.h>
19 #include <linux/usb.h>
21 #include <linux/can.h>
22 #include <linux/can/dev.h>
23 #include <linux/can/error.h>
24 #include <linux/can/led.h>
26 /* driver constants */
27 #define MAX_RX_URBS 20
28 #define MAX_TX_URBS 20
29 #define RX_BUFFER_SIZE 64
31 /* vendor and product id */
32 #define USB_8DEV_VENDOR_ID 0x0483
33 #define USB_8DEV_PRODUCT_ID 0x1234
36 enum usb_8dev_endpoint {
37 USB_8DEV_ENDP_DATA_RX = 1,
38 USB_8DEV_ENDP_DATA_TX,
43 /* device CAN clock */
44 #define USB_8DEV_ABP_CLOCK 32000000
47 #define USB_8DEV_SILENT 0x01
48 #define USB_8DEV_LOOPBACK 0x02
49 #define USB_8DEV_DISABLE_AUTO_RESTRANS 0x04
50 #define USB_8DEV_STATUS_FRAME 0x08
58 USB_8DEV_SET_MASK_FILTER,
60 USB_8DEV_GET_STATISTICS,
62 USB_8DEV_GET_SOFTW_VER,
63 USB_8DEV_GET_HARDW_VER,
64 USB_8DEV_RESET_TIMESTAMP,
65 USB_8DEV_GET_SOFTW_HARDW_VER
69 #define USB_8DEV_BAUD_MANUAL 0x09
70 #define USB_8DEV_CMD_START 0x11
71 #define USB_8DEV_CMD_END 0x22
73 #define USB_8DEV_CMD_SUCCESS 0
74 #define USB_8DEV_CMD_ERROR 255
76 #define USB_8DEV_CMD_TIMEOUT 1000
79 #define USB_8DEV_DATA_START 0x55
80 #define USB_8DEV_DATA_END 0xAA
82 #define USB_8DEV_TYPE_CAN_FRAME 0
83 #define USB_8DEV_TYPE_ERROR_FRAME 3
85 #define USB_8DEV_EXTID 0x01
86 #define USB_8DEV_RTR 0x02
87 #define USB_8DEV_ERR_FLAG 0x04
90 #define USB_8DEV_STATUSMSG_OK 0x00 /* Normal condition. */
91 #define USB_8DEV_STATUSMSG_OVERRUN 0x01 /* Overrun occurred when sending */
92 #define USB_8DEV_STATUSMSG_BUSLIGHT 0x02 /* Error counter has reached 96 */
93 #define USB_8DEV_STATUSMSG_BUSHEAVY 0x03 /* Error count. has reached 128 */
94 #define USB_8DEV_STATUSMSG_BUSOFF 0x04 /* Device is in BUSOFF */
95 #define USB_8DEV_STATUSMSG_STUFF 0x20 /* Stuff Error */
96 #define USB_8DEV_STATUSMSG_FORM 0x21 /* Form Error */
97 #define USB_8DEV_STATUSMSG_ACK 0x23 /* Ack Error */
98 #define USB_8DEV_STATUSMSG_BIT0 0x24 /* Bit1 Error */
99 #define USB_8DEV_STATUSMSG_BIT1 0x25 /* Bit0 Error */
100 #define USB_8DEV_STATUSMSG_CRC 0x27 /* CRC Error */
102 #define USB_8DEV_RP_MASK 0x7F /* Mask for Receive Error Bit */
105 /* table of devices that work with this driver */
106 static const struct usb_device_id usb_8dev_table[] = {
107 { USB_DEVICE(USB_8DEV_VENDOR_ID, USB_8DEV_PRODUCT_ID) },
108 { } /* Terminating entry */
111 MODULE_DEVICE_TABLE(usb, usb_8dev_table);
113 struct usb_8dev_tx_urb_context {
114 struct usb_8dev_priv *priv;
120 /* Structure to hold all of our device specific stuff */
121 struct usb_8dev_priv {
122 struct can_priv can; /* must be the first member */
124 struct sk_buff *echo_skb[MAX_TX_URBS];
126 struct usb_device *udev;
127 struct net_device *netdev;
129 atomic_t active_tx_urbs;
130 struct usb_anchor tx_submitted;
131 struct usb_8dev_tx_urb_context tx_contexts[MAX_TX_URBS];
133 struct usb_anchor rx_submitted;
135 struct can_berr_counter bec;
139 struct mutex usb_8dev_cmd_lock;
140 void *rxbuf[MAX_RX_URBS];
141 dma_addr_t rxbuf_dma[MAX_RX_URBS];
145 struct __packed usb_8dev_tx_msg {
147 u8 flags; /* RTR and EXT_ID flag */
148 __be32 id; /* upper 3 bits not used */
149 u8 dlc; /* data length code 0-8 bytes */
150 u8 data[8]; /* 64-bit data */
155 struct __packed usb_8dev_rx_msg {
157 u8 type; /* frame type */
158 u8 flags; /* RTR and EXT_ID flag */
159 __be32 id; /* upper 3 bits not used */
160 u8 dlc; /* data length code 0-8 bytes */
161 u8 data[8]; /* 64-bit data */
162 __be32 timestamp; /* 32-bit timestamp */
167 struct __packed usb_8dev_cmd_msg {
169 u8 channel; /* unknown - always 0 */
170 u8 command; /* command to execute */
171 u8 opt1; /* optional parameter / return value */
172 u8 opt2; /* optional parameter 2 */
173 u8 data[10]; /* optional parameter and data */
177 static int usb_8dev_send_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size)
181 return usb_bulk_msg(priv->udev,
182 usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_TX),
183 msg, size, &actual_length, USB_8DEV_CMD_TIMEOUT);
186 static int usb_8dev_wait_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size,
189 return usb_bulk_msg(priv->udev,
190 usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_RX),
191 msg, size, actual_length, USB_8DEV_CMD_TIMEOUT);
194 /* Send command to device and receive result.
195 * Command was successful when opt1 = 0.
197 static int usb_8dev_send_cmd(struct usb_8dev_priv *priv,
198 struct usb_8dev_cmd_msg *out,
199 struct usb_8dev_cmd_msg *in)
203 struct net_device *netdev;
205 netdev = priv->netdev;
207 out->begin = USB_8DEV_CMD_START;
208 out->end = USB_8DEV_CMD_END;
210 mutex_lock(&priv->usb_8dev_cmd_lock);
212 memcpy(priv->cmd_msg_buffer, out,
213 sizeof(struct usb_8dev_cmd_msg));
215 err = usb_8dev_send_cmd_msg(priv, priv->cmd_msg_buffer,
216 sizeof(struct usb_8dev_cmd_msg));
218 netdev_err(netdev, "sending command message failed\n");
222 err = usb_8dev_wait_cmd_msg(priv, priv->cmd_msg_buffer,
223 sizeof(struct usb_8dev_cmd_msg),
226 netdev_err(netdev, "no command message answer\n");
230 memcpy(in, priv->cmd_msg_buffer, sizeof(struct usb_8dev_cmd_msg));
232 if (in->begin != USB_8DEV_CMD_START || in->end != USB_8DEV_CMD_END ||
233 num_bytes_read != 16 || in->opt1 != 0)
237 mutex_unlock(&priv->usb_8dev_cmd_lock);
241 /* Send open command to device */
242 static int usb_8dev_cmd_open(struct usb_8dev_priv *priv)
244 struct can_bittiming *bt = &priv->can.bittiming;
245 struct usb_8dev_cmd_msg outmsg;
246 struct usb_8dev_cmd_msg inmsg;
247 u32 ctrlmode = priv->can.ctrlmode;
248 u32 flags = USB_8DEV_STATUS_FRAME;
252 memset(&outmsg, 0, sizeof(outmsg));
253 outmsg.command = USB_8DEV_OPEN;
254 outmsg.opt1 = USB_8DEV_BAUD_MANUAL;
255 outmsg.data[0] = bt->prop_seg + bt->phase_seg1;
256 outmsg.data[1] = bt->phase_seg2;
257 outmsg.data[2] = bt->sjw;
260 bebrp = cpu_to_be16((u16)bt->brp);
261 memcpy(&outmsg.data[3], &bebrp, sizeof(bebrp));
264 if (ctrlmode & CAN_CTRLMODE_LOOPBACK)
265 flags |= USB_8DEV_LOOPBACK;
266 if (ctrlmode & CAN_CTRLMODE_LISTENONLY)
267 flags |= USB_8DEV_SILENT;
268 if (ctrlmode & CAN_CTRLMODE_ONE_SHOT)
269 flags |= USB_8DEV_DISABLE_AUTO_RESTRANS;
271 beflags = cpu_to_be32(flags);
272 memcpy(&outmsg.data[5], &beflags, sizeof(beflags));
274 return usb_8dev_send_cmd(priv, &outmsg, &inmsg);
277 /* Send close command to device */
278 static int usb_8dev_cmd_close(struct usb_8dev_priv *priv)
280 struct usb_8dev_cmd_msg inmsg;
281 struct usb_8dev_cmd_msg outmsg = {
283 .command = USB_8DEV_CLOSE,
288 return usb_8dev_send_cmd(priv, &outmsg, &inmsg);
291 /* Get firmware and hardware version */
292 static int usb_8dev_cmd_version(struct usb_8dev_priv *priv, u32 *res)
294 struct usb_8dev_cmd_msg inmsg;
295 struct usb_8dev_cmd_msg outmsg = {
297 .command = USB_8DEV_GET_SOFTW_HARDW_VER,
302 int err = usb_8dev_send_cmd(priv, &outmsg, &inmsg);
306 *res = be32_to_cpup((__be32 *)inmsg.data);
311 /* Set network device mode
313 * Maybe we should leave this function empty, because the device
314 * set mode variable with open command.
316 static int usb_8dev_set_mode(struct net_device *netdev, enum can_mode mode)
318 struct usb_8dev_priv *priv = netdev_priv(netdev);
323 err = usb_8dev_cmd_open(priv);
325 netdev_warn(netdev, "couldn't start device");
335 /* Read error/status frames */
336 static void usb_8dev_rx_err_msg(struct usb_8dev_priv *priv,
337 struct usb_8dev_rx_msg *msg)
339 struct can_frame *cf;
341 struct net_device_stats *stats = &priv->netdev->stats;
345 * byte 1: bit 7: Receive Passive
346 * byte 1: bit 0-6: Receive Error Counter
347 * byte 2: Transmit Error Counter
348 * byte 3: Always 0 (maybe reserved for future use)
351 u8 state = msg->data[0];
352 u8 rxerr = msg->data[1] & USB_8DEV_RP_MASK;
353 u8 txerr = msg->data[2];
357 skb = alloc_can_err_skb(priv->netdev, &cf);
362 case USB_8DEV_STATUSMSG_OK:
363 priv->can.state = CAN_STATE_ERROR_ACTIVE;
364 cf->can_id |= CAN_ERR_PROT;
365 cf->data[2] = CAN_ERR_PROT_ACTIVE;
367 case USB_8DEV_STATUSMSG_BUSOFF:
368 priv->can.state = CAN_STATE_BUS_OFF;
369 cf->can_id |= CAN_ERR_BUSOFF;
370 priv->can.can_stats.bus_off++;
371 can_bus_off(priv->netdev);
373 case USB_8DEV_STATUSMSG_OVERRUN:
374 case USB_8DEV_STATUSMSG_BUSLIGHT:
375 case USB_8DEV_STATUSMSG_BUSHEAVY:
376 cf->can_id |= CAN_ERR_CRTL;
379 priv->can.state = CAN_STATE_ERROR_WARNING;
380 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
381 priv->can.can_stats.bus_error++;
386 case USB_8DEV_STATUSMSG_OK:
387 case USB_8DEV_STATUSMSG_BUSOFF:
389 case USB_8DEV_STATUSMSG_ACK:
390 cf->can_id |= CAN_ERR_ACK;
393 case USB_8DEV_STATUSMSG_CRC:
394 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
397 case USB_8DEV_STATUSMSG_BIT0:
398 cf->data[2] |= CAN_ERR_PROT_BIT0;
401 case USB_8DEV_STATUSMSG_BIT1:
402 cf->data[2] |= CAN_ERR_PROT_BIT1;
405 case USB_8DEV_STATUSMSG_FORM:
406 cf->data[2] |= CAN_ERR_PROT_FORM;
409 case USB_8DEV_STATUSMSG_STUFF:
410 cf->data[2] |= CAN_ERR_PROT_STUFF;
413 case USB_8DEV_STATUSMSG_OVERRUN:
414 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
415 stats->rx_over_errors++;
418 case USB_8DEV_STATUSMSG_BUSLIGHT:
419 priv->can.state = CAN_STATE_ERROR_WARNING;
420 cf->data[1] = (txerr > rxerr) ?
421 CAN_ERR_CRTL_TX_WARNING :
422 CAN_ERR_CRTL_RX_WARNING;
423 priv->can.can_stats.error_warning++;
425 case USB_8DEV_STATUSMSG_BUSHEAVY:
426 priv->can.state = CAN_STATE_ERROR_PASSIVE;
427 cf->data[1] = (txerr > rxerr) ?
428 CAN_ERR_CRTL_TX_PASSIVE :
429 CAN_ERR_CRTL_RX_PASSIVE;
430 priv->can.can_stats.error_passive++;
433 netdev_warn(priv->netdev,
434 "Unknown status/error message (%d)\n", state);
439 cf->data[2] |= CAN_ERR_PROT_TX;
445 if (priv->can.state != CAN_STATE_BUS_OFF) {
450 priv->bec.txerr = txerr;
451 priv->bec.rxerr = rxerr;
454 stats->rx_bytes += cf->can_dlc;
458 /* Read data and status frames */
459 static void usb_8dev_rx_can_msg(struct usb_8dev_priv *priv,
460 struct usb_8dev_rx_msg *msg)
462 struct can_frame *cf;
464 struct net_device_stats *stats = &priv->netdev->stats;
466 if (msg->type == USB_8DEV_TYPE_ERROR_FRAME &&
467 msg->flags == USB_8DEV_ERR_FLAG) {
468 usb_8dev_rx_err_msg(priv, msg);
469 } else if (msg->type == USB_8DEV_TYPE_CAN_FRAME) {
470 skb = alloc_can_skb(priv->netdev, &cf);
474 cf->can_id = be32_to_cpu(msg->id);
475 cf->can_dlc = get_can_dlc(msg->dlc & 0xF);
477 if (msg->flags & USB_8DEV_EXTID)
478 cf->can_id |= CAN_EFF_FLAG;
480 if (msg->flags & USB_8DEV_RTR)
481 cf->can_id |= CAN_RTR_FLAG;
483 memcpy(cf->data, msg->data, cf->can_dlc);
486 stats->rx_bytes += cf->can_dlc;
489 can_led_event(priv->netdev, CAN_LED_EVENT_RX);
491 netdev_warn(priv->netdev, "frame type %d unknown",
497 /* Callback for reading data from device
499 * Check urb status, call read function and resubmit urb read operation.
501 static void usb_8dev_read_bulk_callback(struct urb *urb)
503 struct usb_8dev_priv *priv = urb->context;
504 struct net_device *netdev;
508 netdev = priv->netdev;
510 if (!netif_device_present(netdev))
513 switch (urb->status) {
514 case 0: /* success */
524 netdev_info(netdev, "Rx URB aborted (%d)\n",
529 while (pos < urb->actual_length) {
530 struct usb_8dev_rx_msg *msg;
532 if (pos + sizeof(struct usb_8dev_rx_msg) > urb->actual_length) {
533 netdev_err(priv->netdev, "format error\n");
537 msg = (struct usb_8dev_rx_msg *)(urb->transfer_buffer + pos);
538 usb_8dev_rx_can_msg(priv, msg);
540 pos += sizeof(struct usb_8dev_rx_msg);
544 usb_fill_bulk_urb(urb, priv->udev,
545 usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_RX),
546 urb->transfer_buffer, RX_BUFFER_SIZE,
547 usb_8dev_read_bulk_callback, priv);
549 retval = usb_submit_urb(urb, GFP_ATOMIC);
551 if (retval == -ENODEV)
552 netif_device_detach(netdev);
555 "failed resubmitting read bulk urb: %d\n", retval);
558 /* Callback handler for write operations
560 * Free allocated buffers, check transmit status and
561 * calculate statistic.
563 static void usb_8dev_write_bulk_callback(struct urb *urb)
565 struct usb_8dev_tx_urb_context *context = urb->context;
566 struct usb_8dev_priv *priv;
567 struct net_device *netdev;
571 priv = context->priv;
572 netdev = priv->netdev;
574 /* free up our allocated buffer */
575 usb_free_coherent(urb->dev, urb->transfer_buffer_length,
576 urb->transfer_buffer, urb->transfer_dma);
578 atomic_dec(&priv->active_tx_urbs);
580 if (!netif_device_present(netdev))
584 netdev_info(netdev, "Tx URB aborted (%d)\n",
587 netdev->stats.tx_packets++;
588 netdev->stats.tx_bytes += context->dlc;
590 can_get_echo_skb(netdev, context->echo_index);
592 can_led_event(netdev, CAN_LED_EVENT_TX);
594 /* Release context */
595 context->echo_index = MAX_TX_URBS;
597 netif_wake_queue(netdev);
600 /* Send data to device */
601 static netdev_tx_t usb_8dev_start_xmit(struct sk_buff *skb,
602 struct net_device *netdev)
604 struct usb_8dev_priv *priv = netdev_priv(netdev);
605 struct net_device_stats *stats = &netdev->stats;
606 struct can_frame *cf = (struct can_frame *) skb->data;
607 struct usb_8dev_tx_msg *msg;
609 struct usb_8dev_tx_urb_context *context = NULL;
612 size_t size = sizeof(struct usb_8dev_tx_msg);
614 if (can_dropped_invalid_skb(netdev, skb))
617 /* create a URB, and a buffer for it, and copy the data to the URB */
618 urb = usb_alloc_urb(0, GFP_ATOMIC);
622 buf = usb_alloc_coherent(priv->udev, size, GFP_ATOMIC,
625 netdev_err(netdev, "No memory left for USB buffer\n");
629 memset(buf, 0, size);
631 msg = (struct usb_8dev_tx_msg *)buf;
632 msg->begin = USB_8DEV_DATA_START;
635 if (cf->can_id & CAN_RTR_FLAG)
636 msg->flags |= USB_8DEV_RTR;
638 if (cf->can_id & CAN_EFF_FLAG)
639 msg->flags |= USB_8DEV_EXTID;
641 msg->id = cpu_to_be32(cf->can_id & CAN_ERR_MASK);
642 msg->dlc = cf->can_dlc;
643 memcpy(msg->data, cf->data, cf->can_dlc);
644 msg->end = USB_8DEV_DATA_END;
646 for (i = 0; i < MAX_TX_URBS; i++) {
647 if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) {
648 context = &priv->tx_contexts[i];
653 /* May never happen! When this happens we'd more URBs in flight as
654 * allowed (MAX_TX_URBS).
659 context->priv = priv;
660 context->echo_index = i;
661 context->dlc = cf->can_dlc;
663 usb_fill_bulk_urb(urb, priv->udev,
664 usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_TX),
665 buf, size, usb_8dev_write_bulk_callback, context);
666 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
667 usb_anchor_urb(urb, &priv->tx_submitted);
669 can_put_echo_skb(skb, netdev, context->echo_index);
671 atomic_inc(&priv->active_tx_urbs);
673 err = usb_submit_urb(urb, GFP_ATOMIC);
675 can_free_echo_skb(netdev, context->echo_index);
677 usb_unanchor_urb(urb);
678 usb_free_coherent(priv->udev, size, buf, urb->transfer_dma);
680 atomic_dec(&priv->active_tx_urbs);
683 netif_device_detach(netdev);
685 netdev_warn(netdev, "failed tx_urb %d\n", err);
687 } else if (atomic_read(&priv->active_tx_urbs) >= MAX_TX_URBS)
688 /* Slow down tx path */
689 netif_stop_queue(netdev);
691 /* Release our reference to this URB, the USB core will eventually free
699 usb_free_coherent(priv->udev, size, buf, urb->transfer_dma);
702 netdev_warn(netdev, "couldn't find free context");
704 return NETDEV_TX_BUSY;
716 static int usb_8dev_get_berr_counter(const struct net_device *netdev,
717 struct can_berr_counter *bec)
719 struct usb_8dev_priv *priv = netdev_priv(netdev);
721 bec->txerr = priv->bec.txerr;
722 bec->rxerr = priv->bec.rxerr;
727 /* Start USB device */
728 static int usb_8dev_start(struct usb_8dev_priv *priv)
730 struct net_device *netdev = priv->netdev;
733 for (i = 0; i < MAX_RX_URBS; i++) {
734 struct urb *urb = NULL;
738 /* create a URB, and a buffer for it */
739 urb = usb_alloc_urb(0, GFP_KERNEL);
745 buf = usb_alloc_coherent(priv->udev, RX_BUFFER_SIZE, GFP_KERNEL,
748 netdev_err(netdev, "No memory left for USB buffer\n");
754 urb->transfer_dma = buf_dma;
756 usb_fill_bulk_urb(urb, priv->udev,
757 usb_rcvbulkpipe(priv->udev,
758 USB_8DEV_ENDP_DATA_RX),
760 usb_8dev_read_bulk_callback, priv);
761 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
762 usb_anchor_urb(urb, &priv->rx_submitted);
764 err = usb_submit_urb(urb, GFP_KERNEL);
766 usb_unanchor_urb(urb);
767 usb_free_coherent(priv->udev, RX_BUFFER_SIZE, buf,
773 priv->rxbuf[i] = buf;
774 priv->rxbuf_dma[i] = buf_dma;
776 /* Drop reference, USB core will take care of freeing it */
780 /* Did we submit any URBs */
782 netdev_warn(netdev, "couldn't setup read URBs\n");
786 /* Warn if we've couldn't transmit all the URBs */
788 netdev_warn(netdev, "rx performance may be slow\n");
790 err = usb_8dev_cmd_open(priv);
794 priv->can.state = CAN_STATE_ERROR_ACTIVE;
800 netif_device_detach(priv->netdev);
802 netdev_warn(netdev, "couldn't submit control: %d\n", err);
807 /* Open USB device */
808 static int usb_8dev_open(struct net_device *netdev)
810 struct usb_8dev_priv *priv = netdev_priv(netdev);
814 err = open_candev(netdev);
818 can_led_event(netdev, CAN_LED_EVENT_OPEN);
820 /* finally start device */
821 err = usb_8dev_start(priv);
824 netif_device_detach(priv->netdev);
826 netdev_warn(netdev, "couldn't start device: %d\n",
829 close_candev(netdev);
834 netif_start_queue(netdev);
839 static void unlink_all_urbs(struct usb_8dev_priv *priv)
843 usb_kill_anchored_urbs(&priv->rx_submitted);
845 for (i = 0; i < MAX_RX_URBS; ++i)
846 usb_free_coherent(priv->udev, RX_BUFFER_SIZE,
847 priv->rxbuf[i], priv->rxbuf_dma[i]);
849 usb_kill_anchored_urbs(&priv->tx_submitted);
850 atomic_set(&priv->active_tx_urbs, 0);
852 for (i = 0; i < MAX_TX_URBS; i++)
853 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
856 /* Close USB device */
857 static int usb_8dev_close(struct net_device *netdev)
859 struct usb_8dev_priv *priv = netdev_priv(netdev);
862 /* Send CLOSE command to CAN controller */
863 err = usb_8dev_cmd_close(priv);
865 netdev_warn(netdev, "couldn't stop device");
867 priv->can.state = CAN_STATE_STOPPED;
869 netif_stop_queue(netdev);
872 unlink_all_urbs(priv);
874 close_candev(netdev);
876 can_led_event(netdev, CAN_LED_EVENT_STOP);
881 static const struct net_device_ops usb_8dev_netdev_ops = {
882 .ndo_open = usb_8dev_open,
883 .ndo_stop = usb_8dev_close,
884 .ndo_start_xmit = usb_8dev_start_xmit,
885 .ndo_change_mtu = can_change_mtu,
888 static const struct can_bittiming_const usb_8dev_bittiming_const = {
902 * Check device and firmware.
903 * Set supported modes and bittiming constants.
904 * Allocate some memory.
906 static int usb_8dev_probe(struct usb_interface *intf,
907 const struct usb_device_id *id)
909 struct net_device *netdev;
910 struct usb_8dev_priv *priv;
911 int i, err = -ENOMEM;
914 struct usb_device *usbdev = interface_to_usbdev(intf);
916 /* product id looks strange, better we also check iProduct string */
917 if (usb_string(usbdev, usbdev->descriptor.iProduct, buf,
918 sizeof(buf)) > 0 && strcmp(buf, "USB2CAN converter")) {
919 dev_info(&usbdev->dev, "ignoring: not an USB2CAN converter\n");
923 netdev = alloc_candev(sizeof(struct usb_8dev_priv), MAX_TX_URBS);
925 dev_err(&intf->dev, "Couldn't alloc candev\n");
929 priv = netdev_priv(netdev);
932 priv->netdev = netdev;
934 priv->can.state = CAN_STATE_STOPPED;
935 priv->can.clock.freq = USB_8DEV_ABP_CLOCK;
936 priv->can.bittiming_const = &usb_8dev_bittiming_const;
937 priv->can.do_set_mode = usb_8dev_set_mode;
938 priv->can.do_get_berr_counter = usb_8dev_get_berr_counter;
939 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
940 CAN_CTRLMODE_LISTENONLY |
941 CAN_CTRLMODE_ONE_SHOT;
943 netdev->netdev_ops = &usb_8dev_netdev_ops;
945 netdev->flags |= IFF_ECHO; /* we support local echo */
947 init_usb_anchor(&priv->rx_submitted);
949 init_usb_anchor(&priv->tx_submitted);
950 atomic_set(&priv->active_tx_urbs, 0);
952 for (i = 0; i < MAX_TX_URBS; i++)
953 priv->tx_contexts[i].echo_index = MAX_TX_URBS;
955 priv->cmd_msg_buffer = devm_kzalloc(&intf->dev, sizeof(struct usb_8dev_cmd_msg),
957 if (!priv->cmd_msg_buffer)
960 usb_set_intfdata(intf, priv);
962 SET_NETDEV_DEV(netdev, &intf->dev);
964 mutex_init(&priv->usb_8dev_cmd_lock);
966 err = register_candev(netdev);
969 "couldn't register CAN device: %d\n", err);
973 err = usb_8dev_cmd_version(priv, &version);
975 netdev_err(netdev, "can't get firmware version\n");
976 goto cleanup_unregister_candev;
979 "firmware: %d.%d, hardware: %d.%d\n",
980 (version>>24) & 0xff, (version>>16) & 0xff,
981 (version>>8) & 0xff, version & 0xff);
984 devm_can_led_init(netdev);
988 cleanup_unregister_candev:
989 unregister_netdev(priv->netdev);
998 /* Called by the usb core when driver is unloaded or device is removed */
999 static void usb_8dev_disconnect(struct usb_interface *intf)
1001 struct usb_8dev_priv *priv = usb_get_intfdata(intf);
1003 usb_set_intfdata(intf, NULL);
1006 netdev_info(priv->netdev, "device disconnected\n");
1008 unregister_netdev(priv->netdev);
1009 unlink_all_urbs(priv);
1010 free_candev(priv->netdev);
1015 static struct usb_driver usb_8dev_driver = {
1017 .probe = usb_8dev_probe,
1018 .disconnect = usb_8dev_disconnect,
1019 .id_table = usb_8dev_table,
1022 module_usb_driver(usb_8dev_driver);
1024 MODULE_AUTHOR("Bernd Krumboeck <krumboeck@universalnet.at>");
1025 MODULE_DESCRIPTION("CAN driver for 8 devices USB2CAN interfaces");
1026 MODULE_LICENSE("GPL v2");