331 lines
11 KiB
C
331 lines
11 KiB
C
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
|
|
#include <linux/can/netlink.h>
|
|
|
|
#include "sd-netlink.h"
|
|
|
|
#include "networkd-can.h"
|
|
#include "networkd-link.h"
|
|
#include "networkd-network.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_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;
|
|
}
|
|
|
|
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;
|
|
}
|