UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

linux-can-next-for-6.6-20230803 

-----BEGIN PGP SIGNATURE-----
 
 iQFHBAABCgAxFiEEDs2BvajyNKlf9TJQvlAcSiqKBOgFAmTLXpwTHG1rbEBwZW5n
 dXRyb25peC5kZQAKCRC+UBxKKooE6NM8B/9M3zYbi7CedTzT4TW1i0PNjx5qBL7/
 o7YJg/pVbGSpX8sRFOlJB9K4JTH1GI+ziZ/+KIv5fJlyBMfArqNG64NyC3i5SL3R
 rPpLE3/w6OHk5fZuPYfOsdzf7KOsSnyqr2D2aFDKImrsNaqHIQWdNUBJcAuBG/Hm
 cfmbEOKsYq47eSDkE63aUzb1Ta2wf6lQN2+wVr1jRQIiO3/UEjJyu3mveujYbEVK
 JNOsMBuzx5Kz2bwul7ygKCRdULxT7LoopBg0jJksFY6DjEurG35r4FhOakacW0Jj
 yk+0qHiKdAFGGY2+AlYHt1Hh0eFzsUXBwhMvlZ/aVKXb1uZAZw1iQ/00
 =aQuE
 -----END PGP SIGNATURE-----

Merge tag 'linux-can-next-for-6.6-20230803' of git://git.kernel.org/pub/scm/linux/kernel/git/mkl/linux-can-next

Marc Kleine-Budde says:

====================
pull-request: can-next 2023-08-03

This is a pull request of 9 patches for net-next/master.

The 1st patch is by Ruan Jinjie, targets the flexcan driver, and
cleans up the error handling of platform_get_irq() in the
flexcan_probe() function.

Markus Schneider-Pargmann contributes 6 patches for the tcan4x5x M_CAN
driver, consisting of some cleanups, and adding support for the
tcan4552/4553 chips.

Another patch by Ruan Jinjie, that cleans up the error path of
platform_get_irq() in the c_can_plat_probe() function of the C_CAN
platform driver.

The last patch is by Frank Jungclaus and adds support for the
CAN-USB/3 and CAN FD to the ESD USB CAN driver.
================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2023-08-04 08:46:07 +01:00
parent 992725ff32 806e95aee5
commit f702dbbb9f
8 changed files with 397 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
Documentation/devicetree/bindings/net/can/tcan4x5x.txt
View File

