[{"id":2572028,"web_url":"http://patchwork.ozlabs.org/comment/2572028/","msgid":"","list_archive_url":null,"date":"2020-11-08T13:03:36","subject":"Re: [PATCH v5] can: usb: etas_es58X: add support for ETAS ES58X CAN\n USB interfaces","submitter":{"id":1450,"url":"http://patchwork.ozlabs.org/api/people/1450/","name":"Oliver Hartkopp","email":"socketcan@hartkopp.net"},"content":"Hello Vincent,\n\nOn 07.11.20 15:18, Vincent Mailhol wrote:\n> This driver supports the ES581.4, ES582.1 and ES584.1 interfaces from\n> ETAS GmbH (https://www.etas.com/en/products/es58x.php).\n> \n> Co-developed-by: Arunachalam Santhanam \n> Signed-off-by: Arunachalam Santhanam \n> Signed-off-by: Vincent Mailhol \n> --\n> \n> *Warning*: below patch series are needed to compile:\n> * https://lore.kernel.org/linux-can/20201029083218.41505-1-socketcan@hartkopp.net/\n> * https://lore.kernel.org/linux-can/20201029133123.2196-1-socketcan@hartkopp.net/\n\nI will send a V5 patch set (only improved comments and documentation) \ntoday or tommorrow morning based on net-next.\n\nBest regards,\nOliver\n\n> \n> Changes in v5 (2020-11-07):\n> - Add support for DLC greater than 8.\n> - All other patches from the previous series were either accepted or\n> dismissed. As such, this is not a serie any more but a single\n> patch.\n> \n> Changes in v4 (2020-10-17):\n> - Remove struct es58x_abstracted_can_frame.\n> branch is already done inside net/can/af_can.c#can_send().\n> - Fix formating (spaces, comment style).\n> - Transform macros into static inline functions when possible.\n> - Fix the ctrlmode_supported flags in es581_4.c and removed\n> misleading comments in enum es58x_samples_per_bit.\n> - Rename enums according to the type.\n> - Remove function es58x_can_put_echo_skb().\n> Reference: https://lkml.org/lkml/2020/10/10/53\n> \n> Changes in v3 (2020-10-03):\n> - Remove all the calls to likely() and unlikely().\n> Reference: https://lkml.org/lkml/2020/9/30/995\n> \n> Changes in v2 (2020-09-30):\n> - Fixed -W1 warnings (v1 was tested with GCC -WExtra but not with -W1).\n> ---\n> drivers/net/can/usb/Kconfig | 9 +\n> drivers/net/can/usb/Makefile | 1 +\n> drivers/net/can/usb/etas_es58x/Makefile | 3 +\n> drivers/net/can/usb/etas_es58x/es581_4.c | 552 ++++\n> drivers/net/can/usb/etas_es58x/es581_4.h | 206 ++\n> drivers/net/can/usb/etas_es58x/es58x_core.c | 2627 +++++++++++++++++++\n> drivers/net/can/usb/etas_es58x/es58x_core.h | 712 +++++\n> drivers/net/can/usb/etas_es58x/es58x_fd.c | 657 +++++\n> drivers/net/can/usb/etas_es58x/es58x_fd.h | 242 ++\n> 9 files changed, 5009 insertions(+)\n> create mode 100644 drivers/net/can/usb/etas_es58x/Makefile\n> create mode 100644 drivers/net/can/usb/etas_es58x/es581_4.c\n> create mode 100644 drivers/net/can/usb/etas_es58x/es581_4.h\n> create mode 100644 drivers/net/can/usb/etas_es58x/es58x_core.c\n> create mode 100644 drivers/net/can/usb/etas_es58x/es58x_core.h\n> create mode 100644 drivers/net/can/usb/etas_es58x/es58x_fd.c\n> create mode 100644 drivers/net/can/usb/etas_es58x/es58x_fd.h\n> \n> diff --git a/drivers/net/can/usb/Kconfig b/drivers/net/can/usb/Kconfig\n> index bcb331b0c958..ffb0cd084571 100644\n> --- a/drivers/net/can/usb/Kconfig\n> +++ b/drivers/net/can/usb/Kconfig\n> @@ -20,6 +20,15 @@ config CAN_ESD_USB2\n> \t This driver supports the CAN-USB/2 interface\n> \t from esd electronic system design gmbh (http://www.esd.eu).\n> \n> +config CAN_ETAS_ES58X\n> +\ttristate \"ETAS ES58X CAN/USB interfaces\"\n> +\thelp\n> +\t This driver supports the ES581.4, ES582.1 and ES584.1 interfaces\n> +\t from ETAS GmbH (https://www.etas.com/en/products/es58x.php).\n> +\n> +\t To compile this driver as a module, choose M here: the module\n> +\t will be called etas_es58x.\n> +\n> config CAN_GS_USB\n> \ttristate \"Geschwister Schneider UG interfaces\"\n> \thelp\n> diff --git a/drivers/net/can/usb/Makefile b/drivers/net/can/usb/Makefile\n> index aa0f17c0b2ed..748cf31a0d53 100644\n> --- a/drivers/net/can/usb/Makefile\n> +++ b/drivers/net/can/usb/Makefile\n> @@ -6,6 +6,7 @@\n> obj-$(CONFIG_CAN_8DEV_USB) += usb_8dev.o\n> obj-$(CONFIG_CAN_EMS_USB) += ems_usb.o\n> obj-$(CONFIG_CAN_ESD_USB2) += esd_usb2.o\n> +obj-$(CONFIG_CAN_ETAS_ES58X) += etas_es58x/\n> obj-$(CONFIG_CAN_GS_USB) += gs_usb.o\n> obj-$(CONFIG_CAN_KVASER_USB) += kvaser_usb/\n> obj-$(CONFIG_CAN_MCBA_USB) += mcba_usb.o\n> diff --git a/drivers/net/can/usb/etas_es58x/Makefile b/drivers/net/can/usb/etas_es58x/Makefile\n> new file mode 100644\n> index 000000000000..a129b4aa0215\n> --- /dev/null\n> +++ b/drivers/net/can/usb/etas_es58x/Makefile\n> @@ -0,0 +1,3 @@\n> +# SPDX-License-Identifier: GPL-2.0\n> +obj-$(CONFIG_CAN_ETAS_ES58X) += etas_es58x.o\n> +etas_es58x-y = es58x_core.o es581_4.o es58x_fd.o\n> diff --git a/drivers/net/can/usb/etas_es58x/es581_4.c b/drivers/net/can/usb/etas_es58x/es581_4.c\n> new file mode 100644\n> index 000000000000..ded85b06c31a\n> --- /dev/null\n> +++ b/drivers/net/can/usb/etas_es58x/es581_4.c\n> @@ -0,0 +1,552 @@\n> +// SPDX-License-Identifier: GPL-2.0\n> +\n> +/* Driver for ETAS GmbH ES58X USB CAN(-FD) Bus Interfaces.\n> + *\n> + * File es581_4.c: Adds support to ETAS ES581.4.\n> + *\n> + * Copyright (C) 2019 Robert Bosch Engineering and Business\n> + * Solutions. All rights reserved.\n> + * Copyright (C) 2020 ETAS K.K.. All rights reserved.\n> + */\n> +\n> +#include \n> +#include \n> +\n> +#include \"es58x_core.h\"\n> +#include \"es581_4.h\"\n> +\n> +/**\n> + * es58x_sizeof_rx_tx_msg() - Calculate the actual length of the\n> + *\tstructure of a rx or tx message.\n> + * @msg: message of variable length, must have a dlc field.\n> + *\n> + * Even if RTR frames have actually no payload, the ES58X devices\n> + * still expect it. Must be a macro in order to retrieve the actual\n> + * size using offsetof() and typeof().\n> + *\n> + * Return: length of the message.\n> + */\n> +#define es581_4_sizeof_rx_tx_msg(msg)\t\t\t\t\\\n> +\toffsetof(typeof(msg), data[can_get_cc_len((msg).dlc)])\n> +\n> +static u16 es581_4_get_msg_len(const union es58x_urb_cmd *urb_cmd)\n> +{\n> +\treturn get_unaligned_le16(&urb_cmd->es581_4_urb_cmd.msg_len);\n> +}\n> +\n> +static int es581_4_rx_loopback_msg(struct es58x_device *es58x_dev,\n> +\t\t\t\t const struct es581_4_urb_cmd\n> +\t\t\t\t *es581_4_urb_cmd)\n> +{\n> +\tstruct net_device *netdev;\n> +\tconst struct es581_4_bulk_rx_loopback_msg *bulk_rx_loopback_msg;\n> +\tconst struct es581_4_rx_loopback_msg *rx_loopback_msg;\n> +\tu64 *tstamps = es58x_dev->timestamps;\n> +\tu16 msg_len;\n> +\tu32 first_packet_idx, packet_idx;\n> +\tunsigned int dropped = 0;\n> +\tint i, num_element, ret;\n> +\n> +\tbulk_rx_loopback_msg = &es581_4_urb_cmd->bulk_rx_loopback_msg;\n> +\tmsg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len) -\n> +\t sizeof(bulk_rx_loopback_msg->channel_no);\n> +\tnum_element =\n> +\t es58x_msg_num_element(es58x_dev->dev,\n> +\t\t\t\t bulk_rx_loopback_msg->rx_loopback_msg,\n> +\t\t\t\t msg_len);\n> +\tif (num_element <= 0)\n> +\t\treturn num_element;\n> +\n> +\tret = es58x_get_netdev(es58x_dev, bulk_rx_loopback_msg->channel_no,\n> +\t\t\t &netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\trx_loopback_msg = &bulk_rx_loopback_msg->rx_loopback_msg[0];\n> +\tfirst_packet_idx = get_unaligned_le32(&rx_loopback_msg->packet_idx);\n> +\tpacket_idx = first_packet_idx;\n> +\tfor (i = 0; i < num_element; i++) {\n> +\t\trx_loopback_msg = &bulk_rx_loopback_msg->rx_loopback_msg[i];\n> +\t\tif (get_unaligned_le32(&rx_loopback_msg->packet_idx)\n> +\t\t == packet_idx - 1) {\n> +\t\t\tif (net_ratelimit())\n> +\t\t\t\tnetdev_warn(netdev,\n> +\t\t\t\t\t \"Received loopback packet idx %u twice\\n\",\n> +\t\t\t\t\t packet_idx - 1);\n> +\t\t\tdropped++;\n> +\t\t\tcontinue;\n> +\t\t}\n> +\t\tif (get_unaligned_le32(&rx_loopback_msg->packet_idx)\n> +\t\t != packet_idx) {\n> +\t\t\tnetdev_err(netdev, \"Packet idx jumped from %u to %u\\n\",\n> +\t\t\t\t packet_idx - 1, rx_loopback_msg->packet_idx);\n> +\t\t\treturn -EBADMSG;\n> +\t\t}\n> +\n> +\t\ttstamps[i] = get_unaligned_le64(&rx_loopback_msg->timestamp);\n> +\t\tpacket_idx++;\n> +\t}\n> +\n> +\tnetdev->stats.tx_dropped += dropped;\n> +\treturn es58x_can_get_echo_skb(netdev, first_packet_idx,\n> +\t\t\t\t tstamps, num_element - dropped);\n> +}\n> +\n> +static int es581_4_rx_can_msg(struct es58x_device *es58x_dev,\n> +\t\t\t const struct es581_4_urb_cmd *es581_4_urb_cmd,\n> +\t\t\t u16 msg_len)\n> +{\n> +\tconst struct device *dev = es58x_dev->dev;\n> +\tstruct net_device *netdev;\n> +\tint pkts, num_element, channel_no, ret;\n> +\n> +\tnum_element = es58x_msg_num_element(dev, es581_4_urb_cmd->rx_can_msg,\n> +\t\t\t\t\t msg_len);\n> +\tif (num_element <= 0)\n> +\t\treturn num_element;\n> +\n> +\tchannel_no = es581_4_urb_cmd->rx_can_msg[0].channel_no;\n> +\tret = es58x_get_netdev(es58x_dev, channel_no, &netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\tif (!netif_running(netdev)) {\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_info(netdev,\n> +\t\t\t\t \"%s: %s is down, dropping %d rx packets\\n\",\n> +\t\t\t\t __func__, netdev->name, num_element);\n> +\t\tnetdev->stats.rx_dropped += num_element;\n> +\t\treturn 0;\n> +\t}\n> +\n> +\tfor (pkts = 0; pkts < num_element; pkts++) {\n> +\t\tconst struct es581_4_rx_can_msg *rx_can_msg =\n> +\t\t &es581_4_urb_cmd->rx_can_msg[pkts];\n> +\t\tu64 tstamp = get_unaligned_le64(&rx_can_msg->timestamp);\n> +\t\tcanid_t can_id = get_unaligned_le32(&rx_can_msg->can_id);\n> +\n> +\t\tif (channel_no != rx_can_msg->channel_no) {\n> +\t\t\tnetdev_err(netdev,\n> +\t\t\t\t \"%s: channel_no changed from %d to %d\\n\",\n> +\t\t\t\t __func__,\n> +\t\t\t\t channel_no, rx_can_msg->channel_no);\n> +\t\t\treturn -EBADMSG;\n> +\t\t}\n> +\n> +\t\tret = es58x_rx_can_msg(netdev, tstamp, rx_can_msg->data,\n> +\t\t\t\t can_id, rx_can_msg->flags,\n> +\t\t\t\t rx_can_msg->dlc);\n> +\t\tif (ret)\n> +\t\t\tbreak;\n> +\t}\n> +\n> +\treturn ret;\n> +}\n> +\n> +static int es581_4_rx_err_msg(struct es58x_device *es58x_dev,\n> +\t\t\t const struct es581_4_rx_err_msg *rx_err_msg)\n> +{\n> +\tstruct net_device *netdev;\n> +\tenum es58x_err error = get_unaligned_le32(&rx_err_msg->error);\n> +\tint ret;\n> +\n> +\tret = es58x_get_netdev(es58x_dev, rx_err_msg->channel_no, &netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\treturn es58x_rx_err_msg(netdev, error, 0,\n> +\t\t\t\tget_unaligned_le64(&rx_err_msg->timestamp));\n> +}\n> +\n> +static int es581_4_rx_event_msg(struct es58x_device *es58x_dev,\n> +\t\t\t\tconst struct es581_4_rx_event_msg *rx_event_msg)\n> +{\n> +\tstruct net_device *netdev;\n> +\tenum es58x_event event = get_unaligned_le32(&rx_event_msg->event);\n> +\tint ret;\n> +\n> +\tret = es58x_get_netdev(es58x_dev, rx_event_msg->channel_no, &netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\treturn es58x_rx_err_msg(netdev, 0, event,\n> +\t\t\t\tget_unaligned_le64(&rx_event_msg->timestamp));\n> +}\n> +\n> +static int es581_4_rx_cmd_ret_u32(struct es58x_device *es58x_dev,\n> +\t\t\t\t const struct es581_4_urb_cmd *es581_4_urb_cmd,\n> +\t\t\t\t enum es58x_ret_type ret_type)\n> +{\n> +\tstruct net_device *netdev;\n> +\tconst struct es581_4_rx_dev_ret *rx_dev_ret;\n> +\tu16 msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len);\n> +\tenum es58x_ret_u32 rx_cmd_ret_u32;\n> +\tint ret;\n> +\n> +\tret = es58x_check_msg_len(es58x_dev->dev,\n> +\t\t\t\t es581_4_urb_cmd->rx_dev_ret, msg_len);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\trx_dev_ret = &es581_4_urb_cmd->rx_dev_ret;\n> +\n> +\tret = es58x_get_netdev(es58x_dev, rx_dev_ret->channel_no, &netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\trx_cmd_ret_u32 = get_unaligned_le32(&rx_dev_ret->rx_cmd_ret_le32);\n> +\treturn es58x_rx_cmd_ret_u32(netdev, ret_type, rx_cmd_ret_u32);\n> +}\n> +\n> +static int es581_4_tx_ack_msg(struct es58x_device *es58x_dev,\n> +\t\t\t const struct es581_4_urb_cmd *es581_4_urb_cmd)\n> +{\n> +\tstruct net_device *netdev;\n> +\tconst struct es581_4_tx_ack_msg *tx_ack_msg;\n> +\tu16 msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len);\n> +\tint ret;\n> +\n> +\ttx_ack_msg = &es581_4_urb_cmd->tx_ack_msg;\n> +\tret = es58x_check_msg_len(es58x_dev->dev, *tx_ack_msg, msg_len);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\tif (tx_ack_msg->rx_dev_ret_u8 != ES58X_RET_U8_OK)\n> +\t\treturn es58x_rx_dev_ret_u8(es58x_dev->dev,\n> +\t\t\t\t\t ES58X_RET_TYPE_TX_MSG,\n> +\t\t\t\t\t tx_ack_msg->rx_dev_ret_u8);\n> +\n> +\tret = es58x_get_netdev(es58x_dev, tx_ack_msg->channel_no, &netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\treturn\n> +\t es58x_tx_ack_msg(netdev,\n> +\t\t\t get_unaligned_le16(&tx_ack_msg->tx_free_entries),\n> +\t\t\t ES58X_RET_U32_OK);\n> +}\n> +\n> +static int es581_4_dispatch_rx_cmd(struct es58x_device *es58x_dev,\n> +\t\t\t\t const struct es581_4_urb_cmd\n> +\t\t\t\t *es581_4_urb_cmd)\n> +{\n> +\tconst struct device *dev = es58x_dev->dev;\n> +\tu16 msg_len = get_unaligned_le16(&es581_4_urb_cmd->msg_len);\n> +\tenum es581_4_rx_type rx_type = es581_4_urb_cmd->rx_can_msg[0].rx_type;\n> +\tint ret = 0;\n> +\n> +\tswitch (rx_type) {\n> +\tcase ES581_4_RX_TYPE_MESSAGE:\n> +\t\treturn es581_4_rx_can_msg(es58x_dev, es581_4_urb_cmd, msg_len);\n> +\n> +\tcase ES581_4_RX_TYPE_ERROR:\n> +\t\tret = es58x_check_msg_len(dev, es581_4_urb_cmd->rx_err_msg,\n> +\t\t\t\t\t msg_len);\n> +\t\tif (ret < 0)\n> +\t\t\treturn ret;\n> +\t\treturn es581_4_rx_err_msg(es58x_dev,\n> +\t\t\t\t\t &es581_4_urb_cmd->rx_err_msg);\n> +\n> +\tcase ES581_4_RX_TYPE_EVENT:\n> +\t\tret = es58x_check_msg_len(dev, es581_4_urb_cmd->rx_event_msg,\n> +\t\t\t\t\t msg_len);\n> +\t\tif (ret < 0)\n> +\t\t\treturn ret;\n> +\t\treturn es581_4_rx_event_msg(es58x_dev,\n> +\t\t\t\t\t &es581_4_urb_cmd->rx_event_msg);\n> +\n> +\tdefault:\n> +\t\tdev_err(dev, \"%s: Unknown rx_type 0x%02X\\n\", __func__, rx_type);\n> +\t\treturn -EBADRQC;\n> +\t}\n> +}\n> +\n> +static int es581_4_handle_urb_cmd(struct es58x_device *es58x_dev,\n> +\t\t\t\t const union es58x_urb_cmd *urb_cmd)\n> +{\n> +\tconst struct es581_4_urb_cmd *es581_4_urb_cmd;\n> +\tconst struct device *dev = es58x_dev->dev;\n> +\tu16 msg_len = es581_4_get_msg_len(urb_cmd);\n> +\tint ret;\n> +\n> +\tes581_4_urb_cmd = &urb_cmd->es581_4_urb_cmd;\n> +\n> +\tif (es581_4_urb_cmd->cmd_type != ES581_4_CAN_COMMAND_TYPE) {\n> +\t\tdev_err(dev, \"%s: Unknown command type (0x%02X)\\n\",\n> +\t\t\t__func__, es581_4_urb_cmd->cmd_type);\n> +\t\treturn -EBADRQC;\n> +\t}\n> +\n> +\tswitch ((enum es581_4_cmd_id)es581_4_urb_cmd->cmd_id) {\n> +\tcase ES581_4_CMD_ID_SET_BITTIMING:\n> +\t\treturn es581_4_rx_cmd_ret_u32(es58x_dev, es581_4_urb_cmd,\n> +\t\t\t\t\t ES58X_RET_TYPE_SET_BITTIMING);\n> +\n> +\tcase ES581_4_CMD_ID_ENABLE_CHANNEL:\n> +\t\treturn es581_4_rx_cmd_ret_u32(es58x_dev, es581_4_urb_cmd,\n> +\t\t\t\t\t ES58X_RET_TYPE_ENABLE_CHANNEL);\n> +\n> +\tcase ES581_4_CMD_ID_TX_MSG:\n> +\t\treturn es581_4_tx_ack_msg(es58x_dev, es581_4_urb_cmd);\n> +\n> +\tcase ES581_4_CMD_ID_RX_MSG:\n> +\t\treturn es581_4_dispatch_rx_cmd(es58x_dev, es581_4_urb_cmd);\n> +\n> +\tcase ES581_4_CMD_ID_RESET_RX:\n> +\t\tret = es581_4_rx_cmd_ret_u32(es58x_dev, es581_4_urb_cmd,\n> +\t\t\t\t\t ES58X_RET_TYPE_RESET_RX);\n> +\t\treturn ret;\n> +\n> +\tcase ES581_4_CMD_ID_RESET_TX:\n> +\t\tret = es581_4_rx_cmd_ret_u32(es58x_dev, es581_4_urb_cmd,\n> +\t\t\t\t\t ES58X_RET_TYPE_RESET_TX);\n> +\t\treturn ret;\n> +\n> +\tcase ES581_4_CMD_ID_DISABLE_CHANNEL:\n> +\t\treturn es581_4_rx_cmd_ret_u32(es58x_dev, es581_4_urb_cmd,\n> +\t\t\t\t\t ES58X_RET_TYPE_DISABLE_CHANNEL);\n> +\n> +\tcase ES581_4_CMD_ID_TIMESTAMP:\n> +\t\tret = es58x_check_msg_len(dev, es581_4_urb_cmd->timestamp,\n> +\t\t\t\t\t msg_len);\n> +\t\tif (ret < 0)\n> +\t\t\treturn ret;\n> +\t\treturn es58x_rx_timestamp(es58x_dev,\n> +\t\t\t\t\t get_unaligned_le64\n> +\t\t\t\t\t (&es581_4_urb_cmd->timestamp));\n> +\n> +\tcase ES581_4_CMD_ID_SELF_RECEPTION:\n> +\t\treturn es581_4_rx_loopback_msg(es58x_dev, es581_4_urb_cmd);\n> +\n> +\tcase ES581_4_CMD_ID_DEVICE_ERR:\n> +\t\tret = es58x_check_msg_len(dev, es581_4_urb_cmd->rx_dev_ret_u8,\n> +\t\t\t\t\t msg_len);\n> +\t\tif (ret)\n> +\t\t\treturn ret;\n> +\t\treturn es58x_rx_dev_ret_u8(es58x_dev->dev,\n> +\t\t\t\t\t ES58X_RET_TYPE_DEVICE_ERR,\n> +\t\t\t\t\t es581_4_urb_cmd->rx_dev_ret_u8);\n> +\n> +\tdefault:\n> +\t\tdev_warn(dev, \"%s: Unexpected command ID: 0x%02X\\n\",\n> +\t\t\t __func__, es581_4_urb_cmd->cmd_id);\n> +\t\treturn -EBADRQC;\n> +\t}\n> +}\n> +\n> +static void es581_4_fill_urb_header(union es58x_urb_cmd *urb_cmd, u8 cmd_type,\n> +\t\t\t\t u8 cmd_id, u8 channel_idx, u16 msg_len)\n> +{\n> +\tstruct es581_4_urb_cmd *es581_4_urb_cmd = &urb_cmd->es581_4_urb_cmd;\n> +\n> +\tes581_4_urb_cmd->SOF = cpu_to_le16(es581_4_param.tx_start_of_frame);\n> +\tes581_4_urb_cmd->cmd_type = cmd_type;\n> +\tes581_4_urb_cmd->cmd_id = cmd_id;\n> +\tes581_4_urb_cmd->msg_len = cpu_to_le16(msg_len);\n> +}\n> +\n> +static int es581_4_tx_can_msg(struct es58x_priv *priv, int channel_idx,\n> +\t\t\t u32 packet_idx, const struct sk_buff *skb,\n> +\t\t\t union es58x_urb_cmd *urb_cmd, u32 *urb_cmd_len)\n> +{\n> +\tstruct es58x_device *es58x_dev = priv->es58x_dev;\n> +\tstruct es581_4_urb_cmd *es581_4_urb_cmd = &urb_cmd->es581_4_urb_cmd;\n> +\tstruct can_frame *cf = (struct can_frame *)skb->data;\n> +\tstruct es581_4_tx_can_msg *tx_can_msg;\n> +\tu16 msg_len;\n> +\tint ret;\n> +\n> +\tret = es58x_check_msg_max_len(es58x_dev->dev,\n> +\t\t\t\t es581_4_urb_cmd->bulk_tx_can_msg,\n> +\t\t\t\t es581_4_get_msg_len(urb_cmd) +\n> +\t\t\t\t sizeof(*tx_can_msg));\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\tif (can_is_canfd_skb(skb))\n> +\t\treturn -EMSGSIZE;\n> +\n> +\t/* Fill message contents. */\n> +\tif (*urb_cmd_len == es58x_dev->param->urb_cmd_header_len) {\n> +\t\tes581_4_fill_urb_header(urb_cmd, ES581_4_CAN_COMMAND_TYPE,\n> +\t\t\t\t\tES581_4_CMD_ID_TX_MSG,\n> +\t\t\t\t\tchannel_idx, *urb_cmd_len);\n> +\t\tmsg_len = 1;\n> +\t} else {\n> +\t\tmsg_len = le16_to_cpu(es581_4_urb_cmd->msg_len);\n> +\t}\n> +\ttx_can_msg = (struct es581_4_tx_can_msg *)\n> +\t &es581_4_urb_cmd->bulk_tx_can_msg.tx_can_msg_buf[msg_len - 1];\n> +\n> +\tput_unaligned_le32(es58x_get_raw_can_id(cf), &tx_can_msg->can_id);\n> +\tput_unaligned_le32(packet_idx, &tx_can_msg->packet_idx);\n> +\tput_unaligned_le16((u16)es58x_get_flags(skb), &tx_can_msg->flags);\n> +\ttx_can_msg->channel_no = channel_idx + 1;\n> +\ttx_can_msg->dlc = can_get_cc_dlc(priv->can.ctrlmode,\n> +\t\t\t\t\t cf->len, cf->len8_dlc);\n> +\n> +\tmemcpy(tx_can_msg->data, cf->data, cf->len);\n> +\n> +\t/* Calculate new sizes. */\n> +\tes581_4_urb_cmd->bulk_tx_can_msg.num_can_msg++;\n> +\tmsg_len += es581_4_sizeof_rx_tx_msg(*tx_can_msg);\n> +\t*urb_cmd_len = es58x_get_urb_cmd_len(es58x_dev, msg_len);\n> +\tes581_4_urb_cmd->msg_len = cpu_to_le16(msg_len);\n> +\n> +\treturn 0;\n> +}\n> +\n> +static void es581_4_print_conf(struct net_device *netdev,\n> +\t\t\t struct es581_4_tx_conf_msg *tx_conf_msg)\n> +{\n> +\tnetdev_vdbg(netdev, \"bitrate = %d\\n\",\n> +\t\t le32_to_cpu(tx_conf_msg->bitrate));\n> +\tnetdev_vdbg(netdev, \"sample_point = %d\\n\",\n> +\t\t le32_to_cpu(tx_conf_msg->sample_point));\n> +\tnetdev_vdbg(netdev, \"samples_per_bit = %d\\n\",\n> +\t\t le32_to_cpu(tx_conf_msg->samples_per_bit));\n> +\tnetdev_vdbg(netdev, \"bit_time = %d\\n\",\n> +\t\t le32_to_cpu(tx_conf_msg->bit_time));\n> +\tnetdev_vdbg(netdev, \"sjw = %d\\n\",\n> +\t\t le32_to_cpu(tx_conf_msg->sjw));\n> +\tnetdev_vdbg(netdev, \"sync_edge = %d\\n\",\n> +\t\t le32_to_cpu(tx_conf_msg->sync_edge));\n> +\tnetdev_vdbg(netdev, \"physical_media = %d\\n\",\n> +\t\t le32_to_cpu(tx_conf_msg->physical_media));\n> +\tnetdev_vdbg(netdev, \"self_reception = %d\\n\",\n> +\t\t le32_to_cpu(tx_conf_msg->self_reception_mode));\n> +\tnetdev_vdbg(netdev, \"channel_no = %d\\n\", tx_conf_msg->channel_no);\n> +}\n> +\n> +static int es581_4_set_bittiming(struct es58x_device *es58x_dev,\n> +\t\t\t\t int channel_idx)\n> +{\n> +\tstruct es581_4_tx_conf_msg tx_conf_msg = { 0 };\n> +\tstruct net_device *netdev = es58x_dev->netdev[channel_idx];\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tstruct can_bittiming *bt = &priv->can.bittiming;\n> +\n> +\ttx_conf_msg.bitrate = cpu_to_le32(bt->bitrate);\n> +\t/* bt->sample_point is in tenth of percent. Convert it to percent. */\n> +\ttx_conf_msg.sample_point = cpu_to_le32(bt->sample_point / 10U);\n> +\ttx_conf_msg.samples_per_bit = cpu_to_le32(ES58X_SAMPLES_PER_BIT_ONE);\n> +\ttx_conf_msg.bit_time = cpu_to_le32(can_bit_time(bt));\n> +\ttx_conf_msg.sjw = cpu_to_le32(bt->sjw);\n> +\ttx_conf_msg.sync_edge = cpu_to_le32(ES58X_SYNC_EDGE_SINGLE);\n> +\ttx_conf_msg.physical_media =\n> +\t cpu_to_le32(ES58X_PHYSICAL_MEDIA_HIGH_SPEED);\n> +\ttx_conf_msg.self_reception_mode = cpu_to_le32(ES58X_SELF_RECEPTION_ON);\n> +\ttx_conf_msg.channel_no = channel_idx + es581_4_param.channel_idx_offset;\n> +\n> +\tes581_4_print_conf(netdev, &tx_conf_msg);\n> +\n> +\treturn es58x_send_msg(es58x_dev, ES581_4_CAN_COMMAND_TYPE,\n> +\t\t\t ES581_4_CMD_ID_SET_BITTIMING, &tx_conf_msg,\n> +\t\t\t sizeof(tx_conf_msg), channel_idx);\n> +}\n> +\n> +static int es581_4_enable_channel(struct es58x_device *es58x_dev,\n> +\t\t\t\t int channel_idx)\n> +{\n> +\tu8 msg = channel_idx + 1;\n> +\n> +\treturn es58x_send_msg(es58x_dev, ES581_4_CAN_COMMAND_TYPE,\n> +\t\t\t ES581_4_CMD_ID_ENABLE_CHANNEL, &msg, sizeof(msg),\n> +\t\t\t channel_idx);\n> +}\n> +\n> +static int es581_4_disable_channel(struct es58x_device *es58x_dev,\n> +\t\t\t\t int channel_idx)\n> +{\n> +\tu8 msg = channel_idx + 1;\n> +\n> +\treturn es58x_send_msg(es58x_dev, ES581_4_CAN_COMMAND_TYPE,\n> +\t\t\t ES581_4_CMD_ID_DISABLE_CHANNEL, &msg, sizeof(msg),\n> +\t\t\t channel_idx);\n> +}\n> +\n> +static int es581_4_reset_rx(struct es58x_device *es58x_dev, int channel_idx)\n> +{\n> +\tu8 msg = channel_idx + 1;\n> +\n> +\treturn es58x_send_msg(es58x_dev, ES581_4_CAN_COMMAND_TYPE,\n> +\t\t\t ES581_4_CMD_ID_RESET_RX, &msg, sizeof(msg),\n> +\t\t\t channel_idx);\n> +}\n> +\n> +static int es581_4_reset_tx(struct es58x_device *es58x_dev, int channel_idx)\n> +{\n> +\tu8 msg = channel_idx + 1;\n> +\n> +\treturn es58x_send_msg(es58x_dev, ES581_4_CAN_COMMAND_TYPE,\n> +\t\t\t ES581_4_CMD_ID_RESET_TX, &msg, sizeof(msg),\n> +\t\t\t channel_idx);\n> +}\n> +\n> +static int es581_4_get_timestamp(struct es58x_device *es58x_dev)\n> +{\n> +\treturn es58x_send_msg(es58x_dev, ES581_4_CAN_COMMAND_TYPE,\n> +\t\t\t ES581_4_CMD_ID_TIMESTAMP, ES58X_EMPTY_MSG,\n> +\t\t\t 0, ES58X_CHANNEL_IDX_NA);\n> +}\n> +\n> +/* struct es581_4_bittiming_const - Nominal bittiming constants.\n> + *\n> + * Nominal bittiming constants for ES581.4 as specified in the\n> + * microcontroller datasheet: \"Stellaris(R) LM3S5B91 Microcontroller\"\n> + * table 17-4 \"CAN Protocol Ranges\" from Texas Instruments.\n> + */\n> +static const struct can_bittiming_const es581_4_bittiming_const = {\n> +\t.name = \"ES581.4\",\n> +\t.tseg1_min = 1,\n> +\t.tseg1_max = 8,\n> +\t.tseg2_min = 1,\n> +\t.tseg2_max = 8,\n> +\t.sjw_max = 4,\n> +\t.brp_min = 1,\n> +\t.brp_max = 128,\n> +\t.brp_inc = 1\n> +};\n> +\n> +const struct es58x_parameters es581_4_param = {\n> +\t.bittiming_const = &es581_4_bittiming_const,\n> +\t.data_bittiming_const = NULL,\n> +\t.bitrate_max = ES58X_MBPS(1),\n> +\t.clock = {.freq = ES58X_MHZ(50)},\n> +\t.ctrlmode_supported =\n> +\t CAN_CTRLMODE_LOOPBACK | CAN_CTRLMODE_CC_LEN8_DLC,\n> +\t.tx_start_of_frame = 0xAFAF,\n> +\t.rx_start_of_frame = 0xFAFA,\n> +\t.tx_urb_cmd_max_len = ES581_4_TX_URB_CMD_MAX_LEN,\n> +\t.rx_urb_cmd_max_len = ES581_4_RX_URB_CMD_MAX_LEN,\n> +\t/* Size of internal device TX queue is 330.\n> +\t *\n> +\t * However, we witnessed some ES58X_ERR_PROT_CRC errors from\n> +\t * the device and thus, echo_skb_max was lowered to the\n> +\t * empirical value of 75 which seems stable.\n> +\t *\n> +\t * Root cause of those ES58X_ERR_PROT_CRC errors is still\n> +\t * unclear.\n> +\t */\n> +\t.echo_skb_max = 75,\n> +\t/* Empirical value. */\n> +\t.dql_limit_min = ES58X_CAN_FRAME_BYTES_MAX * 50,\n> +\t.tx_bulk_max = ES581_4_TX_BULK_MAX,\n> +\t.urb_cmd_header_len = ES581_4_URB_CMD_HEADER_LEN,\n> +\t.rx_urb_max = ES58X_RX_URBS_MAX,\n> +\t.tx_urb_max = ES58X_TX_URBS_MAX,\n> +\t.channel_idx_offset = 1\n> +};\n> +\n> +const struct es58x_operators es581_4_ops = {\n> +\t.get_msg_len = es581_4_get_msg_len,\n> +\t.handle_urb_cmd = es581_4_handle_urb_cmd,\n> +\t.fill_urb_header = es581_4_fill_urb_header,\n> +\t.tx_can_msg = es581_4_tx_can_msg,\n> +\t.set_bittiming = es581_4_set_bittiming,\n> +\t.enable_channel = es581_4_enable_channel,\n> +\t.disable_channel = es581_4_disable_channel,\n> +\t.reset_rx = es581_4_reset_rx,\n> +\t.reset_tx = es581_4_reset_tx,\n> +\t.get_timestamp = es581_4_get_timestamp\n> +};\n> diff --git a/drivers/net/can/usb/etas_es58x/es581_4.h b/drivers/net/can/usb/etas_es58x/es581_4.h\n> new file mode 100644\n> index 000000000000..1fbb41cadeea\n> --- /dev/null\n> +++ b/drivers/net/can/usb/etas_es58x/es581_4.h\n> @@ -0,0 +1,206 @@\n> +/* SPDX-License-Identifier: GPL-2.0 */\n> +\n> +/* Driver for ETAS GmbH ES58X USB CAN(-FD) Bus Interfaces.\n> + *\n> + * File es581_4.h: Definitions and declarations specific to ETAS\n> + * ES581.4.\n> + *\n> + * Copyright (C) 2019 Robert Bosch Engineering and Business\n> + * Solutions. All rights reserved.\n> + * Copyright (C) 2020 ETAS K.K.. All rights reserved.\n> + */\n> +\n> +#ifndef __ES581_4_H__\n> +#define __ES581_4_H__\n> +\n> +#include \n> +\n> +#define ES581_4_NUM_CAN_CH 2\n> +\n> +#define ES581_4_TX_BULK_MAX 25\n> +#define ES581_4_RX_BULK_MAX 30\n> +#define ES581_4_RX_LOOPBACK_BULK_MAX 30\n> +\n> +enum es581_4_cmd_type {\n> +\tES581_4_CAN_COMMAND_TYPE = 0x45\n> +};\n> +\n> +enum es581_4_cmd_id {\n> +\tES581_4_CMD_ID_OPEN_CHANNEL = 0x01,\n> +\tES581_4_CMD_ID_CLOSE_CHANNEL = 0x02,\n> +\tES581_4_CMD_ID_SET_BITTIMING = 0x03,\n> +\tES581_4_CMD_ID_ENABLE_CHANNEL = 0x04,\n> +\tES581_4_CMD_ID_TX_MSG = 0x05,\n> +\tES581_4_CMD_ID_RX_MSG = 0x06,\n> +\tES581_4_CMD_ID_RESET_RX = 0x0A,\n> +\tES581_4_CMD_ID_RESET_TX = 0x0B,\n> +\tES581_4_CMD_ID_DISABLE_CHANNEL = 0x0C,\n> +\tES581_4_CMD_ID_TIMESTAMP = 0x0E,\n> +\tES581_4_CMD_ID_RESET_DEVICE = 0x28,\n> +\tES581_4_CMD_ID_SELF_RECEPTION = 0x71,\n> +\tES581_4_CMD_ID_DEVICE_ERR = 0x72\n> +};\n> +\n> +enum es581_4_rx_type {\n> +\tES581_4_RX_TYPE_MESSAGE = 1,\n> +\tES581_4_RX_TYPE_ERROR = 3,\n> +\tES581_4_RX_TYPE_EVENT = 4\n> +};\n> +\n> +/**\n> + * struct es581_4_tx_conf_msg - Channel configuration.\n> + * @bitrate: Bitrate.\n> + * @sample_point: Sample point is in percent [0..100].\n> + * @samples_per_bit: type enum es58x_samples_per_bit.\n> + * @bit_time: Number of time quanta in one bit.\n> + * @sjw: Synchronization Jump Width.\n> + * @sync_edge: type enum es58x_sync_edge.\n> + * @physical_media: type enum es58x_physical_media.\n> + * @self_reception_mode: type enum es58x_self_reception_mode.\n> + * @channel_no: Channel number, starting from 1. Not to be confused\n> + *\twith channed_idx of the ES58X FD which starts from 0.\n> + */\n> +struct es581_4_tx_conf_msg {\n> +\t__le32 bitrate;\n> +\t__le32 sample_point;\n> +\t__le32 samples_per_bit;\n> +\t__le32 bit_time;\n> +\t__le32 sjw;\n> +\t__le32 sync_edge;\n> +\t__le32 physical_media;\n> +\t__le32 self_reception_mode;\n> +\tu8 channel_no;\n> +} __packed;\n> +\n> +struct es581_4_tx_can_msg {\n> +\t__le32 can_id;\n> +\t__le32 packet_idx;\n> +\t__le16 flags;\n> +\tu8 channel_no;\n> +\tu8 dlc;\n> +\tu8 data[CAN_MAX_DLEN];\n> +} __packed;\n> +\n> +/* The ES581.4 allows bulk transfer. */\n> +struct es581_4_bulk_tx_can_msg {\n> +\tu8 num_can_msg;\n> +\t/* Using type \"u8[]\" instead of \"struct es581_4_tx_can_msg[]\"\n> +\t * for tx_msg_buf because each member has a flexible size.\n> +\t */\n> +\tu8 tx_can_msg_buf[ES581_4_TX_BULK_MAX *\n> +\t\t\t sizeof(struct es581_4_tx_can_msg)];\n> +} __packed;\n> +\n> +struct es581_4_rx_loopback_msg {\n> +\t__le64 timestamp;\n> +\t__le32 packet_idx;\n> +} __packed;\n> +\n> +struct es581_4_bulk_rx_loopback_msg {\n> +\tu8 channel_no;\n> +\tstruct es581_4_rx_loopback_msg\n> +\t rx_loopback_msg[ES581_4_RX_LOOPBACK_BULK_MAX];\n> +} __packed;\n> +\n> +/* Normal Rx CAN Message */\n> +struct es581_4_rx_can_msg {\n> +\t__le64 timestamp;\n> +\tu8 rx_type;\t\t/* type enum es581_4_rx_type */\n> +\tu8 flags;\t\t/* type enum es58x_flag */\n> +\tu8 channel_no;\n> +\tu8 dlc;\n> +\t__le32 can_id;\n> +\tu8 data[CAN_MAX_DLEN];\n> +} __packed;\n> +\n> +struct es581_4_rx_err_msg {\n> +\t__le64 timestamp;\n> +\t__le16 rx_type;\t\t/* type enum es581_4_rx_type */\n> +\t__le16 flags;\t\t/* type enum es58x_flag */\n> +\tu8 channel_no;\n> +\tu8 __padding[2];\n> +\tu8 dlc;\n> +\t__le32 tag;\t\t/* Related to the CAN filtering. Unused in this module */\n> +\t__le32 can_id;\n> +\t__le32 error;\t\t/* type enum es58x_error */\n> +\t__le32 destination;\t/* Unused in this module */\n> +} __packed;\n> +\n> +struct es581_4_rx_event_msg {\n> +\t__le64 timestamp;\n> +\t__le16 rx_type;\t\t/* type enum es581_4_rx_type */\n> +\tu8 channel_no;\n> +\tu8 __padding;\n> +\t__le32 tag;\t\t/* Related to the CAN filtering. Unused in this module */\n> +\t__le32 event;\t\t/* type enum es58x_event */\n> +\t__le32 destination;\t/* Unused in this module */\n> +} __packed;\n> +\n> +struct es581_4_tx_ack_msg {\n> +\t__le16 tx_free_entries;\t/* Number of remaining free entries in the device TX queue */\n> +\tu8 channel_no;\n> +\tu8 rx_dev_ret_u8;\t/* type enum es58x_dev_ret_code_u8 */\n> +} __packed;\n> +\n> +struct es581_4_rx_dev_ret {\n> +\t__le32 rx_cmd_ret_le32;\n> +\tu8 channel_no;\n> +\tu8 __padding[3];\n> +} __packed;\n> +\n> +/**\n> + * struct es581_4_urb_cmd - Commands received from or sent to the\n> + *\tES581.4 device.\n> + * @SOF: Start of Frame.\n> + * @cmd_type: Command Type (type: enum es581_4_cmd_type). The CRC\n> + *\tcalculation starts at this position.\n> + * @cmd_id: Command ID (type: enum es581_4_cmd_id).\n> + * @msg_len: Length of the message, excluding CRC (i.e. length of the\n> + *\tunion).\n> + * @raw_msg: Message raw payload.\n> + * @tx_conf_msg: Channel configuration.\n> + * @bulk_tx_can_msg: Tx messages.\n> + * @rx_can_msg: Array of Rx messages.\n> + * @bulk_rx_loopback_msg: Loopback messages.\n> + * @rx_err_msg: Error message.\n> + * @rx_event_msg: Event message.\n> + * @tx_ack_msg: Tx acknowledgment message.\n> + * @timestamp: Timestamp reply.\n> + * @rx_cmd_ret_u8: Rx 8 bits return code (type: enum\n> + *\tes58x_dev_ret_code_u8).\n> + * @reserved_for_crc16_do_not_use: The structure ends with a\n> + *\tCRC16. Because the structures in above union are of variable\n> + *\tlengths, we can not predict the offset of the CRC in\n> + *\tadvance. Use functions es58x_get_crc() and es58x_set_crc() to\n> + *\tmanipulate it.\n> + */\n> +struct es581_4_urb_cmd {\n> +\t__le16 SOF;\n> +\tu8 cmd_type;\n> +\tu8 cmd_id;\n> +\t__le16 msg_len;\n> +\n> +\tunion {\n> +\t\tstruct es581_4_tx_conf_msg tx_conf_msg;\n> +\t\tstruct es581_4_bulk_tx_can_msg bulk_tx_can_msg;\n> +\t\tstruct es581_4_rx_can_msg rx_can_msg[ES581_4_RX_BULK_MAX];\n> +\t\tstruct es581_4_bulk_rx_loopback_msg bulk_rx_loopback_msg;\n> +\t\tstruct es581_4_rx_err_msg rx_err_msg;\n> +\t\tstruct es581_4_rx_event_msg rx_event_msg;\n> +\t\tstruct es581_4_tx_ack_msg tx_ack_msg;\n> +\t\tstruct es581_4_rx_dev_ret rx_dev_ret;\n> +\t\t__le64 timestamp;\n> +\t\tu8 rx_dev_ret_u8;\n> +\t\tu8 raw_msg[0];\n> +\t} __packed;\n> +\n> +\t__le16 reserved_for_crc16_do_not_use;\n> +} __packed;\n> +\n> +#define ES581_4_URB_CMD_HEADER_LEN (offsetof(struct es581_4_urb_cmd, raw_msg))\n> +#define ES581_4_TX_URB_CMD_MAX_LEN\t\t\t\t\t\\\n> +\tES58X_SIZEOF_URB_CMD(struct es581_4_urb_cmd, bulk_tx_can_msg)\n> +#define ES581_4_RX_URB_CMD_MAX_LEN\t\t\t\t\t\\\n> +\tES58X_SIZEOF_URB_CMD(struct es581_4_urb_cmd, rx_can_msg)\n> +\n> +#endif /* __ES581_4_H__ */\n> diff --git a/drivers/net/can/usb/etas_es58x/es58x_core.c b/drivers/net/can/usb/etas_es58x/es58x_core.c\n> new file mode 100644\n> index 000000000000..bfe9e94b7fbc\n> --- /dev/null\n> +++ b/drivers/net/can/usb/etas_es58x/es58x_core.c\n> @@ -0,0 +1,2627 @@\n> +// SPDX-License-Identifier: GPL-2.0\n> +\n> +/* Driver for ETAS GmbH ES58X USB CAN(-FD) Bus Interfaces.\n> + *\n> + * File es58x_core.c: Core logic to manage the network devices and the\n> + * USB interface.\n> + *\n> + * Copyright (C) 2019 Robert Bosch Engineering and Business\n> + * Solutions. All rights reserved.\n> + * Copyright (C) 2020 ETAS K.K.. All rights reserved.\n> + */\n> +\n> +#include \n> +#include \n> +#include \n> +#include \n> +#include \n> +#include \n> +#include \n> +\n> +#include \"es58x_core.h\"\n> +\n> +#define DRV_VERSION \"1.03\"\n> +MODULE_AUTHOR(\"Mailhol Vincent \");\n> +MODULE_AUTHOR(\"Arunachalam Santhanam \");\n> +MODULE_DESCRIPTION(\"Socket CAN driver for ETAS ES58X USB adapters\");\n> +MODULE_VERSION(DRV_VERSION);\n> +MODULE_LICENSE(\"GPL v2\");\n> +\n> +/* Vendor and product id */\n> +#define ES58X_MODULE_NAME \"etas_es58x\"\n> +#define ES58X_VENDOR_ID 0x108C\n> +#define ES581_4_PRODUCT_ID 0x0159\n> +#define ES582_1_PRODUCT_ID 0x0168\n> +#define ES584_1_PRODUCT_ID 0x0169\n> +\n> +/* Table of devices which work with this driver */\n> +static const struct usb_device_id es58x_id_table[] = {\n> +\t{USB_DEVICE(ES58X_VENDOR_ID, ES581_4_PRODUCT_ID)},\n> +\t{USB_DEVICE(ES58X_VENDOR_ID, ES582_1_PRODUCT_ID)},\n> +\t{USB_DEVICE(ES58X_VENDOR_ID, ES584_1_PRODUCT_ID)},\n> +\t{}\t\t\t/* Terminating entry */\n> +};\n> +\n> +MODULE_DEVICE_TABLE(usb, es58x_id_table);\n> +\n> +#define es58x_print_hex_dump(buf, len)\t\t\t\t\t\\\n> +\tprint_hex_dump(KERN_DEBUG,\t\t\t\t\t\\\n> +\t\t ES58X_MODULE_NAME \" \" __stringify(buf) \": \",\t\\\n> +\t\t DUMP_PREFIX_NONE, 16, 1, buf, len, false)\n> +\n> +#define es58x_print_hex_dump_debug(buf, len)\t\t\t\t \\\n> +\tprint_hex_dump_debug(ES58X_MODULE_NAME \" \" __stringify(buf) \": \",\\\n> +\t\t\t DUMP_PREFIX_NONE, 16, 1, buf, len, false)\n> +\n> +/* The last two bytes of an ES58X command is a CRC16. The first two\n> + * bytes (the start of frame) are skipped and the CRC calculation\n> + * starts on the third byte.\n> + */\n> +#define ES58X_CRC_CALC_OFFSET\t2\n> +\n> +/**\n> + * es58x_calculate_crc() - Compute the crc16 of a given URB.\n> + * @urb_cmd: The URB command for which we want to calculate the CRC.\n> + * @urb_len: Length of @urb_cmd. Must be at least bigger than 4\n> + *\t(ES58X_CRC_CALC_OFFSET + sizeof(crc))\n> + *\n> + * Return: crc16 value.\n> + */\n> +static u16 es58x_calculate_crc(const union es58x_urb_cmd *urb_cmd, u16 urb_len)\n> +{\n> +\tu16 crc;\n> +\tssize_t len = urb_len - ES58X_CRC_CALC_OFFSET - sizeof(crc);\n> +\n> +\tWARN_ON(len < 0);\n> +\tcrc = crc16(0, &urb_cmd->raw_cmd[ES58X_CRC_CALC_OFFSET], len);\n> +\treturn crc;\n> +}\n> +\n> +/**\n> + * es58x_get_crc() - Get the CRC value of a given URB.\n> + * @urb_cmd: The URB command for which we want to get the CRC.\n> + * @urb_len: Length of @urb_cmd. Must be at least bigger than 4\n> + *\t(ES58X_CRC_CALC_OFFSET + sizeof(crc))\n> + *\n> + * Return: crc16 value.\n> + */\n> +static u16 es58x_get_crc(const union es58x_urb_cmd *urb_cmd, u16 urb_len)\n> +{\n> +\tu16 crc;\n> +\tconst __le16 *crc_addr;\n> +\n> +\tWARN_ON(urb_len - (ssize_t)sizeof(crc) < 0);\n> +\tcrc_addr = (__le16 *)&urb_cmd->raw_cmd[urb_len - sizeof(crc)];\n> +\tcrc = get_unaligned_le16(crc_addr);\n> +\treturn crc;\n> +}\n> +\n> +/**\n> + * es58x_set_crc() - Set the CRC value of a given URB.\n> + * @urb_cmd: The URB command for which we want to get the CRC.\n> + * @urb_len: Length of @urb_cmd. Must be at least bigger than 4\n> + *\t(ES58X_CRC_CALC_OFFSET + sizeof(crc))\n> + */\n> +static void es58x_set_crc(union es58x_urb_cmd *urb_cmd, u16 urb_len)\n> +{\n> +\tu16 crc;\n> +\t__le16 *crc_addr;\n> +\n> +\tcrc = es58x_calculate_crc(urb_cmd, urb_len);\n> +\tcrc_addr = (__le16 *)&urb_cmd->raw_cmd[urb_len - sizeof(crc)];\n> +\tput_unaligned_le16(crc, crc_addr);\n> +}\n> +\n> +/**\n> + * es58x_check_crc() - Validate the CRC value of a given URB.\n> + * @es58x_dev: ES58X device.\n> + * @urb_cmd: The URB command for which we want to check the CRC.\n> + * @urb_len: Length of @urb_cmd. Must be at least bigger than 4\n> + *\t(ES58X_CRC_CALC_OFFSET + sizeof(crc))\n> + *\n> + * Return: zero on success, -EBADMSG if the CRC check fails.\n> + */\n> +static int es58x_check_crc(struct es58x_device *es58x_dev,\n> +\t\t\t const union es58x_urb_cmd *urb_cmd, u16 urb_len)\n> +{\n> +\tu16 calculated_crc = es58x_calculate_crc(urb_cmd, urb_len);\n> +\tu16 expected_crc = es58x_get_crc(urb_cmd, urb_len);\n> +\n> +\tif (expected_crc != calculated_crc) {\n> +\t\tdev_err_ratelimited(es58x_dev->dev,\n> +\t\t\t\t \"%s: Bad CRC, urb_len: %d\\n\",\n> +\t\t\t\t __func__, urb_len);\n> +\t\treturn -EBADMSG;\n> +\t}\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_timestamp_to_ns() - Convert a timestamp value received from a\n> + *\tES58X device to nanoseconds.\n> + * @timestamp: Timestamp received from a ES58X device.\n> + *\n> + * The timestamp received from ES58X is expressed in multiple of 0.5\n> + * micro seconds. This function converts it in to nanoseconds.\n> + *\n> + * Return: Timestamp value in nanoseconds.\n> + */\n> +static u64 es58x_timestamp_to_ns(u64 timestamp)\n> +{\n> +\tconst u64 es58x_timestamp_ns_mult_coef = 500ULL;\n> +\n> +\treturn es58x_timestamp_ns_mult_coef * timestamp;\n> +}\n> +\n> +/**\n> + * es58x_set_skb_timestamp() - Set the hardware timestamp of an skb.\n> + * @netdev: CAN network device.\n> + * @skb: socket buffer of a CAN message.\n> + * @timestamp: Timestamp received from an ES58X device.\n> + *\n> + * Used for both received and loopback messages.\n> + *\n> + * Return: zero on success, -EFAULT if @skb is NULL.\n> + */\n> +static int es58x_set_skb_timestamp(struct net_device *netdev,\n> +\t\t\t\t struct sk_buff *skb, u64 timestamp)\n> +{\n> +\tstruct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev;\n> +\tstruct skb_shared_hwtstamps *hwts;\n> +\n> +\thwts = skb_hwtstamps(skb);\n> +\t/* Ignoring overflow (overflow on 64 bits timestamp with nano\n> +\t * second precision would occur after more than 500 years).\n> +\t */\n> +\thwts->hwtstamp = ns_to_ktime(es58x_timestamp_to_ns(timestamp) +\n> +\t\t\t\t es58x_dev->realtime_diff_ns);\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_rx_timestamp() - Handle a received timestamp.\n> + * @es58x_dev: ES58X device.\n> + * @timestamp: Timestamp received from a ES58X device.\n> + *\n> + * Calculate the difference between the ES58X device and the kernel\n> + * internal clocks. This difference will be later used as an offset to\n> + * convert the timestamps of RX and loopback messages to match the\n> + * kernel system time (e.g. convert to UNIX time).\n> + *\n> + * Return: zero on success.\n> + */\n> +int es58x_rx_timestamp(struct es58x_device *es58x_dev, u64 timestamp)\n> +{\n> +\tu64 ktime_real_ns = ktime_get_real_ns();\n> +\tu64 device_timestamp = es58x_timestamp_to_ns(timestamp);\n> +\n> +\tdev_dbg(es58x_dev->dev, \"%s: request round-trip time: %llu\\n\",\n> +\t\t__func__, ktime_real_ns - es58x_dev->ktime_req_ns);\n> +\n> +\tes58x_dev->realtime_diff_ns =\n> +\t (es58x_dev->ktime_req_ns + ktime_real_ns) / 2 - device_timestamp;\n> +\tes58x_dev->ktime_req_ns = 0;\n> +\n> +\tdev_dbg(es58x_dev->dev,\n> +\t\t\"%s: Device timestamp: %llu, diff with kernel: %llu\\n\",\n> +\t\t__func__, device_timestamp, es58x_dev->realtime_diff_ns);\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_set_realtime_diff_ns() - Calculate difference between the\n> + *\tclocks of the ES58X device and the kernel\n> + * @es58x_dev: ES58X device.\n> + *\n> + * Request a timestamp from the ES58X device. Once the answer is\n> + * received, the timestamp difference will be set by the callback\n> + * function es58x_rx_timestamp().\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_set_realtime_diff_ns(struct es58x_device *es58x_dev)\n> +{\n> +\tif (es58x_dev->ktime_req_ns) {\n> +\t\tdev_warn(es58x_dev->dev,\n> +\t\t\t \"%s: Previous request to set timestamp has not completed yet\\n\",\n> +\t\t\t __func__);\n> +\t\treturn -EBUSY;\n> +\t}\n> +\n> +\tes58x_dev->ktime_req_ns = ktime_get_real_ns();\n> +\treturn es58x_dev->ops->get_timestamp(es58x_dev);\n> +}\n> +\n> +/**\n> + * es58x_is_can_state_active() - Is the network device in an active\n> + *\tCAN state?\n> + * @netdev: CAN network device.\n> + *\n> + * The device is considered active if it is able to send or receive\n> + * CAN frames, that is to say if it is in any of\n> + * CAN_STATE_ERROR_ACTIVE, CAN_STATE_ERROR_WARNING or\n> + * CAN_STATE_ERROR_PASSIVE states.\n> + *\n> + * Caution: when recovering from a bus-off,\n> + * net/core/dev.c#can_restart() will call\n> + * net/core/dev.c#can_flush_echo_skb() without using any kind of\n> + * locks. For this reason, it is critical to guaranty that no TX or\n> + * loopback operations (i.e. any access to priv->echo_skb[]) can be\n> + * done while this function is returning false.\n> + *\n> + * Return: true if the device is active, else returns false.\n> + */\n> +static bool es58x_is_can_state_active(struct net_device *netdev)\n> +{\n> +\treturn es58x_priv(netdev)->can.state < CAN_STATE_BUS_OFF;\n> +}\n> +\n> +/**\n> + * es58x_echo_skb_stop_threshold() - Determine the limit of how many\n> + *\tskb slots can be taken before we should stop the network\n> + *\tqueue.\n> + * @priv: ES58X private parameters related to the network device.\n> + *\n> + * We need to save enough free skb slots in order to be able to do\n> + * bulk send. This function can be used to determine when to wake or\n> + * stop the network queue in regard to the number of skb slots already\n> + * taken if the loopback FIFO.\n> + *\n> + * Return: stop threshold limit.\n> + */\n> +static int es58x_echo_skb_stop_threshold(struct es58x_priv *priv)\n> +{\n> +\treturn priv->can.echo_skb_max - priv->es58x_dev->param->tx_bulk_max + 1;\n> +}\n> +\n> +/**\n> + * es58x_netif_wake_queue() - Wake-up the network queue if conditions\n> + *\tare met.\n> + * @netdev: CAN network device.\n> + *\n> + * If the queue is already awoken, do nothing.\n> + *\n> + * The conditions to wake up the queue are: a.) The device should be\n> + * active (e.g. not in bus off state), b.) The network device must be\n> + * up, c.) The echo_skb must have enough free slots for a bulk sent\n> + * (c.f. es58x_echo_skb_stop_threshold()), d.) Enough idle URBs should\n> + * be available.\n> + */\n> +static void es58x_netif_wake_queue(struct net_device *netdev)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tstruct es58x_device *es58x_dev = priv->es58x_dev;\n> +\tunsigned long echo_skb_flags, tx_urbs_flags;\n> +\n> +\tif (!netif_queue_stopped(netdev))\n> +\t\treturn;\n> +\n> +\tspin_lock_irqsave(&priv->echo_skb_spinlock, echo_skb_flags);\n> +\tif (!es58x_is_can_state_active(netdev))\n> +\t\tgoto echo_skb_unlock;\n> +\tif (netif_running(netdev) &&\n> +\t priv->num_echo_skb < es58x_echo_skb_stop_threshold(priv)) {\n> +\t\t/* Confirm that we have at least one idle URB per CAN\n> +\t\t * network device. Otherwise, we might run into race\n> +\t\t * conditions in the function es58x_start_xmit() which\n> +\t\t * would force us to return NETDEV_TX_BUSY.\n> +\t\t */\n> +\t\tspin_lock_irqsave(&es58x_dev->tx_urbs_idle.lock, tx_urbs_flags);\n> +\t\tif (atomic_read(&es58x_dev->tx_urbs_idle_cnt) >=\n> +\t\t es58x_dev->num_can_ch)\n> +\t\t\tnetif_wake_queue(netdev);\n> +\t\tspin_unlock_irqrestore(&es58x_dev->tx_urbs_idle.lock,\n> +\t\t\t\t tx_urbs_flags);\n> +\t}\n> + echo_skb_unlock:\n> +\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, echo_skb_flags);\n> +}\n> +\n> +/**\n> + * es58x_netif_wake_all_queues() - Wake-up all the network queues if\n> + *\tconditions are met.\n> + * @es58x_dev: ES58X device.\n> + *\n> + * Try to wake-up all the queues associated with a ES58X device. This\n> + * function should be used when idle URB resources become available.\n> + */\n> +static void es58x_netif_wake_all_queues(struct es58x_device *es58x_dev)\n> +{\n> +\tint i;\n> +\n> +\tfor (i = 0; i < es58x_dev->num_can_ch; i++)\n> +\t\tes58x_netif_wake_queue(es58x_dev->netdev[i]);\n> +}\n> +\n> +/**\n> + * es58x_netif_stop_all_queues() - Unconditionally stop all the\n> + *\tnetwork queues.\n> + * @es58x_dev: ES58X device.\n> + *\n> + * Stop all the queues associated with a ES58X device. This\n> + * function should be used when idle URB resources become unavailable.\n> + */\n> +static void es58x_netif_stop_all_queues(struct es58x_device *es58x_dev)\n> +{\n> +\tint i;\n> +\n> +\tfor (i = 0; i < es58x_dev->num_can_ch; i++)\n> +\t\tif (es58x_dev->netdev[i])\n> +\t\t\tnetif_stop_queue(es58x_dev->netdev[i]);\n> +}\n> +\n> +/**\n> + * es58x_can_frame_bytes() - Calculate the CAN frame length in bytes\n> + *\tof a given skb.\n> + * @skb: socket buffer of a CAN message.\n> + *\n> + * Do a rough calculation: bitstuffing is ignored and length in bits\n> + * is rounded up to a length in bytes.\n> + *\n> + * Rationale: this function is to be used for the BQL functions\n> + * (__netdev_sent_queue() and netdev_completed_queue()) which expect a\n> + * value in bytes. Just using skb->len is insufficient because it will\n> + * return the constant value of CAN(FD)_MTU. Doing the bitstuffing\n> + * calculation would be too expensive in term of computing resources\n> + * for no noticeable gain.\n> + *\n> + * Remarks: a.)Tthe payload of CAN FD frames with BRS flag are sent at\n> + * a different bitrate. Currently, the can-utils canbusload tool does\n> + * not support CAN-FD yet and so we could not run any benchmark to\n> + * measure the impact. There might be possible improvement here. b.)\n> + * The macro ES58X_EFF_BYTES() and ES58X_SFF_BYTES() are for classical\n> + * CAN. Need to do the addition for CAN-FD (the value are expected to\n> + * be close enough so the impact should be minimal or none).\n> + *\n> + * Return: length in bytes.\n> + */\n> +static unsigned int es58x_can_frame_bytes(const struct sk_buff *skb)\n> +{\n> +\tconst struct canfd_frame *cf = (const struct canfd_frame *)skb->data;\n> +\tu8 len = cf->can_id & CAN_RTR_FLAG ? 0 : cf->len;\n> +\n> +\tif (cf->can_id & CAN_EFF_FLAG)\n> +\t\treturn ES58X_EFF_BYTES(len);\n> +\telse\n> +\t\treturn ES58X_SFF_BYTES(len);\n> +}\n> +\n> +/**\n> + * es58x_add_skb_idx() - Increment an index of the loopback FIFO.\n> + * @priv: ES58X private parameters related to the network device.\n> + * @idx: address of the index to be incremented.\n> + * @a: the increment. Must be positive and less or equal to\n> + *\t@priv->can.echo_skb_max.\n> + *\n> + * Do a modulus addition: set *@idx to (*@idx + @a) %\n> + * @priv->can.echo_skb_max.\n> + *\n> + * Rationale: the modulus operator % takes a decent amount of CPU\n> + * cycles (c.f. other division functions such as\n> + * include/linux/math64.h:iter_div_u64_rem()).\n> + */\n> +static __always_inline void es58x_add_skb_idx(struct es58x_priv *priv,\n> +\t\t\t\t\t u16 *idx, u16 a)\n> +{\n> +\t*idx += a;\n> +\tif (*idx >= priv->can.echo_skb_max)\n> +\t\t*idx -= priv->can.echo_skb_max;\n> +}\n> +\n> +/**\n> + * es58x_can_free_echo_skb_tail() - Remove the oldest echo skb of the\n> + *\tloopback FIFO.\n> + * @netdev: CAN network device.\n> + *\n> + * Naming convention: the tail is the beginning of the FIFO, i.e. the\n> + * first skb to have entered the FIFO.\n> + */\n> +static void es58x_can_free_echo_skb_tail(struct net_device *netdev)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tu16 tail_idx = priv->echo_skb_tail_idx;\n> +\tstruct sk_buff *skb = priv->can.echo_skb[tail_idx];\n> +\tunsigned long flags;\n> +\n> +\tnetdev_completed_queue(netdev, 1, es58x_can_frame_bytes(skb));\n> +\tcan_free_echo_skb(netdev, tail_idx);\n> +\n> +\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\tes58x_add_skb_idx(priv, &priv->echo_skb_tail_idx, 1);\n> +\tpriv->num_echo_skb--;\n> +\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\n> +\tnetdev->stats.tx_dropped++;\n> +}\n> +\n> +/**\n> + * es58x_can_get_echo_skb_recovery() - Try to re-sync the loopback FIFO.\n> + * @netdev: CAN network device.\n> + * @packet_idx: Index\n> + *\n> + * This function should not be called under normal circumstances. In\n> + * the unlikely case that one or several URB packages get dropped by\n> + * the device, the index will get out of sync. Try to recover by\n> + * dropping the echo skb packets with older indexes.\n> + *\n> + * Return: zero if recovery was successful, -EINVAL otherwise.\n> + */\n> +static int es58x_can_get_echo_skb_recovery(struct net_device *netdev,\n> +\t\t\t\t\t u32 packet_idx)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tu32 current_packet_idx, first_packet_idx, num_echo_skb;\n> +\tunsigned long flags;\n> +\tint ret = 0;\n> +\n> +\tnetdev->stats.tx_errors++;\n> +\n> +\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\tcurrent_packet_idx = priv->current_packet_idx;\n> +\tnum_echo_skb = priv->num_echo_skb;\n> +\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\tfirst_packet_idx = current_packet_idx - num_echo_skb;\n> +\n> +\tif (net_ratelimit())\n> +\t\tnetdev_warn(netdev,\n> +\t\t\t \"Bad loopback packet index: %u. First index: %u, end index %u, num_echo_skb: %02u/%02u\\n\",\n> +\t\t\t packet_idx, first_packet_idx,\n> +\t\t\t current_packet_idx - 1, num_echo_skb,\n> +\t\t\t priv->can.echo_skb_max);\n> +\n> +\tif (packet_idx < first_packet_idx) {\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_warn(netdev,\n> +\t\t\t\t \"Received loopback is from the past. Ignoring it\\n\");\n> +\t\tret = -EINVAL;\n> +\t} else if ((s32)(packet_idx - current_packet_idx) >= 0LL) {\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_err(netdev,\n> +\t\t\t\t \"Received loopback is from the future. Ignoring it\\n\");\n> +\t\tret = -EINVAL;\n> +\t} else {\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_warn(netdev,\n> +\t\t\t\t \"Loopback recovery: dropping %u echo skb from index %u to %u\\n\",\n> +\t\t\t\t packet_idx - first_packet_idx,\n> +\t\t\t\t first_packet_idx, packet_idx - 1);\n> +\t\twhile (first_packet_idx != packet_idx) {\n> +\t\t\tif (num_echo_skb == 0)\n> +\t\t\t\treturn -EINVAL;\n> +\t\t\tes58x_can_free_echo_skb_tail(netdev);\n> +\t\t\tfirst_packet_idx++;\n> +\t\t\tnum_echo_skb--;\n> +\t\t}\n> +\t}\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_can_get_echo_skb() - Get the skb from the loopback FIFO and\n> + *\tloop it back locally.\n> + * @netdev: CAN network device.\n> + * @packet_idx: Index of the first packet.\n> + * @tstamps: Array of hardware timestamps received from a ES58X device.\n> + * @pkts: Number of packets (and so, length of @tstamps).\n> + *\n> + * Callback function for when we receive a self reception acknowledgment.\n> + * Retrieves the skb from the loopback FIFO, sets its hardware timestamp\n> + * (the actual time it was sent) and loops it back locally.\n> + *\n> + * The device has to be active (i.e. network interface UP and not in\n> + * bus off state or restarting).\n> + *\n> + * Packet indexes must be consecutive (i.e. index of first packet is\n> + * @packet_idx, index of second packet is @packet_idx + 1 and index of\n> + * last packet is @packet_idx + @pkts - 1).\n> + *\n> + * Return: zero on success.\n> + */\n> +int es58x_can_get_echo_skb(struct net_device *netdev, u32 packet_idx,\n> +\t\t\t u64 *tstamps, unsigned int pkts)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tu16 tail_idx;\n> +\tu32 first_packet_idx;\n> +\tunsigned long flags;\n> +\tunsigned int frames_bytes = 0;\n> +\tint i;\n> +\tint ret = 0;\n> +\n> +\tif (!netif_running(netdev)) {\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_info(netdev,\n> +\t\t\t\t \"%s: %s is down, dropping %d loopback packets\\n\",\n> +\t\t\t\t __func__, netdev->name, pkts);\n> +\t\tnetdev->stats.tx_dropped++;\n> +\t\treturn 0;\n> +\t} else if (!es58x_is_can_state_active(netdev)) {\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev,\n> +\t\t\t\t \"Bus is off or device is restarting. Ignoring %u loopback packets from index %u\\n\",\n> +\t\t\t\t pkts, packet_idx);\n> +\t\t/* stats.tx_dropped will be (or was already)\n> +\t\t * incremented by\n> +\t\t * drivers/net/can/net/dev.c:can_flush_echo_skb().\n> +\t\t */\n> +\t\treturn 0;\n> +\t} else if (priv->num_echo_skb == 0) {\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_warn(netdev,\n> +\t\t\t\t \"Received %u loopback packets from index: %u but echo skb queue is empty.\\n\",\n> +\t\t\t\t pkts, packet_idx);\n> +\t\tnetdev->stats.tx_dropped += pkts;\n> +\t\treturn 0;\n> +\t}\n> +\n> +\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\tfirst_packet_idx = priv->current_packet_idx - priv->num_echo_skb;\n> +\tif (first_packet_idx != packet_idx) {\n> +\t\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\t\tret = es58x_can_get_echo_skb_recovery(netdev, packet_idx);\n> +\t\tif (ret < 0) {\n> +\t\t\tif (net_ratelimit())\n> +\t\t\t\tnetdev_warn(netdev,\n> +\t\t\t\t\t \"Could not find echo skb for loopback packet index: %u\\n\",\n> +\t\t\t\t\t packet_idx);\n> +\t\t\treturn 0;\n> +\t\t}\n> +\t\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\t\tfirst_packet_idx =\n> +\t\t priv->current_packet_idx - priv->num_echo_skb;\n> +\t\tWARN_ON(first_packet_idx != packet_idx);\n> +\t}\n> +\ttail_idx = priv->echo_skb_tail_idx;\n> +\tif (priv->num_echo_skb < pkts) {\n> +\t\tint pkts_drop = pkts - priv->num_echo_skb;\n> +\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_err(netdev,\n> +\t\t\t\t \"Received %u loopback packets but have only %d echo skb. Dropping %d echo skb\\n\",\n> +\t\t\t\t pkts, priv->num_echo_skb, pkts_drop);\n> +\t\tnetdev->stats.tx_dropped += pkts_drop;\n> +\t\tpkts -= pkts_drop;\n> +\t}\n> +\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\n> +\tfor (i = 0; i < pkts; i++) {\n> +\t\tstruct sk_buff *skb = priv->can.echo_skb[tail_idx];\n> +\n> +\t\tif (skb) {\n> +\t\t\tframes_bytes += es58x_can_frame_bytes(skb);\n> +\t\t\tes58x_set_skb_timestamp(netdev, skb, tstamps[i]);\n> +\t\t}\n> +\t\tnetdev->stats.tx_bytes += can_get_echo_skb(netdev, tail_idx);\n> +\n> +\t\tes58x_add_skb_idx(priv, &tail_idx, 1);\n> +\t}\n> +\n> +\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\tes58x_add_skb_idx(priv, &priv->echo_skb_tail_idx, pkts);\n> +\tpriv->num_echo_skb -= pkts;\n> +\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\n> +\tnetdev_completed_queue(netdev, pkts, frames_bytes);\n> +\tnetdev->stats.tx_packets += pkts;\n> +\n> +\tpriv->err_passive_before_rtx_success = 0;\n> +\tes58x_netif_wake_queue(netdev);\n> +\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_can_flush_echo_skb() - Reset the loopback FIFO.\n> + * @netdev: CAN network device.\n> + *\n> + * The echo_skb array of struct can_priv will be flushed by\n> + * drivers/net/can/dev.c:can_flush_echo_skb(). This function resets\n> + * the parameters of the struct es58x_priv of our device and reset the\n> + * queue (c.f. BQL).\n> + */\n> +static void es58x_can_flush_echo_skb(struct net_device *netdev)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tunsigned long flags;\n> +\n> +\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\tpriv->current_packet_idx = 0;\n> +\tpriv->echo_skb_tail_idx = 0;\n> +\tpriv->echo_skb_head_idx = 0;\n> +\tpriv->num_echo_skb = 0;\n> +\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\n> +\tnetdev_reset_queue(netdev);\n> +}\n> +\n> +/**\n> + * es58x_flush_pending_tx_msg() - Reset the buffer for transmission messages.\n> + * @netdev: CAN network device.\n> + *\n> + * es58x_start_xmit() will queue up to tx_bulk_max messages in\n> + * &tx_urb buffer and do a bulk send of all messages in one single URB\n> + * (c.f. xmit_more flag). When the device recovers from a bus off\n> + * state or when the device stops, the tx_urb buffer might still have\n> + * pending messages in it and thus need to be flushed.\n> + */\n> +static void es58x_flush_pending_tx_msg(struct net_device *netdev)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tstruct es58x_device *es58x_dev = priv->es58x_dev;\n> +\tunsigned long flags;\n> +\tint i;\n> +\n> +\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\tif (priv->tx_urb) {\n> +\t\tunsigned int frames_bytes = 0;\n> +\t\tu16 head_idx = priv->echo_skb_head_idx;\n> +\n> +\t\tnetdev_warn(netdev,\n> +\t\t\t \"%s: dropping %d tx_msg that were pending for transmission\\n\",\n> +\t\t\t __func__, priv->tx_can_msg_cnt);\n> +\t\tfor (i = 0; i < priv->tx_can_msg_cnt; i++) {\n> +\t\t\tframes_bytes +=\n> +\t\t\t es58x_can_frame_bytes(priv->can.echo_skb[head_idx]);\n> +\t\t\tcan_free_echo_skb(netdev, head_idx);\n> +\t\t\tes58x_add_skb_idx(priv, &head_idx, 1);\n> +\t\t}\n> +\t\t__netdev_sent_queue(netdev, 0, false);\n> +\t\tnetdev_completed_queue(netdev,\n> +\t\t\t\t priv->tx_can_msg_cnt, frames_bytes);\n> +\t\tusb_anchor_urb(priv->tx_urb, &priv->es58x_dev->tx_urbs_idle);\n> +\t\tnetdev->stats.tx_dropped += priv->tx_can_msg_cnt;\n> +\n> +\t\tatomic_inc(&es58x_dev->tx_urbs_idle_cnt);\n> +\t\tusb_free_urb(priv->tx_urb);\n> +\t}\n> +\tpriv->tx_urb = NULL;\n> +\tpriv->tx_can_msg_cnt = 0;\n> +\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +}\n> +\n> +/**\n> + * es58x_tx_ack_msg() - Handle acknowledgment messages.\n> + * @netdev: CAN network device.\n> + * @tx_free_entries: Number of free entries in the device transmit FIFO.\n> + * @rx_cmd_ret_u32: error code as returned by the ES58X device.\n> + *\n> + * ES58X sends an acknowledgment message after a transmission request\n> + * is done. This is mandatory for the ES581.4 but is optional (and\n> + * deactivated in this driver) for the ES58X_FD family.\n> + *\n> + * Under normal circumstances, this function should never throw an\n> + * error message.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +int es58x_tx_ack_msg(struct net_device *netdev, u16 tx_free_entries,\n> +\t\t enum es58x_ret_u32 rx_cmd_ret_u32)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\n> +\tif (tx_free_entries <= priv->es58x_dev->param->tx_bulk_max) {\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_err(netdev,\n> +\t\t\t\t \"Only %d entries remaining in device queue, echo_skb_max: %d, num_echo_skb: %d, tx_free_entries + num_echo_skb: %d\\n\",\n> +\t\t\t\t tx_free_entries, priv->can.echo_skb_max,\n> +\t\t\t\t priv->num_echo_skb,\n> +\t\t\t\t tx_free_entries + priv->num_echo_skb);\n> +\t\tnetif_stop_queue(netdev);\n> +\t}\n> +\n> +\treturn es58x_rx_cmd_ret_u32(netdev, ES58X_RET_TYPE_TX_MSG,\n> +\t\t\t\t rx_cmd_ret_u32);\n> +}\n> +\n> +/**\n> + * es58x_rx_can_msg() - Handle a received a CAN message.\n> + * @netdev: CAN network device.\n> + * @timestamp: Hardware time stamp (only relevant in rx branches).\n> + * @data: CAN payload.\n> + * @can_id: CAN ID.\n> + * @es58x_flags: Please refer to enum es58x_flag.\n> + * @dlc: Data Length Code (raw value).\n> + *\n> + * Fill up a CAN skb and post it.\n> + *\n> + * This function handles the case where the DLC of a classical CAN\n> + * frame is greater than CAN_MAX_DLEN (c.f. the len8_dlc field of\n> + * struct can_frame).\n> + *\n> + * Return: zero on success.\n> + */\n> +int es58x_rx_can_msg(struct net_device *netdev, u64 timestamp, const u8 *data,\n> +\t\t canid_t can_id, enum es58x_flag es58x_flags, u8 dlc)\n> +{\n> +\tstruct canfd_frame *cfd;\n> +\tstruct can_frame *ccf;\n> +\tstruct sk_buff *skb;\n> +\tu8 len;\n> +\tbool is_can_fd = !!(es58x_flags & ES58X_FLAG_FD_DATA);\n> +\n> +\tif (dlc > CAN_MAX_RAW_DLC) {\n> +\t\tnetdev_err(netdev,\n> +\t\t\t \"%s: DLC is %d but maximum should be %d\\n\",\n> +\t\t\t __func__, dlc, CAN_MAX_RAW_DLC);\n> +\t\treturn -EMSGSIZE;\n> +\t}\n> +\n> +\tif (is_can_fd) {\n> +\t\tlen = can_dlc2len(dlc);\n> +\t\tskb = alloc_canfd_skb(netdev, &cfd);\n> +\t} else {\n> +\t\tlen = can_get_cc_len(dlc);\n> +\t\tskb = alloc_can_skb(netdev, &ccf);\n> +\t\tcfd = (struct canfd_frame *)ccf;\n> +\t}\n> +\n> +\tif (!skb) {\n> +\t\tnetdev->stats.rx_dropped++;\n> +\t\treturn -ENOMEM;\n> +\t}\n> +\tcfd->can_id = can_id;\n> +\tcfd->len = len;\n> +\tif (es58x_flags & ES58X_FLAG_EFF)\n> +\t\tcfd->can_id |= CAN_EFF_FLAG;\n> +\tif (is_can_fd) {\n> +\t\tif (es58x_flags & ES58X_FLAG_FD_BRS)\n> +\t\t\tcfd->flags |= CANFD_BRS;\n> +\t\tif (es58x_flags & ES58X_FLAG_FD_ESI)\n> +\t\t\tcfd->flags |= CANFD_ESI;\n> +\t} else {\n> +\t\tccf->len8_dlc = can_get_len8_dlc(es58x_priv(netdev)->can.ctrlmode,\n> +\t\t\t\t\t\t len, dlc);\n> +\t\tif (es58x_flags & ES58X_FLAG_RTR) {\n> +\t\t\tccf->can_id |= CAN_RTR_FLAG;\n> +\t\t\tlen = 0;\n> +\t\t}\n> +\t}\n> +\tmemcpy(cfd->data, data, len);\n> +\tnetdev->stats.rx_packets++;\n> +\tnetdev->stats.rx_bytes += len;\n> +\n> +\tes58x_set_skb_timestamp(netdev, skb, timestamp);\n> +\tnetif_rx(skb);\n> +\n> +\tes58x_priv(netdev)->err_passive_before_rtx_success = 0;\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_rx_err_msg() - Handle a received CAN event or error message.\n> + * @netdev: CAN network device.\n> + * @error: Error code.\n> + * @event: Event code.\n> + * @timestamp: Timestamp received from a ES58X device.\n> + *\n> + * Handle the errors and events received by the ES58X device, create\n> + * a CAN error skb and post it.\n> + *\n> + * In some rare cases the devices might get stucked alternating between\n> + * CAN_STATE_ERROR_PASSIVE and CAN_STATE_ERROR_WARNING. To prevent\n> + * this behavior, we force a bus off state if the device goes in\n> + * CAN_STATE_ERROR_WARNING for ES58X_MAX_CONSECUTIVE_WARN consecutive\n> + * times with no successful transmission or reception in between.\n> + *\n> + * Once the device is in bus off state, the only way to restart it is\n> + * through the drivers/net/can/dev.c:can_restart() function. The\n> + * device is technically capable to recover by itself under certain\n> + * circumstances, however, allowing self recovery would create\n> + * complex race conditions with drivers/net/can/dev.c:can_restart()\n> + * and thus was not implemented. To activate automatic restart, please\n> + * set the restart-ms parameter (e.g. ip link set can0 type can\n> + * restart-ms 100).\n> + *\n> + * If the bus is really instable, this function would try to send a\n> + * lot of log messages. Those are rate limited (i.e. you will see\n> + * messages such as \"net_ratelimit: XXX callbacks suppressed\" in\n> + * dmesg).\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +int es58x_rx_err_msg(struct net_device *netdev, enum es58x_err error,\n> +\t\t enum es58x_event event, u64 timestamp)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tstruct can_priv *can = netdev_priv(netdev);\n> +\tstruct can_device_stats *can_stats = &can->can_stats;\n> +\tstruct can_frame *cf;\n> +\tstruct sk_buff *skb;\n> +\tunsigned long flags;\n> +\n> +\tif (!netif_running(netdev)) {\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_info(netdev, \"%s: %s is down, dropping packet\\n\",\n> +\t\t\t\t __func__, netdev->name);\n> +\t\tnetdev->stats.rx_dropped++;\n> +\t\treturn 0;\n> +\t}\n> +\n> +\tif (error == ES58X_ERR_OK && event == ES58X_EVENT_OK) {\n> +\t\tnetdev_err(netdev, \"%s: Both error and event are zero\\n\",\n> +\t\t\t __func__);\n> +\t\treturn -EINVAL;\n> +\t}\n> +\n> +\tskb = alloc_can_err_skb(netdev, &cf);\n> +\tif (!skb)\n> +\t\treturn -ENOMEM;\n> +\n> +\tswitch (error) {\n> +\tcase ES58X_ERR_OK:\t/* 0: No error */\n> +\t\tbreak;\n> +\n> +\tcase ES58X_ERR_PROT_STUFF:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Error BITSUFF\\n\");\n> +\t\tcf->data[2] |= CAN_ERR_PROT_STUFF;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_ERR_PROT_FORM:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Error FORMAT\\n\");\n> +\t\tcf->data[2] |= CAN_ERR_PROT_FORM;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_ERR_ACK:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Error ACK\\n\");\n> +\t\tcf->can_id |= CAN_ERR_ACK;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_ERR_PROT_BIT:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Error BIT\\n\");\n> +\t\tcf->data[2] |= CAN_ERR_PROT_BIT;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_ERR_PROT_CRC:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Error CRC\\n\");\n> +\t\tcf->data[3] |= CAN_ERR_PROT_LOC_CRC_SEQ;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_ERR_PROT_BIT1:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev,\n> +\t\t\t\t \"Error: expected a recessive bit but monitored a dominant one\\n\");\n> +\t\tcf->data[2] |= CAN_ERR_PROT_BIT1;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_ERR_PROT_BIT0:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev,\n> +\t\t\t\t \"Error expected a dominant bit but monitored a recessive one\\n\");\n> +\t\tcf->data[2] |= CAN_ERR_PROT_BIT0;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_ERR_PROT_OVERLOAD:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Error OVERLOAD\\n\");\n> +\t\tcf->data[2] |= CAN_ERR_PROT_OVERLOAD;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_ERR_PROT_UNSPEC:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Unspecified error\\n\");\n> +\t\tcf->can_id |= CAN_ERR_PROT;\n> +\t\tbreak;\n> +\n> +\tdefault:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_err(netdev,\n> +\t\t\t\t \"%s: Unspecified error code 0x%04X\\n\",\n> +\t\t\t\t __func__, (int)error);\n> +\t\tcf->can_id |= CAN_ERR_PROT;\n> +\t\tbreak;\n> +\t}\n> +\n> +\tswitch (event) {\n> +\tcase ES58X_EVENT_OK:\t/* 0: No event */\n> +\t\tbreak;\n> +\n> +\tcase ES58X_EVENT_CRTL_ACTIVE:\n> +\t\tif (can->state == CAN_STATE_BUS_OFF) {\n> +\t\t\tnetdev_err(netdev,\n> +\t\t\t\t \"%s: state transition: BUS OFF -> ACTIVE\\n\",\n> +\t\t\t\t __func__);\n> +\t\t}\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Event CAN BUS ACTIVE\\n\");\n> +\t\tcf->data[1] |= CAN_ERR_CRTL_ACTIVE;\n> +\t\tcan->state = CAN_STATE_ERROR_ACTIVE;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_EVENT_CRTL_PASSIVE:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Event CAN BUS PASSIVE\\n\");\n> +\t\t/* Either TX or RX error count reached passive state\n> +\t\t * but we do not know which. Setting both flags by\n> +\t\t * default.\n> +\t\t */\n> +\t\tcf->data[1] |= CAN_ERR_CRTL_RX_PASSIVE;\n> +\t\tcf->data[1] |= CAN_ERR_CRTL_TX_PASSIVE;\n> +\t\tif (can->state < CAN_STATE_BUS_OFF)\n> +\t\t\tcan->state = CAN_STATE_ERROR_PASSIVE;\n> +\t\tcan_stats->error_passive++;\n> +\t\tif (priv->err_passive_before_rtx_success < U8_MAX)\n> +\t\t\tpriv->err_passive_before_rtx_success++;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_EVENT_CRTL_WARNING:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Event CAN BUS WARNING\\n\");\n> +\t\t/* Either TX or RX error count reached warning state\n> +\t\t * but we do not know which. Setting both flags by\n> +\t\t * default.\n> +\t\t */\n> +\t\tcf->data[1] |= CAN_ERR_CRTL_RX_WARNING;\n> +\t\tcf->data[1] |= CAN_ERR_CRTL_TX_WARNING;\n> +\t\tif (can->state < CAN_STATE_BUS_OFF)\n> +\t\t\tcan->state = CAN_STATE_ERROR_WARNING;\n> +\t\tcan_stats->error_warning++;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_EVENT_BUSOFF:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"Event CAN BUS OFF\\n\");\n> +\t\t/* Prevent the network device queue for being woke-up\n> +\t\t * by another interrupt while we set the bus to off\n> +\t\t * status.\n> +\t\t */\n> +\t\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\t\tnetif_stop_queue(netdev);\n> +\t\tif (can->state != CAN_STATE_BUS_OFF) {\n> +\t\t\tcan->state = CAN_STATE_BUS_OFF;\n> +\t\t\tcan_bus_off(netdev);\n> +\t\t}\n> +\t\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\t\tcf->can_id |= CAN_ERR_BUSOFF;\n> +\t\tcan_stats->bus_off++;\n> +\t\tbreak;\n> +\n> +\tcase ES58X_EVENT_SINGLE_WIRE:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_warn(netdev,\n> +\t\t\t\t \"Lost connection on either CAN high or CAN low\\n\");\n> +\t\t/* Lost connection on either CAN high or CAN\n> +\t\t * low. Setting both flags by default.\n> +\t\t */\n> +\t\tcf->data[4] |= CAN_ERR_TRX_CANH_NO_WIRE;\n> +\t\tcf->data[4] |= CAN_ERR_TRX_CANL_NO_WIRE;\n> +\t\tbreak;\n> +\n> +\tdefault:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_err(netdev,\n> +\t\t\t\t \"%s: Unspecified event code 0x%04X\\n\",\n> +\t\t\t\t __func__, (int)event);\n> +\t\tcf->can_id |= CAN_ERR_CRTL;\n> +\t\tbreak;\n> +\t}\n> +\n> +\tif (cf->data[1])\n> +\t\tcf->can_id |= CAN_ERR_CRTL;\n> +\tif (cf->data[2] || cf->data[3]) {\n> +\t\tcf->can_id |= CAN_ERR_PROT;\n> +\t\tcan_stats->bus_error++;\n> +\t}\n> +\tif (cf->data[4])\n> +\t\tcf->can_id |= CAN_ERR_TRX;\n> +\n> +\t/* driver/net/can/dev.c:can_restart() takes in account error\n> +\t * messages in the RX stats. Doing same here for\n> +\t * consistency.\n> +\t */\n> +\tnetdev->stats.rx_packets++;\n> +\tnetdev->stats.rx_bytes += cf->can_dlc;\n> +\n> +\tes58x_set_skb_timestamp(netdev, skb, timestamp);\n> +\tnetif_rx(skb);\n> +\n> +\tif ((event & ES58X_EVENT_CRTL_PASSIVE) &&\n> +\t priv->err_passive_before_rtx_success ==\n> +\t ES58X_CONSECUTIVE_ERR_PASSIVE_MAX) {\n> +\t\tnetdev_info(netdev,\n> +\t\t\t \"Got %d consecutive warning events with no successful rx or tx. Forcing bus-off\\n\",\n> +\t\t\t priv->err_passive_before_rtx_success);\n> +\t\treturn es58x_rx_err_msg(netdev, ES58X_ERR_OK,\n> +\t\t\t\t\tES58X_EVENT_BUSOFF, timestamp);\n> +\t}\n> +\n> +\treturn 0;\n> +}\n> +\n> +/* Human readable description of the &enum es58x_cmd_ret_type. */\n> +static const char *const es58x_cmd_ret_desc[] = {\n> +\t\"Set bittiming\",\n> +\t\"Enable channel\",\n> +\t\"Disable channel\",\n> +\t\"Transmit message\",\n> +\t\"Reset rx\",\n> +\t\"Reset tx\",\n> +\t\"Device error\"\n> +};\n> +\n> +/**\n> + * es58x_rx_dev_ret_u8() - Handle return codes received from the\n> + *\tES58X device.\n> + * @dev: Device, only used for the dev_XXX() print functions.\n> + * @cmd_ret_type: Type of the command which triggered the return code.\n> + * @rx_dev_ret_u8: error code as returned by the ES58X device.\n> + *\n> + * Handles the 8 bits return code. Those are specific to the ES581.4\n> + * device. The return value will eventually be used by\n> + * es58x_handle_urb_cmd() function which will take proper actions in\n> + * case of critical issues such and memory errors or bad CRC values.\n> + *\n> + * In contrast with es58x_rx_cmd_ret_u32(), the network device is\n> + * unknown.\n> + *\n> + * Return: zero on success, return errno when any error occurs.\n> + */\n> +int es58x_rx_dev_ret_u8(struct device *dev,\n> +\t\t\tenum es58x_ret_type cmd_ret_type,\n> +\t\t\tenum es58x_ret_u8 rx_dev_ret_u8)\n> +{\n> +\tconst char *ret_desc = es58x_cmd_ret_desc[cmd_ret_type];\n> +\n> +\tcompiletime_assert(ARRAY_SIZE(es58x_cmd_ret_desc) ==\n> +\t\t\t ES58X_RET_TYPE_NUM_ENTRIES,\n> +\t\t\t \"Size mismatch between es58x_cmd_ret_desc and enum es58x_cmd_ret_type\");\n> +\n> +\tswitch (rx_dev_ret_u8) {\n> +\tcase ES58X_RET_U8_OK:\n> +\t\tdev_dbg_ratelimited(dev, \"%s: OK\\n\", ret_desc);\n> +\t\tbreak;\n> +\n> +\tcase ES58X_RET_U8_ERR_UNSPECIFIED_FAILURE:\n> +\t\tdev_err(dev, \"%s: unspecified failure\\n\", ret_desc);\n> +\t\tbreak;\n> +\n> +\tcase ES58X_RET_U8_ERR_NO_MEM:\n> +\t\tdev_err(dev, \"%s: device ran out of memory\\n\", ret_desc);\n> +\t\treturn -ENOMEM;\n> +\n> +\tcase ES58X_RET_U8_ERR_BAD_CRC:\n> +\t\tdev_err(dev, \"%s: CRC of previous command is incorrect\\n\",\n> +\t\t\tret_desc);\n> +\t\treturn -EIO;\n> +\n> +\tdefault:\n> +\t\tdev_err(dev, \"%s: returned unknown value: 0x%02X\\n\",\n> +\t\t\tret_desc, rx_dev_ret_u8);\n> +\t\tbreak;\n> +\t}\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_rx_dev_ret_u32() - Handle return codes received from the\n> + *\tES58X device.\n> + * @netdev: CAN network device.\n> + * @cmd_ret_type: Type of the command which triggered the return code.\n> + * @rx_cmd_ret_u32: error code as returned by the ES58X device.\n> + *\n> + * Handles the 32 bits return code. The return value will eventually\n> + * be used by es58x_handle_urb_cmd() function which will take proper\n> + * actions in case of critical issues such and memory errors or bad\n> + * CRC values.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +int es58x_rx_cmd_ret_u32(struct net_device *netdev,\n> +\t\t\t enum es58x_ret_type cmd_ret_type,\n> +\t\t\t enum es58x_ret_u32 rx_cmd_ret_u32)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tconst char *ret_desc = es58x_cmd_ret_desc[cmd_ret_type];\n> +\n> +\tswitch (rx_cmd_ret_u32) {\n> +\tcase ES58X_RET_U32_OK:\n> +\t\tswitch (cmd_ret_type) {\n> +\t\tcase ES58X_RET_TYPE_ENABLE_CHANNEL:\n> +\t\t\tes58x_flush_pending_tx_msg(netdev);\n> +\t\t\tes58x_can_flush_echo_skb(netdev);\n> +\t\t\tpriv->err_passive_before_rtx_success = 0;\n> +\t\t\tpriv->can.state = CAN_STATE_ERROR_ACTIVE;\n> +\t\t\tes58x_netif_wake_queue(netdev);\n> +\t\t\tnetdev_info(netdev,\n> +\t\t\t\t \"%s (Serial Number %s): CAN%d channel becomes ready\\n\",\n> +\t\t\t\t priv->es58x_dev->udev->product,\n> +\t\t\t\t priv->es58x_dev->udev->serial,\n> +\t\t\t\t priv->channel_idx + 1);\n> +\t\t\tbreak;\n> +\n> +\t\tcase ES58X_RET_TYPE_TX_MSG:\n> +#ifdef VERBOSE_DEBUG\n> +\t\t\tif (net_ratelimit())\n> +\t\t\t\tnetdev_vdbg(netdev, \"%s: OK\\n\", ret_desc);\n> +#endif\n> +\t\t\tbreak;\n> +\n> +\t\tdefault:\n> +\t\t\tnetdev_dbg(netdev, \"%s: OK\\n\", ret_desc);\n> +\t\t\tbreak;\n> +\t\t}\n> +\t\tbreak;\n> +\n> +\tcase ES58X_RET_U32_ERR_UNSPECIFIED_FAILURE:\n> +\t\tif (cmd_ret_type == ES58X_RET_TYPE_DISABLE_CHANNEL)\n> +\t\t\tnetdev_dbg(netdev,\n> +\t\t\t\t \"%s: channel is already closed\\n\", ret_desc);\n> +\t\telse\n> +\t\t\tnetdev_err(netdev,\n> +\t\t\t\t \"%s: unspecified failure\\n\", ret_desc);\n> +\t\tbreak;\n> +\n> +\tcase ES58X_RET_U32_ERR_NO_MEM:\n> +\t\tnetdev_err(netdev, \"%s: device ran out of memory\\n\", ret_desc);\n> +\t\treturn -ENOMEM;\n> +\n> +\tcase ES58X_RET_U32_WARN_PARAM_ADJUSTED:\n> +\t\tnetdev_warn(netdev,\n> +\t\t\t \"%s: some incompatible parameters have been adjusted\\n\",\n> +\t\t\t ret_desc);\n> +\t\tbreak;\n> +\n> +\tcase ES58X_RET_U32_WARN_TX_MAYBE_REORDER:\n> +\t\tnetdev_warn(netdev,\n> +\t\t\t \"%s: TX messages might have been reordered\\n\",\n> +\t\t\t ret_desc);\n> +\t\tbreak;\n> +\n> +\tcase ES58X_RET_U32_ERR_TIMEOUT:\n> +\t\tnetdev_err(netdev, \"%s: command timed out\\n\", ret_desc);\n> +\t\tbreak;\n> +\n> +\tcase ES58X_RET_U32_ERR_FIFO_FULL:\n> +\t\tnetdev_warn(netdev, \"%s: fifo is full\\n\", ret_desc);\n> +\t\tbreak;\n> +\n> +\tcase ES58X_RET_U32_ERR_BAD_CONFIG:\n> +\t\tnetdev_err(netdev, \"%s: bad configuration\\n\", ret_desc);\n> +\t\treturn -EINVAL;\n> +\n> +\tcase ES58X_RET_U32_ERR_NO_RESOURCE:\n> +\t\tnetdev_err(netdev, \"%s: no resource available\\n\", ret_desc);\n> +\t\tbreak;\n> +\n> +\tdefault:\n> +\t\tnetdev_err(netdev, \"%s returned unknown value: 0x%08X\\n\",\n> +\t\t\t ret_desc, rx_cmd_ret_u32);\n> +\t\tbreak;\n> +\t}\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_increment_rx_errors() - Increment the network devices' error\n> + *\tcount.\n> + * @es58x_dev: ES58X device.\n> + *\n> + * If an error occurs on the early stages on receiving an URB command,\n> + * we might not be able to figure out on which network device the\n> + * error occurred. In such case, we arbitrarily increment the error\n> + * count of all the network devices attached to our ES58X device.\n> + */\n> +static void es58x_increment_rx_errors(struct es58x_device *es58x_dev)\n> +{\n> +\tint i;\n> +\n> +\tfor (i = 0; i < es58x_dev->num_can_ch; i++)\n> +\t\tif (es58x_dev->netdev[i])\n> +\t\t\tes58x_dev->netdev[i]->stats.rx_errors++;\n> +}\n> +\n> +/**\n> + * es58x_handle_urb_cmd() - Handle the URB command\n> + * @es58x_dev: ES58X device.\n> + * @urb_cmd: The URB command received from the ES58X device, might not\n> + *\tbe aligned.\n> + *\n> + * Sends the URB command to the device specific function. Manages the\n> + * errors throwed back by those functions.\n> + */\n> +static void es58x_handle_urb_cmd(struct es58x_device *es58x_dev,\n> +\t\t\t\t const union es58x_urb_cmd *urb_cmd)\n> +{\n> +\tconst struct es58x_operators *ops = es58x_dev->ops;\n> +\tsize_t cmd_len;\n> +\tint i, ret;\n> +\n> +\tret = ops->handle_urb_cmd(es58x_dev, urb_cmd);\n> +\tswitch (ret) {\n> +\tcase 0:\t\t/* OK */\n> +\t\treturn;\n> +\n> +\tcase -ENODEV:\n> +\t\tdev_err_ratelimited(es58x_dev->dev, \"Device is not ready\\n\");\n> +\t\tbreak;\n> +\n> +\tcase -EINVAL:\n> +\tcase -EMSGSIZE:\n> +\tcase -EBADRQC:\n> +\tcase -EBADMSG:\n> +\tcase -ECHRNG:\n> +\t\tcmd_len = es58x_get_urb_cmd_len(es58x_dev,\n> +\t\t\t\t\t\tops->get_msg_len(urb_cmd));\n> +\t\tdev_err(es58x_dev->dev,\n> +\t\t\t\"ops->handle_urb_cmd() returned error %pe\",\n> +\t\t\tERR_PTR(ret));\n> +\t\tes58x_print_hex_dump(urb_cmd, cmd_len);\n> +\t\tbreak;\n> +\n> +\tcase -EFAULT:\n> +\tcase -ENOMEM:\n> +\tcase -EIO:\n> +\tdefault:\n> +\t\tdev_crit(es58x_dev->dev,\n> +\t\t\t \"ops->handle_urb_cmd() returned error %pe, detaching all network devices\\n\",\n> +\t\t\t ERR_PTR(ret));\n> +\t\tfor (i = 0; i < es58x_dev->num_can_ch; i++)\n> +\t\t\tif (es58x_dev->netdev[i])\n> +\t\t\t\tnetif_device_detach(es58x_dev->netdev[i]);\n> +\t\tbreak;\n> +\t}\n> +\n> +\t/* Because the urb command could not fully be parsed,\n> +\t * channel_id is not confirmed. Incrementing rx_errors count\n> +\t * of all channels.\n> +\t */\n> +\tes58x_increment_rx_errors(es58x_dev);\n> +}\n> +\n> +/**\n> + * es58x_check_rx_urb() - Check the length and format of the URB command.\n> + * @es58x_dev: ES58X device.\n> + * @urb_cmd: The URB command received from the ES58X device, might not\n> + *\tbe aligned.\n> + * @urb_actual_len: The actual length of the URB command.\n> + *\n> + * Check if the first message of the received urb is valid, that is to\n> + * say that both the header and the length are coherent.\n> + *\n> + * Return:\n> + * the length of the first message of the URB on success.\n> + *\n> + * -ENODATA if the URB command is incomplete (in which case, the URB\n> + * command should be buffered and combined with the next URB to try to\n> + * reconstitute the URB command).\n> + *\n> + * -EOVERFLOW if the length is bigger than the maximum expected one.\n> + *\n> + * -EBADRQC if the start of frame does not match the expected value.\n> + */\n> +static signed int es58x_check_rx_urb(struct es58x_device *es58x_dev,\n> +\t\t\t\t const union es58x_urb_cmd *urb_cmd,\n> +\t\t\t\t u32 urb_actual_len)\n> +{\n> +\tconst struct device *dev = es58x_dev->dev;\n> +\tconst struct es58x_parameters *param = es58x_dev->param;\n> +\tu16 sof, msg_len;\n> +\tsigned int urb_cmd_len, ret;\n> +\n> +\tif (urb_actual_len < param->urb_cmd_header_len) {\n> +\t\tdev_vdbg(dev,\n> +\t\t\t \"%s: Received %d bytes [%*ph]: header incomplete\\n\",\n> +\t\t\t __func__, urb_actual_len, urb_actual_len,\n> +\t\t\t urb_cmd->raw_cmd);\n> +\t\treturn -ENODATA;\n> +\t}\n> +\n> +\tsof = get_unaligned_le16(&urb_cmd->sof);\n> +\tif (sof != param->rx_start_of_frame) {\n> +\t\tdev_err_ratelimited(es58x_dev->dev,\n> +\t\t\t\t \"%s: Expected sequence 0x%04X for start of frame but got 0x%04X.\\n\",\n> +\t\t\t\t __func__, param->rx_start_of_frame, sof);\n> +\t\treturn -EBADRQC;\n> +\t}\n> +\n> +\tmsg_len = es58x_dev->ops->get_msg_len(urb_cmd);\n> +\turb_cmd_len = es58x_get_urb_cmd_len(es58x_dev, msg_len);\n> +\tif (urb_cmd_len > param->rx_urb_cmd_max_len) {\n> +\t\tdev_err_ratelimited(es58x_dev->dev,\n> +\t\t\t\t \"%s: Biggest expected size for rx urb_cmd is %u but receive a command of size %d\\n\",\n> +\t\t\t\t __func__,\n> +\t\t\t\t param->rx_urb_cmd_max_len, urb_cmd_len);\n> +\t\treturn -EOVERFLOW;\n> +\t} else if (urb_actual_len < urb_cmd_len) {\n> +\t\tdev_vdbg(dev, \"%s: Received %02d/%02d bytes\\n\",\n> +\t\t\t __func__, urb_actual_len, urb_cmd_len);\n> +\t\treturn -ENODATA;\n> +\t}\n> +\n> +\tret = es58x_check_crc(es58x_dev, urb_cmd, urb_cmd_len);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\treturn urb_cmd_len;\n> +}\n> +\n> +/**\n> + * es58x_flush_cmd_buf() - Reset the buffer for URB commands.\n> + * @es58x_dev: ES58X device.\n> + */\n> +static void es58x_flush_cmd_buf(struct es58x_device *es58x_dev)\n> +{\n> +\tmemset(&es58x_dev->rx_cmd_buf, 0, es58x_dev->param->rx_urb_cmd_max_len);\n> +\tes58x_dev->rx_cmd_buf_len = 0;\n> +}\n> +\n> +/**\n> + * es58x_copy_to_cmd_buf() - Copy an array to the URB command buffer.\n> + * @es58x_dev: ES58X device.\n> + * @raw_cmd: the buffer we want to copy.\n> + * @raw_cmd_len: length of @raw_cmd.\n> + *\n> + * Concatenates @raw_cmd_len bytes of @raw_cmd to the end of the URB\n> + * command buffer.\n> + *\n> + * Return: zero on success, -EMSGSIZE if not enough space is available\n> + * to do the copy.\n> + */\n> +static int es58x_copy_to_cmd_buf(struct es58x_device *es58x_dev,\n> +\t\t\t\t u8 *raw_cmd, int raw_cmd_len)\n> +{\n> +\tif (es58x_dev->rx_cmd_buf_len + raw_cmd_len >\n> +\t es58x_dev->param->rx_urb_cmd_max_len)\n> +\t\treturn -EMSGSIZE;\n> +\n> +\tmemcpy(&es58x_dev->rx_cmd_buf.raw_cmd[es58x_dev->rx_cmd_buf_len],\n> +\t raw_cmd, raw_cmd_len);\n> +\tes58x_dev->rx_cmd_buf_len += raw_cmd_len;\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_split_urb_try_recovery() - Try to recover bad URB sequences.\n> + * @es58x_dev: ES58X device.\n> + * @raw_cmd: pointer to the buffer we want to copy.\n> + * @raw_cmd_len: length of @raw_cmd.\n> + *\n> + * Under some rare conditions, we might get incorrect URBs from the\n> + * device. From our observations, one of the valid URB gets replaced\n> + * by one from the past. The full root cause is not identified.\n> + *\n> + * This function looks for the next start of frame in the urb buffer\n> + * in order to try to recover.\n> + *\n> + * Such behavior was not observed on the devices of the ES58X FD\n> + * family and only seems to impact the ES581.4.\n> + *\n> + * Return: the number of bytes dropped on success, -EBADMSG if recovery failed.\n> + */\n> +static int es58x_split_urb_try_recovery(struct es58x_device *es58x_dev,\n> +\t\t\t\t\tu8 *raw_cmd, size_t raw_cmd_len)\n> +{\n> +\tunion es58x_urb_cmd *urb_cmd;\n> +\tsigned int urb_cmd_len;\n> +\tu16 sof;\n> +\tint dropped_bytes = 0;\n> +\n> +\tes58x_increment_rx_errors(es58x_dev);\n> +\n> +\twhile (raw_cmd_len > sizeof(sof)) {\n> +\t\turb_cmd = (union es58x_urb_cmd *)raw_cmd;\n> +\t\tsof = get_unaligned_le16(&urb_cmd->sof);\n> +\n> +\t\tif (sof == es58x_dev->param->rx_start_of_frame) {\n> +\t\t\turb_cmd_len = es58x_check_rx_urb(es58x_dev,\n> +\t\t\t\t\t\t\t urb_cmd, raw_cmd_len);\n> +\t\t\tif ((urb_cmd_len == -ENODATA) || urb_cmd_len > 0) {\n> +\t\t\t\tdev_info_ratelimited(es58x_dev->dev,\n> +\t\t\t\t\t\t \"Recovery successful! Dropped %d bytes (urb_cmd_len: %d)\\n\",\n> +\t\t\t\t\t\t dropped_bytes,\n> +\t\t\t\t\t\t urb_cmd_len);\n> +\t\t\t\treturn dropped_bytes;\n> +\t\t\t}\n> +\t\t}\n> +\t\traw_cmd++;\n> +\t\traw_cmd_len--;\n> +\t\tdropped_bytes++;\n> +\t}\n> +\n> +\tdev_warn_ratelimited(es58x_dev->dev, \"%s: Recovery failed\\n\", __func__);\n> +\treturn -EBADMSG;\n> +}\n> +\n> +/**\n> + * es58x_handle_incomplete_cmd() - Reconstitute an URB command from\n> + *\tdifferent URB pieces.\n> + * @es58x_dev: ES58X device.\n> + * @urb: last urb buffer received.\n> + *\n> + * The device might split the URB commands in an arbitrary amount of\n> + * pieces. This function concatenates those in an URB buffer until a\n> + * full URB command is reconstituted and consume it.\n> + *\n> + * Return:\n> + * number of bytes consumed from @urb if successful.\n> + *\n> + * -ENODATA if the URB command is still incomplete.\n> + *\n> + * -EBADMSG if the URB command is incorrect.\n> + */\n> +static signed int es58x_handle_incomplete_cmd(struct es58x_device *es58x_dev,\n> +\t\t\t\t\t struct urb *urb)\n> +{\n> +\tsize_t cpy_len;\n> +\tsigned int urb_cmd_len, tmp_cmd_buf_len, ret;\n> +\n> +\ttmp_cmd_buf_len = es58x_dev->rx_cmd_buf_len;\n> +\tcpy_len = min_t(int, es58x_dev->param->rx_urb_cmd_max_len -\n> +\t\t\tes58x_dev->rx_cmd_buf_len, urb->actual_length);\n> +\tret = es58x_copy_to_cmd_buf(es58x_dev, urb->transfer_buffer, cpy_len);\n> +\tif (ret < 0)\n> +\t\treturn ret;\n> +\n> +\turb_cmd_len = es58x_check_rx_urb(es58x_dev, &es58x_dev->rx_cmd_buf,\n> +\t\t\t\t\t es58x_dev->rx_cmd_buf_len);\n> +\tif (urb_cmd_len == -ENODATA) {\n> +\t\treturn -ENODATA;\n> +\t} else if (urb_cmd_len < 0) {\n> +\t\tdev_err_ratelimited(es58x_dev->dev,\n> +\t\t\t\t \"Could not reconstitute incomplete command from previous URB, dropping %d bytes\\n\",\n> +\t\t\t\t tmp_cmd_buf_len + urb->actual_length);\n> +\t\tdev_err_ratelimited(es58x_dev->dev,\n> +\t\t\t\t \"Error code: %pe, es58x_dev->rx_cmd_buf_len: %d, urb->actual_length: %u\\n\",\n> +\t\t\t\t ERR_PTR(urb_cmd_len),\n> +\t\t\t\t tmp_cmd_buf_len, urb->actual_length);\n> +\t\tes58x_print_hex_dump(&es58x_dev->rx_cmd_buf, tmp_cmd_buf_len);\n> +\t\tes58x_print_hex_dump(urb->transfer_buffer, urb->actual_length);\n> +\t\treturn urb->actual_length;\n> +\t}\n> +\n> +\tes58x_handle_urb_cmd(es58x_dev, &es58x_dev->rx_cmd_buf);\n> +\treturn urb_cmd_len - tmp_cmd_buf_len;\t/* consumed length */\n> +}\n> +\n> +/**\n> + * es58x_split_urb() - Cut the received URB in individual URB commands.\n> + * @es58x_dev: ES58X device.\n> + * @urb: last urb buffer received.\n> + *\n> + * The device might send urb in bulk format (i.e. several URB commands\n> + * concatenated together). This function will split all the commands\n> + * contained in the urb.\n> + *\n> + * Return:\n> + * number of bytes consumed from @urb if successful.\n> + *\n> + * -ENODATA if the URB command is still incomplete.\n> + *\n> + * -EBADMSG if the URB command is incorrect.\n> + */\n> +static signed int es58x_split_urb(struct es58x_device *es58x_dev,\n> +\t\t\t\t struct urb *urb)\n> +{\n> +\tconst u8 es58x_is_alive = 0x11;\n> +\tunion es58x_urb_cmd *urb_cmd;\n> +\tu8 *raw_cmd = urb->transfer_buffer;\n> +\tssize_t raw_cmd_len = urb->actual_length;\n> +\tint ret;\n> +\n> +\tif (es58x_dev->rx_cmd_buf_len != 0) {\n> +\t\tret = es58x_handle_incomplete_cmd(es58x_dev, urb);\n> +\t\tif (ret != -ENODATA)\n> +\t\t\tes58x_flush_cmd_buf(es58x_dev);\n> +\t\tif (ret < 0)\n> +\t\t\treturn ret;\n> +\n> +\t\traw_cmd += ret;\n> +\t\traw_cmd_len -= ret;\n> +\t}\n> +\n> +\twhile (raw_cmd_len > 0) {\n> +\t\tif (raw_cmd[0] == es58x_is_alive) {\n> +\t\t\traw_cmd++;\n> +\t\t\traw_cmd_len--;\n> +\t\t\tcontinue;\n> +\t\t}\n> +\t\turb_cmd = (union es58x_urb_cmd *)raw_cmd;\n> +\t\tret = es58x_check_rx_urb(es58x_dev, urb_cmd, raw_cmd_len);\n> +\t\tif (ret > 0) {\n> +\t\t\tes58x_handle_urb_cmd(es58x_dev, urb_cmd);\n> +\t\t} else if (ret == -ENODATA) {\n> +\t\t\tes58x_copy_to_cmd_buf(es58x_dev, raw_cmd, raw_cmd_len);\n> +\t\t\treturn -ENODATA;\n> +\t\t} else if (ret < 0) {\n> +\t\t\tret = es58x_split_urb_try_recovery(es58x_dev, raw_cmd,\n> +\t\t\t\t\t\t\t raw_cmd_len);\n> +\t\t\tif (ret < 0)\n> +\t\t\t\treturn ret;\n> +\t\t}\n> +\t\traw_cmd += ret;\n> +\t\traw_cmd_len -= ret;\n> +\t}\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_read_bulk_callback() - Callback for reading data from device.\n> + * @urb: last urb buffer received.\n> + *\n> + * This function gets eventually called each time an URB is received\n> + * from the ES58X device.\n> + *\n> + * Checks urb status, calls read function and resubmits urb read\n> + * operation.\n> + */\n> +static void es58x_read_bulk_callback(struct urb *urb)\n> +{\n> +\tstruct es58x_device *es58x_dev = urb->context;\n> +\tconst struct device *dev = es58x_dev->dev;\n> +\tint i, ret;\n> +\n> +\tswitch (urb->status) {\n> +\tcase 0:\t\t/* success */\n> +\t\tbreak;\n> +\n> +\tcase -EOVERFLOW:\n> +\t\tdev_err_ratelimited(dev, \"%s: error %pe\\n\",\n> +\t\t\t\t __func__, ERR_PTR(urb->status));\n> +\t\tes58x_print_hex_dump_debug(urb->transfer_buffer,\n> +\t\t\t\t\t urb->transfer_buffer_length);\n> +\t\tgoto resubmit_urb;\n> +\n> +\tcase -EPROTO:\n> +\t\tdev_warn_ratelimited(dev, \"%s: error %pe. Device unplugged?\\n\",\n> +\t\t\t\t __func__, ERR_PTR(urb->status));\n> +\t\tgoto free_urb;\n> +\n> +\tcase -ENOENT:\n> +\tcase -EPIPE:\n> +\t\tdev_err_ratelimited(dev, \"%s: error %pe\\n\",\n> +\t\t\t\t __func__, ERR_PTR(urb->status));\n> +\t\tgoto free_urb;\n> +\n> +\tcase -ESHUTDOWN:\n> +\t\tdev_dbg_ratelimited(dev, \"%s: error %pe\\n\",\n> +\t\t\t\t __func__, ERR_PTR(urb->status));\n> +\t\tgoto free_urb;\n> +\n> +\tdefault:\n> +\t\tdev_err_ratelimited(dev, \"%s: error %pe\\n\",\n> +\t\t\t\t __func__, ERR_PTR(urb->status));\n> +\t\tgoto resubmit_urb;\n> +\t}\n> +\n> +\tret = es58x_split_urb(es58x_dev, urb);\n> +\tif ((ret != -ENODATA) && ret < 0) {\n> +\t\tdev_err(es58x_dev->dev, \"es58x_split_urb() returned error %pe\",\n> +\t\t\tERR_PTR(ret));\n> +\t\tes58x_print_hex_dump_debug(urb->transfer_buffer,\n> +\t\t\t\t\t urb->actual_length);\n> +\n> +\t\t/* Because the urb command could not be parsed,\n> +\t\t * channel_id is not confirmed. Incrementing rx_errors\n> +\t\t * count of all channels.\n> +\t\t */\n> +\t\tes58x_increment_rx_errors(es58x_dev);\n> +\t}\n> +\n> + resubmit_urb:\n> +\tusb_fill_bulk_urb(urb, es58x_dev->udev, es58x_dev->rx_pipe,\n> +\t\t\t urb->transfer_buffer, urb->transfer_buffer_length,\n> +\t\t\t es58x_read_bulk_callback, es58x_dev);\n> +\n> +\tret = usb_submit_urb(urb, GFP_ATOMIC);\n> +\tif (ret == -ENODEV) {\n> +\t\tfor (i = 0; i < es58x_dev->num_can_ch; i++)\n> +\t\t\tif (es58x_dev->netdev[i])\n> +\t\t\t\tnetif_device_detach(es58x_dev->netdev[i]);\n> +\t} else if (ret)\n> +\t\tdev_err_ratelimited(dev,\n> +\t\t\t\t \"Failed resubmitting read bulk urb: %pe\\n\",\n> +\t\t\t\t ERR_PTR(ret));\n> +\treturn;\n> +\n> + free_urb:\n> +\tusb_free_coherent(urb->dev, urb->transfer_buffer_length,\n> +\t\t\t urb->transfer_buffer, urb->transfer_dma);\n> +}\n> +\n> +/**\n> + * es58x_write_bulk_callback() - Callback after writing data to the device.\n> + * @urb: urb buffer which was previously submitted.\n> + *\n> + * This function gets eventually called each time an URB was sent to\n> + * the ES58X device.\n> + *\n> + * Puts the @urb back to the urbs idle anchor and tries to restart the\n> + * network queue.\n> + */\n> +static void es58x_write_bulk_callback(struct urb *urb)\n> +{\n> +\tstruct net_device *netdev = urb->context;\n> +\tstruct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev;\n> +\n> +\tswitch (urb->status) {\n> +\tcase 0:\t\t/* success */\n> +\t\tbreak;\n> +\n> +\tcase -EOVERFLOW:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_err(netdev, \"%s: error %pe\\n\",\n> +\t\t\t\t __func__, ERR_PTR(urb->status));\n> +\t\tes58x_print_hex_dump(urb->transfer_buffer,\n> +\t\t\t\t urb->transfer_buffer_length);\n> +\t\tbreak;\n> +\n> +\tcase -ENOENT:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_dbg(netdev, \"%s: error %pe\\n\",\n> +\t\t\t\t __func__, ERR_PTR(urb->status));\n> +\t\tusb_free_coherent(urb->dev,\n> +\t\t\t\t es58x_dev->param->tx_urb_cmd_max_len,\n> +\t\t\t\t urb->transfer_buffer, urb->transfer_dma);\n> +\t\treturn;\n> +\n> +\tdefault:\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_info(netdev, \"%s: error %pe\\n\",\n> +\t\t\t\t __func__, ERR_PTR(urb->status));\n> +\t\tbreak;\n> +\t}\n> +\n> +\tusb_anchor_urb(urb, &es58x_dev->tx_urbs_idle);\n> +\t/* Wake the queue if it was stopped because of exhaustion of\n> +\t * urb resources.\n> +\t */\n> +\tif (atomic_inc_return(&es58x_dev->tx_urbs_idle_cnt) ==\n> +\t es58x_dev->num_can_ch)\n> +\t\tes58x_netif_wake_all_queues(es58x_dev);\n> +}\n> +\n> +/**\n> + * es58x_alloc_urb() - Allocate memory for an URB and its transfer\n> + *\tbuffer.\n> + * @es58x_dev: ES58X device.\n> + * @urb: URB to be allocated.\n> + * @buf: used to return DMA address of buffer.\n> + * @buf_len: requested buffer size.\n> + * @mem_flags: affect whether allocation may block.\n> + *\n> + * Allocates an URB and its @transfer_buffer and set its @transfer_dma\n> + * address.\n> + *\n> + * This function is used at start-up to allocate all of our TX and RX\n> + * URBs at once (in order to avoid numerous memory allocations during\n> + * run time) and might be used during run time under extremely rare\n> + * conditions by @es58x_get_tx_urb() (c.f. comments of this function).\n> + *\n> + * Return: zero on success, -ENOMEM if no memory is available.\n> + */\n> +static int es58x_alloc_urb(struct es58x_device *es58x_dev, struct urb **urb,\n> +\t\t\t u8 **buf, size_t buf_len, gfp_t mem_flags)\n> +{\n> +\t*urb = usb_alloc_urb(0, mem_flags);\n> +\tif (!*urb) {\n> +\t\tdev_err(es58x_dev->dev, \"No memory left for URBs\\n\");\n> +\t\treturn -ENOMEM;\n> +\t}\n> +\n> +\t*buf = usb_alloc_coherent(es58x_dev->udev, buf_len,\n> +\t\t\t\t mem_flags, &(*urb)->transfer_dma);\n> +\tif (!*buf) {\n> +\t\tdev_err(es58x_dev->dev, \"No memory left for USB buffer\\n\");\n> +\t\tusb_free_urb(*urb);\n> +\t\treturn -ENOMEM;\n> +\t}\n> +\n> +\t(*urb)->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_get_tx_urb() - Get an URB for transmission.\n> + * @netdev: CAN network device.\n> + *\n> + * Gets an URB from the idle urbs anchor and stop all network devices'\n> + * queue if the idle urbs anchor is nearly empty.\n> + *\n> + * If the URB anchor is empty, allocates an new URB.\n> + *\n> + * Under normal circumstances, the network device stop/wake\n> + * management should prevent any further request for memory\n> + * allocations to occur when trying to send a message.\n> + *\n> + * Yet, new URB memory allocation might occur after a restart from bus\n> + * off status when @es58x_set_mode() tries to disable and re-enable\n> + * the device. This would only occur if no idle URBs are available at\n> + * the moment (which is highly improbable because\n> + * @es58x_write_bulk_callback() should have returned the URBs to the\n> + * idle urbs anchor by that point).\n> + *\n> + * Return: a pointer to an URB on success, NULL if no memory is\n> + * available.\n> + */\n> +static struct urb *es58x_get_tx_urb(struct net_device *netdev)\n> +{\n> +\tstruct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev;\n> +\tstruct urb *urb;\n> +\tunsigned long flags;\n> +\tint ret;\n> +\n> +\turb = usb_get_from_anchor(&es58x_dev->tx_urbs_idle);\n> +\n> +\tif (!urb) {\n> +\t\tsize_t tx_buf_len;\n> +\t\tu8 *buf;\n> +\n> +\t\tnetdev_warn(netdev,\n> +\t\t\t \"%s: Idle TX URB anchor is empty. Allocating an extra URB\\n\",\n> +\t\t\t __func__);\n> +\t\ttx_buf_len = es58x_dev->param->tx_urb_cmd_max_len;\n> +\t\tret = es58x_alloc_urb(es58x_dev, &urb, &buf, tx_buf_len,\n> +\t\t\t\t GFP_ATOMIC);\n> +\t\tif (ret)\n> +\t\t\turb = NULL;\n> +\t\telse\n> +\t\t\tusb_fill_bulk_urb(urb, es58x_dev->udev,\n> +\t\t\t\t\t es58x_dev->tx_pipe, buf, tx_buf_len,\n> +\t\t\t\t\t NULL, NULL);\n> +\t} else {\n> +\t\tspin_lock_irqsave(&es58x_dev->tx_urbs_idle.lock, flags);\n> +\t\tif (atomic_dec_return(&es58x_dev->tx_urbs_idle_cnt) <\n> +\t\t es58x_dev->num_can_ch)\n> +\t\t\tes58x_netif_stop_all_queues(es58x_dev);\n> +\t\tspin_unlock_irqrestore(&es58x_dev->tx_urbs_idle.lock, flags);\n> +\t}\n> +\n> +\treturn urb;\n> +}\n> +\n> +/**\n> + * es58x_submit_urb() - Send data to the device.\n> + * @es58x_dev: ES58X device.\n> + * @urb: URB to be sent.\n> + * @netdev: CAN network device.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_submit_urb(struct es58x_device *es58x_dev, struct urb *urb,\n> +\t\t\t struct net_device *netdev)\n> +{\n> +\tint ret;\n> +\n> +\tes58x_set_crc(urb->transfer_buffer, urb->transfer_buffer_length);\n> +\tusb_fill_bulk_urb(urb, es58x_dev->udev, es58x_dev->tx_pipe,\n> +\t\t\t urb->transfer_buffer, urb->transfer_buffer_length,\n> +\t\t\t es58x_write_bulk_callback, netdev);\n> +\tusb_anchor_urb(urb, &es58x_dev->tx_urbs_busy);\n> +\tret = usb_submit_urb(urb, GFP_ATOMIC);\n> +\tif (ret) {\n> +\t\tnetdev_err(netdev, \"%s: USB send urb failure: %pe\\n\",\n> +\t\t\t __func__, ERR_PTR(ret));\n> +\t\tusb_unanchor_urb(urb);\n> +\t\tusb_free_coherent(urb->dev,\n> +\t\t\t\t es58x_dev->param->tx_urb_cmd_max_len,\n> +\t\t\t\t urb->transfer_buffer, urb->transfer_dma);\n> +\t}\n> +\tusb_free_urb(urb);\n> +\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_send_msg() - Prepare an URB and submit it.\n> + * @es58x_dev: ES58X device.\n> + * @cmd_type: Command type.\n> + * @cmd_id: Command ID.\n> + * @msg: ES58X message to be sent.\n> + * @msg_len: Length of @msg.\n> + * @channel_idx: Index of the network device.\n> + *\n> + * Creates an URB command from a given message, sets the header and the\n> + * CRC and then submits it.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +int es58x_send_msg(struct es58x_device *es58x_dev, u8 cmd_type, u8 cmd_id,\n> +\t\t const void *msg, u16 msg_len, int channel_idx)\n> +{\n> +\tstruct net_device *netdev;\n> +\tunion es58x_urb_cmd *urb_cmd;\n> +\tstruct urb *urb;\n> +\tint urb_cmd_len;\n> +\n> +\tif (channel_idx == ES58X_CHANNEL_IDX_NA)\n> +\t\tnetdev = es58x_dev->netdev[0];\t/* Default to first channel */\n> +\telse\n> +\t\tnetdev = es58x_dev->netdev[channel_idx];\n> +\n> +\turb_cmd_len = es58x_get_urb_cmd_len(es58x_dev, msg_len);\n> +\tif (urb_cmd_len > es58x_dev->param->tx_urb_cmd_max_len)\n> +\t\treturn -EOVERFLOW;\n> +\n> +\turb = es58x_get_tx_urb(netdev);\n> +\tif (!urb)\n> +\t\treturn -EBUSY;\n> +\n> +\turb_cmd = urb->transfer_buffer;\n> +\tes58x_dev->ops->fill_urb_header(urb_cmd, cmd_type, cmd_id,\n> +\t\t\t\t\tchannel_idx, msg_len);\n> +\tmemcpy(&urb_cmd->raw_cmd[es58x_dev->param->urb_cmd_header_len],\n> +\t msg, msg_len);\n> +\turb->transfer_buffer_length = urb_cmd_len;\n> +\n> +\treturn es58x_submit_urb(es58x_dev, urb, netdev);\n> +}\n> +\n> +/**\n> + * es58x_start() - Start USB device.\n> + * @es58x_dev: ES58X device.\n> + *\n> + * Allocate URBs for transmission and reception and put them in their\n> + * respective anchors.\n> + *\n> + * This function took a lot of inspiration from the other drivers in\n> + * drivers/net/can/usb.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_start(struct es58x_device *es58x_dev)\n> +{\n> +\tconst struct device *dev = es58x_dev->dev;\n> +\tconst struct es58x_parameters *param = es58x_dev->param;\n> +\tsize_t rx_buf_len, tx_buf_len;\n> +\tstruct urb *urb;\n> +\tu8 *buf;\n> +\tint i;\n> +\tint ret = -EINVAL;\n> +\n> +\trx_buf_len = es58x_dev->rx_max_packet_size;\n> +\tdev_dbg(dev, \"%s: Allocation %d rx URBs each of size %zu\\n\", __func__,\n> +\t\tparam->rx_urb_max, rx_buf_len);\n> +\n> +\tfor (i = 0; i < param->rx_urb_max; i++) {\n> +\t\tret = es58x_alloc_urb(es58x_dev, &urb, &buf, rx_buf_len,\n> +\t\t\t\t GFP_KERNEL);\n> +\t\tif (ret)\n> +\t\t\tbreak;\n> +\n> +\t\tusb_fill_bulk_urb(urb, es58x_dev->udev, es58x_dev->rx_pipe,\n> +\t\t\t\t buf, rx_buf_len, es58x_read_bulk_callback,\n> +\t\t\t\t es58x_dev);\n> +\t\tusb_anchor_urb(urb, &es58x_dev->rx_urbs);\n> +\n> +\t\tret = usb_submit_urb(urb, GFP_KERNEL);\n> +\t\tif (ret) {\n> +\t\t\tusb_unanchor_urb(urb);\n> +\t\t\tusb_free_coherent(es58x_dev->udev, rx_buf_len,\n> +\t\t\t\t\t buf, urb->transfer_dma);\n> +\t\t\tusb_free_urb(urb);\n> +\t\t\tbreak;\n> +\t\t}\n> +\t\tusb_free_urb(urb);\n> +\t}\n> +\n> +\tif (i == 0) {\n> +\t\tdev_err(dev, \"%s: Could not setup any rx URBs\\n\", __func__);\n> +\t\treturn ret;\n> +\t} else if (i < param->rx_urb_max) {\n> +\t\tdev_warn(dev,\n> +\t\t\t \"%s: Could only allocate %d on %d URBs. Rx performance may be slow\\n\",\n> +\t\t\t __func__, i, param->rx_urb_max);\n> +\t}\n> +\n> +\ttx_buf_len = es58x_dev->param->tx_urb_cmd_max_len;\n> +\tdev_dbg(dev, \"%s: Allocation %d tx URBs each of size %zu\\n\", __func__,\n> +\t\tparam->tx_urb_max, tx_buf_len);\n> +\n> +\tfor (i = 0; i < param->tx_urb_max; i++) {\n> +\t\tret = es58x_alloc_urb(es58x_dev, &urb, &buf, tx_buf_len,\n> +\t\t\t\t GFP_KERNEL);\n> +\t\tif (ret)\n> +\t\t\tbreak;\n> +\n> +\t\tusb_fill_bulk_urb(urb, es58x_dev->udev, es58x_dev->tx_pipe,\n> +\t\t\t\t buf, tx_buf_len, NULL, NULL);\n> +\t\tusb_anchor_urb(urb, &es58x_dev->tx_urbs_idle);\n> +\t\tusb_free_urb(urb);\n> +\t}\n> +\n> +\tif (i == 0) {\n> +\t\tdev_err(dev, \"%s: Could not setup any tx URBs\\n\", __func__);\n> +\t\treturn ret;\n> +\t} else if (i < param->tx_urb_max) {\n> +\t\tdev_warn(dev,\n> +\t\t\t \"%s: Could only allocate %d on %d URBs. Tx performance may be slow\\n\",\n> +\t\t\t __func__, i, param->tx_urb_max);\n> +\t}\n> +\tatomic_set(&es58x_dev->tx_urbs_idle_cnt, i);\n> +\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_enable_channel() - Enable the network device.\n> + * @netdev: CAN network device.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_enable_channel(struct net_device *netdev)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tstruct es58x_device *es58x_dev = priv->es58x_dev;\n> +\tint ret;\n> +\n> +\tret = es58x_dev->ops->enable_channel(es58x_dev, priv->channel_idx);\n> +\tif (ret)\n> +\t\tnetdev_err(netdev, \"%s: Could not enable the channel: %pe\\n\",\n> +\t\t\t __func__, ERR_PTR(ret));\n> +\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_open() - Open and start network device.\n> + * @netdev: CAN network device.\n> + *\n> + * Called when the network transitions to the up state.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_open(struct net_device *netdev)\n> +{\n> +\tint ret;\n> +\n> +\tret = open_candev(netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\tret = es58x_enable_channel(netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\tnetif_start_queue(netdev);\n> +\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_stop() - Disable the network device.\n> + * @netdev: CAN network device.\n> + *\n> + * Called when the network transitions to the down state.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_stop(struct net_device *netdev)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tunsigned long flags;\n> +\n> +\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\tnetif_stop_queue(netdev);\n> +\tpriv->can.state = CAN_STATE_STOPPED;\n> +\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\tes58x_can_flush_echo_skb(netdev);\n> +\tclose_candev(netdev);\n> +\n> +\tes58x_flush_pending_tx_msg(netdev);\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_xmit_commit() - Send the bulk urb.\n> + * @netdev: CAN network device.\n> + *\n> + * Update the loopback FIFO and do a bulk send.\n> + *\n> + * Each loopback skb should be put individually with\n> + * can_put_echo_skb(). This function should be called only once by\n> + * bulk transmission.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_xmit_commit(struct net_device *netdev)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tunsigned long flags;\n> +\tunsigned int pkts = priv->tx_can_msg_cnt;\n> +\tint ret;\n> +\n> +\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\tif (!es58x_is_can_state_active(netdev)) {\n> +\t\tnetdev_warn(netdev,\n> +\t\t\t \"%s: Device turned to CAN state: %d while preparing to send. Aborting transmission\\n\",\n> +\t\t\t __func__, priv->can.state);\n> +\t\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\t\treturn -ENETDOWN;\n> +\t}\n> +\tpriv->num_echo_skb += pkts;\n> +\tpriv->current_packet_idx += pkts;\n> +\tes58x_add_skb_idx(priv, &priv->echo_skb_head_idx, pkts);\n> +\tif (priv->num_echo_skb >= es58x_echo_skb_stop_threshold(priv))\n> +\t\tnetif_stop_queue(netdev);\n> +\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\n> +\tret = es58x_submit_urb(priv->es58x_dev, priv->tx_urb, netdev);\n> +\tif (ret) {\n> +\t\tnetdev_warn(netdev,\n> +\t\t\t \"%s: es58x_submit_urb returned failed: %pe priv->num_echo_skb = %u\\n\",\n> +\t\t\t __func__, ERR_PTR(ret), priv->num_echo_skb);\n> +\t\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\t\tpriv->num_echo_skb -= pkts;\n> +\t\tpriv->current_packet_idx -= pkts;\n> +\t\tes58x_add_skb_idx(priv, &priv->echo_skb_head_idx,\n> +\t\t\t\t priv->can.echo_skb_max - pkts);\n> +\t\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\t}\n> +\tpriv->tx_urb = NULL;\n> +\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_start_xmit() - Transmit an skb.\n> + * @skb: socket buffer of a CAN message.\n> + * @netdev: CAN network device.\n> + *\n> + * Called when a packet needs to be transmitted.\n> + *\n> + * This function relies on Byte Queue Limits (BQL). The main benefit\n> + * it to increase the throughput by allowing bulk transfers\n> + * (c.f. xmit_more flag).\n> + *\n> + * Queues up to tx_bulk_max messages in &tx_urb buffer and does\n> + * a bulk send of all messages in one single URB.\n> + *\n> + * Return:\n> + * NETDEV_TX_OK if we could manage the @skb (either transmit it or\n> + * drop it)\n> + *\n> + * NETDEV_TX_BUSY if the device is busy (this is a bug, the network\n> + * device stop/wake management should prevent this return code to\n> + * occur).\n> + */\n> +static netdev_tx_t es58x_start_xmit(struct sk_buff *skb,\n> +\t\t\t\t struct net_device *netdev)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tstruct es58x_device *es58x_dev = priv->es58x_dev;\n> +\tunsigned int packet_idx, tx_msg_threshold;\n> +\tu16 skb_idx;\n> +\tu8 channel_idx = priv->channel_idx;\n> +\tbool send_doorbell;\n> +\tint ret;\n> +\n> +\tif (((struct can_frame *)skb->data)->can_id & CAN_ERR_FLAG) {\n> +\t\tnetdev_info(netdev,\n> +\t\t\t \"%s: CAN_ERR_FLAG is set but device does not support sending error frames. Dropping message\\n\",\n> +\t\t\t __func__);\n> +\t\tif (priv->tx_urb && !netdev_xmit_more()) {\n> +\t\t\t__netdev_sent_queue(netdev, 0, false);\n> +\t\t\tret = es58x_xmit_commit(netdev);\n> +\t\t\tif (ret)\n> +\t\t\t\tgoto xmit_failure;\n> +\t\t}\n> +\t\treturn NETDEV_TX_OK;\n> +\t}\n> +\n> +\tif (!priv->tx_urb) {\n> +\t\tpriv->tx_urb = es58x_get_tx_urb(netdev);\n> +\t\tif (!priv->tx_urb)\n> +\t\t\treturn NETDEV_TX_BUSY;\n> +\t\tmemset(priv->tx_urb->transfer_buffer, 0,\n> +\t\t es58x_dev->param->tx_urb_cmd_max_len);\n> +\t\tpriv->tx_urb->transfer_buffer_length =\n> +\t\t es58x_dev->param->urb_cmd_header_len;\n> +\t\tpriv->tx_can_msg_cnt = 0;\n> +\t\tpriv->tx_can_msg_is_fd = can_is_canfd_skb(skb);\n> +\t} else if (priv->tx_can_msg_is_fd != can_is_canfd_skb(skb)) {\n> +\t\t/* Can not send bulk message with mixed CAN and CAN-FD\n> +\t\t * frames.\n> +\t\t */\n> +\t\t__netdev_sent_queue(netdev, 0, false);\n> +\t\tret = es58x_xmit_commit(netdev);\n> +\t\tif (ret)\n> +\t\t\tgoto xmit_failure;\n> +\t\treturn es58x_start_xmit(skb, netdev);\n> +\t}\n> +\n> +\tpacket_idx = priv->current_packet_idx + priv->tx_can_msg_cnt;\n> +\tret = es58x_dev->ops->tx_can_msg(priv, channel_idx,\n> +\t\t\t\t\t packet_idx, skb,\n> +\t\t\t\t\t priv->tx_urb->transfer_buffer,\n> +\t\t\t\t\t &priv->tx_urb->transfer_buffer_length);\n> +\tif (ret)\n> +\t\tgoto xmit_failure;\n> +\n> +\tskb_idx = priv->echo_skb_head_idx;\n> +\tes58x_add_skb_idx(priv, &skb_idx, priv->tx_can_msg_cnt);\n> +\tskb_tx_timestamp(skb);\n> +\tret = can_put_echo_skb(skb, netdev, skb_idx);\n> +\tif (ret)\n> +\t\tgoto xmit_failure;\n> +\tpriv->tx_can_msg_cnt++;\n> +\n> +\tsend_doorbell = __netdev_sent_queue(netdev, es58x_can_frame_bytes(skb),\n> +\t\t\t\t\t netdev_xmit_more());\n> +\ttx_msg_threshold = min_t(unsigned int,\n> +\t\t\t\t es58x_dev->param->tx_bulk_max,\n> +\t\t\t\t priv->can.echo_skb_max - priv->num_echo_skb);\n> +\tif (send_doorbell || priv->tx_can_msg_cnt >= tx_msg_threshold) {\n> +\t\tret = es58x_xmit_commit(netdev);\n> +\t\tif (ret)\n> +\t\t\tgoto xmit_failure;\n> +\t}\n> +\n> +\treturn NETDEV_TX_OK;\n> +\n> + xmit_failure:\n> +\tnetdev->stats.tx_errors++;\n> +\tes58x_flush_pending_tx_msg(netdev);\n> +\tnetdev_err(netdev, \"%s: send message failure: %pe\\n\",\n> +\t\t __func__, ERR_PTR(ret));\n> +\treturn NETDEV_TX_OK;\n> +}\n> +\n> +static const struct net_device_ops es58x_netdev_ops = {\n> +\t.ndo_open = es58x_open,\n> +\t.ndo_stop = es58x_stop,\n> +\t.ndo_start_xmit = es58x_start_xmit\n> +};\n> +\n> +/**\n> + * es58x_set_bittiming() - Configure all the nominal bit timing\n> + *\tparameters.\n> + * @netdev: CAN network device.\n> + *\n> + * Only relevant for ES581.4 (the ES58X FD family sets the bittiming\n> + * parameters at the same time as the channel gets enabled).\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_set_bittiming(struct net_device *netdev)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tstruct es58x_device *es58x_dev = priv->es58x_dev;\n> +\tint ret;\n> +\n> +\t/* Make sure that channel is closed before sending configuration. */\n> +\tret = es58x_dev->ops->disable_channel(es58x_dev, priv->channel_idx);\n> +\tif (ret)\n> +\t\tnetdev_err(netdev, \"%s: Could not disable the channel: %pe\\n\",\n> +\t\t\t __func__, ERR_PTR(ret));\n> +\tret = es58x_dev->ops->set_bittiming(es58x_dev, priv->channel_idx);\n> +\tif (ret)\n> +\t\tnetdev_err(netdev, \"%s: Could not set bittiming: %pe\\n\",\n> +\t\t\t __func__, ERR_PTR(ret));\n> +\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_set_data_bittiming() - Configure all the data bit timing parameters.\n> + * @netdev: CAN network device.\n> + *\n> + * Dummy function: ES58X FD family sets the bittiming\n> + * parameters at the same time as the channel gets enabled.\n> + *\n> + * Return: zero.\n> + */\n> +static int es58x_set_data_bittiming(struct net_device *netdev)\n> +{\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_reset() - Reset one channel of the device.\n> + * @netdev: CAN network device.\n> + *\n> + * Race conditions might appear when trying to use the reset_rx()\n> + * and reset_tx() methods (e.g. loopback packets might remain in the\n> + * queue causing some use after free issues in\n> + * es58x_can_get_echo_skb()). Disabling and reenabling the channel is\n> + * safer.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_reset(struct net_device *netdev)\n> +{\n> +\tint ret = 0;\n> +\n> +\tif (es58x_is_can_state_active(netdev))\n> +\t\tes58x_priv(netdev)->can.do_set_mode(netdev, CAN_MODE_STOP);\n> +\tWARN_ON(!netif_queue_stopped(netdev));\n> +\n> +\tret = es58x_set_bittiming(netdev);\n> +\tif (ret)\n> +\t\tgoto failure;\n> +\tret = es58x_enable_channel(netdev);\n> +\tif (ret)\n> +\t\tgoto failure;\n> +\n> +\treturn ret;\n> +\n> + failure:\n> +\tnetdev_err(netdev, \"%s: reset failure: %pe\\n\", __func__, ERR_PTR(ret));\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_set_mode() - Change network device mode.\n> + * @netdev: CAN network device.\n> + * @mode: either %CAN_MODE_START, %CAN_MODE_STOP or %CAN_MODE_SLEEP\n> + *\n> + * This function is used by drivers/net/can/dev.c:can_restart() to\n> + * recover from a bus off state. Thus only the only value expected for\n> + * @mode is %CAN_MODE_START. None the less, other modes were\n> + * implemented as well.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_set_mode(struct net_device *netdev, enum can_mode mode)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tstruct can_priv *can = netdev_priv(netdev);\n> +\tunsigned long flags;\n> +\n> +\tnetdev_dbg(netdev, \"%s: Switching to can_mode %d\\n\", __func__, mode);\n> +\n> +\tswitch (mode) {\n> +\tcase CAN_MODE_START:\n> +\t\tswitch (can->state) {\n> +\t\tcase CAN_STATE_BUS_OFF:\n> +\t\t\treturn es58x_reset(netdev);\n> +\n> +\t\tcase CAN_STATE_STOPPED:\n> +\t\tcase CAN_STATE_SLEEPING:\n> +\t\t\tes58x_netif_wake_queue(netdev);\n> +\t\t\tcan->state = CAN_STATE_ERROR_ACTIVE;\n> +\t\t\treturn 0;\n> +\n> +\t\tcase CAN_STATE_ERROR_ACTIVE:\n> +\t\tcase CAN_STATE_ERROR_WARNING:\n> +\t\tcase CAN_STATE_ERROR_PASSIVE:\n> +\t\tdefault:\n> +\t\t\treturn 0;\n> +\t\t}\n> +\n> +\tcase CAN_MODE_STOP:\n> +\tcase CAN_MODE_SLEEP:\n> +\t\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\t\tnetif_stop_queue(netdev);\n> +\t\tcan->state = (mode == CAN_MODE_STOP) ?\n> +\t\t CAN_STATE_STOPPED : CAN_STATE_SLEEPING;\n> +\t\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\t\treturn 0;\n> +\n> +\tdefault:\n> +\t\tnetdev_err(netdev, \"%s: Invalid can_mode value: %d\\n\",\n> +\t\t\t __func__, mode);\n> +\t\treturn -EOPNOTSUPP;\n> +\t}\n> +}\n> +\n> +/**\n> + * es58x_init_priv() - Initialize private parameters.\n> + * @es58x_dev: ES58X device.\n> + * @priv: ES58X private parameters related to the network device.\n> + * @channel_idx: Index of the network device.\n> + */\n> +static void es58x_init_priv(struct es58x_device *es58x_dev,\n> +\t\t\t struct es58x_priv *priv, int channel_idx)\n> +{\n> +\tconst struct es58x_parameters *param = es58x_dev->param;\n> +\tstruct can_priv *can = &priv->can;\n> +\n> +\tpriv->es58x_dev = es58x_dev;\n> +\tpriv->channel_idx = channel_idx;\n> +\tpriv->tx_urb = NULL;\n> +\tpriv->tx_can_msg_cnt = 0;\n> +\tspin_lock_init(&priv->echo_skb_spinlock);\n> +\n> +\tcan->bittiming_const = param->bittiming_const;\n> +\tcan->do_set_bittiming = es58x_set_bittiming;\n> +\tif (param->ctrlmode_supported & CAN_CTRLMODE_FD) {\n> +\t\tcan->data_bittiming_const = param->data_bittiming_const;\n> +\t\tcan->do_set_data_bittiming = es58x_set_data_bittiming;\n> +\t}\n> +\tcan->bitrate_max = param->bitrate_max;\n> +\tcan->clock = param->clock;\n> +\n> +\tcan->state = CAN_STATE_STOPPED;\n> +\n> +\t/* Hardware loopback is always enabled, regardless of the\n> +\t * value of can.ctrlmode & CAN_CTRLMODE_LOOPBACK.\n> +\t */\n> +\tcan->ctrlmode_supported = param->ctrlmode_supported;\n> +\tcan->do_get_berr_counter = NULL;\t/* Not supported */\n> +\n> +\tcan->do_set_mode = es58x_set_mode;\n> +}\n> +\n> +/**\n> + * es58x_init_netdev() - Initialize the network device.\n> + * @es58x_dev: ES58X device.\n> + * @channel_idx: Index of the network device.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_init_netdev(struct es58x_device *es58x_dev, int channel_idx)\n> +{\n> +\tstruct net_device *netdev;\n> +\tstruct device *dev = es58x_dev->dev;\n> +\tint ret;\n> +\n> +\tnetdev = alloc_candev(sizeof(struct es58x_priv),\n> +\t\t\t es58x_dev->param->echo_skb_max);\n> +\tif (!netdev) {\n> +\t\tdev_err(dev, \"Could not allocate candev\\n\");\n> +\t\treturn -ENOMEM;\n> +\t}\n> +\tSET_NETDEV_DEV(netdev, dev);\n> +\tes58x_dev->netdev[channel_idx] = netdev;\n> +\tes58x_init_priv(es58x_dev, es58x_priv(netdev), channel_idx);\n> +\n> +\tnetdev->netdev_ops = &es58x_netdev_ops;\n> +\tnetdev->flags |= IFF_ECHO;\t/* we support local echo */\n> +\n> +\tret = register_candev(netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\tnetdev_dbg(netdev, \"%s: Registered channel %s\\n\",\n> +\t\t es58x_dev->udev->product, netdev->name);\n> +\n> +\tnetdev_get_tx_queue(netdev, 0)->dql.min_limit =\n> +\t es58x_dev->param->dql_limit_min;\n> +\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_get_product_info() - Get the product information and print them.\n> + * @es58x_dev: ES58X device.\n> + *\n> + * Do a synchronous call to get the product information.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_get_product_info(struct es58x_device *es58x_dev)\n> +{\n> +\tstruct usb_device *udev = es58x_dev->udev;\n> +\tconst int es58x_prod_info_idx = 6;\n> +\t/* Empirical tests show a prod_info length of maximum 83,\n> +\t * below should be more than enough.\n> +\t */\n> +\tconst size_t prod_info_len = 127;\n> +\tchar *prod_info;\n> +\tint ret;\n> +\n> +\tprod_info = kmalloc(prod_info_len, GFP_KERNEL);\n> +\tif (!prod_info)\n> +\t\treturn -ENOMEM;\n> +\n> +\tret = usb_string(udev, es58x_prod_info_idx, prod_info, prod_info_len);\n> +\tif (ret < 0) {\n> +\t\tdev_err(es58x_dev->dev,\n> +\t\t\t\"%s: Could not read the product info: %pe\\n\",\n> +\t\t\t__func__, ERR_PTR(ret));\n> +\t\treturn ret;\n> +\t} else if (ret >= prod_info_len - 1) {\n> +\t\tdev_warn(es58x_dev->dev,\n> +\t\t\t \"%s: Buffer is too small, result might be truncated\\n\",\n> +\t\t\t __func__);\n> +\t}\n> +\tdev_info(es58x_dev->dev, \"Product info: %s\\n\", prod_info);\n> +\tkfree(prod_info);\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_init_es58x_dev() - Initialize the ES58X device.\n> + * @intf: USB interface\n> + * @p_es58x_dev: pointer to the address of the ES58X device.\n> + *\n> + * Return: zero on success, errno when any error occurs.\n> + */\n> +static int es58x_init_es58x_dev(struct usb_interface *intf,\n> +\t\t\t\tstruct es58x_device **p_es58x_dev)\n> +{\n> +\tstruct device *dev = &intf->dev;\n> +\tstruct es58x_device *es58x_dev;\n> +\tconst struct es58x_parameters *param;\n> +\tconst struct es58x_operators *ops;\n> +\tstruct usb_device *udev = interface_to_usbdev(intf);\n> +\tstruct usb_endpoint_descriptor *ep_in, *ep_out;\n> +\tconst u16 usb_id_product = le16_to_cpu(udev->descriptor.idProduct);\n> +\tu8 num_can_ch;\n> +\tint ret;\n> +\n> +\tdev_info(dev,\n> +\t\t \"Starting %s %s (Serial Number %s) driver version %s\\n\",\n> +\t\t udev->manufacturer, udev->product, udev->serial, DRV_VERSION);\n> +\n> +\tret = usb_find_common_endpoints(intf->cur_altsetting, &ep_in, &ep_out,\n> +\t\t\t\t\tNULL, NULL);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\tswitch (usb_id_product) {\n> +\tcase ES581_4_PRODUCT_ID:\t/* 2 Classical CAN channels */\n> +\t\tparam = &es581_4_param;\n> +\t\tops = &es581_4_ops;\n> +\t\tnum_can_ch = ES581_4_NUM_CAN_CH;\n> +\t\tbreak;\n> +\n> +\tcase ES582_1_PRODUCT_ID:\t/* 2 CAN(-FD) channels */\n> +\t\tparam = &es58x_fd_param;\n> +\t\tops = &es58x_fd_ops;\n> +\t\tnum_can_ch = ES582_1_NUM_CAN_CH;\n> +\t\tbreak;\n> +\n> +\tcase ES584_1_PRODUCT_ID:\t/* 1 CAN(-FD) and 1 LIN channel */\n> +\t\tparam = &es58x_fd_param;\n> +\t\tops = &es58x_fd_ops;\n> +\t\tnum_can_ch = ES584_1_NUM_CAN_CH;\n> +\t\tbreak;\n> +\n> +\tdefault:\n> +\t\treturn -ENODEV;\n> +\t}\n> +\tif (num_can_ch > ARRAY_SIZE(es58x_dev->netdev) ||\n> +\t num_can_ch >= param->echo_skb_max)\n> +\t\treturn -ECHRNG;\n> +\n> +\tes58x_dev = kzalloc(es58x_sizeof_es58x_device(param), GFP_KERNEL);\n> +\tif (!es58x_dev)\n> +\t\treturn -ENOMEM;\n> +\n> +\tes58x_dev->param = param;\n> +\tes58x_dev->ops = ops;\n> +\tes58x_dev->num_can_ch = num_can_ch;\n> +\tes58x_dev->dev = dev;\n> +\tes58x_dev->udev = udev;\n> +\n> +\tinit_usb_anchor(&es58x_dev->rx_urbs);\n> +\tinit_usb_anchor(&es58x_dev->tx_urbs_idle);\n> +\tinit_usb_anchor(&es58x_dev->tx_urbs_busy);\n> +\tusb_set_intfdata(intf, es58x_dev);\n> +\n> +\tes58x_dev->rx_pipe = usb_rcvbulkpipe(es58x_dev->udev,\n> +\t\t\t\t\t ep_in->bEndpointAddress);\n> +\tes58x_dev->tx_pipe = usb_sndbulkpipe(es58x_dev->udev,\n> +\t\t\t\t\t ep_out->bEndpointAddress);\n> +\tes58x_dev->rx_max_packet_size = le16_to_cpu(ep_in->wMaxPacketSize);\n> +\n> +\t*p_es58x_dev = es58x_dev;\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_probe() - Initialize the USB device.\n> + * @intf: USB interface\n> + * @id: USB device ID\n> + *\n> + * Return: zero on success, -ENODEV if the interface is not supported\n> + * or errno when any other error occurs.\n> + */\n> +static int es58x_probe(struct usb_interface *intf,\n> +\t\t const struct usb_device_id *id)\n> +{\n> +\tstruct es58x_device *es58x_dev;\n> +\tint ch_idx, ret;\n> +\n> +\t/* ES58X FD has some interface protocols unsupported by this driver. */\n> +\tif (intf->cur_altsetting->desc.bInterfaceProtocol != 0) {\n> +\t\tdev_dbg(&intf->dev, \"Interface protocol %d is not supported\\n\",\n> +\t\t\tintf->cur_altsetting->desc.bInterfaceProtocol);\n> +\t\treturn -ENODEV;\n> +\t}\n> +\n> +\tret = es58x_init_es58x_dev(intf, &es58x_dev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\tret = es58x_get_product_info(es58x_dev);\n> +\tif (ret)\n> +\t\tgoto cleanup_es58x_dev;\n> +\n> +\tfor (ch_idx = 0; ch_idx < es58x_dev->num_can_ch; ch_idx++) {\n> +\t\tret = es58x_init_netdev(es58x_dev, ch_idx);\n> +\t\tif (ret)\n> +\t\t\tgoto cleanup_candev;\n> +\t}\n> +\n> +\tret = es58x_start(es58x_dev);\n> +\tif (ret)\n> +\t\tgoto cleanup_candev;\n> +\n> +\tes58x_set_realtime_diff_ns(es58x_dev);\n> +\n> +\treturn ret;\n> +\n> + cleanup_candev:\n> +\tfor (ch_idx = 0; ch_idx < es58x_dev->num_can_ch; ch_idx++)\n> +\t\tif (es58x_dev->netdev[ch_idx]) {\n> +\t\t\tunregister_candev(es58x_dev->netdev[ch_idx]);\n> +\t\t\tfree_candev(es58x_dev->netdev[ch_idx]);\n> +\t\t}\n> + cleanup_es58x_dev:\n> +\tkfree(es58x_dev);\n> +\n> +\treturn ret;\n> +}\n> +\n> +/**\n> + * es58x_disconnect() - Disconnect the USB device.\n> + * @intf: USB interface\n> + *\n> + * Called by the usb core when driver is unloaded or device is\n> + * removed.\n> + */\n> +static void es58x_disconnect(struct usb_interface *intf)\n> +{\n> +\tstruct es58x_device *es58x_dev = usb_get_intfdata(intf);\n> +\tstruct net_device *netdev;\n> +\tstruct urb *urb;\n> +\tint i;\n> +\n> +\tdev_info(&intf->dev, \"Disconnecting %s %s\\n\",\n> +\t\t es58x_dev->udev->manufacturer, es58x_dev->udev->product);\n> +\n> +\tfor (i = 0; i < es58x_dev->num_can_ch; i++) {\n> +\t\tnetdev = es58x_dev->netdev[i];\n> +\t\tif (!netdev)\n> +\t\t\tcontinue;\n> +\t\tnetdev_dbg(netdev, \"Unregistering %s\\n\", netdev->name);\n> +\t\tunregister_candev(netdev);\n> +\t\tnetdev_dbg(netdev, \"Freeing %s\\n\", netdev->name);\n> +\t\tes58x_dev->netdev[i] = NULL;\n> +\t\tfree_candev(netdev);\n> +\t}\n> +\n> +\tdev_dbg(&intf->dev, \"Killing TX busy anchored urbs\\n\");\n> +\tif (!usb_wait_anchor_empty_timeout(&es58x_dev->tx_urbs_busy, 1000)) {\n> +\t\tdev_err(&intf->dev, \"%s: Timeout, some TX urbs still remain\\n\",\n> +\t\t\t__func__);\n> +\t\tusb_kill_anchored_urbs(&es58x_dev->tx_urbs_busy);\n> +\t}\n> +\n> +\tdev_dbg(&intf->dev, \"Freeing TX idle anchored urbs\\n\");\n> +\twhile ((urb = usb_get_from_anchor(&es58x_dev->tx_urbs_idle)) != NULL) {\n> +\t\tusb_free_coherent(urb->dev,\n> +\t\t\t\t es58x_dev->param->tx_urb_cmd_max_len,\n> +\t\t\t\t urb->transfer_buffer, urb->transfer_dma);\n> +\t\tusb_free_urb(urb);\n> +\t\tatomic_dec(&es58x_dev->tx_urbs_idle_cnt);\n> +\t}\n> +\tif (atomic_read(&es58x_dev->tx_urbs_idle_cnt) > 0)\n> +\t\tdev_err(&intf->dev,\n> +\t\t\t\"All idle urbs were freed but tx_urb_idle_cnt is %u\\n\",\n> +\t\t\tatomic_read(&es58x_dev->tx_urbs_idle_cnt));\n> +\n> +\tdev_dbg(&intf->dev, \"Unlinking RX anchored urbs\\n\");\n> +\tusb_kill_anchored_urbs(&es58x_dev->rx_urbs);\n> +\n> +\tdev_dbg(&intf->dev, \"Freeing %s\\n\", es58x_dev->udev->product);\n> +\tkfree(es58x_dev);\n> +\tdev_dbg(&intf->dev, \"Setting USB interface to NULL\\n\");\n> +\tusb_set_intfdata(intf, NULL);\n> +}\n> +\n> +static struct usb_driver es58x_driver = {\n> +\t.name = ES58X_MODULE_NAME,\n> +\t.probe = es58x_probe,\n> +\t.disconnect = es58x_disconnect,\n> +\t.id_table = es58x_id_table,\n> +};\n> +\n> +module_usb_driver(es58x_driver);\n> diff --git a/drivers/net/can/usb/etas_es58x/es58x_core.h b/drivers/net/can/usb/etas_es58x/es58x_core.h\n> new file mode 100644\n> index 000000000000..e74fb8bc9dde\n> --- /dev/null\n> +++ b/drivers/net/can/usb/etas_es58x/es58x_core.h\n> @@ -0,0 +1,712 @@\n> +/* SPDX-License-Identifier: GPL-2.0 */\n> +\n> +/* Driver for ETAS GmbH ES58X USB CAN(-FD) Bus Interfaces.\n> + *\n> + * File es58x_core.h: All common definitions and declarations.\n> + *\n> + * Copyright (C) 2019 Robert Bosch Engineering and Business\n> + * Solutions. All rights reserved.\n> + * Copyright (C) 2020 ETAS K.K.. All rights reserved.\n> + */\n> +\n> +#ifndef __ES58X_COMMON_H__\n> +#define __ES58X_COMMON_H__\n> +\n> +#include \n> +#include \n> +#include \n> +#include \n> +#include \n> +\n> +#include \"es581_4.h\"\n> +#include \"es58x_fd.h\"\n> +\n> +/* Size of a Classical CAN Standard Frame (rounded up and ignoring\n> + * bitsuffing).\n> + */\n> +#define ES58X_SFF_BYTES(data_len) (DIV_ROUND_UP(47, 8) + (data_len))\n> +\n> +/* Size of a Classical CAN Extended Frame (rounded up and ignoring\n> + * bitsuffing).\n> + */\n> +#define ES58X_EFF_BYTES(data_len) (DIV_ROUND_UP(67, 8) + (data_len))\n> +\n> +/* Maximum size of a Classical CAN frame (rounded up and ignoring\n> + * bitsuffing).\n> + */\n> +#define ES58X_CAN_FRAME_BYTES_MAX ES58X_EFF_BYTES(CAN_MAX_DLEN)\n> +\n> +/* Maximum size of a CAN-FD frame (rough estimation because\n> + * ES58X_SFF_BYTES() and ES58X_EFF_BYTES() macros are using the\n> + * constant values for Classical CAN, not CAN-FD).\n> + */\n> +#define ES58X_CANFD_FRAME_BYTES_MAX ES58X_EFF_BYTES(CANFD_MAX_DLEN)\n> +\n> +/* Driver constants */\n> +#define ES58X_RX_URBS_MAX 5\t/* Empirical value */\n> +#define ES58X_TX_URBS_MAX 8\t/* Empirical value */\n> +\n> +#define ES58X_MAX(param)\t\t\t\t\\\n> +\t(ES581_4_##param > ES58X_FD_##param ?\t\t\\\n> +\t\tES581_4_##param : ES58X_FD_##param)\n> +#define ES58X_TX_BULK_MAX ES58X_MAX(TX_BULK_MAX)\n> +#define ES58X_RX_BULK_MAX ES58X_MAX(RX_BULK_MAX)\n> +#define ES58X_RX_LOOPBACK_BULK_MAX ES58X_MAX(RX_LOOPBACK_BULK_MAX)\n> +#define ES58X_NUM_CAN_CH_MAX ES58X_MAX(NUM_CAN_CH)\n> +\n> +/* Use this when channel index is irrelevant (e.g. device\n> + * timestamp).\n> + */\n> +#define ES58X_CHANNEL_IDX_NA 0xFF\n> +#define ES58X_EMPTY_MSG NULL\n> +\n> +/* Threshold on consecutive CAN_STATE_ERROR_PASSIVE. If we receive\n> + * ES58X_CONSECUTIVE_ERR_PASSIVE_MAX times the event\n> + * ES58X_ERR_CRTL_PASSIVE in a row without any successful Rx or Tx,\n> + * we force the device to switch to CAN_STATE_BUS_OFF state.\n> + */\n> +#define ES58X_CONSECUTIVE_ERR_PASSIVE_MAX 254\n> +\n> +enum es58x_self_reception {\n> +\tES58X_SELF_RECEPTION_OFF = 0,\n> +\tES58X_SELF_RECEPTION_ON = 1\n> +};\n> +\n> +enum es58x_physical_media {\n> +\tES58X_PHYSICAL_MEDIA_HIGH_SPEED = 1\n> +};\n> +\n> +enum es58x_samples_per_bit {\n> +\tES58X_SAMPLES_PER_BIT_ONE = 1,\n> +\tES58X_SAMPLES_PER_BIT_THREE = 2\n> +};\n> +\n> +/**\n> + * enum es58x_sync_edge - Synchronization method.\n> + * @ES58X_SYNC_EDGE_SINGLE: ISO CAN specification defines the use of a\n> + *\tsingle edge synchronization. The synchronization should be\n> + *\tdone on recessive to dominant level change.\n> + *\n> + * Some product of the ETAS portfolio also support a double\n> + * synchronization, requiring both recessive to dominant then dominant\n> + * to recessive level change. However, the devices of this driver do\n> + * not support the option, thus, the enum has only one member.\n> + */\n> +enum es58x_sync_edge {\n> +\tES58X_SYNC_EDGE_SINGLE = 1\n> +};\n> +\n> +/**\n> + * enum es58x_flag - CAN flags for RX/TX messages.\n> + * @ES58X_FLAG_EFF: Extended Frame Format (EFF).\n> + * @ES58X_FLAG_RTR: Remote Transmission Request (RTR).\n> + * @ES58X_FLAG_FD_BRS: Bit rate switch (BRS): second bitrate for\n> + *\tpayload data.\n> + * @ES58X_FLAG_FD_ESI: Error State Indicator (ESI): tell if the\n> + *\ttransmitting node is in error passive mode.\n> + * @ES58X_FLAG_FD_DATA: CAN FD frame.\n> + */\n> +enum es58x_flag {\n> +\tES58X_FLAG_EFF = BIT(0),\n> +\tES58X_FLAG_RTR = BIT(1),\n> +\tES58X_FLAG_FD_BRS = BIT(3),\n> +\tES58X_FLAG_FD_ESI = BIT(5),\n> +\tES58X_FLAG_FD_DATA = BIT(6)\n> +};\n> +\n> +/**\n> + * enum es58x_err - CAN error detection.\n> + * @ES58X_ERR_OK: No errors.\n> + * @ES58X_ERR_PROT_STUFF: Bit stuffing error: more than 5 consecutive\n> + *\tequal bits.\n> + * @ES58X_ERR_PROT_FORM: Frame format error.\n> + * @ES58X_ERR_ACK: Received no ACK on transmission.\n> + * @ES58X_ERR_PROT_BIT: Single bit error.\n> + * @ES58X_ERR_PROT_CRC: Incorrect 15, 17 or 21 bits CRC.\n> + * @ES58X_ERR_PROT_BIT1: Unable to send recessive bit: tried to send\n> + *\trecessive bit 1 but monitored dominant bit 0.\n> + * @ES58X_ERR_PROT_BIT0: Unable to send dominant bit: tried to send\n> + *\tdominant bit 0 but monitored recessive bit 1.\n> + * @ES58X_ERR_PROT_OVERLOAD: Bus overload.\n> + * @ES58X_ERR_PROT_UNSPEC: Unspecified.\n> + *\n> + * Please refer to ISO 11898-1:2015, section 10.11 \"Error detection\"\n> + * and section 10.13 \"Overload signaling\" for additional details.\n> + */\n> +enum es58x_err {\n> +\tES58X_ERR_OK = 0,\n> +\tES58X_ERR_PROT_STUFF = BIT(0),\n> +\tES58X_ERR_PROT_FORM = BIT(1),\n> +\tES58X_ERR_ACK = BIT(2),\n> +\tES58X_ERR_PROT_BIT = BIT(3),\n> +\tES58X_ERR_PROT_CRC = BIT(4),\n> +\tES58X_ERR_PROT_BIT1 = BIT(5),\n> +\tES58X_ERR_PROT_BIT0 = BIT(6),\n> +\tES58X_ERR_PROT_OVERLOAD = BIT(7),\n> +\tES58X_ERR_PROT_UNSPEC = BIT(31)\n> +};\n> +\n> +/**\n> + * enum es58x_event - CAN error codes returned by the device.\n> + * @ES58X_EVENT_OK: No errors.\n> + * @ES58X_EVENT_CRTL_ACTIVE: Active state: both TR and RX error count\n> + *\tis less than 128.\n> + * @ES58X_EVENT_CRTL_PASSIVE: Passive state: either TX or RX error\n> + *\tcount is greater than 127.\n> + * @ES58X_EVENT_CRTL_WARNING: Warning state: either TX or RX error\n> + *\tcount is greater than 96.\n> + * @ES58X_EVENT_BUSOFF: Bus off.\n> + * @ES58X_EVENT_SINGLE_WIRE: Lost connection on either CAN high or CAN\n> + *\tlow.\n> + *\n> + * Please refer to ISO 11898-1:2015, section 12.1.4 \"Rules of fault\n> + * confinement\" for additional details.\n> + */\n> +enum es58x_event {\n> +\tES58X_EVENT_OK = 0,\n> +\tES58X_EVENT_CRTL_ACTIVE = BIT(0),\n> +\tES58X_EVENT_CRTL_PASSIVE = BIT(1),\n> +\tES58X_EVENT_CRTL_WARNING = BIT(2),\n> +\tES58X_EVENT_BUSOFF = BIT(3),\n> +\tES58X_EVENT_SINGLE_WIRE = BIT(4)\n> +};\n> +\n> +/**\n> + * enum es58x_ret_u8 - Device return error codes, 8 bit format.\n> + *\n> + * Specific to ES581.4.\n> + */\n> +enum es58x_ret_u8 {\n> +\tES58X_RET_U8_OK = 0x00,\n> +\tES58X_RET_U8_ERR_UNSPECIFIED_FAILURE = 0x80,\n> +\tES58X_RET_U8_ERR_NO_MEM = 0x81,\n> +\tES58X_RET_U8_ERR_BAD_CRC = 0x99\n> +};\n> +\n> +/**\n> + * enum es58x_ret_u32 - Device return error codes, 32 bit format.\n> + */\n> +enum es58x_ret_u32 {\n> +\tES58X_RET_U32_OK = 0x00000000UL,\n> +\tES58X_RET_U32_ERR_UNSPECIFIED_FAILURE = 0x80000000UL,\n> +\tES58X_RET_U32_ERR_NO_MEM = 0x80004001UL,\n> +\tES58X_RET_U32_WARN_PARAM_ADJUSTED = 0x40004000UL,\n> +\tES58X_RET_U32_WARN_TX_MAYBE_REORDER = 0x40004001UL,\n> +\tES58X_RET_U32_ERR_TIMEOUT = 0x80000008UL,\n> +\tES58X_RET_U32_ERR_FIFO_FULL = 0x80003002UL,\n> +\tES58X_RET_U32_ERR_BAD_CONFIG = 0x80004000UL,\n> +\tES58X_RET_U32_ERR_NO_RESOURCE = 0x80004002UL\n> +};\n> +\n> +/**\n> + * enum es58x_ret_type - Type of the command returned by the ES58X\n> + *\tdevice.\n> + */\n> +enum es58x_ret_type {\n> +\tES58X_RET_TYPE_SET_BITTIMING,\n> +\tES58X_RET_TYPE_ENABLE_CHANNEL,\n> +\tES58X_RET_TYPE_DISABLE_CHANNEL,\n> +\tES58X_RET_TYPE_TX_MSG,\n> +\tES58X_RET_TYPE_RESET_RX,\n> +\tES58X_RET_TYPE_RESET_TX,\n> +\tES58X_RET_TYPE_DEVICE_ERR,\n> +\tES58X_RET_TYPE_NUM_ENTRIES\n> +};\n> +\n> +union es58x_urb_cmd {\n> +\tstruct es581_4_urb_cmd es581_4_urb_cmd;\n> +\tstruct es58x_fd_urb_cmd es58x_fd_urb_cmd;\n> +\tstruct {\t\t/* Common header parts of all variants */\n> +\t\t__le16 sof;\n> +\t\tu8 cmd_type;\n> +\t\tu8 cmd_id;\n> +\t} __packed;\n> +\tu8 raw_cmd[0];\n> +};\n> +\n> +/**\n> + * struct es58x_priv - All information specific to a can channel.\n> + * @can: struct can_priv must be the first member (Socket CAN relies\n> + *\ton the fact that function netdev_priv() returns a pointer to\n> + *\ta struct can_priv).\n> + * @es58x_dev: pointer to the corresponding ES58X device.\n> + * @tx_urb: Used as a buffer to concatenate the TX messages and to do\n> + *\ta bulk send. Please refer to es58x_start_xmit() for more\n> + *\tdetails.\n> + * @echo_skb_spinlock: Spinlock to protect the access to the echo skb\n> + *\tFIFO.\n> + * @current_packet_idx: Keeps track of the packet indexes.\n> + * @echo_skb_tail_idx: beginning of the echo skb FIFO, i.e. index of\n> + *\tthe first element.\n> + * @echo_skb_head_idx: end of the echo skb FIFO plus one, i.e. first\n> + *\tfree index.\n> + * @num_echo_skb: actual number of elements in the FIFO. Thus, the end\n> + *\tof the FIFO is echo_skb_head = (echo_skb_tail_idx +\n> + *\tnum_echo_skb) % can.echo_skb_max.\n> + * @tx_can_msg_is_fd: false: all messages in @tx_urb are Classical\n> + *\tCAN, true: all messages in @tx_urb are CAN-FD. Rationale:\n> + *\tES58X FD devices do not allow to mix standard and FD CAN in\n> + *\tone single bulk transmission.\n> + * @tx_can_msg_cnt: Number of messages in @tx_urb.\n> + * @err_passive_before_rtx_success: The ES58X device might enter in a\n> + *\tstate in which it keeps alternating between error passive\n> + *\tand active state. This counter keeps track of the number of\n> + *\terror passive and if it gets bigger than\n> + *\tES58X_CONSECUTIVE_ERR_PASSIVE_MAX, es58x_rx_err_msg() will\n> + *\tforce the status to bus-off.\n> + * @channel_idx: Channel index, starts at zero.\n> + */\n> +struct es58x_priv {\n> +\tstruct can_priv can;\n> +\tstruct es58x_device *es58x_dev;\n> +\tstruct urb *tx_urb;\n> +\n> +\tspinlock_t echo_skb_spinlock;\t/* Comments: c.f. supra */\n> +\tu32 current_packet_idx;\n> +\tu16 echo_skb_tail_idx;\n> +\tu16 echo_skb_head_idx;\n> +\tu16 num_echo_skb;\n> +\n> +\tbool tx_can_msg_is_fd;\n> +\tu8 tx_can_msg_cnt;\n> +\n> +\tu8 err_passive_before_rtx_success;\n> +\n> +\tu8 channel_idx;\n> +};\n> +\n> +/**\n> + * struct es58x_parameters - Constant parameters of a given hardware\n> + *\tvariant.\n> + * @can_bittiming_const: Nominal bittimming parameters.\n> + * @data_bittiming_const: Data bittiming parameters.\n> + * @bitrate_max: Maximum bitrate supported by the device.\n> + * @clock: CAN clock parameters.\n> + * @ctrlmode_supported: List of supported modes. Please refer to\n> + *\tcan/netlink.h file for additional details.\n> + * @tx_start_of_frame: Magic number at the beginning of each TX URB\n> + *\tcommand.\n> + * @rx_start_of_frame: Magic number at the beginning of each RX URB\n> + *\tcommand.\n> + * @tx_urb_cmd_max_len: Maximum length of a TX URB command.\n> + * @rx_urb_cmd_max_len: Maximum length of a RX URB command.\n> + * @echo_skb_max: Maximum number of echo SKB. This value must not\n> + *\texceed the maximum size of the device internal TX FIFO\n> + *\tlength. This parameter is used to control the network queue\n> + *\twake/stop logic.\n> + * @dql_limit_min: Dynamic Queue Limits (DQL) absolute minimum limit\n> + *\tof bytes allowed to be queued on this network device transmit\n> + *\tqueue. Used by the Byte Queue Limits (BQL) to determine how\n> + *\tfrequently the xmit_more flag will be set to true in\n> + *\tes58x_start_xmit(). Set this value higher to optimize for\n> + *\tthroughput but be aware that it might have a negative impact\n> + *\ton the latency! This value can also be set dynamically. Please\n> + *\trefer to Documentation/ABI/testing/sysfs-class-net-queues for\n> + *\tmore details.\n> + * @tx_bulk_max: Maximum number of Tx messages that can be sent in one\n> + *\tsingle URB packet.\n> + * @urb_cmd_header_len: Length of the URB command header.\n> + * @rx_urb_max: Number of RX URB to be allocated during device probe.\n> + * @tx_urb_max: Number of TX URB to be allocated during device probe.\n> + * @channel_idx_offset: Some of the ES58x starts channel numbering\n> + *\tfrom 0 (ES58X FD), others from 1 (ES581.4).\n> + */\n> +struct es58x_parameters {\n> +\tconst struct can_bittiming_const *bittiming_const;\n> +\tconst struct can_bittiming_const *data_bittiming_const;\n> +\tu32 bitrate_max;\n> +\tstruct can_clock clock;\n> +\tu32 ctrlmode_supported;\n> +\tu16 tx_start_of_frame;\n> +\tu16 rx_start_of_frame;\n> +\tu16 tx_urb_cmd_max_len;\n> +\tu16 rx_urb_cmd_max_len;\n> +\tu16 echo_skb_max;\n> +\tu16 dql_limit_min;\n> +\tu8 tx_bulk_max;\n> +\tu8 urb_cmd_header_len;\n> +\tu8 rx_urb_max;\n> +\tu8 tx_urb_max;\n> +\tu8 channel_idx_offset;\n> +};\n> +\n> +/**\n> + * struct es58x_operators - Function pointers used to encode/decode\n> + *\tthe TX/RX messages.\n> + * @get_msg_len: Get field msg_len of the urb_cmd. The offset of\n> + *\tmsg_len inside urb_cmd depends of the device model.\n> + * @handle_urb_cmd: Handle URB command received from the device and\n> + *\tmanage the return code from device.\n> + * @fill_urb_header: Fill the header of urb_cmd.\n> + * @tx_can_msg: Encode a TX CAN message and add it to the bulk buffer\n> + *\tcmd_buf of es58x_dev.\n> + * @set_bittiming: Encode the bittiming information and send it.\n> + * @enable_channel: Start the CAN channel with index channel_idx.\n> + * @disable_channel: Stop the CAN channel with index channel_idx.\n> + * @reset_rx: Reset the RX queue of the ES58X device.\n> + * @reset_tx: Reset the TX queue of the ES58X device.\n> + * @get_timestamp: Request a timestamp from the ES58X device.\n> + */\n> +struct es58x_operators {\n> +\tu16 (*get_msg_len)(const union es58x_urb_cmd *urb_cmd);\n> +\tint (*handle_urb_cmd)(struct es58x_device *es58x_dev,\n> +\t\t\t const union es58x_urb_cmd *urb_cmd);\n> +\tvoid (*fill_urb_header)(union es58x_urb_cmd *urb_cmd, u8 cmd_type,\n> +\t\t\t\tu8 cmd_id, u8 channel_idx, u16 cmd_len);\n> +\tint (*tx_can_msg)(struct es58x_priv *priv, int channel_idx,\n> +\t\t\t u32 packet_idx, const struct sk_buff *skb,\n> +\t\t\t union es58x_urb_cmd *urb_cmd, u32 *urb_cmd_len);\n> +\tint (*set_bittiming)(struct es58x_device *es58x_dev, int channel_idx);\n> +\tint (*enable_channel)(struct es58x_device *es58x_dev,\n> +\t\t\t int channel_idx);\n> +\tint (*disable_channel)(struct es58x_device *es58x_dev,\n> +\t\t\t int channel_idx);\n> +\tint (*reset_rx)(struct es58x_device *es58x_dev, int channel_idx);\n> +\tint (*reset_tx)(struct es58x_device *es58x_dev, int channel_idx);\n> +\tint (*get_timestamp)(struct es58x_device *es58x_dev);\n> +};\n> +\n> +/**\n> + * struct es58x_device - All information specific to an ES58X device.\n> + * @dev: Device information.\n> + * @udev: USB device information.\n> + * @netdev: Array of our CAN channels.\n> + * @param: The constant parameters.\n> + * @ops: Operators.\n> + * @rx_pipe: USB reception pipe.\n> + * @tx_pipe: USB transmission pipe.\n> + * @rx_urbs: Anchor for received URBs.\n> + * @tx_urbs_busy: Anchor for TX URBs which were send to the device.\n> + * @tx_urbs_idle: Anchor for TX USB which are idle. This driver\n> + *\tallocates the memory for the URBs during the probe. When a TX\n> + *\tURB is needed, it can be taken from this anchor. The network\n> + *\tqueue wake/stop logic should prevent this URB from getting\n> + *\tempty. Please refer to es58x_get_tx_urb() for more details.\n> + * @tx_urbs_idle_cnt: number of urbs in @tx_urbs_idle.\n> + * @ktime_req_ns: kernel timestamp when es58x_set_realtime_diff_ns()\n> + *\twas called.\n> + * @realtime_diff_ns: difference in nanoseconds between the clocks of\n> + *\tthe ES58X device and the kernel.\n> + * @timestamps: a temporary buffer to store the time stamps before\n> + *\tfeeding them to es58x_can_get_echo_skb(). Can only be used\n> + *\tin rx branches.\n> + * @rx_max_packet_size: Maximum length of bulk-in URB.\n> + * @num_can_ch: Number of CAN channel (i.e. number of elements of @netdev).\n> + * @rx_cmd_buf_len: Length of @rx_cmd_buf.\n> + * @rx_cmd_buf: The device might split the URB commands in an\n> + *\tarbitrary amount of pieces. This buffer is used to concatenate\n> + *\tall those pieces. Can only be used in rx branches. This field\n> + *\thas to be the last one of the structure because it is has a\n> + *\tflexible size (c.f. es58x_sizeof_es58x_device() function).\n> + */\n> +struct es58x_device {\n> +\tstruct device *dev;\n> +\tstruct usb_device *udev;\n> +\tstruct net_device *netdev[ES58X_NUM_CAN_CH_MAX];\n> +\n> +\tconst struct es58x_parameters *param;\n> +\tconst struct es58x_operators *ops;\n> +\n> +\tint rx_pipe;\n> +\tint tx_pipe;\n> +\n> +\tstruct usb_anchor rx_urbs;\n> +\tstruct usb_anchor tx_urbs_busy;\n> +\tstruct usb_anchor tx_urbs_idle;\n> +\tatomic_t tx_urbs_idle_cnt;\n> +\n> +\tu64 ktime_req_ns;\n> +\ts64 realtime_diff_ns;\n> +\n> +\tu64 timestamps[ES58X_RX_LOOPBACK_BULK_MAX];\n> +\n> +\tu16 rx_max_packet_size;\n> +\tu8 num_can_ch;\n> +\n> +\tu16 rx_cmd_buf_len;\n> +\tunion es58x_urb_cmd rx_cmd_buf;\n> +};\n> +\n> +/**\n> + * es58x_sizeof_es58x_device() - Calculate the maximum length of\n> + *\tstruct es58x_device.\n> + * @es58x_dev_param: The constant parameters of the device.\n> + *\n> + * The length of struct es58x_device depends on the length of its last\n> + * field: rx_cmd_buf. This macro allows to optimize size for memory\n> + * allocation.\n> + *\n> + * Return: length of struct es58x_device.\n> + */\n> +static inline size_t es58x_sizeof_es58x_device(const struct es58x_parameters\n> +\t\t\t\t\t *es58x_dev_param)\n> +{\n> +\treturn offsetof(struct es58x_device, rx_cmd_buf) +\n> +\t\tes58x_dev_param->rx_urb_cmd_max_len;\n> +}\n> +\n> +/* Megabit per second (multiply x per one million) */\n> +#define ES58X_MBPS(x) (1000000UL * (x))\n> +\n> +/* Megahertz (multiply x per one million) */\n> +#define ES58X_MHZ(x) (1000000UL * (x))\n> +\n> +static inline int __es58x_check_msg_len(const struct device *dev,\n> +\t\t\t\t\tconst char *stringified_msg,\n> +\t\t\t\t\tsize_t actual_len, size_t expected_len)\n> +{\n> +\tif (expected_len != actual_len) {\n> +\t\tdev_err(dev,\n> +\t\t\t\"Length of %s is %zu but received command is %zu.\\n\",\n> +\t\t\tstringified_msg, expected_len, actual_len);\n> +\t\treturn -EMSGSIZE;\n> +\t}\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_check_msg_len() - Check the size of a received message.\n> + * @dev: Device, used to print error messages.\n> + * @msg: Received message, must not be a pointer.\n> + * @actual_len: Length of the message as advertised in the command header.\n> + *\n> + * Must be a macro in order to retrieve the actual size using\n> + * sizeof(). Can be use with any of the messages which have a fixed\n> + * length. Check for an exact match of the size.\n> + *\n> + * Return: zero on success, -EMSGSIZE if @actual_len differs from the\n> + * expected length.\n> + */\n> +#define es58x_check_msg_len(dev, msg, actual_len)\t\t\t\\\n> +\t__es58x_check_msg_len(dev, __stringify(msg),\t\t\t\\\n> +\t\t\t actual_len, sizeof(msg))\n> +\n> +static inline int __es58x_check_msg_max_len(const struct device *dev,\n> +\t\t\t\t\t const char *stringified_msg,\n> +\t\t\t\t\t size_t actual_len,\n> +\t\t\t\t\t size_t expected_len)\n> +{\n> +\tif (actual_len > expected_len) {\n> +\t\tdev_err(dev,\n> +\t\t\t\"Maximum length for %s is %zu but received command is %zu.\\n\",\n> +\t\t\tstringified_msg, expected_len, actual_len);\n> +\t\treturn -EOVERFLOW;\n> +\t}\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_check_msg_max_len() - Check the maximum size of a received message.\n> + * @dev: Device, used to print error messages.\n> + * @msg: Received message, must not be a pointer.\n> + * @actual_len: Length of the message as advertised in the command header.\n> + *\n> + * Must be a macro in order to retrieve the actual size using\n> + * sizeof(). To be used with the messages of variable sizes. Only\n> + * check that the message is not bigger than the maximum expected\n> + * size.\n> + *\n> + * Return: zero on success, -EOVERFLOW if @actual_len is greater than\n> + * the expected length.\n> + */\n> +#define es58x_check_msg_max_len(dev, msg, actual_len)\t\t\t\\\n> +\t__es58x_check_msg_max_len(dev, __stringify(msg),\t\t\\\n> +\t\t\t\t actual_len, sizeof(msg))\n> +\n> +static inline int __es58x_msg_num_element(const struct device *dev,\n> +\t\t\t\t\t const char *stringified_msg,\n> +\t\t\t\t\t size_t actual_len, size_t msg_len,\n> +\t\t\t\t\t size_t elem_len)\n> +{\n> +\tsize_t actual_num_elem = actual_len / elem_len;\n> +\tsize_t expected_num_elem = msg_len / elem_len;\n> +\n> +\tif (actual_num_elem == 0) {\n> +\t\tdev_err(dev,\n> +\t\t\t\"Minimum length for %s is %zu but received command is %zu.\\n\",\n> +\t\t\tstringified_msg, elem_len, actual_len);\n> +\t\treturn -EMSGSIZE;\n> +\t} else if ((actual_len % elem_len) != 0) {\n> +\t\tdev_err(dev,\n> +\t\t\t\"Received command length: %zu is not a multiple of %s[0]: %zu\\n\",\n> +\t\t\tactual_len, stringified_msg, elem_len);\n> +\t\treturn -EMSGSIZE;\n> +\t} else if (actual_num_elem > expected_num_elem) {\n> +\t\tdev_err(dev,\n> +\t\t\t\"Array %s is supposed to have %zu elements each of size %zu...\\n\",\n> +\t\t\tstringified_msg, expected_num_elem, elem_len);\n> +\t\tdev_err(dev,\n> +\t\t\t\"... But received command has %zu elements (total length %zu).\\n\",\n> +\t\t\tactual_num_elem, actual_len);\n> +\t\treturn -EOVERFLOW;\n> +\t}\n> +\treturn actual_num_elem;\n> +}\n> +\n> +/**\n> + * es58x_msg_num_element() - Check size and give the number of\n> + *\telements in a message of array type.\n> + * @dev: Device, used to print error messages.\n> + * @msg: Received message, must be an array.\n> + * @actual_len: Length of the message as advertised in the command\n> + *\theader.\n> + *\n> + * Must be a macro in order to retrieve the actual size using\n> + * sizeof(). To be used on message of array type. Array's element has\n> + * to be of fixed size (else use es58x_check_msg_max_len()). Check\n> + * that the total length is an exact multiple of the length of a\n> + * single element.\n> + *\n> + * Return: number of elements in the array on success, -EOVERFLOW if\n> + * @actual_len is greater than the expected length, -EMSGSIZE if\n> + * @actual_len is not a multiple of a single element.\n> + */\n> +#define es58x_msg_num_element(dev, msg, actual_len)\t\t\t\\\n> +({\t\t\t\t\t\t\t\t\t\\\n> +\tsize_t __elem_len = sizeof((msg)[0]) + __must_be_array(msg);\t\\\n> +\t__es58x_msg_num_element(dev, __stringify(msg), actual_len,\t\\\n> +\t\t\t\tsizeof(msg), __elem_len);\t\t\\\n> +})\n> +\n> +/**\n> + * es58x_priv() - Get the priv member and cast it to struct es58x_priv.\n> + * @netdev: CAN network device.\n> + *\n> + * Return: ES58X device.\n> + */\n> +static inline struct es58x_priv *es58x_priv(struct net_device *netdev)\n> +{\n> +\treturn (struct es58x_priv *)netdev_priv(netdev);\n> +}\n> +\n> +/**\n> + * ES58X_SIZEOF_URB_CMD() - Calculate the maximum length of an urb\n> + *\tcommand for a given message field name.\n> + * @es58x_urb_cmd_type: type (either \"struct es581_4_urb_cmd\" or\n> + *\t\"struct es58x_fd_urb_cmd\").\n> + * @msg_field: name of the message field.\n> + *\n> + * Must be a macro in order to retrieve the actual size using\n> + * offsetof() and sizeof_field().\n> + *\n> + * Return: length of the urb command.\n> + */\n> +#define ES58X_SIZEOF_URB_CMD(es58x_urb_cmd_type, msg_field)\t\t\\\n> +\t(offsetof(es58x_urb_cmd_type, raw_msg)\t\t\t\t\\\n> +\t\t+ sizeof_field(es58x_urb_cmd_type, msg_field)\t\t\\\n> +\t\t+ sizeof_field(es58x_urb_cmd_type,\t\t\t\\\n> +\t\t\t reserved_for_crc16_do_not_use))\n> +\n> +/**\n> + * es58x_get_urb_cmd_len() - Calculate the actual length of an urb\n> + *\tcommand for a given message length.\n> + * @es58x_dev: ES58X device.\n> + * @msg_len: Length of the message.\n> + *\n> + * Add the header and CRC lengths to the message length.\n> + *\n> + * Return: length of the urb command.\n> + */\n> +static inline size_t es58x_get_urb_cmd_len(struct es58x_device *es58x_dev,\n> +\t\t\t\t\t u16 msg_len)\n> +{\n> +\t/* URB Length = URB header len + Message len + sizeof crc16 */\n> +\treturn es58x_dev->param->urb_cmd_header_len + msg_len + sizeof(u16);\n> +}\n> +\n> +/**\n> + * es58x_get_netdev() - Get the network device.\n> + * @es58x_dev: ES58X device.\n> + * @channel_no: The channel number as advertised in the urb command.\n> + * @netdev: CAN network device.\n> + *\n> + * ES581.4 starts the numbering on channels from 1, ES58X FD family\n> + * starts it from 0. This method does the sanity check.\n> + *\n> + * Return: zero on success, -ECHRNG if the received channel number is\n> + * out of range and -ENODEV if the network device is not yet\n> + * configured.\n> + */\n> +static inline int es58x_get_netdev(struct es58x_device *es58x_dev,\n> +\t\t\t\t int channel_no, struct net_device **netdev)\n> +{\n> +\tint channel_idx = channel_no - es58x_dev->param->channel_idx_offset;\n> +\n> +\t*netdev = NULL;\n> +\tif (channel_idx < 0 || channel_idx >= es58x_dev->num_can_ch)\n> +\t\treturn -ECHRNG;\n> +\n> +\t*netdev = es58x_dev->netdev[channel_idx];\n> +\tif (!netdev || !netif_device_present(*netdev))\n> +\t\treturn -ENODEV;\n> +\n> +\treturn 0;\n> +}\n> +\n> +/**\n> + * es58x_get_raw_can_id() - Get the CAN ID.\n> + * @cf: CAN frame.\n> + *\n> + * Mask the CAN ID in order to only keep the significant bits.\n> + *\n> + * Return: the raw value of the CAN ID.\n> + */\n> +static inline int es58x_get_raw_can_id(const struct can_frame *cf)\n> +{\n> +\tif (cf->can_id & CAN_EFF_FLAG)\n> +\t\treturn cf->can_id & CAN_EFF_MASK;\n> +\telse\n> +\t\treturn cf->can_id & CAN_SFF_MASK;\n> +}\n> +\n> +/**\n> + * es58x_get_flags() - Get the CAN flags.\n> + * @skb: socket buffer of a CAN message.\n> + *\n> + * Return: the CAN flag as an enum es58x_flag.\n> + */\n> +static inline enum es58x_flag es58x_get_flags(const struct sk_buff *skb)\n> +{\n> +\tstruct canfd_frame *cf = (struct canfd_frame *)skb->data;\n> +\tenum es58x_flag es58x_flags = 0;\n> +\n> +\tif (cf->can_id & CAN_EFF_FLAG)\n> +\t\tes58x_flags |= ES58X_FLAG_EFF;\n> +\n> +\tif (can_is_canfd_skb(skb)) {\n> +\t\tes58x_flags |= ES58X_FLAG_FD_DATA;\n> +\t\tif (cf->flags & CANFD_BRS)\n> +\t\t\tes58x_flags |= ES58X_FLAG_FD_BRS;\n> +\t\tif (cf->flags & CANFD_ESI)\n> +\t\t\tes58x_flags |= ES58X_FLAG_FD_ESI;\n> +\t} else if (cf->can_id & CAN_RTR_FLAG)\n> +\t\t/* Remote frames are only defined in Classical CAN frames */\n> +\t\tes58x_flags |= ES58X_FLAG_RTR;\n> +\n> +\treturn es58x_flags;\n> +}\n> +\n> +int es58x_can_get_echo_skb(struct net_device *netdev, u32 packet_idx,\n> +\t\t\t u64 *tstamps, unsigned int pkts);\n> +int es58x_tx_ack_msg(struct net_device *netdev, u16 tx_free_entries,\n> +\t\t enum es58x_ret_u32 rx_cmd_ret_u32);\n> +int es58x_rx_can_msg(struct net_device *netdev, u64 timestamp, const u8 *data,\n> +\t\t canid_t can_id, enum es58x_flag es58x_flags, u8 dlc);\n> +int es58x_rx_err_msg(struct net_device *netdev, enum es58x_err error,\n> +\t\t enum es58x_event event, u64 timestamp);\n> +int es58x_rx_timestamp(struct es58x_device *es58x_dev, u64 timestamp);\n> +int es58x_rx_dev_ret_u8(struct device *dev, enum es58x_ret_type cmd_ret_type,\n> +\t\t\tenum es58x_ret_u8 rx_dev_ret_u8);\n> +int es58x_rx_cmd_ret_u32(struct net_device *netdev,\n> +\t\t\t enum es58x_ret_type cmd_ret_type,\n> +\t\t\t enum es58x_ret_u32 rx_cmd_ret_u32);\n> +int es58x_send_msg(struct es58x_device *es58x_dev, u8 cmd_type, u8 cmd_id,\n> +\t\t const void *msg, u16 cmd_len, int channel_idx);\n> +\n> +extern const struct es58x_parameters es581_4_param;\n> +extern const struct es58x_operators es581_4_ops;\n> +\n> +extern const struct es58x_parameters es58x_fd_param;\n> +extern const struct es58x_operators es58x_fd_ops;\n> +\n> +#endif /* __ES58X_COMMON_H__ */\n> diff --git a/drivers/net/can/usb/etas_es58x/es58x_fd.c b/drivers/net/can/usb/etas_es58x/es58x_fd.c\n> new file mode 100644\n> index 000000000000..0c8e850e330b\n> --- /dev/null\n> +++ b/drivers/net/can/usb/etas_es58x/es58x_fd.c\n> @@ -0,0 +1,657 @@\n> +// SPDX-License-Identifier: GPL-2.0\n> +\n> +/* Driver for ETAS GmbH ES58X USB CAN(-FD) Bus Interfaces.\n> + *\n> + * File es58x_fd.c: Adds support to ETAS ES582.1 and ES584.1 (naming\n> + * convention: we use the term \"ES58X FD\" when referring to those two\n> + * variants together).\n> + *\n> + * Copyright (C) 2019 Robert Bosch Engineering and Business\n> + * Solutions. All rights reserved.\n> + * Copyright (C) 2020 ETAS K.K.. All rights reserved.\n> + */\n> +\n> +#include \n> +#include \n> +\n> +#include \"es58x_core.h\"\n> +#include \"es58x_fd.h\"\n> +\n> +/**\n> + * es58x_sizeof_rx_tx_msg() - Calculate the actual length of the\n> + *\tstructure of a rx or tx message.\n> + * @msg: message of variable length, must have a dlc and a len fields.\n> + *\n> + * Even if RTR frames have actually no payload, the ES58X devices\n> + * still expect it. Must be a macro in order to retrieve the actual\n> + * size using offsetof() and typeof().\n> + *\n> + * Return: length of the message.\n> + */\n> +#define es58x_fd_sizeof_rx_tx_msg(msg)\t\t\t\t\t\\\n> +({\t\t\t\t\t\t\t\t\t\\\n> +\ttypeof(msg) __msg = (msg);\t\t\t\t\t\\\n> +\tsize_t __msg_len = __msg.flags & ES58X_FLAG_FD_DATA ?\t\t\\\n> +\t\tmin_t(u8, __msg.len, CANFD_MAX_DLEN) :\t\t\t\\\n> +\t\tcan_get_cc_len(__msg.dlc);\t\t\t\t\\\n> +\t(offsetof(typeof(__msg), data[__msg_len]));\t\t\t\\\n> +})\n> +\n> +static enum es58x_fd_cmd_type es58x_fd_cmd_type(struct net_device *netdev)\n> +{\n> +\tu32 ctrlmode = es58x_priv(netdev)->can.ctrlmode;\n> +\n> +\treturn ctrlmode & (CAN_CTRLMODE_FD | CAN_CTRLMODE_FD_NON_ISO) ?\n> +\t ES58X_FD_CMD_TYPE_CANFD : ES58X_FD_CMD_TYPE_CAN;\n> +}\n> +\n> +static u16 es58x_fd_get_msg_len(const union es58x_urb_cmd *urb_cmd)\n> +{\n> +\treturn get_unaligned_le16(&urb_cmd->es58x_fd_urb_cmd.msg_len);\n> +}\n> +\n> +static int es58x_fd_rx_loopback_msg(struct net_device *netdev,\n> +\t\t\t\t const struct es58x_fd_urb_cmd\n> +\t\t\t\t *es58x_fd_urb_cmd)\n> +{\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tconst struct es58x_fd_rx_loopback_msg *rx_loopback_msg;\n> +\tstruct es58x_device *es58x_dev = priv->es58x_dev;\n> +\tu64 *tstamps = es58x_dev->timestamps;\n> +\tu16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);\n> +\tint i, num_element;\n> +\tu32 first_packet_idx, packet_idx;\n> +\tunsigned long flags;\n> +\n> +\tconst u32 mask = ~(u32)((typeof(rx_loopback_msg->packet_idx))(~0U));\n> +\n> +\tnum_element = es58x_msg_num_element(es58x_dev->dev,\n> +\t\t\t\t\t es58x_fd_urb_cmd->rx_loopback_msg,\n> +\t\t\t\t\t msg_len);\n> +\tif (num_element < 0)\n> +\t\treturn num_element;\n> +\trx_loopback_msg = es58x_fd_urb_cmd->rx_loopback_msg;\n> +\n> +\tspin_lock_irqsave(&priv->echo_skb_spinlock, flags);\n> +\tfirst_packet_idx = priv->current_packet_idx - priv->num_echo_skb;\n> +\tspin_unlock_irqrestore(&priv->echo_skb_spinlock, flags);\n> +\n> +\tpacket_idx = (first_packet_idx & mask) | rx_loopback_msg[0].packet_idx;\n> +\tfor (i = 0; i < num_element; i++) {\n> +\t\tif ((u8)packet_idx != rx_loopback_msg[i].packet_idx) {\n> +\t\t\tnetdev_err(netdev, \"Packet idx jumped from %u to %u\\n\",\n> +\t\t\t\t (u8)packet_idx - 1,\n> +\t\t\t\t rx_loopback_msg[i].packet_idx);\n> +\t\t\treturn -EBADMSG;\n> +\t\t}\n> +\n> +\t\ttstamps[i] = get_unaligned_le64(&rx_loopback_msg[i].timestamp);\n> +\t\tpacket_idx++;\n> +\t}\n> +\n> +\treturn es58x_can_get_echo_skb(netdev, first_packet_idx,\n> +\t\t\t\t tstamps, num_element);\n> +}\n> +\n> +static int es58x_fd_rx_can_msg(struct net_device *netdev,\n> +\t\t\t const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd)\n> +{\n> +\tstruct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev;\n> +\tconst u8 *rx_can_msg_buf = es58x_fd_urb_cmd->rx_can_msg_buf;\n> +\tu16 rx_can_msg_buf_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);\n> +\tint pkts, ret;\n> +\n> +\tret = es58x_check_msg_max_len(es58x_dev->dev,\n> +\t\t\t\t es58x_fd_urb_cmd->rx_can_msg_buf,\n> +\t\t\t\t rx_can_msg_buf_len);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\tfor (pkts = 0; rx_can_msg_buf_len > 0; pkts++) {\n> +\t\tconst struct es58x_fd_rx_can_msg *rx_can_msg =\n> +\t\t (const struct es58x_fd_rx_can_msg *)rx_can_msg_buf;\n> +\t\tbool is_can_fd = !!(rx_can_msg->flags & ES58X_FLAG_FD_DATA);\n> +\t\t/* rx_can_msg_len is the length of the rx_can_msg\n> +\t\t * buffer. Not to be confused with rx_can_msg->len\n> +\t\t * which is the length of the CAN payload\n> +\t\t * rx_can_msg->data.\n> +\t\t */\n> +\t\tu16 rx_can_msg_len = es58x_fd_sizeof_rx_tx_msg(*rx_can_msg);\n> +\n> +\t\tif (rx_can_msg_len > rx_can_msg_buf_len) {\n> +\t\t\tnetdev_err(netdev,\n> +\t\t\t\t \"%s: Expected a rx_can_msg of size %d but only %d bytes are left in rx_can_msg_buf\\n\",\n> +\t\t\t\t __func__,\n> +\t\t\t\t rx_can_msg_len, rx_can_msg_buf_len);\n> +\t\t\treturn -EMSGSIZE;\n> +\t\t}\n> +\t\tif (rx_can_msg->len > CANFD_MAX_DLEN) {\n> +\t\t\tnetdev_err(netdev,\n> +\t\t\t\t \"%s: Data length is %d but maximum should be %d\\n\",\n> +\t\t\t\t __func__, rx_can_msg->len, CANFD_MAX_DLEN);\n> +\t\t\treturn -EMSGSIZE;\n> +\t\t}\n> +\n> +\t\tif (netif_running(netdev)) {\n> +\t\t\tu64 tstamp = get_unaligned_le64(&rx_can_msg->timestamp);\n> +\t\t\tcanid_t can_id = get_unaligned_le32(&rx_can_msg->can_id);\n> +\t\t\tu8 dlc;\n> +\n> +\t\t\tif (is_can_fd)\n> +\t\t\t\tdlc = can_len2dlc(rx_can_msg->len);\n> +\t\t\telse\n> +\t\t\t\tdlc = rx_can_msg->dlc;\n> +\n> +\t\t\tret = es58x_rx_can_msg(netdev, tstamp, rx_can_msg->data,\n> +\t\t\t\t\t can_id, rx_can_msg->flags, dlc);\n> +\t\t\tif (ret)\n> +\t\t\t\tbreak;\n> +\t\t}\n> +\n> +\t\trx_can_msg_buf_len -= rx_can_msg_len;\n> +\t\trx_can_msg_buf += rx_can_msg_len;\n> +\t}\n> +\n> +\tif (!netif_running(netdev)) {\n> +\t\tif (net_ratelimit())\n> +\t\t\tnetdev_info(netdev,\n> +\t\t\t\t \"%s: %s is down, dropping %d rx packets\\n\",\n> +\t\t\t\t __func__, netdev->name, pkts);\n> +\t\tnetdev->stats.rx_dropped += pkts;\n> +\t}\n> +\n> +\treturn ret;\n> +}\n> +\n> +static int es58x_fd_rx_event_msg(struct net_device *netdev,\n> +\t\t\t\t const struct es58x_fd_urb_cmd\n> +\t\t\t\t *es58x_fd_urb_cmd)\n> +{\n> +\tstruct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev;\n> +\tu16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);\n> +\tconst struct es58x_fd_rx_event_msg *rx_event_msg;\n> +\tint ret;\n> +\n> +\tret = es58x_check_msg_len(es58x_dev->dev, *rx_event_msg, msg_len);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\trx_event_msg = &es58x_fd_urb_cmd->rx_event_msg;\n> +\n> +\treturn es58x_rx_err_msg(netdev, rx_event_msg->error_code,\n> +\t\t\t\trx_event_msg->event_code,\n> +\t\t\t\tget_unaligned_le64(&rx_event_msg->timestamp));\n> +}\n> +\n> +static int es58x_fd_rx_cmd_ret_u32(struct net_device *netdev,\n> +\t\t\t\t const struct es58x_fd_urb_cmd\n> +\t\t\t\t *es58x_fd_urb_cmd,\n> +\t\t\t\t enum es58x_ret_type cmd_ret_type)\n> +{\n> +\tstruct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev;\n> +\tu16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);\n> +\tenum es58x_ret_u32 rx_cmd_ret_u32;\n> +\tint ret;\n> +\n> +\tret = es58x_check_msg_len(es58x_dev->dev,\n> +\t\t\t\t es58x_fd_urb_cmd->rx_cmd_ret_le32, msg_len);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\trx_cmd_ret_u32 = get_unaligned_le32(&es58x_fd_urb_cmd->rx_cmd_ret_le32);\n> +\n> +\treturn es58x_rx_cmd_ret_u32(netdev, cmd_ret_type, rx_cmd_ret_u32);\n> +}\n> +\n> +static int es58x_fd_tx_ack_msg(struct net_device *netdev,\n> +\t\t\t const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd)\n> +{\n> +\tstruct es58x_device *es58x_dev = es58x_priv(netdev)->es58x_dev;\n> +\tconst struct es58x_fd_tx_ack_msg *tx_ack_msg;\n> +\tu16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);\n> +\tint ret;\n> +\n> +\ttx_ack_msg = &es58x_fd_urb_cmd->tx_ack_msg;\n> +\tret = es58x_check_msg_len(es58x_dev->dev, *tx_ack_msg, msg_len);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\treturn\n> +\t es58x_tx_ack_msg(netdev,\n> +\t\t\t get_unaligned_le16(&tx_ack_msg->tx_free_entries),\n> +\t\t\t get_unaligned_le32(&tx_ack_msg->rx_cmd_ret_le32));\n> +}\n> +\n> +static int es58x_fd_can_cmd_id(struct es58x_device *es58x_dev,\n> +\t\t\t const struct es58x_fd_urb_cmd *es58x_fd_urb_cmd)\n> +{\n> +\tstruct net_device *netdev;\n> +\tint ret;\n> +\n> +\tret = es58x_get_netdev(es58x_dev, es58x_fd_urb_cmd->channel_idx,\n> +\t\t\t &netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\tswitch ((enum es58x_fd_can_cmd_id)es58x_fd_urb_cmd->cmd_id) {\n> +\tcase ES58X_FD_CAN_CMD_ID_ENABLE_CHANNEL:\n> +\t\treturn es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd,\n> +\t\t\t\t\t ES58X_RET_TYPE_ENABLE_CHANNEL);\n> +\n> +\tcase ES58X_FD_CAN_CMD_ID_DISABLE_CHANNEL:\n> +\t\treturn es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd,\n> +\t\t\t\t\t ES58X_RET_TYPE_DISABLE_CHANNEL);\n> +\n> +\tcase ES58X_FD_CAN_CMD_ID_TX_MSG:\n> +\t\treturn es58x_fd_tx_ack_msg(netdev, es58x_fd_urb_cmd);\n> +\n> +\tcase ES58X_FD_CAN_CMD_ID_MSG_SELFRX_ACK:\n> +\t\treturn es58x_fd_rx_loopback_msg(netdev, es58x_fd_urb_cmd);\n> +\n> +\tcase ES58X_FD_CAN_CMD_ID_RX_MSG:\n> +\t\treturn es58x_fd_rx_can_msg(netdev, es58x_fd_urb_cmd);\n> +\n> +\tcase ES58X_FD_CAN_CMD_ID_RESET_RX:\n> +\t\treturn es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd,\n> +\t\t\t\t\t ES58X_RET_TYPE_RESET_RX);\n> +\n> +\tcase ES58X_FD_CAN_CMD_ID_RESET_TX:\n> +\t\treturn es58x_fd_rx_cmd_ret_u32(netdev, es58x_fd_urb_cmd,\n> +\t\t\t\t\t ES58X_RET_TYPE_RESET_TX);\n> +\n> +\tcase ES58X_FD_CAN_CMD_ID_ERROR_OR_EVENT_MSG:\n> +\t\treturn es58x_fd_rx_event_msg(netdev, es58x_fd_urb_cmd);\n> +\n> +\tdefault:\n> +\t\treturn -EBADRQC;\n> +\t}\n> +}\n> +\n> +static int es58x_fd_device_cmd_id(struct es58x_device *es58x_dev,\n> +\t\t\t\t const struct es58x_fd_urb_cmd\n> +\t\t\t\t *es58x_fd_urb_cmd)\n> +{\n> +\tu16 msg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);\n> +\tu64 timestamp;\n> +\tint ret;\n> +\n> +\tswitch ((enum es58x_fd_dev_cmd_id)es58x_fd_urb_cmd->cmd_id) {\n> +\tcase ES58X_FD_DEV_CMD_ID_TIMESTAMP:\n> +\t\tret = es58x_check_msg_len(es58x_dev->dev,\n> +\t\t\t\t\t es58x_fd_urb_cmd->timestamp, msg_len);\n> +\t\tif (ret)\n> +\t\t\treturn ret;\n> +\t\ttimestamp = get_unaligned_le64(&es58x_fd_urb_cmd->timestamp);\n> +\t\treturn es58x_rx_timestamp(es58x_dev, timestamp);\n> +\n> +\tdefault:\n> +\t\treturn -EBADRQC;\n> +\t}\n> +}\n> +\n> +static int es58x_fd_handle_urb_cmd(struct es58x_device *es58x_dev,\n> +\t\t\t\t const union es58x_urb_cmd *urb_cmd)\n> +{\n> +\tconst struct es58x_fd_urb_cmd *es58x_fd_urb_cmd;\n> +\tconst struct device *dev = es58x_dev->dev;\n> +\tint ret;\n> +\n> +\tes58x_fd_urb_cmd = &urb_cmd->es58x_fd_urb_cmd;\n> +\n> +\tswitch ((enum es58x_fd_cmd_type)es58x_fd_urb_cmd->cmd_type) {\n> +\tcase ES58X_FD_CMD_TYPE_CAN:\n> +\tcase ES58X_FD_CMD_TYPE_CANFD:\n> +\t\tret = es58x_fd_can_cmd_id(es58x_dev, es58x_fd_urb_cmd);\n> +\t\tbreak;\n> +\n> +\tcase ES58X_FD_CMD_TYPE_DEVICE:\n> +\t\tret = es58x_fd_device_cmd_id(es58x_dev, es58x_fd_urb_cmd);\n> +\t\tbreak;\n> +\n> +\tdefault:\n> +\t\tret = -EBADRQC;\n> +\t\tbreak;\n> +\t}\n> +\n> +\tif (ret == -EBADRQC)\n> +\t\tdev_err(dev,\n> +\t\t\t\"%s: Unknown command type (0x%02X) and command ID (0x%02X) combination\\n\",\n> +\t\t\t__func__, es58x_fd_urb_cmd->cmd_type,\n> +\t\t\tes58x_fd_urb_cmd->cmd_id);\n> +\n> +\treturn ret;\n> +}\n> +\n> +static void es58x_fd_fill_urb_header(union es58x_urb_cmd *urb_cmd, u8 cmd_type,\n> +\t\t\t\t u8 cmd_id, u8 channel_idx, u16 msg_len)\n> +{\n> +\tstruct es58x_fd_urb_cmd *es58x_fd_urb_cmd = &urb_cmd->es58x_fd_urb_cmd;\n> +\n> +\tes58x_fd_urb_cmd->SOF = cpu_to_le16(es58x_fd_param.tx_start_of_frame);\n> +\tes58x_fd_urb_cmd->cmd_type = cmd_type;\n> +\tes58x_fd_urb_cmd->cmd_id = cmd_id;\n> +\tes58x_fd_urb_cmd->channel_idx = channel_idx;\n> +\tes58x_fd_urb_cmd->msg_len = cpu_to_le16(msg_len);\n> +}\n> +\n> +static int es58x_fd_tx_can_msg(struct es58x_priv *priv, int channel_idx,\n> +\t\t\t u32 packet_idx, const struct sk_buff *skb,\n> +\t\t\t union es58x_urb_cmd *urb_cmd, u32 *urb_cmd_len)\n> +{\n> +\tstruct es58x_device *es58x_dev = priv->es58x_dev;\n> +\tstruct es58x_fd_urb_cmd *es58x_fd_urb_cmd = &urb_cmd->es58x_fd_urb_cmd;\n> +\tstruct can_frame *cf = (struct can_frame *)skb->data;\n> +\tstruct es58x_fd_tx_can_msg *tx_can_msg;\n> +\tbool is_fd = can_is_canfd_skb(skb);\n> +\tu16 msg_len;\n> +\tint ret;\n> +\n> +\tret = es58x_check_msg_max_len(es58x_dev->dev,\n> +\t\t\t\t es58x_fd_urb_cmd->tx_can_msg_buf,\n> +\t\t\t\t es58x_fd_get_msg_len(urb_cmd) +\n> +\t\t\t\t sizeof(*tx_can_msg));\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\tmsg_len = get_unaligned_le16(&es58x_fd_urb_cmd->msg_len);\n> +\ttx_can_msg = (struct es58x_fd_tx_can_msg *)\n> +\t &es58x_fd_urb_cmd->tx_can_msg_buf[msg_len];\n> +\n> +\t/* Fill message contents. */\n> +\tif (*urb_cmd_len == es58x_dev->param->urb_cmd_header_len)\n> +\t\tes58x_fd_fill_urb_header(urb_cmd,\n> +\t\t\t\t\t is_fd ? ES58X_FD_CMD_TYPE_CANFD\n> +\t\t\t\t\t : ES58X_FD_CMD_TYPE_CAN,\n> +\t\t\t\t\t ES58X_FD_CAN_CMD_ID_TX_MSG_NO_ACK,\n> +\t\t\t\t\t channel_idx, *urb_cmd_len);\n> +\ttx_can_msg->packet_idx = packet_idx;\n> +\tput_unaligned_le32(es58x_get_raw_can_id(cf), &tx_can_msg->can_id);\n> +\ttx_can_msg->flags = (u8)es58x_get_flags(skb);\n> +\tif (is_fd)\n> +\t\ttx_can_msg->len = cf->len;\n> +\telse\n> +\t\ttx_can_msg->dlc = can_get_cc_dlc(priv->can.ctrlmode,\n> +\t\t\t\t\t\t cf->len, cf->len8_dlc);\n> +\tmemcpy(tx_can_msg->data, cf->data, cf->len);\n> +\n> +\t/* Calculate new sizes */\n> +\tmsg_len += es58x_fd_sizeof_rx_tx_msg(*tx_can_msg);\n> +\t*urb_cmd_len = es58x_get_urb_cmd_len(es58x_dev, msg_len);\n> +\tput_unaligned_le16(msg_len, &es58x_fd_urb_cmd->msg_len);\n> +\n> +\treturn 0;\n> +}\n> +\n> +/* ES58X uses the same command to set the bittiming parameters and\n> + * enable the channel. The modification is done in\n> + * es58x_fd_enable_channel().\n> + */\n> +static int es58x_fd_set_bittiming(struct es58x_device *es58x_dev,\n> +\t\t\t\t int channel_idx)\n> +{\n> +\treturn 0;\n> +}\n> +\n> +static void es58x_fd_print_bittiming(struct net_device *netdev,\n> +\t\t\t\t struct es58x_fd_bittiming\n> +\t\t\t\t *es58x_fd_bittiming, char *type)\n> +{\n> +\tnetdev_vdbg(netdev, \"bitrate %s = %d\\n\", type,\n> +\t\t le32_to_cpu(es58x_fd_bittiming->bitrate));\n> +\tnetdev_vdbg(netdev, \"tseg1 %s = %d\\n\", type,\n> +\t\t le16_to_cpu(es58x_fd_bittiming->tseg1));\n> +\tnetdev_vdbg(netdev, \"tseg2 %s = %d\\n\", type,\n> +\t\t le16_to_cpu(es58x_fd_bittiming->tseg2));\n> +\tnetdev_vdbg(netdev, \"brp %s = %d\\n\", type,\n> +\t\t le16_to_cpu(es58x_fd_bittiming->brp));\n> +\tnetdev_vdbg(netdev, \"sjw %s = %d\\n\", type,\n> +\t\t le16_to_cpu(es58x_fd_bittiming->sjw));\n> +}\n> +\n> +static void es58x_fd_print_conf(struct net_device *netdev,\n> +\t\t\t\tstruct es58x_fd_tx_conf_msg *tx_conf_msg)\n> +{\n> +\tes58x_fd_print_bittiming(netdev, &tx_conf_msg->nominal_bittiming,\n> +\t\t\t\t \"nominal\");\n> +\tnetdev_vdbg(netdev, \"samples_per_bit = %d\\n\",\n> +\t\t tx_conf_msg->samples_per_bit);\n> +\tnetdev_vdbg(netdev, \"sync_edge = %d\\n\",\n> +\t\t tx_conf_msg->sync_edge);\n> +\tnetdev_vdbg(netdev, \"physical_media = %d\\n\",\n> +\t\t tx_conf_msg->physical_media);\n> +\tnetdev_vdbg(netdev, \"self_reception = %d\\n\",\n> +\t\t tx_conf_msg->self_reception_mode);\n> +\tnetdev_vdbg(netdev, \"ctrlmode = %d\\n\", tx_conf_msg->ctrlmode);\n> +\tnetdev_vdbg(netdev, \"canfd_enabled = %d\\n\",\n> +\t\t tx_conf_msg->canfd_enabled);\n> +\tif (tx_conf_msg->canfd_enabled) {\n> +\t\tes58x_fd_print_bittiming(netdev,\n> +\t\t\t\t\t &tx_conf_msg->data_bittiming, \"data\");\n> +\t\tnetdev_vdbg(netdev,\n> +\t\t\t \"Transmitter Delay Compensation = %d\\n\",\n> +\t\t\t tx_conf_msg->tdc);\n> +\t\tnetdev_vdbg(netdev,\n> +\t\t\t \"Transmitter Delay Compensation Offset = %d\\n\",\n> +\t\t\t le16_to_cpu(tx_conf_msg->tdco));\n> +\t\tnetdev_vdbg(netdev,\n> +\t\t\t \"Transmitter Delay Compensation Filter = %d\\n\",\n> +\t\t\t le16_to_cpu(tx_conf_msg->tdcf));\n> +\t}\n> +}\n> +\n> +static void es58x_fd_convert_bittiming(struct es58x_fd_bittiming *es58x_fd_bt,\n> +\t\t\t\t struct can_bittiming *bt)\n> +{\n> +\t/* The actual value set in the hardware registers is one less\n> +\t * than the functional value.\n> +\t */\n> +\tconst int offset = 1;\n> +\n> +\tes58x_fd_bt->bitrate = cpu_to_le32(bt->bitrate);\n> +\tes58x_fd_bt->tseg1 =\n> +\t cpu_to_le16(bt->prop_seg + bt->phase_seg1 - offset);\n> +\tes58x_fd_bt->tseg2 = cpu_to_le16(bt->phase_seg2 - offset);\n> +\tes58x_fd_bt->brp = cpu_to_le16(bt->brp - offset);\n> +\tes58x_fd_bt->sjw = cpu_to_le16(bt->sjw - offset);\n> +}\n> +\n> +static int es58x_fd_enable_channel(struct es58x_device *es58x_dev,\n> +\t\t\t\t int channel_idx)\n> +{\n> +\tstruct net_device *netdev = es58x_dev->netdev[channel_idx];\n> +\tstruct es58x_priv *priv = es58x_priv(netdev);\n> +\tstruct es58x_fd_tx_conf_msg tx_conf_msg = { 0 };\n> +\tu32 ctrlmode;\n> +\tbool is_can_fd = false;\n> +\tsize_t conf_len = 0;\n> +\n> +\tes58x_fd_convert_bittiming(&tx_conf_msg.nominal_bittiming,\n> +\t\t\t\t &priv->can.bittiming);\n> +\tctrlmode = priv->can.ctrlmode;\n> +\n> +\ttx_conf_msg.samples_per_bit =\n> +\t ctrlmode & CAN_CTRLMODE_3_SAMPLES ?\n> +\t ES58X_SAMPLES_PER_BIT_THREE : ES58X_SAMPLES_PER_BIT_ONE;\n> +\ttx_conf_msg.sync_edge = ES58X_SYNC_EDGE_SINGLE;\n> +\ttx_conf_msg.physical_media = ES58X_PHYSICAL_MEDIA_HIGH_SPEED;\n> +\ttx_conf_msg.self_reception_mode = ES58X_SELF_RECEPTION_ON;\n> +\n> +\ttx_conf_msg.ctrlmode |=\n> +\t ctrlmode & CAN_CTRLMODE_LISTENONLY ?\n> +\t ES58X_FD_CTRLMODE_PASSIVE : ES58X_FD_CTRLMODE_ACTIVE;\n> +\n> +\tconf_len = ES58X_FD_CAN_CONF_LEN;\n> +\tif (ctrlmode & CAN_CTRLMODE_FD) {\n> +\t\ttx_conf_msg.ctrlmode |= ES58X_FD_CTRLMODE_FD_ISO;\n> +\t\tis_can_fd = true;\n> +\t} else if (ctrlmode & CAN_CTRLMODE_FD_NON_ISO) {\n> +\t\ttx_conf_msg.ctrlmode |= ES58X_FD_CTRLMODE_FD_NON_ISO;\n> +\t\tis_can_fd = true;\n> +\t}\n> +\tif (is_can_fd) {\n> +\t\tstruct can_bittiming *dbt = &priv->can.data_bittiming;\n> +\t\tint tdco = 0;\n> +\n> +\t\tconf_len = ES58X_FD_CANFD_CONF_LEN;\n> +\n> +\t\ttx_conf_msg.canfd_enabled = !!is_can_fd;\n> +\t\tes58x_fd_convert_bittiming(&tx_conf_msg.data_bittiming, dbt);\n> +\n> +\t\t/* As specified in ISO 11898-1 section 11.3.3\n> +\t\t * \"Transmitter delay compensation\" (TDC) is only\n> +\t\t * applicable if data BRP is one or two.\n> +\t\t */\n> +\t\ttx_conf_msg.tdc = (dbt->brp == 1) || (dbt->brp == 2);\n> +\t\tif (tx_conf_msg.tdc) {\n> +\t\t\t/* Set the Transmitter Delay Compensation\n> +\t\t\t * offset as the duration (in time quanta)\n> +\t\t\t * from the start of the bit to the sample\n> +\t\t\t * point.\n> +\t\t\t */\n> +\t\t\ttdco = can_bit_time(dbt) * dbt->sample_point / 1000;\n> +\t\t}\n> +\t\ttx_conf_msg.tdco = cpu_to_le16(min_t(u16, 127, tdco));\n> +\t\ttx_conf_msg.tdcf = cpu_to_le16(0);\n> +\t}\n> +\tes58x_fd_print_conf(netdev, &tx_conf_msg);\n> +\n> +\treturn es58x_send_msg(es58x_dev, es58x_fd_cmd_type(netdev),\n> +\t\t\t ES58X_FD_CAN_CMD_ID_ENABLE_CHANNEL,\n> +\t\t\t &tx_conf_msg, conf_len, channel_idx);\n> +}\n> +\n> +static int es58x_fd_disable_channel(struct es58x_device *es58x_dev,\n> +\t\t\t\t int channel_idx)\n> +{\n> +\t/* The type (ES58X_FD_CMD_TYPE_CAN or ES58X_FD_CMD_TYPE_CANFD) does\n> +\t * not matter here.\n> +\t */\n> +\treturn es58x_send_msg(es58x_dev, ES58X_FD_CMD_TYPE_CAN,\n> +\t\t\t ES58X_FD_CAN_CMD_ID_DISABLE_CHANNEL,\n> +\t\t\t ES58X_EMPTY_MSG, 0, channel_idx);\n> +}\n> +\n> +static int es58x_fd_reset_rx(struct es58x_device *es58x_dev, int channel_idx)\n> +{\n> +\tstruct net_device *netdev;\n> +\tint ret;\n> +\n> +\tret = es58x_get_netdev(es58x_dev, channel_idx, &netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\treturn es58x_send_msg(es58x_dev, es58x_fd_cmd_type(netdev),\n> +\t\t\t ES58X_FD_CAN_CMD_ID_RESET_RX, ES58X_EMPTY_MSG,\n> +\t\t\t 0, channel_idx);\n> +}\n> +\n> +static int es58x_fd_reset_tx(struct es58x_device *es58x_dev, int channel_idx)\n> +{\n> +\tstruct net_device *netdev;\n> +\tint ret;\n> +\n> +\tret = es58x_get_netdev(es58x_dev, channel_idx, &netdev);\n> +\tif (ret)\n> +\t\treturn ret;\n> +\n> +\treturn es58x_send_msg(es58x_dev, es58x_fd_cmd_type(netdev),\n> +\t\t\t ES58X_FD_CAN_CMD_ID_RESET_TX, ES58X_EMPTY_MSG,\n> +\t\t\t 0, channel_idx);\n> +}\n> +\n> +static int es58x_fd_get_timestamp(struct es58x_device *es58x_dev)\n> +{\n> +\treturn es58x_send_msg(es58x_dev, ES58X_FD_CMD_TYPE_DEVICE,\n> +\t\t\t ES58X_FD_DEV_CMD_ID_TIMESTAMP, ES58X_EMPTY_MSG,\n> +\t\t\t 0, ES58X_CHANNEL_IDX_NA);\n> +}\n> +\n> +/* struct es58x_fd_nom_bittiming_const - Nominal bittiming constants.\n> + *\n> + * Nominal bittiming constants for ES582.1 and ES584.1 as specified in\n> + * the microcontroller datasheet: \"SAM E701/S70/V70/V71 Family\"\n> + * section 49.6.8 \"MCAN Nominal Bit Timing and Prescaler Register\"\n> + * from Microchip.\n> + *\n> + * The values from the specification are the hardware register\n> + * values. To convert them to the functional values, all ranges were\n> + * incremented by 1 (e.g. range [0..n-1] changed to [1..n]).\n> + */\n> +static const struct can_bittiming_const es58x_fd_nom_bittiming_const = {\n> +\t.name = \"ES582.1/ES584.1\",\n> +\t.tseg1_min = 2,\n> +\t.tseg1_max = 256,\n> +\t.tseg2_min = 2,\n> +\t.tseg2_max = 128,\n> +\t.sjw_max = 128,\n> +\t.brp_min = 1,\n> +\t.brp_max = 512,\n> +\t.brp_inc = 1\n> +};\n> +\n> +/* struct es58x_fd_data_bittiming_const - Data bittiming constants.\n> + *\n> + * Data bittiming constants for ES582.1 and ES584.1 as specified in\n> + * the microcontroller datasheet: \"SAM E701/S70/V70/V71 Family\"\n> + * section 49.6.4 \"MCAN Data Bit Timing and Prescaler Register\" from\n> + * Microchip.\n> + */\n> +static const struct can_bittiming_const es58x_fd_data_bittiming_const = {\n> +\t.name = \"ES582.1/ES584.1\",\n> +\t.tseg1_min = 2,\n> +\t.tseg1_max = 32,\n> +\t.tseg2_min = 1,\n> +\t.tseg2_max = 16,\n> +\t.sjw_max = 8,\n> +\t.brp_min = 1,\n> +\t.brp_max = 32,\n> +\t.brp_inc = 1\n> +};\n> +\n> +const struct es58x_parameters es58x_fd_param = {\n> +\t.bittiming_const = &es58x_fd_nom_bittiming_const,\n> +\t.data_bittiming_const = &es58x_fd_data_bittiming_const,\n> +\t.bitrate_max = ES58X_MBPS(8),\n> +\t.clock = {.freq = ES58X_MHZ(80)},\n> +\t.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK | CAN_CTRLMODE_LISTENONLY |\n> +\t CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_FD | CAN_CTRLMODE_FD_NON_ISO |\n> +\t CAN_CTRLMODE_CC_LEN8_DLC,\n> +\t.tx_start_of_frame = 0xCEFA,\t/* FACE in little endian */\n> +\t.rx_start_of_frame = 0xFECA,\t/* CAFE in little endian */\n> +\t.tx_urb_cmd_max_len = ES58X_FD_TX_URB_CMD_MAX_LEN,\n> +\t.rx_urb_cmd_max_len = ES58X_FD_RX_URB_CMD_MAX_LEN,\n> +\t/* Size of internal device TX queue is 500.\n> +\t *\n> +\t * However, when reaching value around 278, the device's busy\n> +\t * LED turns on and thus maximum value of 500 is never reached\n> +\t * in practice. Also, when this value is too high, some error\n> +\t * on the rx_loopback_msg were witnessed when the device is\n> +\t * recovering from bus off.\n> +\t *\n> +\t * For above reasons, a value that would prevent the device\n> +\t * from becoming busy was chosen. In practice, BQL would\n> +\t * prevent the value from even getting closer to below\n> +\t * maximum, so no impact on performance was measured.\n> +\t */\n> +\t.echo_skb_max = U8_MAX,\n> +\t/* Empirical value. */\n> +\t.dql_limit_min = ES58X_CAN_FRAME_BYTES_MAX * 15,\n> +\t.tx_bulk_max = ES58X_FD_TX_BULK_MAX,\n> +\t.urb_cmd_header_len = ES58X_FD_URB_CMD_HEADER_LEN,\n> +\t.rx_urb_max = ES58X_RX_URBS_MAX,\n> +\t.tx_urb_max = ES58X_TX_URBS_MAX,\n> +\t.channel_idx_offset = 0\n> +};\n> +\n> +const struct es58x_operators es58x_fd_ops = {\n> +\t.get_msg_len = es58x_fd_get_msg_len,\n> +\t.handle_urb_cmd = es58x_fd_handle_urb_cmd,\n> +\t.fill_urb_header = es58x_fd_fill_urb_header,\n> +\t.tx_can_msg = es58x_fd_tx_can_msg,\n> +\t.set_bittiming = es58x_fd_set_bittiming,\n> +\t.enable_channel = es58x_fd_enable_channel,\n> +\t.disable_channel = es58x_fd_disable_channel,\n> +\t.reset_rx = es58x_fd_reset_rx,\n> +\t.reset_tx = es58x_fd_reset_tx,\n> +\t.get_timestamp = es58x_fd_get_timestamp\n> +};\n> diff --git a/drivers/net/can/usb/etas_es58x/es58x_fd.h b/drivers/net/can/usb/etas_es58x/es58x_fd.h\n> new file mode 100644\n> index 000000000000..e9457ea542d4\n> --- /dev/null\n> +++ b/drivers/net/can/usb/etas_es58x/es58x_fd.h\n> @@ -0,0 +1,242 @@\n> +/* SPDX-License-Identifier: GPL-2.0 */\n> +\n> +/* Driver for ETAS GmbH ES58X USB CAN(-FD) Bus Interfaces.\n> + *\n> + * File es58x_fd.h: Definitions and declarations specific to ETAS\n> + * ES582.1 and ES584.1 (naming convention: we use the term \"ES58X FD\"\n> + * when referring to those two variants together).\n> + *\n> + * Copyright (C) 2019 Robert Bosch Engineering and Business\n> + * Solutions. All rights reserved.\n> + * Copyright (C) 2020 ETAS K.K.. All rights reserved.\n> + */\n> +\n> +#ifndef __ES58X_FD_H__\n> +#define __ES58X_FD_H__\n> +\n> +#include \n> +\n> +#define ES582_1_NUM_CAN_CH 2\n> +#define ES584_1_NUM_CAN_CH 1\n> +#define ES58X_FD_NUM_CAN_CH 2\n> +\n> +#define ES58X_FD_TX_BULK_MAX 100\n> +#define ES58X_FD_RX_BULK_MAX 100\n> +#define ES58X_FD_RX_LOOPBACK_BULK_MAX 100\n> +\n> +enum es58x_fd_cmd_type {\n> +\tES58X_FD_CMD_TYPE_CAN = 0x03,\n> +\tES58X_FD_CMD_TYPE_CANFD = 0x04,\n> +\tES58X_FD_CMD_TYPE_DEVICE = 0xFF\n> +};\n> +\n> +/* Command IDs for ES58X_FD_CMD_TYPE_{CAN,CANFD}. */\n> +enum es58x_fd_can_cmd_id {\n> +\tES58X_FD_CAN_CMD_ID_ENABLE_CHANNEL = 0x01,\n> +\tES58X_FD_CAN_CMD_ID_DISABLE_CHANNEL = 0x02,\n> +\tES58X_FD_CAN_CMD_ID_TX_MSG = 0x05,\n> +\tES58X_FD_CAN_CMD_ID_MSG_SELFRX_ACK = 0x07,\n> +\tES58X_FD_CAN_CMD_ID_RX_MSG = 0x10,\n> +\tES58X_FD_CAN_CMD_ID_ERROR_OR_EVENT_MSG = 0x11,\n> +\tES58X_FD_CAN_CMD_ID_RESET_RX = 0x20,\n> +\tES58X_FD_CAN_CMD_ID_RESET_TX = 0x21,\n> +\tES58X_FD_CAN_CMD_ID_TX_MSG_NO_ACK = 0x55\n> +};\n> +\n> +/* Command IDs for ES58X_FD_CMD_TYPE_DEVICE. */\n> +enum es58x_fd_dev_cmd_id {\n> +\tES58X_FD_DEV_CMD_ID_GETTIMETICKS = 0x01,\n> +\tES58X_FD_DEV_CMD_ID_TIMESTAMP = 0x02\n> +};\n> +\n> +/**\n> + * enum es58x_fd_ctrlmode - Controller mode.\n> + * @ES58X_FD_CTRLMODE_ACTIVE: send and receive messages.\n> + * @ES58X_FD_CTRLMODE_PASSIVE: only receive messages (monitor). Do not\n> + *\tsend anything, not even the acknowledgment bit.\n> + * @ES58X_FD_CTRLMODE_FD_ISO: CAN-FD according to ISO11898-1.\n> + * @ES58X_FD_CTRLMODE_FD_NON_ISO: follow Bosch CAN FD Specification\n> + *\tV1.0\n> + * @ES58X_FD_CTRLMODE_DISABLE_PROTOCOL_EXCEPTION_HANDLING: How to\n> + *\tbehave when CAN FD reserved bit is monitored as\n> + *\tdominant. (c.f. ISO 11898-1:2015, section 10.4.2.4 \"Control\n> + *\tfield\", paragraph \"r0 bit\"). 0 (not disable = enable): send\n> + *\terror frame. 1 (disable): goes into bus integration mode\n> + *\t(c.f. below).\n> + * @ES58X_FD_CTRLMODE_EDGE_FILTER_DURING_BUS_INTEGRATION: 0: Edge\n> + *\tfiltering is disabled. 1: Edge filtering is enabled. Two\n> + *\tconsecutive dominant bits required to detect an edge for hard\n> + *\tsynchronization.\n> + */\n> +enum es58x_fd_ctrlmode {\n> +\tES58X_FD_CTRLMODE_ACTIVE = 0,\n> +\tES58X_FD_CTRLMODE_PASSIVE = BIT(0),\n> +\tES58X_FD_CTRLMODE_FD_ISO = BIT(4),\n> +\tES58X_FD_CTRLMODE_FD_NON_ISO = BIT(5),\n> +\tES58X_FD_CTRLMODE_DISABLE_PROTOCOL_EXCEPTION_HANDLING = BIT(6),\n> +\tES58X_FD_CTRLMODE_EDGE_FILTER_DURING_BUS_INTEGRATION = BIT(7)\n> +};\n> +\n> +struct es58x_fd_bittiming {\n> +\t__le32 bitrate;\n> +\t__le16 tseg1;\t\t/* range: [tseg1_min-1..tseg1_max-1] */\n> +\t__le16 tseg2;\t\t/* range: [tseg2_min-1..tseg2_max-1] */\n> +\t__le16 brp;\t\t/* range: [brp_min-1..brp_max-1] */\n> +\t__le16 sjw;\t\t/* range: [0..sjw_max-1] */\n> +} __packed;\n> +\n> +/**\n> + * struct es58x_fd_tx_conf_msg - Channel configuration.\n> + * @nominal_bittiming: Nominal bittiming.\n> + * @samples_per_bit: type enum es58x_samples_per_bit.\n> + * @sync_edge: type enum es58x_sync_edge.\n> + * @physical_media: type enum es58x_physical_media.\n> + * @self_reception_mode: type enum es58x_self_reception_mode.\n> + * @ctrlmode: type enum es58x_fd_ctrlmode.\n> + * @canfd_enabled: boolean (0: Classical CAN, 1: CAN and/or CANFD).\n> + * @data_bittiming: Bittiming for flexible data-rate transmission.\n> + * @tdc: Transmitter Delay Compensation switch (0: disabled, 1:\n> + *\tenabled). On very high bitrates, the delay between when the\n> + *\tbit is sent and received on the CANTX and CANRX pins of the\n> + *\ttransceiver start to be significant enough for errors to occur\n> + *\tand thus need to be compensated.\n> + * @tdco: Transmitter Delay Compensation Offset. Offset value, in time\n> + *\tquanta, defining the delay between the start of the bit\n> + *\treception on the CANRX pin of the transceiver and the SSP\n> + *\t(Secondary Sample Point). Valid values: 0 to 127.\n> + * @tdcf: Transmitter Delay Compensation Filter window. Defines the\n> + *\tminimum value for the SSP position, in time quanta. The\n> + *\tfeature is enabled when TDCF is configured to a value greater\n> + *\tthan TDCO. Valid values: 0 to 127.\n> + *\n> + * Please refer to the microcontroller datasheet: \"SAM\n> + * E701/S70/V70/V71 Family\" section 49 \"Controller Area Network\n> + * (MCAN)\" for additional information.\n> + */\n> +struct es58x_fd_tx_conf_msg {\n> +\tstruct es58x_fd_bittiming nominal_bittiming;\n> +\tu8 samples_per_bit;\n> +\tu8 sync_edge;\n> +\tu8 physical_media;\n> +\tu8 self_reception_mode;\n> +\tu8 ctrlmode;\n> +\tu8 canfd_enabled;\n> +\tstruct es58x_fd_bittiming data_bittiming;\n> +\tu8 tdc;\n> +\t__le16 tdco;\n> +\t__le16 tdcf;\n> +} __packed;\n> +\n> +#define ES58X_FD_CAN_CONF_LEN\t\t\t\t\t\\\n> +\t(offsetof(struct es58x_fd_tx_conf_msg, canfd_enabled))\n> +#define ES58X_FD_CANFD_CONF_LEN (sizeof(struct es58x_fd_tx_conf_msg))\n> +\n> +struct es58x_fd_tx_can_msg {\n> +\tu8 packet_idx;\n> +\t__le32 can_id;\n> +\tu8 flags;\n> +\tunion {\n> +\t\tu8 dlc;\t\t/* Only if cmd_id is ES58X_FD_CMD_TYPE_CAN */\n> +\t\tu8 len;\t\t/* Only if cmd_id is ES58X_FD_CMD_TYPE_CANFD */\n> +\t} __packed;\n> +\tu8 data[CANFD_MAX_DLEN];\n> +} __packed;\n> +\n> +#define ES58X_FD_CAN_TX_LEN\t\t\t\t\t\t\\\n> +\t(offsetof(struct es58x_fd_tx_can_msg, data[CAN_MAX_DLEN]))\n> +#define ES58X_FD_CANFD_TX_LEN (sizeof(struct es58x_fd_tx_can_msg))\n> +\n> +struct es58x_fd_rx_can_msg {\n> +\t__le64 timestamp;\n> +\t__le32 can_id;\n> +\tu8 flags;\n> +\tunion {\n> +\t\tu8 dlc;\t\t/* Only if cmd_id is ES58X_FD_CMD_TYPE_CAN */\n> +\t\tu8 len;\t\t/* Only if cmd_id is ES58X_FD_CMD_TYPE_CANFD */\n> +\t} __packed;\n> +\tu8 data[CANFD_MAX_DLEN];\n> +} __packed;\n> +\n> +#define ES58X_FD_CAN_RX_LEN\t\t\t\t\t\t\\\n> +\t(offsetof(struct es58x_fd_rx_can_msg, data[CAN_MAX_DLEN]))\n> +#define ES58X_FD_CANFD_RX_LEN (sizeof(struct es58x_fd_rx_can_msg))\n> +\n> +struct es58x_fd_rx_loopback_msg {\n> +\t__le64 timestamp;\n> +\tu8 packet_idx;\n> +} __packed;\n> +\n> +struct es58x_fd_rx_event_msg {\n> +\t__le64 timestamp;\n> +\t__le32 can_id;\n> +\tu8 flags;\t\t/* type enum es58x_flag */\n> +\tu8 error_type;\t\t/* 0: event, 1: error */\n> +\tu8 error_code;\n> +\tu8 event_code;\n> +} __packed;\n> +\n> +struct es58x_fd_tx_ack_msg {\n> +\t__le32 rx_cmd_ret_le32;\t/* type enum es58x_cmd_ret_code_u32 */\n> +\t__le16 tx_free_entries;\t/* Number of remaining free entries in the device TX queue */\n> +} __packed;\n> +\n> +/**\n> + * struct es58x_fd_urb_cmd - Commands received from or sent to the\n> + *\tES58X FD device.\n> + * @SOF: Start of Frame.\n> + * @cmd_type: Command Type (type: enum es58x_fd_cmd_type). The CRC\n> + *\tcalculation starts at this position.\n> + * @cmd_id: Command ID (type: enum es58x_fd_cmd_id).\n> + * @channel_idx: Channel index starting at 0.\n> + * @msg_len: Length of the message, excluding CRC (i.e. length of the\n> + *\tunion).\n> + * @raw_msg: Message raw payload.\n> + * @tx_conf_msg: Channel configuration.\n> + * @tx_can_msg_buf: Concatenation of Tx messages. Type is \"u8[]\"\n> + *\tinstead of \"struct es58x_fd_tx_msg[]\" because the structure\n> + *\thas a flexible size.\n> + * @rx_can_msg_buf: Concatenation Rx messages. Type is \"u8[]\" instead\n> + *\tof \"struct es58x_fd_rx_msg[]\" because the structure has a\n> + *\tflexible size.\n> + * @rx_loopback_msg: Array of loopback messages.\n> + * @rx_event_msg: Error or event message.\n> + * @tx_ack_msg: Tx acknowledgment message.\n> + * @timestamp: Timestamp reply.\n> + * @rx_cmd_ret_le32: Rx 32 bits return code (type: enum\n> + *\tes58x_cmd_ret_code_u32).\n> + * @reserved_for_crc16_do_not_use: The structure ends with a\n> + *\tCRC16. Because the structures in above union are of variable\n> + *\tlengths, we can not predict the offset of the CRC in\n> + *\tadvance. Use functions es58x_get_crc() and es58x_set_crc() to\n> + *\tmanipulate it.\n> + */\n> +struct es58x_fd_urb_cmd {\n> +\t__le16 SOF;\n> +\tu8 cmd_type;\n> +\tu8 cmd_id;\n> +\tu8 channel_idx;\n> +\t__le16 msg_len;\n> +\n> +\tunion {\n> +\t\tstruct es58x_fd_tx_conf_msg tx_conf_msg;\n> +\t\tu8 tx_can_msg_buf[ES58X_FD_TX_BULK_MAX * ES58X_FD_CANFD_TX_LEN];\n> +\t\tu8 rx_can_msg_buf[ES58X_FD_RX_BULK_MAX * ES58X_FD_CANFD_RX_LEN];\n> +\t\tstruct es58x_fd_rx_loopback_msg\n> +\t\t rx_loopback_msg[ES58X_FD_RX_LOOPBACK_BULK_MAX];\n> +\t\tstruct es58x_fd_rx_event_msg rx_event_msg;\n> +\t\tstruct es58x_fd_tx_ack_msg tx_ack_msg;\n> +\t\t__le64 timestamp;\n> +\t\t__le32 rx_cmd_ret_le32;\n> +\t\tu8 raw_msg[0];\n> +\t} __packed;\n> +\n> +\t__le16 reserved_for_crc16_do_not_use;\n> +} __packed;\n> +\n> +#define ES58X_FD_URB_CMD_HEADER_LEN (offsetof(struct es58x_fd_urb_cmd, raw_msg))\n> +#define ES58X_FD_TX_URB_CMD_MAX_LEN\t\t\t\t\t\\\n> +\tES58X_SIZEOF_URB_CMD(struct es58x_fd_urb_cmd, tx_can_msg_buf)\n> +#define ES58X_FD_RX_URB_CMD_MAX_LEN\t\t\t\t\t\\\n> +\tES58X_SIZEOF_URB_CMD(struct es58x_fd_urb_cmd, rx_can_msg_buf)\n> +\n> +#endif /* __ES58X_FD_H__ */\n>","headers":{"Return-Path":"","X-Original-To":"patchwork-incoming-netdev@ozlabs.org","Delivered-To":"patchwork-incoming-netdev@ozlabs.org","Authentication-Results":["ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org\n (client-ip=23.128.96.18; helo=vger.kernel.org;\n envelope-from=netdev-owner@vger.kernel.org; receiver=)","ozlabs.org;\n dmarc=none (p=none dis=none) header.from=hartkopp.net","ozlabs.org;\n\tdkim=pass (2048-bit key;\n unprotected) header.d=hartkopp.net header.i=@hartkopp.net header.a=rsa-sha256\n header.s=strato-dkim-0002 header.b=oLOIsCnP;\n\tdkim-atps=neutral"],"Received":["from vger.kernel.org (vger.kernel.org [23.128.96.18])\n\tby ozlabs.org (Postfix) with ESMTP id 4CTZ994HdBz9sTD\n\tfor ;\n Mon, 9 Nov 2020 00:05:01 +1100 (AEDT)","(majordomo@vger.kernel.org) by vger.kernel.org via listexpand\n id S1728451AbgKHNEq (ORCPT\n );\n Sun, 8 Nov 2020 08:04:46 -0500","from mo4-p01-ob.smtp.rzone.de ([85.215.255.54]:36012 \"EHLO\n mo4-p01-ob.smtp.rzone.de\" rhost-flags-OK-OK-OK-OK) by vger.kernel.org\n with ESMTP id S1726607AbgKHNEo (ORCPT\n ); Sun, 8 Nov 2020 08:04:44 -0500","from [192.168.10.177]\n by smtp.strato.de (RZmta 47.3.3 DYNA|AUTH)\n with ESMTPSA id V0298cwA8D3h4Cm\n (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256 bits))\n (Client did not present a certificate);\n Sun, 8 Nov 2020 14:03:43 +0100 (CET)"],"DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed; t=1604840643;\n s=strato-dkim-0002; d=hartkopp.net;\n h=In-Reply-To:Date:Message-ID:From:References:Cc:To:Subject:\n X-RZG-CLASS-ID:X-RZG-AUTH:From:Subject:Sender;\n bh=iyc3WwfxPkmnzydRmLaGQsF0c27wVy8gTZ0Bm9RPwW0=;\n b=oLOIsCnPVb8PPJQqhjWk91B8fsFj/8ce/CkzQHIt+d3UfmdTo2mqgXSqmQBHxdbamW\n AM9Ww1q3qLsjXnREPRn1j5+uPpYmWXHtVYkZ0Ij3f5U4daPBi6YoMs/gS+RutuvqkHsl\n AAOs1gv0mRO5Q9PG0ailovKKCalFZdxGSfDuyQdk76HqweAMNFpSZXcPGFHsgrDLO0yv\n mGwO1I3D4YKLi1p1roIXD/pAwvdq5O1b373uN/JNc85yyioZyMaXYY/n0OLGeoMJ5p38\n 63ajb0NThc93aQtdBKAnA2idsltkHJi59DgpM+oYMIutwPmuGjQTuvUYnU8BZKQdE2Py\n KmmQ==","X-RZG-AUTH":"\n \":P2MHfkW8eP4Mre39l357AZT/I7AY/7nT2yrDxb8mjG14FZxedJy6qgO1o3TMaFqTGVNiP6A=\"","X-RZG-CLASS-ID":"mo00","Subject":"Re: [PATCH v5] can: usb: etas_es58X: add support for ETAS ES58X CAN\n USB interfaces","To":"Vincent Mailhol ,\n linux-can@vger.kernel.org, Marc Kleine-Budde ","Cc":"Arunachalam Santhanam ,\n Wolfgang Grandegger ,\n \"David S. Miller\" ,\n Jakub Kicinski ,\n Masahiro Yamada ,\n open list ,\n \"open list:NETWORKING DRIVERS\" ","References":"<20201107141837.277708-1-mailhol.vincent@wanadoo.fr>","From":"Oliver Hartkopp ","Message-ID":"","Date":"Sun, 8 Nov 2020 14:03:36 +0100","User-Agent":"Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101\n Thunderbird/68.12.0","MIME-Version":"1.0","In-Reply-To":"<20201107141837.277708-1-mailhol.vincent@wanadoo.fr>","Content-Type":"text/plain; charset=utf-8; format=flowed","Content-Language":"en-US","Content-Transfer-Encoding":"7bit","Precedence":"bulk","List-ID":"","X-Mailing-List":"netdev@vger.kernel.org"}},{"id":2574492,"web_url":"http://patchwork.ozlabs.org/comment/2574492/","msgid":"<202011111346.5uOmotE1-lkp@intel.com>","list_archive_url":null,"date":"2020-11-11T05:09:58","subject":"Re: [PATCH v5] can: usb: etas_es58X: add support for ETAS ES58X CAN\n USB interfaces","submitter":{"id":67315,"url":"http://patchwork.ozlabs.org/api/people/67315/","name":"kernel test robot","email":"lkp@intel.com"},"content":"Hi Vincent,\n\nThank you for the patch! Yet something to improve:\n\n[auto build test ERROR on linus/master]\n[also build test ERROR on v5.10-rc3 next-20201110]\n[If your patch is applied to the wrong git tree, kindly drop us a note.\nAnd when submitting patch, we suggest to use '--base' as documented in\nhttps://git-scm.com/docs/git-format-patch]\n\nurl: https://github.com/0day-ci/linux/commits/Vincent-Mailhol/can-usb-etas_es58X-add-support-for-ETAS-ES58X-CAN-USB-interfaces/20201109-094004\nbase: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 521b619acdc8f1f5acdac15b84f81fd9515b2aff\nconfig: i386-randconfig-a012-20201110 (attached as .config)\ncompiler: gcc-9 (Debian 9.3.0-15) 9.3.0\nreproduce (this is a W=1 build):\n # https://github.com/0day-ci/linux/commit/879dffec30f6576b5fdea872e5d3c71965f902ca\n git remote add linux-review https://github.com/0day-ci/linux\n git fetch --no-tags linux-review Vincent-Mailhol/can-usb-etas_es58X-add-support-for-ETAS-ES58X-CAN-USB-interfaces/20201109-094004\n git checkout 879dffec30f6576b5fdea872e5d3c71965f902ca\n # save the attached .config to linux build tree\n make W=1 ARCH=i386 \n\nIf you fix the issue, kindly add following tag as appropriate\nReported-by: kernel test robot \n\nAll errors (new ones prefixed by >>):\n\n drivers/net/can/usb/etas_es58x/es58x_core.c: In function 'es58x_rx_can_msg':\n drivers/net/can/usb/etas_es58x/es58x_core.c:745:12: error: 'CAN_MAX_RAW_DLC' undeclared (first use in this function); did you mean 'CAN_MAX_DLC'?\n 745 | if (dlc > CAN_MAX_RAW_DLC) {\n | ^~~~~~~~~~~~~~~\n | CAN_MAX_DLC\n drivers/net/can/usb/etas_es58x/es58x_core.c:745:12: note: each undeclared identifier is reported only once for each function it appears in\n drivers/net/can/usb/etas_es58x/es58x_core.c:756:9: error: implicit declaration of function 'can_get_cc_len'; did you mean 'can_get_echo_skb'? [-Werror=implicit-function-declaration]\n 756 | len = can_get_cc_len(dlc);\n | ^~~~~~~~~~~~~~\n | can_get_echo_skb\n drivers/net/can/usb/etas_es58x/es58x_core.c:775:6: error: 'struct can_frame' has no member named 'len8_dlc'\n 775 | ccf->len8_dlc = can_get_len8_dlc(es58x_priv(netdev)->can.ctrlmode,\n | ^~\n>> drivers/net/can/usb/etas_es58x/es58x_core.c:775:19: error: implicit declaration of function 'can_get_len8_dlc'; did you mean 'can_len2dlc'? [-Werror=implicit-function-declaration]\n 775 | ccf->len8_dlc = can_get_len8_dlc(es58x_priv(netdev)->can.ctrlmode,\n | ^~~~~~~~~~~~~~~~\n | can_len2dlc\n cc1: some warnings being treated as errors\n--\n drivers/net/can/usb/etas_es58x/es581_4.c: In function 'es581_4_tx_can_msg':\n drivers/net/can/usb/etas_es58x/es581_4.c:385:20: error: implicit declaration of function 'can_get_cc_dlc'; did you mean 'can_get_echo_skb'? [-Werror=implicit-function-declaration]\n 385 | tx_can_msg->dlc = can_get_cc_dlc(priv->can.ctrlmode,\n | ^~~~~~~~~~~~~~\n | can_get_echo_skb\n>> drivers/net/can/usb/etas_es58x/es581_4.c:386:9: error: 'struct can_frame' has no member named 'len'\n 386 | cf->len, cf->len8_dlc);\n | ^~\n drivers/net/can/usb/etas_es58x/es581_4.c:386:18: error: 'struct can_frame' has no member named 'len8_dlc'\n 386 | cf->len, cf->len8_dlc);\n | ^~\n In file included from arch/x86/include/asm/string.h:3,\n from include/linux/string.h:20,\n from include/linux/uuid.h:12,\n from include/linux/mod_devicetable.h:13,\n from include/linux/usb.h:5,\n from drivers/net/can/usb/etas_es58x/es58x_core.h:16,\n from drivers/net/can/usb/etas_es58x/es581_4.c:15:\n drivers/net/can/usb/etas_es58x/es581_4.c:388:39: error: 'struct can_frame' has no member named 'len'\n 388 | memcpy(tx_can_msg->data, cf->data, cf->len);\n | ^~\n arch/x86/include/asm/string_32.h:182:48: note: in definition of macro 'memcpy'\n 182 | #define memcpy(t, f, n) __builtin_memcpy(t, f, n)\n | ^\n In file included from :\n drivers/net/can/usb/etas_es58x/es581_4.c:30:29: error: implicit declaration of function 'can_get_cc_len'; did you mean 'can_get_echo_skb'? [-Werror=implicit-function-declaration]\n 30 | offsetof(typeof(msg), data[can_get_cc_len((msg).dlc)])\n | ^~~~~~~~~~~~~~\n include/linux/compiler_types.h:135:57: note: in definition of macro '__compiler_offsetof'\n 135 | #define __compiler_offsetof(a, b) __builtin_offsetof(a, b)\n | ^\n drivers/net/can/usb/etas_es58x/es581_4.c:30:2: note: in expansion of macro 'offsetof'\n 30 | offsetof(typeof(msg), data[can_get_cc_len((msg).dlc)])\n | ^~~~~~~~\n drivers/net/can/usb/etas_es58x/es581_4.c:392:13: note: in expansion of macro 'es581_4_sizeof_rx_tx_msg'\n 392 | msg_len += es581_4_sizeof_rx_tx_msg(*tx_can_msg);\n | ^~~~~~~~~~~~~~~~~~~~~~~~\n drivers/net/can/usb/etas_es58x/es581_4.c: At top level:\n>> drivers/net/can/usb/etas_es58x/es581_4.c:517:30: error: 'CAN_CTRLMODE_CC_LEN8_DLC' undeclared here (not in a function); did you mean 'CAN_CTRLMODE_LISTENONLY'?\n 517 | CAN_CTRLMODE_LOOPBACK | CAN_CTRLMODE_CC_LEN8_DLC,\n | ^~~~~~~~~~~~~~~~~~~~~~~~\n | CAN_CTRLMODE_LISTENONLY\n cc1: some warnings being treated as errors\n--\n drivers/net/can/usb/etas_es58x/es58x_fd.c: In function 'es58x_fd_rx_can_msg':\n>> drivers/net/can/usb/etas_es58x/es58x_fd.c:36:3: error: implicit declaration of function 'can_get_cc_len'; did you mean 'can_get_echo_skb'? [-Werror=implicit-function-declaration]\n 36 | can_get_cc_len(__msg.dlc); \\\n | ^~~~~~~~~~~~~~\n drivers/net/can/usb/etas_es58x/es58x_fd.c:119:24: note: in expansion of macro 'es58x_fd_sizeof_rx_tx_msg'\n 119 | u16 rx_can_msg_len = es58x_fd_sizeof_rx_tx_msg(*rx_can_msg);\n | ^~~~~~~~~~~~~~~~~~~~~~~~~\n drivers/net/can/usb/etas_es58x/es58x_fd.c: In function 'es58x_fd_tx_can_msg':\n drivers/net/can/usb/etas_es58x/es58x_fd.c:371:23: error: 'struct can_frame' has no member named 'len'\n 371 | tx_can_msg->len = cf->len;\n | ^~\n drivers/net/can/usb/etas_es58x/es58x_fd.c:373:21: error: implicit declaration of function 'can_get_cc_dlc'; did you mean 'can_get_echo_skb'? [-Werror=implicit-function-declaration]\n 373 | tx_can_msg->dlc = can_get_cc_dlc(priv->can.ctrlmode,\n | ^~~~~~~~~~~~~~\n | can_get_echo_skb\n drivers/net/can/usb/etas_es58x/es58x_fd.c:374:10: error: 'struct can_frame' has no member named 'len'\n 374 | cf->len, cf->len8_dlc);\n | ^~\n drivers/net/can/usb/etas_es58x/es58x_fd.c:374:19: error: 'struct can_frame' has no member named 'len8_dlc'\n 374 | cf->len, cf->len8_dlc);\n | ^~\n In file included from arch/x86/include/asm/string.h:3,\n from include/linux/string.h:20,\n from include/linux/uuid.h:12,\n from include/linux/mod_devicetable.h:13,\n from include/linux/usb.h:5,\n from drivers/net/can/usb/etas_es58x/es58x_core.h:16,\n from drivers/net/can/usb/etas_es58x/es58x_fd.c:17:\n drivers/net/can/usb/etas_es58x/es58x_fd.c:375:39: error: 'struct can_frame' has no member named 'len'\n 375 | memcpy(tx_can_msg->data, cf->data, cf->len);\n | ^~\n arch/x86/include/asm/string_32.h:182:48: note: in definition of macro 'memcpy'\n 182 | #define memcpy(t, f, n) __builtin_memcpy(t, f, n)\n | ^\n drivers/net/can/usb/etas_es58x/es58x_fd.c: At top level:\n drivers/net/can/usb/etas_es58x/es58x_fd.c:618:6: error: 'CAN_CTRLMODE_CC_LEN8_DLC' undeclared here (not in a function); did you mean 'CAN_CTRLMODE_LISTENONLY'?\n 618 | CAN_CTRLMODE_CC_LEN8_DLC,\n | ^~~~~~~~~~~~~~~~~~~~~~~~\n | CAN_CTRLMODE_LISTENONLY\n cc1: some warnings being treated as errors\n\nvim +775 drivers/net/can/usb/etas_es58x/es58x_core.c\n\n 718\t\n 719\t/**\n 720\t * es58x_rx_can_msg() - Handle a received a CAN message.\n 721\t * @netdev: CAN network device.\n 722\t * @timestamp: Hardware time stamp (only relevant in rx branches).\n 723\t * @data: CAN payload.\n 724\t * @can_id: CAN ID.\n 725\t * @es58x_flags: Please refer to enum es58x_flag.\n 726\t * @dlc: Data Length Code (raw value).\n 727\t *\n 728\t * Fill up a CAN skb and post it.\n 729\t *\n 730\t * This function handles the case where the DLC of a classical CAN\n 731\t * frame is greater than CAN_MAX_DLEN (c.f. the len8_dlc field of\n 732\t * struct can_frame).\n 733\t *\n 734\t * Return: zero on success.\n 735\t */\n 736\tint es58x_rx_can_msg(struct net_device *netdev, u64 timestamp, const u8 *data,\n 737\t\t\t canid_t can_id, enum es58x_flag es58x_flags, u8 dlc)\n 738\t{\n 739\t\tstruct canfd_frame *cfd;\n 740\t\tstruct can_frame *ccf;\n 741\t\tstruct sk_buff *skb;\n 742\t\tu8 len;\n 743\t\tbool is_can_fd = !!(es58x_flags & ES58X_FLAG_FD_DATA);\n 744\t\n 745\t\tif (dlc > CAN_MAX_RAW_DLC) {\n 746\t\t\tnetdev_err(netdev,\n 747\t\t\t\t \"%s: DLC is %d but maximum should be %d\\n\",\n 748\t\t\t\t __func__, dlc, CAN_MAX_RAW_DLC);\n 749\t\t\treturn -EMSGSIZE;\n 750\t\t}\n 751\t\n 752\t\tif (is_can_fd) {\n 753\t\t\tlen = can_dlc2len(dlc);\n 754\t\t\tskb = alloc_canfd_skb(netdev, &cfd);\n 755\t\t} else {\n 756\t\t\tlen = can_get_cc_len(dlc);\n 757\t\t\tskb = alloc_can_skb(netdev, &ccf);\n 758\t\t\tcfd = (struct canfd_frame *)ccf;\n 759\t\t}\n 760\t\n 761\t\tif (!skb) {\n 762\t\t\tnetdev->stats.rx_dropped++;\n 763\t\t\treturn -ENOMEM;\n 764\t\t}\n 765\t\tcfd->can_id = can_id;\n 766\t\tcfd->len = len;\n 767\t\tif (es58x_flags & ES58X_FLAG_EFF)\n 768\t\t\tcfd->can_id |= CAN_EFF_FLAG;\n 769\t\tif (is_can_fd) {\n 770\t\t\tif (es58x_flags & ES58X_FLAG_FD_BRS)\n 771\t\t\t\tcfd->flags |= CANFD_BRS;\n 772\t\t\tif (es58x_flags & ES58X_FLAG_FD_ESI)\n 773\t\t\t\tcfd->flags |= CANFD_ESI;\n 774\t\t} else {\n > 775\t\t\tccf->len8_dlc = can_get_len8_dlc(es58x_priv(netdev)->can.ctrlmode,\n 776\t\t\t\t\t\t\t len, dlc);\n 777\t\t\tif (es58x_flags & ES58X_FLAG_RTR) {\n 778\t\t\t\tccf->can_id |= CAN_RTR_FLAG;\n 779\t\t\t\tlen = 0;\n 780\t\t\t}\n 781\t\t}\n 782\t\tmemcpy(cfd->data, data, len);\n 783\t\tnetdev->stats.rx_packets++;\n 784\t\tnetdev->stats.rx_bytes += len;\n 785\t\n 786\t\tes58x_set_skb_timestamp(netdev, skb, timestamp);\n 787\t\tnetif_rx(skb);\n 788\t\n 789\t\tes58x_priv(netdev)->err_passive_before_rtx_success = 0;\n 790\t\n 791\t\treturn 0;\n 792\t}\n 793\t\n\n---\n0-DAY CI Kernel Test Service, Intel Corporation\nhttps://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org","headers":{"Return-Path":"","X-Original-To":"patchwork-incoming-netdev@ozlabs.org","Delivered-To":"patchwork-incoming-netdev@ozlabs.org","Authentication-Results":["ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org\n (client-ip=23.128.96.18; helo=vger.kernel.org;\n envelope-from=netdev-owner@vger.kernel.org; receiver=)","ozlabs.org;\n dmarc=fail (p=none dis=none) header.from=intel.com"],"Received":["from vger.kernel.org (vger.kernel.org [23.128.96.18])\n\tby ozlabs.org (Postfix) with ESMTP id 4CWCV66zwhz9sRR\n\tfor ;\n Wed, 11 Nov 2020 16:10:22 +1100 (AEDT)","(majordomo@vger.kernel.org) by vger.kernel.org via listexpand\n id S1725949AbgKKFKP (ORCPT\n );\n Wed, 11 Nov 2020 00:10:15 -0500","from mga06.intel.com ([134.134.136.31]:24675 \"EHLO mga06.intel.com\"\n rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP\n id S1725468AbgKKFKO (ORCPT );\n Wed, 11 Nov 2020 00:10:14 -0500","from fmsmga007.fm.intel.com ([10.253.24.52])\n by orsmga104.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384;\n 10 Nov 2020 21:10:09 -0800","from lkp-server02.sh.intel.com (HELO 14a21f3b7a6a) ([10.239.97.151])\n by fmsmga007.fm.intel.com with ESMTP; 10 Nov 2020 21:10:06 -0800","from kbuild by 14a21f3b7a6a with local (Exim 4.92)\n (envelope-from )\n id 1kciOU-00003h-0j; Wed, 11 Nov 2020 05:10:06 +0000"],"IronPort-SDR":["\n Pr0ZB49PNYPZlXKBckVmBIgI30ix47UyOdOc/R61l00X7mmn4XVeeKxhZuEdUFdhrNB1JApT0Z\n jBzSHbXoBhwA==","\n 9UqH6KNXIGq28ytM0hUKuctjCnu5OTy6awjfKwiWF0fXUcmaU5ianE671/RZCne3OPsVI+f538\n zNc3TkO2SkJw=="],"X-IronPort-AV":["E=McAfee;i=\"6000,8403,9801\"; a=\"231720343\"","E=Sophos;i=\"5.77,468,1596524400\";\n d=\"gz'50?scan'50,208,50\";a=\"231720343\"","E=Sophos;i=\"5.77,468,1596524400\";\n d=\"gz'50?scan'50,208,50\";a=\"308702826\""],"X-Amp-Result":"UNKNOWN","X-Amp-Original-Verdict":"FILE UNKNOWN","X-Amp-File-Uploaded":"False","X-ExtLoop1":"1","Date":"Wed, 11 Nov 2020 13:09:58 +0800","From":"kernel test robot ","To":"Vincent Mailhol ,\n linux-can@vger.kernel.org, Marc Kleine-Budde ","Cc":"kbuild-all@lists.01.org, Oliver Hartkopp ,\n Vincent Mailhol ,\n Arunachalam Santhanam ,\n Wolfgang Grandegger ,\n Jakub Kicinski ,\n Masahiro Yamada ,\n open list ,\n \"open list:NETWORKING DRIVERS\" ","Subject":"Re: [PATCH v5] can: usb: etas_es58X: add support for ETAS ES58X CAN\n USB interfaces","Message-ID":"<202011111346.5uOmotE1-lkp@intel.com>","References":"<20201107141837.277708-1-mailhol.vincent@wanadoo.fr>","MIME-Version":"1.0","Content-Type":"multipart/mixed; boundary=\"FL5UXtIhxfXey3p5\"","Content-Disposition":"inline","In-Reply-To":"<20201107141837.277708-1-mailhol.vincent@wanadoo.fr>","User-Agent":"Mutt/1.10.1 (2018-07-13)","Precedence":"bulk","List-ID":"","X-Mailing-List":"netdev@vger.kernel.org"}}]