diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 15:35:18 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 15:35:18 +0000 |
commit | b750101eb236130cf056c675997decbac904cc49 (patch) | |
tree | a5df1a06754bdd014cb975c051c83b01c9a97532 /src/network/networkd-can.c | |
parent | Initial commit. (diff) | |
download | systemd-b750101eb236130cf056c675997decbac904cc49.tar.xz systemd-b750101eb236130cf056c675997decbac904cc49.zip |
Adding upstream version 252.22.upstream/252.22
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/network/networkd-can.c')
-rw-r--r-- | src/network/networkd-can.c | 336 |
1 files changed, 336 insertions, 0 deletions
diff --git a/src/network/networkd-can.c b/src/network/networkd-can.c new file mode 100644 index 0000000..b8a1871 --- /dev/null +++ b/src/network/networkd-can.c @@ -0,0 +1,336 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +#include <net/if.h> +#include <linux/can/netlink.h> + +#include "networkd-can.h" +#include "networkd-link.h" +#include "networkd-network.h" +#include "networkd-setlink.h" +#include "parse-util.h" +#include "string-util.h" + +#define CAN_TERMINATION_DEFAULT_OHM_VALUE 120 + +int can_set_netlink_message(Link *link, sd_netlink_message *m) { + int r; + + assert(link); + assert(link->network); + assert(m); + + r = sd_netlink_message_set_flags(m, NLM_F_REQUEST | NLM_F_ACK); + if (r < 0) + return r; + + r = sd_netlink_message_open_container(m, IFLA_LINKINFO); + if (r < 0) + return r; + + r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind); + if (r < 0) + return r; + + if (link->network->can_bitrate > 0) { + struct can_bittiming bt = { + .bitrate = link->network->can_bitrate, + .sample_point = link->network->can_sample_point, + .sjw = link->network->can_sync_jump_width, + }; + + log_link_debug(link, "Setting bitrate = %u bit/s", bt.bitrate); + if (link->network->can_sample_point > 0) + log_link_debug(link, "Setting sample point = %u.%u%%", bt.sample_point / 10, bt.sample_point % 10); + else + log_link_debug(link, "Using default sample point"); + + r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt)); + if (r < 0) + return r; + } else if (link->network->can_time_quanta_ns > 0) { + struct can_bittiming bt = { + .tq = link->network->can_time_quanta_ns, + .prop_seg = link->network->can_propagation_segment, + .phase_seg1 = link->network->can_phase_buffer_segment_1, + .phase_seg2 = link->network->can_phase_buffer_segment_2, + .sjw = link->network->can_sync_jump_width, + }; + + log_link_debug(link, "Setting time quanta = %"PRIu32" nsec", bt.tq); + r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt)); + if (r < 0) + return r; + } + + if (link->network->can_data_bitrate > 0) { + struct can_bittiming bt = { + .bitrate = link->network->can_data_bitrate, + .sample_point = link->network->can_data_sample_point, + .sjw = link->network->can_data_sync_jump_width, + }; + + log_link_debug(link, "Setting data bitrate = %u bit/s", bt.bitrate); + if (link->network->can_data_sample_point > 0) + log_link_debug(link, "Setting data sample point = %u.%u%%", bt.sample_point / 10, bt.sample_point % 10); + else + log_link_debug(link, "Using default data sample point"); + + r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt)); + if (r < 0) + return r; + } else if (link->network->can_data_time_quanta_ns > 0) { + struct can_bittiming bt = { + .tq = link->network->can_data_time_quanta_ns, + .prop_seg = link->network->can_data_propagation_segment, + .phase_seg1 = link->network->can_data_phase_buffer_segment_1, + .phase_seg2 = link->network->can_data_phase_buffer_segment_2, + .sjw = link->network->can_data_sync_jump_width, + }; + + log_link_debug(link, "Setting data time quanta = %"PRIu32" nsec", bt.tq); + r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt)); + if (r < 0) + return r; + } + + if (link->network->can_restart_us > 0) { + uint64_t restart_ms; + + if (link->network->can_restart_us == USEC_INFINITY) + restart_ms = 0; + else + restart_ms = DIV_ROUND_UP(link->network->can_restart_us, USEC_PER_MSEC); + + log_link_debug(link, "Setting restart = %s", FORMAT_TIMESPAN(restart_ms * 1000, MSEC_PER_SEC)); + r = sd_netlink_message_append_u32(m, IFLA_CAN_RESTART_MS, restart_ms); + if (r < 0) + return r; + } + + if (link->network->can_control_mode_mask != 0) { + struct can_ctrlmode cm = { + .mask = link->network->can_control_mode_mask, + .flags = link->network->can_control_mode_flags, + }; + + r = sd_netlink_message_append_data(m, IFLA_CAN_CTRLMODE, &cm, sizeof(cm)); + if (r < 0) + return r; + } + + if (link->network->can_termination_set) { + log_link_debug(link, "Setting can-termination to '%u'.", link->network->can_termination); + + r = sd_netlink_message_append_u16(m, IFLA_CAN_TERMINATION, link->network->can_termination); + if (r < 0) + return r; + } + + r = sd_netlink_message_close_container(m); + if (r < 0) + return r; + + r = sd_netlink_message_close_container(m); + if (r < 0) + return r; + + return 0; +} + +int config_parse_can_bitrate( + const char* unit, + const char *filename, + unsigned line, + const char *section, + unsigned section_line, + const char *lvalue, + int ltype, + const char *rvalue, + void *data, + void *userdata) { + + uint32_t *br = ASSERT_PTR(data); + uint64_t sz; + int r; + + assert(filename); + assert(lvalue); + assert(rvalue); + + r = parse_size(rvalue, 1000, &sz); + if (r < 0) { + log_syntax(unit, LOG_WARNING, filename, line, r, + "Failed to parse can bitrate '%s', ignoring: %m", rvalue); + return 0; + } + + /* Linux uses __u32 for bitrates, so the value should not exceed that. */ + if (sz <= 0 || sz > UINT32_MAX) { + log_syntax(unit, LOG_WARNING, filename, line, 0, + "Bit rate out of permitted range 1...4294967295"); + return 0; + } + + *br = (uint32_t) sz; + + return 0; +} + +int config_parse_can_time_quanta( + const char* unit, + const char *filename, + unsigned line, + const char *section, + unsigned section_line, + const char *lvalue, + int ltype, + const char *rvalue, + void *data, + void *userdata) { + + nsec_t val, *tq = ASSERT_PTR(data); + int r; + + assert(filename); + assert(lvalue); + assert(rvalue); + + r = parse_nsec(rvalue, &val); + if (r < 0) { + log_syntax(unit, LOG_WARNING, filename, line, r, + "Failed to parse can time quanta '%s', ignoring: %m", rvalue); + return 0; + } + + /* Linux uses __u32 for bitrates, so the value should not exceed that. */ + if (val <= 0 || val > UINT32_MAX) { + log_syntax(unit, LOG_WARNING, filename, line, 0, + "Time quanta out of permitted range 1...4294967295"); + return 0; + } + + *tq = val; + return 0; +} + +int config_parse_can_restart_usec( + const char* unit, + const char *filename, + unsigned line, + const char *section, + unsigned section_line, + const char *lvalue, + int ltype, + const char *rvalue, + void *data, + void *userdata) { + + usec_t usec, *restart_usec = ASSERT_PTR(data); + int r; + + assert(filename); + assert(lvalue); + assert(rvalue); + + r = parse_sec(rvalue, &usec); + if (r < 0) { + log_syntax(unit, LOG_WARNING, filename, line, r, + "Failed to parse CAN restart sec '%s', ignoring: %m", rvalue); + return 0; + } + + if (usec != USEC_INFINITY && + DIV_ROUND_UP(usec, USEC_PER_MSEC) > UINT32_MAX) { + log_syntax(unit, LOG_WARNING, filename, line, 0, + "CAN RestartSec= must be in the range 0...%"PRIu32"ms, ignoring: %s", UINT32_MAX, rvalue); + return 0; + } + + *restart_usec = usec; + return 0; +} + +int config_parse_can_control_mode( + const char* unit, + const char *filename, + unsigned line, + const char *section, + unsigned section_line, + const char *lvalue, + int ltype, + const char *rvalue, + void *data, + void *userdata) { + + Network *network = ASSERT_PTR(userdata); + uint32_t mask = ltype; + int r; + + assert(filename); + assert(lvalue); + assert(rvalue); + assert(mask != 0); + + if (isempty(rvalue)) { + network->can_control_mode_mask &= ~mask; + network->can_control_mode_flags &= ~mask; + return 0; + } + + r = parse_boolean(rvalue); + if (r < 0) { + log_syntax(unit, LOG_WARNING, filename, line, r, + "Failed to parse CAN control mode '%s', ignoring: %s", lvalue, rvalue); + return 0; + } + + network->can_control_mode_mask |= mask; + SET_FLAG(network->can_control_mode_flags, mask, r); + return 0; +} + +int config_parse_can_termination( + const char* unit, + const char *filename, + unsigned line, + const char *section, + unsigned section_line, + const char *lvalue, + int ltype, + const char *rvalue, + void *data, + void *userdata) { + + Network *network = userdata; + int r; + + assert(filename); + assert(lvalue); + assert(rvalue); + assert(data); + + if (isempty(rvalue)) { + network->can_termination_set = false; + return 0; + } + + /* Note that 0 termination ohm value means no termination resistor, and there is no conflict + * between parse_boolean() and safe_atou16() when Termination=0. However, Termination=1 must be + * treated as 1 ohm, instead of true (and then the default ohm value). So, we need to parse the + * string with safe_atou16() at first. */ + + r = safe_atou16(rvalue, &network->can_termination); + if (r < 0) { + r = parse_boolean(rvalue); + if (r < 0) { + log_syntax(unit, LOG_WARNING, filename, line, r, + "Failed to parse CAN termination value, ignoring: %s", rvalue); + return 0; + } + + network->can_termination = r ? CAN_TERMINATION_DEFAULT_OHM_VALUE : 0; + } + + network->can_termination_set = true; + return 0; +} |