1017 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * CAN driver for "8 devices" USB2CAN converter4 *5 * Copyright (C) 2012 Bernd Krumboeck (krumboeck@universalnet.at)6 *7 * This driver is inspired by the 3.2.0 version of drivers/net/can/usb/ems_usb.c8 * and drivers/net/can/usb/esd_usb2.c9 *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.13 */14 15#include <linux/ethtool.h>16#include <linux/signal.h>17#include <linux/slab.h>18#include <linux/module.h>19#include <linux/netdevice.h>20#include <linux/usb.h>21 22#include <linux/can.h>23#include <linux/can/dev.h>24#include <linux/can/error.h>25 26/* driver constants */27#define MAX_RX_URBS 2028#define MAX_TX_URBS 2029#define RX_BUFFER_SIZE 6430 31/* vendor and product id */32#define USB_8DEV_VENDOR_ID 0x048333#define USB_8DEV_PRODUCT_ID 0x123434 35/* endpoints */36enum usb_8dev_endpoint {37 USB_8DEV_ENDP_DATA_RX = 1,38 USB_8DEV_ENDP_DATA_TX,39 USB_8DEV_ENDP_CMD_RX,40 USB_8DEV_ENDP_CMD_TX41};42 43/* device CAN clock */44#define USB_8DEV_ABP_CLOCK 3200000045 46/* setup flags */47#define USB_8DEV_SILENT 0x0148#define USB_8DEV_LOOPBACK 0x0249#define USB_8DEV_DISABLE_AUTO_RESTRANS 0x0450#define USB_8DEV_STATUS_FRAME 0x0851 52/* commands */53enum usb_8dev_cmd {54 USB_8DEV_RESET = 1,55 USB_8DEV_OPEN,56 USB_8DEV_CLOSE,57 USB_8DEV_SET_SPEED,58 USB_8DEV_SET_MASK_FILTER,59 USB_8DEV_GET_STATUS,60 USB_8DEV_GET_STATISTICS,61 USB_8DEV_GET_SERIAL,62 USB_8DEV_GET_SOFTW_VER,63 USB_8DEV_GET_HARDW_VER,64 USB_8DEV_RESET_TIMESTAMP,65 USB_8DEV_GET_SOFTW_HARDW_VER66};67 68/* command options */69#define USB_8DEV_BAUD_MANUAL 0x0970#define USB_8DEV_CMD_START 0x1171#define USB_8DEV_CMD_END 0x2272 73#define USB_8DEV_CMD_SUCCESS 074#define USB_8DEV_CMD_ERROR 25575 76#define USB_8DEV_CMD_TIMEOUT 100077 78/* frames */79#define USB_8DEV_DATA_START 0x5580#define USB_8DEV_DATA_END 0xAA81 82#define USB_8DEV_TYPE_CAN_FRAME 083#define USB_8DEV_TYPE_ERROR_FRAME 384 85#define USB_8DEV_EXTID 0x0186#define USB_8DEV_RTR 0x0287#define USB_8DEV_ERR_FLAG 0x0488 89/* status */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 */101 102#define USB_8DEV_RP_MASK 0x7F /* Mask for Receive Error Bit */103 104 105/* table of devices that work with this driver */106static const struct usb_device_id usb_8dev_table[] = {107 { USB_DEVICE(USB_8DEV_VENDOR_ID, USB_8DEV_PRODUCT_ID) },108 { } /* Terminating entry */109};110 111MODULE_DEVICE_TABLE(usb, usb_8dev_table);112 113struct usb_8dev_tx_urb_context {114 struct usb_8dev_priv *priv;115 116 u32 echo_index;117};118 119/* Structure to hold all of our device specific stuff */120struct usb_8dev_priv {121 struct can_priv can; /* must be the first member */122 123 struct usb_device *udev;124 struct net_device *netdev;125 126 atomic_t active_tx_urbs;127 struct usb_anchor tx_submitted;128 struct usb_8dev_tx_urb_context tx_contexts[MAX_TX_URBS];129 130 struct usb_anchor rx_submitted;131 132 struct can_berr_counter bec;133 134 u8 *cmd_msg_buffer;135 136 struct mutex usb_8dev_cmd_lock;137 void *rxbuf[MAX_RX_URBS];138 dma_addr_t rxbuf_dma[MAX_RX_URBS];139};140 141/* tx frame */142struct __packed usb_8dev_tx_msg {143 u8 begin;144 u8 flags; /* RTR and EXT_ID flag */145 __be32 id; /* upper 3 bits not used */146 u8 dlc; /* data length code 0-8 bytes */147 u8 data[8]; /* 64-bit data */148 u8 end;149};150 151/* rx frame */152struct __packed usb_8dev_rx_msg {153 u8 begin;154 u8 type; /* frame type */155 u8 flags; /* RTR and EXT_ID flag */156 __be32 id; /* upper 3 bits not used */157 u8 dlc; /* data length code 0-8 bytes */158 u8 data[8]; /* 64-bit data */159 __be32 timestamp; /* 32-bit timestamp */160 u8 end;161};162 163/* command frame */164struct __packed usb_8dev_cmd_msg {165 u8 begin;166 u8 channel; /* unknown - always 0 */167 u8 command; /* command to execute */168 u8 opt1; /* optional parameter / return value */169 u8 opt2; /* optional parameter 2 */170 u8 data[10]; /* optional parameter and data */171 u8 end;172};173 174static int usb_8dev_send_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size)175{176 int actual_length;177 178 return usb_bulk_msg(priv->udev,179 usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_TX),180 msg, size, &actual_length, USB_8DEV_CMD_TIMEOUT);181}182 183static int usb_8dev_wait_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size,184 int *actual_length)185{186 return usb_bulk_msg(priv->udev,187 usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_RX),188 msg, size, actual_length, USB_8DEV_CMD_TIMEOUT);189}190 191/* Send command to device and receive result.192 * Command was successful when opt1 = 0.193 */194static int usb_8dev_send_cmd(struct usb_8dev_priv *priv,195 struct usb_8dev_cmd_msg *out,196 struct usb_8dev_cmd_msg *in)197{198 int err;199 int num_bytes_read;200 struct net_device *netdev;201 202 netdev = priv->netdev;203 204 out->begin = USB_8DEV_CMD_START;205 out->end = USB_8DEV_CMD_END;206 207 mutex_lock(&priv->usb_8dev_cmd_lock);208 209 memcpy(priv->cmd_msg_buffer, out,210 sizeof(struct usb_8dev_cmd_msg));211 212 err = usb_8dev_send_cmd_msg(priv, priv->cmd_msg_buffer,213 sizeof(struct usb_8dev_cmd_msg));214 if (err < 0) {215 netdev_err(netdev, "sending command message failed\n");216 goto failed;217 }218 219 err = usb_8dev_wait_cmd_msg(priv, priv->cmd_msg_buffer,220 sizeof(struct usb_8dev_cmd_msg),221 &num_bytes_read);222 if (err < 0) {223 netdev_err(netdev, "no command message answer\n");224 goto failed;225 }226 227 memcpy(in, priv->cmd_msg_buffer, sizeof(struct usb_8dev_cmd_msg));228 229 if (in->begin != USB_8DEV_CMD_START || in->end != USB_8DEV_CMD_END ||230 num_bytes_read != 16 || in->opt1 != 0)231 err = -EPROTO;232 233failed:234 mutex_unlock(&priv->usb_8dev_cmd_lock);235 return err;236}237 238/* Send open command to device */239static int usb_8dev_cmd_open(struct usb_8dev_priv *priv)240{241 struct can_bittiming *bt = &priv->can.bittiming;242 struct usb_8dev_cmd_msg outmsg;243 struct usb_8dev_cmd_msg inmsg;244 u32 ctrlmode = priv->can.ctrlmode;245 u32 flags = USB_8DEV_STATUS_FRAME;246 __be32 beflags;247 __be16 bebrp;248 249 memset(&outmsg, 0, sizeof(outmsg));250 outmsg.command = USB_8DEV_OPEN;251 outmsg.opt1 = USB_8DEV_BAUD_MANUAL;252 outmsg.data[0] = bt->prop_seg + bt->phase_seg1;253 outmsg.data[1] = bt->phase_seg2;254 outmsg.data[2] = bt->sjw;255 256 /* BRP */257 bebrp = cpu_to_be16((u16)bt->brp);258 memcpy(&outmsg.data[3], &bebrp, sizeof(bebrp));259 260 /* flags */261 if (ctrlmode & CAN_CTRLMODE_LOOPBACK)262 flags |= USB_8DEV_LOOPBACK;263 if (ctrlmode & CAN_CTRLMODE_LISTENONLY)264 flags |= USB_8DEV_SILENT;265 if (ctrlmode & CAN_CTRLMODE_ONE_SHOT)266 flags |= USB_8DEV_DISABLE_AUTO_RESTRANS;267 268 beflags = cpu_to_be32(flags);269 memcpy(&outmsg.data[5], &beflags, sizeof(beflags));270 271 return usb_8dev_send_cmd(priv, &outmsg, &inmsg);272}273 274/* Send close command to device */275static int usb_8dev_cmd_close(struct usb_8dev_priv *priv)276{277 struct usb_8dev_cmd_msg inmsg;278 struct usb_8dev_cmd_msg outmsg = {279 .channel = 0,280 .command = USB_8DEV_CLOSE,281 .opt1 = 0,282 .opt2 = 0283 };284 285 return usb_8dev_send_cmd(priv, &outmsg, &inmsg);286}287 288/* Get firmware and hardware version */289static int usb_8dev_cmd_version(struct usb_8dev_priv *priv, u32 *res)290{291 struct usb_8dev_cmd_msg inmsg;292 struct usb_8dev_cmd_msg outmsg = {293 .channel = 0,294 .command = USB_8DEV_GET_SOFTW_HARDW_VER,295 .opt1 = 0,296 .opt2 = 0297 };298 299 int err = usb_8dev_send_cmd(priv, &outmsg, &inmsg);300 if (err)301 return err;302 303 *res = be32_to_cpup((__be32 *)inmsg.data);304 305 return err;306}307 308/* Set network device mode309 *310 * Maybe we should leave this function empty, because the device311 * set mode variable with open command.312 */313static int usb_8dev_set_mode(struct net_device *netdev, enum can_mode mode)314{315 struct usb_8dev_priv *priv = netdev_priv(netdev);316 int err = 0;317 318 switch (mode) {319 case CAN_MODE_START:320 err = usb_8dev_cmd_open(priv);321 if (err)322 netdev_warn(netdev, "couldn't start device");323 break;324 325 default:326 return -EOPNOTSUPP;327 }328 329 return err;330}331 332/* Read error/status frames */333static void usb_8dev_rx_err_msg(struct usb_8dev_priv *priv,334 struct usb_8dev_rx_msg *msg)335{336 struct can_frame *cf;337 struct sk_buff *skb;338 struct net_device_stats *stats = &priv->netdev->stats;339 340 /* Error message:341 * byte 0: Status342 * byte 1: bit 7: Receive Passive343 * byte 1: bit 0-6: Receive Error Counter344 * byte 2: Transmit Error Counter345 * byte 3: Always 0 (maybe reserved for future use)346 */347 348 u8 state = msg->data[0];349 u8 rxerr = msg->data[1] & USB_8DEV_RP_MASK;350 u8 txerr = msg->data[2];351 int rx_errors = 0;352 int tx_errors = 0;353 354 skb = alloc_can_err_skb(priv->netdev, &cf);355 if (!skb)356 return;357 358 switch (state) {359 case USB_8DEV_STATUSMSG_OK:360 priv->can.state = CAN_STATE_ERROR_ACTIVE;361 cf->can_id |= CAN_ERR_PROT;362 cf->data[2] = CAN_ERR_PROT_ACTIVE;363 break;364 case USB_8DEV_STATUSMSG_BUSOFF:365 priv->can.state = CAN_STATE_BUS_OFF;366 cf->can_id |= CAN_ERR_BUSOFF;367 priv->can.can_stats.bus_off++;368 can_bus_off(priv->netdev);369 break;370 case USB_8DEV_STATUSMSG_OVERRUN:371 case USB_8DEV_STATUSMSG_BUSLIGHT:372 case USB_8DEV_STATUSMSG_BUSHEAVY:373 cf->can_id |= CAN_ERR_CRTL;374 break;375 default:376 priv->can.state = CAN_STATE_ERROR_WARNING;377 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;378 priv->can.can_stats.bus_error++;379 break;380 }381 382 switch (state) {383 case USB_8DEV_STATUSMSG_OK:384 case USB_8DEV_STATUSMSG_BUSOFF:385 break;386 case USB_8DEV_STATUSMSG_ACK:387 cf->can_id |= CAN_ERR_ACK;388 tx_errors = 1;389 break;390 case USB_8DEV_STATUSMSG_CRC:391 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;392 rx_errors = 1;393 break;394 case USB_8DEV_STATUSMSG_BIT0:395 cf->data[2] |= CAN_ERR_PROT_BIT0;396 tx_errors = 1;397 break;398 case USB_8DEV_STATUSMSG_BIT1:399 cf->data[2] |= CAN_ERR_PROT_BIT1;400 tx_errors = 1;401 break;402 case USB_8DEV_STATUSMSG_FORM:403 cf->data[2] |= CAN_ERR_PROT_FORM;404 rx_errors = 1;405 break;406 case USB_8DEV_STATUSMSG_STUFF:407 cf->data[2] |= CAN_ERR_PROT_STUFF;408 rx_errors = 1;409 break;410 case USB_8DEV_STATUSMSG_OVERRUN:411 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;412 stats->rx_over_errors++;413 rx_errors = 1;414 break;415 case USB_8DEV_STATUSMSG_BUSLIGHT:416 priv->can.state = CAN_STATE_ERROR_WARNING;417 cf->data[1] = (txerr > rxerr) ?418 CAN_ERR_CRTL_TX_WARNING :419 CAN_ERR_CRTL_RX_WARNING;420 priv->can.can_stats.error_warning++;421 break;422 case USB_8DEV_STATUSMSG_BUSHEAVY:423 priv->can.state = CAN_STATE_ERROR_PASSIVE;424 cf->data[1] = (txerr > rxerr) ?425 CAN_ERR_CRTL_TX_PASSIVE :426 CAN_ERR_CRTL_RX_PASSIVE;427 priv->can.can_stats.error_passive++;428 break;429 default:430 netdev_warn(priv->netdev,431 "Unknown status/error message (%d)\n", state);432 break;433 }434 435 if (tx_errors) {436 cf->data[2] |= CAN_ERR_PROT_TX;437 stats->tx_errors++;438 }439 440 if (rx_errors)441 stats->rx_errors++;442 if (priv->can.state != CAN_STATE_BUS_OFF) {443 cf->can_id |= CAN_ERR_CNT;444 cf->data[6] = txerr;445 cf->data[7] = rxerr;446 }447 448 priv->bec.txerr = txerr;449 priv->bec.rxerr = rxerr;450 451 netif_rx(skb);452}453 454/* Read data and status frames */455static void usb_8dev_rx_can_msg(struct usb_8dev_priv *priv,456 struct usb_8dev_rx_msg *msg)457{458 struct can_frame *cf;459 struct sk_buff *skb;460 struct net_device_stats *stats = &priv->netdev->stats;461 462 if (msg->type == USB_8DEV_TYPE_ERROR_FRAME &&463 msg->flags == USB_8DEV_ERR_FLAG) {464 usb_8dev_rx_err_msg(priv, msg);465 } else if (msg->type == USB_8DEV_TYPE_CAN_FRAME) {466 skb = alloc_can_skb(priv->netdev, &cf);467 if (!skb)468 return;469 470 cf->can_id = be32_to_cpu(msg->id);471 can_frame_set_cc_len(cf, msg->dlc & 0xF, priv->can.ctrlmode);472 473 if (msg->flags & USB_8DEV_EXTID)474 cf->can_id |= CAN_EFF_FLAG;475 476 if (msg->flags & USB_8DEV_RTR) {477 cf->can_id |= CAN_RTR_FLAG;478 } else {479 memcpy(cf->data, msg->data, cf->len);480 stats->rx_bytes += cf->len;481 }482 stats->rx_packets++;483 484 netif_rx(skb);485 } else {486 netdev_warn(priv->netdev, "frame type %d unknown",487 msg->type);488 }489 490}491 492/* Callback for reading data from device493 *494 * Check urb status, call read function and resubmit urb read operation.495 */496static void usb_8dev_read_bulk_callback(struct urb *urb)497{498 struct usb_8dev_priv *priv = urb->context;499 struct net_device *netdev;500 int retval;501 int pos = 0;502 503 netdev = priv->netdev;504 505 if (!netif_device_present(netdev))506 return;507 508 switch (urb->status) {509 case 0: /* success */510 break;511 512 case -ENOENT:513 case -EPIPE:514 case -EPROTO:515 case -ESHUTDOWN:516 return;517 518 default:519 netdev_info(netdev, "Rx URB aborted (%d)\n",520 urb->status);521 goto resubmit_urb;522 }523 524 while (pos < urb->actual_length) {525 struct usb_8dev_rx_msg *msg;526 527 if (pos + sizeof(struct usb_8dev_rx_msg) > urb->actual_length) {528 netdev_err(priv->netdev, "format error\n");529 break;530 }531 532 msg = (struct usb_8dev_rx_msg *)(urb->transfer_buffer + pos);533 usb_8dev_rx_can_msg(priv, msg);534 535 pos += sizeof(struct usb_8dev_rx_msg);536 }537 538resubmit_urb:539 usb_fill_bulk_urb(urb, priv->udev,540 usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_RX),541 urb->transfer_buffer, RX_BUFFER_SIZE,542 usb_8dev_read_bulk_callback, priv);543 544 retval = usb_submit_urb(urb, GFP_ATOMIC);545 546 if (retval == -ENODEV)547 netif_device_detach(netdev);548 else if (retval)549 netdev_err(netdev,550 "failed resubmitting read bulk urb: %d\n", retval);551}552 553/* Callback handler for write operations554 *555 * Free allocated buffers, check transmit status and556 * calculate statistic.557 */558static void usb_8dev_write_bulk_callback(struct urb *urb)559{560 struct usb_8dev_tx_urb_context *context = urb->context;561 struct usb_8dev_priv *priv;562 struct net_device *netdev;563 564 BUG_ON(!context);565 566 priv = context->priv;567 netdev = priv->netdev;568 569 /* free up our allocated buffer */570 usb_free_coherent(urb->dev, urb->transfer_buffer_length,571 urb->transfer_buffer, urb->transfer_dma);572 573 atomic_dec(&priv->active_tx_urbs);574 575 if (!netif_device_present(netdev))576 return;577 578 if (urb->status)579 netdev_info(netdev, "Tx URB aborted (%d)\n",580 urb->status);581 582 netdev->stats.tx_packets++;583 netdev->stats.tx_bytes += can_get_echo_skb(netdev, context->echo_index, NULL);584 585 /* Release context */586 context->echo_index = MAX_TX_URBS;587 588 netif_wake_queue(netdev);589}590 591/* Send data to device */592static netdev_tx_t usb_8dev_start_xmit(struct sk_buff *skb,593 struct net_device *netdev)594{595 struct usb_8dev_priv *priv = netdev_priv(netdev);596 struct net_device_stats *stats = &netdev->stats;597 struct can_frame *cf = (struct can_frame *) skb->data;598 struct usb_8dev_tx_msg *msg;599 struct urb *urb;600 struct usb_8dev_tx_urb_context *context = NULL;601 u8 *buf;602 int i, err;603 size_t size = sizeof(struct usb_8dev_tx_msg);604 605 if (can_dev_dropped_skb(netdev, skb))606 return NETDEV_TX_OK;607 608 /* create a URB, and a buffer for it, and copy the data to the URB */609 urb = usb_alloc_urb(0, GFP_ATOMIC);610 if (!urb)611 goto nomem;612 613 buf = usb_alloc_coherent(priv->udev, size, GFP_ATOMIC,614 &urb->transfer_dma);615 if (!buf) {616 netdev_err(netdev, "No memory left for USB buffer\n");617 goto nomembuf;618 }619 620 memset(buf, 0, size);621 622 msg = (struct usb_8dev_tx_msg *)buf;623 msg->begin = USB_8DEV_DATA_START;624 msg->flags = 0x00;625 626 if (cf->can_id & CAN_RTR_FLAG)627 msg->flags |= USB_8DEV_RTR;628 629 if (cf->can_id & CAN_EFF_FLAG)630 msg->flags |= USB_8DEV_EXTID;631 632 msg->id = cpu_to_be32(cf->can_id & CAN_ERR_MASK);633 msg->dlc = can_get_cc_dlc(cf, priv->can.ctrlmode);634 memcpy(msg->data, cf->data, cf->len);635 msg->end = USB_8DEV_DATA_END;636 637 for (i = 0; i < MAX_TX_URBS; i++) {638 if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) {639 context = &priv->tx_contexts[i];640 break;641 }642 }643 644 /* May never happen! When this happens we'd more URBs in flight as645 * allowed (MAX_TX_URBS).646 */647 if (!context)648 goto nofreecontext;649 650 context->priv = priv;651 context->echo_index = i;652 653 usb_fill_bulk_urb(urb, priv->udev,654 usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_TX),655 buf, size, usb_8dev_write_bulk_callback, context);656 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;657 usb_anchor_urb(urb, &priv->tx_submitted);658 659 can_put_echo_skb(skb, netdev, context->echo_index, 0);660 661 atomic_inc(&priv->active_tx_urbs);662 663 err = usb_submit_urb(urb, GFP_ATOMIC);664 if (unlikely(err)) {665 can_free_echo_skb(netdev, context->echo_index, NULL);666 667 usb_unanchor_urb(urb);668 usb_free_coherent(priv->udev, size, buf, urb->transfer_dma);669 670 atomic_dec(&priv->active_tx_urbs);671 672 if (err == -ENODEV)673 netif_device_detach(netdev);674 else675 netdev_warn(netdev, "failed tx_urb %d\n", err);676 stats->tx_dropped++;677 } else if (atomic_read(&priv->active_tx_urbs) >= MAX_TX_URBS)678 /* Slow down tx path */679 netif_stop_queue(netdev);680 681 /* Release our reference to this URB, the USB core will eventually free682 * it entirely.683 */684 usb_free_urb(urb);685 686 return NETDEV_TX_OK;687 688nofreecontext:689 usb_free_coherent(priv->udev, size, buf, urb->transfer_dma);690 usb_free_urb(urb);691 692 netdev_warn(netdev, "couldn't find free context");693 694 return NETDEV_TX_BUSY;695 696nomembuf:697 usb_free_urb(urb);698 699nomem:700 dev_kfree_skb(skb);701 stats->tx_dropped++;702 703 return NETDEV_TX_OK;704}705 706static int usb_8dev_get_berr_counter(const struct net_device *netdev,707 struct can_berr_counter *bec)708{709 struct usb_8dev_priv *priv = netdev_priv(netdev);710 711 bec->txerr = priv->bec.txerr;712 bec->rxerr = priv->bec.rxerr;713 714 return 0;715}716 717/* Start USB device */718static int usb_8dev_start(struct usb_8dev_priv *priv)719{720 struct net_device *netdev = priv->netdev;721 int err, i;722 723 for (i = 0; i < MAX_RX_URBS; i++) {724 struct urb *urb = NULL;725 u8 *buf;726 dma_addr_t buf_dma;727 728 /* create a URB, and a buffer for it */729 urb = usb_alloc_urb(0, GFP_KERNEL);730 if (!urb) {731 err = -ENOMEM;732 break;733 }734 735 buf = usb_alloc_coherent(priv->udev, RX_BUFFER_SIZE, GFP_KERNEL,736 &buf_dma);737 if (!buf) {738 netdev_err(netdev, "No memory left for USB buffer\n");739 usb_free_urb(urb);740 err = -ENOMEM;741 break;742 }743 744 urb->transfer_dma = buf_dma;745 746 usb_fill_bulk_urb(urb, priv->udev,747 usb_rcvbulkpipe(priv->udev,748 USB_8DEV_ENDP_DATA_RX),749 buf, RX_BUFFER_SIZE,750 usb_8dev_read_bulk_callback, priv);751 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;752 usb_anchor_urb(urb, &priv->rx_submitted);753 754 err = usb_submit_urb(urb, GFP_KERNEL);755 if (err) {756 usb_unanchor_urb(urb);757 usb_free_coherent(priv->udev, RX_BUFFER_SIZE, buf,758 urb->transfer_dma);759 usb_free_urb(urb);760 break;761 }762 763 priv->rxbuf[i] = buf;764 priv->rxbuf_dma[i] = buf_dma;765 766 /* Drop reference, USB core will take care of freeing it */767 usb_free_urb(urb);768 }769 770 /* Did we submit any URBs */771 if (i == 0) {772 netdev_warn(netdev, "couldn't setup read URBs\n");773 return err;774 }775 776 /* Warn if we've couldn't transmit all the URBs */777 if (i < MAX_RX_URBS)778 netdev_warn(netdev, "rx performance may be slow\n");779 780 err = usb_8dev_cmd_open(priv);781 if (err)782 goto failed;783 784 priv->can.state = CAN_STATE_ERROR_ACTIVE;785 786 return 0;787 788failed:789 if (err == -ENODEV)790 netif_device_detach(priv->netdev);791 792 netdev_warn(netdev, "couldn't submit control: %d\n", err);793 794 return err;795}796 797/* Open USB device */798static int usb_8dev_open(struct net_device *netdev)799{800 struct usb_8dev_priv *priv = netdev_priv(netdev);801 int err;802 803 /* common open */804 err = open_candev(netdev);805 if (err)806 return err;807 808 /* finally start device */809 err = usb_8dev_start(priv);810 if (err) {811 if (err == -ENODEV)812 netif_device_detach(priv->netdev);813 814 netdev_warn(netdev, "couldn't start device: %d\n",815 err);816 817 close_candev(netdev);818 819 return err;820 }821 822 netif_start_queue(netdev);823 824 return 0;825}826 827static void unlink_all_urbs(struct usb_8dev_priv *priv)828{829 int i;830 831 usb_kill_anchored_urbs(&priv->rx_submitted);832 833 for (i = 0; i < MAX_RX_URBS; ++i)834 usb_free_coherent(priv->udev, RX_BUFFER_SIZE,835 priv->rxbuf[i], priv->rxbuf_dma[i]);836 837 usb_kill_anchored_urbs(&priv->tx_submitted);838 atomic_set(&priv->active_tx_urbs, 0);839 840 for (i = 0; i < MAX_TX_URBS; i++)841 priv->tx_contexts[i].echo_index = MAX_TX_URBS;842}843 844/* Close USB device */845static int usb_8dev_close(struct net_device *netdev)846{847 struct usb_8dev_priv *priv = netdev_priv(netdev);848 int err = 0;849 850 /* Send CLOSE command to CAN controller */851 err = usb_8dev_cmd_close(priv);852 if (err)853 netdev_warn(netdev, "couldn't stop device");854 855 priv->can.state = CAN_STATE_STOPPED;856 857 netif_stop_queue(netdev);858 859 /* Stop polling */860 unlink_all_urbs(priv);861 862 close_candev(netdev);863 864 return err;865}866 867static const struct net_device_ops usb_8dev_netdev_ops = {868 .ndo_open = usb_8dev_open,869 .ndo_stop = usb_8dev_close,870 .ndo_start_xmit = usb_8dev_start_xmit,871 .ndo_change_mtu = can_change_mtu,872};873 874static const struct ethtool_ops usb_8dev_ethtool_ops = {875 .get_ts_info = ethtool_op_get_ts_info,876};877 878static const struct can_bittiming_const usb_8dev_bittiming_const = {879 .name = KBUILD_MODNAME,880 .tseg1_min = 1,881 .tseg1_max = 16,882 .tseg2_min = 1,883 .tseg2_max = 8,884 .sjw_max = 4,885 .brp_min = 1,886 .brp_max = 1024,887 .brp_inc = 1,888};889 890/* Probe USB device891 *892 * Check device and firmware.893 * Set supported modes and bittiming constants.894 * Allocate some memory.895 */896static int usb_8dev_probe(struct usb_interface *intf,897 const struct usb_device_id *id)898{899 struct net_device *netdev;900 struct usb_8dev_priv *priv;901 int i, err = -ENOMEM;902 u32 version;903 char buf[18];904 struct usb_device *usbdev = interface_to_usbdev(intf);905 906 /* product id looks strange, better we also check iProduct string */907 if (usb_string(usbdev, usbdev->descriptor.iProduct, buf,908 sizeof(buf)) > 0 && strcmp(buf, "USB2CAN converter")) {909 dev_info(&usbdev->dev, "ignoring: not an USB2CAN converter\n");910 return -ENODEV;911 }912 913 netdev = alloc_candev(sizeof(struct usb_8dev_priv), MAX_TX_URBS);914 if (!netdev) {915 dev_err(&intf->dev, "Couldn't alloc candev\n");916 return -ENOMEM;917 }918 919 priv = netdev_priv(netdev);920 921 priv->udev = usbdev;922 priv->netdev = netdev;923 924 priv->can.state = CAN_STATE_STOPPED;925 priv->can.clock.freq = USB_8DEV_ABP_CLOCK;926 priv->can.bittiming_const = &usb_8dev_bittiming_const;927 priv->can.do_set_mode = usb_8dev_set_mode;928 priv->can.do_get_berr_counter = usb_8dev_get_berr_counter;929 priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |930 CAN_CTRLMODE_LISTENONLY |931 CAN_CTRLMODE_ONE_SHOT |932 CAN_CTRLMODE_CC_LEN8_DLC;933 934 netdev->netdev_ops = &usb_8dev_netdev_ops;935 netdev->ethtool_ops = &usb_8dev_ethtool_ops;936 937 netdev->flags |= IFF_ECHO; /* we support local echo */938 939 init_usb_anchor(&priv->rx_submitted);940 941 init_usb_anchor(&priv->tx_submitted);942 atomic_set(&priv->active_tx_urbs, 0);943 944 for (i = 0; i < MAX_TX_URBS; i++)945 priv->tx_contexts[i].echo_index = MAX_TX_URBS;946 947 priv->cmd_msg_buffer = devm_kzalloc(&intf->dev, sizeof(struct usb_8dev_cmd_msg),948 GFP_KERNEL);949 if (!priv->cmd_msg_buffer)950 goto cleanup_candev;951 952 usb_set_intfdata(intf, priv);953 954 SET_NETDEV_DEV(netdev, &intf->dev);955 956 mutex_init(&priv->usb_8dev_cmd_lock);957 958 err = register_candev(netdev);959 if (err) {960 netdev_err(netdev,961 "couldn't register CAN device: %d\n", err);962 goto cleanup_candev;963 }964 965 err = usb_8dev_cmd_version(priv, &version);966 if (err) {967 netdev_err(netdev, "can't get firmware version\n");968 goto cleanup_unregister_candev;969 } else {970 netdev_info(netdev,971 "firmware: %d.%d, hardware: %d.%d\n",972 (version>>24) & 0xff, (version>>16) & 0xff,973 (version>>8) & 0xff, version & 0xff);974 }975 976 return 0;977 978cleanup_unregister_candev:979 unregister_netdev(priv->netdev);980 981cleanup_candev:982 free_candev(netdev);983 984 return err;985 986}987 988/* Called by the usb core when driver is unloaded or device is removed */989static void usb_8dev_disconnect(struct usb_interface *intf)990{991 struct usb_8dev_priv *priv = usb_get_intfdata(intf);992 993 usb_set_intfdata(intf, NULL);994 995 if (priv) {996 netdev_info(priv->netdev, "device disconnected\n");997 998 unregister_netdev(priv->netdev);999 unlink_all_urbs(priv);1000 free_candev(priv->netdev);1001 }1002 1003}1004 1005static struct usb_driver usb_8dev_driver = {1006 .name = KBUILD_MODNAME,1007 .probe = usb_8dev_probe,1008 .disconnect = usb_8dev_disconnect,1009 .id_table = usb_8dev_table,1010};1011 1012module_usb_driver(usb_8dev_driver);1013 1014MODULE_AUTHOR("Bernd Krumboeck <krumboeck@universalnet.at>");1015MODULE_DESCRIPTION("CAN driver for 8 devices USB2CAN interfaces");1016MODULE_LICENSE("GPL v2");1017