2022-07-26 21:06:03

by Dario Binacchi

[permalink] [raw]
Subject: [RFC PATCH v3 0/9] can: slcan: extend supported features (step 2)

With this series I try to finish the task, started with the series [1],
of completely removing the dependency of the slcan driver from the
userspace slcand/slcan_attach applications.

The series also contains patches that remove the legacy stuff (slcan_devs,
SLCAN_MAGIC, ...) and do some module cleanup.

The series has been created on top of the patches:

can: slcan: convert comments to network style comments
can: slcan: slcan_init() convert printk(LEVEL ...) to pr_level()
can: slcan: fix whitespace issues
can: slcan: convert comparison to NULL into !val
can: slcan: clean up if/else
can: slcan: use scnprintf() as a hardening measure
can: slcan: do not report txerr and rxerr during bus-off
can: slcan: do not sleep with a spin lock held

applied to linux-next.

[1] https://lore.kernel.org/all/[email protected]/

Changes in v3:
- Update the commit message.
- Use 1 space in front of the =.
- Put the series as RFC again.
- Pick up the patch "can: slcan: use KBUILD_MODNAME and define pr_fmt to replace hardcoded names".
- Add the patch "ethtool: add support to get/set CAN bit time register"
to the series.
- Add the patch "can: slcan: add support to set bit time register (btr)"
to the series.
- Replace the link https://marc.info/?l=linux-can&m=165806705927851&w=2 with
https://lore.kernel.org/all/[email protected].
- Add the `Suggested-by' tag.

Changes in v2:
- Re-add headers that export at least one symbol used by the module.
- Update the commit description.
- Drop the old "slcan" name to use the standard canX interface naming.
- Remove comment on listen-only command.
- Update the commit subject and description.
- Add the patch "MAINTAINERS: Add myself as maintainer of the SLCAN driver"
to the series.

Dario Binacchi (8):
can: slcan: remove useless header inclusions
can: slcan: remove legacy infrastructure
can: slcan: change every `slc' occurrence in `slcan'
can: slcan: use the generic can_change_mtu()
can: slcan: add support for listen-only mode
ethtool: add support to get/set CAN bit time register
can: slcan: add support to set bit time register (btr)
MAINTAINERS: Add maintainer for the slcan driver

Vincent Mailhol (1):
can: slcan: use KBUILD_MODNAME and define pr_fmt to replace hardcoded
names

MAINTAINERS | 6 +
drivers/net/can/slcan/slcan-core.c | 515 +++++++++-----------------
drivers/net/can/slcan/slcan-ethtool.c | 13 +
drivers/net/can/slcan/slcan.h | 1 +
include/uapi/linux/ethtool.h | 1 +
net/ethtool/common.c | 1 +
net/ethtool/ioctl.c | 1 +
7 files changed, 204 insertions(+), 334 deletions(-)

--
2.32.0


2022-07-26 21:06:12

by Dario Binacchi

[permalink] [raw]
Subject: [RFC PATCH v3 2/9] can: slcan: remove useless header inclusions

Include only the necessary headers.

Signed-off-by: Dario Binacchi <[email protected]>

---

(no changes since v2)

Changes in v2:
- Re-add headers that export at least one symbol used by the module.

drivers/net/can/slcan/slcan-core.c | 3 ---
1 file changed, 3 deletions(-)

diff --git a/drivers/net/can/slcan/slcan-core.c b/drivers/net/can/slcan/slcan-core.c
index 2c9d9fc19ea9..ca383c43167d 100644
--- a/drivers/net/can/slcan/slcan-core.c
+++ b/drivers/net/can/slcan/slcan-core.c
@@ -48,9 +48,6 @@
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
-#include <linux/if_arp.h>
-#include <linux/if_ether.h>
-#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/kernel.h>
--
2.32.0

2022-07-26 21:06:17

by Dario Binacchi

[permalink] [raw]
Subject: [RFC PATCH v3 4/9] can: slcan: change every `slc' occurrence in `slcan'

In the driver there are parts of code where the prefix `slc' is used and
others where the prefix `slcan' is used instead. The patch replaces
every occurrence of `slc' with `slcan', except for the netdev functions
where, to avoid compilation conflicts, it was necessary to replace `slc'
with `slcan_netdev'.

The patch does not make any functional changes.

Signed-off-by: Dario Binacchi <[email protected]>
---

(no changes since v1)

drivers/net/can/slcan/slcan-core.c | 109 +++++++++++++++--------------
1 file changed, 56 insertions(+), 53 deletions(-)

diff --git a/drivers/net/can/slcan/slcan-core.c b/drivers/net/can/slcan/slcan-core.c
index 0d309d0636df..bd8e84ded051 100644
--- a/drivers/net/can/slcan/slcan-core.c
+++ b/drivers/net/can/slcan/slcan-core.c
@@ -65,16 +65,17 @@ MODULE_LICENSE("GPL");
MODULE_AUTHOR("Oliver Hartkopp <[email protected]>");

