19#include "nl-default.h"
21#include <linux/can/netlink.h>
23#include <netlink/netlink.h>
24#include <netlink/attr.h>
25#include <netlink/utils.h>
26#include <netlink/object.h>
27#include <netlink/route/rtnl.h>
28#include <netlink/route/link/can.h>
34#define CAN_HAS_BITTIMING (1<<0)
35#define CAN_HAS_BITTIMING_CONST (1<<1)
36#define CAN_HAS_CLOCK (1<<2)
37#define CAN_HAS_STATE (1<<3)
38#define CAN_HAS_CTRLMODE (1<<4)
39#define CAN_HAS_RESTART_MS (1<<5)
40#define CAN_HAS_RESTART (1<<6)
41#define CAN_HAS_BERR_COUNTER (1<<7)
42#define CAN_HAS_DATA_BITTIMING (1<<8)
43#define CAN_HAS_DATA_BITTIMING_CONST (1<<9)
44#define CAN_HAS_DEVICE_STATS (1<<10)
49 uint32_t ci_restart_ms;
50 struct can_ctrlmode ci_ctrlmode;
51 struct can_bittiming ci_bittiming;
52 struct can_bittiming_const ci_bittiming_const;
53 struct can_clock ci_clock;
54 struct can_berr_counter ci_berr_counter;
56 struct can_bittiming ci_data_bittiming;
57 struct can_bittiming_const ci_data_bittiming_const;
58 struct can_device_stats ci_device_stats;
66 [IFLA_CAN_RESTART_MS] = { .type =
NLA_U32 },
67 [IFLA_CAN_RESTART] = { .type =
NLA_U32 },
68 [IFLA_CAN_BITTIMING] = { .minlen =
sizeof(
struct can_bittiming) },
69 [IFLA_CAN_BITTIMING_CONST]
70 = { .minlen =
sizeof(
struct can_bittiming_const) },
71 [IFLA_CAN_CLOCK] = { .minlen =
sizeof(
struct can_clock) },
72 [IFLA_CAN_BERR_COUNTER] = { .minlen =
sizeof(
struct can_berr_counter) },
73 [IFLA_CAN_DATA_BITTIMING]
74 = { .minlen =
sizeof(
struct can_bittiming) },
75 [IFLA_CAN_DATA_BITTIMING_CONST]
76 = { .minlen =
sizeof(
struct can_bittiming_const) },
79static int can_alloc(
struct rtnl_link *link)
84 memset(link->l_info, 0,
sizeof(*ci));
86 ci = calloc(1,
sizeof(*ci));
96static int can_parse(
struct rtnl_link *link,
struct nlattr *data,
97 struct nlattr *xstats)
99 struct nlattr *tb[IFLA_CAN_MAX+1];
103 NL_DBG(3,
"Parsing CAN link info\n");
108 if ((err = can_alloc(link)) < 0)
113 if (tb[IFLA_CAN_STATE]) {
115 ci->ci_mask |= CAN_HAS_STATE;
118 if (tb[IFLA_CAN_RESTART]) {
119 ci->ci_restart =
nla_get_u32(tb[IFLA_CAN_RESTART]);
120 ci->ci_mask |= CAN_HAS_RESTART;
123 if (tb[IFLA_CAN_RESTART_MS]) {
124 ci->ci_restart_ms =
nla_get_u32(tb[IFLA_CAN_RESTART_MS]);
125 ci->ci_mask |= CAN_HAS_RESTART_MS;
128 if (tb[IFLA_CAN_CTRLMODE]) {
129 nla_memcpy(&ci->ci_ctrlmode, tb[IFLA_CAN_CTRLMODE],
130 sizeof(ci->ci_ctrlmode));
131 ci->ci_mask |= CAN_HAS_CTRLMODE;
134 if (tb[IFLA_CAN_BITTIMING]) {
135 nla_memcpy(&ci->ci_bittiming, tb[IFLA_CAN_BITTIMING],
136 sizeof(ci->ci_bittiming));
137 ci->ci_mask |= CAN_HAS_BITTIMING;
140 if (tb[IFLA_CAN_BITTIMING_CONST]) {
142 tb[IFLA_CAN_BITTIMING_CONST],
143 sizeof(ci->ci_bittiming_const));
144 ci->ci_mask |= CAN_HAS_BITTIMING_CONST;
147 if (tb[IFLA_CAN_CLOCK]) {
149 sizeof(ci->ci_clock));
150 ci->ci_mask |= CAN_HAS_CLOCK;
153 if (tb[IFLA_CAN_BERR_COUNTER]) {
154 nla_memcpy(&ci->ci_berr_counter, tb[IFLA_CAN_BERR_COUNTER],
155 sizeof(ci->ci_berr_counter));
156 ci->ci_mask |= CAN_HAS_BERR_COUNTER;
159 if (tb[IFLA_CAN_DATA_BITTIMING]) {
160 nla_memcpy(&ci->ci_data_bittiming, tb[IFLA_CAN_DATA_BITTIMING],
161 sizeof(ci->ci_data_bittiming));
162 ci->ci_mask |= CAN_HAS_DATA_BITTIMING;
165 if (tb[IFLA_CAN_DATA_BITTIMING_CONST]) {
166 nla_memcpy(&ci->ci_data_bittiming_const, tb[IFLA_CAN_DATA_BITTIMING_CONST],
167 sizeof(ci->ci_data_bittiming_const));
168 ci->ci_mask |= CAN_HAS_DATA_BITTIMING_CONST;
171 if (xstats && _nla_len(xstats) >=
sizeof(ci->ci_device_stats)) {
172 nla_memcpy(&ci->ci_device_stats, xstats,
sizeof(ci->ci_device_stats));
173 ci->ci_mask |= CAN_HAS_DEVICE_STATS;
181static void can_free(
struct rtnl_link *link)
183 struct can_info *ci = link->l_info;
189static char *print_can_state (uint32_t state)
195 case CAN_STATE_ERROR_ACTIVE:
196 text =
"error active";
198 case CAN_STATE_ERROR_WARNING:
199 text =
"error warning";
201 case CAN_STATE_ERROR_PASSIVE:
202 text =
"error passive";
204 case CAN_STATE_BUS_OFF:
207 case CAN_STATE_STOPPED:
210 case CAN_STATE_SLEEPING:
214 text =
"unknown state";
222 struct can_info *ci = link->l_info;
225 rtnl_link_can_ctrlmode2str(ci->ci_ctrlmode.flags, buf,
sizeof(buf));
226 nl_dump(p,
"bitrate %d %s <%s>",
227 ci->ci_bittiming.bitrate, print_can_state(ci->ci_state), buf);
232 struct can_info *ci = link->l_info;
234 can_dump_line(link, p);
236 if (ci->ci_mask & CAN_HAS_RESTART) {
238 nl_dump_line(p,
" restarting\n");
241 if (ci->ci_mask & CAN_HAS_RESTART_MS) {
242 nl_dump_line(p,
" restart interval %d ms\n",
246 if (ci->ci_mask & CAN_HAS_BITTIMING) {
247 nl_dump_line(p,
" sample point %f %%\n",
248 ((
float) ci->ci_bittiming.sample_point)/10);
249 nl_dump_line(p,
" time quanta %d ns\n",
250 ci->ci_bittiming.tq);
251 nl_dump_line(p,
" propagation segment %d tq\n",
252 ci->ci_bittiming.prop_seg);
253 nl_dump_line(p,
" phase buffer segment1 %d tq\n",
254 ci->ci_bittiming.phase_seg1);
255 nl_dump_line(p,
" phase buffer segment2 %d tq\n",
256 ci->ci_bittiming.phase_seg2);
257 nl_dump_line(p,
" synchronisation jump width %d tq\n",
258 ci->ci_bittiming.sjw);
259 nl_dump_line(p,
" bitrate prescaler %d\n",
260 ci->ci_bittiming.brp);
263 if (ci->ci_mask & CAN_HAS_BITTIMING_CONST) {
264 nl_dump_line(p,
" minimum tsig1 %d tq\n",
265 ci->ci_bittiming_const.tseg1_min);
266 nl_dump_line(p,
" maximum tsig1 %d tq\n",
267 ci->ci_bittiming_const.tseg1_max);
268 nl_dump_line(p,
" minimum tsig2 %d tq\n",
269 ci->ci_bittiming_const.tseg2_min);
270 nl_dump_line(p,
" maximum tsig2 %d tq\n",
271 ci->ci_bittiming_const.tseg2_max);
272 nl_dump_line(p,
" maximum sjw %d tq\n",
273 ci->ci_bittiming_const.sjw_max);
274 nl_dump_line(p,
" minimum brp %d\n",
275 ci->ci_bittiming_const.brp_min);
276 nl_dump_line(p,
" maximum brp %d\n",
277 ci->ci_bittiming_const.brp_max);
278 nl_dump_line(p,
" brp increment %d\n",
279 ci->ci_bittiming_const.brp_inc);
282 if (ci->ci_mask & CAN_HAS_CLOCK) {
283 nl_dump_line(p,
" base freq %u Hz\n", ci->ci_clock.freq);
287 if (ci->ci_mask & CAN_HAS_BERR_COUNTER) {
288 nl_dump_line(p,
" bus error RX %d\n",
289 ci->ci_berr_counter.rxerr);
290 nl_dump_line(p,
" bus error TX %d\n",
291 ci->ci_berr_counter.txerr);
297 struct can_info *ci = link->l_info;
299 can_dump_details(link, p);
301 if (ci->ci_mask & CAN_HAS_DEVICE_STATS) {
302 nl_dump_line(p,
" bus errors %d\n",
303 ci->ci_device_stats.bus_error);
304 nl_dump_line(p,
" error warning state changes %d\n",
305 ci->ci_device_stats.error_warning);
306 nl_dump_line(p,
" error passive state changes %d\n",
307 ci->ci_device_stats.error_passive);
308 nl_dump_line(p,
" bus off state changes %d\n",
309 ci->ci_device_stats.bus_off);
310 nl_dump_line(p,
" arbitration lost errors %d\n",
311 ci->ci_device_stats.arbitration_lost);
312 nl_dump_line(p,
" restarts %d\n",
313 ci->ci_device_stats.restarts);
319 struct can_info *cdst, *csrc = src->l_info;
327 cdst = malloc(
sizeof(*cdst));
337static int can_put_attrs(
struct nl_msg *msg,
struct rtnl_link *link)
339 struct can_info *ci = link->l_info;
346 if (ci->ci_mask & CAN_HAS_RESTART)
347 NLA_PUT_U32(msg, IFLA_CAN_RESTART, ci->ci_restart);
349 if (ci->ci_mask & CAN_HAS_RESTART_MS)
350 NLA_PUT_U32(msg, IFLA_CAN_RESTART_MS, ci->ci_restart_ms);
352 if (ci->ci_mask & CAN_HAS_CTRLMODE)
353 NLA_PUT(msg, IFLA_CAN_CTRLMODE,
sizeof(ci->ci_ctrlmode),
356 if (ci->ci_mask & CAN_HAS_BITTIMING)
357 NLA_PUT(msg, IFLA_CAN_BITTIMING,
sizeof(ci->ci_bittiming),
360 if (ci->ci_mask & CAN_HAS_BITTIMING_CONST)
361 NLA_PUT(msg, IFLA_CAN_BITTIMING_CONST,
362 sizeof(ci->ci_bittiming_const),
363 &ci->ci_bittiming_const);
365 if (ci->ci_mask & CAN_HAS_CLOCK)
366 NLA_PUT(msg, IFLA_CAN_CLOCK,
sizeof(ci->ci_clock),
369 if (ci->ci_mask & CAN_HAS_DATA_BITTIMING)
370 NLA_PUT(msg, IFLA_CAN_DATA_BITTIMING,
sizeof(ci->ci_data_bittiming),
371 &ci->ci_data_bittiming);
373 if (ci->ci_mask & CAN_HAS_DATA_BITTIMING_CONST)
374 NLA_PUT(msg, IFLA_CAN_DATA_BITTIMING_CONST,
sizeof(ci->ci_data_bittiming_const),
375 &ci->ci_data_bittiming_const);
386 .io_alloc = can_alloc,
387 .io_parse = can_parse,
393 .io_clone = can_clone,
394 .io_put_attrs = can_put_attrs,
399#define IS_CAN_LINK_ASSERT(link) \
400 if ((link)->l_info_ops != &can_info_ops) { \
401 APPBUG("Link is not a CAN link. set type \"can\" first."); \
402 return -NLE_OPNOTSUPP; \
419 return link->l_info_ops && !strcmp(link->l_info_ops->
io_name,
"can");
430 struct can_info *ci = link->l_info;
432 IS_CAN_LINK_ASSERT(link);
435 ci->ci_restart |= CAN_HAS_RESTART;
449 struct can_info *ci = link->l_info;
451 IS_CAN_LINK_ASSERT(link);
455 if (ci->ci_mask & CAN_HAS_CLOCK)
456 *freq = ci->ci_clock.freq;
471 struct can_info *ci = link->l_info;
473 IS_CAN_LINK_ASSERT(link);
477 *state = ci->ci_state;
490 struct can_info *ci = link->l_info;
492 IS_CAN_LINK_ASSERT(link);
494 if (ci->ci_mask & CAN_HAS_BERR_COUNTER)
495 return ci->ci_berr_counter.rxerr;
508 struct can_info *ci = link->l_info;
510 IS_CAN_LINK_ASSERT(link);
512 if (ci->ci_mask & CAN_HAS_BERR_COUNTER)
513 return ci->ci_berr_counter.txerr;
527 struct can_info *ci = link->l_info;
529 IS_CAN_LINK_ASSERT(link);
533 if (ci->ci_mask & CAN_HAS_BERR_COUNTER)
534 *berr = ci->ci_berr_counter;
549 struct can_bittiming_const *bt_const)
551 struct can_info *ci = link->l_info;
553 IS_CAN_LINK_ASSERT(link);
557 if (ci->ci_mask & CAN_HAS_BITTIMING_CONST)
558 *bt_const = ci->ci_bittiming_const;
573 struct can_bittiming *bit_timing)
575 struct can_info *ci = link->l_info;
577 IS_CAN_LINK_ASSERT(link);
581 if (ci->ci_mask & CAN_HAS_BITTIMING)
582 *bit_timing = ci->ci_bittiming;
597 const struct can_bittiming *bit_timing)
599 struct can_info *ci = link->l_info;
601 IS_CAN_LINK_ASSERT(link);
605 ci->ci_bittiming = *bit_timing;
606 ci->ci_mask |= CAN_HAS_BITTIMING;
620 struct can_info *ci = link->l_info;
622 IS_CAN_LINK_ASSERT(link);
626 if (ci->ci_mask & CAN_HAS_BITTIMING)
627 *bitrate = ci->ci_bittiming.bitrate;
643 struct can_info *ci = link->l_info;
645 IS_CAN_LINK_ASSERT(link);
647 ci->ci_bittiming.bitrate = bitrate;
648 ci->ci_mask |= CAN_HAS_BITTIMING;
662 struct can_info *ci = link->l_info;
664 IS_CAN_LINK_ASSERT(link);
668 if (ci->ci_mask & CAN_HAS_BITTIMING)
669 *sp = ci->ci_bittiming.sample_point;
685 struct can_info *ci = link->l_info;
687 IS_CAN_LINK_ASSERT(link);
689 ci->ci_bittiming.sample_point = sp;
690 ci->ci_mask |= CAN_HAS_BITTIMING;
704 struct can_info *ci = link->l_info;
706 IS_CAN_LINK_ASSERT(link);
710 if (ci->ci_mask & CAN_HAS_RESTART_MS)
711 *interval = ci->ci_restart_ms;
727 struct can_info *ci = link->l_info;
729 IS_CAN_LINK_ASSERT(link);
731 ci->ci_restart_ms = interval;
732 ci->ci_mask |= CAN_HAS_RESTART_MS;
746 struct can_info *ci = link->l_info;
748 IS_CAN_LINK_ASSERT(link);
752 if (ci->ci_mask & CAN_HAS_CTRLMODE)
753 *ctrlmode = ci->ci_ctrlmode.flags;
769 struct can_info *ci = link->l_info;
771 IS_CAN_LINK_ASSERT(link);
773 ci->ci_ctrlmode.flags |= ctrlmode;
774 ci->ci_ctrlmode.mask |= ctrlmode;
775 ci->ci_mask |= CAN_HAS_CTRLMODE;
789 struct can_info *ci = link->l_info;
791 IS_CAN_LINK_ASSERT(link);
793 ci->ci_ctrlmode.flags &= ~ctrlmode;
794 ci->ci_ctrlmode.mask |= ctrlmode;
795 ci->ci_mask |= CAN_HAS_CTRLMODE;
808 struct can_bittiming_const *data_bt_const)
810 struct can_info *ci = link->l_info;
812 IS_CAN_LINK_ASSERT(link);
816 if (ci->ci_mask & CAN_HAS_DATA_BITTIMING_CONST)
817 *data_bt_const = ci->ci_data_bittiming_const;
832 const struct can_bittiming_const *data_bt_const)
834 struct can_info *ci = link->l_info;
836 IS_CAN_LINK_ASSERT(link);
840 ci->ci_data_bittiming_const = *data_bt_const;
841 ci->ci_mask |= CAN_HAS_DATA_BITTIMING_CONST;
854 struct can_bittiming *data_bit_timing)
856 struct can_info *ci = link->l_info;
858 IS_CAN_LINK_ASSERT(link);
859 if (!data_bit_timing)
862 if (ci->ci_mask & CAN_HAS_DATA_BITTIMING)
863 *data_bit_timing = ci->ci_data_bittiming;
878 const struct can_bittiming *data_bit_timing)
880 struct can_info *ci = link->l_info;
882 IS_CAN_LINK_ASSERT(link);
883 if (!data_bit_timing)
886 ci->ci_data_bittiming = *data_bit_timing;
887 ci->ci_mask |= CAN_HAS_DATA_BITTIMING;
900 struct can_device_stats *device_stats)
902 struct can_info *ci = link->l_info;
904 IS_CAN_LINK_ASSERT(link);
908 if (ci->ci_mask & CAN_HAS_DEVICE_STATS)
909 *device_stats = ci->ci_device_stats;
911 return -NLE_MISSING_ATTR;
923static const struct trans_tbl can_ctrlmode[] = {
924 __ADD(CAN_CTRLMODE_LOOPBACK, loopback),
925 __ADD(CAN_CTRLMODE_LISTENONLY, listen-only),
926 __ADD(CAN_CTRLMODE_3_SAMPLES, triple-sampling),
927 __ADD(CAN_CTRLMODE_ONE_SHOT, one-shot),
928 __ADD(CAN_CTRLMODE_BERR_REPORTING, berr-reporting),
929 __ADD(CAN_CTRLMODE_FD, fd),
930 __ADD(CAN_CTRLMODE_PRESUME_ACK, presume-ack),
931 __ADD(CAN_CTRLMODE_FD_NON_ISO, fd-non-iso),
934char *rtnl_link_can_ctrlmode2str(
int ctrlmode,
char *buf,
size_t len)
936 return __flags2str(ctrlmode, buf, len, can_ctrlmode,
937 ARRAY_SIZE(can_ctrlmode));
940int rtnl_link_can_str2ctrlmode(
const char *name)
942 return __str2flags(name, can_ctrlmode, ARRAY_SIZE(can_ctrlmode));
947static void _nl_init can_init(
void)
952static void _nl_exit can_exit(
void)
uint32_t nla_get_u32(const struct nlattr *nla)
Return payload of 32 bit integer attribute.
#define NLA_PUT(msg, attrtype, attrlen, data)
Add unspecific attribute to netlink message.
#define NLA_PUT_U32(msg, attrtype, value)
Add 32 bit integer attribute to netlink message.
int nla_memcpy(void *dest, const struct nlattr *src, int count)
Copy attribute payload to another memory area.
struct nlattr * nla_nest_start(struct nl_msg *msg, int attrtype)
Start a new level of nested attributes.
int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla, const struct nla_policy *policy)
Create attribute index based on nested attribute.
int nla_nest_end(struct nl_msg *msg, struct nlattr *start)
Finalize nesting of attributes.
int rtnl_link_can_berr_rx(struct rtnl_link *link)
Get CAN RX bus error count.
int rtnl_link_can_set_restart_ms(struct rtnl_link *link, uint32_t interval)
Set CAN device restart intervall.
int rtnl_link_can_get_restart_ms(struct rtnl_link *link, uint32_t *interval)
Get CAN device restart intervall.
int rtnl_link_can_get_ctrlmode(struct rtnl_link *link, uint32_t *ctrlmode)
Get CAN control mode.
int rtnl_link_can_freq(struct rtnl_link *link, uint32_t *freq)
Get CAN base frequency.
int rtnl_link_can_get_bittiming(struct rtnl_link *link, struct can_bittiming *bit_timing)
Get CAN device bit-timing.
int rtnl_link_can_unset_ctrlmode(struct rtnl_link *link, uint32_t ctrlmode)
Unset a CAN Control Mode.
int rtnl_link_can_set_data_bittiming_const(struct rtnl_link *link, const struct can_bittiming_const *data_bt_const)
Set CAN FD device data bit-timing-const.
int rtnl_link_is_can(struct rtnl_link *link)
Check if link is a CAN link.
int rtnl_link_can_get_data_bittiming(struct rtnl_link *link, struct can_bittiming *data_bit_timing)
Get CAN FD device data bit-timing.
int rtnl_link_can_restart(struct rtnl_link *link)
Restart CAN device.
int rtnl_link_can_set_sample_point(struct rtnl_link *link, uint32_t sp)
Set CAN device sample point.
int rtnl_link_can_set_data_bittiming(struct rtnl_link *link, const struct can_bittiming *data_bit_timing)
Set CAN FD device data bit-timing.
int rtnl_link_can_get_sample_point(struct rtnl_link *link, uint32_t *sp)
Get CAN device sample point.
int rtnl_link_can_set_bittiming(struct rtnl_link *link, const struct can_bittiming *bit_timing)
Set CAN device bit-timing.
int rtnl_link_can_set_bitrate(struct rtnl_link *link, uint32_t bitrate)
Set CAN device bit-rate.
int rtnl_link_can_get_device_stats(struct rtnl_link *link, struct can_device_stats *device_stats)
Get CAN device stats.
int rtnl_link_can_get_data_bittiming_const(struct rtnl_link *link, struct can_bittiming_const *data_bt_const)
Get CAN FD hardware-dependent data bit-timing constant.
int rtnl_link_can_get_bitrate(struct rtnl_link *link, uint32_t *bitrate)
Get CAN device bit-timing.
int rtnl_link_can_berr_tx(struct rtnl_link *link)
Get CAN TX bus error count.
int rtnl_link_can_state(struct rtnl_link *link, uint32_t *state)
Get CAN state.
int rtnl_link_can_get_bt_const(struct rtnl_link *link, struct can_bittiming_const *bt_const)
Get CAN hardware-dependent bit-timing constant.
int rtnl_link_can_set_ctrlmode(struct rtnl_link *link, uint32_t ctrlmode)
Set a CAN Control Mode.
int rtnl_link_can_berr(struct rtnl_link *link, struct can_berr_counter *berr)
Get CAN bus error count.
int rtnl_link_register_info(struct rtnl_link_info_ops *ops)
Register operations for a link info type.
int rtnl_link_unregister_info(struct rtnl_link_info_ops *ops)
Unregister operations for a link info type.
int rtnl_link_set_type(struct rtnl_link *link, const char *type)
Set type of link object.
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
@ NL_DUMP_STATS
Dump all attributes including statistics.
@ NL_DUMP_LINE
Dump object briefly on one line.
@ NL_DUMP_DETAILS
Dump all attributes but no statistics.
Attribute validation policy.
uint16_t type
Type of attribute or NLA_UNSPEC.
Available operations to modules implementing a link info type.
char * io_name
Name of link info type, must match name on kernel side.