ip/iplink_can.c - main - githubmirror/iproute2

ip/iplink_can.c
974 строки30 KB
Vincent Mailhol
iplink_can: add CAN XL TMS PWM configuration support
07 дек 2025, 20:38
07 дек 2025, 20:3824a5a42
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * iplink_can.c	CAN device support
 *
 * Authors:	Wolfgang Grandegger <wg@grandegger.com>
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <linux/can/netlink.h>

#include "rt_names.h"
#include "utils.h"
#include "ip_common.h"

struct can_tdc {
	__u32 tdcv;
	__u32 tdco;
	__u32 tdcf;
};

static void print_usage(FILE *f)
{
	fprintf(f,
		"Usage: ip link set DEVICE type can\n"
		"\t[ bitrate BITRATE [ sample-point SAMPLE-POINT] ] |\n"
		"\t[ tq TQ prop-seg PROP_SEG phase-seg1 PHASE-SEG1\n \t  phase-seg2 PHASE-SEG2 [ sjw SJW ] ]\n"
		"\n"
		"\t[ dbitrate BITRATE [ dsample-point SAMPLE-POINT] ] |\n"
		"\t[ dtq TQ dprop-seg PROP_SEG dphase-seg1 PHASE-SEG1\n \t  dphase-seg2 PHASE-SEG2 [ dsjw SJW ] ]\n"
		"\t[ tdcv TDCV tdco TDCO tdcf TDCF ]\n"
		"\n"
		"\t[ xbitrate BITRATE [ xsample-point SAMPLE-POINT] ] |\n"
		"\t[ xtq TQ xprop-seg PROP_SEG xphase-seg1 PHASE-SEG1\n \t  xphase-seg2 PHASE-SEG2 [ xsjw SJW ] ]\n"
		"\t[ xtdcv TDCV xtdco TDCO xtdcf TDCF pwms PWMS pwml PWML pwmo PWMO]\n"
		"\n"
		"\t[ loopback { on | off } ]\n"
		"\t[ listen-only { on | off } ]\n"
		"\t[ triple-sampling { on | off } ]\n"
		"\t[ one-shot { on | off } ]\n"
		"\t[ berr-reporting { on | off } ]\n"
		"\t[ fd { on | off } ]\n"
		"\t[ fd-non-iso { on | off } ]\n"
		"\t[ presume-ack { on | off } ]\n"
		"\t[ cc-len8-dlc { on | off } ]\n"
		"\t[ tdc-mode { auto | manual | off } ]\n"
		"\t[ restricted { on | off } ]\n"
		"\t[ xl { on | off } ]\n"
		"\t[ xtdc-mode { auto | manual | off } ]\n"
		"\t[ tms { on | off } ]\n"
		"\n"
		"\t[ restart-ms TIME-MS ]\n"
		"\t[ restart ]\n"
		"\n"
		"\t[ termination { 0..65535 } ]\n"
		"\n"
		"\tWhere:\n"
		"\t	BITRATE		:= { NUMBER in bps }\n"
		"\t	SAMPLE-POINT	:= { 0.000..0.999 }\n"
		"\t	TQ		:= { NUMBER in ns }\n"
		"\t	PROP-SEG	:= { NUMBER in tq }\n"
		"\t	PHASE-SEG1	:= { NUMBER in tq }\n"
		"\t	PHASE-SEG2	:= { NUMBER in tq }\n"
		"\t	SJW		:= { NUMBER in tq }\n"
		"\t	TDCV		:= { NUMBER in mtq }\n"
		"\t	TDCO		:= { NUMBER in mtq }\n"
		"\t	TDCF		:= { NUMBER in mtq }\n"
		"\t	PWMS		:= { NUMBER in mtq }\n"
		"\t	PWML		:= { NUMBER in mtq }\n"
		"\t	PWMO		:= { NUMBER in mtq }\n"
		"\t	RESTART-MS	:= { 0 | NUMBER in ms }\n"
		"\n"
		"\tUnits:\n"
		"\t	bps	:= bit per second\n"
		"\t	ms	:= millisecond\n"
		"\t	mtq	:= minimum time quanta\n"
		"\t	ns	:= nanosecond\n"
		"\t	tq	:= time quanta\n"
		);
}

static void usage(void)
{
	print_usage(stderr);
}

static void set_ctrlmode(char *name, char *arg,
			 struct can_ctrlmode *cm, __u32 flags)
{
	if (strcmp(arg, "on") == 0) {
		cm->flags |= flags;
	} else if (strcmp(arg, "off") != 0) {
		fprintf(stderr,
			"Error: argument of \"%s\" must be \"on\" or \"off\", not \"%s\"\n",
			name, arg);
		exit(-1);
	}
	cm->mask |= flags;
}

static void print_flag(enum output_type t, __u32 *flags, __u32 flag,
		       const char *name)
{
	if (*flags & flag) {
		*flags &= ~flag;
		print_string(t, NULL, *flags ? "%s," : "%s", name);
	}
}

static void print_ctrlmode(enum output_type t, __u32 flags, const char *key)
{
	if (!flags)
		return;

	open_json_array(t, is_json_context() ? key : "<");

	print_flag(t, &flags, CAN_CTRLMODE_LOOPBACK, "LOOPBACK");
	print_flag(t, &flags, CAN_CTRLMODE_LISTENONLY, "LISTEN-ONLY");
	print_flag(t, &flags, CAN_CTRLMODE_3_SAMPLES, "TRIPLE-SAMPLING");
	print_flag(t, &flags, CAN_CTRLMODE_ONE_SHOT, "ONE-SHOT");
	print_flag(t, &flags, CAN_CTRLMODE_BERR_REPORTING, "BERR-REPORTING");
	print_flag(t, &flags, CAN_CTRLMODE_FD, "FD");
	print_flag(t, &flags, CAN_CTRLMODE_FD_NON_ISO, "FD-NON-ISO");
	print_flag(t, &flags, CAN_CTRLMODE_PRESUME_ACK, "PRESUME-ACK");
	print_flag(t, &flags, CAN_CTRLMODE_CC_LEN8_DLC, "CC-LEN8-DLC");
	print_flag(t, &flags, CAN_CTRLMODE_TDC_AUTO, "TDC-AUTO");
	print_flag(t, &flags, CAN_CTRLMODE_TDC_MANUAL, "TDC-MANUAL");
	print_flag(t, &flags, CAN_CTRLMODE_RESTRICTED, "RESTRICTED");
	print_flag(t, &flags, CAN_CTRLMODE_XL, "XL");
	print_flag(t, &flags, CAN_CTRLMODE_XL_TDC_AUTO, "XL-TDC-AUTO");
	print_flag(t, &flags, CAN_CTRLMODE_XL_TDC_MANUAL, "XL-TDC-MANUAL");
	print_flag(t, &flags, CAN_CTRLMODE_XL_TMS, "TMS");

	if (flags)
		print_hex(t, NULL, "%x", flags);

	close_json_array(t, "> ");
}

