]>
Commit | Line | Data |
---|---|---|
db9ecf05 | 1 | /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
3ddcbeea | 2 | |
edda10f2 | 3 | /* Make sure the net/if.h header is included before any linux/ one */ |
3ddcbeea YW |
4 | #include <net/if.h> |
5 | #include <linux/can/netlink.h> | |
6 | ||
3ddcbeea YW |
7 | #include "networkd-can.h" |
8 | #include "networkd-link.h" | |
7558f9e7 | 9 | #include "networkd-network.h" |
112a0972 | 10 | #include "networkd-setlink.h" |
74a27268 | 11 | #include "parse-util.h" |
3ddcbeea YW |
12 | #include "string-util.h" |
13 | ||
239f91f7 | 14 | #define CAN_TERMINATION_DEFAULT_OHM_VALUE 120 |
52aa38f1 | 15 | |
7558f9e7 | 16 | int can_set_netlink_message(Link *link, sd_netlink_message *m) { |
3ddcbeea YW |
17 | int r; |
18 | ||
19 | assert(link); | |
20 | assert(link->network); | |
7558f9e7 | 21 | assert(m); |
3ddcbeea YW |
22 | |
23 | r = sd_netlink_message_set_flags(m, NLM_F_REQUEST | NLM_F_ACK); | |
24 | if (r < 0) | |
9a93dabc | 25 | return r; |
3ddcbeea YW |
26 | |
27 | r = sd_netlink_message_open_container(m, IFLA_LINKINFO); | |
28 | if (r < 0) | |
9a93dabc | 29 | return r; |
3ddcbeea YW |
30 | |
31 | r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind); | |
32 | if (r < 0) | |
9a93dabc | 33 | return r; |
3ddcbeea | 34 | |
817561cc | 35 | if (link->network->can_bitrate > 0) { |
3ddcbeea YW |
36 | struct can_bittiming bt = { |
37 | .bitrate = link->network->can_bitrate, | |
38 | .sample_point = link->network->can_sample_point, | |
b164b570 | 39 | .sjw = link->network->can_sync_jump_width, |
3ddcbeea YW |
40 | }; |
41 | ||
c0f86d66 | 42 | log_link_debug(link, "Setting bitrate = %u bit/s", bt.bitrate); |
3ddcbeea | 43 | if (link->network->can_sample_point > 0) |
c0f86d66 | 44 | log_link_debug(link, "Setting sample point = %u.%u%%", bt.sample_point / 10, bt.sample_point % 10); |
3ddcbeea YW |
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) | |
9a93dabc | 50 | return r; |
b164b570 YW |
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) | |
9a93dabc | 63 | return r; |
3ddcbeea YW |
64 | } |
65 | ||
817561cc | 66 | if (link->network->can_data_bitrate > 0) { |
7e025e9c RP |
67 | struct can_bittiming bt = { |
68 | .bitrate = link->network->can_data_bitrate, | |
69 | .sample_point = link->network->can_data_sample_point, | |
b164b570 | 70 | .sjw = link->network->can_data_sync_jump_width, |
7e025e9c RP |
71 | }; |
72 | ||
c0f86d66 | 73 | log_link_debug(link, "Setting data bitrate = %u bit/s", bt.bitrate); |
7e025e9c | 74 | if (link->network->can_data_sample_point > 0) |
c0f86d66 | 75 | log_link_debug(link, "Setting data sample point = %u.%u%%", bt.sample_point / 10, bt.sample_point % 10); |
7e025e9c RP |
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) | |
9a93dabc | 81 | return r; |
b164b570 YW |
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) | |
9a93dabc | 94 | return r; |
7e025e9c RP |
95 | } |
96 | ||
3ddcbeea | 97 | if (link->network->can_restart_us > 0) { |
3ddcbeea YW |
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 | ||
5291f26d | 105 | log_link_debug(link, "Setting restart = %s", FORMAT_TIMESPAN(restart_ms * 1000, MSEC_PER_SEC)); |
3ddcbeea YW |
106 | r = sd_netlink_message_append_u32(m, IFLA_CAN_RESTART_MS, restart_ms); |
107 | if (r < 0) | |
9a93dabc | 108 | return r; |
7558f9e7 YW |
109 | } |
110 | ||
f1c141cb YW |
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 | }; | |
3ddcbeea YW |
116 | |
117 | r = sd_netlink_message_append_data(m, IFLA_CAN_CTRLMODE, &cm, sizeof(cm)); | |
118 | if (r < 0) | |
9a93dabc | 119 | return r; |
3ddcbeea YW |
120 | } |
121 | ||
239f91f7 YW |
122 | if (link->network->can_termination_set) { |
123 | log_link_debug(link, "Setting can-termination to '%u'.", link->network->can_termination); | |
52aa38f1 | 124 | |
239f91f7 | 125 | r = sd_netlink_message_append_u16(m, IFLA_CAN_TERMINATION, link->network->can_termination); |
52aa38f1 | 126 | if (r < 0) |
9a93dabc | 127 | return r; |
52aa38f1 MR |
128 | } |
129 | ||
3ddcbeea YW |
130 | r = sd_netlink_message_close_container(m); |
131 | if (r < 0) | |
9a93dabc | 132 | return r; |
3ddcbeea YW |
133 | |
134 | r = sd_netlink_message_close_container(m); | |
135 | if (r < 0) | |
9a93dabc | 136 | return r; |
600b7898 | 137 | |
3ddcbeea YW |
138 | return 0; |
139 | } | |
952508ab YW |
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 | ||
99534007 | 153 | uint32_t *br = ASSERT_PTR(data); |
952508ab YW |
154 | uint64_t sz; |
155 | int r; | |
156 | ||
157 | assert(filename); | |
158 | assert(lvalue); | |
159 | assert(rvalue); | |
952508ab YW |
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 | } | |
0fa2984d | 179 | |
b164b570 YW |
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 | ||
99534007 | 192 | nsec_t val, *tq = ASSERT_PTR(data); |
b164b570 YW |
193 | int r; |
194 | ||
195 | assert(filename); | |
196 | assert(lvalue); | |
197 | assert(rvalue); | |
b164b570 YW |
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 | ||
0fa2984d YW |
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 | ||
99534007 | 229 | usec_t usec, *restart_usec = ASSERT_PTR(data); |
0fa2984d YW |
230 | int r; |
231 | ||
232 | assert(filename); | |
233 | assert(lvalue); | |
234 | assert(rvalue); | |
0fa2984d YW |
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 | } | |
f1c141cb YW |
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 | ||
99534007 | 266 | Network *network = ASSERT_PTR(userdata); |
f1c141cb YW |
267 | uint32_t mask = ltype; |
268 | int r; | |
269 | ||
270 | assert(filename); | |
271 | assert(lvalue); | |
272 | assert(rvalue); | |
f1c141cb YW |
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 | } | |
239f91f7 YW |
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 | } |