/* maximum rx buffer len: extended CAN frame with timestamp */
-#define SLC_MTU (sizeof("T1111222281122334455667788EA5F\r") + 1)
-
-#define SLC_CMD_LEN 1
-#define SLC_SFF_ID_LEN 3
-#define SLC_EFF_ID_LEN 8
-#define SLC_STATE_LEN 1
-#define SLC_STATE_BE_RXCNT_LEN 3
-#define SLC_STATE_BE_TXCNT_LEN 3
-#define SLC_STATE_FRAME_LEN (1 + SLC_CMD_LEN + SLC_STATE_BE_RXCNT_LEN + \
- SLC_STATE_BE_TXCNT_LEN)
+#define SLCAN_MTU (sizeof("T1111222281122334455667788EA5F\r") + 1)
+
+#define SLCAN_CMD_LEN 1
+#define SLCAN_SFF_ID_LEN 3
+#define SLCAN_EFF_ID_LEN 8
+#define SLCAN_STATE_LEN 1
+#define SLCAN_STATE_BE_RXCNT_LEN 3
+#define SLCAN_STATE_BE_TXCNT_LEN 3
+#define SLCAN_STATE_FRAME_LEN (1 + SLCAN_CMD_LEN + \
+ SLCAN_STATE_BE_RXCNT_LEN + \
+ SLCAN_STATE_BE_TXCNT_LEN)
struct slcan {
struct can_priv can;

@@ -85,9 +86,9 @@ struct slcan {
struct work_struct tx_work; /* Flushes transmit buffer */

/* These are pointers to the malloc()ed frame buffers. */
- unsigned char rbuff[SLC_MTU]; /* receiver buffer */
+ unsigned char rbuff[SLCAN_MTU]; /* receiver buffer */
int rcount; /* received chars counter */
- unsigned char xbuff[SLC_MTU]; /* transmitter buffer */
+ unsigned char xbuff[SLCAN_MTU]; /* transmitter buffer*/
unsigned char *xhead; /* pointer to next XMIT byte */
int xleft; /* bytes left in XMIT queue */

@@ -166,7 +167,7 @@ int slcan_enable_err_rst_on_open(struct net_device *ndev, bool on)
*************************************************************************/

/* Send one completely decapsulated can_frame to the network layer */
-static void slc_bump_frame(struct slcan *sl)
+static void slcan_bump_frame(struct slcan *sl)
{
struct sk_buff *skb;
struct can_frame *cf;
@@ -186,10 +187,10 @@ static void slc_bump_frame(struct slcan *sl)
fallthrough;
case 't':
/* store dlc ASCII value and terminate SFF CAN ID string */
- cf->len = sl->rbuff[SLC_CMD_LEN + SLC_SFF_ID_LEN];
- sl->rbuff[SLC_CMD_LEN + SLC_SFF_ID_LEN] = 0;
+ cf->len = sl->rbuff[SLCAN_CMD_LEN + SLCAN_SFF_ID_LEN];
+ sl->rbuff[SLCAN_CMD_LEN + SLCAN_SFF_ID_LEN] = 0;
/* point to payload data behind the dlc */
- cmd += SLC_CMD_LEN + SLC_SFF_ID_LEN + 1;
+ cmd += SLCAN_CMD_LEN + SLCAN_SFF_ID_LEN + 1;
break;
case 'R':
cf->can_id = CAN_RTR_FLAG;
@@ -197,16 +198,16 @@ static void slc_bump_frame(struct slcan *sl)
case 'T':
cf->can_id |= CAN_EFF_FLAG;
/* store dlc ASCII value and terminate EFF CAN ID string */
- cf->len = sl->rbuff[SLC_CMD_LEN + SLC_EFF_ID_LEN];
- sl->rbuff[SLC_CMD_LEN + SLC_EFF_ID_LEN] = 0;
+ cf->len = sl->rbuff[SLCAN_CMD_LEN + SLCAN_EFF_ID_LEN];
+ sl->rbuff[SLCAN_CMD_LEN + SLCAN_EFF_ID_LEN] = 0;
/* point to payload data behind the dlc */
- cmd += SLC_CMD_LEN + SLC_EFF_ID_LEN + 1;
+ cmd += SLCAN_CMD_LEN + SLCAN_EFF_ID_LEN + 1;
break;
default:
goto decode_failed;
}

- if (kstrtou32(sl->rbuff + SLC_CMD_LEN, 16, &tmpid))
+ if (kstrtou32(sl->rbuff + SLCAN_CMD_LEN, 16, &tmpid))
goto decode_failed;

cf->can_id |= tmpid;
@@ -253,7 +254,7 @@ static void slc_bump_frame(struct slcan *sl)
* sb256256 : state bus-off: rx counter 256, tx counter 256
* sa057033 : state active, rx counter 57, tx counter 33
*/
-static void slc_bump_state(struct slcan *sl)
+static void slcan_bump_state(struct slcan *sl)
{
struct net_device *dev = sl->dev;
struct sk_buff *skb;
@@ -279,16 +280,16 @@ static void slc_bump_state(struct slcan *sl)
return;
}

- if (state == sl->can.state || sl->rcount < SLC_STATE_FRAME_LEN)
+ if (state == sl->can.state || sl->rcount < SLCAN_STATE_FRAME_LEN)
return;

- cmd += SLC_STATE_BE_RXCNT_LEN + SLC_CMD_LEN + 1;
- cmd[SLC_STATE_BE_TXCNT_LEN] = 0;
+ cmd += SLCAN_STATE_BE_RXCNT_LEN + SLCAN_CMD_LEN + 1;
+ cmd[SLCAN_STATE_BE_TXCNT_LEN] = 0;
if (kstrtou32(cmd, 10, &txerr))
return;

*cmd = 0;
- cmd -= SLC_STATE_BE_RXCNT_LEN;
+ cmd -= SLCAN_STATE_BE_RXCNT_LEN;
if (kstrtou32(cmd, 10, &rxerr))
return;

@@ -316,7 +317,7 @@ static void slc_bump_state(struct slcan *sl)
* e1a : len 1, errors: ACK error
* e3bcO: len 3, errors: Bit0 error, CRC error, Tx overrun error
*/
-static void slc_bump_err(struct slcan *sl)
+static void slcan_bump_err(struct slcan *sl)
{
struct net_device *dev = sl->dev;
struct sk_buff *skb;
@@ -332,7 +333,7 @@ static void slc_bump_err(struct slcan *sl)
else
return;

- if ((len + SLC_CMD_LEN + 1) > sl->rcount)
+ if ((len + SLCAN_CMD_LEN + 1) > sl->rcount)
return;

skb = alloc_can_err_skb(dev, &cf);
@@ -340,7 +341,7 @@ static void slc_bump_err(struct slcan *sl)
if (skb)
cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;

- cmd += SLC_CMD_LEN + 1;
+ cmd += SLCAN_CMD_LEN + 1;
for (i = 0; i < len; i++, cmd++) {
switch (*cmd) {
case 'a':
@@ -429,7 +430,7 @@ static void slc_bump_err(struct slcan *sl)
netif_rx(skb);
}

-static void slc_bump(struct slcan *sl)
+static void slcan_bump(struct slcan *sl)
{
switch (sl->rbuff[0]) {
case 'r':
@@ -439,11 +440,11 @@ static void slc_bump(struct slcan *sl)
case 'R':
fallthrough;
case 'T':
- return slc_bump_frame(sl);
+ return slcan_bump_frame(sl);
case 'e':
- return slc_bump_err(sl);
+ return slcan_bump_err(sl);
case 's':
- return slc_bump_state(sl);
+ return slcan_bump_state(sl);
default:
return;
}
@@ -455,12 +456,12 @@ static void slcan_unesc(struct slcan *sl, unsigned char s)
if ((s == '\r') || (s == '\a')) { /* CR or BEL ends the pdu */
if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
sl->rcount > 4)
- slc_bump(sl);
+ slcan_bump(sl);

sl->rcount = 0;
} else {
if (!test_bit(SLF_ERROR, &sl->flags)) {
- if (sl->rcount < SLC_MTU) {
+ if (sl->rcount < SLCAN_MTU) {
sl->rbuff[sl->rcount++] = s;
return;
}
@@ -476,7 +477,7 @@ static void slcan_unesc(struct slcan *sl, unsigned char s)
*************************************************************************/

/* Encapsulate one can_frame and stuff into a TTY queue. */
-static void slc_encaps(struct slcan *sl, struct can_frame *cf)
+static void slcan_encaps(struct slcan *sl, struct can_frame *cf)
{
int actual, i;
unsigned char *pos;
@@ -493,11 +494,11 @@ static void slc_encaps(struct slcan *sl, struct can_frame *cf)
/* determine number of chars for the CAN-identifier */
if (cf->can_id & CAN_EFF_FLAG) {
id &= CAN_EFF_MASK;
- endpos = pos + SLC_EFF_ID_LEN;
+ endpos = pos + SLCAN_EFF_ID_LEN;
} else {
*pos |= 0x20; /* convert R/T to lower case for SFF */
id &= CAN_SFF_MASK;
- endpos = pos + SLC_SFF_ID_LEN;
+ endpos = pos + SLCAN_SFF_ID_LEN;
}

/* build 3 (SFF) or 8 (EFF) digit CAN identifier */
@@ -507,7 +508,8 @@ static void slc_encaps(struct slcan *sl, struct can_frame *cf)
id >>= 4;
}

- pos += (cf->can_id & CAN_EFF_FLAG) ? SLC_EFF_ID_LEN : SLC_SFF_ID_LEN;
+ pos += (cf->can_id & CAN_EFF_FLAG) ?
+ SLCAN_EFF_ID_LEN : SLCAN_SFF_ID_LEN;

*pos++ = cf->len + '0';

@@ -585,7 +587,8 @@ static void slcan_write_wakeup(struct tty_struct *tty)
}

/* Send a can_frame to a TTY queue. */
-static netdev_tx_t slc_xmit(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t slcan_netdev_xmit(struct sk_buff *skb,
+ struct net_device *dev)
{
struct slcan *sl = netdev_priv(dev);

@@ -604,7 +607,7 @@ static netdev_tx_t slc_xmit(struct sk_buff *skb, struct net_device *dev)
}

netif_stop_queue(sl->dev);
- slc_encaps(sl, (struct can_frame *)skb->data); /* encaps & send */
+ slcan_encaps(sl, (struct can_frame *)skb->data); /* encaps & send */
spin_unlock(&sl->lock);

out:
@@ -647,7 +650,7 @@ static int slcan_transmit_cmd(struct slcan *sl, const unsigned char *cmd)
}

/* Netdevice UP -> DOWN routine */
-static int slc_close(struct net_device *dev)
+static int slcan_netdev_close(struct net_device *dev)
{
struct slcan *sl = netdev_priv(dev);
int err;
@@ -676,10 +679,10 @@ static int slc_close(struct net_device *dev)
}

/* Netdevice DOWN -> UP routine */
-static int slc_open(struct net_device *dev)
+static int slcan_netdev_open(struct net_device *dev)
{
struct slcan *sl = netdev_priv(dev);
- unsigned char cmd[SLC_MTU];
+ unsigned char cmd[SLCAN_MTU];
int err, s;

/* The baud rate is not set with the command
@@ -739,16 +742,16 @@ static int slc_open(struct net_device *dev)
return err;
}

-static int slcan_change_mtu(struct net_device *dev, int new_mtu)
+static int slcan_netdev_change_mtu(struct net_device *dev, int new_mtu)
{
return -EINVAL;
}

-static const struct net_device_ops slc_netdev_ops = {
- .ndo_open = slc_open,
- .ndo_stop = slc_close,
- .ndo_start_xmit = slc_xmit,
- .ndo_change_mtu = slcan_change_mtu,
+static const struct net_device_ops slcan_netdev_ops = {
+ .ndo_open = slcan_netdev_open,
+ .ndo_stop = slcan_netdev_close,
+ .ndo_start_xmit = slcan_netdev_xmit,
+ .ndo_change_mtu = slcan_netdev_change_mtu,
};

/******************************************
@@ -821,7 +824,7 @@ static int slcan_open(struct tty_struct *tty)

/* Configure netdev interface */
sl->dev = dev;
- dev->netdev_ops = &slc_netdev_ops;
+ dev->netdev_ops = &slcan_netdev_ops;
slcan_set_ethtool_ops(dev);

/* Mark ldisc channel as alive */
@@ -889,7 +892,7 @@ static int slcan_ioctl(struct tty_struct *tty, unsigned int cmd,
}
}

-static struct tty_ldisc_ops slc_ldisc = {
+static struct tty_ldisc_ops slcan_ldisc = {
.owner = THIS_MODULE,
.num = N_SLCAN,
.name = KBUILD_MODNAME,
@@ -907,7 +910,7 @@ static int __init slcan_init(void)
pr_info("serial line CAN interface driver\n");

/* Fill in our line protocol discipline, and register it */
- status = tty_register_ldisc(&slc_ldisc);
+ status = tty_register_ldisc(&slcan_ldisc);
if (status)
pr_err("can't register line discipline\n");

@@ -919,7 +922,7 @@ static void __exit slcan_exit(void)
/* This will only be called when all channels have been closed by
* userspace - tty_ldisc.c takes care of the module's refcount.
*/
- tty_unregister_ldisc(&slc_ldisc);
+ tty_unregister_ldisc(&slcan_ldisc);
}

module_init(slcan_init);
--
2.32.0

2022-07-26 21:07:26

by Dario Binacchi

[permalink] [raw]
Subject: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

It allows to set the bit time register with tunable values.
The setting can only be changed if the interface is down:

ip link set dev can0 down
ethtool --set-tunable can0 can-btr 0x31c
ip link set dev can0 up

Suggested-by: Marc Kleine-Budde <[email protected]>
Signed-off-by: Dario Binacchi <[email protected]>
---

(no changes since v1)

drivers/net/can/slcan/slcan-core.c | 58 ++++++++++++++++++++-------
drivers/net/can/slcan/slcan-ethtool.c | 13 ++++++
drivers/net/can/slcan/slcan.h | 1 +
3 files changed, 58 insertions(+), 14 deletions(-)

diff --git a/drivers/net/can/slcan/slcan-core.c b/drivers/net/can/slcan/slcan-core.c
index 45e521910236..3905f21e7788 100644
--- a/drivers/net/can/slcan/slcan-core.c
+++ b/drivers/net/can/slcan/slcan-core.c
@@ -99,6 +99,7 @@ struct slcan {
#define CF_ERR_RST 0 /* Reset errors on open */
wait_queue_head_t xcmd_wait; /* Wait queue for commands */
/* transmission */
+ u32 btr; /* bit timing register */
};

static const u32 slcan_bitrate_const[] = {
@@ -128,6 +129,17 @@ int slcan_enable_err_rst_on_open(struct net_device *ndev, bool on)
return 0;
}

+int slcan_set_btr(struct net_device *ndev, u32 btr)
+{
+ struct slcan *sl = netdev_priv(ndev);
+
+ if (netif_running(ndev))
+ return -EBUSY;
+
+ sl->btr = btr;
+ return 0;
+}
+
/*************************************************************************
* SLCAN ENCAPSULATION FORMAT *
*************************************************************************/
@@ -699,22 +711,40 @@ static int slcan_netdev_open(struct net_device *dev)
return err;
}

- if (sl->can.bittiming.bitrate != CAN_BITRATE_UNKNOWN) {
- for (s = 0; s < ARRAY_SIZE(slcan_bitrate_const); s++) {
- if (sl->can.bittiming.bitrate == slcan_bitrate_const[s])
- break;
+ if (sl->can.bittiming.bitrate != CAN_BITRATE_UNKNOWN || sl->btr) {
+ if (sl->can.bittiming.bitrate != CAN_BITRATE_UNKNOWN) {
+ for (s = 0; s < ARRAY_SIZE(slcan_bitrate_const); s++) {
+ if (sl->can.bittiming.bitrate ==
+ slcan_bitrate_const[s])
+ break;
+ }
+
+ /* The CAN framework has already validate the bitrate
+ * value, so we can avoid to check if `s' has been
+ * properly set.
+ */
+ snprintf(cmd, sizeof(cmd), "C\rS%d\r", s);
+ err = slcan_transmit_cmd(sl, cmd);
+ if (err) {
+ netdev_err(dev,
+ "failed to send bitrate command 'C\\rS%d\\r'\n",
+ s);
+ goto cmd_transmit_failed;
+ }
}

- /* The CAN framework has already validate the bitrate value,
- * so we can avoid to check if `s' has been properly set.
- */
- snprintf(cmd, sizeof(cmd), "C\rS%d\r", s);
- err = slcan_transmit_cmd(sl, cmd);
- if (err) {
- netdev_err(dev,
- "failed to send bitrate command 'C\\rS%d\\r'\n",
- s);
- goto cmd_transmit_failed;
+ if (sl->btr) {
+ u32 btr = sl->btr & GENMASK(15, 0);
+
+ snprintf(cmd, sizeof(cmd), "C\rs%04x\r", btr);
+ err = slcan_transmit_cmd(sl, cmd);
+ if (err) {
+ netdev_err(dev,
+ "failed to send bit timing command 'C\\rs%04x\\r'\n",
+ btr);
+ goto cmd_transmit_failed;
+ }
+
}

if (test_bit(CF_ERR_RST, &sl->cmd_flags)) {
diff --git a/drivers/net/can/slcan/slcan-ethtool.c b/drivers/net/can/slcan/slcan-ethtool.c
index bf0afdc4e49d..8e2e77bbffda 100644
--- a/drivers/net/can/slcan/slcan-ethtool.c
+++ b/drivers/net/can/slcan/slcan-ethtool.c
@@ -52,11 +52,24 @@ static int slcan_get_sset_count(struct net_device *netdev, int sset)
}
}

+static int slcan_set_tunable(struct net_device *netdev,
+ const struct ethtool_tunable *tuna,
+ const void *data)
+{
+ switch (tuna->id) {
+ case ETHTOOL_CAN_BTR:
+ return slcan_set_btr(netdev, *(u32 *)data);
+ default:
+ return -EINVAL;
+ }
+}
+
static const struct ethtool_ops slcan_ethtool_ops = {
.get_strings = slcan_get_strings,
.get_priv_flags = slcan_get_priv_flags,
.set_priv_flags = slcan_set_priv_flags,
.get_sset_count = slcan_get_sset_count,
+ .set_tunable = slcan_set_tunable,
};

void slcan_set_ethtool_ops(struct net_device *netdev)
diff --git a/drivers/net/can/slcan/slcan.h b/drivers/net/can/slcan/slcan.h
index d463c8d99e22..1ac412fe8c95 100644
--- a/drivers/net/can/slcan/slcan.h
+++ b/drivers/net/can/slcan/slcan.h
@@ -13,6 +13,7 @@

bool slcan_err_rst_on_open(struct net_device *ndev);
int slcan_enable_err_rst_on_open(struct net_device *ndev, bool on);
+int slcan_set_btr(struct net_device *ndev, u32 btr);
void slcan_set_ethtool_ops(struct net_device *ndev);

#endif /* _SLCAN_H */
--
2.32.0

2022-07-26 21:07:57

by Dario Binacchi

[permalink] [raw]
Subject: [RFC PATCH v3 7/9] ethtool: add support to get/set CAN bit time register

Add ethtool support to get/set tunable values from/to the CAN bit time
register (btr).

CC: Marc Kleine-Budde <[email protected]>
CC: [email protected]
Suggested-by: Marc Kleine-Budde <[email protected]>
Signed-off-by: Dario Binacchi <[email protected]>
---

(no changes since v1)

include/uapi/linux/ethtool.h | 1 +
net/ethtool/common.c | 1 +
net/ethtool/ioctl.c | 1 +
3 files changed, 3 insertions(+)

diff --git a/include/uapi/linux/ethtool.h b/include/uapi/linux/ethtool.h
index e0f0ee9bc89e..a2d24f689124 100644
--- a/include/uapi/linux/ethtool.h
+++ b/include/uapi/linux/ethtool.h
@@ -232,6 +232,7 @@ enum tunable_id {
ETHTOOL_TX_COPYBREAK,
ETHTOOL_PFC_PREVENTION_TOUT, /* timeout in msecs */
ETHTOOL_TX_COPYBREAK_BUF_SIZE,
+ ETHTOOL_CAN_BTR,
/*
* Add your fresh new tunable attribute above and remember to update
* tunable_strings[] in net/ethtool/common.c
diff --git a/net/ethtool/common.c b/net/ethtool/common.c
index 566adf85e658..78f23b898243 100644
--- a/net/ethtool/common.c
+++ b/net/ethtool/common.c
@@ -90,6 +90,7 @@ tunable_strings[__ETHTOOL_TUNABLE_COUNT][ETH_GSTRING_LEN] = {
[ETHTOOL_TX_COPYBREAK] = "tx-copybreak",
[ETHTOOL_PFC_PREVENTION_TOUT] = "pfc-prevention-tout",
[ETHTOOL_TX_COPYBREAK_BUF_SIZE] = "tx-copybreak-buf-size",
+ [ETHTOOL_CAN_BTR] = "can-btr",
};

const char
diff --git a/net/ethtool/ioctl.c b/net/ethtool/ioctl.c
index 326e14ee05db..17b69d6fcab4 100644
--- a/net/ethtool/ioctl.c
+++ b/net/ethtool/ioctl.c
@@ -2403,6 +2403,7 @@ static int ethtool_get_module_eeprom(struct net_device *dev,
static int ethtool_tunable_valid(const struct ethtool_tunable *tuna)
{
switch (tuna->id) {
+ case ETHTOOL_CAN_BTR:
case ETHTOOL_RX_COPYBREAK:
case ETHTOOL_TX_COPYBREAK:
case ETHTOOL_TX_COPYBREAK_BUF_SIZE:
--
2.32.0

2022-07-26 21:09:13

by Dario Binacchi

[permalink] [raw]
Subject: [RFC PATCH v3 9/9] MAINTAINERS: Add maintainer for the slcan driver

At the suggestion of its author Oliver Hartkopp ([1]), I take over the
maintainer-ship and add myself to the authors of the driver.

[1] https://lore.kernel.org/all/[email protected]

Suggested-by: Oliver Hartkopp <[email protected]>
Signed-off-by: Dario Binacchi <[email protected]>

---

Changes in v3:
- Put the series as RFC again.
- Pick up the patch "can: slcan: use KBUILD_MODNAME and define pr_fmt to replace hardcoded names".
- Add the patch "ethtool: add support to get/set CAN bit time register"
to the series.
- Add the patch "can: slcan: add support to set bit time register (btr)"
to the series.
- Replace the link https://marc.info/?l=linux-can&m=165806705927851&w=2 with
https://lore.kernel.org/all/[email protected].
- Add the `Suggested-by' tag.

Changes in v2:
- Add the patch "MAINTAINERS: Add myself as maintainer of the SLCAN driver"
to the series.

MAINTAINERS | 6 ++++++
drivers/net/can/slcan/slcan-core.c | 1 +
2 files changed, 7 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index fc7d75c5cdb9..74e42f78e7cb 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -18448,6 +18448,12 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/vbabka/slab.git
F: include/linux/sl?b*.h
F: mm/sl?b*

+SLCAN CAN NETWORK DRIVER
+M: Dario Binacchi <[email protected]>
+L: [email protected]
+S: Maintained
+F: drivers/net/can/slcan/
+
SLEEPABLE READ-COPY UPDATE (SRCU)
M: Lai Jiangshan <[email protected]>
M: "Paul E. McKenney" <[email protected]>
diff --git a/drivers/net/can/slcan/slcan-core.c b/drivers/net/can/slcan/slcan-core.c
index 3905f21e7788..6a0f12cfbb4e 100644
--- a/drivers/net/can/slcan/slcan-core.c
+++ b/drivers/net/can/slcan/slcan-core.c
@@ -63,6 +63,7 @@ MODULE_ALIAS_LDISC(N_SLCAN);
MODULE_DESCRIPTION("serial line CAN interface");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Oliver Hartkopp <[email protected]>");
+MODULE_AUTHOR("Dario Binacchi <[email protected]>");

/* maximum rx buffer len: extended CAN frame with timestamp */
#define SLCAN_MTU (sizeof("T1111222281122334455667788EA5F\r") + 1)
--
2.32.0

2022-07-27 11:35:48

by Marc Kleine-Budde

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On 26.07.2022 23:02:16, Dario Binacchi wrote:
> It allows to set the bit time register with tunable values.
> The setting can only be changed if the interface is down:
>
> ip link set dev can0 down
> ethtool --set-tunable can0 can-btr 0x31c
> ip link set dev can0 up

As far as I understand, setting the btr is an alternative way to set the
bitrate, right? I don't like the idea of poking arbitrary values into a
hardware from user space.

Do you have a use case for this?

Marc

--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung West/Dortmund | Phone: +49-231-2826-924 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |


Attachments:
(No filename) (766.00 B)
signature.asc (499.00 B)
Download all attachments

2022-07-27 18:29:46

by Dario Binacchi

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

Hello Marc,

On Wed, Jul 27, 2022 at 1:31 PM Marc Kleine-Budde <[email protected]> wrote:
>
> On 26.07.2022 23:02:16, Dario Binacchi wrote:
> > It allows to set the bit time register with tunable values.
> > The setting can only be changed if the interface is down:
> >
> > ip link set dev can0 down
> > ethtool --set-tunable can0 can-btr 0x31c
> > ip link set dev can0 up
>
> As far as I understand, setting the btr is an alternative way to set the
> bitrate, right?

I thought of a non-standard bitrate or, in addition to the bitrate, the
possibility of enabling some specific CAN controller options. Maybe Oliver
could help us come up with the right answer.

This is the the slcan source code:
https://github.com/linux-can/can-utils/blob/cad1cecf1ca19277b5f5db39f8ef6f8ae426191d/slcand.c#L331
btr case cames after speed but they don't seem to be considered alternative.

> I don't like the idea of poking arbitrary values into a
> hardware from user space.

However this is already possible through the slcand and slcan_attach
applications.
Furthermore, the driver implements the LAWICEL ASCII protocol for CAN
frame transport over serial lines,
and this is one of the supported commands.

>
> Do you have a use case for this?

I use the applications slcand and slcan_attach as a reference, I try to make the
driver independent from them for what concerns the CAN setup. And the bit time
register setting is the last dependency.

Thanks and regards,
Dario

>
> Marc
>
> --
> Pengutronix e.K. | Marc Kleine-Budde |
> Embedded Linux | https://www.pengutronix.de |
> Vertretung West/Dortmund | Phone: +49-231-2826-924 |
> Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |



--

Dario Binacchi

Embedded Linux Developer

[email protected]

__________________________________


Amarula Solutions SRL

Via Le Canevare 30, 31100 Treviso, Veneto, IT

T. +39 042 243 5310
[email protected]

http://www.amarulasolutions.com

2022-07-27 18:35:10

by Max Staudt

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On Wed, 27 Jul 2022 13:30:54 +0200
Marc Kleine-Budde <[email protected]> wrote:

> As far as I understand, setting the btr is an alternative way to set the
> bitrate, right? I don't like the idea of poking arbitrary values into a
> hardware from user space.

I agree with Marc here.

This is a modification across the whole stack, specific to a single
device, when there are ways around.


If I understand correctly, the CAN232 "S" command sets one of the fixed
bitrates, whereas "s" sets the two BTR registers. Now the question is,
what do BTR0/BTR1 mean, and what are they? If they are merely a divider
in a CAN controller's master clock, like in ELM327, then you could

a) Calculate the BTR values from the bitrate userspace requests, or

b) pre-calculate a huge table of possible bitrates and present them
all to userspace. Sounds horrible, but that's what I did in can327,
haha. Maybe I should have reigned them in a little, to the most
useful values.

c) just limit the bitrates to whatever seems most useful (like the
"S" command's table), and let users complain if they really need
something else. In the meantime, they are still free to slcand or
minicom to their heart's content before attaching slcan, thanks to
your backwards compatibility efforts.


In short, to me, this isn't a deal breaker for your patch series.


Max

2022-07-27 18:35:18

by Dario Binacchi

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On Wed, Jul 27, 2022 at 7:21 PM Marc Kleine-Budde <[email protected]> wrote:
>
> On 27.07.2022 17:55:10, Dario Binacchi wrote:
> > Hello Marc,
> >
> > On Wed, Jul 27, 2022 at 1:31 PM Marc Kleine-Budde <[email protected]> wrote:
> > >
> > > On 26.07.2022 23:02:16, Dario Binacchi wrote:
> > > > It allows to set the bit time register with tunable values.
> > > > The setting can only be changed if the interface is down:
> > > >
> > > > ip link set dev can0 down
> > > > ethtool --set-tunable can0 can-btr 0x31c
> > > > ip link set dev can0 up
> > >
> > > As far as I understand, setting the btr is an alternative way to set the
> > > bitrate, right?
> >
> > I thought of a non-standard bitrate or, in addition to the bitrate, the
> > possibility of enabling some specific CAN controller options. Maybe Oliver
> > could help us come up with the right answer.
> >
> > This is the the slcan source code:
> > https://github.com/linux-can/can-utils/blob/cad1cecf1ca19277b5f5db39f8ef6f8ae426191d/slcand.c#L331
> > btr case cames after speed but they don't seem to be considered alternative.
> >
> > > I don't like the idea of poking arbitrary values into a
> > > hardware from user space.
> >
> > However this is already possible through the slcand and slcan_attach
> > applications.
> > Furthermore, the driver implements the LAWICEL ASCII protocol for CAN
> > frame transport over serial lines,
> > and this is one of the supported commands.
> >
> > >
> > > Do you have a use case for this?
> >
> > I use the applications slcand and slcan_attach as a reference, I try to make the
> > driver independent from them for what concerns the CAN setup. And the bit time
> > register setting is the last dependency.
>
> Ok - We avoided writing bit timing registers from user space into the
> hardware for all existing drivers. If there isn't a specific use case,
> let's skip this patch. If someone comes up with a use case we can think
> of a proper solution.

Ok. So do I also remove the 7/9 "ethtool: add support to get/set CAN
bit time register"
patch ?

Thanks and regards,
Dario

>
> Marc
>
> --
> Pengutronix e.K. | Marc Kleine-Budde |
> Embedded Linux | https://www.pengutronix.de |
> Vertretung West/Dortmund | Phone: +49-231-2826-924 |
> Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |



--

Dario Binacchi

Embedded Linux Developer

[email protected]

__________________________________


Amarula Solutions SRL

Via Le Canevare 30, 31100 Treviso, Veneto, IT

T. +39 042 243 5310
[email protected]

http://www.amarulasolutions.com

2022-07-27 18:38:06

by Max Staudt

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On Wed, 27 Jul 2022 19:28:45 +0200
Dario Binacchi <[email protected]> wrote:

> On Wed, Jul 27, 2022 at 7:21 PM Marc Kleine-Budde <[email protected]> wrote:
> >
> > Ok - We avoided writing bit timing registers from user space into the
> > hardware for all existing drivers. If there isn't a specific use case,
> > let's skip this patch. If someone comes up with a use case we can think
> > of a proper solution.
>
> Ok. So do I also remove the 7/9 "ethtool: add support to get/set CAN
> bit time register"
> patch ?

If I may answer as well - IMHO, yes.

Unless we know that BTR is something other than just a different way to
express the bitrate, I'd skip it, yes. Because bitrate is already
handled by other, cross-device mechanisms.


Max

2022-07-27 19:07:01

by Dario Binacchi

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

Hello Marc and Max,

On Wed, Jul 27, 2022 at 7:33 PM Max Staudt <[email protected]> wrote:
>
> On Wed, 27 Jul 2022 19:28:45 +0200
> Dario Binacchi <[email protected]> wrote:
>
> > On Wed, Jul 27, 2022 at 7:21 PM Marc Kleine-Budde <[email protected]> wrote:
> > >
> > > Ok - We avoided writing bit timing registers from user space into the
> > > hardware for all existing drivers. If there isn't a specific use case,
> > > let's skip this patch. If someone comes up with a use case we can think
> > > of a proper solution.
> >
> > Ok. So do I also remove the 7/9 "ethtool: add support to get/set CAN
> > bit time register"
> > patch ?
>
> If I may answer as well - IMHO, yes.
>
> Unless we know that BTR is something other than just a different way to
> express the bitrate, I'd skip it, yes. Because bitrate is already
> handled by other, cross-device mechanisms.

Thanks to both of you for the explanations.
Regards,

Dario

>
>
> Max

--

Dario Binacchi

Embedded Linux Developer

[email protected]

__________________________________


Amarula Solutions SRL

Via Le Canevare 30, 31100 Treviso, Veneto, IT

T. +39 042 243 5310
[email protected]

http://www.amarulasolutions.com

2022-07-27 19:08:23

by Marc Kleine-Budde

[permalink] [raw]
Subject: Re: [RFC PATCH v3 0/9] can: slcan: extend supported features (step 2)

On 26.07.2022 23:02:08, Dario Binacchi wrote:
> With this series I try to finish the task, started with the series [1],
> of completely removing the dependency of the slcan driver from the
> userspace slcand/slcan_attach applications.
>
> The series also contains patches that remove the legacy stuff (slcan_devs,
> SLCAN_MAGIC, ...) and do some module cleanup.
>
> The series has been created on top of the patches:
>
> can: slcan: convert comments to network style comments
> can: slcan: slcan_init() convert printk(LEVEL ...) to pr_level()
> can: slcan: fix whitespace issues
> can: slcan: convert comparison to NULL into !val
> can: slcan: clean up if/else
> can: slcan: use scnprintf() as a hardening measure
> can: slcan: do not report txerr and rxerr during bus-off
> can: slcan: do not sleep with a spin lock held
>
> applied to linux-next.
>
> [1] https://lore.kernel.org/all/[email protected]/
>
> Changes in v3:
> - Update the commit message.
> - Use 1 space in front of the =.
> - Put the series as RFC again.

No need to change the series to RFC again :)

> - Pick up the patch "can: slcan: use KBUILD_MODNAME and define pr_fmt to replace hardcoded names".
> - Add the patch "ethtool: add support to get/set CAN bit time register"
> to the series.
> - Add the patch "can: slcan: add support to set bit time register (btr)"
> to the series.
> - Replace the link https://marc.info/?l=linux-can&m=165806705927851&w=2 with
> https://lore.kernel.org/all/[email protected].
> - Add the `Suggested-by' tag.

Please post a v4 with both BTR patches dropped and add Max Staudt's
Reviewed-by to patch 3.

Marc

--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung West/Dortmund | Phone: +49-231-2826-924 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |


Attachments:
(No filename) (1.96 kB)
signature.asc (499.00 B)
Download all attachments

2022-07-27 19:09:29

by Marc Kleine-Budde

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On 27.07.2022 19:28:39, Max Staudt wrote:
> On Wed, 27 Jul 2022 13:30:54 +0200
> Marc Kleine-Budde <[email protected]> wrote:
>
> > As far as I understand, setting the btr is an alternative way to set the
> > bitrate, right? I don't like the idea of poking arbitrary values into a
> > hardware from user space.
>
> I agree with Marc here.
>
> This is a modification across the whole stack, specific to a single
> device, when there are ways around.
>
> If I understand correctly, the CAN232 "S" command sets one of the fixed
> bitrates, whereas "s" sets the two BTR registers. Now the question is,
> what do BTR0/BTR1 mean, and what are they? If they are merely a divider
> in a CAN controller's master clock, like in ELM327, then you could
>
> a) Calculate the BTR values from the bitrate userspace requests, or

Most of the other CAN drivers write the BTR values into the register of
the hardware. How are these BTR values transported into the driver?

There are 2 ways:

1) - user space configures a bitrate
- the kernel calculates with the "struct can_bittiming_const" [1] given
by driver and the CAN clock rate the low level timing parameters.

[1] https://elixir.bootlin.com/linux/v5.18/source/include/uapi/linux/can/netlink.h#L47

2) - user space configures low level bit timing parameter
(Sample point in one-tenth of a percent, Time quanta (TQ) in
nanoseconds, Propagation segment in TQs, Phase buffer segment 1 in
TQs, Phase buffer segment 2 in TQs, Synchronisation jump width in
TQs)
- the kernel calculates the Bit-rate prescaler from the given TQ and
CAN clock rate

Both ways result in a fully calculated "struct can_bittiming" [2]. The
driver translates this into the hardware specific BTR values and writes
the into the registers.

If you know the CAN clock and the bit timing const parameters of the
slcan's BTR register you can make use of the automatic BTR calculation,
too. Maybe the framework needs some tweaking if the driver supports both
fixed CAN bit rate _and_ "struct can_bittiming_const".

[2] https://elixir.bootlin.com/linux/v5.18/source/include/uapi/linux/can/netlink.h#L31

> b) pre-calculate a huge table of possible bitrates and present them
> all to userspace. Sounds horrible, but that's what I did in can327,
> haha. Maybe I should have reigned them in a little, to the most
> useful values.

If your adapter only supports fixed values, then that's the only way to
go.

> c) just limit the bitrates to whatever seems most useful (like the
> "S" command's table), and let users complain if they really need
> something else. In the meantime, they are still free to slcand or
> minicom to their heart's content before attaching slcan, thanks to
> your backwards compatibility efforts.

In the early stages of the non-mainline CAN framework we had tables for
BTR values for some fixed bit rates, but that turned out to be not
scaleable.

> In short, to me, this isn't a deal breaker for your patch series.

Marc

--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung West/Dortmund | Phone: +49-231-2826-924 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |


Attachments:
(No filename) (3.30 kB)
signature.asc (499.00 B)
Download all attachments

2022-07-27 19:22:21

by Marc Kleine-Budde

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On 27.07.2022 17:55:10, Dario Binacchi wrote:
> Hello Marc,
>
> On Wed, Jul 27, 2022 at 1:31 PM Marc Kleine-Budde <[email protected]> wrote:
> >
> > On 26.07.2022 23:02:16, Dario Binacchi wrote:
> > > It allows to set the bit time register with tunable values.
> > > The setting can only be changed if the interface is down:
> > >
> > > ip link set dev can0 down
> > > ethtool --set-tunable can0 can-btr 0x31c
> > > ip link set dev can0 up
> >
> > As far as I understand, setting the btr is an alternative way to set the
> > bitrate, right?
>
> I thought of a non-standard bitrate or, in addition to the bitrate, the
> possibility of enabling some specific CAN controller options. Maybe Oliver
> could help us come up with the right answer.
>
> This is the the slcan source code:
> https://github.com/linux-can/can-utils/blob/cad1cecf1ca19277b5f5db39f8ef6f8ae426191d/slcand.c#L331
> btr case cames after speed but they don't seem to be considered alternative.
>
> > I don't like the idea of poking arbitrary values into a
> > hardware from user space.
>
> However this is already possible through the slcand and slcan_attach
> applications.
> Furthermore, the driver implements the LAWICEL ASCII protocol for CAN
> frame transport over serial lines,
> and this is one of the supported commands.
>
> >
> > Do you have a use case for this?
>
> I use the applications slcand and slcan_attach as a reference, I try to make the
> driver independent from them for what concerns the CAN setup. And the bit time
> register setting is the last dependency.

Ok - We avoided writing bit timing registers from user space into the
hardware for all existing drivers. If there isn't a specific use case,
let's skip this patch. If someone comes up with a use case we can think
of a proper solution.

Marc

--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung West/Dortmund | Phone: +49-231-2826-924 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |


Attachments:
(No filename) (2.06 kB)
signature.asc (499.00 B)
Download all attachments

2022-07-27 20:54:38

by Oliver Hartkopp

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)



On 27.07.22 20:24, Marc Kleine-Budde wrote:
> On 27.07.2022 19:28:39, Max Staudt wrote:
>> On Wed, 27 Jul 2022 13:30:54 +0200
>> Marc Kleine-Budde <[email protected]> wrote:
>>
>>> As far as I understand, setting the btr is an alternative way to set the
>>> bitrate, right? I don't like the idea of poking arbitrary values into a
>>> hardware from user space.
>>
>> I agree with Marc here.
>>
>> This is a modification across the whole stack, specific to a single
>> device, when there are ways around.
>>
>> If I understand correctly, the CAN232 "S" command sets one of the fixed
>> bitrates, whereas "s" sets the two BTR registers. Now the question is,
>> what do BTR0/BTR1 mean, and what are they? If they are merely a divider
>> in a CAN controller's master clock, like in ELM327, then you could
>>
>> a) Calculate the BTR values from the bitrate userspace requests, or
>
> Most of the other CAN drivers write the BTR values into the register of
> the hardware. How are these BTR values transported into the driver?
>
> There are 2 ways:
>
> 1) - user space configures a bitrate
> - the kernel calculates with the "struct can_bittiming_const" [1] given
> by driver and the CAN clock rate the low level timing parameters.
>
> [1] https://elixir.bootlin.com/linux/v5.18/source/include/uapi/linux/can/netlink.h#L47
>
> 2) - user space configures low level bit timing parameter
> (Sample point in one-tenth of a percent, Time quanta (TQ) in
> nanoseconds, Propagation segment in TQs, Phase buffer segment 1 in
> TQs, Phase buffer segment 2 in TQs, Synchronisation jump width in
> TQs)
> - the kernel calculates the Bit-rate prescaler from the given TQ and
> CAN clock rate
>
> Both ways result in a fully calculated "struct can_bittiming" [2]. The
> driver translates this into the hardware specific BTR values and writes
> the into the registers.
>
> If you know the CAN clock and the bit timing const parameters of the
> slcan's BTR register you can make use of the automatic BTR calculation,
> too. Maybe the framework needs some tweaking if the driver supports both
> fixed CAN bit rate _and_ "struct can_bittiming_const".
>
> [2] https://elixir.bootlin.com/linux/v5.18/source/include/uapi/linux/can/netlink.h#L31
>
>> b) pre-calculate a huge table of possible bitrates and present them
>> all to userspace. Sounds horrible, but that's what I did in can327,
>> haha. Maybe I should have reigned them in a little, to the most
>> useful values.
>
> If your adapter only supports fixed values, then that's the only way to
> go.
>
>> c) just limit the bitrates to whatever seems most useful (like the
>> "S" command's table), and let users complain if they really need
>> something else. In the meantime, they are still free to slcand or
>> minicom to their heart's content before attaching slcan, thanks to
>> your backwards compatibility efforts.
>
> In the early stages of the non-mainline CAN framework we had tables for
> BTR values for some fixed bit rates, but that turned out to be not
> scaleable.

The Microchip CAN BUS Analyzer Tool is another example for fixed bitrates:

https://elixir.bootlin.com/linux/v5.18.14/source/drivers/net/can/usb/mcba_usb.c#L156

So this might be the way to go here too ...

Best regards,
Oliver

>
>> In short, to me, this isn't a deal breaker for your patch series.
>
> Marc
>

2022-07-28 07:04:03

by Marc Kleine-Budde

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On 27.07.2022 22:12:13, Oliver Hartkopp wrote:
>
>
> On 27.07.22 20:24, Marc Kleine-Budde wrote:
> > On 27.07.2022 19:28:39, Max Staudt wrote:
> > > On Wed, 27 Jul 2022 13:30:54 +0200
> > > Marc Kleine-Budde <[email protected]> wrote:
> > >
> > > > As far as I understand, setting the btr is an alternative way to set the
> > > > bitrate, right? I don't like the idea of poking arbitrary values into a
> > > > hardware from user space.
> > >
> > > I agree with Marc here.
> > >
> > > This is a modification across the whole stack, specific to a single
> > > device, when there are ways around.
> > >
> > > If I understand correctly, the CAN232 "S" command sets one of the fixed
> > > bitrates, whereas "s" sets the two BTR registers. Now the question is,
> > > what do BTR0/BTR1 mean, and what are they? If they are merely a divider
> > > in a CAN controller's master clock, like in ELM327, then you could
> > >
> > > a) Calculate the BTR values from the bitrate userspace requests, or
> >
> > Most of the other CAN drivers write the BTR values into the register of
> > the hardware. How are these BTR values transported into the driver?
> >
> > There are 2 ways:
> >
> > 1) - user space configures a bitrate
> > - the kernel calculates with the "struct can_bittiming_const" [1] given
> > by driver and the CAN clock rate the low level timing parameters.
> >
> > [1] https://elixir.bootlin.com/linux/v5.18/source/include/uapi/linux/can/netlink.h#L47
> >
> > 2) - user space configures low level bit timing parameter
> > (Sample point in one-tenth of a percent, Time quanta (TQ) in
> > nanoseconds, Propagation segment in TQs, Phase buffer segment 1 in
> > TQs, Phase buffer segment 2 in TQs, Synchronisation jump width in
> > TQs)
> > - the kernel calculates the Bit-rate prescaler from the given TQ and
> > CAN clock rate
> >
> > Both ways result in a fully calculated "struct can_bittiming" [2]. The
> > driver translates this into the hardware specific BTR values and writes
> > the into the registers.
> >
> > If you know the CAN clock and the bit timing const parameters of the
> > slcan's BTR register you can make use of the automatic BTR calculation,
> > too. Maybe the framework needs some tweaking if the driver supports both
> > fixed CAN bit rate _and_ "struct can_bittiming_const".
> >
> > [2] https://elixir.bootlin.com/linux/v5.18/source/include/uapi/linux/can/netlink.h#L31
> >
> > > b) pre-calculate a huge table of possible bitrates and present them
> > > all to userspace. Sounds horrible, but that's what I did in can327,
> > > haha. Maybe I should have reigned them in a little, to the most
> > > useful values.
> >
> > If your adapter only supports fixed values, then that's the only way to
> > go.
> >
> > > c) just limit the bitrates to whatever seems most useful (like the
> > > "S" command's table), and let users complain if they really need
> > > something else. In the meantime, they are still free to slcand or
> > > minicom to their heart's content before attaching slcan, thanks to
> > > your backwards compatibility efforts.
> >
> > In the early stages of the non-mainline CAN framework we had tables for
> > BTR values for some fixed bit rates, but that turned out to be not
> > scaleable.
>
> The Microchip CAN BUS Analyzer Tool is another example for fixed bitrates:
>
> https://elixir.bootlin.com/linux/v5.18.14/source/drivers/net/can/usb/mcba_usb.c#L156
>
> So this might be the way to go here too ...

The slcan driver already supports fixed bitrates. This discussion is
about setting the BTR registers in one way or another.

Marc

--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung West/Dortmund | Phone: +49-231-2826-924 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |


Attachments:
(No filename) (3.96 kB)
signature.asc (499.00 B)
Download all attachments

2022-07-28 07:42:28

by Dario Binacchi

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

Hello Marc,

On Wed, Jul 27, 2022 at 8:24 PM Marc Kleine-Budde <[email protected]> wrote:
>
> On 27.07.2022 19:28:39, Max Staudt wrote:
> > On Wed, 27 Jul 2022 13:30:54 +0200
> > Marc Kleine-Budde <[email protected]> wrote:
> >
> > > As far as I understand, setting the btr is an alternative way to set the
> > > bitrate, right? I don't like the idea of poking arbitrary values into a
> > > hardware from user space.
> >
> > I agree with Marc here.
> >
> > This is a modification across the whole stack, specific to a single
> > device, when there are ways around.
> >
> > If I understand correctly, the CAN232 "S" command sets one of the fixed
> > bitrates, whereas "s" sets the two BTR registers. Now the question is,
> > what do BTR0/BTR1 mean, and what are they? If they are merely a divider
> > in a CAN controller's master clock, like in ELM327, then you could
> >
> > a) Calculate the BTR values from the bitrate userspace requests, or
>
> Most of the other CAN drivers write the BTR values into the register of
> the hardware. How are these BTR values transported into the driver?
>
> There are 2 ways:
>
> 1) - user space configures a bitrate
> - the kernel calculates with the "struct can_bittiming_const" [1] given
> by driver and the CAN clock rate the low level timing parameters.
>
> [1] https://elixir.bootlin.com/linux/v5.18/source/include/uapi/linux/can/netlink.h#L47
>
> 2) - user space configures low level bit timing parameter
> (Sample point in one-tenth of a percent, Time quanta (TQ) in
> nanoseconds, Propagation segment in TQs, Phase buffer segment 1 in
> TQs, Phase buffer segment 2 in TQs, Synchronisation jump width in
> TQs)
> - the kernel calculates the Bit-rate prescaler from the given TQ and
> CAN clock rate
>
> Both ways result in a fully calculated "struct can_bittiming" [2]. The
> driver translates this into the hardware specific BTR values and writes
> the into the registers.
>
> If you know the CAN clock and the bit timing const parameters of the
> slcan's BTR register you can make use of the automatic BTR calculation,
> too. Maybe the framework needs some tweaking if the driver supports both
> fixed CAN bit rate _and_ "struct can_bittiming_const".

Does it make sense to use the device tree to provide the driver with those
parameters required for the automatic calculation of the BTR (clock rate,
struct can_bittiming_const, ...) that depend on the connected controller? In
this way the solution should be generic and therefore scalable. I think we
should also add some properties to map the calculated BTR value on the
physical register of the controller.

Or, use the device tree to extend the bittates supported by the controller
to the fixed ones (struct can_priv::bitrate_const)?

Thanks and regards,
Dario

>
> [2] https://elixir.bootlin.com/linux/v5.18/source/include/uapi/linux/can/netlink.h#L31
>
> > b) pre-calculate a huge table of possible bitrates and present them
> > all to userspace. Sounds horrible, but that's what I did in can327,
> > haha. Maybe I should have reigned them in a little, to the most
> > useful values.
>
> If your adapter only supports fixed values, then that's the only way to
> go.
>
> > c) just limit the bitrates to whatever seems most useful (like the
> > "S" command's table), and let users complain if they really need
> > something else. In the meantime, they are still free to slcand or
> > minicom to their heart's content before attaching slcan, thanks to
> > your backwards compatibility efforts.
>
> In the early stages of the non-mainline CAN framework we had tables for
> BTR values for some fixed bit rates, but that turned out to be not
> scaleable.
>
> > In short, to me, this isn't a deal breaker for your patch series.
>
> Marc
>
> --
> Pengutronix e.K. | Marc Kleine-Budde |
> Embedded Linux | https://www.pengutronix.de |
> Vertretung West/Dortmund | Phone: +49-231-2826-924 |
> Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |



--

Dario Binacchi

Embedded Linux Developer

[email protected]

__________________________________


Amarula Solutions SRL

Via Le Canevare 30, 31100 Treviso, Veneto, IT

T. +39 042 243 5310
[email protected]

http://www.amarulasolutions.com

2022-07-28 09:20:41

by Marc Kleine-Budde

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On 28.07.2022 09:36:21, Dario Binacchi wrote:
> > Most of the other CAN drivers write the BTR values into the register of
> > the hardware. How are these BTR values transported into the driver?
> >
> > There are 2 ways:
> >
> > 1) - user space configures a bitrate
> > - the kernel calculates with the "struct can_bittiming_const" [1] given
> > by driver and the CAN clock rate the low level timing parameters.
> >
> > [1] https://elixir.bootlin.com/linux/v5.18/source/include/uapi/linux/can/netlink.h#L47
> >
> > 2) - user space configures low level bit timing parameter
> > (Sample point in one-tenth of a percent, Time quanta (TQ) in
> > nanoseconds, Propagation segment in TQs, Phase buffer segment 1 in
> > TQs, Phase buffer segment 2 in TQs, Synchronisation jump width in
> > TQs)
> > - the kernel calculates the Bit-rate prescaler from the given TQ and
> > CAN clock rate
> >
> > Both ways result in a fully calculated "struct can_bittiming" [2]. The
> > driver translates this into the hardware specific BTR values and writes
> > the into the registers.
> >
> > If you know the CAN clock and the bit timing const parameters of the
> > slcan's BTR register you can make use of the automatic BTR calculation,
> > too. Maybe the framework needs some tweaking if the driver supports both
> > fixed CAN bit rate _and_ "struct can_bittiming_const".
>
> Does it make sense to use the device tree

The driver doesn't support DT and DT only works for static serial
interfaces.

> to provide the driver with those
> parameters required for the automatic calculation of the BTR (clock rate,
> struct can_bittiming_const, ...) that depend on the connected
> controller?

The device tree usually says it's a CAN controller compatible to X and
the following clock(s) are connected. The driver for CAN controller X
knows the bit timing const. Some USB CAN drivers query the bit timing
const from the USB device.

> In this way the solution should be generic and therefore scalable. I
> think we should also add some properties to map the calculated BTR
> value on the physical register of the controller.

The driver knows how to map the "struct can_bittiming" to the BTR
register values of the hardware.

What does the serial protocol say to the BTR values? Are these standard
SJA1000 layout with 8 MHz CAN clock or are those adapter specific?

> Or, use the device tree to extend the bittates supported by the controller
> to the fixed ones (struct can_priv::bitrate_const)?

The serial protocol defines fixed bit rates, no need to describe them in
the DT:

| 0 10 Kbit/s
| 1 20 Kbit/s
| 2 50 Kbit/s
| 3 100 Kbit/s
| 4 125 Kbit/s
| 5 250 Kbit/s
| 6 500 Kbit/s
| 7 800 Kbit/s
| 8 1000 Kbit/s

Are there more bit rates?

regards,
Marc

--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung West/Dortmund | Phone: +49-231-2826-924 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |


Attachments:
(No filename) (3.22 kB)
signature.asc (499.00 B)
Download all attachments

2022-07-28 10:58:36

by Marc Kleine-Budde

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On 28.07.2022 12:23:04, Dario Binacchi wrote:
> > > Does it make sense to use the device tree
> >
> > The driver doesn't support DT and DT only works for static serial
> > interfaces.

Have you seen my remarks about Device Tree?

> > > to provide the driver with those
> > > parameters required for the automatic calculation of the BTR (clock rate,
> > > struct can_bittiming_const, ...) that depend on the connected
> > > controller?
> >
> > The device tree usually says it's a CAN controller compatible to X and
> > the following clock(s) are connected. The driver for CAN controller X
> > knows the bit timing const. Some USB CAN drivers query the bit timing
> > const from the USB device.
> >
> > > In this way the solution should be generic and therefore scalable. I
> > > think we should also add some properties to map the calculated BTR
> > > value on the physical register of the controller.
> >
> > The driver knows how to map the "struct can_bittiming" to the BTR
> > register values of the hardware.
> >
> > What does the serial protocol say to the BTR values? Are these standard
> > SJA1000 layout with 8 MHz CAN clock or are those adapter specific?
>
> I think they are adapter specific.

The BTR values depend on the used CAN controller, the clock rate, and on
the firmware, if it supports BTR at all.

> This is what the can232_ver3_Manual.pdf reports:
>
> sxxyy[CR] Setup with BTR0/BTR1 CAN bit-rates where xx and yy is a hex
> value. This command is only active if the CAN
> channel is closed.
>
> xx BTR0 value in hex
> yy BTR1 value in hex
>
> Example: s031C[CR]
> Setup CAN with BTR0=0x03 & BTR1=0x1C
> which equals to 125Kbit.
>
> But I think the example is misleading because IMHO it depends on the
> adapter's controller (0x31C -> 125Kbit).

I think the BTR in can232_ver3_Manual.pdf is compatible to a sja1000
controller with 8 MHz ref clock. See:

| Bit timing parameters for sja1000 with 8.000000 MHz ref clock using algo 'v4.8'
| nominal real Bitrt nom real SampP
| Bitrate TQ[ns] PrS PhS1 PhS2 SJW BRP Bitrate Error SampP SampP Error BTR0 BTR1
| 1000000 125 2 3 2 1 1 1000000 0.0% 75.0% 75.0% 0.0% 0x00 0x14
| 800000 125 3 4 2 1 1 800000 0.0% 80.0% 80.0% 0.0% 0x00 0x16
| 500000 125 6 7 2 1 1 500000 0.0% 87.5% 87.5% 0.0% 0x00 0x1c
| 250000 250 6 7 2 1 2 250000 0.0% 87.5% 87.5% 0.0% 0x01 0x1c
| 125000 500 6 7 2 1 4 125000 0.0% 87.5% 87.5% 0.0% 0x03 0x1c <---
| 100000 625 6 7 2 1 5 100000 0.0% 87.5% 87.5% 0.0% 0x04 0x1c
| 50000 1250 6 7 2 1 10 50000 0.0% 87.5% 87.5% 0.0% 0x09 0x1c
| 20000 3125 6 7 2 1 25 20000 0.0% 87.5% 87.5% 0.0% 0x18 0x1c
| 10000 6250 6 7 2 1 50 10000 0.0% 87.5% 87.5% 0.0% 0x31 0x1c

> > > Or, use the device tree to extend the bittates supported by the controller
> > > to the fixed ones (struct can_priv::bitrate_const)?
> >
> > The serial protocol defines fixed bit rates, no need to describe them in
> > the DT:
> >
> > | 0 10 Kbit/s
> > | 1 20 Kbit/s
> > | 2 50 Kbit/s
> > | 3 100 Kbit/s
> > | 4 125 Kbit/s
> > | 5 250 Kbit/s
> > | 6 500 Kbit/s
> > | 7 800 Kbit/s
> > | 8 1000 Kbit/s
> >
> > Are there more bit rates?
>
> No, the manual can232_ver3_Manual.pdf does not contain any others.
>
> What about defining a device tree node for the slcan (foo adapter):
>
> slcan {
> compatible = "can,slcan";
> /* bit rate btr0btr1 */
> additional-bitrates = < 33333 0x0123
> 80000 0x4567
> 83333 0x89ab
> 150000 0xcd10
> 175000 0x2345
> 200000 0x6789>
> };
>
> So that the can_priv::bitrate_cons array (dynamically created) will
> contain the bitrates
> 10000,
> 20000,
> 50000,
> 100000,
> 125000,
> 250000,
> 500000,
> 800000,
> 1000000 /* end of standards bitrates, use S command */
> 33333, /* use s command, btr 0x0123 */
> 80000, /* use s command, btr 0x4567 */
> 83333, /* use s command, btr 0x89ab */
> 150000, /* use s command, btr 0xcd10 */
> 175000, /* use s command, btr 0x2345 */
> 200000 /* use s command, btr 0x6789 */
> };
>
> So if a standard bitrate is requested, the S command is used,
> otherwise the s command with the associated btr.

That would be an option. For proper DT support, the driver needs to be
extended to support serdev. But DT only supports "static" devices.

But if you can calculate BTR values you know the bit timing constants
(and frequency) and then it's better to have the bit timing in the
driver so that arbitrary bit rates can be calculated by the kernel.

regards,
Marc

--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung West/Dortmund | Phone: +49-231-2826-924 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |


Attachments:
(No filename) (5.62 kB)
signature.asc (499.00 B)
Download all attachments

2022-07-28 11:03:15

by Dario Binacchi

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On Thu, Jul 28, 2022 at 11:02 AM Marc Kleine-Budde <[email protected]> wrote:
>
> On 28.07.2022 09:36:21, Dario Binacchi wrote:
> > > Most of the other CAN drivers write the BTR values into the register of
> > > the hardware. How are these BTR values transported into the driver?
> > >
> > > There are 2 ways:
> > >
> > > 1) - user space configures a bitrate
> > > - the kernel calculates with the "struct can_bittiming_const" [1] given
> > > by driver and the CAN clock rate the low level timing parameters.
> > >
> > > [1] https://elixir.bootlin.com/linux/v5.18/source/include/uapi/linux/can/netlink.h#L47
> > >
> > > 2) - user space configures low level bit timing parameter
> > > (Sample point in one-tenth of a percent, Time quanta (TQ) in
> > > nanoseconds, Propagation segment in TQs, Phase buffer segment 1 in
> > > TQs, Phase buffer segment 2 in TQs, Synchronisation jump width in
> > > TQs)
> > > - the kernel calculates the Bit-rate prescaler from the given TQ and
> > > CAN clock rate
> > >
> > > Both ways result in a fully calculated "struct can_bittiming" [2]. The
> > > driver translates this into the hardware specific BTR values and writes
> > > the into the registers.
> > >
> > > If you know the CAN clock and the bit timing const parameters of the
> > > slcan's BTR register you can make use of the automatic BTR calculation,
> > > too. Maybe the framework needs some tweaking if the driver supports both
> > > fixed CAN bit rate _and_ "struct can_bittiming_const".
> >
> > Does it make sense to use the device tree
>
> The driver doesn't support DT and DT only works for static serial
> interfaces.
>
> > to provide the driver with those
> > parameters required for the automatic calculation of the BTR (clock rate,
> > struct can_bittiming_const, ...) that depend on the connected
> > controller?
>
> The device tree usually says it's a CAN controller compatible to X and
> the following clock(s) are connected. The driver for CAN controller X
> knows the bit timing const. Some USB CAN drivers query the bit timing
> const from the USB device.
>
> > In this way the solution should be generic and therefore scalable. I
> > think we should also add some properties to map the calculated BTR
> > value on the physical register of the controller.
>
> The driver knows how to map the "struct can_bittiming" to the BTR
> register values of the hardware.
>
> What does the serial protocol say to the BTR values? Are these standard
> SJA1000 layout with 8 MHz CAN clock or are those adapter specific?

I think they are adapter specific.
This is what the can232_ver3_Manual.pdf reports:

sxxyy[CR] Setup with BTR0/BTR1 CAN bit-rates where xx and yy is a hex
value. This command is only active if the CAN
channel is closed.

xx BTR0 value in hex
yy BTR1 value in hex

Example: s031C[CR]
Setup CAN with BTR0=0x03 & BTR1=0x1C
which equals to 125Kbit.

But I think the example is misleading because IMHO it depends on the
adapter's controller (0x31C -> 125Kbit).

>
> > Or, use the device tree to extend the bittates supported by the controller
> > to the fixed ones (struct can_priv::bitrate_const)?
>
> The serial protocol defines fixed bit rates, no need to describe them in
> the DT:
>
> | 0 10 Kbit/s
> | 1 20 Kbit/s
> | 2 50 Kbit/s
> | 3 100 Kbit/s
> | 4 125 Kbit/s
> | 5 250 Kbit/s
> | 6 500 Kbit/s
> | 7 800 Kbit/s
> | 8 1000 Kbit/s
>
> Are there more bit rates?

No, the manual can232_ver3_Manual.pdf does not contain any others.

What about defining a device tree node for the slcan (foo adapter):

slcan {
compatible = "can,slcan";
/* bit rate btr0btr1 */
additional-bitrates = < 33333 0x0123
80000 0x4567
83333 0x89ab
150000 0xcd10
175000 0x2345
200000 0x6789>
};

So that the can_priv::bitrate_cons array (dynamically created) will
contain the bitrates
10000,
20000,
50000,
100000,
125000,
250000,
500000,
800000,
1000000 /* end of standards bitrates, use S command */
33333, /* use s command, btr 0x0123 */
80000, /* use s command, btr 0x4567 */
83333, /* use s command, btr 0x89ab */
150000, /* use s command, btr 0xcd10 */
175000, /* use s command, btr 0x2345 */
200000 /* use s command, btr 0x6789 */
};

So if a standard bitrate is requested, the S command is used,
otherwise the s command with the associated btr.

Thanks and regards,
Dario

>
> regards,
> Marc
>
> --
> Pengutronix e.K. | Marc Kleine-Budde |
> Embedded Linux | https://www.pengutronix.de |
> Vertretung West/Dortmund | Phone: +49-231-2826-924 |
> Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
--

Dario Binacchi

Embedded Linux Developer

[email protected]

__________________________________


Amarula Solutions SRL

Via Le Canevare 30, 31100 Treviso, Veneto, IT

T. +39 042 243 5310
[email protected]

http://www.amarulasolutions.com

2022-07-28 11:06:19

by Max Staudt

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On Thu, 28 Jul 2022 12:50:49 +0200
Marc Kleine-Budde <[email protected]> wrote:

> On 28.07.2022 12:23:04, Dario Binacchi wrote:
> > > > Does it make sense to use the device tree
> > >
> > > The driver doesn't support DT and DT only works for static serial
> > > interfaces.
>
> Have you seen my remarks about Device Tree?

Dario, there seems to be a misunderstanding about the Device Tree.

It is used *only* for hardware that is permanently attached, present at
boot, and forever after. Not for dyamically added stuff, and definitely
not for ldiscs that have to be attached manually by the user.


The only exception to this is if you have an embedded device with an
slcan adapter permanently attached to one of its UARTs. Then you can
use the serdev ldisc adapter to attach the ldisc automatically at boot.

If you are actively developing for such a use case, please let us know,
so we know what you're after and can help you better :)


Max

2022-07-29 06:55:44

by Dario Binacchi

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

Hello Marc and Max,

On Thu, Jul 28, 2022 at 12:57 PM Max Staudt <[email protected]> wrote:
>
> On Thu, 28 Jul 2022 12:50:49 +0200
> Marc Kleine-Budde <[email protected]> wrote:
>
> > On 28.07.2022 12:23:04, Dario Binacchi wrote:
> > > > > Does it make sense to use the device tree
> > > >
> > > > The driver doesn't support DT and DT only works for static serial
> > > > interfaces.
> >
> > Have you seen my remarks about Device Tree?
>
> Dario, there seems to be a misunderstanding about the Device Tree.
>
> It is used *only* for hardware that is permanently attached, present at
> boot, and forever after. Not for dyamically added stuff, and definitely
> not for ldiscs that have to be attached manually by the user.
>
>
> The only exception to this is if you have an embedded device with an
> slcan adapter permanently attached to one of its UARTs. Then you can
> use the serdev ldisc adapter to attach the ldisc automatically at boot.

It is evident that I am lacking some skills (I will try to fix it :)).
I think it is
equally clear that it is not worth going down this path.

>
> If you are actively developing for such a use case, please let us know,
> so we know what you're after and can help you better :)
>

I don't have a use case, other than to try, if possible, to make the driver
autonomous from slcand / slcan_attach for the CAN bus setup.

Returning to Marc's previous analysis:
"... Some USB CAN drivers query the bit timing const from the USB device."

Can we think of taking the gs_usb driver as inspiration for getting/setting the
bit timings?

https://elixir.bootlin.com/linux/latest/source/drivers/net/can/usb/gs_usb.c#L951
https://elixir.bootlin.com/linux/latest/source/drivers/net/can/usb/gs_usb.c#L510

and, as done with patches:

can: slcan: extend the protocol with CAN state info
can: slcan: extend the protocol with error info

further extend the protocol to get/set the bit timing from / to the adapter ?
In the case of non-standard bit rates, the driver would try, depending on the
firmware of the adapter, to calculate and set the bit timings autonomously.

Thanks and regards,
Dario

>
> Max



--

Dario Binacchi

Embedded Linux Developer

[email protected]

__________________________________


Amarula Solutions SRL

Via Le Canevare 30, 31100 Treviso, Veneto, IT

T. +39 042 243 5310
[email protected]

http://www.amarulasolutions.com

2022-07-29 08:06:54

by Marc Kleine-Budde

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On 29.07.2022 08:52:07, Dario Binacchi wrote:
> Hello Marc and Max,
>
> On Thu, Jul 28, 2022 at 12:57 PM Max Staudt <[email protected]> wrote:
> >
> > On Thu, 28 Jul 2022 12:50:49 +0200
> > Marc Kleine-Budde <[email protected]> wrote:
> >
> > > On 28.07.2022 12:23:04, Dario Binacchi wrote:
> > > > > > Does it make sense to use the device tree
> > > > >
> > > > > The driver doesn't support DT and DT only works for static serial
> > > > > interfaces.
> > >
> > > Have you seen my remarks about Device Tree?
> >
> > Dario, there seems to be a misunderstanding about the Device Tree.
> >
> > It is used *only* for hardware that is permanently attached, present at
> > boot, and forever after. Not for dyamically added stuff, and definitely
> > not for ldiscs that have to be attached manually by the user.
> >
> >
> > The only exception to this is if you have an embedded device with an
> > slcan adapter permanently attached to one of its UARTs. Then you can
> > use the serdev ldisc adapter to attach the ldisc automatically at boot.
>
> It is evident that I am lacking some skills (I will try to fix it :)).

We're all here to learn something!

> I think it is equally clear that it is not worth going down this path.

If you have a static attached serial devices serdev is the way to go.
But slcan has so many drawbacks compared to "real" CAN adapters that I
hope the no one uses them in such a scenario.

> > If you are actively developing for such a use case, please let us know,
> > so we know what you're after and can help you better :)
>
> I don't have a use case, other than to try, if possible, to make the driver
> autonomous from slcand / slcan_attach for the CAN bus setup.

From my point of view your job is done!

> Returning to Marc's previous analysis:
> "... Some USB CAN drivers query the bit timing const from the USB device."
>
> Can we think of taking the gs_usb driver as inspiration for getting/setting the
> bit timings?
>
> https://elixir.bootlin.com/linux/latest/source/drivers/net/can/usb/gs_usb.c#L951
> https://elixir.bootlin.com/linux/latest/source/drivers/net/can/usb/gs_usb.c#L510
>
> and, as done with patches:
>
> can: slcan: extend the protocol with CAN state info
> can: slcan: extend the protocol with error info

You can define a way to query bit timing constants and CAN clock rate,
but you have to get this into the "official" firmware. You have to roll
out a firmware update to all devices. What about non official firmware?

> further extend the protocol to get/set the bit timing from / to the adapter ?
> In the case of non-standard bit rates, the driver would try, depending on the
> firmware of the adapter, to calculate and set the bit timings autonomously.

If an adapter follows 100% the official firmware doc the BTR registers
are interpreted as SJA1000 with 8 MHz CAN clock.

See

| https://lore.kernel.org/all/[email protected]

where I compare the 125 Kbit/s BTR config of the documentation with the
bit timing calculated by the kernel algorithm.

regards,
Marc

--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung West/Dortmund | Phone: +49-231-2826-924 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |


Attachments:
(No filename) (3.32 kB)
signature.asc (499.00 B)
Download all attachments

2022-07-31 16:00:46

by Dario Binacchi

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

Hi Marc,

On Fri, Jul 29, 2022 at 9:33 AM Marc Kleine-Budde <[email protected]> wrote:
>
> On 29.07.2022 08:52:07, Dario Binacchi wrote:
> > Hello Marc and Max,
> >
> > On Thu, Jul 28, 2022 at 12:57 PM Max Staudt <[email protected]> wrote:
> > >
> > > On Thu, 28 Jul 2022 12:50:49 +0200
> > > Marc Kleine-Budde <[email protected]> wrote:
> > >
> > > > On 28.07.2022 12:23:04, Dario Binacchi wrote:
> > > > > > > Does it make sense to use the device tree
> > > > > >
> > > > > > The driver doesn't support DT and DT only works for static serial
> > > > > > interfaces.
> > > >
> > > > Have you seen my remarks about Device Tree?
> > >
> > > Dario, there seems to be a misunderstanding about the Device Tree.
> > >
> > > It is used *only* for hardware that is permanently attached, present at
> > > boot, and forever after. Not for dyamically added stuff, and definitely
> > > not for ldiscs that have to be attached manually by the user.
> > >
> > >
> > > The only exception to this is if you have an embedded device with an
> > > slcan adapter permanently attached to one of its UARTs. Then you can
> > > use the serdev ldisc adapter to attach the ldisc automatically at boot.
> >
> > It is evident that I am lacking some skills (I will try to fix it :)).
>
> We're all here to learn something!
>
> > I think it is equally clear that it is not worth going down this path.
>
> If you have a static attached serial devices serdev is the way to go.
> But slcan has so many drawbacks compared to "real" CAN adapters that I
> hope the no one uses them in such a scenario.
>
> > > If you are actively developing for such a use case, please let us know,
> > > so we know what you're after and can help you better :)
> >
> > I don't have a use case, other than to try, if possible, to make the driver
> > autonomous from slcand / slcan_attach for the CAN bus setup.
>
> From my point of view your job is done!

Ok.

>
> > Returning to Marc's previous analysis:
> > "... Some USB CAN drivers query the bit timing const from the USB device."
> >
> > Can we think of taking the gs_usb driver as inspiration for getting/setting the
> > bit timings?
> >
> > https://elixir.bootlin.com/linux/latest/source/drivers/net/can/usb/gs_usb.c#L951
> > https://elixir.bootlin.com/linux/latest/source/drivers/net/can/usb/gs_usb.c#L510
> >
> > and, as done with patches:
> >
> > can: slcan: extend the protocol with CAN state info
> > can: slcan: extend the protocol with error info
>
> You can define a way to query bit timing constants and CAN clock rate,
> but you have to get this into the "official" firmware. You have to roll
> out a firmware update to all devices. What about non official firmware?
>
> > further extend the protocol to get/set the bit timing from / to the adapter ?
> > In the case of non-standard bit rates, the driver would try, depending on the
> > firmware of the adapter, to calculate and set the bit timings autonomously.
>
> If an adapter follows 100% the official firmware doc the BTR registers
> are interpreted as SJA1000 with 8 MHz CAN clock.

I checked the sources and documentation of the usb adapter I used (i.
e. Https://www.fischl.de/usbtin/):
...
sxxyyzz[CR] Set can bitrate registers of MCP2515. You
can set non-standard baudrates which are not supported by the "Sx"
command.
xx: CNF1 as hexadecimal value (00-FF)
yy: CNF2 as hexadecimal value (00-FF)
zz: CNF3 as hexadecimal value
...

Different from what is reported by can232_ver3_Manual.pdf :

sxxyy[CR] Setup with BTR0/BTR1 CAN bit-rates where xx and yy is a hex
value. This command is only active if the CAN

And here is the type of control carried out by the slcan_attach for
the btr parameter:
https://github.com/linux-can/can-utils/blob/master/slcan_attach.c#L144
When I would have expected a different check (i. e. if (strlen(btr) > 4).
Therefore it is possible that each adapter uses these bytes in its own
way as well as
in the content and also in the number of bytes.

Thanks and regards,
Dario

>
> See
>
> | https://lore.kernel.org/all/[email protected]
>
> where I compare the 125 Kbit/s BTR config of the documentation with the
> bit timing calculated by the kernel algorithm.
>
> regards,
> Marc
>
> --
> Pengutronix e.K. | Marc Kleine-Budde |
> Embedded Linux | https://www.pengutronix.de |
> Vertretung West/Dortmund | Phone: +49-231-2826-924 |
> Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |



--

Dario Binacchi

Embedded Linux Developer

[email protected]

__________________________________


Amarula Solutions SRL

Via Le Canevare 30, 31100 Treviso, Veneto, IT

T. +39 042 243 5310
[email protected]

http://www.amarulasolutions.com

2022-07-31 18:59:42

by Marc Kleine-Budde

[permalink] [raw]
Subject: Re: [RFC PATCH v3 8/9] can: slcan: add support to set bit time register (btr)

On 31.07.2022 17:54:01, Dario Binacchi wrote:
> > If an adapter follows 100% the official firmware doc the BTR registers
> > are interpreted as SJA1000 with 8 MHz CAN clock.
>
> I checked the sources and documentation of the usb adapter I used (i.
> e. Https://www.fischl.de/usbtin/):
> ...
> sxxyyzz[CR] Set can bitrate registers of MCP2515. You
> can set non-standard baudrates which are not supported by the "Sx"
> command.

I hope the effective clock speed is documented somewhere, as you need
this information to set the registers.

> xx: CNF1 as hexadecimal value (00-FF)
> yy: CNF2 as hexadecimal value (00-FF)
> zz: CNF3 as hexadecimal value
> ...
>
> Different from what is reported by can232_ver3_Manual.pdf :
>
> sxxyy[CR] Setup with BTR0/BTR1 CAN bit-rates where xx and yy is a hex
> value. This command is only active if the CAN
>
> And here is the type of control carried out by the slcan_attach for
> the btr parameter:
> https://github.com/linux-can/can-utils/blob/master/slcan_attach.c#L144
> When I would have expected a different check (i. e. if (strlen(btr) > 4).
> Therefore it is possible that each adapter uses these bytes in its own
> way as well as
> in the content and also in the number of bytes.

I expected something like that.

regards,
Marc

--
Pengutronix e.K. | Marc Kleine-Budde |
Embedded Linux | https://www.pengutronix.de |
Vertretung West/Dortmund | Phone: +49-231-2826-924 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |


Attachments:
(No filename) (1.70 kB)
signature.asc (499.00 B)
Download all attachments