@ -4,7 +4,10 @@ Texas Instruments TCAN4x5x CAN Controller
This file provides device node information for the TCAN4x5x interface contains.
Required properties:
- compatible: "ti,tcan4x5x"
- compatible:
"ti,tcan4552", "ti,tcan4x5x"
"ti,tcan4553", "ti,tcan4x5x" or
"ti,tcan4x5x"
- reg: 0
- #address-cells: 1
- #size-cells: 0
@ -21,8 +24,10 @@ Optional properties:
- reset-gpios: Hardwired output GPIO. If not defined then software
reset.
- device-state-gpios: Input GPIO that indicates if the device is in
a sleep state or if the device is active.
- device-wake-gpios: Wake up GPIO to wake up the TCAN device.
a sleep state or if the device is active. Not
available with tcan4552/4553.
- device-wake-gpios: Wake up GPIO to wake up the TCAN device. Not
available with tcan4552/4553.
Example:
tcan4x5x: tcan4x5x@0 {

4
drivers/net/can/c_can/c_can_platform.c
View File

@ -285,8 +285,8 @@ static int c_can_plat_probe(struct platform_device *pdev)
/* get the platform data */
irq = platform_get_irq(pdev, 0);
if (irq <= 0) {
ret = -ENODEV;
if (irq < 0) {
ret = irq;
goto exit;
}

12
drivers/net/can/flexcan/flexcan-core.c
View File

@ -2089,8 +2089,8 @@ static int flexcan_probe(struct platform_device *pdev)
}
irq = platform_get_irq(pdev, 0);
if (irq <= 0)
return -ENODEV;
if (irq < 0)
return irq;
regs = devm_platform_ioremap_resource(pdev, 0);
if (IS_ERR(regs))
@ -2167,13 +2167,13 @@ static int flexcan_probe(struct platform_device *pdev)
if (priv->devtype_data.quirks & FLEXCAN_QUIRK_NR_IRQ_3) {
priv->irq_boff = platform_get_irq(pdev, 1);
if (priv->irq_boff <= 0) {
err = -ENODEV;
if (priv->irq_boff < 0) {
err = priv->irq_boff;
goto failed_platform_get_irq;
}
priv->irq_err = platform_get_irq(pdev, 2);
if (priv->irq_err <= 0) {
err = -ENODEV;
if (priv->irq_err < 0) {
err = priv->irq_err;
goto failed_platform_get_irq;
}
}

16
drivers/net/can/m_can/m_can.c
View File

@ -1913,6 +1913,22 @@ static int register_m_can_dev(struct net_device *dev)
return register_candev(dev);
}
int m_can_check_mram_cfg(struct m_can_classdev *cdev, u32 mram_max_size)
{
u32 total_size;
total_size = cdev->mcfg[MRAM_TXB].off - cdev->mcfg[MRAM_SIDF].off +
cdev->mcfg[MRAM_TXB].num * TXB_ELEMENT_SIZE;
if (total_size > mram_max_size) {
dev_err(cdev->dev, "Total size of mram config(%u) exceeds mram(%u)\n",
total_size, mram_max_size);
return -EINVAL;
}
return 0;
}
EXPORT_SYMBOL_GPL(m_can_check_mram_cfg);
static void m_can_of_parse_mram(struct m_can_classdev *cdev,
const u32 *mram_config_vals)
{

1
drivers/net/can/m_can/m_can.h
View File

@ -103,6 +103,7 @@ int m_can_class_register(struct m_can_classdev *cdev);
void m_can_class_unregister(struct m_can_classdev *cdev);
int m_can_class_get_clocks(struct m_can_classdev *cdev);
int m_can_init_ram(struct m_can_classdev *priv);
int m_can_check_mram_cfg(struct m_can_classdev *cdev, u32 mram_max_size);
int m_can_class_suspend(struct device *dev);
int m_can_class_resume(struct device *dev);

142
drivers/net/can/m_can/tcan4x5x-core.c
View File

@ -6,8 +6,9 @@
#define TCAN4X5X_EXT_CLK_DEF 40000000
#define TCAN4X5X_DEV_ID0 0x00
#define TCAN4X5X_DEV_ID1 0x04
#define TCAN4X5X_DEV_ID1 0x00
#define TCAN4X5X_DEV_ID1_TCAN 0x4e414354 /* ASCII TCAN */
#define TCAN4X5X_DEV_ID2 0x04
#define TCAN4X5X_REV 0x08
#define TCAN4X5X_STATUS 0x0C
#define TCAN4X5X_ERROR_STATUS_MASK 0x10
@ -80,6 +81,7 @@
TCAN4X5X_MCAN_IR_RF1F)
#define TCAN4X5X_MRAM_START 0x8000
#define TCAN4X5X_MRAM_SIZE 0x800
#define TCAN4X5X_MCAN_OFFSET 0x1000
#define TCAN4X5X_CLEAR_ALL_INT 0xffffffff
@ -102,6 +104,37 @@
#define TCAN4X5X_WD_3_S_TIMER BIT(29)
#define TCAN4X5X_WD_6_S_TIMER (BIT(28) | BIT(29))
struct tcan4x5x_version_info {
const char *name;
u32 id2_register;
bool has_wake_pin;
bool has_state_pin;
};
enum {
TCAN4552 = 0,
TCAN4553,
TCAN4X5X,
};
static const struct tcan4x5x_version_info tcan4x5x_versions[] = {
[TCAN4552] = {
.name = "4552",
.id2_register = 0x32353534,
},
[TCAN4553] = {
.name = "4553",
.id2_register = 0x32353534,
},
/* generic version with no id2_register at the end */
[TCAN4X5X] = {
.name = "generic",
.has_wake_pin = true,
.has_state_pin = true,
},
};
static inline struct tcan4x5x_priv *cdev_to_priv(struct m_can_classdev *cdev)
{
return container_of(cdev, struct tcan4x5x_priv, cdev);
@ -253,18 +286,53 @@ static int tcan4x5x_disable_state(struct m_can_classdev *cdev)
TCAN4X5X_DISABLE_INH_MSK, 0x01);
}
static int tcan4x5x_get_gpios(struct m_can_classdev *cdev)
static const struct tcan4x5x_version_info
*tcan4x5x_find_version(struct tcan4x5x_priv *priv)
{
u32 val;
int ret;
ret = regmap_read(priv->regmap, TCAN4X5X_DEV_ID1, &val);
if (ret)
return ERR_PTR(ret);
if (val != TCAN4X5X_DEV_ID1_TCAN) {
dev_err(&priv->spi->dev, "Not a tcan device %x\n", val);
return ERR_PTR(-ENODEV);
}
ret = regmap_read(priv->regmap, TCAN4X5X_DEV_ID2, &val);
if (ret)
return ERR_PTR(ret);
for (int i = 0; i != ARRAY_SIZE(tcan4x5x_versions); ++i) {
const struct tcan4x5x_version_info *vinfo = &tcan4x5x_versions[i];
if (!vinfo->id2_register || val == vinfo->id2_register) {
dev_info(&priv->spi->dev, "Detected TCAN device version %s\n",
vinfo->name);
return vinfo;
}
}
return &tcan4x5x_versions[TCAN4X5X];
}
static int tcan4x5x_get_gpios(struct m_can_classdev *cdev,
const struct tcan4x5x_version_info *version_info)
{
struct tcan4x5x_priv *tcan4x5x = cdev_to_priv(cdev);
int ret;
tcan4x5x->device_wake_gpio = devm_gpiod_get(cdev->dev, "device-wake",
GPIOD_OUT_HIGH);
if (IS_ERR(tcan4x5x->device_wake_gpio)) {
if (PTR_ERR(tcan4x5x->device_wake_gpio) == -EPROBE_DEFER)
return -EPROBE_DEFER;
if (version_info->has_wake_pin) {
tcan4x5x->device_wake_gpio = devm_gpiod_get(cdev->dev, "device-wake",
GPIOD_OUT_HIGH);
if (IS_ERR(tcan4x5x->device_wake_gpio)) {
if (PTR_ERR(tcan4x5x->device_wake_gpio) == -EPROBE_DEFER)
return -EPROBE_DEFER;
tcan4x5x_disable_wake(cdev);
tcan4x5x_disable_wake(cdev);
}
}
tcan4x5x->reset_gpio = devm_gpiod_get_optional(cdev->dev, "reset",
@ -276,12 +344,14 @@ static int tcan4x5x_get_gpios(struct m_can_classdev *cdev)
if (ret)
return ret;
tcan4x5x->device_state_gpio = devm_gpiod_get_optional(cdev->dev,
"device-state",
GPIOD_IN);
if (IS_ERR(tcan4x5x->device_state_gpio)) {
tcan4x5x->device_state_gpio = NULL;
tcan4x5x_disable_state(cdev);
if (version_info->has_state_pin) {
tcan4x5x->device_state_gpio = devm_gpiod_get_optional(cdev->dev,
"device-state",
GPIOD_IN);
if (IS_ERR(tcan4x5x->device_state_gpio)) {
tcan4x5x->device_state_gpio = NULL;
tcan4x5x_disable_state(cdev);
}
}
return 0;
@ -298,6 +368,7 @@ static struct m_can_ops tcan4x5x_ops = {
static int tcan4x5x_can_probe(struct spi_device *spi)
{
const struct tcan4x5x_version_info *version_info;
struct tcan4x5x_priv *priv;
struct m_can_classdev *mcan_class;
int freq, ret;
@ -307,6 +378,10 @@ static int tcan4x5x_can_probe(struct spi_device *spi)
if (!mcan_class)
return -ENOMEM;
ret = m_can_check_mram_cfg(mcan_class, TCAN4X5X_MRAM_SIZE);
if (ret)
goto out_m_can_class_free_dev;
priv = cdev_to_priv(mcan_class);
priv->power = devm_regulator_get_optional(&spi->dev, "vsup");
@ -327,6 +402,8 @@ static int tcan4x5x_can_probe(struct spi_device *spi)
/* Sanity check */
if (freq < 20000000 || freq > TCAN4X5X_EXT_CLK_DEF) {
dev_err(&spi->dev, "Clock frequency is out of supported range %d\n",
freq);
ret = -ERANGE;
goto out_m_can_class_free_dev;
}
@ -345,28 +422,49 @@ static int tcan4x5x_can_probe(struct spi_device *spi)
/* Configure the SPI bus */
spi->bits_per_word = 8;
ret = spi_setup(spi);
if (ret)
if (ret) {
dev_err(&spi->dev, "SPI setup failed %pe\n", ERR_PTR(ret));
goto out_m_can_class_free_dev;
}
ret = tcan4x5x_regmap_init(priv);
if (ret)
if (ret) {
dev_err(&spi->dev, "regmap init failed %pe\n", ERR_PTR(ret));
goto out_m_can_class_free_dev;
}
ret = tcan4x5x_power_enable(priv->power, 1);
if (ret)
if (ret) {
dev_err(&spi->dev, "Enabling regulator failed %pe\n",
ERR_PTR(ret));
goto out_m_can_class_free_dev;
}
ret = tcan4x5x_get_gpios(mcan_class);
if (ret)
version_info = tcan4x5x_find_version(priv);
if (IS_ERR(version_info)) {
ret = PTR_ERR(version_info);
goto out_power;
}
ret = tcan4x5x_get_gpios(mcan_class, version_info);
if (ret) {
dev_err(&spi->dev, "Getting gpios failed %pe\n", ERR_PTR(ret));
goto out_power;
}
ret = tcan4x5x_init(mcan_class);
if (ret)
if (ret) {
dev_err(&spi->dev, "tcan initialization failed %pe\n",
ERR_PTR(ret));
goto out_power;
}
ret = m_can_class_register(mcan_class);
if (ret)
if (ret) {
dev_err(&spi->dev, "Failed registering m_can device %pe\n",
ERR_PTR(ret));
goto out_power;
}
netdev_info(mcan_class->net, "TCAN4X5X successfully initialized.\n");
return 0;

1
drivers/net/can/m_can/tcan4x5x-regmap.c
View File

@ -95,7 +95,6 @@ static const struct regmap_range tcan4x5x_reg_table_wr_range[] = {
regmap_reg_range(0x000c, 0x0010),
/* Device configuration registers and Interrupt Flags*/
regmap_reg_range(0x0800, 0x080c),
regmap_reg_range(0x0814, 0x0814),
regmap_reg_range(0x0820, 0x0820),
regmap_reg_range(0x0830, 0x0830),
/* M_CAN */

275
drivers/net/can/usb/esd_usb.c
View File

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* CAN driver for esd electronics gmbh CAN-USB/2 and CAN-USB/Micro
* CAN driver for esd electronics gmbh CAN-USB/2, CAN-USB/3 and CAN-USB/Micro
*
* Copyright (C) 2010-2012 esd electronic system design gmbh, Matthias Fuchs <socketcan@esd.eu>
* Copyright (C) 2022-2023 esd electronics gmbh, Frank Jungclaus <frank.jungclaus@esd.eu>
@ -19,17 +19,19 @@
MODULE_AUTHOR("Matthias Fuchs <socketcan@esd.eu>");
MODULE_AUTHOR("Frank Jungclaus <frank.jungclaus@esd.eu>");
MODULE_DESCRIPTION("CAN driver for esd electronics gmbh CAN-USB/2 and CAN-USB/Micro interfaces");
MODULE_DESCRIPTION("CAN driver for esd electronics gmbh CAN-USB/2, CAN-USB/3 and CAN-USB/Micro interfaces");
MODULE_LICENSE("GPL v2");
/* USB vendor and product ID */
#define ESD_USB_ESDGMBH_VENDOR_ID 0x0ab4
#define ESD_USB_CANUSB2_PRODUCT_ID 0x0010
#define ESD_USB_CANUSBM_PRODUCT_ID 0x0011
#define ESD_USB_CANUSB3_PRODUCT_ID 0x0014
/* CAN controller clock frequencies */
#define ESD_USB_2_CAN_CLOCK (60 * MEGA) /* Hz */
#define ESD_USB_M_CAN_CLOCK (36 * MEGA) /* Hz */
#define ESD_USB_3_CAN_CLOCK (80 * MEGA) /* Hz */
/* Maximum number of CAN nets */
#define ESD_USB_MAX_NETS 2
@ -44,6 +46,9 @@ MODULE_LICENSE("GPL v2");
/* esd CAN message flags - dlc field */
#define ESD_USB_RTR BIT(4)
#define ESD_USB_NO_BRS BIT(4)
#define ESD_USB_ESI BIT(5)
#define ESD_USB_FD BIT(7)
/* esd CAN message flags - id field */
#define ESD_USB_EXTID BIT(29)
@ -65,6 +70,9 @@ MODULE_LICENSE("GPL v2");
#define ESD_USB_M_SJW_SHIFT 24
#define ESD_USB_TRIPLE_SAMPLES BIT(23)
/* Transmitter Delay Compensation */
#define ESD_USB_3_TDC_MODE_AUTO 0
/* esd IDADD message */
#define ESD_USB_ID_ENABLE BIT(7)
#define ESD_USB_MAX_ID_SEGMENT 64
@ -88,6 +96,21 @@ MODULE_LICENSE("GPL v2");
#define ESD_USB_MAX_RX_URBS 4
#define ESD_USB_MAX_TX_URBS 16 /* must be power of 2 */
/* Modes for CAN-USB/3, to be used for esd_usb_3_set_baudrate_msg_x.mode */
#define ESD_USB_3_BAUDRATE_MODE_DISABLE 0 /* remove from bus */
#define ESD_USB_3_BAUDRATE_MODE_INDEX 1 /* ESD (CiA) bit rate idx */
#define ESD_USB_3_BAUDRATE_MODE_BTR_CTRL 2 /* BTR values (controller)*/
#define ESD_USB_3_BAUDRATE_MODE_BTR_CANONICAL 3 /* BTR values (canonical) */
#define ESD_USB_3_BAUDRATE_MODE_NUM 4 /* numerical bit rate */
#define ESD_USB_3_BAUDRATE_MODE_AUTOBAUD 5 /* autobaud */
/* Flags for CAN-USB/3, to be used for esd_usb_3_set_baudrate_msg_x.flags */
#define ESD_USB_3_BAUDRATE_FLAG_FD BIT(0) /* enable CAN FD mode */
#define ESD_USB_3_BAUDRATE_FLAG_LOM BIT(1) /* enable listen only mode */
#define ESD_USB_3_BAUDRATE_FLAG_STM BIT(2) /* enable self test mode */
#define ESD_USB_3_BAUDRATE_FLAG_TRS BIT(3) /* enable triple sampling */
#define ESD_USB_3_BAUDRATE_FLAG_TXP BIT(4) /* enable transmit pause */
struct esd_usb_header_msg {
u8 len; /* total message length in 32bit words */
u8 cmd;
@ -122,6 +145,7 @@ struct esd_usb_rx_msg {
__le32 id; /* upper 3 bits contain flags */
union {
u8 data[CAN_MAX_DLEN];
u8 data_fd[CANFD_MAX_DLEN];
struct {
u8 status; /* CAN Controller Status */
u8 ecc; /* Error Capture Register */
@ -138,7 +162,10 @@ struct esd_usb_tx_msg {
u8 dlc;
u32 hnd; /* opaque handle, not used by device */
__le32 id; /* upper 3 bits contain flags */
u8 data[CAN_MAX_DLEN];
union {
u8 data[CAN_MAX_DLEN];
u8 data_fd[CANFD_MAX_DLEN];
};
};
struct esd_usb_tx_done_msg {
@ -166,6 +193,50 @@ struct esd_usb_set_baudrate_msg {
__le32 baud;
};
/* CAN-USB/3 baudrate configuration, used for nominal as well as for data bit rate */
struct esd_usb_3_baudrate_cfg {
__le16 brp; /* bit rate pre-scaler */
__le16 tseg1; /* time segment before sample point */
__le16 tseg2; /* time segment after sample point */
__le16 sjw; /* synchronization jump Width */
};
/* In principle, the esd CAN-USB/3 supports Transmitter Delay Compensation (TDC),
* but currently only the automatic TDC mode is supported by this driver.
* An implementation for manual TDC configuration will follow.
*
* For information about struct esd_usb_3_tdc_cfg, see
* NTCAN Application Developers Manual, 6.2.25 NTCAN_TDC_CFG + related chapters
* https://esd.eu/fileadmin/esd/docs/manuals/NTCAN_Part1_Function_API_Manual_en_56.pdf
*/
struct esd_usb_3_tdc_cfg {
u8 tdc_mode; /* transmitter delay compensation mode */
u8 ssp_offset; /* secondary sample point offset in mtq */
s8 ssp_shift; /* secondary sample point shift in mtq */
u8 tdc_filter; /* TDC filter in mtq */
};
/* Extended version of the above set_baudrate_msg for a CAN-USB/3
* to define the CAN bit timing configuration of the CAN controller in
* CAN FD mode as well as in Classical CAN mode.
*
* The payload of this command is a NTCAN_BAUDRATE_X structure according to
* esd electronics gmbh, NTCAN Application Developers Manual, 6.2.15 NTCAN_BAUDRATE_X
* https://esd.eu/fileadmin/esd/docs/manuals/NTCAN_Part1_Function_API_Manual_en_56.pdf
*/
struct esd_usb_3_set_baudrate_msg_x {
u8 len; /* total message length in 32bit words */
u8 cmd;
u8 net;
u8 rsvd; /*reserved */
/* Payload ... */
__le16 mode; /* mode word, see ESD_USB_3_BAUDRATE_MODE_xxx */
__le16 flags; /* control flags, see ESD_USB_3_BAUDRATE_FLAG_xxx */
struct esd_usb_3_tdc_cfg tdc; /* TDC configuration */
struct esd_usb_3_baudrate_cfg nom; /* nominal bit rate */
struct esd_usb_3_baudrate_cfg data; /* data bit rate */
};
/* Main message type used between library and application */
union __packed esd_usb_msg {
struct esd_usb_header_msg hdr;
@ -175,12 +246,14 @@ union __packed esd_usb_msg {
struct esd_usb_tx_msg tx;
struct esd_usb_tx_done_msg txdone;
struct esd_usb_set_baudrate_msg setbaud;
struct esd_usb_3_set_baudrate_msg_x setbaud_x;
struct esd_usb_id_filter_msg filter;
};
static struct usb_device_id esd_usb_table[] = {
{USB_DEVICE(ESD_USB_ESDGMBH_VENDOR_ID, ESD_USB_CANUSB2_PRODUCT_ID)},
{USB_DEVICE(ESD_USB_ESDGMBH_VENDOR_ID, ESD_USB_CANUSBM_PRODUCT_ID)},
{USB_DEVICE(ESD_USB_ESDGMBH_VENDOR_ID, ESD_USB_CANUSB3_PRODUCT_ID)},
{}
};
MODULE_DEVICE_TABLE(usb, esd_usb_table);
@ -321,9 +394,10 @@ static void esd_usb_rx_can_msg(struct esd_usb_net_priv *priv,
{
struct net_device_stats *stats = &priv->netdev->stats;
struct can_frame *cf;
struct canfd_frame *cfd;
struct sk_buff *skb;
int i;
u32 id;
u8 len;
if (!netif_device_present(priv->netdev))
return;
@ -333,27 +407,42 @@ static void esd_usb_rx_can_msg(struct esd_usb_net_priv *priv,
if (id & ESD_USB_EVENT) {
esd_usb_rx_event(priv, msg);
} else {
skb = alloc_can_skb(priv->netdev, &cf);
if (msg->rx.dlc & ESD_USB_FD) {
skb = alloc_canfd_skb(priv->netdev, &cfd);
} else {
skb = alloc_can_skb(priv->netdev, &cf);
cfd = (struct canfd_frame *)cf;
}
if (skb == NULL) {
stats->rx_dropped++;
return;
}
cf->can_id = id & ESD_USB_IDMASK;
can_frame_set_cc_len(cf, msg->rx.dlc & ~ESD_USB_RTR,
priv->can.ctrlmode);
cfd->can_id = id & ESD_USB_IDMASK;
if (msg->rx.dlc & ESD_USB_FD) {
/* masking by 0x0F is already done within can_fd_dlc2len() */
cfd->len = can_fd_dlc2len(msg->rx.dlc);
len = cfd->len;
if ((msg->rx.dlc & ESD_USB_NO_BRS) == 0)
cfd->flags |= CANFD_BRS;
if (msg->rx.dlc & ESD_USB_ESI)
cfd->flags |= CANFD_ESI;
} else {
can_frame_set_cc_len(cf, msg->rx.dlc & ~ESD_USB_RTR, priv->can.ctrlmode);
len = cf->len;
if (msg->rx.dlc & ESD_USB_RTR) {
cf->can_id |= CAN_RTR_FLAG;
len = 0;
}
}
if (id & ESD_USB_EXTID)
cf->can_id |= CAN_EFF_FLAG;
cfd->can_id |= CAN_EFF_FLAG;
if (msg->rx.dlc & ESD_USB_RTR) {
cf->can_id |= CAN_RTR_FLAG;
} else {
for (i = 0; i < cf->len; i++)
cf->data[i] = msg->rx.data[i];
stats->rx_bytes += cf->len;
}
memcpy(cfd->data, msg->rx.data_fd, len);
stats->rx_bytes += len;
stats->rx_packets++;
netif_rx(skb);
@ -728,7 +817,7 @@ static netdev_tx_t esd_usb_start_xmit(struct sk_buff *skb,
struct esd_usb *dev = priv->usb;
struct esd_tx_urb_context *context = NULL;
struct net_device_stats *stats = &netdev->stats;
struct can_frame *cf = (struct can_frame *)skb->data;
struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
union esd_usb_msg *msg;
struct urb *urb;
u8 *buf;
@ -762,20 +851,29 @@ static netdev_tx_t esd_usb_start_xmit(struct sk_buff *skb,
msg->hdr.len = offsetof(struct esd_usb_tx_msg, data) / sizeof(u32);
msg->hdr.cmd = ESD_USB_CMD_CAN_TX;
msg->tx.net = priv->index;
msg->tx.dlc = can_get_cc_dlc(cf, priv->can.ctrlmode);
msg->tx.id = cpu_to_le32(cf->can_id & CAN_ERR_MASK);
if (cf->can_id & CAN_RTR_FLAG)
msg->tx.dlc |= ESD_USB_RTR;
if (can_is_canfd_skb(skb)) {
msg->tx.dlc = can_fd_len2dlc(cfd->len);
msg->tx.dlc |= ESD_USB_FD;
if (cf->can_id & CAN_EFF_FLAG)
if ((cfd->flags & CANFD_BRS) == 0)
msg->tx.dlc |= ESD_USB_NO_BRS;
} else {
msg->tx.dlc = can_get_cc_dlc((struct can_frame *)cfd, priv->can.ctrlmode);
if (cfd->can_id & CAN_RTR_FLAG)
msg->tx.dlc |= ESD_USB_RTR;
}
msg->tx.id = cpu_to_le32(cfd->can_id & CAN_ERR_MASK);
if (cfd->can_id & CAN_EFF_FLAG)
msg->tx.id |= cpu_to_le32(ESD_USB_EXTID);
for (i = 0; i < cf->len; i++)
msg->tx.data[i] = cf->data[i];
memcpy(msg->tx.data_fd, cfd->data, cfd->len);
/* round up, then divide by 4 to add the payload length as # of 32bit words */
msg->hdr.len += DIV_ROUND_UP(cf->len, sizeof(u32));
msg->hdr.len += DIV_ROUND_UP(cfd->len, sizeof(u32));
for (i = 0; i < ESD_USB_MAX_TX_URBS; i++) {
if (priv->tx_contexts[i].echo_index == ESD_USB_MAX_TX_URBS) {
@ -962,6 +1060,105 @@ static int esd_usb_2_set_bittiming(struct net_device *netdev)
return err;
}
/* Nominal bittiming constants, see
* Microchip SAM E70/S70/V70/V71, Data Sheet, Rev. G - 07/2022
* 48.6.8 MCAN Nominal Bit Timing and Prescaler Register
*/
static const struct can_bittiming_const esd_usb_3_nom_bittiming_const = {
.name = "esd_usb_3",
.tseg1_min = 2,
.tseg1_max = 256,
.tseg2_min = 2,
.tseg2_max = 128,
.sjw_max = 128,
.brp_min = 1,
.brp_max = 512,
.brp_inc = 1,
};
/* Data bittiming constants, see
* Microchip SAM E70/S70/V70/V71, Data Sheet, Rev. G - 07/2022
* 48.6.4 MCAN Data Bit Timing and Prescaler Register
*/
static const struct can_bittiming_const esd_usb_3_data_bittiming_const = {
.name = "esd_usb_3",
.tseg1_min = 2,
.tseg1_max = 32,
.tseg2_min = 1,
.tseg2_max = 16,
.sjw_max = 8,
.brp_min = 1,
.brp_max = 32,
.brp_inc = 1,
};
static int esd_usb_3_set_bittiming(struct net_device *netdev)
{
const struct can_bittiming_const *nom_btc = &esd_usb_3_nom_bittiming_const;
const struct can_bittiming_const *data_btc = &esd_usb_3_data_bittiming_const;
struct esd_usb_net_priv *priv = netdev_priv(netdev);
struct can_bittiming *nom_bt = &priv->can.bittiming;
struct can_bittiming *data_bt = &priv->can.data_bittiming;
struct esd_usb_3_set_baudrate_msg_x *baud_x;
union esd_usb_msg *msg;
u16 flags = 0;
int err;
msg = kmalloc(sizeof(*msg), GFP_KERNEL);
if (!msg)
return -ENOMEM;
baud_x = &msg->setbaud_x;
/* Canonical is the most reasonable mode for SocketCAN on CAN-USB/3 ... */
baud_x->mode = cpu_to_le16(ESD_USB_3_BAUDRATE_MODE_BTR_CANONICAL);
if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
flags |= ESD_USB_3_BAUDRATE_FLAG_LOM;
if (priv->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
flags |= ESD_USB_3_BAUDRATE_FLAG_TRS;
baud_x->nom.brp = cpu_to_le16(nom_bt->brp & (nom_btc->brp_max - 1));
baud_x->nom.sjw = cpu_to_le16(nom_bt->sjw & (nom_btc->sjw_max - 1));
baud_x->nom.tseg1 = cpu_to_le16((nom_bt->prop_seg + nom_bt->phase_seg1)
& (nom_btc->tseg1_max - 1));
baud_x->nom.tseg2 = cpu_to_le16(nom_bt->phase_seg2 & (nom_btc->tseg2_max - 1));
if (priv->can.ctrlmode & CAN_CTRLMODE_FD) {
baud_x->data.brp = cpu_to_le16(data_bt->brp & (data_btc->brp_max - 1));
baud_x->data.sjw = cpu_to_le16(data_bt->sjw & (data_btc->sjw_max - 1));
baud_x->data.tseg1 = cpu_to_le16((data_bt->prop_seg + data_bt->phase_seg1)
& (data_btc->tseg1_max - 1));
baud_x->data.tseg2 = cpu_to_le16(data_bt->phase_seg2 & (data_btc->tseg2_max - 1));
flags |= ESD_USB_3_BAUDRATE_FLAG_FD;
}
/* Currently this driver only supports the automatic TDC mode */
baud_x->tdc.tdc_mode = ESD_USB_3_TDC_MODE_AUTO;
baud_x->tdc.ssp_offset = 0;
baud_x->tdc.ssp_shift = 0;
baud_x->tdc.tdc_filter = 0;
baud_x->flags = cpu_to_le16(flags);
baud_x->net = priv->index;
baud_x->rsvd = 0;
/* set len as # of 32bit words */
msg->hdr.len = sizeof(struct esd_usb_3_set_baudrate_msg_x) / sizeof(u32);
msg->hdr.cmd = ESD_USB_CMD_SETBAUD;
netdev_dbg(netdev,
"ctrlmode=%#x/%#x, esd-net=%u, esd-mode=%#x, esd-flags=%#x\n",
priv->can.ctrlmode, priv->can.ctrlmode_supported,
priv->index, le16_to_cpu(baud_x->mode), flags);
err = esd_usb_send_msg(priv->usb, msg);
kfree(msg);
return err;
}
static int esd_usb_get_berr_counter(const struct net_device *netdev,
struct can_berr_counter *bec)
{
@ -1019,16 +1216,32 @@ static int esd_usb_probe_one_net(struct usb_interface *intf, int index)
CAN_CTRLMODE_CC_LEN8_DLC |
CAN_CTRLMODE_BERR_REPORTING;
if (le16_to_cpu(dev->udev->descriptor.idProduct) ==
ESD_USB_CANUSBM_PRODUCT_ID)
switch (le16_to_cpu(dev->udev->descriptor.idProduct)) {
case ESD_USB_CANUSB3_PRODUCT_ID:
priv->can.clock.freq = ESD_USB_3_CAN_CLOCK;
priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
priv->can.ctrlmode_supported |= CAN_CTRLMODE_FD;
priv->can.bittiming_const = &esd_usb_3_nom_bittiming_const;
priv->can.data_bittiming_const = &esd_usb_3_data_bittiming_const;
priv->can.do_set_bittiming = esd_usb_3_set_bittiming;
priv->can.do_set_data_bittiming = esd_usb_3_set_bittiming;
break;
case ESD_USB_CANUSBM_PRODUCT_ID:
priv->can.clock.freq = ESD_USB_M_CAN_CLOCK;
else {
priv->can.bittiming_const = &esd_usb_2_bittiming_const;
priv->can.do_set_bittiming = esd_usb_2_set_bittiming;
break;
case ESD_USB_CANUSB2_PRODUCT_ID:
default:
priv->can.clock.freq = ESD_USB_2_CAN_CLOCK;
priv->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
priv->can.bittiming_const = &esd_usb_2_bittiming_const;
priv->can.do_set_bittiming = esd_usb_2_set_bittiming;
break;
}
priv->can.bittiming_const = &esd_usb_2_bittiming_const;
priv->can.do_set_bittiming = esd_usb_2_set_bittiming;
priv->can.do_set_mode = esd_usb_set_mode;
priv->can.do_get_berr_counter = esd_usb_get_berr_counter;