static int can_parse_opt(struct link_util *lu, int argc, char **argv,
			 struct nlmsghdr *n)
{
	struct can_bittiming bt = {}, fd_dbt = {}, xl_dbt = {};
	struct can_ctrlmode cm = { 0 };
	struct can_tdc fd = { .tdcv = -1, .tdco = -1, .tdcf = -1 };
	struct can_tdc xl = { .tdcv = -1, .tdco = -1, .tdcf = -1 };
	__u32 pwms = -1, pwml = -1, pwmo = -1;

	while (argc > 0) {
		if (matches(*argv, "bitrate") == 0) {
			NEXT_ARG();
			if (get_u32(&bt.bitrate, *argv, 0))
				invarg("invalid \"bitrate\" value", *argv);
		} else if (matches(*argv, "sample-point") == 0) {
			float sp;

			NEXT_ARG();
			if (get_float(&sp, *argv))
				invarg("invalid \"sample-point\" value",
				       *argv);
			bt.sample_point = (__u32)(sp * 1000);
		} else if (matches(*argv, "tq") == 0) {
			NEXT_ARG();
			if (get_u32(&bt.tq, *argv, 0))
				invarg("invalid \"tq\" value", *argv);
		} else if (matches(*argv, "prop-seg") == 0) {
			NEXT_ARG();
			if (get_u32(&bt.prop_seg, *argv, 0))
				invarg("invalid \"prop-seg\" value", *argv);
		} else if (matches(*argv, "phase-seg1") == 0) {
			NEXT_ARG();
			if (get_u32(&bt.phase_seg1, *argv, 0))
				invarg("invalid \"phase-seg1\" value", *argv);
		} else if (matches(*argv, "phase-seg2") == 0) {
			NEXT_ARG();
			if (get_u32(&bt.phase_seg2, *argv, 0))
				invarg("invalid \"phase-seg2\" value", *argv);
		} else if (matches(*argv, "sjw") == 0) {
			NEXT_ARG();
			if (get_u32(&bt.sjw, *argv, 0))
				invarg("invalid \"sjw\" value", *argv);
		} else if (matches(*argv, "dbitrate") == 0) {
			NEXT_ARG();
			if (get_u32(&fd_dbt.bitrate, *argv, 0))
				invarg("invalid \"dbitrate\" value", *argv);
		} else if (matches(*argv, "dsample-point") == 0) {
			float sp;

			NEXT_ARG();
			if (get_float(&sp, *argv))
				invarg("invalid \"dsample-point\" value", *argv);
			fd_dbt.sample_point = (__u32)(sp * 1000);
		} else if (matches(*argv, "dtq") == 0) {
			NEXT_ARG();
			if (get_u32(&fd_dbt.tq, *argv, 0))
				invarg("invalid \"dtq\" value", *argv);
		} else if (matches(*argv, "dprop-seg") == 0) {
			NEXT_ARG();
			if (get_u32(&fd_dbt.prop_seg, *argv, 0))
				invarg("invalid \"dprop-seg\" value", *argv);
		} else if (matches(*argv, "dphase-seg1") == 0) {
			NEXT_ARG();
			if (get_u32(&fd_dbt.phase_seg1, *argv, 0))
				invarg("invalid \"dphase-seg1\" value", *argv);
		} else if (matches(*argv, "dphase-seg2") == 0) {
			NEXT_ARG();
			if (get_u32(&fd_dbt.phase_seg2, *argv, 0))
				invarg("invalid \"dphase-seg2\" value", *argv);
		} else if (matches(*argv, "dsjw") == 0) {
			NEXT_ARG();
			if (get_u32(&fd_dbt.sjw, *argv, 0))
				invarg("invalid \"dsjw\" value", *argv);
		} else if (matches(*argv, "tdcv") == 0) {
			NEXT_ARG();
			if (get_u32(&fd.tdcv, *argv, 0))
				invarg("invalid \"tdcv\" value", *argv);
		} else if (matches(*argv, "tdco") == 0) {
			NEXT_ARG();
			if (get_u32(&fd.tdco, *argv, 0))
				invarg("invalid \"tdco\" value", *argv);
		} else if (matches(*argv, "tdcf") == 0) {
			NEXT_ARG();
			if (get_u32(&fd.tdcf, *argv, 0))
				invarg("invalid \"tdcf\" value", *argv);
		} else if (strcmp(*argv, "xl") == 0) {
			NEXT_ARG();
			set_ctrlmode("xl", *argv, &cm, CAN_CTRLMODE_XL);
		} else if (strcmp(*argv, "xbitrate") == 0) {
			NEXT_ARG();
			if (get_u32(&xl_dbt.bitrate, *argv, 0))
				invarg("invalid \"xbitrate\" value", *argv);
		} else if (strcmp(*argv, "xsample-point") == 0) {
			float sp;

			NEXT_ARG();
			if (get_float(&sp, *argv))
				invarg("invalid \"xsample-point\" value", *argv);
			xl_dbt.sample_point = (__u32)(sp * 1000);
		} else if (strcmp(*argv, "xtq") == 0) {
			NEXT_ARG();
			if (get_u32(&xl_dbt.tq, *argv, 0))
				invarg("invalid \"xtq\" value", *argv);
		} else if (strcmp(*argv, "xprop-seg") == 0) {
			NEXT_ARG();
			if (get_u32(&xl_dbt.prop_seg, *argv, 0))
				invarg("invalid \"xprop-seg\" value", *argv);
		} else if (strcmp(*argv, "xphase-seg1") == 0) {
			NEXT_ARG();
			if (get_u32(&xl_dbt.phase_seg1, *argv, 0))
				invarg("invalid \"xphase-seg1\" value", *argv);
		} else if (strcmp(*argv, "xphase-seg2") == 0) {
			NEXT_ARG();
			if (get_u32(&xl_dbt.phase_seg2, *argv, 0))
				invarg("invalid \"xphase-seg2\" value", *argv);
		} else if (strcmp(*argv, "xsjw") == 0) {
			NEXT_ARG();
			if (get_u32(&xl_dbt.sjw, *argv, 0))
				invarg("invalid \"xsjw\" value", *argv);
		} else if (strcmp(*argv, "xtdcv") == 0) {
			NEXT_ARG();
			if (get_u32(&xl.tdcv, *argv, 0))
				invarg("invalid \"xtdcv\" value", *argv);
		} else if (strcmp(*argv, "xtdco") == 0) {
			NEXT_ARG();
			if (get_u32(&xl.tdco, *argv, 0))
				invarg("invalid \"xtdco\" value", *argv);
		} else if (strcmp(*argv, "xtdcf") == 0) {
			NEXT_ARG();
			if (get_u32(&xl.tdcf, *argv, 0))
				invarg("invalid \"xtdcf\" value", *argv);
		} else if (strcmp(*argv, "pwms") == 0) {
			NEXT_ARG();
			if (get_u32(&pwms, *argv, 0))
				invarg("invalid \"pwms\" value", *argv);
		} else if (strcmp(*argv, "pwml") == 0) {
			NEXT_ARG();
			if (get_u32(&pwml, *argv, 0))
				invarg("invalid \"pwml\" value", *argv);
		} else if (strcmp(*argv, "pwmo") == 0) {
			NEXT_ARG();
			if (get_u32(&pwmo, *argv, 0))
				invarg("invalid \"pwmo\" value", *argv);
		} else if (matches(*argv, "loopback") == 0) {
			NEXT_ARG();
			set_ctrlmode("loopback", *argv, &cm,
				     CAN_CTRLMODE_LOOPBACK);
		} else if (matches(*argv, "listen-only") == 0) {
			NEXT_ARG();
			set_ctrlmode("listen-only", *argv, &cm,
				     CAN_CTRLMODE_LISTENONLY);
		} else if (matches(*argv, "triple-sampling") == 0) {
			NEXT_ARG();
			set_ctrlmode("triple-sampling", *argv, &cm,
				     CAN_CTRLMODE_3_SAMPLES);
		} else if (matches(*argv, "one-shot") == 0) {
			NEXT_ARG();
			set_ctrlmode("one-shot", *argv, &cm,
				     CAN_CTRLMODE_ONE_SHOT);
		} else if (matches(*argv, "berr-reporting") == 0) {
			NEXT_ARG();
			set_ctrlmode("berr-reporting", *argv, &cm,
				     CAN_CTRLMODE_BERR_REPORTING);
		} else if (matches(*argv, "fd") == 0) {
			NEXT_ARG();
			set_ctrlmode("fd", *argv, &cm,
				     CAN_CTRLMODE_FD);
		} else if (matches(*argv, "fd-non-iso") == 0) {
			NEXT_ARG();
			set_ctrlmode("fd-non-iso", *argv, &cm,
				     CAN_CTRLMODE_FD_NON_ISO);
		} else if (matches(*argv, "presume-ack") == 0) {
			NEXT_ARG();
			set_ctrlmode("presume-ack", *argv, &cm,
				     CAN_CTRLMODE_PRESUME_ACK);
		} else if (matches(*argv, "cc-len8-dlc") == 0) {
			NEXT_ARG();
			set_ctrlmode("cc-len8-dlc", *argv, &cm,
				     CAN_CTRLMODE_CC_LEN8_DLC);
		} else if (matches(*argv, "tdc-mode") == 0) {
			NEXT_ARG();
			if (strcmp(*argv, "auto") == 0) {
				cm.flags |= CAN_CTRLMODE_TDC_AUTO;
				cm.mask |= CAN_CTRLMODE_TDC_AUTO;
			} else if (strcmp(*argv, "manual") == 0) {
				cm.flags |= CAN_CTRLMODE_TDC_MANUAL;
				cm.mask |= CAN_CTRLMODE_TDC_MANUAL;
			} else if (strcmp(*argv, "off") == 0) {
				cm.mask |= CAN_CTRLMODE_TDC_AUTO |
					   CAN_CTRLMODE_TDC_MANUAL;
			} else {
				invarg("\"tdc-mode\" must be either of \"auto\", \"manual\" or \"off\"",
					*argv);
			}
		} else if (strcmp(*argv, "restricted") == 0) {
			NEXT_ARG();
			set_ctrlmode("restricted", *argv, &cm, CAN_CTRLMODE_RESTRICTED);
		} else if (strcmp(*argv, "xtdc-mode") == 0) {
			NEXT_ARG();
			if (strcmp(*argv, "auto") == 0) {
				cm.flags |= CAN_CTRLMODE_XL_TDC_AUTO;
				cm.mask |= CAN_CTRLMODE_XL_TDC_AUTO;
			} else if (strcmp(*argv, "manual") == 0) {
				cm.flags |= CAN_CTRLMODE_XL_TDC_MANUAL;
				cm.mask |= CAN_CTRLMODE_XL_TDC_MANUAL;
			} else if (strcmp(*argv, "off") == 0) {
				cm.mask |= CAN_CTRLMODE_XL_TDC_AUTO |
					   CAN_CTRLMODE_XL_TDC_MANUAL;
			} else {
				invarg("\"xtdc-mode\" must be either of \"auto\", \"manual\" or \"off\"",
					*argv);
			}
		} else if (strcmp(*argv, "tms") == 0) {
			NEXT_ARG();
			set_ctrlmode("tms", *argv, &cm, CAN_CTRLMODE_XL_TMS);
		} else if (matches(*argv, "restart") == 0) {
			__u32 val = 1;

			addattr32(n, 1024, IFLA_CAN_RESTART, val);
		} else if (matches(*argv, "restart-ms") == 0) {
			__u32 val;

			NEXT_ARG();
			if (get_u32(&val, *argv, 0))
				invarg("invalid \"restart-ms\" value", *argv);
			addattr32(n, 1024, IFLA_CAN_RESTART_MS, val);
		} else if (matches(*argv, "termination") == 0) {
			__u16 val;

			NEXT_ARG();
			if (get_u16(&val, *argv, 0))
				invarg("invalid \"termination\" value",
				       *argv);
			addattr16(n, 1024, IFLA_CAN_TERMINATION, val);
		} else if (matches(*argv, "help") == 0) {
			usage();
			return -1;
		} else {
			fprintf(stderr, "can: unknown option \"%s\"\n", *argv);
			usage();
			return -1;
		}
		argc--, argv++;
	}

