#define KVASER_HAS_SILENT_MODE BIT(0)
#define KVASER_HAS_TXRX_ERRORS BIT(1)
-/* Message header size */
-#define MSG_HEADER_LEN 2
+/* Command header size */
+#define CMD_HEADER_LEN 2
/* Can message flags */
#define MSG_FLAG_ERROR_FRAME BIT(0)
#define M16C_STATE_BUS_PASSIVE BIT(5)
#define M16C_STATE_BUS_OFF BIT(6)
-/* Can msg ids */
+/* Leaf/usbcan command ids */
#define CMD_RX_STD_MESSAGE 12
#define CMD_TX_STD_MESSAGE 13
#define CMD_RX_EXT_MESSAGE 14
KVASER_USBCAN,
};
-struct kvaser_msg_simple {
+struct kvaser_cmd_simple {
u8 tid;
u8 channel;
} __packed;
-struct kvaser_msg_cardinfo {
+struct kvaser_cmd_cardinfo {
u8 tid;
u8 nchannels;
union {
__le16 padding;
} __packed;
-struct leaf_msg_softinfo {
+struct leaf_cmd_softinfo {
u8 tid;
u8 padding0;
__le32 sw_options;
__le16 padding1[9];
} __packed;
-struct usbcan_msg_softinfo {
+struct usbcan_cmd_softinfo {
u8 tid;
u8 fw_name[5];
__le16 max_outstanding_tx;
__le16 sw_options;
} __packed;
-struct kvaser_msg_busparams {
+struct kvaser_cmd_busparams {
u8 tid;
u8 channel;
__le32 bitrate;
u8 no_samp;
} __packed;
-struct kvaser_msg_tx_can {
+struct kvaser_cmd_tx_can {
u8 channel;
u8 tid;
- u8 msg[14];
+ u8 data[14];
union {
struct {
u8 padding;
} __packed;
} __packed;
-struct kvaser_msg_rx_can_header {
+struct kvaser_cmd_rx_can_header {
u8 channel;
u8 flag;
} __packed;
-struct leaf_msg_rx_can {
+struct leaf_cmd_rx_can {
u8 channel;
u8 flag;
__le16 time[3];
- u8 msg[14];
+ u8 data[14];
} __packed;
-struct usbcan_msg_rx_can {
+struct usbcan_cmd_rx_can {
u8 channel;
u8 flag;
- u8 msg[14];
+ u8 data[14];
__le16 time;
} __packed;
-struct leaf_msg_chip_state_event {
+struct leaf_cmd_chip_state_event {
u8 tid;
u8 channel;
u8 padding[3];
} __packed;
-struct usbcan_msg_chip_state_event {
+struct usbcan_cmd_chip_state_event {
u8 tid;
u8 channel;
u8 padding[3];
} __packed;
-struct kvaser_msg_tx_acknowledge_header {
+struct kvaser_cmd_tx_acknowledge_header {
u8 channel;
u8 tid;
} __packed;
-struct leaf_msg_error_event {
+struct leaf_cmd_error_event {
u8 tid;
u8 flags;
__le16 time[3];
u8 error_factor;
} __packed;
-struct usbcan_msg_error_event {
+struct usbcan_cmd_error_event {
u8 tid;
u8 padding;
u8 tx_errors_count_ch0;
__le16 time;
} __packed;
-struct kvaser_msg_ctrl_mode {
+struct kvaser_cmd_ctrl_mode {
u8 tid;
u8 channel;
u8 ctrl_mode;
u8 padding[3];
} __packed;
-struct kvaser_msg_flush_queue {
+struct kvaser_cmd_flush_queue {
u8 tid;
u8 channel;
u8 flags;
u8 padding[3];
} __packed;
-struct leaf_msg_log_message {
+struct leaf_cmd_log_message {
u8 channel;
u8 flags;
__le16 time[3];
u8 data[8];
} __packed;
-struct kvaser_msg {
+struct kvaser_cmd {
u8 len;
u8 id;
union {
- struct kvaser_msg_simple simple;
- struct kvaser_msg_cardinfo cardinfo;
- struct kvaser_msg_busparams busparams;
+ struct kvaser_cmd_simple simple;
+ struct kvaser_cmd_cardinfo cardinfo;
+ struct kvaser_cmd_busparams busparams;
- struct kvaser_msg_rx_can_header rx_can_header;
- struct kvaser_msg_tx_acknowledge_header tx_acknowledge_header;
+ struct kvaser_cmd_rx_can_header rx_can_header;
+ struct kvaser_cmd_tx_acknowledge_header tx_acknowledge_header;
union {
- struct leaf_msg_softinfo softinfo;
- struct leaf_msg_rx_can rx_can;
- struct leaf_msg_chip_state_event chip_state_event;
- struct leaf_msg_error_event error_event;
- struct leaf_msg_log_message log_message;
+ struct leaf_cmd_softinfo softinfo;
+ struct leaf_cmd_rx_can rx_can;
+ struct leaf_cmd_chip_state_event chip_state_event;
+ struct leaf_cmd_error_event error_event;
+ struct leaf_cmd_log_message log_message;
} __packed leaf;
union {
- struct usbcan_msg_softinfo softinfo;
- struct usbcan_msg_rx_can rx_can;
- struct usbcan_msg_chip_state_event chip_state_event;
- struct usbcan_msg_error_event error_event;
+ struct usbcan_cmd_softinfo softinfo;
+ struct usbcan_cmd_rx_can rx_can;
+ struct usbcan_cmd_chip_state_event chip_state_event;
+ struct usbcan_cmd_error_event error_event;
} __packed usbcan;
- struct kvaser_msg_tx_can tx_can;
- struct kvaser_msg_ctrl_mode ctrl_mode;
- struct kvaser_msg_flush_queue flush_queue;
+ struct kvaser_cmd_tx_can tx_can;
+ struct kvaser_cmd_ctrl_mode ctrl_mode;
+ struct kvaser_cmd_flush_queue flush_queue;
} u;
} __packed;
};
MODULE_DEVICE_TABLE(usb, kvaser_usb_table);
-static inline int kvaser_usb_send_msg(const struct kvaser_usb *dev,
- struct kvaser_msg *msg)
+static inline int kvaser_usb_send_cmd(const struct kvaser_usb *dev,
+ struct kvaser_cmd *cmd)
{
int actual_len;
return usb_bulk_msg(dev->udev,
usb_sndbulkpipe(dev->udev,
dev->bulk_out->bEndpointAddress),
- msg, msg->len, &actual_len,
+ cmd, cmd->len, &actual_len,
USB_SEND_TIMEOUT);
}
-static int kvaser_usb_wait_msg(const struct kvaser_usb *dev, u8 id,
- struct kvaser_msg *msg)
+static int kvaser_usb_wait_cmd(const struct kvaser_usb *dev, u8 id,
+ struct kvaser_cmd *cmd)
{
- struct kvaser_msg *tmp;
+ struct kvaser_cmd *tmp;
void *buf;
int actual_len;
int err;
goto end;
pos = 0;
- while (pos <= actual_len - MSG_HEADER_LEN) {
+ while (pos <= actual_len - CMD_HEADER_LEN) {
tmp = buf + pos;
- /* Handle messages crossing the USB endpoint max packet
+ /* Handle commands crossing the USB endpoint max packet
* size boundary. Check kvaser_usb_read_bulk_callback()
* for further details.
*/
}
if (tmp->id == id) {
- memcpy(msg, tmp, tmp->len);
+ memcpy(cmd, tmp, tmp->len);
goto end;
}
return err;
}
-static int kvaser_usb_send_simple_msg(const struct kvaser_usb *dev,
- u8 msg_id, int channel)
+static int kvaser_usb_send_simple_cmd(const struct kvaser_usb *dev,
+ u8 cmd_id, int channel)
{
- struct kvaser_msg *msg;
+ struct kvaser_cmd *cmd;
int rc;
- msg = kmalloc(sizeof(*msg), GFP_KERNEL);
- if (!msg)
+ cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
+ if (!cmd)
return -ENOMEM;
- msg->id = msg_id;
- msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_simple);
- msg->u.simple.channel = channel;
- msg->u.simple.tid = 0xff;
+ cmd->id = cmd_id;
+ cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple);
+ cmd->u.simple.channel = channel;
+ cmd->u.simple.tid = 0xff;
- rc = kvaser_usb_send_msg(dev, msg);
+ rc = kvaser_usb_send_cmd(dev, cmd);
- kfree(msg);
+ kfree(cmd);
return rc;
}
static int kvaser_usb_get_software_info(struct kvaser_usb *dev)
{
- struct kvaser_msg msg;
+ struct kvaser_cmd cmd;
int err;
- err = kvaser_usb_send_simple_msg(dev, CMD_GET_SOFTWARE_INFO, 0);
+ err = kvaser_usb_send_simple_cmd(dev, CMD_GET_SOFTWARE_INFO, 0);
if (err)
return err;
- err = kvaser_usb_wait_msg(dev, CMD_GET_SOFTWARE_INFO_REPLY, &msg);
+ err = kvaser_usb_wait_cmd(dev, CMD_GET_SOFTWARE_INFO_REPLY, &cmd);
if (err)
return err;
switch (dev->family) {
case KVASER_LEAF:
- dev->fw_version = le32_to_cpu(msg.u.leaf.softinfo.fw_version);
+ dev->fw_version = le32_to_cpu(cmd.u.leaf.softinfo.fw_version);
dev->max_tx_urbs =
- le16_to_cpu(msg.u.leaf.softinfo.max_outstanding_tx);
+ le16_to_cpu(cmd.u.leaf.softinfo.max_outstanding_tx);
break;
case KVASER_USBCAN:
- dev->fw_version = le32_to_cpu(msg.u.usbcan.softinfo.fw_version);
+ dev->fw_version = le32_to_cpu(cmd.u.usbcan.softinfo.fw_version);
dev->max_tx_urbs =
- le16_to_cpu(msg.u.usbcan.softinfo.max_outstanding_tx);
+ le16_to_cpu(cmd.u.usbcan.softinfo.max_outstanding_tx);
break;
}
static int kvaser_usb_get_card_info(struct kvaser_usb *dev)
{
- struct kvaser_msg msg;
+ struct kvaser_cmd cmd;
int err;
- err = kvaser_usb_send_simple_msg(dev, CMD_GET_CARD_INFO, 0);
+ err = kvaser_usb_send_simple_cmd(dev, CMD_GET_CARD_INFO, 0);
if (err)
return err;
- err = kvaser_usb_wait_msg(dev, CMD_GET_CARD_INFO_REPLY, &msg);
+ err = kvaser_usb_wait_cmd(dev, CMD_GET_CARD_INFO_REPLY, &cmd);
if (err)
return err;
- dev->nchannels = msg.u.cardinfo.nchannels;
+ dev->nchannels = cmd.u.cardinfo.nchannels;
if ((dev->nchannels > MAX_NET_DEVICES) ||
(dev->family == KVASER_USBCAN &&
dev->nchannels > MAX_USBCAN_NET_DEVICES))
}
static void kvaser_usb_tx_acknowledge(const struct kvaser_usb *dev,
- const struct kvaser_msg *msg)
+ const struct kvaser_cmd *cmd)
{
struct net_device_stats *stats;
struct kvaser_usb_tx_urb_context *context;
unsigned long flags;
u8 channel, tid;
- channel = msg->u.tx_acknowledge_header.channel;
- tid = msg->u.tx_acknowledge_header.tid;
+ channel = cmd->u.tx_acknowledge_header.channel;
+ tid = cmd->u.tx_acknowledge_header.tid;
if (channel >= dev->nchannels) {
dev_err(dev->udev->dev.parent,
spin_unlock_irqrestore(&priv->tx_contexts_lock, flags);
}
-static void kvaser_usb_simple_msg_callback(struct urb *urb)
+static void kvaser_usb_simple_cmd_callback(struct urb *urb)
{
struct net_device *netdev = urb->context;
urb->status);
}
-static int kvaser_usb_simple_msg_async(struct kvaser_usb_net_priv *priv,
- u8 msg_id)
+static int kvaser_usb_simple_cmd_async(struct kvaser_usb_net_priv *priv,
+ u8 cmd_id)
{
struct kvaser_usb *dev = priv->dev;
struct net_device *netdev = priv->netdev;
- struct kvaser_msg *msg;
+ struct kvaser_cmd *cmd;
struct urb *urb;
void *buf;
int err;
if (!urb)
return -ENOMEM;
- buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC);
+ buf = kmalloc(sizeof(struct kvaser_cmd), GFP_ATOMIC);
if (!buf) {
usb_free_urb(urb);
return -ENOMEM;
}
- msg = (struct kvaser_msg *)buf;
- msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_simple);
- msg->id = msg_id;
- msg->u.simple.channel = priv->channel;
+ cmd = (struct kvaser_cmd *)buf;
+ cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_simple);
+ cmd->id = cmd_id;
+ cmd->u.simple.channel = priv->channel;
usb_fill_bulk_urb(urb, dev->udev,
usb_sndbulkpipe(dev->udev,
dev->bulk_out->bEndpointAddress),
- buf, msg->len,
- kvaser_usb_simple_msg_callback, netdev);
+ buf, cmd->len,
+ kvaser_usb_simple_cmd_callback, netdev);
usb_anchor_urb(urb, &priv->tx_submitted);
err = usb_submit_urb(urb, GFP_ATOMIC);
if (es->status &
(M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
if (!priv->can.restart_ms)
- kvaser_usb_simple_msg_async(priv, CMD_STOP_CHIP);
+ kvaser_usb_simple_cmd_async(priv, CMD_STOP_CHIP);
netif_carrier_off(priv->netdev);
}
}
static void kvaser_usbcan_rx_error(const struct kvaser_usb *dev,
- const struct kvaser_msg *msg)
+ const struct kvaser_cmd *cmd)
{
struct kvaser_usb_error_summary es = { };
- switch (msg->id) {
+ switch (cmd->id) {
/* Sometimes errors are sent as unsolicited chip state events */
case CMD_CHIP_STATE_EVENT:
- es.channel = msg->u.usbcan.chip_state_event.channel;
- es.status = msg->u.usbcan.chip_state_event.status;
- es.txerr = msg->u.usbcan.chip_state_event.tx_errors_count;
- es.rxerr = msg->u.usbcan.chip_state_event.rx_errors_count;
+ es.channel = cmd->u.usbcan.chip_state_event.channel;
+ es.status = cmd->u.usbcan.chip_state_event.status;
+ es.txerr = cmd->u.usbcan.chip_state_event.tx_errors_count;
+ es.rxerr = cmd->u.usbcan.chip_state_event.rx_errors_count;
kvaser_usbcan_conditionally_rx_error(dev, &es);
break;
case CMD_CAN_ERROR_EVENT:
es.channel = 0;
- es.status = msg->u.usbcan.error_event.status_ch0;
- es.txerr = msg->u.usbcan.error_event.tx_errors_count_ch0;
- es.rxerr = msg->u.usbcan.error_event.rx_errors_count_ch0;
+ es.status = cmd->u.usbcan.error_event.status_ch0;
+ es.txerr = cmd->u.usbcan.error_event.tx_errors_count_ch0;
+ es.rxerr = cmd->u.usbcan.error_event.rx_errors_count_ch0;
es.usbcan.other_ch_status =
- msg->u.usbcan.error_event.status_ch1;
+ cmd->u.usbcan.error_event.status_ch1;
kvaser_usbcan_conditionally_rx_error(dev, &es);
/* The USBCAN firmware supports up to 2 channels.
*/
if (dev->nchannels == MAX_USBCAN_NET_DEVICES) {
es.channel = 1;
- es.status = msg->u.usbcan.error_event.status_ch1;
- es.txerr = msg->u.usbcan.error_event.tx_errors_count_ch1;
- es.rxerr = msg->u.usbcan.error_event.rx_errors_count_ch1;
+ es.status = cmd->u.usbcan.error_event.status_ch1;
+ es.txerr = cmd->u.usbcan.error_event.tx_errors_count_ch1;
+ es.rxerr = cmd->u.usbcan.error_event.rx_errors_count_ch1;
es.usbcan.other_ch_status =
- msg->u.usbcan.error_event.status_ch0;
+ cmd->u.usbcan.error_event.status_ch0;
kvaser_usbcan_conditionally_rx_error(dev, &es);
}
break;
default:
- dev_err(dev->udev->dev.parent, "Invalid msg id (%d)\n",
- msg->id);
+ dev_err(dev->udev->dev.parent, "Invalid cmd id (%d)\n",
+ cmd->id);
}
}
static void kvaser_leaf_rx_error(const struct kvaser_usb *dev,
- const struct kvaser_msg *msg)
+ const struct kvaser_cmd *cmd)
{
struct kvaser_usb_error_summary es = { };
- switch (msg->id) {
+ switch (cmd->id) {
case CMD_CAN_ERROR_EVENT:
- es.channel = msg->u.leaf.error_event.channel;
- es.status = msg->u.leaf.error_event.status;
- es.txerr = msg->u.leaf.error_event.tx_errors_count;
- es.rxerr = msg->u.leaf.error_event.rx_errors_count;
- es.leaf.error_factor = msg->u.leaf.error_event.error_factor;
+ es.channel = cmd->u.leaf.error_event.channel;
+ es.status = cmd->u.leaf.error_event.status;
+ es.txerr = cmd->u.leaf.error_event.tx_errors_count;
+ es.rxerr = cmd->u.leaf.error_event.rx_errors_count;
+ es.leaf.error_factor = cmd->u.leaf.error_event.error_factor;
break;
case CMD_LEAF_LOG_MESSAGE:
- es.channel = msg->u.leaf.log_message.channel;
- es.status = msg->u.leaf.log_message.data[0];
- es.txerr = msg->u.leaf.log_message.data[2];
- es.rxerr = msg->u.leaf.log_message.data[3];
- es.leaf.error_factor = msg->u.leaf.log_message.data[1];
+ es.channel = cmd->u.leaf.log_message.channel;
+ es.status = cmd->u.leaf.log_message.data[0];
+ es.txerr = cmd->u.leaf.log_message.data[2];
+ es.rxerr = cmd->u.leaf.log_message.data[3];
+ es.leaf.error_factor = cmd->u.leaf.log_message.data[1];
break;
case CMD_CHIP_STATE_EVENT:
- es.channel = msg->u.leaf.chip_state_event.channel;
- es.status = msg->u.leaf.chip_state_event.status;
- es.txerr = msg->u.leaf.chip_state_event.tx_errors_count;
- es.rxerr = msg->u.leaf.chip_state_event.rx_errors_count;
+ es.channel = cmd->u.leaf.chip_state_event.channel;
+ es.status = cmd->u.leaf.chip_state_event.status;
+ es.txerr = cmd->u.leaf.chip_state_event.tx_errors_count;
+ es.rxerr = cmd->u.leaf.chip_state_event.rx_errors_count;
es.leaf.error_factor = 0;
break;
default:
- dev_err(dev->udev->dev.parent, "Invalid msg id (%d)\n",
- msg->id);
+ dev_err(dev->udev->dev.parent, "Invalid cmd id (%d)\n",
+ cmd->id);
return;
}
}
static void kvaser_usb_rx_can_err(const struct kvaser_usb_net_priv *priv,
- const struct kvaser_msg *msg)
+ const struct kvaser_cmd *cmd)
{
struct can_frame *cf;
struct sk_buff *skb;
struct net_device_stats *stats = &priv->netdev->stats;
- if (msg->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
+ if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
MSG_FLAG_NERR)) {
netdev_err(priv->netdev, "Unknown error (flags: 0x%02x)\n",
- msg->u.rx_can_header.flag);
+ cmd->u.rx_can_header.flag);
stats->rx_errors++;
return;
}
- if (msg->u.rx_can_header.flag & MSG_FLAG_OVERRUN) {
+ if (cmd->u.rx_can_header.flag & MSG_FLAG_OVERRUN) {
stats->rx_over_errors++;
stats->rx_errors++;
}
static void kvaser_usb_rx_can_msg(const struct kvaser_usb *dev,
- const struct kvaser_msg *msg)
+ const struct kvaser_cmd *cmd)
{
struct kvaser_usb_net_priv *priv;
struct can_frame *cf;
struct sk_buff *skb;
struct net_device_stats *stats;
- u8 channel = msg->u.rx_can_header.channel;
- const u8 *rx_msg = NULL; /* GCC */
+ u8 channel = cmd->u.rx_can_header.channel;
+ const u8 *rx_data = NULL; /* GCC */
if (channel >= dev->nchannels) {
dev_err(dev->udev->dev.parent,
priv = dev->nets[channel];
stats = &priv->netdev->stats;
- if ((msg->u.rx_can_header.flag & MSG_FLAG_ERROR_FRAME) &&
- (dev->family == KVASER_LEAF && msg->id == CMD_LEAF_LOG_MESSAGE)) {
- kvaser_leaf_rx_error(dev, msg);
+ if ((cmd->u.rx_can_header.flag & MSG_FLAG_ERROR_FRAME) &&
+ (dev->family == KVASER_LEAF && cmd->id == CMD_LEAF_LOG_MESSAGE)) {
+ kvaser_leaf_rx_error(dev, cmd);
return;
- } else if (msg->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
+ } else if (cmd->u.rx_can_header.flag & (MSG_FLAG_ERROR_FRAME |
MSG_FLAG_NERR |
MSG_FLAG_OVERRUN)) {
- kvaser_usb_rx_can_err(priv, msg);
+ kvaser_usb_rx_can_err(priv, cmd);
return;
- } else if (msg->u.rx_can_header.flag & ~MSG_FLAG_REMOTE_FRAME) {
+ } else if (cmd->u.rx_can_header.flag & ~MSG_FLAG_REMOTE_FRAME) {
netdev_warn(priv->netdev,
"Unhandled frame (flags: 0x%02x)",
- msg->u.rx_can_header.flag);
+ cmd->u.rx_can_header.flag);
return;
}
switch (dev->family) {
case KVASER_LEAF:
- rx_msg = msg->u.leaf.rx_can.msg;
+ rx_data = cmd->u.leaf.rx_can.data;
break;
case KVASER_USBCAN:
- rx_msg = msg->u.usbcan.rx_can.msg;
+ rx_data = cmd->u.usbcan.rx_can.data;
break;
}
return;
}
- if (dev->family == KVASER_LEAF && msg->id == CMD_LEAF_LOG_MESSAGE) {
- cf->can_id = le32_to_cpu(msg->u.leaf.log_message.id);
+ if (dev->family == KVASER_LEAF && cmd->id == CMD_LEAF_LOG_MESSAGE) {
+ cf->can_id = le32_to_cpu(cmd->u.leaf.log_message.id);
if (cf->can_id & KVASER_EXTENDED_FRAME)
cf->can_id &= CAN_EFF_MASK | CAN_EFF_FLAG;
else
cf->can_id &= CAN_SFF_MASK;
- cf->can_dlc = get_can_dlc(msg->u.leaf.log_message.dlc);
+ cf->can_dlc = get_can_dlc(cmd->u.leaf.log_message.dlc);
- if (msg->u.leaf.log_message.flags & MSG_FLAG_REMOTE_FRAME)
+ if (cmd->u.leaf.log_message.flags & MSG_FLAG_REMOTE_FRAME)
cf->can_id |= CAN_RTR_FLAG;
else
- memcpy(cf->data, &msg->u.leaf.log_message.data,
+ memcpy(cf->data, &cmd->u.leaf.log_message.data,
cf->can_dlc);
} else {
- cf->can_id = ((rx_msg[0] & 0x1f) << 6) | (rx_msg[1] & 0x3f);
+ cf->can_id = ((rx_data[0] & 0x1f) << 6) | (rx_data[1] & 0x3f);
- if (msg->id == CMD_RX_EXT_MESSAGE) {
+ if (cmd->id == CMD_RX_EXT_MESSAGE) {
cf->can_id <<= 18;
- cf->can_id |= ((rx_msg[2] & 0x0f) << 14) |
- ((rx_msg[3] & 0xff) << 6) |
- (rx_msg[4] & 0x3f);
+ cf->can_id |= ((rx_data[2] & 0x0f) << 14) |
+ ((rx_data[3] & 0xff) << 6) |
+ (rx_data[4] & 0x3f);
cf->can_id |= CAN_EFF_FLAG;
}
- cf->can_dlc = get_can_dlc(rx_msg[5]);
+ cf->can_dlc = get_can_dlc(rx_data[5]);
- if (msg->u.rx_can_header.flag & MSG_FLAG_REMOTE_FRAME)
+ if (cmd->u.rx_can_header.flag & MSG_FLAG_REMOTE_FRAME)
cf->can_id |= CAN_RTR_FLAG;
else
- memcpy(cf->data, &rx_msg[6],
- cf->can_dlc);
+ memcpy(cf->data, &rx_data[6], cf->can_dlc);
}
stats->rx_packets++;
}
static void kvaser_usb_start_chip_reply(const struct kvaser_usb *dev,
- const struct kvaser_msg *msg)
+ const struct kvaser_cmd *cmd)
{
struct kvaser_usb_net_priv *priv;
- u8 channel = msg->u.simple.channel;
+ u8 channel = cmd->u.simple.channel;
if (channel >= dev->nchannels) {
dev_err(dev->udev->dev.parent,
}
static void kvaser_usb_stop_chip_reply(const struct kvaser_usb *dev,
- const struct kvaser_msg *msg)
+ const struct kvaser_cmd *cmd)
{
struct kvaser_usb_net_priv *priv;
- u8 channel = msg->u.simple.channel;
+ u8 channel = cmd->u.simple.channel;
if (channel >= dev->nchannels) {
dev_err(dev->udev->dev.parent,
complete(&priv->stop_comp);
}
-static void kvaser_usb_handle_message(const struct kvaser_usb *dev,
- const struct kvaser_msg *msg)
+static void kvaser_usb_handle_cmd(const struct kvaser_usb *dev,
+ const struct kvaser_cmd *cmd)
{
- switch (msg->id) {
+ switch (cmd->id) {
case CMD_START_CHIP_REPLY:
- kvaser_usb_start_chip_reply(dev, msg);
+ kvaser_usb_start_chip_reply(dev, cmd);
break;
case CMD_STOP_CHIP_REPLY:
- kvaser_usb_stop_chip_reply(dev, msg);
+ kvaser_usb_stop_chip_reply(dev, cmd);
break;
case CMD_RX_STD_MESSAGE:
case CMD_RX_EXT_MESSAGE:
- kvaser_usb_rx_can_msg(dev, msg);
+ kvaser_usb_rx_can_msg(dev, cmd);
break;
case CMD_LEAF_LOG_MESSAGE:
if (dev->family != KVASER_LEAF)
goto warn;
- kvaser_usb_rx_can_msg(dev, msg);
+ kvaser_usb_rx_can_msg(dev, cmd);
break;
case CMD_CHIP_STATE_EVENT:
case CMD_CAN_ERROR_EVENT:
if (dev->family == KVASER_LEAF)
- kvaser_leaf_rx_error(dev, msg);
+ kvaser_leaf_rx_error(dev, cmd);
else
- kvaser_usbcan_rx_error(dev, msg);
+ kvaser_usbcan_rx_error(dev, cmd);
break;
case CMD_TX_ACKNOWLEDGE:
- kvaser_usb_tx_acknowledge(dev, msg);
+ kvaser_usb_tx_acknowledge(dev, cmd);
break;
- /* Ignored messages */
+ /* Ignored commands */
case CMD_USBCAN_CLOCK_OVERFLOW_EVENT:
if (dev->family != KVASER_USBCAN)
goto warn;
default:
warn: dev_warn(dev->udev->dev.parent,
- "Unhandled message (%d)\n", msg->id);
+ "Unhandled command (%d)\n", cmd->id);
break;
}
}
static void kvaser_usb_read_bulk_callback(struct urb *urb)
{
struct kvaser_usb *dev = urb->context;
- struct kvaser_msg *msg;
+ struct kvaser_cmd *cmd;
int pos = 0;
int err, i;
goto resubmit_urb;
}
- while (pos <= (int)(urb->actual_length - MSG_HEADER_LEN)) {
- msg = urb->transfer_buffer + pos;
+ while (pos <= (int)(urb->actual_length - CMD_HEADER_LEN)) {
+ cmd = urb->transfer_buffer + pos;
- /* The Kvaser firmware can only read and write messages that
+ /* The Kvaser firmware can only read and write commands that
* does not cross the USB's endpoint wMaxPacketSize boundary.
* If a follow-up command crosses such boundary, firmware puts
* a placeholder zero-length command in its place then aligns
* Handle such cases or we're going to miss a significant
* number of events in case of a heavy rx load on the bus.
*/
- if (msg->len == 0) {
+ if (cmd->len == 0) {
pos = round_up(pos, le16_to_cpu(dev->bulk_in->
wMaxPacketSize));
continue;
}
- if (pos + msg->len > urb->actual_length) {
+ if (pos + cmd->len > urb->actual_length) {
dev_err_ratelimited(dev->udev->dev.parent,
"Format error\n");
break;
}
- kvaser_usb_handle_message(dev, msg);
- pos += msg->len;
+ kvaser_usb_handle_cmd(dev, cmd);
+ pos += cmd->len;
}
resubmit_urb:
static int kvaser_usb_set_opt_mode(const struct kvaser_usb_net_priv *priv)
{
- struct kvaser_msg *msg;
+ struct kvaser_cmd *cmd;
int rc;
- msg = kmalloc(sizeof(*msg), GFP_KERNEL);
- if (!msg)
+ cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
+ if (!cmd)
return -ENOMEM;
- msg->id = CMD_SET_CTRL_MODE;
- msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_ctrl_mode);
- msg->u.ctrl_mode.tid = 0xff;
- msg->u.ctrl_mode.channel = priv->channel;
+ cmd->id = CMD_SET_CTRL_MODE;
+ cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_ctrl_mode);
+ cmd->u.ctrl_mode.tid = 0xff;
+ cmd->u.ctrl_mode.channel = priv->channel;
if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
- msg->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT;
+ cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_SILENT;
else
- msg->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL;
+ cmd->u.ctrl_mode.ctrl_mode = KVASER_CTRL_MODE_NORMAL;
- rc = kvaser_usb_send_msg(priv->dev, msg);
+ rc = kvaser_usb_send_cmd(priv->dev, cmd);
- kfree(msg);
+ kfree(cmd);
return rc;
}
init_completion(&priv->start_comp);
- err = kvaser_usb_send_simple_msg(priv->dev, CMD_START_CHIP,
+ err = kvaser_usb_send_simple_cmd(priv->dev, CMD_START_CHIP,
priv->channel);
if (err)
return err;
init_completion(&priv->stop_comp);
- err = kvaser_usb_send_simple_msg(priv->dev, CMD_STOP_CHIP,
+ err = kvaser_usb_send_simple_cmd(priv->dev, CMD_STOP_CHIP,
priv->channel);
if (err)
return err;
static int kvaser_usb_flush_queue(struct kvaser_usb_net_priv *priv)
{
- struct kvaser_msg *msg;
+ struct kvaser_cmd *cmd;
int rc;
- msg = kmalloc(sizeof(*msg), GFP_KERNEL);
- if (!msg)
+ cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
+ if (!cmd)
return -ENOMEM;
- msg->id = CMD_FLUSH_QUEUE;
- msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_flush_queue);
- msg->u.flush_queue.channel = priv->channel;
- msg->u.flush_queue.flags = 0x00;
+ cmd->id = CMD_FLUSH_QUEUE;
+ cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_flush_queue);
+ cmd->u.flush_queue.channel = priv->channel;
+ cmd->u.flush_queue.flags = 0x00;
- rc = kvaser_usb_send_msg(priv->dev, msg);
+ rc = kvaser_usb_send_cmd(priv->dev, cmd);
- kfree(msg);
+ kfree(cmd);
return rc;
}
if (err)
netdev_warn(netdev, "Cannot flush queue, error %d\n", err);
- err = kvaser_usb_send_simple_msg(dev, CMD_RESET_CHIP, priv->channel);
+ err = kvaser_usb_send_simple_cmd(dev, CMD_RESET_CHIP, priv->channel);
if (err)
netdev_warn(netdev, "Cannot reset card, error %d\n", err);
struct kvaser_usb_tx_urb_context *context = NULL;
struct urb *urb;
void *buf;
- struct kvaser_msg *msg;
+ struct kvaser_cmd *cmd;
int i, err, ret = NETDEV_TX_OK;
- u8 *msg_tx_can_flags = NULL; /* GCC */
+ u8 *cmd_tx_can_flags = NULL; /* GCC */
unsigned long flags;
if (can_dropped_invalid_skb(netdev, skb))
return NETDEV_TX_OK;
}
- buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC);
+ buf = kmalloc(sizeof(struct kvaser_cmd), GFP_ATOMIC);
if (!buf) {
stats->tx_dropped++;
dev_kfree_skb(skb);
goto freeurb;
}
- msg = buf;
- msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_tx_can);
- msg->u.tx_can.channel = priv->channel;
+ cmd = buf;
+ cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_tx_can);
+ cmd->u.tx_can.channel = priv->channel;
switch (dev->family) {
case KVASER_LEAF:
- msg_tx_can_flags = &msg->u.tx_can.leaf.flags;
+ cmd_tx_can_flags = &cmd->u.tx_can.leaf.flags;
break;
case KVASER_USBCAN:
- msg_tx_can_flags = &msg->u.tx_can.usbcan.flags;
+ cmd_tx_can_flags = &cmd->u.tx_can.usbcan.flags;
break;
}
- *msg_tx_can_flags = 0;
+ *cmd_tx_can_flags = 0;
if (cf->can_id & CAN_EFF_FLAG) {
- msg->id = CMD_TX_EXT_MESSAGE;
- msg->u.tx_can.msg[0] = (cf->can_id >> 24) & 0x1f;
- msg->u.tx_can.msg[1] = (cf->can_id >> 18) & 0x3f;
- msg->u.tx_can.msg[2] = (cf->can_id >> 14) & 0x0f;
- msg->u.tx_can.msg[3] = (cf->can_id >> 6) & 0xff;
- msg->u.tx_can.msg[4] = cf->can_id & 0x3f;
+ cmd->id = CMD_TX_EXT_MESSAGE;
+ cmd->u.tx_can.data[0] = (cf->can_id >> 24) & 0x1f;
+ cmd->u.tx_can.data[1] = (cf->can_id >> 18) & 0x3f;
+ cmd->u.tx_can.data[2] = (cf->can_id >> 14) & 0x0f;
+ cmd->u.tx_can.data[3] = (cf->can_id >> 6) & 0xff;
+ cmd->u.tx_can.data[4] = cf->can_id & 0x3f;
} else {
- msg->id = CMD_TX_STD_MESSAGE;
- msg->u.tx_can.msg[0] = (cf->can_id >> 6) & 0x1f;
- msg->u.tx_can.msg[1] = cf->can_id & 0x3f;
+ cmd->id = CMD_TX_STD_MESSAGE;
+ cmd->u.tx_can.data[0] = (cf->can_id >> 6) & 0x1f;
+ cmd->u.tx_can.data[1] = cf->can_id & 0x3f;
}
- msg->u.tx_can.msg[5] = cf->can_dlc;
- memcpy(&msg->u.tx_can.msg[6], cf->data, cf->can_dlc);
+ cmd->u.tx_can.data[5] = cf->can_dlc;
+ memcpy(&cmd->u.tx_can.data[6], cf->data, cf->can_dlc);
if (cf->can_id & CAN_RTR_FLAG)
- *msg_tx_can_flags |= MSG_FLAG_REMOTE_FRAME;
+ *cmd_tx_can_flags |= MSG_FLAG_REMOTE_FRAME;
spin_lock_irqsave(&priv->tx_contexts_lock, flags);
for (i = 0; i < dev->max_tx_urbs; i++) {
context->priv = priv;
context->dlc = cf->can_dlc;
- msg->u.tx_can.tid = context->echo_index;
+ cmd->u.tx_can.tid = context->echo_index;
usb_fill_bulk_urb(urb, dev->udev,
usb_sndbulkpipe(dev->udev,
dev->bulk_out->bEndpointAddress),
- buf, msg->len,
+ buf, cmd->len,
kvaser_usb_write_bulk_callback, context);
usb_anchor_urb(urb, &priv->tx_submitted);
struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
struct can_bittiming *bt = &priv->can.bittiming;
struct kvaser_usb *dev = priv->dev;
- struct kvaser_msg *msg;
+ struct kvaser_cmd *cmd;
int rc;
- msg = kmalloc(sizeof(*msg), GFP_KERNEL);
- if (!msg)
+ cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
+ if (!cmd)
return -ENOMEM;
- msg->id = CMD_SET_BUS_PARAMS;
- msg->len = MSG_HEADER_LEN + sizeof(struct kvaser_msg_busparams);
- msg->u.busparams.channel = priv->channel;
- msg->u.busparams.tid = 0xff;
- msg->u.busparams.bitrate = cpu_to_le32(bt->bitrate);
- msg->u.busparams.sjw = bt->sjw;
- msg->u.busparams.tseg1 = bt->prop_seg + bt->phase_seg1;
- msg->u.busparams.tseg2 = bt->phase_seg2;
+ cmd->id = CMD_SET_BUS_PARAMS;
+ cmd->len = CMD_HEADER_LEN + sizeof(struct kvaser_cmd_busparams);
+ cmd->u.busparams.channel = priv->channel;
+ cmd->u.busparams.tid = 0xff;
+ cmd->u.busparams.bitrate = cpu_to_le32(bt->bitrate);
+ cmd->u.busparams.sjw = bt->sjw;
+ cmd->u.busparams.tseg1 = bt->prop_seg + bt->phase_seg1;
+ cmd->u.busparams.tseg2 = bt->phase_seg2;
if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
- msg->u.busparams.no_samp = 3;
+ cmd->u.busparams.no_samp = 3;
else
- msg->u.busparams.no_samp = 1;
+ cmd->u.busparams.no_samp = 1;
- rc = kvaser_usb_send_msg(dev, msg);
+ rc = kvaser_usb_send_cmd(dev, cmd);
- kfree(msg);
+ kfree(cmd);
return rc;
}
switch (mode) {
case CAN_MODE_START:
- err = kvaser_usb_simple_msg_async(priv, CMD_START_CHIP);
+ err = kvaser_usb_simple_cmd_async(priv, CMD_START_CHIP);
if (err)
return err;
break;
struct kvaser_usb_net_priv *priv;
int err;
- err = kvaser_usb_send_simple_msg(dev, CMD_RESET_CHIP, channel);
+ err = kvaser_usb_send_simple_cmd(dev, CMD_RESET_CHIP, channel);
if (err)
return err;
projects / platform / kernel / linux-starfive.git / commitdiff