Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * CAN driver for "8 devices" USB2CAN converter
0004  *
0005  * Copyright (C) 2012 Bernd Krumboeck (krumboeck@universalnet.at)
0006  *
0007  * This driver is inspired by the 3.2.0 version of drivers/net/can/usb/ems_usb.c
0008  * and drivers/net/can/usb/esd_usb2.c
0009  *
0010  * Many thanks to Gerhard Bertelsmann (info@gerhard-bertelsmann.de)
0011  * for testing and fixing this driver. Also many thanks to "8 devices",
0012  * who were very cooperative and answered my questions.
0013  */
0014 
0015 #include <linux/ethtool.h>
0016 #include <linux/signal.h>
0017 #include <linux/slab.h>
0018 #include <linux/module.h>
0019 #include <linux/netdevice.h>
0020 #include <linux/usb.h>
0021 
0022 #include <linux/can.h>
0023 #include <linux/can/dev.h>
0024 #include <linux/can/error.h>
0025 
0026 /* driver constants */
0027 #define MAX_RX_URBS         20
0028 #define MAX_TX_URBS         20
0029 #define RX_BUFFER_SIZE          64
0030 
0031 /* vendor and product id */
0032 #define USB_8DEV_VENDOR_ID      0x0483
0033 #define USB_8DEV_PRODUCT_ID     0x1234
0034 
0035 /* endpoints */
0036 enum usb_8dev_endpoint {
0037     USB_8DEV_ENDP_DATA_RX = 1,
0038     USB_8DEV_ENDP_DATA_TX,
0039     USB_8DEV_ENDP_CMD_RX,
0040     USB_8DEV_ENDP_CMD_TX
0041 };
0042 
0043 /* device CAN clock */
0044 #define USB_8DEV_ABP_CLOCK      32000000
0045 
0046 /* setup flags */
0047 #define USB_8DEV_SILENT         0x01
0048 #define USB_8DEV_LOOPBACK       0x02
0049 #define USB_8DEV_DISABLE_AUTO_RESTRANS  0x04
0050 #define USB_8DEV_STATUS_FRAME       0x08
0051 
0052 /* commands */
0053 enum usb_8dev_cmd {
0054     USB_8DEV_RESET = 1,
0055     USB_8DEV_OPEN,
0056     USB_8DEV_CLOSE,
0057     USB_8DEV_SET_SPEED,
0058     USB_8DEV_SET_MASK_FILTER,
0059     USB_8DEV_GET_STATUS,
0060     USB_8DEV_GET_STATISTICS,
0061     USB_8DEV_GET_SERIAL,
0062     USB_8DEV_GET_SOFTW_VER,
0063     USB_8DEV_GET_HARDW_VER,
0064     USB_8DEV_RESET_TIMESTAMP,
0065     USB_8DEV_GET_SOFTW_HARDW_VER
0066 };
0067 
0068 /* command options */
0069 #define USB_8DEV_BAUD_MANUAL        0x09
0070 #define USB_8DEV_CMD_START      0x11
0071 #define USB_8DEV_CMD_END        0x22
0072 
0073 #define USB_8DEV_CMD_SUCCESS        0
0074 #define USB_8DEV_CMD_ERROR      255
0075 
0076 #define USB_8DEV_CMD_TIMEOUT        1000
0077 
0078 /* frames */
0079 #define USB_8DEV_DATA_START     0x55
0080 #define USB_8DEV_DATA_END       0xAA
0081 
0082 #define USB_8DEV_TYPE_CAN_FRAME     0
0083 #define USB_8DEV_TYPE_ERROR_FRAME   3
0084 
0085 #define USB_8DEV_EXTID          0x01
0086 #define USB_8DEV_RTR            0x02
0087 #define USB_8DEV_ERR_FLAG       0x04
0088 
0089 /* status */
0090 #define USB_8DEV_STATUSMSG_OK       0x00  /* Normal condition. */
0091 #define USB_8DEV_STATUSMSG_OVERRUN  0x01  /* Overrun occurred when sending */
0092 #define USB_8DEV_STATUSMSG_BUSLIGHT 0x02  /* Error counter has reached 96 */
0093 #define USB_8DEV_STATUSMSG_BUSHEAVY 0x03  /* Error count. has reached 128 */
0094 #define USB_8DEV_STATUSMSG_BUSOFF   0x04  /* Device is in BUSOFF */
0095 #define USB_8DEV_STATUSMSG_STUFF    0x20  /* Stuff Error */
0096 #define USB_8DEV_STATUSMSG_FORM     0x21  /* Form Error */
0097 #define USB_8DEV_STATUSMSG_ACK      0x23  /* Ack Error */
0098 #define USB_8DEV_STATUSMSG_BIT0     0x24  /* Bit1 Error */
0099 #define USB_8DEV_STATUSMSG_BIT1     0x25  /* Bit0 Error */
0100 #define USB_8DEV_STATUSMSG_CRC      0x27  /* CRC Error */
0101 
0102 #define USB_8DEV_RP_MASK        0x7F  /* Mask for Receive Error Bit */
0103 
0104 
0105 /* table of devices that work with this driver */
0106 static const struct usb_device_id usb_8dev_table[] = {
0107     { USB_DEVICE(USB_8DEV_VENDOR_ID, USB_8DEV_PRODUCT_ID) },
0108     { }                 /* Terminating entry */
0109 };
0110 
0111 MODULE_DEVICE_TABLE(usb, usb_8dev_table);
0112 
0113 struct usb_8dev_tx_urb_context {
0114     struct usb_8dev_priv *priv;
0115 
0116     u32 echo_index;
0117 };
0118 
0119 /* Structure to hold all of our device specific stuff */
0120 struct usb_8dev_priv {
0121     struct can_priv can; /* must be the first member */
0122 
0123     struct usb_device *udev;
0124     struct net_device *netdev;
0125 
0126     atomic_t active_tx_urbs;
0127     struct usb_anchor tx_submitted;
0128     struct usb_8dev_tx_urb_context tx_contexts[MAX_TX_URBS];
0129 
0130     struct usb_anchor rx_submitted;
0131 
0132     struct can_berr_counter bec;
0133 
0134     u8 *cmd_msg_buffer;
0135 
0136     struct mutex usb_8dev_cmd_lock;
0137     void *rxbuf[MAX_RX_URBS];
0138     dma_addr_t rxbuf_dma[MAX_RX_URBS];
0139 };
0140 
0141 /* tx frame */
0142 struct __packed usb_8dev_tx_msg {
0143     u8 begin;
0144     u8 flags;   /* RTR and EXT_ID flag */
0145     __be32 id;  /* upper 3 bits not used */
0146     u8 dlc;     /* data length code 0-8 bytes */
0147     u8 data[8]; /* 64-bit data */
0148     u8 end;
0149 };
0150 
0151 /* rx frame */
0152 struct __packed usb_8dev_rx_msg {
0153     u8 begin;
0154     u8 type;        /* frame type */
0155     u8 flags;       /* RTR and EXT_ID flag */
0156     __be32 id;      /* upper 3 bits not used */
0157     u8 dlc;         /* data length code 0-8 bytes */
0158     u8 data[8];     /* 64-bit data */
0159     __be32 timestamp;   /* 32-bit timestamp */
0160     u8 end;
0161 };
0162 
0163 /* command frame */
0164 struct __packed usb_8dev_cmd_msg {
0165     u8 begin;
0166     u8 channel; /* unknown - always 0 */
0167     u8 command; /* command to execute */
0168     u8 opt1;    /* optional parameter / return value */
0169     u8 opt2;    /* optional parameter 2 */
0170     u8 data[10];    /* optional parameter and data */
0171     u8 end;
0172 };
0173 
0174 static int usb_8dev_send_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size)
0175 {
0176     int actual_length;
0177 
0178     return usb_bulk_msg(priv->udev,
0179                 usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_TX),
0180                 msg, size, &actual_length, USB_8DEV_CMD_TIMEOUT);
0181 }
0182 
0183 static int usb_8dev_wait_cmd_msg(struct usb_8dev_priv *priv, u8 *msg, int size,
0184                 int *actual_length)
0185 {
0186     return usb_bulk_msg(priv->udev,
0187                 usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_CMD_RX),
0188                 msg, size, actual_length, USB_8DEV_CMD_TIMEOUT);
0189 }
0190 
0191 /* Send command to device and receive result.
0192  * Command was successful when opt1 = 0.
0193  */
0194 static int usb_8dev_send_cmd(struct usb_8dev_priv *priv,
0195                  struct usb_8dev_cmd_msg *out,
0196                  struct usb_8dev_cmd_msg *in)
0197 {
0198     int err;
0199     int num_bytes_read;
0200     struct net_device *netdev;
0201 
0202     netdev = priv->netdev;
0203 
0204     out->begin = USB_8DEV_CMD_START;
0205     out->end = USB_8DEV_CMD_END;
0206 
0207     mutex_lock(&priv->usb_8dev_cmd_lock);
0208 
0209     memcpy(priv->cmd_msg_buffer, out,
0210         sizeof(struct usb_8dev_cmd_msg));
0211 
0212     err = usb_8dev_send_cmd_msg(priv, priv->cmd_msg_buffer,
0213                     sizeof(struct usb_8dev_cmd_msg));
0214     if (err < 0) {
0215         netdev_err(netdev, "sending command message failed\n");
0216         goto failed;
0217     }
0218 
0219     err = usb_8dev_wait_cmd_msg(priv, priv->cmd_msg_buffer,
0220                     sizeof(struct usb_8dev_cmd_msg),
0221                     &num_bytes_read);
0222     if (err < 0) {
0223         netdev_err(netdev, "no command message answer\n");
0224         goto failed;
0225     }
0226 
0227     memcpy(in, priv->cmd_msg_buffer, sizeof(struct usb_8dev_cmd_msg));
0228 
0229     if (in->begin != USB_8DEV_CMD_START || in->end != USB_8DEV_CMD_END ||
0230             num_bytes_read != 16 || in->opt1 != 0)
0231         err = -EPROTO;
0232 
0233 failed:
0234     mutex_unlock(&priv->usb_8dev_cmd_lock);
0235     return err;
0236 }
0237 
0238 /* Send open command to device */
0239 static int usb_8dev_cmd_open(struct usb_8dev_priv *priv)
0240 {
0241     struct can_bittiming *bt = &priv->can.bittiming;
0242     struct usb_8dev_cmd_msg outmsg;
0243     struct usb_8dev_cmd_msg inmsg;
0244     u32 ctrlmode = priv->can.ctrlmode;
0245     u32 flags = USB_8DEV_STATUS_FRAME;
0246     __be32 beflags;
0247     __be16 bebrp;
0248 
0249     memset(&outmsg, 0, sizeof(outmsg));
0250     outmsg.command = USB_8DEV_OPEN;
0251     outmsg.opt1 = USB_8DEV_BAUD_MANUAL;
0252     outmsg.data[0] = bt->prop_seg + bt->phase_seg1;
0253     outmsg.data[1] = bt->phase_seg2;
0254     outmsg.data[2] = bt->sjw;
0255 
0256     /* BRP */
0257     bebrp = cpu_to_be16((u16)bt->brp);
0258     memcpy(&outmsg.data[3], &bebrp, sizeof(bebrp));
0259 
0260     /* flags */
0261     if (ctrlmode & CAN_CTRLMODE_LOOPBACK)
0262         flags |= USB_8DEV_LOOPBACK;
0263     if (ctrlmode & CAN_CTRLMODE_LISTENONLY)
0264         flags |= USB_8DEV_SILENT;
0265     if (ctrlmode & CAN_CTRLMODE_ONE_SHOT)
0266         flags |= USB_8DEV_DISABLE_AUTO_RESTRANS;
0267 
0268     beflags = cpu_to_be32(flags);
0269     memcpy(&outmsg.data[5], &beflags, sizeof(beflags));
0270 
0271     return usb_8dev_send_cmd(priv, &outmsg, &inmsg);
0272 }
0273 
0274 /* Send close command to device */
0275 static int usb_8dev_cmd_close(struct usb_8dev_priv *priv)
0276 {
0277     struct usb_8dev_cmd_msg inmsg;
0278     struct usb_8dev_cmd_msg outmsg = {
0279         .channel = 0,
0280         .command = USB_8DEV_CLOSE,
0281         .opt1 = 0,
0282         .opt2 = 0
0283     };
0284 
0285     return usb_8dev_send_cmd(priv, &outmsg, &inmsg);
0286 }
0287 
0288 /* Get firmware and hardware version */
0289 static int usb_8dev_cmd_version(struct usb_8dev_priv *priv, u32 *res)
0290 {
0291     struct usb_8dev_cmd_msg inmsg;
0292     struct usb_8dev_cmd_msg outmsg = {
0293         .channel = 0,
0294         .command = USB_8DEV_GET_SOFTW_HARDW_VER,
0295         .opt1 = 0,
0296         .opt2 = 0
0297     };
0298 
0299     int err = usb_8dev_send_cmd(priv, &outmsg, &inmsg);
0300     if (err)
0301         return err;
0302 
0303     *res = be32_to_cpup((__be32 *)inmsg.data);
0304 
0305     return err;
0306 }
0307 
0308 /* Set network device mode
0309  *
0310  * Maybe we should leave this function empty, because the device
0311  * set mode variable with open command.
0312  */
0313 static int usb_8dev_set_mode(struct net_device *netdev, enum can_mode mode)
0314 {
0315     struct usb_8dev_priv *priv = netdev_priv(netdev);
0316     int err = 0;
0317 
0318     switch (mode) {
0319     case CAN_MODE_START:
0320         err = usb_8dev_cmd_open(priv);
0321         if (err)
0322             netdev_warn(netdev, "couldn't start device");
0323         break;
0324 
0325     default:
0326         return -EOPNOTSUPP;
0327     }
0328 
0329     return err;
0330 }
0331 
0332 /* Read error/status frames */
0333 static void usb_8dev_rx_err_msg(struct usb_8dev_priv *priv,
0334                 struct usb_8dev_rx_msg *msg)
0335 {
0336     struct can_frame *cf;
0337     struct sk_buff *skb;
0338     struct net_device_stats *stats = &priv->netdev->stats;
0339 
0340     /* Error message:
0341      * byte 0: Status
0342      * byte 1: bit   7: Receive Passive
0343      * byte 1: bit 0-6: Receive Error Counter
0344      * byte 2: Transmit Error Counter
0345      * byte 3: Always 0 (maybe reserved for future use)
0346      */
0347 
0348     u8 state = msg->data[0];
0349     u8 rxerr = msg->data[1] & USB_8DEV_RP_MASK;
0350     u8 txerr = msg->data[2];
0351     int rx_errors = 0;
0352     int tx_errors = 0;
0353 
0354     skb = alloc_can_err_skb(priv->netdev, &cf);
0355     if (!skb)
0356         return;
0357 
0358     switch (state) {
0359     case USB_8DEV_STATUSMSG_OK:
0360         priv->can.state = CAN_STATE_ERROR_ACTIVE;
0361         cf->can_id |= CAN_ERR_PROT;
0362         cf->data[2] = CAN_ERR_PROT_ACTIVE;
0363         break;
0364     case USB_8DEV_STATUSMSG_BUSOFF:
0365         priv->can.state = CAN_STATE_BUS_OFF;
0366         cf->can_id |= CAN_ERR_BUSOFF;
0367         priv->can.can_stats.bus_off++;
0368         can_bus_off(priv->netdev);
0369         break;
0370     case USB_8DEV_STATUSMSG_OVERRUN:
0371     case USB_8DEV_STATUSMSG_BUSLIGHT:
0372     case USB_8DEV_STATUSMSG_BUSHEAVY:
0373         cf->can_id |= CAN_ERR_CRTL;
0374         break;
0375     default:
0376         priv->can.state = CAN_STATE_ERROR_WARNING;
0377         cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
0378         priv->can.can_stats.bus_error++;
0379         break;
0380     }
0381 
0382     switch (state) {
0383     case USB_8DEV_STATUSMSG_OK:
0384     case USB_8DEV_STATUSMSG_BUSOFF:
0385         break;
0386     case USB_8DEV_STATUSMSG_ACK:
0387         cf->can_id |= CAN_ERR_ACK;
0388         tx_errors = 1;
0389         break;
0390     case USB_8DEV_STATUSMSG_CRC:
0391         cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
0392         rx_errors = 1;
0393         break;
0394     case USB_8DEV_STATUSMSG_BIT0:
0395         cf->data[2] |= CAN_ERR_PROT_BIT0;
0396         tx_errors = 1;
0397         break;
0398     case USB_8DEV_STATUSMSG_BIT1:
0399         cf->data[2] |= CAN_ERR_PROT_BIT1;
0400         tx_errors = 1;
0401         break;
0402     case USB_8DEV_STATUSMSG_FORM:
0403         cf->data[2] |= CAN_ERR_PROT_FORM;
0404         rx_errors = 1;
0405         break;
0406     case USB_8DEV_STATUSMSG_STUFF:
0407         cf->data[2] |= CAN_ERR_PROT_STUFF;
0408         rx_errors = 1;
0409         break;
0410     case USB_8DEV_STATUSMSG_OVERRUN:
0411         cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
0412         stats->rx_over_errors++;
0413         rx_errors = 1;
0414         break;
0415     case USB_8DEV_STATUSMSG_BUSLIGHT:
0416         priv->can.state = CAN_STATE_ERROR_WARNING;
0417         cf->data[1] = (txerr > rxerr) ?
0418             CAN_ERR_CRTL_TX_WARNING :
0419             CAN_ERR_CRTL_RX_WARNING;
0420         priv->can.can_stats.error_warning++;
0421         break;
0422     case USB_8DEV_STATUSMSG_BUSHEAVY:
0423         priv->can.state = CAN_STATE_ERROR_PASSIVE;
0424         cf->data[1] = (txerr > rxerr) ?
0425             CAN_ERR_CRTL_TX_PASSIVE :
0426             CAN_ERR_CRTL_RX_PASSIVE;
0427         priv->can.can_stats.error_passive++;
0428         break;
0429     default:
0430         netdev_warn(priv->netdev,
0431                 "Unknown status/error message (%d)\n", state);
0432         break;
0433     }
0434 
0435     if (tx_errors) {
0436         cf->data[2] |= CAN_ERR_PROT_TX;
0437         stats->tx_errors++;
0438     }
0439 
0440     if (rx_errors)
0441         stats->rx_errors++;
0442     if (priv->can.state != CAN_STATE_BUS_OFF) {
0443         cf->can_id |= CAN_ERR_CNT;
0444         cf->data[6] = txerr;
0445         cf->data[7] = rxerr;
0446     }
0447 
0448     priv->bec.txerr = txerr;
0449     priv->bec.rxerr = rxerr;
0450 
0451     netif_rx(skb);
0452 }
0453 
0454 /* Read data and status frames */
0455 static void usb_8dev_rx_can_msg(struct usb_8dev_priv *priv,
0456                 struct usb_8dev_rx_msg *msg)
0457 {
0458     struct can_frame *cf;
0459     struct sk_buff *skb;
0460     struct net_device_stats *stats = &priv->netdev->stats;
0461 
0462     if (msg->type == USB_8DEV_TYPE_ERROR_FRAME &&
0463            msg->flags == USB_8DEV_ERR_FLAG) {
0464         usb_8dev_rx_err_msg(priv, msg);
0465     } else if (msg->type == USB_8DEV_TYPE_CAN_FRAME) {
0466         skb = alloc_can_skb(priv->netdev, &cf);
0467         if (!skb)
0468             return;
0469 
0470         cf->can_id = be32_to_cpu(msg->id);
0471         can_frame_set_cc_len(cf, msg->dlc & 0xF, priv->can.ctrlmode);
0472 
0473         if (msg->flags & USB_8DEV_EXTID)
0474             cf->can_id |= CAN_EFF_FLAG;
0475 
0476         if (msg->flags & USB_8DEV_RTR) {
0477             cf->can_id |= CAN_RTR_FLAG;
0478         } else {
0479             memcpy(cf->data, msg->data, cf->len);
0480             stats->rx_bytes += cf->len;
0481         }
0482         stats->rx_packets++;
0483 
0484         netif_rx(skb);
0485     } else {
0486         netdev_warn(priv->netdev, "frame type %d unknown",
0487              msg->type);
0488     }
0489 
0490 }
0491 
0492 /* Callback for reading data from device
0493  *
0494  * Check urb status, call read function and resubmit urb read operation.
0495  */
0496 static void usb_8dev_read_bulk_callback(struct urb *urb)
0497 {
0498     struct usb_8dev_priv *priv = urb->context;
0499     struct net_device *netdev;
0500     int retval;
0501     int pos = 0;
0502 
0503     netdev = priv->netdev;
0504 
0505     if (!netif_device_present(netdev))
0506         return;
0507 
0508     switch (urb->status) {
0509     case 0: /* success */
0510         break;
0511 
0512     case -ENOENT:
0513     case -EPIPE:
0514     case -EPROTO:
0515     case -ESHUTDOWN:
0516         return;
0517 
0518     default:
0519         netdev_info(netdev, "Rx URB aborted (%d)\n",
0520              urb->status);
0521         goto resubmit_urb;
0522     }
0523 
0524     while (pos < urb->actual_length) {
0525         struct usb_8dev_rx_msg *msg;
0526 
0527         if (pos + sizeof(struct usb_8dev_rx_msg) > urb->actual_length) {
0528             netdev_err(priv->netdev, "format error\n");
0529             break;
0530         }
0531 
0532         msg = (struct usb_8dev_rx_msg *)(urb->transfer_buffer + pos);
0533         usb_8dev_rx_can_msg(priv, msg);
0534 
0535         pos += sizeof(struct usb_8dev_rx_msg);
0536     }
0537 
0538 resubmit_urb:
0539     usb_fill_bulk_urb(urb, priv->udev,
0540               usb_rcvbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_RX),
0541               urb->transfer_buffer, RX_BUFFER_SIZE,
0542               usb_8dev_read_bulk_callback, priv);
0543 
0544     retval = usb_submit_urb(urb, GFP_ATOMIC);
0545 
0546     if (retval == -ENODEV)
0547         netif_device_detach(netdev);
0548     else if (retval)
0549         netdev_err(netdev,
0550             "failed resubmitting read bulk urb: %d\n", retval);
0551 }
0552 
0553 /* Callback handler for write operations
0554  *
0555  * Free allocated buffers, check transmit status and
0556  * calculate statistic.
0557  */
0558 static void usb_8dev_write_bulk_callback(struct urb *urb)
0559 {
0560     struct usb_8dev_tx_urb_context *context = urb->context;
0561     struct usb_8dev_priv *priv;
0562     struct net_device *netdev;
0563 
0564     BUG_ON(!context);
0565 
0566     priv = context->priv;
0567     netdev = priv->netdev;
0568 
0569     /* free up our allocated buffer */
0570     usb_free_coherent(urb->dev, urb->transfer_buffer_length,
0571               urb->transfer_buffer, urb->transfer_dma);
0572 
0573     atomic_dec(&priv->active_tx_urbs);
0574 
0575     if (!netif_device_present(netdev))
0576         return;
0577 
0578     if (urb->status)
0579         netdev_info(netdev, "Tx URB aborted (%d)\n",
0580              urb->status);
0581 
0582     netdev->stats.tx_packets++;
0583     netdev->stats.tx_bytes += can_get_echo_skb(netdev, context->echo_index, NULL);
0584 
0585     /* Release context */
0586     context->echo_index = MAX_TX_URBS;
0587 
0588     netif_wake_queue(netdev);
0589 }
0590 
0591 /* Send data to device */
0592 static netdev_tx_t usb_8dev_start_xmit(struct sk_buff *skb,
0593                       struct net_device *netdev)
0594 {
0595     struct usb_8dev_priv *priv = netdev_priv(netdev);
0596     struct net_device_stats *stats = &netdev->stats;
0597     struct can_frame *cf = (struct can_frame *) skb->data;
0598     struct usb_8dev_tx_msg *msg;
0599     struct urb *urb;
0600     struct usb_8dev_tx_urb_context *context = NULL;
0601     u8 *buf;
0602     int i, err;
0603     size_t size = sizeof(struct usb_8dev_tx_msg);
0604 
0605     if (can_dropped_invalid_skb(netdev, skb))
0606         return NETDEV_TX_OK;
0607 
0608     /* create a URB, and a buffer for it, and copy the data to the URB */
0609     urb = usb_alloc_urb(0, GFP_ATOMIC);
0610     if (!urb)
0611         goto nomem;
0612 
0613     buf = usb_alloc_coherent(priv->udev, size, GFP_ATOMIC,
0614                  &urb->transfer_dma);
0615     if (!buf) {
0616         netdev_err(netdev, "No memory left for USB buffer\n");
0617         goto nomembuf;
0618     }
0619 
0620     memset(buf, 0, size);
0621 
0622     msg = (struct usb_8dev_tx_msg *)buf;
0623     msg->begin = USB_8DEV_DATA_START;
0624     msg->flags = 0x00;
0625 
0626     if (cf->can_id & CAN_RTR_FLAG)
0627         msg->flags |= USB_8DEV_RTR;
0628 
0629     if (cf->can_id & CAN_EFF_FLAG)
0630         msg->flags |= USB_8DEV_EXTID;
0631 
0632     msg->id = cpu_to_be32(cf->can_id & CAN_ERR_MASK);
0633     msg->dlc = can_get_cc_dlc(cf, priv->can.ctrlmode);
0634     memcpy(msg->data, cf->data, cf->len);
0635     msg->end = USB_8DEV_DATA_END;
0636 
0637     for (i = 0; i < MAX_TX_URBS; i++) {
0638         if (priv->tx_contexts[i].echo_index == MAX_TX_URBS) {
0639             context = &priv->tx_contexts[i];
0640             break;
0641         }
0642     }
0643 
0644     /* May never happen! When this happens we'd more URBs in flight as
0645      * allowed (MAX_TX_URBS).
0646      */
0647     if (!context)
0648         goto nofreecontext;
0649 
0650     context->priv = priv;
0651     context->echo_index = i;
0652 
0653     usb_fill_bulk_urb(urb, priv->udev,
0654               usb_sndbulkpipe(priv->udev, USB_8DEV_ENDP_DATA_TX),
0655               buf, size, usb_8dev_write_bulk_callback, context);
0656     urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
0657     usb_anchor_urb(urb, &priv->tx_submitted);
0658 
0659     can_put_echo_skb(skb, netdev, context->echo_index, 0);
0660 
0661     atomic_inc(&priv->active_tx_urbs);
0662 
0663     err = usb_submit_urb(urb, GFP_ATOMIC);
0664     if (unlikely(err)) {
0665         can_free_echo_skb(netdev, context->echo_index, NULL);
0666 
0667         usb_unanchor_urb(urb);
0668         usb_free_coherent(priv->udev, size, buf, urb->transfer_dma);
0669 
0670         atomic_dec(&priv->active_tx_urbs);
0671 
0672         if (err == -ENODEV)
0673             netif_device_detach(netdev);
0674         else
0675             netdev_warn(netdev, "failed tx_urb %d\n", err);
0676         stats->tx_dropped++;
0677     } else if (atomic_read(&priv->active_tx_urbs) >= MAX_TX_URBS)
0678         /* Slow down tx path */
0679         netif_stop_queue(netdev);
0680 
0681     /* Release our reference to this URB, the USB core will eventually free
0682      * it entirely.
0683      */
0684     usb_free_urb(urb);
0685 
0686     return NETDEV_TX_OK;
0687 
0688 nofreecontext:
0689     usb_free_coherent(priv->udev, size, buf, urb->transfer_dma);
0690     usb_free_urb(urb);
0691 
0692     netdev_warn(netdev, "couldn't find free context");
0693 
0694     return NETDEV_TX_BUSY;
0695 
0696 nomembuf:
0697     usb_free_urb(urb);
0698 
0699 nomem:
0700     dev_kfree_skb(skb);
0701     stats->tx_dropped++;
0702 
0703     return NETDEV_TX_OK;
0704 }
0705 
0706 static int usb_8dev_get_berr_counter(const struct net_device *netdev,
0707                      struct can_berr_counter *bec)
0708 {
0709     struct usb_8dev_priv *priv = netdev_priv(netdev);
0710 
0711     bec->txerr = priv->bec.txerr;
0712     bec->rxerr = priv->bec.rxerr;
0713 
0714     return 0;
0715 }
0716 
0717 /* Start USB device */
0718 static int usb_8dev_start(struct usb_8dev_priv *priv)
0719 {
0720     struct net_device *netdev = priv->netdev;
0721     int err, i;
0722 
0723     for (i = 0; i < MAX_RX_URBS; i++) {
0724         struct urb *urb = NULL;
0725         u8 *buf;
0726         dma_addr_t buf_dma;
0727 
0728         /* create a URB, and a buffer for it */
0729         urb = usb_alloc_urb(0, GFP_KERNEL);
0730         if (!urb) {
0731             err = -ENOMEM;
0732             break;
0733         }
0734 
0735         buf = usb_alloc_coherent(priv->udev, RX_BUFFER_SIZE, GFP_KERNEL,
0736                      &buf_dma);
0737         if (!buf) {
0738             netdev_err(netdev, "No memory left for USB buffer\n");
0739             usb_free_urb(urb);
0740             err = -ENOMEM;
0741             break;
0742         }
0743 
0744         urb->transfer_dma = buf_dma;
0745 
0746         usb_fill_bulk_urb(urb, priv->udev,
0747                   usb_rcvbulkpipe(priv->udev,
0748                           USB_8DEV_ENDP_DATA_RX),
0749                   buf, RX_BUFFER_SIZE,
0750                   usb_8dev_read_bulk_callback, priv);
0751         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
0752         usb_anchor_urb(urb, &priv->rx_submitted);
0753 
0754         err = usb_submit_urb(urb, GFP_KERNEL);
0755         if (err) {
0756             usb_unanchor_urb(urb);
0757             usb_free_coherent(priv->udev, RX_BUFFER_SIZE, buf,
0758                       urb->transfer_dma);
0759             usb_free_urb(urb);
0760             break;
0761         }
0762 
0763         priv->rxbuf[i] = buf;
0764         priv->rxbuf_dma[i] = buf_dma;
0765 
0766         /* Drop reference, USB core will take care of freeing it */
0767         usb_free_urb(urb);
0768     }
0769 
0770     /* Did we submit any URBs */
0771     if (i == 0) {
0772         netdev_warn(netdev, "couldn't setup read URBs\n");
0773         return err;
0774     }
0775 
0776     /* Warn if we've couldn't transmit all the URBs */
0777     if (i < MAX_RX_URBS)
0778         netdev_warn(netdev, "rx performance may be slow\n");
0779 
0780     err = usb_8dev_cmd_open(priv);
0781     if (err)
0782         goto failed;
0783 
0784     priv->can.state = CAN_STATE_ERROR_ACTIVE;
0785 
0786     return 0;
0787 
0788 failed:
0789     if (err == -ENODEV)
0790         netif_device_detach(priv->netdev);
0791 
0792     netdev_warn(netdev, "couldn't submit control: %d\n", err);
0793 
0794     return err;
0795 }
0796 
0797 /* Open USB device */
0798 static int usb_8dev_open(struct net_device *netdev)
0799 {
0800     struct usb_8dev_priv *priv = netdev_priv(netdev);
0801     int err;
0802 
0803     /* common open */
0804     err = open_candev(netdev);
0805     if (err)
0806         return err;
0807 
0808     /* finally start device */
0809     err = usb_8dev_start(priv);
0810     if (err) {
0811         if (err == -ENODEV)
0812             netif_device_detach(priv->netdev);
0813 
0814         netdev_warn(netdev, "couldn't start device: %d\n",
0815              err);
0816 
0817         close_candev(netdev);
0818 
0819         return err;
0820     }
0821 
0822     netif_start_queue(netdev);
0823 
0824     return 0;
0825 }
0826 
0827 static void unlink_all_urbs(struct usb_8dev_priv *priv)
0828 {
0829     int i;
0830 
0831     usb_kill_anchored_urbs(&priv->rx_submitted);
0832 
0833     for (i = 0; i < MAX_RX_URBS; ++i)
0834         usb_free_coherent(priv->udev, RX_BUFFER_SIZE,
0835                   priv->rxbuf[i], priv->rxbuf_dma[i]);
0836 
0837     usb_kill_anchored_urbs(&priv->tx_submitted);
0838     atomic_set(&priv->active_tx_urbs, 0);
0839 
0840     for (i = 0; i < MAX_TX_URBS; i++)
0841         priv->tx_contexts[i].echo_index = MAX_TX_URBS;
0842 }
0843 
0844 /* Close USB device */
0845 static int usb_8dev_close(struct net_device *netdev)
0846 {
0847     struct usb_8dev_priv *priv = netdev_priv(netdev);
0848     int err = 0;
0849 
0850     /* Send CLOSE command to CAN controller */
0851     err = usb_8dev_cmd_close(priv);
0852     if (err)
0853         netdev_warn(netdev, "couldn't stop device");
0854 
0855     priv->can.state = CAN_STATE_STOPPED;
0856 
0857     netif_stop_queue(netdev);
0858 
0859     /* Stop polling */
0860     unlink_all_urbs(priv);
0861 
0862     close_candev(netdev);
0863 
0864     return err;
0865 }
0866 
0867 static const struct net_device_ops usb_8dev_netdev_ops = {
0868     .ndo_open = usb_8dev_open,
0869     .ndo_stop = usb_8dev_close,
0870     .ndo_start_xmit = usb_8dev_start_xmit,
0871     .ndo_change_mtu = can_change_mtu,
0872 };
0873 
0874 static const struct ethtool_ops usb_8dev_ethtool_ops = {
0875     .get_ts_info = ethtool_op_get_ts_info,
0876 };
0877 
0878 static const struct can_bittiming_const usb_8dev_bittiming_const = {
0879     .name = KBUILD_MODNAME,
0880     .tseg1_min = 1,
0881     .tseg1_max = 16,
0882     .tseg2_min = 1,
0883     .tseg2_max = 8,
0884     .sjw_max = 4,
0885     .brp_min = 1,
0886     .brp_max = 1024,
0887     .brp_inc = 1,
0888 };
0889 
0890 /* Probe USB device
0891  *
0892  * Check device and firmware.
0893  * Set supported modes and bittiming constants.
0894  * Allocate some memory.
0895  */
0896 static int usb_8dev_probe(struct usb_interface *intf,
0897              const struct usb_device_id *id)
0898 {
0899     struct net_device *netdev;
0900     struct usb_8dev_priv *priv;
0901     int i, err = -ENOMEM;
0902     u32 version;
0903     char buf[18];
0904     struct usb_device *usbdev = interface_to_usbdev(intf);
0905 
0906     /* product id looks strange, better we also check iProduct string */
0907     if (usb_string(usbdev, usbdev->descriptor.iProduct, buf,
0908                sizeof(buf)) > 0 && strcmp(buf, "USB2CAN converter")) {
0909         dev_info(&usbdev->dev, "ignoring: not an USB2CAN converter\n");
0910         return -ENODEV;
0911     }
0912 
0913     netdev = alloc_candev(sizeof(struct usb_8dev_priv), MAX_TX_URBS);
0914     if (!netdev) {
0915         dev_err(&intf->dev, "Couldn't alloc candev\n");
0916         return -ENOMEM;
0917     }
0918 
0919     priv = netdev_priv(netdev);
0920 
0921     priv->udev = usbdev;
0922     priv->netdev = netdev;
0923 
0924     priv->can.state = CAN_STATE_STOPPED;
0925     priv->can.clock.freq = USB_8DEV_ABP_CLOCK;
0926     priv->can.bittiming_const = &usb_8dev_bittiming_const;
0927     priv->can.do_set_mode = usb_8dev_set_mode;
0928     priv->can.do_get_berr_counter = usb_8dev_get_berr_counter;
0929     priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
0930                       CAN_CTRLMODE_LISTENONLY |
0931                       CAN_CTRLMODE_ONE_SHOT |
0932                       CAN_CTRLMODE_CC_LEN8_DLC;
0933 
0934     netdev->netdev_ops = &usb_8dev_netdev_ops;
0935     netdev->ethtool_ops = &usb_8dev_ethtool_ops;
0936 
0937     netdev->flags |= IFF_ECHO; /* we support local echo */
0938 
0939     init_usb_anchor(&priv->rx_submitted);
0940 
0941     init_usb_anchor(&priv->tx_submitted);
0942     atomic_set(&priv->active_tx_urbs, 0);
0943 
0944     for (i = 0; i < MAX_TX_URBS; i++)
0945         priv->tx_contexts[i].echo_index = MAX_TX_URBS;
0946 
0947     priv->cmd_msg_buffer = devm_kzalloc(&intf->dev, sizeof(struct usb_8dev_cmd_msg),
0948                         GFP_KERNEL);
0949     if (!priv->cmd_msg_buffer)
0950         goto cleanup_candev;
0951 
0952     usb_set_intfdata(intf, priv);
0953 
0954     SET_NETDEV_DEV(netdev, &intf->dev);
0955 
0956     mutex_init(&priv->usb_8dev_cmd_lock);
0957 
0958     err = register_candev(netdev);
0959     if (err) {
0960         netdev_err(netdev,
0961             "couldn't register CAN device: %d\n", err);
0962         goto cleanup_candev;
0963     }
0964 
0965     err = usb_8dev_cmd_version(priv, &version);
0966     if (err) {
0967         netdev_err(netdev, "can't get firmware version\n");
0968         goto cleanup_unregister_candev;
0969     } else {
0970         netdev_info(netdev,
0971              "firmware: %d.%d, hardware: %d.%d\n",
0972              (version>>24) & 0xff, (version>>16) & 0xff,
0973              (version>>8) & 0xff, version & 0xff);
0974     }
0975 
0976     return 0;
0977 
0978 cleanup_unregister_candev:
0979     unregister_netdev(priv->netdev);
0980 
0981 cleanup_candev:
0982     free_candev(netdev);
0983 
0984     return err;
0985 
0986 }
0987 
0988 /* Called by the usb core when driver is unloaded or device is removed */
0989 static void usb_8dev_disconnect(struct usb_interface *intf)
0990 {
0991     struct usb_8dev_priv *priv = usb_get_intfdata(intf);
0992 
0993     usb_set_intfdata(intf, NULL);
0994 
0995     if (priv) {
0996         netdev_info(priv->netdev, "device disconnected\n");
0997 
0998         unregister_netdev(priv->netdev);
0999         unlink_all_urbs(priv);
1000         free_candev(priv->netdev);
1001     }
1002 
1003 }
1004 
1005 static 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 
1012 module_usb_driver(usb_8dev_driver);
1013 
1014 MODULE_AUTHOR("Bernd Krumboeck <krumboeck@universalnet.at>");
1015 MODULE_DESCRIPTION("CAN driver for 8 devices USB2CAN interfaces");
1016 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!