	if (bt.bitrate || bt.tq)
		addattr_l(n, 1024, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
	if (fd_dbt.bitrate || fd_dbt.tq)
		addattr_l(n, 1024, IFLA_CAN_DATA_BITTIMING, &fd_dbt, sizeof(fd_dbt));
	if (xl_dbt.bitrate || xl_dbt.tq)
		addattr_l(n, 1024, IFLA_CAN_XL_DATA_BITTIMING, &xl_dbt, sizeof(xl_dbt));
	if (cm.mask)
		addattr_l(n, 1024, IFLA_CAN_CTRLMODE, &cm, sizeof(cm));

	if (fd.tdcv != -1 || fd.tdco != -1 || fd.tdcf != -1) {
		struct rtattr *tdc = addattr_nest(n, 1024,
						  IFLA_CAN_TDC | NLA_F_NESTED);

		if (fd.tdcv != -1)
			addattr32(n, 1024, IFLA_CAN_TDC_TDCV, fd.tdcv);
		if (fd.tdco != -1)
			addattr32(n, 1024, IFLA_CAN_TDC_TDCO, fd.tdco);
		if (fd.tdcf != -1)
			addattr32(n, 1024, IFLA_CAN_TDC_TDCF, fd.tdcf);
		addattr_nest_end(n, tdc);
	}
	if (xl.tdcv != -1 || xl.tdco != -1 || xl.tdcf != -1) {
		struct rtattr *tdc = addattr_nest(n, 1024,
						  IFLA_CAN_XL_TDC | NLA_F_NESTED);

		if (xl.tdcv != -1)
			addattr32(n, 1024, IFLA_CAN_TDC_TDCV, xl.tdcv);
		if (xl.tdco != -1)
			addattr32(n, 1024, IFLA_CAN_TDC_TDCO, xl.tdco);
		if (xl.tdcf != -1)
			addattr32(n, 1024, IFLA_CAN_TDC_TDCF, xl.tdcf);
		addattr_nest_end(n, tdc);
	}
	if (pwms != -1 || pwml != -1 || pwmo != -1) {
		struct rtattr *pwm = addattr_nest(n, 1024,
						  IFLA_CAN_XL_PWM | NLA_F_NESTED);

		if (pwms != -1)
			addattr32(n, 1024, IFLA_CAN_PWM_PWMS, pwms);
		if (pwml != -1)
			addattr32(n, 1024, IFLA_CAN_PWM_PWML, pwml);
		if (pwmo != -1)
			addattr32(n, 1024, IFLA_CAN_PWM_PWMO, pwmo);
		addattr_nest_end(n, pwm);
	}

	return 0;
}

static const char *can_state_names[CAN_STATE_MAX] = {
	[CAN_STATE_ERROR_ACTIVE] = "ERROR-ACTIVE",
	[CAN_STATE_ERROR_WARNING] = "ERROR-WARNING",
	[CAN_STATE_ERROR_PASSIVE] = "ERROR-PASSIVE",
	[CAN_STATE_BUS_OFF] = "BUS-OFF",
	[CAN_STATE_STOPPED] = "STOPPED",
	[CAN_STATE_SLEEPING] = "SLEEPING"
};

static void can_print_nl_indent(void)
{
	print_nl();
	print_string(PRINT_FP, NULL, "%s", "\t ");
}

static void __attribute__((format(printf, 2, 0)))
can_print_timing_min_max(const char *json_attr, const char *fp_attr,
			 int min, int max)
{
	print_null(PRINT_FP, NULL, fp_attr, NULL);
	open_json_object(json_attr);
	print_uint(PRINT_ANY, "min", " %d", min);
	print_uint(PRINT_ANY, "max", "..%d", max);
	close_json_object();
}

static void can_print_tdc_opt(struct rtattr *tdc_attr)
{
	struct rtattr *tb[IFLA_CAN_TDC_MAX + 1];

	parse_rtattr_nested(tb, IFLA_CAN_TDC_MAX, tdc_attr);
	if (tb[IFLA_CAN_TDC_TDCV] || tb[IFLA_CAN_TDC_TDCO] ||
	    tb[IFLA_CAN_TDC_TDCF]) {
		open_json_object("tdc");
		can_print_nl_indent();
		if (tb[IFLA_CAN_TDC_TDCV]) {
			__u32 *tdcv = RTA_DATA(tb[IFLA_CAN_TDC_TDCV]);

			print_uint(PRINT_ANY, "tdcv", " tdcv %u", *tdcv);
		}
		if (tb[IFLA_CAN_TDC_TDCO]) {
			__u32 *tdco = RTA_DATA(tb[IFLA_CAN_TDC_TDCO]);

			print_uint(PRINT_ANY, "tdco", " tdco %u", *tdco);
		}
		if (tb[IFLA_CAN_TDC_TDCF]) {
			__u32 *tdcf = RTA_DATA(tb[IFLA_CAN_TDC_TDCF]);

			print_uint(PRINT_ANY, "tdcf", " tdcf %u", *tdcf);
		}
		close_json_object();
	}
}

static void can_print_xtdc_opt(struct rtattr *tdc_attr)
{
	struct rtattr *tb[IFLA_CAN_TDC_MAX + 1];

	parse_rtattr_nested(tb, IFLA_CAN_TDC_MAX, tdc_attr);
	if (tb[IFLA_CAN_TDC_TDCV] || tb[IFLA_CAN_TDC_TDCO] ||
	    tb[IFLA_CAN_TDC_TDCF]) {
		open_json_object("xtdc");
		can_print_nl_indent();
		if (tb[IFLA_CAN_TDC_TDCV]) {
			__u32 *tdcv = RTA_DATA(tb[IFLA_CAN_TDC_TDCV]);

			print_uint(PRINT_ANY, "tdcv", " xtdcv %u", *tdcv);
		}
		if (tb[IFLA_CAN_TDC_TDCO]) {
			__u32 *tdco = RTA_DATA(tb[IFLA_CAN_TDC_TDCO]);

			print_uint(PRINT_ANY, "tdco", " xtdco %u", *tdco);
		}
		if (tb[IFLA_CAN_TDC_TDCF]) {
			__u32 *tdcf = RTA_DATA(tb[IFLA_CAN_TDC_TDCF]);

			print_uint(PRINT_ANY, "tdcf", " xtdcf %u", *tdcf);
		}
		close_json_object();
	}
}

static void can_print_tdc_const_opt(struct rtattr *tdc_attr, bool is_xl)
{
	const char *tdc = is_xl ? "xtdc" : "tdc";
	struct rtattr *tb[IFLA_CAN_TDC_MAX + 1];

	parse_rtattr_nested(tb, IFLA_CAN_TDC_MAX, tdc_attr);
	open_json_object(tdc);
	can_print_nl_indent();
	if (tb[IFLA_CAN_TDC_TDCV_MIN] && tb[IFLA_CAN_TDC_TDCV_MAX]) {
		__u32 *tdcv_min = RTA_DATA(tb[IFLA_CAN_TDC_TDCV_MIN]);
		__u32 *tdcv_max = RTA_DATA(tb[IFLA_CAN_TDC_TDCV_MAX]);
		const char *tdcv = is_xl ? " xtdcv" : " tdcv";

		can_print_timing_min_max("tdcv", tdcv, *tdcv_min, *tdcv_max);
	}
	if (tb[IFLA_CAN_TDC_TDCO_MIN] && tb[IFLA_CAN_TDC_TDCO_MAX]) {
		__u32 *tdco_min = RTA_DATA(tb[IFLA_CAN_TDC_TDCO_MIN]);
		__u32 *tdco_max = RTA_DATA(tb[IFLA_CAN_TDC_TDCO_MAX]);
		const char *tdco = is_xl ? " xtdco" : " tdco";

		can_print_timing_min_max("tdco", tdco, *tdco_min, *tdco_max);
	}
	if (tb[IFLA_CAN_TDC_TDCF_MIN] && tb[IFLA_CAN_TDC_TDCF_MAX]) {
		__u32 *tdcf_min = RTA_DATA(tb[IFLA_CAN_TDC_TDCF_MIN]);
		__u32 *tdcf_max = RTA_DATA(tb[IFLA_CAN_TDC_TDCF_MAX]);
		const char *tdcf = is_xl ? " xtdcf" : " tdcf";

		can_print_timing_min_max("tdcf", tdcf, *tdcf_min, *tdcf_max);
	}
	close_json_object();
}

static void can_print_pwm_opt(struct rtattr *pwm_attr)
{
	struct rtattr *tb[IFLA_CAN_PWM_MAX + 1];

	parse_rtattr_nested(tb, IFLA_CAN_PWM_MAX, pwm_attr);
	if (tb[IFLA_CAN_PWM_PWMS] || tb[IFLA_CAN_PWM_PWML] ||
	    tb[IFLA_CAN_PWM_PWMO]) {
		open_json_object("pwm");
		can_print_nl_indent();
		if (tb[IFLA_CAN_PWM_PWMS]) {
			__u32 *pwms = RTA_DATA(tb[IFLA_CAN_PWM_PWMS]);

			print_uint(PRINT_ANY, " pwms", " pwms %u", *pwms);
		}
		if (tb[IFLA_CAN_PWM_PWML]) {
			__u32 *pwml = RTA_DATA(tb[IFLA_CAN_PWM_PWML]);

			print_uint(PRINT_ANY, " pwml", " pwml %u", *pwml);
		}
		if (tb[IFLA_CAN_PWM_PWMO]) {
			__u32 *pwmo = RTA_DATA(tb[IFLA_CAN_PWM_PWMO]);

			print_uint(PRINT_ANY, " pwmo", " pwmo %u", *pwmo);
		}
		close_json_object();
	}
}

static void can_print_pwm_const_opt(struct rtattr *pwm_attr)
{
	struct rtattr *tb[IFLA_CAN_PWM_MAX + 1];

	parse_rtattr_nested(tb, IFLA_CAN_PWM_MAX, pwm_attr);
	open_json_object("pwm");
	can_print_nl_indent();
	if (tb[IFLA_CAN_PWM_PWMS_MAX]) {
		__u32 *pwms_min = RTA_DATA(tb[IFLA_CAN_PWM_PWMS_MIN]);
		__u32 *pwms_max = RTA_DATA(tb[IFLA_CAN_PWM_PWMS_MAX]);

		can_print_timing_min_max("pwms", " pwms", *pwms_min, *pwms_max);
	}
	if (tb[IFLA_CAN_PWM_PWML_MAX]) {
		__u32 *pwml_min = RTA_DATA(tb[IFLA_CAN_PWM_PWML_MIN]);
		__u32 *pwml_max = RTA_DATA(tb[IFLA_CAN_PWM_PWML_MAX]);

		can_print_timing_min_max("pwml", " pwml", *pwml_min, *pwml_max);
	}
	if (tb[IFLA_CAN_PWM_PWMO_MAX]) {
		__u32 *pwmo_min = RTA_DATA(tb[IFLA_CAN_PWM_PWMO_MIN]);
		__u32 *pwmo_max = RTA_DATA(tb[IFLA_CAN_PWM_PWMO_MAX]);

		can_print_timing_min_max("pwmo", " pwmo", *pwmo_min, *pwmo_max);
	}
	close_json_object();
}

static void can_print_ctrlmode_ext(struct rtattr *ctrlmode_ext_attr,
				   __u32 cm_flags)
{
	struct rtattr *tb[IFLA_CAN_CTRLMODE_MAX + 1];

	parse_rtattr_nested(tb, IFLA_CAN_CTRLMODE_MAX, ctrlmode_ext_attr);
	if (tb[IFLA_CAN_CTRLMODE_SUPPORTED]) {
		__u32 *supported = RTA_DATA(tb[IFLA_CAN_CTRLMODE_SUPPORTED]);

		print_ctrlmode(PRINT_JSON, *supported, "ctrlmode_supported");
		print_ctrlmode(PRINT_JSON, cm_flags & ~*supported, "ctrlmode_static");
	}
}

static void can_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
{
	if (!tb)
		return;

	if (tb[IFLA_CAN_CTRLMODE]) {
		struct can_ctrlmode *cm = RTA_DATA(tb[IFLA_CAN_CTRLMODE]);

		print_ctrlmode(PRINT_ANY, cm->flags, "ctrlmode");
		if (tb[IFLA_CAN_CTRLMODE_EXT])
			can_print_ctrlmode_ext(tb[IFLA_CAN_CTRLMODE_EXT],
					       cm->flags);
	}

	if (tb[IFLA_CAN_STATE]) {
		uint32_t state = rta_getattr_u32(tb[IFLA_CAN_STATE]);

		print_string(PRINT_ANY, "state", "state %s ", state < CAN_STATE_MAX ?
			can_state_names[state] : "UNKNOWN");
	}

	if (tb[IFLA_CAN_BERR_COUNTER]) {
		struct can_berr_counter *bc =
			RTA_DATA(tb[IFLA_CAN_BERR_COUNTER]);

		open_json_object("berr_counter");
		print_uint(PRINT_ANY, "tx", "(berr-counter tx %u", bc->txerr);
		print_uint(PRINT_ANY, "rx", " rx %u) ", bc->rxerr);
		close_json_object();
	}

	if (tb[IFLA_CAN_RESTART_MS]) {
		__u32 *restart_ms = RTA_DATA(tb[IFLA_CAN_RESTART_MS]);

		print_uint(PRINT_ANY, "restart_ms", "restart-ms %u ",
			   *restart_ms);
	}

	/* bittiming is irrelevant if fixed bitrate is defined */
	if (tb[IFLA_CAN_BITTIMING] && !tb[IFLA_CAN_BITRATE_CONST]) {
		struct can_bittiming *bt = RTA_DATA(tb[IFLA_CAN_BITTIMING]);
		char sp[6];

		open_json_object("bittiming");
		can_print_nl_indent();
		print_uint(PRINT_ANY, "bitrate", " bitrate %u", bt->bitrate);
		snprintf(sp, sizeof(sp), "%.3f", bt->sample_point / 1000.);
		print_string(PRINT_ANY, "sample_point", " sample-point %s", sp);
		can_print_nl_indent();
		print_uint(PRINT_ANY, "tq", " tq %u", bt->tq);
		print_uint(PRINT_ANY, "prop_seg", " prop-seg %u", bt->prop_seg);
		print_uint(PRINT_ANY, "phase_seg1", " phase-seg1 %u",
			   bt->phase_seg1);
		print_uint(PRINT_ANY, "phase_seg2", " phase-seg2 %u",
			   bt->phase_seg2);
		print_uint(PRINT_ANY, "sjw", " sjw %u", bt->sjw);
		print_uint(PRINT_ANY, "brp", " brp %u", bt->brp);
		close_json_object();
	}

	/* bittiming const is irrelevant if fixed bitrate is defined */
	if (tb[IFLA_CAN_BITTIMING_CONST] && !tb[IFLA_CAN_BITRATE_CONST]) {
		struct can_bittiming_const *btc =
			RTA_DATA(tb[IFLA_CAN_BITTIMING_CONST]);

		open_json_object("bittiming_const");
		can_print_nl_indent();
		print_string(PRINT_ANY, "name", " %s:", btc->name);
		can_print_timing_min_max("tseg1", " tseg1",
					 btc->tseg1_min, btc->tseg1_max);
		can_print_timing_min_max("tseg2", " tseg2",
					 btc->tseg2_min, btc->tseg2_max);
		can_print_timing_min_max("sjw", " sjw", 1, btc->sjw_max);
		can_print_timing_min_max("brp", " brp",
					 btc->brp_min, btc->brp_max);
		print_uint(PRINT_ANY, "brp_inc", " brp_inc %u", btc->brp_inc);
		close_json_object();
	}

	if (tb[IFLA_CAN_BITRATE_CONST]) {
		__u32 *bitrate_const = RTA_DATA(tb[IFLA_CAN_BITRATE_CONST]);
		int bitrate_cnt = RTA_PAYLOAD(tb[IFLA_CAN_BITRATE_CONST]) /
			sizeof(*bitrate_const);
		int i;
		__u32 bitrate = 0;

		if (tb[IFLA_CAN_BITTIMING]) {
			struct can_bittiming *bt =
				RTA_DATA(tb[IFLA_CAN_BITTIMING]);
			bitrate = bt->bitrate;
		}

		can_print_nl_indent();
		print_uint(PRINT_ANY, "bittiming_bitrate", " bitrate %u",
			   bitrate);
		can_print_nl_indent();
		open_json_array(PRINT_ANY, is_json_context() ?
				"bitrate_const" : "    [");
		for (i = 0; i < bitrate_cnt; ++i) {
			/* This will keep lines below 80 signs */
			if (!(i % 6) && i) {
				can_print_nl_indent();
				print_string(PRINT_FP, NULL, "%s", "     ");
			}
			print_uint(PRINT_ANY, NULL,
				   i < bitrate_cnt - 1 ? "%8u, " : "%8u",
				   bitrate_const[i]);
		}
		close_json_array(PRINT_ANY, " ]");
	}

	/* data bittiming is irrelevant if fixed bitrate is defined */
	if (tb[IFLA_CAN_DATA_BITTIMING] && !tb[IFLA_CAN_DATA_BITRATE_CONST]) {
		struct can_bittiming *dbt =
			RTA_DATA(tb[IFLA_CAN_DATA_BITTIMING]);
		char dsp[6];

		open_json_object("data_bittiming");
		can_print_nl_indent();
		print_uint(PRINT_ANY, "bitrate", " dbitrate %u", dbt->bitrate);
		snprintf(dsp, sizeof(dsp), "%.3f", dbt->sample_point / 1000.);
		print_string(PRINT_ANY, "sample_point", " dsample-point %s",
			     dsp);
		can_print_nl_indent();
		print_uint(PRINT_ANY, "tq", " dtq %u", dbt->tq);
		print_uint(PRINT_ANY, "prop_seg", " dprop-seg %u",
			   dbt->prop_seg);
		print_uint(PRINT_ANY, "phase_seg1", " dphase-seg1 %u",
			   dbt->phase_seg1);
		print_uint(PRINT_ANY, "phase_seg2", " dphase-seg2 %u",
			   dbt->phase_seg2);
		print_uint(PRINT_ANY, "sjw", " dsjw %u", dbt->sjw);
		print_uint(PRINT_ANY, "brp", " dbrp %u", dbt->brp);

		if (tb[IFLA_CAN_TDC])
			can_print_tdc_opt(tb[IFLA_CAN_TDC]);

		close_json_object();
	}

	/* data bittiming const is irrelevant if fixed bitrate is defined */
	if (tb[IFLA_CAN_DATA_BITTIMING_CONST] &&
	    !tb[IFLA_CAN_DATA_BITRATE_CONST]) {
		struct can_bittiming_const *dbtc =
			RTA_DATA(tb[IFLA_CAN_DATA_BITTIMING_CONST]);

		open_json_object("data_bittiming_const");
		can_print_nl_indent();
		print_string(PRINT_ANY, "name", " %s:", dbtc->name);
		can_print_timing_min_max("tseg1", " dtseg1",
					 dbtc->tseg1_min, dbtc->tseg1_max);
		can_print_timing_min_max("tseg2", " dtseg2",
					 dbtc->tseg2_min, dbtc->tseg2_max);
		can_print_timing_min_max("sjw", " dsjw", 1, dbtc->sjw_max);
		can_print_timing_min_max("brp", " dbrp",
					 dbtc->brp_min, dbtc->brp_max);
		print_uint(PRINT_ANY, "brp_inc", " dbrp_inc %u", dbtc->brp_inc);

		if (tb[IFLA_CAN_TDC])
			can_print_tdc_const_opt(tb[IFLA_CAN_TDC], false);

		close_json_object();
	}

	if (tb[IFLA_CAN_DATA_BITRATE_CONST]) {
		__u32 *dbitrate_const =
			RTA_DATA(tb[IFLA_CAN_DATA_BITRATE_CONST]);
		int dbitrate_cnt =
			RTA_PAYLOAD(tb[IFLA_CAN_DATA_BITRATE_CONST]) /
			sizeof(*dbitrate_const);
		int i;
		__u32 dbitrate = 0;

		if (tb[IFLA_CAN_DATA_BITTIMING]) {
			struct can_bittiming *dbt =
				RTA_DATA(tb[IFLA_CAN_DATA_BITTIMING]);
			dbitrate = dbt->bitrate;
		}

		can_print_nl_indent();
		print_uint(PRINT_ANY, "data_bittiming_bitrate", " dbitrate %u",
			   dbitrate);
		can_print_nl_indent();
		open_json_array(PRINT_ANY, is_json_context() ?
				"data_bitrate_const" : "    [");
		for (i = 0; i < dbitrate_cnt; ++i) {
			/* This will keep lines below 80 signs */
			if (!(i % 6) && i) {
				can_print_nl_indent();
				print_string(PRINT_FP, NULL, "%s", "     ");
			}
			print_uint(PRINT_ANY, NULL,
				   i < dbitrate_cnt - 1 ? "%8u, " : "%8u",
				   dbitrate_const[i]);
		}
		close_json_array(PRINT_ANY, " ]");
	}

	/* data bittiming is irrelevant if fixed bitrate is defined */
	if (tb[IFLA_CAN_XL_DATA_BITTIMING] &&
	    !tb[IFLA_CAN_XL_DATA_BITRATE_CONST]) {
		struct can_bittiming *dbt =
			RTA_DATA(tb[IFLA_CAN_XL_DATA_BITTIMING]);
		char dsp[6];

		open_json_object("xl_data_bittiming");
		can_print_nl_indent();
		print_uint(PRINT_ANY, "bitrate", " xbitrate %u", dbt->bitrate);
		snprintf(dsp, sizeof(dsp), "%.3f", dbt->sample_point / 1000.);
		print_string(PRINT_ANY, "sample_point", " xsample-point %s",
			     dsp);
		can_print_nl_indent();
		print_uint(PRINT_ANY, "tq", " xtq %u", dbt->tq);
		print_uint(PRINT_ANY, "prop_seg", " xprop-seg %u",
			   dbt->prop_seg);
		print_uint(PRINT_ANY, "phase_seg1", " xphase-seg1 %u",
			   dbt->phase_seg1);
		print_uint(PRINT_ANY, "phase_seg2", " xphase-seg2 %u",
			   dbt->phase_seg2);
		print_uint(PRINT_ANY, "sjw", " xsjw %u", dbt->sjw);
		print_uint(PRINT_ANY, "brp", " xbrp %u", dbt->brp);

		if (tb[IFLA_CAN_XL_TDC])
			can_print_xtdc_opt(tb[IFLA_CAN_XL_TDC]);

		if (tb[IFLA_CAN_XL_PWM])
			can_print_pwm_opt(tb[IFLA_CAN_XL_PWM]);

		close_json_object();
	}

	/* data bittiming const is irrelevant if fixed bitrate is defined */
	if (tb[IFLA_CAN_XL_DATA_BITTIMING_CONST] &&
	    !tb[IFLA_CAN_XL_DATA_BITRATE_CONST]) {
		struct can_bittiming_const *dbtc =
			RTA_DATA(tb[IFLA_CAN_XL_DATA_BITTIMING_CONST]);

		open_json_object("xl_data_bittiming_const");
		can_print_nl_indent();
		print_string(PRINT_ANY, "name", " %s:", dbtc->name);
		can_print_timing_min_max("tseg1", " xtseg1",
					 dbtc->tseg1_min, dbtc->tseg1_max);
		can_print_timing_min_max("tseg2", " xtseg2",
					 dbtc->tseg2_min, dbtc->tseg2_max);
		can_print_timing_min_max("sjw", " xsjw", 1, dbtc->sjw_max);
		can_print_timing_min_max("brp", " xbrp",
					 dbtc->brp_min, dbtc->brp_max);
		print_uint(PRINT_ANY, "brp_inc", " xbrp_inc %u", dbtc->brp_inc);

		if (tb[IFLA_CAN_XL_TDC])
			can_print_tdc_const_opt(tb[IFLA_CAN_XL_TDC], true);

		if (tb[IFLA_CAN_XL_PWM])
			can_print_pwm_const_opt(tb[IFLA_CAN_XL_PWM]);

		close_json_object();
	}

	if (tb[IFLA_CAN_XL_DATA_BITRATE_CONST]) {
		__u32 *dbitrate_const =
			RTA_DATA(tb[IFLA_CAN_XL_DATA_BITRATE_CONST]);
		int dbitrate_cnt =
			RTA_PAYLOAD(tb[IFLA_CAN_XL_DATA_BITRATE_CONST]) /
			sizeof(*dbitrate_const);
		int i;
		__u32 dbitrate = 0;

		if (tb[IFLA_CAN_XL_DATA_BITTIMING]) {
			struct can_bittiming *dbt =
				RTA_DATA(tb[IFLA_CAN_XL_DATA_BITTIMING]);
			dbitrate = dbt->bitrate;
		}

		can_print_nl_indent();
		print_uint(PRINT_ANY, "xl_data_bittiming_bitrate", " xbitrate %u",
			   dbitrate);
		can_print_nl_indent();
		open_json_array(PRINT_ANY, is_json_context() ?
				"data_bitrate_const" : "    [");
		for (i = 0; i < dbitrate_cnt; ++i) {
			/* This will keep lines below 80 signs */
			if (!(i % 6) && i) {
				can_print_nl_indent();
				print_string(PRINT_FP, NULL, "%s", "     ");
			}
			print_uint(PRINT_ANY, NULL,
				   i < dbitrate_cnt - 1 ? "%8u, " : "%8u",
				   dbitrate_const[i]);
		}
		close_json_array(PRINT_ANY, " ]");
	}

	if (tb[IFLA_CAN_TERMINATION_CONST] && tb[IFLA_CAN_TERMINATION]) {
		__u16 *trm = RTA_DATA(tb[IFLA_CAN_TERMINATION]);
		__u16 *trm_const = RTA_DATA(tb[IFLA_CAN_TERMINATION_CONST]);
		int trm_cnt = RTA_PAYLOAD(tb[IFLA_CAN_TERMINATION_CONST]) /
			sizeof(*trm_const);
		int i;

		can_print_nl_indent();
		print_hu(PRINT_ANY, "termination", " termination %hu [ ", *trm);
		open_json_array(PRINT_JSON, "termination_const");
		for (i = 0; i < trm_cnt; ++i)
			print_hu(PRINT_ANY, NULL,
				 i < trm_cnt - 1 ? "%hu, " : "%hu",
				 trm_const[i]);
		close_json_array(PRINT_ANY, " ]");
	}

	if (tb[IFLA_CAN_CLOCK]) {
		struct can_clock *clock = RTA_DATA(tb[IFLA_CAN_CLOCK]);

		can_print_nl_indent();
		print_uint(PRINT_ANY, "clock", " clock %u ", clock->freq);
	}

}

static void can_print_xstats(struct link_util *lu,
			     FILE *f, struct rtattr *xstats)
{
	struct can_device_stats *stats;

	if (xstats && RTA_PAYLOAD(xstats) == sizeof(*stats)) {
		stats = RTA_DATA(xstats);

		can_print_nl_indent();
		print_string(PRINT_FP, NULL, "%s",
			     " re-started bus-errors arbit-lost error-warn error-pass bus-off");
		can_print_nl_indent();
		print_uint(PRINT_ANY, "restarts", " %-10u", stats->restarts);
		print_uint(PRINT_ANY, "bus_error", " %-10u", stats->bus_error);
		print_uint(PRINT_ANY, "arbitration_lost", " %-10u",
			   stats->arbitration_lost);
		print_uint(PRINT_ANY, "error_warning", " %-10u",
			   stats->error_warning);
		print_uint(PRINT_ANY, "error_passive", " %-10u",
			   stats->error_passive);
		print_uint(PRINT_ANY, "bus_off", " %-10u", stats->bus_off);
	}
}

static void can_print_help(struct link_util *lu, int argc, char **argv, FILE *f)
{
	print_usage(f);
}

struct link_util can_link_util = {
	.id		= "can",
	.maxattr	= IFLA_CAN_MAX,
	.parse_opt	= can_parse_opt,
	.print_opt	= can_print_opt,
	.print_xstats	= can_print_xstats,
	.print_help	= can_print_help,
};