Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Parts of this driver are based on the following:
0003  *  - Kvaser linux leaf driver (version 4.78)
0004  *  - CAN driver for esd CAN-USB/2
0005  *  - Kvaser linux usbcanII driver (version 5.3)
0006  *
0007  * Copyright (C) 2002-2018 KVASER AB, Sweden. All rights reserved.
0008  * Copyright (C) 2010 Matthias Fuchs <matthias.fuchs@esd.eu>, esd gmbh
0009  * Copyright (C) 2012 Olivier Sobrie <olivier@sobrie.be>
0010  * Copyright (C) 2015 Valeo S.A.
0011  */
0012 
0013 #include <linux/completion.h>
0014 #include <linux/device.h>
0015 #include <linux/gfp.h>
0016 #include <linux/jiffies.h>
0017 #include <linux/kernel.h>
0018 #include <linux/netdevice.h>
0019 #include <linux/spinlock.h>
0020 #include <linux/string.h>
0021 #include <linux/types.h>
0022 #include <linux/units.h>
0023 #include <linux/usb.h>
0024 
0025 #include <linux/can.h>
0026 #include <linux/can/dev.h>
0027 #include <linux/can/error.h>
0028 #include <linux/can/netlink.h>
0029 
0030 #include "kvaser_usb.h"
0031 
0032 #define MAX_USBCAN_NET_DEVICES      2
0033 
0034 /* Command header size */
0035 #define CMD_HEADER_LEN          2
0036 
0037 /* Kvaser CAN message flags */
0038 #define MSG_FLAG_ERROR_FRAME        BIT(0)
0039 #define MSG_FLAG_OVERRUN        BIT(1)
0040 #define MSG_FLAG_NERR           BIT(2)
0041 #define MSG_FLAG_WAKEUP         BIT(3)
0042 #define MSG_FLAG_REMOTE_FRAME       BIT(4)
0043 #define MSG_FLAG_RESERVED       BIT(5)
0044 #define MSG_FLAG_TX_ACK         BIT(6)
0045 #define MSG_FLAG_TX_REQUEST     BIT(7)
0046 
0047 /* CAN states (M16C CxSTRH register) */
0048 #define M16C_STATE_BUS_RESET        BIT(0)
0049 #define M16C_STATE_BUS_ERROR        BIT(4)
0050 #define M16C_STATE_BUS_PASSIVE      BIT(5)
0051 #define M16C_STATE_BUS_OFF      BIT(6)
0052 
0053 /* Leaf/usbcan command ids */
0054 #define CMD_RX_STD_MESSAGE      12
0055 #define CMD_TX_STD_MESSAGE      13
0056 #define CMD_RX_EXT_MESSAGE      14
0057 #define CMD_TX_EXT_MESSAGE      15
0058 #define CMD_SET_BUS_PARAMS      16
0059 #define CMD_CHIP_STATE_EVENT        20
0060 #define CMD_SET_CTRL_MODE       21
0061 #define CMD_RESET_CHIP          24
0062 #define CMD_START_CHIP          26
0063 #define CMD_START_CHIP_REPLY        27
0064 #define CMD_STOP_CHIP           28
0065 #define CMD_STOP_CHIP_REPLY     29
0066 
0067 #define CMD_USBCAN_CLOCK_OVERFLOW_EVENT 33
0068 
0069 #define CMD_GET_CARD_INFO       34
0070 #define CMD_GET_CARD_INFO_REPLY     35
0071 #define CMD_GET_SOFTWARE_INFO       38
0072 #define CMD_GET_SOFTWARE_INFO_REPLY 39
0073 #define CMD_FLUSH_QUEUE         48
0074 #define CMD_TX_ACKNOWLEDGE      50
0075 #define CMD_CAN_ERROR_EVENT     51
0076 #define CMD_FLUSH_QUEUE_REPLY       68
0077 
0078 #define CMD_LEAF_LOG_MESSAGE        106
0079 
0080 /* Leaf frequency options */
0081 #define KVASER_USB_LEAF_SWOPTION_FREQ_MASK 0x60
0082 #define KVASER_USB_LEAF_SWOPTION_FREQ_16_MHZ_CLK 0
0083 #define KVASER_USB_LEAF_SWOPTION_FREQ_32_MHZ_CLK BIT(5)
0084 #define KVASER_USB_LEAF_SWOPTION_FREQ_24_MHZ_CLK BIT(6)
0085 
0086 /* error factors */
0087 #define M16C_EF_ACKE            BIT(0)
0088 #define M16C_EF_CRCE            BIT(1)
0089 #define M16C_EF_FORME           BIT(2)
0090 #define M16C_EF_STFE            BIT(3)
0091 #define M16C_EF_BITE0           BIT(4)
0092 #define M16C_EF_BITE1           BIT(5)
0093 #define M16C_EF_RCVE            BIT(6)
0094 #define M16C_EF_TRE         BIT(7)
0095 
0096 /* Only Leaf-based devices can report M16C error factors,
0097  * thus define our own error status flags for USBCANII
0098  */
0099 #define USBCAN_ERROR_STATE_NONE     0
0100 #define USBCAN_ERROR_STATE_TX_ERROR BIT(0)
0101 #define USBCAN_ERROR_STATE_RX_ERROR BIT(1)
0102 #define USBCAN_ERROR_STATE_BUSERROR BIT(2)
0103 
0104 /* ctrl modes */
0105 #define KVASER_CTRL_MODE_NORMAL     1
0106 #define KVASER_CTRL_MODE_SILENT     2
0107 #define KVASER_CTRL_MODE_SELFRECEPTION  3
0108 #define KVASER_CTRL_MODE_OFF        4
0109 
0110 /* Extended CAN identifier flag */
0111 #define KVASER_EXTENDED_FRAME       BIT(31)
0112 
0113 struct kvaser_cmd_simple {
0114     u8 tid;
0115     u8 channel;
0116 } __packed;
0117 
0118 struct kvaser_cmd_cardinfo {
0119     u8 tid;
0120     u8 nchannels;
0121     __le32 serial_number;
0122     __le32 padding0;
0123     __le32 clock_resolution;
0124     __le32 mfgdate;
0125     u8 ean[8];
0126     u8 hw_revision;
0127     union {
0128         struct {
0129             u8 usb_hs_mode;
0130         } __packed leaf1;
0131         struct {
0132             u8 padding;
0133         } __packed usbcan1;
0134     } __packed;
0135     __le16 padding1;
0136 } __packed;
0137 
0138 struct leaf_cmd_softinfo {
0139     u8 tid;
0140     u8 padding0;
0141     __le32 sw_options;
0142     __le32 fw_version;
0143     __le16 max_outstanding_tx;
0144     __le16 padding1[9];
0145 } __packed;
0146 
0147 struct usbcan_cmd_softinfo {
0148     u8 tid;
0149     u8 fw_name[5];
0150     __le16 max_outstanding_tx;
0151     u8 padding[6];
0152     __le32 fw_version;
0153     __le16 checksum;
0154     __le16 sw_options;
0155 } __packed;
0156 
0157 struct kvaser_cmd_busparams {
0158     u8 tid;
0159     u8 channel;
0160     __le32 bitrate;
0161     u8 tseg1;
0162     u8 tseg2;
0163     u8 sjw;
0164     u8 no_samp;
0165 } __packed;
0166 
0167 struct kvaser_cmd_tx_can {
0168     u8 channel;
0169     u8 tid;
0170     u8 data[14];
0171     union {
0172         struct {
0173             u8 padding;
0174             u8 flags;
0175         } __packed leaf;
0176         struct {
0177             u8 flags;
0178             u8 padding;
0179         } __packed usbcan;
0180     } __packed;
0181 } __packed;
0182 
0183 struct kvaser_cmd_rx_can_header {
0184     u8 channel;
0185     u8 flag;
0186 } __packed;
0187 
0188 struct leaf_cmd_rx_can {
0189     u8 channel;
0190     u8 flag;
0191 
0192     __le16 time[3];
0193     u8 data[14];
0194 } __packed;
0195 
0196 struct usbcan_cmd_rx_can {
0197     u8 channel;
0198     u8 flag;
0199 
0200     u8 data[14];
0201     __le16 time;
0202 } __packed;
0203 
0204 struct leaf_cmd_chip_state_event {
0205     u8 tid;
0206     u8 channel;
0207 
0208     __le16 time[3];
0209     u8 tx_errors_count;
0210     u8 rx_errors_count;
0211 
0212     u8 status;
0213     u8 padding[3];
0214 } __packed;
0215 
0216 struct usbcan_cmd_chip_state_event {
0217     u8 tid;
0218     u8 channel;
0219 
0220     u8 tx_errors_count;
0221     u8 rx_errors_count;
0222     __le16 time;
0223 
0224     u8 status;
0225     u8 padding[3];
0226 } __packed;
0227 
0228 struct kvaser_cmd_tx_acknowledge_header {
0229     u8 channel;
0230     u8 tid;
0231 } __packed;
0232 
0233 struct leaf_cmd_error_event {
0234     u8 tid;
0235     u8 flags;
0236     __le16 time[3];
0237     u8 channel;
0238     u8 padding;
0239     u8 tx_errors_count;
0240     u8 rx_errors_count;
0241     u8 status;
0242     u8 error_factor;
0243 } __packed;
0244 
0245 struct usbcan_cmd_error_event {
0246     u8 tid;
0247     u8 padding;
0248     u8 tx_errors_count_ch0;
0249     u8 rx_errors_count_ch0;
0250     u8 tx_errors_count_ch1;
0251     u8 rx_errors_count_ch1;
0252     u8 status_ch0;
0253     u8 status_ch1;
0254     __le16 time;
0255 } __packed;
0256 
0257 struct kvaser_cmd_ctrl_mode {
0258     u8 tid;
0259     u8 channel;
0260     u8 ctrl_mode;
0261     u8 padding[3];
0262 } __packed;
0263 
0264 struct kvaser_cmd_flush_queue {
0265     u8 tid;
0266     u8 channel;
0267     u8 flags;
0268     u8 padding[3];
0269 } __packed;
0270 
0271 struct leaf_cmd_log_message {
0272     u8 channel;
0273     u8 flags;
0274     __le16 time[3];
0275     u8 dlc;
0276     u8 time_offset;
0277     __le32 id;
0278     u8 data[8];
0279 } __packed;
0280 
0281 struct kvaser_cmd {
0282     u8 len;
0283     u8 id;
0284     union   {
0285         struct kvaser_cmd_simple simple;
0286         struct kvaser_cmd_cardinfo cardinfo;
0287         struct kvaser_cmd_busparams busparams;
0288 
0289         struct kvaser_cmd_rx_can_header rx_can_header;
0290         struct kvaser_cmd_tx_acknowledge_header tx_acknowledge_header;
0291 
0292         union {
0293             struct leaf_cmd_softinfo softinfo;
0294             struct leaf_cmd_rx_can rx_can;
0295             struct leaf_cmd_chip_state_event chip_state_event;
0296             struct leaf_cmd_error_event error_event;
0297             struct leaf_cmd_log_message log_message;
0298         } __packed leaf;
0299 
0300         union {
0301             struct usbcan_cmd_softinfo softinfo;
0302             struct usbcan_cmd_rx_can rx_can;
0303             struct usbcan_cmd_chip_state_event chip_state_event;
0304             struct usbcan_cmd_error_event error_event;
0305         } __packed usbcan;
0306 
0307         struct kvaser_cmd_tx_can tx_can;
0308         struct kvaser_cmd_ctrl_mode ctrl_mode;
0309         struct kvaser_cmd_flush_queue flush_queue;
0310     } u;
0311 } __packed;
0312 
0313 /* Summary of a kvaser error event, for a unified Leaf/Usbcan error
0314  * handling. Some discrepancies between the two families exist:
0315  *
0316  * - USBCAN firmware does not report M16C "error factors"
0317  * - USBCAN controllers has difficulties reporting if the raised error
0318  *   event is for ch0 or ch1. They leave such arbitration to the OS
0319  *   driver by letting it compare error counters with previous values
0320  *   and decide the error event's channel. Thus for USBCAN, the channel
0321  *   field is only advisory.
0322  */
0323 struct kvaser_usb_err_summary {
0324     u8 channel, status, txerr, rxerr;
0325     union {
0326         struct {
0327             u8 error_factor;
0328         } leaf;
0329         struct {
0330             u8 other_ch_status;
0331             u8 error_state;
0332         } usbcan;
0333     };
0334 };
0335 
0336 static const struct can_bittiming_const kvaser_usb_leaf_m16c_bittiming_const = {
0337     .name = "kvaser_usb_ucii",
0338     .tseg1_min = 4,
0339     .tseg1_max = 16,
0340     .tseg2_min = 2,
0341     .tseg2_max = 8,
0342     .sjw_max = 4,
0343     .brp_min = 1,
0344     .brp_max = 16,
0345     .brp_inc = 1,
0346 };
0347 
0348 static const struct can_bittiming_const kvaser_usb_leaf_m32c_bittiming_const = {
0349     .name = "kvaser_usb_leaf",
0350     .tseg1_min = 3,
0351     .tseg1_max = 16,
0352     .tseg2_min = 2,
0353     .tseg2_max = 8,
0354     .sjw_max = 4,
0355     .brp_min = 2,
0356     .brp_max = 128,
0357     .brp_inc = 2,
0358 };
0359 
0360 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_usbcan_dev_cfg = {
0361     .clock = {
0362         .freq = 8 * MEGA /* Hz */,
0363     },
0364     .timestamp_freq = 1,
0365     .bittiming_const = &kvaser_usb_leaf_m16c_bittiming_const,
0366 };
0367 
0368 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_m32c_dev_cfg = {
0369     .clock = {
0370         .freq = 16 * MEGA /* Hz */,
0371     },
0372     .timestamp_freq = 1,
0373     .bittiming_const = &kvaser_usb_leaf_m32c_bittiming_const,
0374 };
0375 
0376 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_imx_dev_cfg_16mhz = {
0377     .clock = {
0378         .freq = 16 * MEGA /* Hz */,
0379     },
0380     .timestamp_freq = 1,
0381     .bittiming_const = &kvaser_usb_flexc_bittiming_const,
0382 };
0383 
0384 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_imx_dev_cfg_24mhz = {
0385     .clock = {
0386         .freq = 24 * MEGA /* Hz */,
0387     },
0388     .timestamp_freq = 1,
0389     .bittiming_const = &kvaser_usb_flexc_bittiming_const,
0390 };
0391 
0392 static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_imx_dev_cfg_32mhz = {
0393     .clock = {
0394         .freq = 32 * MEGA /* Hz */,
0395     },
0396     .timestamp_freq = 1,
0397     .bittiming_const = &kvaser_usb_flexc_bittiming_const,
0398 };
0399 
0400 static void *
0401 kvaser_usb_leaf_frame_to_cmd(const struct kvaser_usb_net_priv *priv,
0402                  const struct sk_buff *skb, int *cmd_len,
0403                  u16 transid)
0404 {
0405     struct kvaser_usb *dev = priv->dev;
0406     struct kvaser_cmd *cmd;
0407     u8 *cmd_tx_can_flags = NULL;        /* GCC */
0408     struct can_frame *cf = (struct can_frame *)skb->data;
0409 
0410     cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);
0411     if (cmd) {
0412         cmd->u.tx_can.tid = transid & 0xff;
0413         cmd->len = *cmd_len = CMD_HEADER_LEN +
0414                       sizeof(struct kvaser_cmd_tx_can);
0415         cmd->u.tx_can.channel = priv->channel;
0416 
0417         switch (dev->driver_info->family) {
0418         case KVASER_LEAF:
0419             cmd_tx_can_flags = &cmd->u.tx_can.leaf.flags;
0420             break;
0421         case KVASER_USBCAN:
0422             cmd_tx_can_flags = &cmd->u.tx_can.usbcan.flags;
0423             break;
0424         }
0425 
0426         *cmd_tx_can_flags = 0;
0427 
0428         if (cf->can_id & CAN_EFF_FLAG) {
0429             cmd->id = CMD_TX_EXT_MESSAGE;
0430             cmd->u.tx_can.data[0] = (cf->can_id >> 24) & 0x1f;
0431             cmd->u.tx_can.data[1] = (cf->can_id >> 18) & 0x3f;
0432             cmd->u.tx_can.data[2] = (cf->can_id >> 14) & 0x0f;
0433             cmd->u.tx_can.data[3] = (cf->can_id >> 6) & 0xff;
0434             cmd->u.tx_can.data[4] = cf->can_id & 0x3f;
0435         } else {
0436             cmd->id = CMD_TX_STD_MESSAGE;
0437             cmd->u.tx_can.data[0] = (cf->can_id >> 6) & 0x1f;
0438             cmd->u.tx_can.data[1] = cf->can_id & 0x3f;
0439         }
0440 
0441         cmd->u.tx_can.data[5] = cf->len;
0442         memcpy(&cmd->u.tx_can.data[6], cf->data, cf->len);
0443 
0444         if (cf->can_id & CAN_RTR_FLAG)
0445             *cmd_tx_can_flags |= MSG_FLAG_REMOTE_FRAME;
0446     }
0447     return cmd;
0448 }
0449 
0450 static int kvaser_usb_leaf_wait_cmd(const struct kvaser_usb *dev, u8 id,
0451                     struct kvaser_cmd *cmd)
0452 {
0453     struct kvaser_cmd *tmp;
0454     void *buf;
0455     int actual_len;
0456     int err;
0457     int pos;
0458     unsigned long to = jiffies + msecs_to_jiffies(KVASER_USB_TIMEOUT);
0459 
0460     buf = kzalloc(KVASER_USB_RX_BUFFER_SIZE, GFP_KERNEL);
0461     if (!buf)
0462         return -ENOMEM;
0463 
0464     do {
0465         err = kvaser_usb_recv_cmd(dev, buf, KVASER_USB_RX_BUFFER_SIZE,
0466                       &actual_len);
0467         if (err < 0)
0468             goto end;
0469 
0470         pos = 0;
0471         while (pos <= actual_len - CMD_HEADER_LEN) {
0472             tmp = buf + pos;
0473 
0474             /* Handle commands crossing the USB endpoint max packet
0475              * size boundary. Check kvaser_usb_read_bulk_callback()
0476              * for further details.
0477              */
0478             if (tmp->len == 0) {
0479                 pos = round_up(pos,
0480                            le16_to_cpu
0481                         (dev->bulk_in->wMaxPacketSize));
0482                 continue;
0483             }
0484 
0485             if (pos + tmp->len > actual_len) {
0486                 dev_err_ratelimited(&dev->intf->dev,
0487                             "Format error\n");
0488                 break;
0489             }
0490 
0491             if (tmp->id == id) {
0492                 memcpy(cmd, tmp, tmp->len);
0493                 goto end;
0494             }
0495 
0496             pos += tmp->len;
0497         }
0498     } while (time_before(jiffies, to));
0499 
0500     err = -EINVAL;
0501 
0502 end:
0503     kfree(buf);
0504 
0505     return err;
0506 }
0507 
0508 static int kvaser_usb_leaf_send_simple_cmd(const struct kvaser_usb *dev,
0509                        u8 cmd_id, int channel)
0510 {
0511     struct kvaser_cmd *cmd;
0512     int rc;
0513 
0514     cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
0515     if (!cmd)
0516         return -ENOMEM;
0517 
0518     cmd->id = cmd_id;
0519     cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple);
0520     cmd->u.simple.channel = channel;
0521     cmd->u.simple.tid = 0xff;
0522 
0523     rc = kvaser_usb_send_cmd(dev, cmd, cmd->len);
0524 
0525     kfree(cmd);
0526     return rc;
0527 }
0528 
0529 static void kvaser_usb_leaf_get_software_info_leaf(struct kvaser_usb *dev,
0530                            const struct leaf_cmd_softinfo *softinfo)
0531 {
0532     u32 sw_options = le32_to_cpu(softinfo->sw_options);
0533 
0534     dev->fw_version = le32_to_cpu(softinfo->fw_version);
0535     dev->max_tx_urbs = le16_to_cpu(softinfo->max_outstanding_tx);
0536 
0537     if (dev->driver_info->quirks & KVASER_USB_QUIRK_IGNORE_CLK_FREQ) {
0538         /* Firmware expects bittiming parameters calculated for 16MHz
0539          * clock, regardless of the actual clock
0540          */
0541         dev->cfg = &kvaser_usb_leaf_m32c_dev_cfg;
0542     } else {
0543         switch (sw_options & KVASER_USB_LEAF_SWOPTION_FREQ_MASK) {
0544         case KVASER_USB_LEAF_SWOPTION_FREQ_16_MHZ_CLK:
0545             dev->cfg = &kvaser_usb_leaf_imx_dev_cfg_16mhz;
0546             break;
0547         case KVASER_USB_LEAF_SWOPTION_FREQ_24_MHZ_CLK:
0548             dev->cfg = &kvaser_usb_leaf_imx_dev_cfg_24mhz;
0549             break;
0550         case KVASER_USB_LEAF_SWOPTION_FREQ_32_MHZ_CLK:
0551             dev->cfg = &kvaser_usb_leaf_imx_dev_cfg_32mhz;
0552             break;
0553         }
0554     }
0555 }
0556 
0557 static int kvaser_usb_leaf_get_software_info_inner(struct kvaser_usb *dev)
0558 {
0559     struct kvaser_cmd cmd;
0560     int err;
0561 
0562     err = kvaser_usb_leaf_send_simple_cmd(dev, CMD_GET_SOFTWARE_INFO, 0);
0563     if (err)
0564         return err;
0565 
0566     err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_SOFTWARE_INFO_REPLY, &cmd);
0567     if (err)
0568         return err;
0569 
0570     switch (dev->driver_info->family) {
0571     case KVASER_LEAF:
0572         kvaser_usb_leaf_get_software_info_leaf(dev, &cmd.u.leaf.softinfo);
0573         break;
0574     case KVASER_USBCAN:
0575         dev->fw_version = le32_to_cpu(cmd.u.usbcan.softinfo.fw_version);
0576         dev->max_tx_urbs =
0577             le16_to_cpu(cmd.u.usbcan.softinfo.max_outstanding_tx);
0578         dev->cfg = &kvaser_usb_leaf_usbcan_dev_cfg;
0579         break;
0580     }
0581 
0582     return 0;
0583 }
0584 
0585 static int kvaser_usb_leaf_get_software_info(struct kvaser_usb *dev)
0586 {
0587     int err;
0588     int retry = 3;
0589 
0590     /* On some x86 laptops, plugging a Kvaser device again after
0591      * an unplug makes the firmware always ignore the very first
0592      * command. For such a case, provide some room for retries
0593      * instead of completely exiting the driver.
0594      */
0595     do {
0596         err = kvaser_usb_leaf_get_software_info_inner(dev);
0597     } while (--retry && err == -ETIMEDOUT);
0598 
0599     return err;
0600 }
0601 
0602 static int kvaser_usb_leaf_get_card_info(struct kvaser_usb *dev)
0603 {
0604     struct kvaser_cmd cmd;
0605     int err;
0606 
0607     err = kvaser_usb_leaf_send_simple_cmd(dev, CMD_GET_CARD_INFO, 0);
0608     if (err)
0609         return err;
0610 
0611     err = kvaser_usb_leaf_wait_cmd(dev, CMD_GET_CARD_INFO_REPLY, &cmd);
0612     if (err)
0613         return err;
0614 
0615     dev->nchannels = cmd.u.cardinfo.nchannels;
0616     if (dev->nchannels > KVASER_USB_MAX_NET_DEVICES ||
0617         (dev->driver_info->family == KVASER_USBCAN &&
0618          dev->nchannels > MAX_USBCAN_NET_DEVICES))
0619         return -EINVAL;
0620 
0621     return 0;
0622 }
0623 
0624 static void kvaser_usb_leaf_tx_acknowledge(const struct kvaser_usb *dev,
0625                        const struct kvaser_cmd *cmd)
0626 {
0627     struct net_device_stats *stats;
0628     struct kvaser_usb_tx_urb_context *context;
0629     struct kvaser_usb_net_priv *priv;
0630     unsigned long flags;
0631     u8 channel, tid;
0632 
0633     channel = cmd->u.tx_acknowledge_header.channel;
0634     tid = cmd->u.tx_acknowledge_header.tid;
0635 
0636     if (channel >= dev->nchannels) {
0637         dev_err(&dev->intf->dev,
0638             "Invalid channel number (%d)\n", channel);
0639         return;
0640     }
0641 
0642     priv = dev->nets[channel];
0643 
0644     if (!netif_device_present(priv->netdev))
0645         return;
0646 
0647     stats = &priv->netdev->stats;
0648 
0649     context = &priv->tx_contexts[tid % dev->max_tx_urbs];
0650 
0651     /* Sometimes the state change doesn't come after a bus-off event */
0652     if (priv->can.restart_ms && priv->can.state >= CAN_STATE_BUS_OFF) {
0653         struct sk_buff *skb;
0654         struct can_frame *cf;
0655 
0656         skb = alloc_can_err_skb(priv->netdev, &cf);
0657         if (skb) {
0658             cf->can_id |= CAN_ERR_RESTARTED;
0659 
0660             netif_rx(skb);
0661         } else {
0662             netdev_err(priv->netdev,
0663                    "No memory left for err_skb\n");
0664         }
0665 
0666         priv->can.can_stats.restarts++;
0667         netif_carrier_on(priv->netdev);
0668 
0669         priv->can.state = CAN_STATE_ERROR_ACTIVE;
0670     }
0671 
0672     spin_lock_irqsave(&priv->tx_contexts_lock, flags);
0673 
0674     stats->tx_packets++;
0675     stats->tx_bytes += can_get_echo_skb(priv->netdev,
0676                         context->echo_index, NULL);
0677     context->echo_index = dev->max_tx_urbs;
0678     --priv->active_tx_contexts;
0679     netif_wake_queue(priv->netdev);
0680 
0681     spin_unlock_irqrestore(&priv->tx_contexts_lock, flags);
0682 }
0683 
0684 static int kvaser_usb_leaf_simple_cmd_async(struct kvaser_usb_net_priv *priv,
0685                         u8 cmd_id)
0686 {
0687     struct kvaser_cmd *cmd;
0688     int err;
0689 
0690     cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
0691     if (!cmd)
0692         return -ENOMEM;
0693 
0694     cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple);
0695     cmd->id = cmd_id;
0696     cmd->u.simple.channel = priv->channel;
0697 
0698     err = kvaser_usb_send_cmd_async(priv, cmd, cmd->len);
0699     if (err)
0700         kfree(cmd);
0701 
0702     return err;
0703 }
0704 
0705 static void
0706 kvaser_usb_leaf_rx_error_update_can_state(struct kvaser_usb_net_priv *priv,
0707                     const struct kvaser_usb_err_summary *es,
0708                     struct can_frame *cf)
0709 {
0710     struct kvaser_usb *dev = priv->dev;
0711     struct net_device_stats *stats = &priv->netdev->stats;
0712     enum can_state cur_state, new_state, tx_state, rx_state;
0713 
0714     netdev_dbg(priv->netdev, "Error status: 0x%02x\n", es->status);
0715 
0716     new_state = priv->can.state;
0717     cur_state = priv->can.state;
0718 
0719     if (es->status & (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
0720         new_state = CAN_STATE_BUS_OFF;
0721     } else if (es->status & M16C_STATE_BUS_PASSIVE) {
0722         new_state = CAN_STATE_ERROR_PASSIVE;
0723     } else if (es->status & M16C_STATE_BUS_ERROR) {
0724         /* Guard against spurious error events after a busoff */
0725         if (cur_state < CAN_STATE_BUS_OFF) {
0726             if (es->txerr >= 128 || es->rxerr >= 128)
0727                 new_state = CAN_STATE_ERROR_PASSIVE;
0728             else if (es->txerr >= 96 || es->rxerr >= 96)
0729                 new_state = CAN_STATE_ERROR_WARNING;
0730             else if (cur_state > CAN_STATE_ERROR_ACTIVE)
0731                 new_state = CAN_STATE_ERROR_ACTIVE;
0732         }
0733     }
0734 
0735     if (!es->status)
0736         new_state = CAN_STATE_ERROR_ACTIVE;
0737 
0738     if (new_state != cur_state) {
0739         tx_state = (es->txerr >= es->rxerr) ? new_state : 0;
0740         rx_state = (es->txerr <= es->rxerr) ? new_state : 0;
0741 
0742         can_change_state(priv->netdev, cf, tx_state, rx_state);
0743     }
0744 
0745     if (priv->can.restart_ms &&
0746         cur_state >= CAN_STATE_BUS_OFF &&
0747         new_state < CAN_STATE_BUS_OFF)
0748         priv->can.can_stats.restarts++;
0749 
0750     switch (dev->driver_info->family) {
0751     case KVASER_LEAF:
0752         if (es->leaf.error_factor) {
0753             priv->can.can_stats.bus_error++;
0754             stats->rx_errors++;
0755         }
0756         break;
0757     case KVASER_USBCAN:
0758         if (es->usbcan.error_state & USBCAN_ERROR_STATE_TX_ERROR)
0759             stats->tx_errors++;
0760         if (es->usbcan.error_state & USBCAN_ERROR_STATE_RX_ERROR)
0761             stats->rx_errors++;
0762         if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR)
0763             priv->can.can_stats.bus_error++;
0764         break;
0765     }
0766 
0767     priv->bec.txerr = es->txerr;
0768     priv->bec.rxerr = es->rxerr;
0769 }
0770 
0771 static void kvaser_usb_leaf_rx_error(const struct kvaser_usb *dev,
0772                      const struct kvaser_usb_err_summary *es)
0773 {
0774     struct can_frame *cf;
0775     struct can_frame tmp_cf = { .can_id = CAN_ERR_FLAG,
0776                     .len = CAN_ERR_DLC };
0777     struct sk_buff *skb;
0778     struct net_device_stats *stats;
0779     struct kvaser_usb_net_priv *priv;
0780     enum can_state old_state, new_state;
0781 
0782     if (es->channel >= dev->nchannels) {
0783         dev_err(&dev->intf->dev,
0784             "Invalid channel number (%d)\n", es->channel);
0785         return;
0786     }
0787 
0788     priv = dev->nets[es->channel];
0789     stats = &priv->netdev->stats;
0790 
0791     /* Update all of the CAN interface's state and error counters before
0792      * trying any memory allocation that can actually fail with -ENOMEM.
0793      *
0794      * We send a temporary stack-allocated error CAN frame to
0795      * can_change_state() for the very same reason.
0796      *
0797      * TODO: Split can_change_state() responsibility between updating the
0798      * CAN interface's state and counters, and the setting up of CAN error
0799      * frame ID and data to userspace. Remove stack allocation afterwards.
0800      */
0801     old_state = priv->can.state;
0802     kvaser_usb_leaf_rx_error_update_can_state(priv, es, &tmp_cf);
0803     new_state = priv->can.state;
0804 
0805     skb = alloc_can_err_skb(priv->netdev, &cf);
0806     if (!skb) {
0807         stats->rx_dropped++;
0808         return;
0809     }
0810     memcpy(cf, &tmp_cf, sizeof(*cf));
0811 
0812     if (new_state != old_state) {
0813         if (es->status &
0814             (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
0815             if (!priv->can.restart_ms)
0816                 kvaser_usb_leaf_simple_cmd_async(priv,
0817                                  CMD_STOP_CHIP);
0818             netif_carrier_off(priv->netdev);
0819         }
0820 
0821         if (priv->can.restart_ms &&
0822             old_state >= CAN_STATE_BUS_OFF &&
0823             new_state < CAN_STATE_BUS_OFF) {
0824             cf->can_id |= CAN_ERR_RESTARTED;
0825             netif_carrier_on(priv->netdev);
0826         }
0827     }
0828 
0829     switch (dev->driver_info->family) {
0830     case KVASER_LEAF:
0831         if (es->leaf.error_factor) {
0832             cf->can_id |= CAN_ERR_BUSERROR | CAN_ERR_PROT;
0833 
0834             if (es->leaf.error_factor & M16C_EF_ACKE)
0835                 cf->data[3] = CAN_ERR_PROT_LOC_ACK;
0836             if (es->leaf.error_factor & M16C_EF_CRCE)
0837                 cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ;
0838             if (es->leaf.error_factor & M16C_EF_FORME)
0839                 cf->data[2] |= CAN_ERR_PROT_FORM;
0840             if (es->leaf.error_factor & M16C_EF_STFE)
0841                 cf->data[2] |= CAN_ERR_PROT_STUFF;
0842             if (es->leaf.error_factor & M16C_EF_BITE0)
0843                 cf->data[2] |= CAN_ERR_PROT_BIT0;
0844             if (es->leaf.error_factor & M16C_EF_BITE1)
0845                 cf->data[2] |= CAN_ERR_PROT_BIT1;
0846             if (es->leaf.error_factor & M16C_EF_TRE)
0847                 cf->data[2] |= CAN_ERR_PROT_TX;
0848         }
0849         break;
0850     case KVASER_USBCAN:
0851         if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR)
0852             cf->can_id |= CAN_ERR_BUSERROR;
0853         break;
0854     }
0855 
0856     if (new_state != CAN_STATE_BUS_OFF) {
0857         cf->can_id |= CAN_ERR_CNT;
0858         cf->data[6] = es->txerr;
0859         cf->data[7] = es->rxerr;
0860     }
0861 
0862     netif_rx(skb);
0863 }
0864 
0865 /* For USBCAN, report error to userspace if the channels's errors counter
0866  * has changed, or we're the only channel seeing a bus error state.
0867  */
0868 static void
0869 kvaser_usb_leaf_usbcan_conditionally_rx_error(const struct kvaser_usb *dev,
0870                           struct kvaser_usb_err_summary *es)
0871 {
0872     struct kvaser_usb_net_priv *priv;
0873     unsigned int channel;
0874     bool report_error;
0875 
0876     channel = es->channel;
0877     if (channel >= dev->nchannels) {
0878         dev_err(&dev->intf->dev,
0879             "Invalid channel number (%d)\n", channel);
0880         return;
0881     }
0882 
0883     priv = dev->nets[channel];
0884     report_error = false;
0885 
0886     if (es->txerr != priv->bec.txerr) {
0887         es->usbcan.error_state |= USBCAN_ERROR_STATE_TX_ERROR;
0888         report_error = true;
0889     }
0890     if (es->rxerr != priv->bec.rxerr) {
0891         es->usbcan.error_state |= USBCAN_ERROR_STATE_RX_ERROR;
0892         report_error = true;
0893     }
0894     if ((es->status & M16C_STATE_BUS_ERROR) &&
0895         !(es->usbcan.other_ch_status & M16C_STATE_BUS_ERROR)) {
0896         es->usbcan.error_state |= USBCAN_ERROR_STATE_BUSERROR;
0897         report_error = true;
0898     }
0899 
0900     if (report_error)
0901         kvaser_usb_leaf_rx_error(dev, es);
0902 }
0903 
0904 static void kvaser_usb_leaf_usbcan_rx_error(const struct kvaser_usb *dev,
0905                         const struct kvaser_cmd *cmd)
0906 {
0907     struct kvaser_usb_err_summary es = { };
0908 
0909     switch (cmd->id) {
0910     /* Sometimes errors are sent as unsolicited chip state events */
0911     case CMD_CHIP_STATE_EVENT:
0912         es.channel = cmd->u.usbcan.chip_state_event.channel;
0913         es.status = cmd->u.usbcan.chip_state_event.status;
0914         es.txerr = cmd->u.usbcan.chip_state_event.tx_errors_count;
0915         es.rxerr = cmd->u.usbcan.chip_state_event.rx_errors_count;
0916         kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
0917         break;
0918 
0919     case CMD_CAN_ERROR_EVENT:
0920         es.channel = 0;
0921         es.status = cmd->u.usbcan.error_event.status_ch0;
0922         es.txerr = cmd->u.usbcan.error_event.tx_errors_count_ch0;
0923         es.rxerr = cmd->u.usbcan.error_event.rx_errors_count_ch0;
0924         es.usbcan.other_ch_status =
0925             cmd->u.usbcan.error_event.status_ch1;
0926         kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
0927 
0928         /* The USBCAN firmware supports up to 2 channels.
0929          * Now that ch0 was checked, check if ch1 has any errors.
0930          */
0931         if (dev->nchannels == MAX_USBCAN_NET_DEVICES) {
0932             es.channel = 1;
0933             es.status = cmd->u.usbcan.error_event.status_ch1;
0934             es.txerr =
0935                 cmd->u.usbcan.error_event.tx_errors_count_ch1;
0936             es.rxerr =
0937                 cmd->u.usbcan.error_event.rx_errors_count_ch1;
0938             es.usbcan.other_ch_status =
0939                 cmd->u.usbcan.error_event.status_ch0;
0940             kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
0941         }
0942         break;
0943 
0944     default:
0945         dev_err(&dev->intf->dev, "Invalid cmd id (%d)\n", cmd->id);
0946     }
0947 }
0948 
0949 static void kvaser_usb_leaf_leaf_rx_error(const struct kvaser_usb *dev,
0950                       const struct kvaser_cmd *cmd)
0951 {
0952     struct kvaser_usb_err_summary es = { };
0953 
0954     switch (cmd->id) {
0955     case CMD_CAN_ERROR_EVENT:
0956         es.channel = cmd->u.leaf.error_event.channel;
0957         es.status = cmd->u.leaf.error_event.status;
0958         es.txerr = cmd->u.leaf.error_event.tx_errors_count;
0959         es.rxerr = cmd->u.leaf.error_event.rx_errors_count;
0960         es.leaf.error_factor = cmd->u.leaf.error_event.error_factor;
0961         break;
0962     case CMD_LEAF_LOG_MESSAGE:
0963         es.channel = cmd->u.leaf.log_message.channel;
0964         es.status = cmd->u.leaf.log_message.data[0];
0965         es.txerr = cmd->u.leaf.log_message.data[2];
0966         es.rxerr = cmd->u.leaf.log_message.data[3];
0967         es.leaf.error_factor = cmd->u.leaf.log_message.data[1];
0968         break;
0969     case CMD_CHIP_STATE_EVENT:
0970         es.channel = cmd->u.leaf.chip_state_event.channel;
0971         es.status = cmd->u.leaf.chip_state_event.status;
0972         es.txerr = cmd->u.leaf.chip_state_event.tx_errors_count;
0973         es.rxerr = cmd->u.leaf.chip_state_event.rx_errors_count;
0974         es.leaf.error_factor = 0;
0975         break;
0976     default:
0977         dev_err(&dev->intf->dev, "Invalid cmd id (%d)\n", cmd->id);
0978         return;
0979     }
0980 
0981     kvaser_usb_leaf_rx_error(dev, &es);
0982 }
0983 
0984 static void kvaser_usb_leaf_rx_can_err(const struct kvaser_usb_net_priv *priv,
0985                        const struct kvaser_cmd *cmd)
0986 {
0987     if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
0988                      MSG_FLAG_NERR)) {
0989         struct net_device_stats *stats = &priv->netdev->stats;
0990 
0991         netdev_err(priv->netdev, "Unknown error (flags: 0x%02x)\n",
0992                cmd->u.rx_can_header.flag);
0993 
0994         stats->rx_errors++;
0995         return;
0996     }
0997 
0998     if (cmd->u.rx_can_header.flag & MSG_FLAG_OVERRUN)
0999         kvaser_usb_can_rx_over_error(priv->netdev);
1000 }
1001 
1002 static void kvaser_usb_leaf_rx_can_msg(const struct kvaser_usb *dev,
1003                        const struct kvaser_cmd *cmd)
1004 {
1005     struct kvaser_usb_net_priv *priv;
1006     struct can_frame *cf;
1007     struct sk_buff *skb;
1008     struct net_device_stats *stats;
1009     u8 channel = cmd->u.rx_can_header.channel;
1010     const u8 *rx_data = NULL;   /* GCC */
1011 
1012     if (channel >= dev->nchannels) {
1013         dev_err(&dev->intf->dev,
1014             "Invalid channel number (%d)\n", channel);
1015         return;
1016     }
1017 
1018     priv = dev->nets[channel];
1019     stats = &priv->netdev->stats;
1020 
1021     if ((cmd->u.rx_can_header.flag & MSG_FLAG_ERROR_FRAME) &&
1022         (dev->driver_info->family == KVASER_LEAF &&
1023          cmd->id == CMD_LEAF_LOG_MESSAGE)) {
1024         kvaser_usb_leaf_leaf_rx_error(dev, cmd);
1025         return;
1026     } else if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
1027                         MSG_FLAG_NERR |
1028                         MSG_FLAG_OVERRUN)) {
1029         kvaser_usb_leaf_rx_can_err(priv, cmd);
1030         return;
1031     } else if (cmd->u.rx_can_header.flag & ~MSG_FLAG_REMOTE_FRAME) {
1032         netdev_warn(priv->netdev,
1033                 "Unhandled frame (flags: 0x%02x)\n",
1034                 cmd->u.rx_can_header.flag);
1035         return;
1036     }
1037 
1038     switch (dev->driver_info->family) {
1039     case KVASER_LEAF:
1040         rx_data = cmd->u.leaf.rx_can.data;
1041         break;
1042     case KVASER_USBCAN:
1043         rx_data = cmd->u.usbcan.rx_can.data;
1044         break;
1045     }
1046 
1047     skb = alloc_can_skb(priv->netdev, &cf);
1048     if (!skb) {
1049         stats->rx_dropped++;
1050         return;
1051     }
1052 
1053     if (dev->driver_info->family == KVASER_LEAF && cmd->id ==
1054         CMD_LEAF_LOG_MESSAGE) {
1055         cf->can_id = le32_to_cpu(cmd->u.leaf.log_message.id);
1056         if (cf->can_id & KVASER_EXTENDED_FRAME)
1057             cf->can_id &= CAN_EFF_MASK | CAN_EFF_FLAG;
1058         else
1059             cf->can_id &= CAN_SFF_MASK;
1060 
1061         cf->len = can_cc_dlc2len(cmd->u.leaf.log_message.dlc);
1062 
1063         if (cmd->u.leaf.log_message.flags & MSG_FLAG_REMOTE_FRAME)
1064             cf->can_id |= CAN_RTR_FLAG;
1065         else
1066             memcpy(cf->data, &cmd->u.leaf.log_message.data,
1067                    cf->len);
1068     } else {
1069         cf->can_id = ((rx_data[0] & 0x1f) << 6) | (rx_data[1] & 0x3f);
1070 
1071         if (cmd->id == CMD_RX_EXT_MESSAGE) {
1072             cf->can_id <<= 18;
1073             cf->can_id |= ((rx_data[2] & 0x0f) << 14) |
1074                       ((rx_data[3] & 0xff) << 6) |
1075                       (rx_data[4] & 0x3f);
1076             cf->can_id |= CAN_EFF_FLAG;
1077         }
1078 
1079         cf->len = can_cc_dlc2len(rx_data[5]);
1080 
1081         if (cmd->u.rx_can_header.flag & MSG_FLAG_REMOTE_FRAME)
1082             cf->can_id |= CAN_RTR_FLAG;
1083         else
1084             memcpy(cf->data, &rx_data[6], cf->len);
1085     }
1086 
1087     stats->rx_packets++;
1088     if (!(cf->can_id & CAN_RTR_FLAG))
1089         stats->rx_bytes += cf->len;
1090     netif_rx(skb);
1091 }
1092 
1093 static void kvaser_usb_leaf_start_chip_reply(const struct kvaser_usb *dev,
1094                          const struct kvaser_cmd *cmd)
1095 {
1096     struct kvaser_usb_net_priv *priv;
1097     u8 channel = cmd->u.simple.channel;
1098 
1099     if (channel >= dev->nchannels) {
1100         dev_err(&dev->intf->dev,
1101             "Invalid channel number (%d)\n", channel);
1102         return;
1103     }
1104 
1105     priv = dev->nets[channel];
1106 
1107     if (completion_done(&priv->start_comp) &&
1108         netif_queue_stopped(priv->netdev)) {
1109         netif_wake_queue(priv->netdev);
1110     } else {
1111         netif_start_queue(priv->netdev);
1112         complete(&priv->start_comp);
1113     }
1114 }
1115 
1116 static void kvaser_usb_leaf_stop_chip_reply(const struct kvaser_usb *dev,
1117                         const struct kvaser_cmd *cmd)
1118 {
1119     struct kvaser_usb_net_priv *priv;
1120     u8 channel = cmd->u.simple.channel;
1121 
1122     if (channel >= dev->nchannels) {
1123         dev_err(&dev->intf->dev,
1124             "Invalid channel number (%d)\n", channel);
1125         return;
1126     }
1127 
1128     priv = dev->nets[channel];
1129 
1130     complete(&priv->stop_comp);
1131 }
1132 
1133 static void kvaser_usb_leaf_handle_command(const struct kvaser_usb *dev,
1134                        const struct kvaser_cmd *cmd)
1135 {
1136     switch (cmd->id) {
1137     case CMD_START_CHIP_REPLY:
1138         kvaser_usb_leaf_start_chip_reply(dev, cmd);
1139         break;
1140 
1141     case CMD_STOP_CHIP_REPLY:
1142         kvaser_usb_leaf_stop_chip_reply(dev, cmd);
1143         break;
1144 
1145     case CMD_RX_STD_MESSAGE:
1146     case CMD_RX_EXT_MESSAGE:
1147         kvaser_usb_leaf_rx_can_msg(dev, cmd);
1148         break;
1149 
1150     case CMD_LEAF_LOG_MESSAGE:
1151         if (dev->driver_info->family != KVASER_LEAF)
1152             goto warn;
1153         kvaser_usb_leaf_rx_can_msg(dev, cmd);
1154         break;
1155 
1156     case CMD_CHIP_STATE_EVENT:
1157     case CMD_CAN_ERROR_EVENT:
1158         if (dev->driver_info->family == KVASER_LEAF)
1159             kvaser_usb_leaf_leaf_rx_error(dev, cmd);
1160         else
1161             kvaser_usb_leaf_usbcan_rx_error(dev, cmd);
1162         break;
1163 
1164     case CMD_TX_ACKNOWLEDGE:
1165         kvaser_usb_leaf_tx_acknowledge(dev, cmd);
1166         break;
1167 
1168     /* Ignored commands */
1169     case CMD_USBCAN_CLOCK_OVERFLOW_EVENT:
1170         if (dev->driver_info->family != KVASER_USBCAN)
1171             goto warn;
1172         break;
1173 
1174     case CMD_FLUSH_QUEUE_REPLY:
1175         if (dev->driver_info->family != KVASER_LEAF)
1176             goto warn;
1177         break;
1178 
1179     default:
1180 warn:       dev_warn(&dev->intf->dev, "Unhandled command (%d)\n", cmd->id);
1181         break;
1182     }
1183 }
1184 
1185 static void kvaser_usb_leaf_read_bulk_callback(struct kvaser_usb *dev,
1186                            void *buf, int len)
1187 {
1188     struct kvaser_cmd *cmd;
1189     int pos = 0;
1190 
1191     while (pos <= len - CMD_HEADER_LEN) {
1192         cmd = buf + pos;
1193 
1194         /* The Kvaser firmware can only read and write commands that
1195          * does not cross the USB's endpoint wMaxPacketSize boundary.
1196          * If a follow-up command crosses such boundary, firmware puts
1197          * a placeholder zero-length command in its place then aligns
1198          * the real command to the next max packet size.
1199          *
1200          * Handle such cases or we're going to miss a significant
1201          * number of events in case of a heavy rx load on the bus.
1202          */
1203         if (cmd->len == 0) {
1204             pos = round_up(pos, le16_to_cpu
1205                         (dev->bulk_in->wMaxPacketSize));
1206             continue;
1207         }
1208 
1209         if (pos + cmd->len > len) {
1210             dev_err_ratelimited(&dev->intf->dev, "Format error\n");
1211             break;
1212         }
1213 
1214         kvaser_usb_leaf_handle_command(dev, cmd);
1215         pos += cmd->len;
1216     }
1217 }
1218 
1219 static int kvaser_usb_leaf_set_opt_mode(const struct kvaser_usb_net_priv *priv)
1220 {
1221     struct kvaser_cmd *cmd;
1222     int rc;
1223 
1224     cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1225     if (!cmd)
1226         return -ENOMEM;
1227 
1228     cmd->id = CMD_SET_CTRL_MODE;
1229     cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_ctrl_mode);
1230     cmd->u.ctrl_mode.tid = 0xff;
1231     cmd->u.ctrl_mode.channel = priv->channel;
1232 
1233     if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
1234         cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT;
1235     else
1236         cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL;
1237 
1238     rc = kvaser_usb_send_cmd(priv->dev, cmd, cmd->len);
1239 
1240     kfree(cmd);
1241     return rc;
1242 }
1243 
1244 static int kvaser_usb_leaf_start_chip(struct kvaser_usb_net_priv *priv)
1245 {
1246     int err;
1247 
1248     init_completion(&priv->start_comp);
1249 
1250     err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_START_CHIP,
1251                           priv->channel);
1252     if (err)
1253         return err;
1254 
1255     if (!wait_for_completion_timeout(&priv->start_comp,
1256                      msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1257         return -ETIMEDOUT;
1258 
1259     return 0;
1260 }
1261 
1262 static int kvaser_usb_leaf_stop_chip(struct kvaser_usb_net_priv *priv)
1263 {
1264     int err;
1265 
1266     init_completion(&priv->stop_comp);
1267 
1268     err = kvaser_usb_leaf_send_simple_cmd(priv->dev, CMD_STOP_CHIP,
1269                           priv->channel);
1270     if (err)
1271         return err;
1272 
1273     if (!wait_for_completion_timeout(&priv->stop_comp,
1274                      msecs_to_jiffies(KVASER_USB_TIMEOUT)))
1275         return -ETIMEDOUT;
1276 
1277     return 0;
1278 }
1279 
1280 static int kvaser_usb_leaf_reset_chip(struct kvaser_usb *dev, int channel)
1281 {
1282     return kvaser_usb_leaf_send_simple_cmd(dev, CMD_RESET_CHIP, channel);
1283 }
1284 
1285 static int kvaser_usb_leaf_flush_queue(struct kvaser_usb_net_priv *priv)
1286 {
1287     struct kvaser_cmd *cmd;
1288     int rc;
1289 
1290     cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1291     if (!cmd)
1292         return -ENOMEM;
1293 
1294     cmd->id = CMD_FLUSH_QUEUE;
1295     cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_flush_queue);
1296     cmd->u.flush_queue.channel = priv->channel;
1297     cmd->u.flush_queue.flags = 0x00;
1298 
1299     rc = kvaser_usb_send_cmd(priv->dev, cmd, cmd->len);
1300 
1301     kfree(cmd);
1302     return rc;
1303 }
1304 
1305 static int kvaser_usb_leaf_init_card(struct kvaser_usb *dev)
1306 {
1307     struct kvaser_usb_dev_card_data *card_data = &dev->card_data;
1308 
1309     card_data->ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
1310 
1311     return 0;
1312 }
1313 
1314 static int kvaser_usb_leaf_set_bittiming(struct net_device *netdev)
1315 {
1316     struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1317     struct can_bittiming *bt = &priv->can.bittiming;
1318     struct kvaser_usb *dev = priv->dev;
1319     struct kvaser_cmd *cmd;
1320     int rc;
1321 
1322     cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
1323     if (!cmd)
1324         return -ENOMEM;
1325 
1326     cmd->id = CMD_SET_BUS_PARAMS;
1327     cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_busparams);
1328     cmd->u.busparams.channel = priv->channel;
1329     cmd->u.busparams.tid = 0xff;
1330     cmd->u.busparams.bitrate = cpu_to_le32(bt->bitrate);
1331     cmd->u.busparams.sjw = bt->sjw;
1332     cmd->u.busparams.tseg1 = bt->prop_seg + bt->phase_seg1;
1333     cmd->u.busparams.tseg2 = bt->phase_seg2;
1334 
1335     if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
1336         cmd->u.busparams.no_samp = 3;
1337     else
1338         cmd->u.busparams.no_samp = 1;
1339 
1340     rc = kvaser_usb_send_cmd(dev, cmd, cmd->len);
1341 
1342     kfree(cmd);
1343     return rc;
1344 }
1345 
1346 static int kvaser_usb_leaf_set_mode(struct net_device *netdev,
1347                     enum can_mode mode)
1348 {
1349     struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1350     int err;
1351 
1352     switch (mode) {
1353     case CAN_MODE_START:
1354         err = kvaser_usb_leaf_simple_cmd_async(priv, CMD_START_CHIP);
1355         if (err)
1356             return err;
1357         break;
1358     default:
1359         return -EOPNOTSUPP;
1360     }
1361 
1362     return 0;
1363 }
1364 
1365 static int kvaser_usb_leaf_get_berr_counter(const struct net_device *netdev,
1366                         struct can_berr_counter *bec)
1367 {
1368     struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
1369 
1370     *bec = priv->bec;
1371 
1372     return 0;
1373 }
1374 
1375 static int kvaser_usb_leaf_setup_endpoints(struct kvaser_usb *dev)
1376 {
1377     const struct usb_host_interface *iface_desc;
1378     struct usb_endpoint_descriptor *endpoint;
1379     int i;
1380 
1381     iface_desc = dev->intf->cur_altsetting;
1382 
1383     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1384         endpoint = &iface_desc->endpoint[i].desc;
1385 
1386         if (!dev->bulk_in && usb_endpoint_is_bulk_in(endpoint))
1387             dev->bulk_in = endpoint;
1388 
1389         if (!dev->bulk_out && usb_endpoint_is_bulk_out(endpoint))
1390             dev->bulk_out = endpoint;
1391 
1392         /* use first bulk endpoint for in and out */
1393         if (dev->bulk_in && dev->bulk_out)
1394             return 0;
1395     }
1396 
1397     return -ENODEV;
1398 }
1399 
1400 const struct kvaser_usb_dev_ops kvaser_usb_leaf_dev_ops = {
1401     .dev_set_mode = kvaser_usb_leaf_set_mode,
1402     .dev_set_bittiming = kvaser_usb_leaf_set_bittiming,
1403     .dev_set_data_bittiming = NULL,
1404     .dev_get_berr_counter = kvaser_usb_leaf_get_berr_counter,
1405     .dev_setup_endpoints = kvaser_usb_leaf_setup_endpoints,
1406     .dev_init_card = kvaser_usb_leaf_init_card,
1407     .dev_get_software_info = kvaser_usb_leaf_get_software_info,
1408     .dev_get_software_details = NULL,
1409     .dev_get_card_info = kvaser_usb_leaf_get_card_info,
1410     .dev_get_capabilities = NULL,
1411     .dev_set_opt_mode = kvaser_usb_leaf_set_opt_mode,
1412     .dev_start_chip = kvaser_usb_leaf_start_chip,
1413     .dev_stop_chip = kvaser_usb_leaf_stop_chip,
1414     .dev_reset_chip = kvaser_usb_leaf_reset_chip,
1415     .dev_flush_queue = kvaser_usb_leaf_flush_queue,
1416     .dev_read_bulk_callback = kvaser_usb_leaf_read_bulk_callback,
1417     .dev_frame_to_cmd = kvaser_usb_leaf_frame_to_cmd,
1418 };
[ 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!