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)
48 uint32_t ci_restart_ms;
49 struct can_ctrlmode ci_ctrlmode;
50 struct can_bittiming ci_bittiming;
51 struct can_bittiming_const ci_bittiming_const;
52 struct can_clock ci_clock;
53 struct can_berr_counter ci_berr_counter;
55 struct can_bittiming ci_data_bittiming;
56 struct can_bittiming_const ci_data_bittiming_const;
61static struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {
63 [IFLA_CAN_CTRLMODE] = { .minlen =
sizeof(
struct can_ctrlmode) },
64 [IFLA_CAN_RESTART_MS] = { .type =
NLA_U32 },
65 [IFLA_CAN_RESTART] = { .type =
NLA_U32 },
66 [IFLA_CAN_BITTIMING] = { .minlen =
sizeof(
struct can_bittiming) },
67 [IFLA_CAN_BITTIMING_CONST]
68 = { .minlen =
sizeof(
struct can_bittiming_const) },
69 [IFLA_CAN_CLOCK] = { .minlen =
sizeof(
struct can_clock) },
70 [IFLA_CAN_BERR_COUNTER] = { .minlen =
sizeof(
struct can_berr_counter) },
71 [IFLA_CAN_DATA_BITTIMING]
72 = { .minlen =
sizeof(
struct can_bittiming) },
73 [IFLA_CAN_DATA_BITTIMING_CONST]
74 = { .minlen =
sizeof(
struct can_bittiming_const) },
77static int can_alloc(
struct rtnl_link *link)
82 memset(link->l_info, 0,
sizeof(*ci));
84 ci = calloc(1,
sizeof(*ci));
94static int can_parse(
struct rtnl_link *link,
struct nlattr *data,
95 struct nlattr *xstats)
97 struct nlattr *tb[IFLA_CAN_MAX+1];
101 NL_DBG(3,
"Parsing CAN link info\n");
106 if ((err = can_alloc(link)) < 0)
111 if (tb[IFLA_CAN_STATE]) {
113 ci->ci_mask |= CAN_HAS_STATE;
116 if (tb[IFLA_CAN_RESTART]) {
117 ci->ci_restart =
nla_get_u32(tb[IFLA_CAN_RESTART]);
118 ci->ci_mask |= CAN_HAS_RESTART;
121 if (tb[IFLA_CAN_RESTART_MS]) {
122 ci->ci_restart_ms =
nla_get_u32(tb[IFLA_CAN_RESTART_MS]);
123 ci->ci_mask |= CAN_HAS_RESTART_MS;
126 if (tb[IFLA_CAN_CTRLMODE]) {
127 nla_memcpy(&ci->ci_ctrlmode, tb[IFLA_CAN_CTRLMODE],
128 sizeof(ci->ci_ctrlmode));
129 ci->ci_mask |= CAN_HAS_CTRLMODE;
132 if (tb[IFLA_CAN_BITTIMING]) {
133 nla_memcpy(&ci->ci_bittiming, tb[IFLA_CAN_BITTIMING],
134 sizeof(ci->ci_bittiming));
135 ci->ci_mask |= CAN_HAS_BITTIMING;
138 if (tb[IFLA_CAN_BITTIMING_CONST]) {
140 tb[IFLA_CAN_BITTIMING_CONST],
141 sizeof(ci->ci_bittiming_const));
142 ci->ci_mask |= CAN_HAS_BITTIMING_CONST;
145 if (tb[IFLA_CAN_CLOCK]) {
147 sizeof(ci->ci_clock));
148 ci->ci_mask |= CAN_HAS_CLOCK;
151 if (tb[IFLA_CAN_BERR_COUNTER]) {
152 nla_memcpy(&ci->ci_berr_counter, tb[IFLA_CAN_BERR_COUNTER],
153 sizeof(ci->ci_berr_counter));
154 ci->ci_mask |= CAN_HAS_BERR_COUNTER;
157 if (tb[IFLA_CAN_DATA_BITTIMING]) {
158 nla_memcpy(&ci->ci_data_bittiming, tb[IFLA_CAN_DATA_BITTIMING],
159 sizeof(ci->ci_data_bittiming));
160 ci->ci_mask |= CAN_HAS_DATA_BITTIMING;
163 if (tb[IFLA_CAN_DATA_BITTIMING_CONST]) {
164 nla_memcpy(&ci->ci_data_bittiming_const, tb[IFLA_CAN_DATA_BITTIMING_CONST],
165 sizeof(ci->ci_data_bittiming_const));
166 ci->ci_mask |= CAN_HAS_DATA_BITTIMING_CONST;
174static void can_free(
struct rtnl_link *link)
176 struct can_info *ci = link->l_info;
182static char *print_can_state (uint32_t state)
188 case CAN_STATE_ERROR_ACTIVE:
189 text =
"error active";
191 case CAN_STATE_ERROR_WARNING:
192 text =
"error warning";
194 case CAN_STATE_ERROR_PASSIVE:
195 text =
"error passive";
197 case CAN_STATE_BUS_OFF:
200 case CAN_STATE_STOPPED:
203 case CAN_STATE_SLEEPING:
207 text =
"unknown state";
215 struct can_info *ci = link->l_info;
218 rtnl_link_can_ctrlmode2str(ci->ci_ctrlmode.flags, buf,
sizeof(buf));
219 nl_dump(p,
"bitrate %d %s <%s>",
220 ci->ci_bittiming.bitrate, print_can_state(ci->ci_state), buf);
225 struct can_info *ci = link->l_info;
228 rtnl_link_can_ctrlmode2str(ci->ci_ctrlmode.flags, buf,
sizeof(buf));
229 nl_dump(p,
" bitrate %d %s <%s>",
230 ci->ci_bittiming.bitrate, print_can_state(ci->ci_state), buf);
232 if (ci->ci_mask & CAN_HAS_RESTART) {
234 nl_dump_line(p,
" restarting\n");
237 if (ci->ci_mask & CAN_HAS_RESTART_MS) {
238 nl_dump_line(p,
" restart interval %d ms\n",
242 if (ci->ci_mask & CAN_HAS_BITTIMING) {
243 nl_dump_line(p,
" sample point %f %%\n",
244 ((
float) ci->ci_bittiming.sample_point)/10);
245 nl_dump_line(p,
" time quanta %d ns\n",
246 ci->ci_bittiming.tq);
247 nl_dump_line(p,
" propagation segment %d tq\n",
248 ci->ci_bittiming.prop_seg);
249 nl_dump_line(p,
" phase buffer segment1 %d tq\n",
250 ci->ci_bittiming.phase_seg1);
251 nl_dump_line(p,
" phase buffer segment2 %d tq\n",
252 ci->ci_bittiming.phase_seg2);
253 nl_dump_line(p,
" synchronisation jump width %d tq\n",
254 ci->ci_bittiming.sjw);
255 nl_dump_line(p,
" bitrate prescaler %d\n",
256 ci->ci_bittiming.brp);
259 if (ci->ci_mask & CAN_HAS_BITTIMING_CONST) {
260 nl_dump_line(p,
" minimum tsig1 %d tq\n",
261 ci->ci_bittiming_const.tseg1_min);
262 nl_dump_line(p,
" maximum tsig1 %d tq\n",
263 ci->ci_bittiming_const.tseg1_max);
264 nl_dump_line(p,
" minimum tsig2 %d tq\n",
265 ci->ci_bittiming_const.tseg2_min);
266 nl_dump_line(p,
" maximum tsig2 %d tq\n",
267 ci->ci_bittiming_const.tseg2_max);
268 nl_dump_line(p,
" maximum sjw %d tq\n",
269 ci->ci_bittiming_const.sjw_max);
270 nl_dump_line(p,
" minimum brp %d\n",
271 ci->ci_bittiming_const.brp_min);
272 nl_dump_line(p,
" maximum brp %d\n",
273 ci->ci_bittiming_const.brp_max);
274 nl_dump_line(p,
" brp increment %d\n",
275 ci->ci_bittiming_const.brp_inc);
278 if (ci->ci_mask & CAN_HAS_CLOCK) {
279 nl_dump_line(p,
" base freq %u Hz\n", ci->ci_clock.freq);
283 if (ci->ci_mask & CAN_HAS_BERR_COUNTER) {
284 nl_dump_line(p,
" bus error RX %d\n",
285 ci->ci_berr_counter.rxerr);
286 nl_dump_line(p,
" bus error TX %d\n",
287 ci->ci_berr_counter.txerr);
295 struct can_info *cdst, *csrc = src->l_info;
303 cdst = malloc(
sizeof(*cdst));
313static int can_put_attrs(
struct nl_msg *msg,
struct rtnl_link *link)
315 struct can_info *ci = link->l_info;
322 if (ci->ci_mask & CAN_HAS_RESTART)
323 NLA_PUT_U32(msg, IFLA_CAN_RESTART, ci->ci_restart);
325 if (ci->ci_mask & CAN_HAS_RESTART_MS)
326 NLA_PUT_U32(msg, IFLA_CAN_RESTART_MS, ci->ci_restart_ms);
328 if (ci->ci_mask & CAN_HAS_CTRLMODE)
329 NLA_PUT(msg, IFLA_CAN_CTRLMODE,
sizeof(ci->ci_ctrlmode),
332 if (ci->ci_mask & CAN_HAS_BITTIMING)
333 NLA_PUT(msg, IFLA_CAN_BITTIMING,
sizeof(ci->ci_bittiming),
336 if (ci->ci_mask & CAN_HAS_BITTIMING_CONST)
337 NLA_PUT(msg, IFLA_CAN_BITTIMING_CONST,
338 sizeof(ci->ci_bittiming_const),
339 &ci->ci_bittiming_const);
341 if (ci->ci_mask & CAN_HAS_CLOCK)
342 NLA_PUT(msg, IFLA_CAN_CLOCK,
sizeof(ci->ci_clock),
345 if (ci->ci_mask & CAN_HAS_DATA_BITTIMING)
346 NLA_PUT(msg, IFLA_CAN_DATA_BITTIMING,
sizeof(ci->ci_data_bittiming),
347 &ci->ci_data_bittiming);
349 if (ci->ci_mask & CAN_HAS_DATA_BITTIMING_CONST)
350 NLA_PUT(msg, IFLA_CAN_DATA_BITTIMING_CONST,
sizeof(ci->ci_data_bittiming_const),
351 &ci->ci_data_bittiming_const);
362 .io_alloc = can_alloc,
363 .io_parse = can_parse,
368 .io_clone = can_clone,
369 .io_put_attrs = can_put_attrs,
374#define IS_CAN_LINK_ASSERT(link) \
375 if ((link)->l_info_ops != &can_info_ops) { \
376 APPBUG("Link is not a CAN link. set type \"can\" first."); \
377 return -NLE_OPNOTSUPP; \
394 return link->l_info_ops && !strcmp(link->l_info_ops->
io_name,
"can");
405 struct can_info *ci = link->l_info;
407 IS_CAN_LINK_ASSERT(link);
410 ci->ci_restart |= CAN_HAS_RESTART;
424 struct can_info *ci = link->l_info;
426 IS_CAN_LINK_ASSERT(link);
430 if (ci->ci_mask & CAN_HAS_CLOCK)
431 *freq = ci->ci_clock.freq;
446 struct can_info *ci = link->l_info;
448 IS_CAN_LINK_ASSERT(link);
452 *state = ci->ci_state;
465 struct can_info *ci = link->l_info;
467 IS_CAN_LINK_ASSERT(link);
469 if (ci->ci_mask & CAN_HAS_BERR_COUNTER)
470 return ci->ci_berr_counter.rxerr;
483 struct can_info *ci = link->l_info;
485 IS_CAN_LINK_ASSERT(link);
487 if (ci->ci_mask & CAN_HAS_BERR_COUNTER)
488 return ci->ci_berr_counter.txerr;
502 struct can_info *ci = link->l_info;
504 IS_CAN_LINK_ASSERT(link);
508 if (ci->ci_mask & CAN_HAS_BERR_COUNTER)
509 *berr = ci->ci_berr_counter;
524 struct can_bittiming_const *bt_const)
526 struct can_info *ci = link->l_info;
528 IS_CAN_LINK_ASSERT(link);
532 if (ci->ci_mask & CAN_HAS_BITTIMING_CONST)
533 *bt_const = ci->ci_bittiming_const;
548 struct can_bittiming *bit_timing)
550 struct can_info *ci = link->l_info;
552 IS_CAN_LINK_ASSERT(link);
556 if (ci->ci_mask & CAN_HAS_BITTIMING)
557 *bit_timing = ci->ci_bittiming;
572 const struct can_bittiming *bit_timing)
574 struct can_info *ci = link->l_info;
576 IS_CAN_LINK_ASSERT(link);
580 ci->ci_bittiming = *bit_timing;
581 ci->ci_mask |= CAN_HAS_BITTIMING;
595 struct can_info *ci = link->l_info;
597 IS_CAN_LINK_ASSERT(link);
601 if (ci->ci_mask & CAN_HAS_BITTIMING)
602 *bitrate = ci->ci_bittiming.bitrate;
618 struct can_info *ci = link->l_info;
620 IS_CAN_LINK_ASSERT(link);
622 ci->ci_bittiming.bitrate = bitrate;
623 ci->ci_mask |= CAN_HAS_BITTIMING;
637 struct can_info *ci = link->l_info;
639 IS_CAN_LINK_ASSERT(link);
643 if (ci->ci_mask & CAN_HAS_BITTIMING)
644 *sp = ci->ci_bittiming.sample_point;
660 struct can_info *ci = link->l_info;
662 IS_CAN_LINK_ASSERT(link);
664 ci->ci_bittiming.sample_point = sp;
665 ci->ci_mask |= CAN_HAS_BITTIMING;
679 struct can_info *ci = link->l_info;
681 IS_CAN_LINK_ASSERT(link);
685 if (ci->ci_mask & CAN_HAS_RESTART_MS)
686 *interval = ci->ci_restart_ms;
702 struct can_info *ci = link->l_info;
704 IS_CAN_LINK_ASSERT(link);
706 ci->ci_restart_ms = interval;
707 ci->ci_mask |= CAN_HAS_RESTART_MS;
721 struct can_info *ci = link->l_info;
723 IS_CAN_LINK_ASSERT(link);
727 if (ci->ci_mask & CAN_HAS_CTRLMODE)
728 *ctrlmode = ci->ci_ctrlmode.flags;
744 struct can_info *ci = link->l_info;
746 IS_CAN_LINK_ASSERT(link);
748 ci->ci_ctrlmode.flags |= ctrlmode;
749 ci->ci_ctrlmode.mask |= ctrlmode;
750 ci->ci_mask |= CAN_HAS_CTRLMODE;
764 struct can_info *ci = link->l_info;
766 IS_CAN_LINK_ASSERT(link);
768 ci->ci_ctrlmode.flags &= ~ctrlmode;
769 ci->ci_ctrlmode.mask |= ctrlmode;
770 ci->ci_mask |= CAN_HAS_CTRLMODE;
783 struct can_bittiming_const *data_bt_const)
785 struct can_info *ci = link->l_info;
787 IS_CAN_LINK_ASSERT(link);
791 if (ci->ci_mask & CAN_HAS_DATA_BITTIMING_CONST)
792 *data_bt_const = ci->ci_data_bittiming_const;
807 const struct can_bittiming_const *data_bt_const)
809 struct can_info *ci = link->l_info;
811 IS_CAN_LINK_ASSERT(link);
815 ci->ci_data_bittiming_const = *data_bt_const;
816 ci->ci_mask |= CAN_HAS_DATA_BITTIMING_CONST;
829 struct can_bittiming *data_bit_timing)
831 struct can_info *ci = link->l_info;
833 IS_CAN_LINK_ASSERT(link);
834 if (!data_bit_timing)
837 if (ci->ci_mask & CAN_HAS_DATA_BITTIMING)
838 *data_bit_timing = ci->ci_data_bittiming;
853 const struct can_bittiming *data_bit_timing)
855 struct can_info *ci = link->l_info;
857 IS_CAN_LINK_ASSERT(link);
858 if (!data_bit_timing)
861 ci->ci_data_bittiming = *data_bit_timing;
862 ci->ci_mask |= CAN_HAS_DATA_BITTIMING;
874static const struct trans_tbl can_ctrlmode[] = {
875 __ADD(CAN_CTRLMODE_LOOPBACK, loopback),
876 __ADD(CAN_CTRLMODE_LISTENONLY, listen-only),
877 __ADD(CAN_CTRLMODE_3_SAMPLES, triple-sampling),
878 __ADD(CAN_CTRLMODE_ONE_SHOT, one-shot),
879 __ADD(CAN_CTRLMODE_BERR_REPORTING, berr-reporting),
880 __ADD(CAN_CTRLMODE_FD, fd),
881 __ADD(CAN_CTRLMODE_PRESUME_ACK, presume-ack),
882 __ADD(CAN_CTRLMODE_FD_NON_ISO, fd-non-iso),
885char *rtnl_link_can_ctrlmode2str(
int ctrlmode,
char *buf,
size_t len)
887 return __flags2str(ctrlmode, buf, len, can_ctrlmode,
888 ARRAY_SIZE(can_ctrlmode));
891int rtnl_link_can_str2ctrlmode(
const char *name)
893 return __str2flags(name, can_ctrlmode, ARRAY_SIZE(can_ctrlmode));
898static void _nl_init can_init(
void)
903static 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_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_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.