src/network/networkd-can.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 /* Make sure the net/if.h header is included before any linux/ one */
   4 #include <net/if.h>
   5 #include <linux/can/netlink.h>
   6
   7 #include "networkd-can.h"
   8 #include "networkd-link.h"
   9 #include "networkd-network.h"
  10 #include "networkd-setlink.h"
  11 #include "parse-util.h"
  12 #include "string-util.h"
  13
  14 #define CAN_TERMINATION_DEFAULT_OHM_VALUE 120
  15
  16 int can_set_netlink_message(Link *link, sd_netlink_message *m) {
  17         int r;
  18
  19         assert(link);
  20         assert(link->network);
  21         assert(m);
  22
  23         r = sd_netlink_message_set_flags(m, NLM_F_REQUEST | NLM_F_ACK);
  24         if (r < 0)
  25                 return r;
  26
  27         r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
  28         if (r < 0)
  29                 return r;
  30
  31         r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind);
  32         if (r < 0)
  33                 return r;
  34
  35         if (link->network->can_bitrate > 0) {
  36                 struct can_bittiming bt = {
  37                         .bitrate = link->network->can_bitrate,
  38                         .sample_point = link->network->can_sample_point,
  39                         .sjw = link->network->can_sync_jump_width,
  40                 };
  41
  42                 log_link_debug(link, "Setting bitrate = %u bit/s", bt.bitrate);
  43                 if (link->network->can_sample_point > 0)
  44                         log_link_debug(link, "Setting sample point = %u.%u%%", bt.sample_point / 10, bt.sample_point % 10);
  45                 else
  46                         log_link_debug(link, "Using default sample point");
  47
  48                 r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
  49                 if (r < 0)
  50                         return r;
  51         } else if (link->network->can_time_quanta_ns > 0) {
  52                 struct can_bittiming bt = {
  53                         .tq = link->network->can_time_quanta_ns,
  54                         .prop_seg = link->network->can_propagation_segment,
  55                         .phase_seg1 = link->network->can_phase_buffer_segment_1,
  56                         .phase_seg2 = link->network->can_phase_buffer_segment_2,
  57                         .sjw = link->network->can_sync_jump_width,
  58                 };
  59
  60                 log_link_debug(link, "Setting time quanta = %"PRIu32" nsec", bt.tq);
  61                 r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
  62                 if (r < 0)
  63                         return r;
  64         }
  65
  66         if (link->network->can_data_bitrate > 0) {
  67                 struct can_bittiming bt = {
  68                         .bitrate = link->network->can_data_bitrate,
  69                         .sample_point = link->network->can_data_sample_point,
  70                         .sjw = link->network->can_data_sync_jump_width,
  71                 };
  72
  73                 log_link_debug(link, "Setting data bitrate = %u bit/s", bt.bitrate);
  74                 if (link->network->can_data_sample_point > 0)
  75                         log_link_debug(link, "Setting data sample point = %u.%u%%", bt.sample_point / 10, bt.sample_point % 10);
  76                 else
  77                         log_link_debug(link, "Using default data sample point");
  78
  79                 r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt));
  80                 if (r < 0)
  81                         return r;
  82         } else if (link->network->can_data_time_quanta_ns > 0) {
  83                 struct can_bittiming bt = {
  84                         .tq = link->network->can_data_time_quanta_ns,
  85                         .prop_seg = link->network->can_data_propagation_segment,
  86                         .phase_seg1 = link->network->can_data_phase_buffer_segment_1,
  87                         .phase_seg2 = link->network->can_data_phase_buffer_segment_2,
  88                         .sjw = link->network->can_data_sync_jump_width,
  89                 };
  90
  91                 log_link_debug(link, "Setting data time quanta = %"PRIu32" nsec", bt.tq);
  92                 r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt));
  93                 if (r < 0)
  94                         return r;
  95         }
  96
  97         if (link->network->can_restart_us > 0) {
  98                 uint64_t restart_ms;
  99
 100                 if (link->network->can_restart_us == USEC_INFINITY)
 101                         restart_ms = 0;
 102                 else
 103                         restart_ms = DIV_ROUND_UP(link->network->can_restart_us, USEC_PER_MSEC);
 104
 105                 log_link_debug(link, "Setting restart = %s", FORMAT_TIMESPAN(restart_ms * 1000, MSEC_PER_SEC));
 106                 r = sd_netlink_message_append_u32(m, IFLA_CAN_RESTART_MS, restart_ms);
 107                 if (r < 0)
 108                         return r;
 109         }
 110
 111         if (link->network->can_control_mode_mask != 0) {
 112                 struct can_ctrlmode cm = {
 113                         .mask = link->network->can_control_mode_mask,
 114                         .flags = link->network->can_control_mode_flags,
 115                 };
 116
 117                 r = sd_netlink_message_append_data(m, IFLA_CAN_CTRLMODE, &cm, sizeof(cm));
 118                 if (r < 0)
 119                         return r;
 120         }
 121
 122         if (link->network->can_termination_set) {
 123                 log_link_debug(link, "Setting can-termination to '%u'.", link->network->can_termination);
 124
 125                 r = sd_netlink_message_append_u16(m, IFLA_CAN_TERMINATION, link->network->can_termination);
 126                 if (r < 0)
 127                         return r;
 128         }
 129
 130         r = sd_netlink_message_close_container(m);
 131         if (r < 0)
 132                 return r;
 133
 134         r = sd_netlink_message_close_container(m);
 135         if (r < 0)
 136                 return r;
 137
 138         return 0;
 139 }
 140
 141 int config_parse_can_bitrate(
 142                 const char* unit,
 143                 const char *filename,
 144                 unsigned line,
 145                 const char *section,
 146                 unsigned section_line,
 147                 const char *lvalue,
 148                 int ltype,
 149                 const char *rvalue,
 150                 void *data,
 151                 void *userdata) {
 152
 153         uint32_t *br = ASSERT_PTR(data);
 154         uint64_t sz;
 155         int r;
 156
 157         assert(filename);
 158         assert(lvalue);
 159         assert(rvalue);
 160
 161         r = parse_size(rvalue, 1000, &sz);
 162         if (r < 0) {
 163                 log_syntax(unit, LOG_WARNING, filename, line, r,
 164                            "Failed to parse can bitrate '%s', ignoring: %m", rvalue);
 165                 return 0;
 166         }
 167
 168         /* Linux uses __u32 for bitrates, so the value should not exceed that. */
 169         if (sz <= 0 || sz > UINT32_MAX) {
 170                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 171                            "Bit rate out of permitted range 1...4294967295");
 172                 return 0;
 173         }
 174
 175         *br = (uint32_t) sz;
 176
 177         return 0;
 178 }
 179
 180 int config_parse_can_time_quanta(
 181                 const char* unit,
 182                 const char *filename,
 183                 unsigned line,
 184                 const char *section,
 185                 unsigned section_line,
 186                 const char *lvalue,
 187                 int ltype,
 188                 const char *rvalue,
 189                 void *data,
 190                 void *userdata) {
 191
 192         nsec_t val, *tq = ASSERT_PTR(data);
 193         int r;
 194
 195         assert(filename);
 196         assert(lvalue);
 197         assert(rvalue);
 198
 199         r = parse_nsec(rvalue, &val);
 200         if (r < 0) {
 201                 log_syntax(unit, LOG_WARNING, filename, line, r,
 202                            "Failed to parse can time quanta '%s', ignoring: %m", rvalue);
 203                 return 0;
 204         }
 205
 206         /* Linux uses __u32 for bitrates, so the value should not exceed that. */
 207         if (val <= 0 || val > UINT32_MAX) {
 208                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 209                            "Time quanta out of permitted range 1...4294967295");
 210                 return 0;
 211         }
 212
 213         *tq = val;
 214         return 0;
 215 }
 216
 217 int config_parse_can_restart_usec(
 218                 const char* unit,
 219                 const char *filename,
 220                 unsigned line,
 221                 const char *section,
 222                 unsigned section_line,
 223                 const char *lvalue,
 224                 int ltype,
 225                 const char *rvalue,
 226                 void *data,
 227                 void *userdata) {
 228
 229         usec_t usec, *restart_usec = ASSERT_PTR(data);
 230         int r;
 231
 232         assert(filename);
 233         assert(lvalue);
 234         assert(rvalue);
 235
 236         r = parse_sec(rvalue, &usec);
 237         if (r < 0) {
 238                 log_syntax(unit, LOG_WARNING, filename, line, r,
 239                            "Failed to parse CAN restart sec '%s', ignoring: %m", rvalue);
 240                 return 0;
 241         }
 242
 243         if (usec != USEC_INFINITY &&
 244             DIV_ROUND_UP(usec, USEC_PER_MSEC) > UINT32_MAX) {
 245                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 246                            "CAN RestartSec= must be in the range 0...%"PRIu32"ms, ignoring: %s", UINT32_MAX, rvalue);
 247                 return 0;
 248         }
 249
 250         *restart_usec = usec;
 251         return 0;
 252 }
 253
 254 int config_parse_can_control_mode(
 255                 const char* unit,
 256                 const char *filename,
 257                 unsigned line,
 258                 const char *section,
 259                 unsigned section_line,
 260                 const char *lvalue,
 261                 int ltype,
 262                 const char *rvalue,
 263                 void *data,
 264                 void *userdata) {
 265
 266         Network *network = ASSERT_PTR(userdata);
 267         uint32_t mask = ltype;
 268         int r;
 269
 270         assert(filename);
 271         assert(lvalue);
 272         assert(rvalue);
 273         assert(mask != 0);
 274
 275         if (isempty(rvalue)) {
 276                 network->can_control_mode_mask &= ~mask;
 277                 network->can_control_mode_flags &= ~mask;
 278                 return 0;
 279         }
 280
 281         r = parse_boolean(rvalue);
 282         if (r < 0) {
 283                 log_syntax(unit, LOG_WARNING, filename, line, r,
 284                            "Failed to parse CAN control mode '%s', ignoring: %s", lvalue, rvalue);
 285                 return 0;
 286         }
 287
 288         network->can_control_mode_mask |= mask;
 289         SET_FLAG(network->can_control_mode_flags, mask, r);
 290         return 0;
 291 }
 292
 293 int config_parse_can_termination(
 294                 const char* unit,
 295                 const char *filename,
 296                 unsigned line,
 297                 const char *section,
 298                 unsigned section_line,
 299                 const char *lvalue,
 300                 int ltype,
 301                 const char *rvalue,
 302                 void *data,
 303                 void *userdata) {
 304
 305         Network *network = userdata;
 306         int r;
 307
 308         assert(filename);
 309         assert(lvalue);
 310         assert(rvalue);
 311         assert(data);
 312
 313         if (isempty(rvalue)) {
 314                 network->can_termination_set = false;
 315                 return 0;
 316         }
 317
 318         /* Note that 0 termination ohm value means no termination resistor, and there is no conflict
 319          * between parse_boolean() and safe_atou16() when Termination=0. However, Termination=1 must be
 320          * treated as 1 ohm, instead of true (and then the default ohm value). So, we need to parse the
 321          * string with safe_atou16() at first. */
 322
 323         r = safe_atou16(rvalue, &network->can_termination);
 324         if (r < 0) {
 325                 r = parse_boolean(rvalue);
 326                 if (r < 0) {
 327                         log_syntax(unit, LOG_WARNING, filename, line, r,
 328                                    "Failed to parse CAN termination value, ignoring: %s", rvalue);
 329                         return 0;
 330                 }
 331
 332                 network->can_termination = r ? CAN_TERMINATION_DEFAULT_OHM_VALUE : 0;
 333         }
 334
 335         network->can_termination_set = true;
 336         return 0;
 337 }