Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-only
2/* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix
3 * Copyright (C) 2006 Andrey Volkov, Varma Electronics
4 * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>
5 */
6
7#include <linux/can/dev.h>
8#include <net/rtnetlink.h>
9
10static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {
11 [IFLA_CAN_STATE] = { .type = NLA_U32 },
12 [IFLA_CAN_CTRLMODE] = { .len = sizeof(struct can_ctrlmode) },
13 [IFLA_CAN_RESTART_MS] = { .type = NLA_U32 },
14 [IFLA_CAN_RESTART] = { .type = NLA_U32 },
15 [IFLA_CAN_BITTIMING] = { .len = sizeof(struct can_bittiming) },
16 [IFLA_CAN_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) },
17 [IFLA_CAN_CLOCK] = { .len = sizeof(struct can_clock) },
18 [IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) },
19 [IFLA_CAN_DATA_BITTIMING] = { .len = sizeof(struct can_bittiming) },
20 [IFLA_CAN_DATA_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) },
21 [IFLA_CAN_TERMINATION] = { .type = NLA_U16 },
22};
23
24static int can_validate(struct nlattr *tb[], struct nlattr *data[],
25 struct netlink_ext_ack *extack)
26{
27 bool is_can_fd = false;
28
29 /* Make sure that valid CAN FD configurations always consist of
30 * - nominal/arbitration bittiming
31 * - data bittiming
32 * - control mode with CAN_CTRLMODE_FD set
33 */
34
35 if (!data)
36 return 0;
37
38 if (data[IFLA_CAN_CTRLMODE]) {
39 struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
40
41 is_can_fd = cm->flags & cm->mask & CAN_CTRLMODE_FD;
42 }
43
44 if (is_can_fd) {
45 if (!data[IFLA_CAN_BITTIMING] || !data[IFLA_CAN_DATA_BITTIMING])
46 return -EOPNOTSUPP;
47 }
48
49 if (data[IFLA_CAN_DATA_BITTIMING]) {
50 if (!is_can_fd)
51 return -EOPNOTSUPP;
52 }
53
54 return 0;
55}
56
57static int can_changelink(struct net_device *dev, struct nlattr *tb[],
58 struct nlattr *data[],
59 struct netlink_ext_ack *extack)
60{
61 struct can_priv *priv = netdev_priv(dev);
62 int err;
63
64 /* We need synchronization with dev->stop() */
65 ASSERT_RTNL();
66
67 if (data[IFLA_CAN_BITTIMING]) {
68 struct can_bittiming bt;
69
70 /* Do not allow changing bittiming while running */
71 if (dev->flags & IFF_UP)
72 return -EBUSY;
73
74 /* Calculate bittiming parameters based on
75 * bittiming_const if set, otherwise pass bitrate
76 * directly via do_set_bitrate(). Bail out if neither
77 * is given.
78 */
79 if (!priv->bittiming_const && !priv->do_set_bittiming)
80 return -EOPNOTSUPP;
81
82 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
83 err = can_get_bittiming(dev, &bt,
84 priv->bittiming_const,
85 priv->bitrate_const,
86 priv->bitrate_const_cnt);
87 if (err)
88 return err;
89
90 if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) {
91 netdev_err(dev, "arbitration bitrate surpasses transceiver capabilities of %d bps\n",
92 priv->bitrate_max);
93 return -EINVAL;
94 }
95
96 memcpy(&priv->bittiming, &bt, sizeof(bt));
97
98 if (priv->do_set_bittiming) {
99 /* Finally, set the bit-timing registers */
100 err = priv->do_set_bittiming(dev);
101 if (err)
102 return err;
103 }
104 }
105
106 if (data[IFLA_CAN_CTRLMODE]) {
107 struct can_ctrlmode *cm;
108 u32 ctrlstatic;
109 u32 maskedflags;
110
111 /* Do not allow changing controller mode while running */
112 if (dev->flags & IFF_UP)
113 return -EBUSY;
114 cm = nla_data(data[IFLA_CAN_CTRLMODE]);
115 ctrlstatic = priv->ctrlmode_static;
116 maskedflags = cm->flags & cm->mask;
117
118 /* check whether provided bits are allowed to be passed */
119 if (maskedflags & ~(priv->ctrlmode_supported | ctrlstatic))
120 return -EOPNOTSUPP;
121
122 /* do not check for static fd-non-iso if 'fd' is disabled */
123 if (!(maskedflags & CAN_CTRLMODE_FD))
124 ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO;
125
126 /* make sure static options are provided by configuration */
127 if ((maskedflags & ctrlstatic) != ctrlstatic)
128 return -EOPNOTSUPP;
129
130 /* clear bits to be modified and copy the flag values */
131 priv->ctrlmode &= ~cm->mask;
132 priv->ctrlmode |= maskedflags;
133
134 /* CAN_CTRLMODE_FD can only be set when driver supports FD */
135 if (priv->ctrlmode & CAN_CTRLMODE_FD) {
136 dev->mtu = CANFD_MTU;
137 } else {
138 dev->mtu = CAN_MTU;
139 memset(&priv->data_bittiming, 0,
140 sizeof(priv->data_bittiming));
141 }
142 }
143
144 if (data[IFLA_CAN_RESTART_MS]) {
145 /* Do not allow changing restart delay while running */
146 if (dev->flags & IFF_UP)
147 return -EBUSY;
148 priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
149 }
150
151 if (data[IFLA_CAN_RESTART]) {
152 /* Do not allow a restart while not running */
153 if (!(dev->flags & IFF_UP))
154 return -EINVAL;
155 err = can_restart_now(dev);
156 if (err)
157 return err;
158 }
159
160 if (data[IFLA_CAN_DATA_BITTIMING]) {
161 struct can_bittiming dbt;
162
163 /* Do not allow changing bittiming while running */
164 if (dev->flags & IFF_UP)
165 return -EBUSY;
166
167 /* Calculate bittiming parameters based on
168 * data_bittiming_const if set, otherwise pass bitrate
169 * directly via do_set_bitrate(). Bail out if neither
170 * is given.
171 */
172 if (!priv->data_bittiming_const && !priv->do_set_data_bittiming)
173 return -EOPNOTSUPP;
174
175 memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]),
176 sizeof(dbt));
177 err = can_get_bittiming(dev, &dbt,
178 priv->data_bittiming_const,
179 priv->data_bitrate_const,
180 priv->data_bitrate_const_cnt);
181 if (err)
182 return err;
183
184 if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
185 netdev_err(dev, "canfd data bitrate surpasses transceiver capabilities of %d bps\n",
186 priv->bitrate_max);
187 return -EINVAL;
188 }
189
190 memcpy(&priv->data_bittiming, &dbt, sizeof(dbt));
191
192 can_calc_tdco(dev);
193
194 if (priv->do_set_data_bittiming) {
195 /* Finally, set the bit-timing registers */
196 err = priv->do_set_data_bittiming(dev);
197 if (err)
198 return err;
199 }
200 }
201
202 if (data[IFLA_CAN_TERMINATION]) {
203 const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);
204 const unsigned int num_term = priv->termination_const_cnt;
205 unsigned int i;
206
207 if (!priv->do_set_termination)
208 return -EOPNOTSUPP;
209
210 /* check whether given value is supported by the interface */
211 for (i = 0; i < num_term; i++) {
212 if (termval == priv->termination_const[i])
213 break;
214 }
215 if (i >= num_term)
216 return -EINVAL;
217
218 /* Finally, set the termination value */
219 err = priv->do_set_termination(dev, termval);
220 if (err)
221 return err;
222
223 priv->termination = termval;
224 }
225
226 return 0;
227}
228
229static size_t can_get_size(const struct net_device *dev)
230{
231 struct can_priv *priv = netdev_priv(dev);
232 size_t size = 0;
233
234 if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */
235 size += nla_total_size(sizeof(struct can_bittiming));
236 if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */
237 size += nla_total_size(sizeof(struct can_bittiming_const));
238 size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */
239 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */
240 size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */
241 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */
242 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */
243 size += nla_total_size(sizeof(struct can_berr_counter));
244 if (priv->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */
245 size += nla_total_size(sizeof(struct can_bittiming));
246 if (priv->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */
247 size += nla_total_size(sizeof(struct can_bittiming_const));
248 if (priv->termination_const) {
249 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */
250 size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */
251 priv->termination_const_cnt);
252 }
253 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */
254 size += nla_total_size(sizeof(*priv->bitrate_const) *
255 priv->bitrate_const_cnt);
256 if (priv->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */
257 size += nla_total_size(sizeof(*priv->data_bitrate_const) *
258 priv->data_bitrate_const_cnt);
259 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */
260
261 return size;
262}
263
264static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
265{
266 struct can_priv *priv = netdev_priv(dev);
267 struct can_ctrlmode cm = {.flags = priv->ctrlmode};
268 struct can_berr_counter bec = { };
269 enum can_state state = priv->state;
270
271 if (priv->do_get_state)
272 priv->do_get_state(dev, &state);
273
274 if ((priv->bittiming.bitrate &&
275 nla_put(skb, IFLA_CAN_BITTIMING,
276 sizeof(priv->bittiming), &priv->bittiming)) ||
277
278 (priv->bittiming_const &&
279 nla_put(skb, IFLA_CAN_BITTIMING_CONST,
280 sizeof(*priv->bittiming_const), priv->bittiming_const)) ||
281
282 nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) ||
283 nla_put_u32(skb, IFLA_CAN_STATE, state) ||
284 nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) ||
285 nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) ||
286
287 (priv->do_get_berr_counter &&
288 !priv->do_get_berr_counter(dev, &bec) &&
289 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||
290
291 (priv->data_bittiming.bitrate &&
292 nla_put(skb, IFLA_CAN_DATA_BITTIMING,
293 sizeof(priv->data_bittiming), &priv->data_bittiming)) ||
294
295 (priv->data_bittiming_const &&
296 nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,
297 sizeof(*priv->data_bittiming_const),
298 priv->data_bittiming_const)) ||
299
300 (priv->termination_const &&
301 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||
302 nla_put(skb, IFLA_CAN_TERMINATION_CONST,
303 sizeof(*priv->termination_const) *
304 priv->termination_const_cnt,
305 priv->termination_const))) ||
306
307 (priv->bitrate_const &&
308 nla_put(skb, IFLA_CAN_BITRATE_CONST,
309 sizeof(*priv->bitrate_const) *
310 priv->bitrate_const_cnt,
311 priv->bitrate_const)) ||
312
313 (priv->data_bitrate_const &&
314 nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,
315 sizeof(*priv->data_bitrate_const) *
316 priv->data_bitrate_const_cnt,
317 priv->data_bitrate_const)) ||
318
319 (nla_put(skb, IFLA_CAN_BITRATE_MAX,
320 sizeof(priv->bitrate_max),
321 &priv->bitrate_max))
322 )
323
324 return -EMSGSIZE;
325
326 return 0;
327}
328
329static size_t can_get_xstats_size(const struct net_device *dev)
330{
331 return sizeof(struct can_device_stats);
332}
333
334static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
335{
336 struct can_priv *priv = netdev_priv(dev);
337
338 if (nla_put(skb, IFLA_INFO_XSTATS,
339 sizeof(priv->can_stats), &priv->can_stats))
340 goto nla_put_failure;
341 return 0;
342
343nla_put_failure:
344 return -EMSGSIZE;
345}
346
347static int can_newlink(struct net *src_net, struct net_device *dev,
348 struct nlattr *tb[], struct nlattr *data[],
349 struct netlink_ext_ack *extack)
350{
351 return -EOPNOTSUPP;
352}
353
354static void can_dellink(struct net_device *dev, struct list_head *head)
355{
356}
357
358struct rtnl_link_ops can_link_ops __read_mostly = {
359 .kind = "can",
360 .netns_refund = true,
361 .maxtype = IFLA_CAN_MAX,
362 .policy = can_policy,
363 .setup = can_setup,
364 .validate = can_validate,
365 .newlink = can_newlink,
366 .changelink = can_changelink,
367 .dellink = can_dellink,
368 .get_size = can_get_size,
369 .fill_info = can_fill_info,
370 .get_xstats_size = can_get_xstats_size,
371 .fill_xstats = can_fill_xstats,
372};
373
374int can_netlink_register(void)
375{
376 return rtnl_link_register(&can_link_ops);
377}
378
379void can_netlink_unregister(void)
380{
381 rtnl_link_unregister(&can_link_ops);
382}