Merge pull request #301 from kurt-vd/canbusload-fd

[V2] canbusload with FD support

.gitignore

@@ -20,6 +20,7 @@ GNUmakefile.in
 /config/m4/ltsugar.m4
 /config/m4/ltversion.m4
 /config/m4/lt~obsolete.m4
+/mcp251xfd/.dirstamp
 
 /asc2log
 /bcmserver
@@ -47,6 +48,7 @@ GNUmakefile.in
 /j1939sr
 /log2asc
 /log2long
+/mcp251xfd-dump
 /slcan_attach
 /slcand
 /slcanpty

CMakeLists.txt

@@ -65,6 +65,13 @@ set(PROGRAMS
     slcanpty
 )
 
+add_executable(mcp251xfd-dump
+    mcp251xfd/mcp251xfd-dev-coredump.c
+    mcp251xfd/mcp251xfd-dump.c
+    mcp251xfd/mcp251xfd-main.c
+    mcp251xfd/mcp251xfd-regmap.c
+)
+
 if(NOT ANDROID)
   list(APPEND PROGRAMS ${PROGRAMS_J1939})
 

GNUmakefile.am

@@ -24,6 +24,7 @@ noinst_HEADERS = \
 	include/linux/can/raw.h \
 	include/linux/can/vxcan.h \
 	include/linux/errqueue.h \
+	include/linux/kernel.h \
 	include/linux/net_tstamp.h \
 	include/linux/netlink.h
 
@@ -38,6 +39,15 @@ libcan_la_SOURCES = \
 libj1939_la_SOURCES = \
 	libj1939.c
 
+mcp251xfd_dump_SOURCES = \
+	mcp251xfd/mcp251xfd-dev-coredump.c \
+	mcp251xfd/mcp251xfd-dump-userspace.h \
+	mcp251xfd/mcp251xfd-dump.c \
+	mcp251xfd/mcp251xfd-dump.h \
+	mcp251xfd/mcp251xfd-main.c \
+	mcp251xfd/mcp251xfd-regmap.c \
+	mcp251xfd/mcp251xfd.h
+
 bin_PROGRAMS = \
 	asc2log \
 	bcmserver \
@@ -65,6 +75,7 @@ bin_PROGRAMS = \
 	j1939sr \
 	log2asc \
 	log2long \
+	mcp251xfd-dump \
 	slcan_attach \
 	slcand \
 	slcanpty \
@@ -82,7 +93,9 @@ EXTRA_DIST = \
 	README.md \
 	autogen.sh \
 	can-j1939-kickstart.md \
-	can-j1939.md
+	can-j1939.md \
+	mcp251xfd/99-devcoredump.rules \
+	mcp251xfd/devcoredump
 
 MAINTAINERCLEANFILES = \
 	configure \

Makefile

@@ -96,6 +96,7 @@ PROGRAMS := \
 	cansniffer \
 	log2asc \
 	log2long \
+	mcp251xfd-dump \
 	slcanpty
 
 all: $(PROGRAMS)
@@ -142,3 +143,6 @@ j1939spy:	j1939spy.o	libj1939.o
 j1939sr:	j1939sr.o	libj1939.o
 testj1939:	testj1939.o	libj1939.o
 canbusload:	canbusload.o	canframelen.o
+
+mcp251xfd-dump:	mcp251xfd/mcp251xfd-dev-coredump.o mcp251xfd/mcp251xfd-dump.o mcp251xfd/mcp251xfd-main.o mcp251xfd/mcp251xfd-regmap.o
+	$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@

asc2log.c

@@ -119,7 +119,7 @@ void calc_tv(struct timeval *tv, struct timeval *read_tv,
 		tv->tv_usec += read_tv->tv_usec;
 	}
 
-	if (tv->tv_usec > 1000000) {
+	if (tv->tv_usec >= 1000000) {
 		tv->tv_usec -= 1000000;
 		tv->tv_sec++;
 	}
@@ -270,7 +270,7 @@ void eval_canfd(char* buf, struct timeval *date_tvp, char timestamps, int dplace
 		extra_info = " T\n";
 
 	/* don't trust ASCII content - sanitize data length */
-	if (dlen != can_dlc2len(can_len2dlc(dlen)))
+	if (dlen != can_fd_dlc2len(can_fd_len2dlc(dlen)))
 		return;
 
 	get_can_id(&cf, tmp1, 16);
@@ -327,6 +327,15 @@ void eval_canfd(char* buf, struct timeval *date_tvp, char timestamps, int dplace
 			/* dlen is always 0 for classic CAN RTR frames
 			   but the DLC value is valid in RTR cases */
 			cf.len = dlc;
+			/* sanitize payload length value */
+			if (dlc > CAN_MAX_DLEN)
+				cf.len = CAN_MAX_DLEN;
+		}
+		/* check for extra DLC when having a Classic CAN with 8 bytes payload */
+		if ((cf.len == CAN_MAX_DLEN) && (dlc > CAN_MAX_DLEN) && (dlc <= CAN_MAX_RAW_DLC)) {
+			struct can_frame *ccf = (struct can_frame *)&cf;
+
+			ccf->len8_dlc = dlc;
 		}
 	}
 

can-calc-bit-timing.c

@@ -2,7 +2,7 @@
 /* can-calc-bit-timing.c: Calculate CAN bit timing parameters
  *
  * Copyright (C) 2008 Wolfgang Grandegger <wg@grandegger.com>
- * Copyright (C) 2016 Marc Kleine-Budde <mkl@pengutronix.de>
+ * Copyright (C) 2016, 2021 Marc Kleine-Budde <mkl@pengutronix.de>
  *
  * Derived from:
  *   can_baud.c - CAN baudrate calculation
@@ -29,6 +29,17 @@
 #include <linux/can/netlink.h>
 #include <linux/types.h>
 
+enum {
+	OPT_TQ = UCHAR_MAX + 1,
+	OPT_PROP_SEG,
+	OPT_PHASE_SEG1,
+	OPT_PHASE_SEG2,
+	OPT_SJW,
+	OPT_BRP,
+	OPT_TSEG1,
+	OPT_TSEG2,
+};
+
 /* imported from kernel */
 
 /**
@@ -140,7 +151,17 @@ static void print_usage(char *cmd)
 	       "\t-b <bitrate>   bit-rate in bits/sec\n"
 	       "\t-s <samp_pt>   sample-point in one-tenth of a percent\n"
 	       "\t               or 0 for CIA recommended sample points\n"
-	       "\t-c <clock>     real CAN system clock in Hz\n",
+	       "\t-c <clock>     real CAN system clock in Hz\n"
+	       "\n"
+	       "Or supply low level bit timing parameters to decode them:\n"
+	       "\n"
+	       "\t--prop-seg     Propagation segment in TQs\n"
+	       "\t--phase-seg1   Phase buffer segment 1 in TQs\n"
+	       "\t--phase-seg2   Phase buffer segment 2 in TQs\n"
+	       "\t--sjw          Synchronisation jump width in TQs\n"
+	       "\t--brp          Bit-rate prescaler\n"
+	       "\t--tseg1        Time segment 1 = prop-seg + phase-seg1\n"
+	       "\t--tseg2        Time segment 2 = phase_seg2\n",
 	       cmd);
 }
 
@@ -201,6 +222,19 @@ static void printf_btr_mcp251x(struct can_bittiming *bt, bool hdr)
 	}
 }
 
+static void printf_btr_mcp251xfd(struct can_bittiming *bt, bool hdr)
+{
+	if (hdr) {
+		printf("NBTCFG");
+	} else {
+		uint32_t nbtcfg = ((bt->brp - 1) << 24) |
+			((bt->prop_seg + bt->phase_seg1 - 1) << 16) |
+			((bt->phase_seg2 - 1) << 8) |
+			(bt->sjw - 1);
+		printf("0x%08x", nbtcfg);
+	}
+}
+
 static void printf_btr_ti_hecc(struct can_bittiming *bt, bool hdr)
 {
 	if (hdr) {
@@ -239,6 +273,57 @@ static void printf_btr_rcar_can(struct can_bittiming *bt, bool hdr)
 	}
 }
 
+static void printf_btr_bxcan(struct can_bittiming *bt, bool hdr)
+{
+	if (hdr) {
+		printf("%10s", "CAN_BTR");
+	} else {
+		uint32_t btr;
+
+		btr = (((bt->brp -1) & 0x3ff) << 0) |
+			(((bt->prop_seg + bt->phase_seg1 -1) & 0xf) << 16) |
+			(((bt->phase_seg2 -1) & 0x7) << 20) |
+			(((bt->sjw -1) & 0x3) << 24);
+
+		printf("0x%08x", btr);
+	}
+}
+
+static void printf_btr_c_can(struct can_bittiming *bt, bool hdr)
+{
+	if (hdr) {
+		printf("%s", "  BTR  BRPEXT");
+	} else {
+		uint32_t btr;
+		uint32_t brpext;
+
+		btr = (((bt->brp -1) & 0x3f) << 0) |
+			(((bt->sjw -1) & 0x3) << 6) |
+			(((bt->prop_seg + bt->phase_seg1 -1) & 0xf) << 8) |
+			(((bt->phase_seg2 -1) & 0x7) << 12);
+		brpext = ((bt->brp -1) >> 6) & 0xf;
+
+		printf("0x%04x 0x%04x", btr, brpext);
+	}
+}
+
+static void printf_btr_mcan(struct can_bittiming *bt, bool hdr)
+{
+	if (hdr) {
+		printf("%10s", "NBTP");
+	} else {
+		uint32_t nbtp;
+
+
+		nbtp = (((bt->brp -1) & 0x1ff) << 16) |
+			(((bt->sjw -1) & 0x7f) << 25) |
+			(((bt->prop_seg + bt->phase_seg1 -1) & 0xff) << 8) |
+			(((bt->phase_seg2 -1) & 0x7f) << 0);
+
+		printf("0x%08x", nbtp);
+	}
+}
+
 static struct calc_bittiming_const can_calc_consts[] = {
 	{
 		.bittiming_const = {
@@ -276,7 +361,6 @@ static struct calc_bittiming_const can_calc_consts[] = {
 			{ .clk = 66660000, .name = "mpc5121", },
 			{ .clk = 66666666, .name = "mpc5121" },
 		},
-		.printf_btr = printf_btr_sja1000,
 	}, {
 		.bittiming_const = {
 			.name = "at91",
@@ -329,10 +413,29 @@ static struct calc_bittiming_const can_calc_consts[] = {
 			.brp_inc = 1,
 		},
 		.ref_clk = {
-			{ .clk =  8000000, },
-			{ .clk = 16000000, },
+			/* The mcp251x uses half of the external OSC clock as the base clock */
+			{ .clk =  8000000 / 2, .name = "8 MHz OSC" },
+			{ .clk = 16000000 / 2, .name = "16 MHz OSC" },
+			{ .clk = 20000000 / 2, .name = "20 MHz OSC" },
 		},
 		.printf_btr = printf_btr_mcp251x,
+	}, {
+		.bittiming_const = {
+			.name = "mcp251xfd",
+			.tseg1_min = 2,
+			.tseg1_max = 256,
+			.tseg2_min = 1,
+			.tseg2_max = 128,
+			.sjw_max = 128,
+			.brp_min = 1,
+			.brp_max = 256,
+			.brp_inc = 1,
+		},
+		.ref_clk = {
+			{ .clk = 20000000, },
+			{ .clk = 40000000, },
+		},
+		.printf_btr = printf_btr_mcp251xfd,
 	}, {
 		.bittiming_const = {
 			.name = "ti_hecc",
@@ -365,6 +468,54 @@ static struct calc_bittiming_const can_calc_consts[] = {
 			{ .clk = 65000000, },
 		},
 		.printf_btr = printf_btr_rcar_can,
+	}, {
+		.bittiming_const = {
+			.name = "bxcan",
+			.tseg1_min = 1,
+			.tseg1_max = 16,
+			.tseg2_min = 1,
+			.tseg2_max = 8,
+			.sjw_max = 4,
+			.brp_min = 1,
+			.brp_max = 1024,
+			.brp_inc = 1,
+		},
+		.ref_clk = {
+			{ .clk = 48000000, },
+		},
+		.printf_btr = printf_btr_bxcan,
+	}, {
+		.bittiming_const = {
+			.name = "c_can",
+			.tseg1_min = 2,
+			.tseg1_max = 16,
+			.tseg2_min = 1,
+			.tseg2_max = 8,
+			.sjw_max = 4,
+			.brp_min = 1,
+			.brp_max = 1024,
+			.brp_inc = 1,
+		},
+		.ref_clk = {
+			{ .clk = 24000000, },
+		},
+		.printf_btr = printf_btr_c_can,
+	}, {
+		.bittiming_const = {
+			.name = "mcan-v3.1+",
+			.tseg1_min = 2,
+			.tseg1_max = 256,
+			.tseg2_min = 2,
+			.tseg2_max = 128,
+			.sjw_max = 128,
+			.brp_min = 1,
+			.brp_max = 512,
+			.brp_inc = 1,
+		},
+		.ref_clk = {
+			{ .clk = 40000000, },
+		},
+		.printf_btr = printf_btr_mcan,
 	},
 };
 
@@ -540,6 +691,46 @@ static int can_calc_bittiming(struct net_device *dev, struct can_bittiming *bt,
 	return 0;
 }
 
+static int can_fixup_bittiming(struct net_device *dev, struct can_bittiming *bt,
+			       const struct can_bittiming_const *btc)
+{
+	struct can_priv *priv = netdev_priv(dev);
+	int tseg1, alltseg;
+	u64 brp64, v64;
+
+	tseg1 = bt->prop_seg + bt->phase_seg1;
+	if (!bt->sjw)
+		bt->sjw = 1;
+	if (bt->sjw > btc->sjw_max ||
+	    tseg1 < btc->tseg1_min || tseg1 > btc->tseg1_max ||
+	    bt->phase_seg2 < btc->tseg2_min || bt->phase_seg2 > btc->tseg2_max)
+		return -ERANGE;
+
+	if (!bt->brp) {
+		brp64 = (u64)priv->clock.freq * (u64)bt->tq;
+		if (btc->brp_inc > 1)
+			do_div(brp64, btc->brp_inc);
+		brp64 += 500000000UL - 1;
+		do_div(brp64, 1000000000UL); /* the practicable BRP */
+		if (btc->brp_inc > 1)
+			brp64 *= btc->brp_inc;
+		bt->brp = brp64;
+	}
+
+	v64 = bt->brp * 1000 * 1000 * 1000;
+	do_div(v64, priv->clock.freq);
+	bt->tq = v64;
+
+	if (bt->brp < btc->brp_min || bt->brp > btc->brp_max)
+		return -EINVAL;
+
+	alltseg = CAN_CALC_SYNC_SEG + bt->prop_seg + bt->phase_seg1 + bt->phase_seg2;
+	bt->bitrate = priv->clock.freq / (bt->brp * alltseg);
+	bt->sample_point = ((CAN_CALC_SYNC_SEG + tseg1) * 1000) / alltseg;
+
+	return 0;
+}
+
 static __u32 get_cia_sample_point(__u32 bitrate)
 {
 	__u32 sampl_pt;
@@ -555,6 +746,7 @@ static __u32 get_cia_sample_point(__u32 bitrate)
 }
 
 static void print_bit_timing(const struct calc_bittiming_const *btc,
+			     const struct can_bittiming *ref_bt,
 			     const struct calc_ref_clk *ref_clk,
 			     unsigned int bitrate_nominal,
 			     unsigned int spt_nominal,
@@ -579,14 +771,24 @@ static void print_bit_timing(const struct calc_bittiming_const *btc,
 		       ref_clk->name ? ")" : "",
 		       ref_clk->clk / 1000000.0);
 
+		if (btc->printf_btr)
 			btc->printf_btr(&bt, true);
 		printf("\n");
 	}
 
+	if (ref_bt) {
+		bt = *ref_bt;
+
+		if (can_fixup_bittiming(&dev, &bt, &btc->bittiming_const)) {
+			printf("%7d ***parameters exceed controller's range***\n", bitrate_nominal);
+			return;
+		}
+	} else {
 		if (can_calc_bittiming(&dev, &bt, &btc->bittiming_const)) {
 			printf("%7d ***bitrate not possible***\n", bitrate_nominal);
 			return;
 		}
+	}
 
 	/* get nominal sample point */
 	if (!spt_nominal)
@@ -595,22 +797,32 @@ static void print_bit_timing(const struct calc_bittiming_const *btc,
 	rate_error = abs(bitrate_nominal - bt.bitrate);
 	spt_error = abs(spt_nominal - bt.sample_point);
 
-	printf("%7d "
-	       "%6d %3d %4d %4d "
-	       "%3d %3d "
-	       "%7d %4.1f%% "
-	       "%4.1f%% %4.1f%% %4.1f%% ",
+	printf("%7d "				/* Bitrate */
+	       "%6d %3d %4d %4d "		/* TQ[ns], PrS, PhS1, PhS2 */
+	       "%3d %3d "			/* SJW, BRP */
+	       "%7d ",				/* real Bitrate */
 	       bitrate_nominal,
 	       bt.tq, bt.prop_seg, bt.phase_seg1, bt.phase_seg2,
 	       bt.sjw, bt.brp,
+	       bt.bitrate);
 
-	       bt.bitrate,
-	       100.0 * rate_error / bitrate_nominal,
+	if (100.0 * rate_error / bitrate_nominal > 99.9)
+		printf("≥100%% ");
+	else
+		printf("%4.1f%% ",
+		       100.0 * rate_error / bitrate_nominal);
 
+	printf("%4.1f%% %4.1f%% ",		/* nom SampP, real SampP */
 	       spt_nominal / 10.0,
-	       bt.sample_point / 10.0,
+	       bt.sample_point / 10.0);
+
+	if (100.0 * spt_error / spt_nominal > 99.9)
+		printf("≥100%% ");
+	else
+		printf("%4.1f%% ",		/* SampP Error */
 		       100.0 * spt_error / spt_nominal);
 
+	if (btc->printf_btr)
 		btc->printf_btr(&bt, false);
 	printf("\n");
 }
@@ -623,22 +835,81 @@ static void do_list(void)
 		printf("%s\n", can_calc_consts[i].bittiming_const.name);
 }
 
+static void do_calc(const char *name,
+		    const struct can_bittiming *opt_ref_bt,
+		    __u32 bitrate_nominal, unsigned int spt_nominal,
+		    struct calc_ref_clk *opt_ref_clk, bool quiet)
+{
+	const struct calc_bittiming_const *btc;
+	const struct calc_ref_clk *ref_clk;
+	unsigned int i, j, k;
+	bool found = false;
+
+	for (i = 0; i < ARRAY_SIZE(can_calc_consts); i++) {
+		if (name &&
+		    strcmp(can_calc_consts[i].bittiming_const.name, name) != 0)
+			continue;
+
+		found = true;
+		btc = &can_calc_consts[i];
+
+		for (j = 0; j < ARRAY_SIZE(btc->ref_clk); j++) {
+			if (opt_ref_clk)
+				ref_clk = opt_ref_clk;
+			else
+				ref_clk = &btc->ref_clk[j];
+
+			if (!ref_clk->clk)
+				break;
+
+			if (bitrate_nominal) {
+				print_bit_timing(btc, opt_ref_bt, ref_clk, bitrate_nominal,
+						 spt_nominal, quiet);
+			} else {
+				for (k = 0; k < ARRAY_SIZE(common_bitrates); k++)
+					print_bit_timing(btc, opt_ref_bt, ref_clk,
+							 common_bitrates[k],
+							 spt_nominal, k);
+			}
+			printf("\n");
+
+			if (opt_ref_clk)
+				break;
+		}
+	}
+
+	if (!found) {
+		printf("error: unknown CAN controller '%s', try one of these:\n\n", name);
+		do_list();
+		exit(EXIT_FAILURE);
+	}
+}
+
 int main(int argc, char *argv[])
 {
 	__u32 bitrate_nominal = 0;
+	unsigned int spt_nominal = 0;
 	struct calc_ref_clk opt_ref_clk = {
 		.name = "cmd-line",
 	};
-	const struct calc_ref_clk *ref_clk;
-	unsigned int spt_nominal = 0;
-	bool quiet = false, list = false, found = false;
-	char *name = NULL;
-	unsigned int i, j, k;
+	struct can_bittiming bt = { 0 };
+	bool quiet = false, list = false;
+	const char *name = NULL;
 	int opt;
 
-	const struct calc_bittiming_const *btc;
+	const struct option long_options[] = {
+		{ "tq",         required_argument,	0, OPT_TQ, },
+		{ "prop-seg",	required_argument,	0, OPT_PROP_SEG, },
+		{ "phase-seg1",	required_argument,	0, OPT_PHASE_SEG1, },
+		{ "phase-seg2",	required_argument,	0, OPT_PHASE_SEG2, },
+		{ "sjw",	required_argument,	0, OPT_SJW, },
+		{ "brp",	required_argument,	0, OPT_BRP, },
+		{ "tseg1",	required_argument,	0, OPT_TSEG1, },
+		{ "tseg2",	required_argument,	0, OPT_TSEG2, },
+		{ 0,		0,			0, 0 },
+	};
 
-	while ((opt = getopt(argc, argv, "b:c:lqs:?")) != -1) {
+	while ((opt = getopt_long(argc, argv, "b:c:lqs:?", long_options, NULL)) != -1) {
 		switch (opt) {
 		case 'b':
 			bitrate_nominal = atoi(optarg);
@@ -665,6 +936,43 @@ int main(int argc, char *argv[])
 			exit(EXIT_SUCCESS);
 			break;
 
+		case OPT_TQ:
+			bt.tq = strtoul(optarg, NULL, 10);
+			break;
+
+		case OPT_PROP_SEG:
+			bt.prop_seg = strtoul(optarg, NULL, 10);
+			break;
+
+		case OPT_PHASE_SEG1:
+			bt.phase_seg1 = strtoul(optarg, NULL, 10);
+			break;
+
+		case OPT_PHASE_SEG2:
+			bt.phase_seg2 = strtoul(optarg, NULL, 10);
+			break;
+
+		case OPT_SJW:
+			bt.sjw = strtoul(optarg, NULL, 10);
+			break;
+
+		case OPT_BRP:
+			bt.brp = strtoul(optarg, NULL, 10);
+			break;
+
+		case OPT_TSEG1: {
+			__u32 tseg1;
+
+			tseg1 = strtoul(optarg, NULL, 10);
+			bt.prop_seg = tseg1 / 2;
+			bt.phase_seg1 = tseg1 - bt.prop_seg;
+			break;
+		}
+
+		case OPT_TSEG2:
+			bt.phase_seg2 = strtoul(optarg, NULL, 10);
+			break;
+
 		default:
 			print_usage(basename(argv[0]));
 			exit(EXIT_FAILURE);
@@ -690,44 +998,11 @@ int main(int argc, char *argv[])
 		exit(EXIT_FAILURE);
 	}
 
-	for (i = 0; i < ARRAY_SIZE(can_calc_consts); i++) {
-		if (name &&
-		    strcmp(can_calc_consts[i].bittiming_const.name, name) != 0)
-			continue;
-
-		found = true;
-		btc = &can_calc_consts[i];
-
-		for (j = 0; j < ARRAY_SIZE(btc->ref_clk); j++) {
-			if (opt_ref_clk.clk)
-				ref_clk = &opt_ref_clk;
-			else
-				ref_clk = &btc->ref_clk[j];
-
-			if (!ref_clk->clk)
-				break;
-
-			if (bitrate_nominal) {
-				print_bit_timing(btc, ref_clk, bitrate_nominal,
-						 spt_nominal, quiet);
-			} else {
-				for (k = 0; k < ARRAY_SIZE(common_bitrates); k++)
-					print_bit_timing(btc, ref_clk,
-							 common_bitrates[k],
-							 spt_nominal, k);
-			}
-			printf("\n");
-
-			if (opt_ref_clk.clk)
-				break;
-		}
-	}
-
-	if (!found) {
-		printf("error: unknown CAN controller '%s', try one of these:\n\n", name);
-		do_list();
-		exit(EXIT_FAILURE);
-	}
+	do_calc(name,
+		bt.prop_seg ? &bt: NULL,
+		bitrate_nominal, spt_nominal,
+		opt_ref_clk.clk ? &opt_ref_clk : NULL,
+		quiet);
 
 	exit(EXIT_SUCCESS);
 }

canbusload.c

@@ -74,9 +74,11 @@ extern int optind, opterr, optopt;
 static struct {
 	char devname[IFNAMSIZ+1];
 	unsigned int bitrate;
+	unsigned int dbitrate;
 	unsigned int recv_frames;
 	unsigned int recv_bits_total;
 	unsigned int recv_bits_payload;
+	unsigned int recv_bits_dbitrate;
 } stat[MAXSOCK+1];
 
 static int  max_devname_len; /* to prevent frazzled device name output */ 
@@ -103,7 +105,7 @@ void print_usage(char *prg)
 	fprintf(stderr, "         -e  (exact calculation of stuffed bits)\n");
 	fprintf(stderr, "\n");
 	fprintf(stderr, "Up to %d CAN interfaces with mandatory bitrate can be specified on the \n", MAXSOCK);
-	fprintf(stderr, "commandline in the form: <ifname>@<bitrate>\n\n");
+	fprintf(stderr, "commandline in the form: <ifname>@<bitrate>[,<dbitrate>]\n\n");
 	fprintf(stderr, "The bitrate is mandatory as it is needed to know the CAN bus bitrate to\n");
 	fprintf(stderr, "calculate the bus load percentage based on the received CAN frames.\n");
 	fprintf(stderr, "Due to the bitstuffing estimation the calculated busload may exceed 100%%.\n");
@@ -184,16 +186,18 @@ void printstats(int signo)
 		}
 
 		if (stat[i].bitrate)
-			percent = (stat[i].recv_bits_total*100)/stat[i].bitrate;
+			percent = ((stat[i].recv_bits_total-stat[i].recv_bits_dbitrate) * 100) / stat[i].bitrate
+				+ (stat[i].recv_bits_dbitrate * 100) / stat[i].dbitrate;
 		else
 			percent = 0;
 
-		printf(" %*s@%-*d %5d %7d %6d %3d%%",
+		printf(" %*s@%-*d %5d %7d %6d %6d %3d%%",
 		       max_devname_len, stat[i].devname,
 		       max_bitrate_len, stat[i].bitrate,
 		       stat[i].recv_frames,
 		       stat[i].recv_bits_total,
 		       stat[i].recv_bits_payload,
+		       stat[i].recv_bits_dbitrate,
 		       percent);
 
 		if (bargraph) {
@@ -220,6 +224,7 @@ void printstats(int signo)
 
 		stat[i].recv_frames = 0;
 		stat[i].recv_bits_total = 0;
+		stat[i].recv_bits_dbitrate = 0;
 		stat[i].recv_bits_payload = 0;
 	}
 
@@ -237,7 +242,7 @@ int main(int argc, char **argv)
 	int opt;
 	char *ptr, *nptr;
 	struct sockaddr_can addr;
-	struct can_frame frame;
+	struct canfd_frame frame;
 	int nbytes, i;
 	struct ifreq ifr;
 	sigset_t sigmask, savesigmask;
@@ -336,7 +341,13 @@ int main(int argc, char **argv)
 		if (nbytes > max_devname_len)
 			max_devname_len = nbytes; /* for nice printing */
 
-		stat[i].bitrate = atoi(nptr+1); /* bitrate is placed behind the '@' */
+		char *endp;
+		stat[i].bitrate = strtol(nptr + 1, &endp, 0); /* bitrate is placed behind the '@' */
+		if (*endp == ',')
+			/* data bitrate is placed behind the ',' */
+			stat[i].dbitrate = strtol(endp + 1, &endp, 0);
+		else
+			stat[i].dbitrate = stat[i].bitrate;
 
 		if (!stat[i].bitrate || stat[i].bitrate > 1000000) {
 			printf("invalid bitrate for CAN device '%s'!\n", ptr);
@@ -351,6 +362,9 @@ int main(int argc, char **argv)
 #ifdef DEBUG
 		printf("using interface name '%s'.\n", ifr.ifr_name);
 #endif
+		/* try to switch the socket into CAN FD mode */
+		const int canfd_on = 1;
+		setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on));
 
 		if (ioctl(s[i], SIOCGIFINDEX, &ifr) < 0) {
 			perror("SIOCGIFINDEX");
@@ -402,9 +416,11 @@ int main(int argc, char **argv)
 				}
 
 				stat[i].recv_frames++;
-				stat[i].recv_bits_payload += frame.can_dlc*8;
-				stat[i].recv_bits_total += can_frame_length((struct canfd_frame*)&frame,
-									    mode, sizeof(frame));
+				stat[i].recv_bits_payload += frame.len * 8;
+				stat[i].recv_bits_dbitrate += can_frame_dbitrate_length(
+						&frame, mode, sizeof(frame));
+				stat[i].recv_bits_total += can_frame_length(&frame,
+									    mode, nbytes);
 			}
 		}
 	}

candump.c

@@ -54,6 +54,7 @@
 #include <unistd.h>
 
 #include <net/if.h>
+#include <sys/epoll.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/time.h>
@@ -75,6 +76,7 @@
 #define SOF_TIMESTAMPING_SOFTWARE (1 << 4)
 #define SOF_TIMESTAMPING_RX_SOFTWARE (1 << 3)
 #define SOF_TIMESTAMPING_RAW_HARDWARE (1 << 6)
+#define TIMESTAMPSZ 50 /* string 'absolute with date' requires max 49 bytes */
 
 #define MAXSOCK 16    /* max. number of CAN interfaces given on the cmdline */
 #define MAXIFNAMES 30 /* size of receive name index to omit ioctls */
@@ -88,33 +90,38 @@
 #define SILENT_ON 2   /* silent mode (completely silent) */
 
 #define BOLD ATTBOLD
-#define RED     ATTBOLD FGRED
-#define GREEN   ATTBOLD FGGREEN
-#define YELLOW  ATTBOLD FGYELLOW
-#define BLUE    ATTBOLD FGBLUE
-#define MAGENTA ATTBOLD FGMAGENTA
-#define CYAN    ATTBOLD FGCYAN
+#define RED (ATTBOLD FGRED)
+#define GREEN (ATTBOLD FGGREEN)
+#define YELLOW (ATTBOLD FGYELLOW)
+#define BLUE (ATTBOLD FGBLUE)
+#define MAGENTA (ATTBOLD FGMAGENTA)
+#define CYAN (ATTBOLD FGCYAN)
 
-const char col_on [MAXCOL][19] = {BLUE, RED, GREEN, BOLD, MAGENTA, CYAN};
-const char col_off [] = ATTRESET;
+static const char col_on[MAXCOL][19] = { BLUE, RED, GREEN, BOLD, MAGENTA, CYAN };
+static const char col_off[] = ATTRESET;
+
+struct if_info { /* bundled information per open socket */
+	int s; /* socket */
+	char *cmdlinename;
+	__u32 dropcnt;
+	__u32 last_dropcnt;
+};
+static struct if_info sock_info[MAXSOCK];
 
-static char *cmdlinename[MAXSOCK];
-static __u32 dropcnt[MAXSOCK];
-static __u32 last_dropcnt[MAXSOCK];
 static char devname[MAXIFNAMES][IFNAMSIZ+1];
 static int dindex[MAXIFNAMES];
 static int max_devname_len; /* to prevent frazzled device name output */
-const int canfd_on = 1;
+static const int canfd_on = 1;
 
 #define MAXANI 4
-const char anichar[MAXANI] = {'|', '/', '-', '\\'};
-const char extra_m_info[4][4] = {"- -", "B -", "- E", "B E"};
+static const char anichar[MAXANI] = { '|', '/', '-', '\\' };
+static const char extra_m_info[4][4] = { "- -", "B -", "- E", "B E" };
 
 extern int optind, opterr, optopt;
 
 static volatile int running = 1;
 
-void print_usage(char *prg)
+static void print_usage(char *prg)
 {
 	fprintf(stderr, "%s - dump CAN bus traffic.\n", prg);
 	fprintf(stderr, "\nUsage: %s [options] <CAN interface>+\n", prg);
@@ -134,8 +141,9 @@ void print_usage(char *prg)
 	fprintf(stderr, "         -D          (Don't exit if a \"detected\" can device goes down.\n");
 	fprintf(stderr, "         -d          (monitor dropped CAN frames)\n");
 	fprintf(stderr, "         -e          (dump CAN error frames in human-readable format)\n");
+	fprintf(stderr, "         -8          (display raw DLC values in {} for Classical CAN)\n");
 	fprintf(stderr, "         -x          (print extra message infos, rx/tx brs esi)\n");
-	fprintf(stderr, "         -T <msecs>  (terminate after <msecs> without any reception)\n");
+	fprintf(stderr, "         -T <msecs>  (terminate after <msecs> if no frames were received)\n");
 	fprintf(stderr, "\n");
 	fprintf(stderr, "Up to %d CAN interfaces with optional filter sets can be specified\n", MAXSOCK);
 	fprintf(stderr, "on the commandline in the form: <ifname>[,filter]*\n");
@@ -159,12 +167,13 @@ void print_usage(char *prg)
 	fprintf(stderr, "\n");
 }
 
-void sigterm(int signo)
+static void sigterm(int signo)
 {
 	running = 0;
 }
 
-int idx2dindex(int ifidx, int socket) {
+static int idx2dindex(int ifidx, int socket)
+{
 
 	int i;
 	struct ifreq ifr;
@@ -213,11 +222,69 @@ int idx2dindex(int ifidx, int socket) {
 	return i;
 }
 
+static inline void sprint_timestamp(const char timestamp, const struct timeval *tv,
+				    struct timeval *const last_tv, char *ts_buffer)
+{
+	switch (timestamp) {
+
+	case 'a': /* absolute with timestamp */
+		sprintf(ts_buffer, "(%010lu.%06lu) ", tv->tv_sec, tv->tv_usec);
+		break;
+
+	case 'A': /* absolute with date */
+	{
+		struct tm tm;
+		char timestring[25];
+
+		tm = *localtime(&tv->tv_sec);
+		strftime(timestring, 24, "%Y-%m-%d %H:%M:%S", &tm);
+		sprintf(ts_buffer, "(%s.%06lu) ", timestring, tv->tv_usec);
+	}
+	break;
+
+	case 'd': /* delta */
+	case 'z': /* starting with zero */
+	{
+		struct timeval diff;
+
+		if (last_tv->tv_sec == 0)   /* first init */
+			*last_tv = *tv;
+		diff.tv_sec  = tv->tv_sec - last_tv->tv_sec;
+		diff.tv_usec = tv->tv_usec - last_tv->tv_usec;
+		if (diff.tv_usec < 0)
+			diff.tv_sec--, diff.tv_usec += 1000000;
+		if (diff.tv_sec < 0)
+			diff.tv_sec = diff.tv_usec = 0;
+		sprintf(ts_buffer, "(%03lu.%06lu) ", diff.tv_sec, diff.tv_usec);
+
+		if (timestamp == 'd')
+			*last_tv = *tv; /* update for delta calculation */
+	}
+	break;
+
+	default: /* no timestamp output */
+		break;
+	}
+}
+
+static inline void print_timestamp(const char timestamp, const struct timeval *tv,
+				   struct timeval *const last_tv)
+{
+	static char buffer[TIMESTAMPSZ];
+
+	sprint_timestamp(timestamp, tv, last_tv, buffer);
+	printf("%s", buffer);
+}
+
 int main(int argc, char **argv)
 {
-	fd_set rdfs;
-	int s[MAXSOCK];
+	int fd_epoll;
+	struct epoll_event events_pending[MAXSOCK];
+	struct epoll_event event_setup = {
+		.events = EPOLLIN, /* prepare the common part */
+	};
 	unsigned char timestamp = 0;
+	unsigned char logtimestamp = 'a';
 	unsigned char hwtimestamp = 0;
 	unsigned char down_causes_exit = 1;
 	unsigned char dropmonitor = 0;
@@ -230,7 +297,7 @@ int main(int argc, char **argv)
 	unsigned char logfrmt = 0;
 	int count = 0;
 	int rcvbuf_size = 0;
-	int opt, ret;
+	int opt, num_events;
 	int currmax, numfilter;
 	int join_filter;
 	char *ptr, *nptr;
@@ -245,7 +312,7 @@ int main(int argc, char **argv)
 	int nbytes, i, maxdlen;
 	struct ifreq ifr;
 	struct timeval tv, last_tv;
-	struct timeval timeout, timeout_config = { 0, 0 }, *timeout_current = NULL;
+	int timeout_ms = -1; /* default to no timeout */
 	FILE *logfile = NULL;
 
 	signal(SIGTERM, sigterm);
@@ -255,16 +322,20 @@ int main(int argc, char **argv)
 	last_tv.tv_sec = 0;
 	last_tv.tv_usec = 0;
 
-	while ((opt = getopt(argc, argv, "t:HciaSs:lDdxLn:r:heT:?")) != -1) {
+	while ((opt = getopt(argc, argv, "t:HciaSs:lDdxLn:r:he8T:?")) != -1) {
 		switch (opt) {
 		case 't':
 			timestamp = optarg[0];
+			logtimestamp = optarg[0];
 			if ((timestamp != 'a') && (timestamp != 'A') &&
 			    (timestamp != 'd') && (timestamp != 'z')) {
 				fprintf(stderr, "%s: unknown timestamp mode '%c' - ignored\n",
 					basename(argv[0]), optarg[0]);
 				timestamp = 0;
 			}
+			if ((logtimestamp != 'a') && (logtimestamp != 'z')) {
+				logtimestamp = 'a';
+			}
 			break;
 
 		case 'H':
@@ -291,6 +362,10 @@ int main(int argc, char **argv)
 			view |= CANLIB_VIEW_ERROR;
 			break;
 
+		case '8':
+			view |= CANLIB_VIEW_LEN8_DLC;
+			break;
+
 		case 's':
 			silent = atoi(optarg);
 			if (silent > SILENT_ON) {
@@ -337,14 +412,11 @@ int main(int argc, char **argv)
 
 		case 'T':
 			errno = 0;
-			timeout_config.tv_usec = strtol(optarg, NULL, 0);
+			timeout_ms = strtol(optarg, NULL, 0);
 			if (errno != 0) {
 				print_usage(basename(argv[0]));
 				exit(1);
 			}
-			timeout_config.tv_sec = timeout_config.tv_usec / 1000;
-			timeout_config.tv_usec = (timeout_config.tv_usec % 1000) * 1000;
-			timeout_current = &timeout;
 			break;
 		default:
 			print_usage(basename(argv[0]));
@@ -359,7 +431,7 @@ int main(int argc, char **argv)
 	}
 
 	if (logfrmt && view) {
-		fprintf(stderr, "Log file format selected: Please disable ASCII/BINARY/SWAP options!\n");
+		fprintf(stderr, "Log file format selected: Please disable ASCII/BINARY/SWAP/RAWDLC options!\n");
 		exit(0);
 	}
 
@@ -378,8 +450,14 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
-	for (i=0; i < currmax; i++) {
+	fd_epoll = epoll_create(1);
+	if (fd_epoll < 0) {
+		perror("epoll_create");
+		return 1;
+	}
 
+	for (i = 0; i < currmax; i++) {
+		struct if_info* obj = &sock_info[i];
 		ptr = argv[optind+i];
 		nptr = strchr(ptr, ',');
 
@@ -387,13 +465,19 @@ int main(int argc, char **argv)
 		printf("open %d '%s'.\n", i, ptr);
 #endif
 
-		s[i] = socket(PF_CAN, SOCK_RAW, CAN_RAW);
-		if (s[i] < 0) {
+		obj->s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+		if (obj->s < 0) {
 			perror("socket");
 			return 1;
 		}
 
-		cmdlinename[i] = ptr; /* save pointer to cmdline name of this socket */
+		event_setup.data.ptr = obj; /* remember the instance as private data */
+		if (epoll_ctl(fd_epoll, EPOLL_CTL_ADD, obj->s, &event_setup)) {
+			perror("failed to add socket to epoll");
+			return 1;
+		}
+
+		obj->cmdlinename = ptr; /* save pointer to cmdline name of this socket */
 
 		if (nptr)
 			nbytes = nptr - ptr;  /* interface name is up the first ',' */
@@ -418,7 +502,7 @@ int main(int argc, char **argv)
 #endif
 
 		if (strcmp(ANYDEV, ifr.ifr_name) != 0) {
-			if (ioctl(s[i], SIOCGIFINDEX, &ifr) < 0) {
+			if (ioctl(obj->s, SIOCGIFINDEX, &ifr) < 0) {
 				perror("SIOCGIFINDEX");
 				exit(1);
 			}
@@ -478,17 +562,17 @@ int main(int argc, char **argv)
 			}
 
 			if (err_mask)
-				setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_ERR_FILTER,
+				setsockopt(obj->s, SOL_CAN_RAW, CAN_RAW_ERR_FILTER,
 					   &err_mask, sizeof(err_mask));
 
-			if (join_filter && setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_JOIN_FILTERS,
+			if (join_filter && setsockopt(obj->s, SOL_CAN_RAW, CAN_RAW_JOIN_FILTERS,
 						      &join_filter, sizeof(join_filter)) < 0) {
 				perror("setsockopt CAN_RAW_JOIN_FILTERS not supported by your Linux Kernel");
 				return 1;
 			}
 
 			if (numfilter)
-				setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_FILTER,
+				setsockopt(obj->s, SOL_CAN_RAW, CAN_RAW_FILTER,
 					   rfilter, numfilter * sizeof(struct can_filter));
 
 			free(rfilter);
@@ -496,26 +580,25 @@ int main(int argc, char **argv)
 		} /* if (nptr) */
 
 		/* try to switch the socket into CAN FD mode */
-		setsockopt(s[i], SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on));
+		setsockopt(obj->s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on));
 
 		if (rcvbuf_size) {
-
 			int curr_rcvbuf_size;
 			socklen_t curr_rcvbuf_size_len = sizeof(curr_rcvbuf_size);
 
 			/* try SO_RCVBUFFORCE first, if we run with CAP_NET_ADMIN */
-			if (setsockopt(s[i], SOL_SOCKET, SO_RCVBUFFORCE,
+			if (setsockopt(obj->s, SOL_SOCKET, SO_RCVBUFFORCE,
 				       &rcvbuf_size, sizeof(rcvbuf_size)) < 0) {
 #ifdef DEBUG
 				printf("SO_RCVBUFFORCE failed so try SO_RCVBUF ...\n");
 #endif
-				if (setsockopt(s[i], SOL_SOCKET, SO_RCVBUF,
+				if (setsockopt(obj->s, SOL_SOCKET, SO_RCVBUF,
 					       &rcvbuf_size, sizeof(rcvbuf_size)) < 0) {
 					perror("setsockopt SO_RCVBUF");
 					return 1;
 				}
 
-				if (getsockopt(s[i], SOL_SOCKET, SO_RCVBUF,
+				if (getsockopt(obj->s, SOL_SOCKET, SO_RCVBUF,
 					       &curr_rcvbuf_size, &curr_rcvbuf_size_len) < 0) {
 					perror("getsockopt SO_RCVBUF");
 					return 1;
@@ -530,13 +613,12 @@ int main(int argc, char **argv)
 		}
 
 		if (timestamp || log || logfrmt) {
-
 			if (hwtimestamp) {
-				const int timestamping_flags = (SOF_TIMESTAMPING_SOFTWARE | \
-								SOF_TIMESTAMPING_RX_SOFTWARE | \
+				const int timestamping_flags = (SOF_TIMESTAMPING_SOFTWARE |
+								SOF_TIMESTAMPING_RX_SOFTWARE |
 								SOF_TIMESTAMPING_RAW_HARDWARE);
 
-				if (setsockopt(s[i], SOL_SOCKET, SO_TIMESTAMPING,
+				if (setsockopt(obj->s, SOL_SOCKET, SO_TIMESTAMPING,
 					       &timestamping_flags, sizeof(timestamping_flags)) < 0) {
 					perror("setsockopt SO_TIMESTAMPING is not supported by your Linux kernel");
 					return 1;
@@ -544,7 +626,7 @@ int main(int argc, char **argv)
 			} else {
 				const int timestamp_on = 1;
 
-				if (setsockopt(s[i], SOL_SOCKET, SO_TIMESTAMP,
+				if (setsockopt(obj->s, SOL_SOCKET, SO_TIMESTAMP,
 					       &timestamp_on, sizeof(timestamp_on)) < 0) {
 					perror("setsockopt SO_TIMESTAMP");
 					return 1;
@@ -553,17 +635,16 @@ int main(int argc, char **argv)
 		}
 
 		if (dropmonitor) {
-
 			const int dropmonitor_on = 1;
 
-			if (setsockopt(s[i], SOL_SOCKET, SO_RXQ_OVFL,
+			if (setsockopt(obj->s, SOL_SOCKET, SO_RXQ_OVFL,
 				       &dropmonitor_on, sizeof(dropmonitor_on)) < 0) {
 				perror("setsockopt SO_RXQ_OVFL not supported by your Linux Kernel");
 				return 1;
 			}
 		}
 
-		if (bind(s[i], (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+		if (bind(obj->s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 			perror("bind");
 			return 1;
 		}
@@ -609,24 +690,15 @@ int main(int argc, char **argv)
 	msg.msg_control = &ctrlmsg;
 
 	while (running) {
-
-		FD_ZERO(&rdfs);
-		for (i=0; i<currmax; i++)
-			FD_SET(s[i], &rdfs);
-
-		if (timeout_current)
-			*timeout_current = timeout_config;
-
-		if ((ret = select(s[currmax-1]+1, &rdfs, NULL, NULL, timeout_current)) <= 0) {
-			//perror("select");
+		num_events = epoll_wait(fd_epoll, events_pending, currmax, timeout_ms);
+		if (num_events == -1) {
+			if (errno != EINTR)
 				running = 0;
 			continue;
 		}
 
-		for (i=0; i<currmax; i++) {  /* check all CAN RAW sockets */
-
-			if (FD_ISSET(s[i], &rdfs)) {
-
+		for (i = 0; i < num_events; i++) {  /* check waiting CAN RAW sockets */
+			struct if_info* obj = events_pending[i].data.ptr;
 			int idx;
 			char *extra_info = "";
 
@@ -636,8 +708,8 @@ int main(int argc, char **argv)
 			msg.msg_controllen = sizeof(ctrlmsg);
 			msg.msg_flags = 0;
 
-				nbytes = recvmsg(s[i], &msg, 0);
-				idx = idx2dindex(addr.can_ifindex, s[i]);
+			nbytes = recvmsg(obj->s, &msg, 0);
+			idx = idx2dindex(addr.can_ifindex, obj->s);
 
 			if (nbytes < 0) {
 				if ((errno == ENETDOWN) && !down_causes_exit) {
@@ -679,23 +751,23 @@ int main(int argc, char **argv)
 					tv.tv_sec = stamp[2].tv_sec;
 					tv.tv_usec = stamp[2].tv_nsec/1000;
 				} else if (cmsg->cmsg_type == SO_RXQ_OVFL)
-						memcpy(&dropcnt[i], CMSG_DATA(cmsg), sizeof(__u32));
+					memcpy(&obj->dropcnt, CMSG_DATA(cmsg), sizeof(__u32));
 			}
 
 			/* check for (unlikely) dropped frames on this specific socket */
-				if (dropcnt[i] != last_dropcnt[i]) {
+			if (obj->dropcnt != obj->last_dropcnt) {
 
-					__u32 frames = dropcnt[i] - last_dropcnt[i];
+				__u32 frames = obj->dropcnt - obj->last_dropcnt;
 
 				if (silent != SILENT_ON)
 					printf("DROPCOUNT: dropped %d CAN frame%s on '%s' socket (total drops %d)\n",
-						       frames, (frames > 1)?"s":"", devname[idx], dropcnt[i]);
+					       frames, (frames > 1)?"s":"", devname[idx], obj->dropcnt);
 
 				if (log)
 					fprintf(logfile, "DROPCOUNT: dropped %d CAN frame%s on '%s' socket (total drops %d)\n",
-							frames, (frames > 1)?"s":"", devname[idx], dropcnt[i]);
+						frames, (frames > 1)?"s":"", devname[idx], obj->dropcnt);
 
-					last_dropcnt[i] = dropcnt[i];
+				obj->last_dropcnt = obj->dropcnt;
 			}
 
 			/* once we detected a EFF frame indent SFF frames accordingly */
@@ -711,11 +783,13 @@ int main(int argc, char **argv)
 
 			if (log) {
 				char buf[CL_CFSZ]; /* max length */
+				char ts_buf[TIMESTAMPSZ];
+
+				sprint_timestamp(logtimestamp, &tv, &last_tv, ts_buf);
 
 				/* log CAN frame with absolute timestamp & device */
 				sprint_canframe(buf, &frame, 0, maxdlen);
-					fprintf(logfile, "(%010lu.%06lu) %*s %s%s\n",
-						tv.tv_sec, tv.tv_usec,
+				fprintf(logfile, "%s%*s %s%s\n", ts_buf,
 					max_devname_len, devname[idx], buf,
 					extra_info);
 			}
@@ -725,8 +799,9 @@ int main(int argc, char **argv)
 
 				/* print CAN frame in log file style to stdout */
 				sprint_canframe(buf, &frame, 0, maxdlen);
-					printf("(%010lu.%06lu) %*s %s%s\n",
-					       tv.tv_sec, tv.tv_usec,
+				print_timestamp(logtimestamp, &tv, &last_tv);
+
+				printf("%*s %s%s\n",
 					max_devname_len, devname[idx], buf,
 					extra_info);
 				goto out_fflush; /* no other output to stdout */
@@ -741,48 +816,7 @@ int main(int argc, char **argv)
 			}
 
 			printf(" %s", (color > 2) ? col_on[idx % MAXCOL] : "");
-
-				switch (timestamp) {
-
-				case 'a': /* absolute with timestamp */
-					printf("(%010lu.%06lu) ", tv.tv_sec, tv.tv_usec);
-					break;
-
-				case 'A': /* absolute with date */
-				{
-					struct tm tm;
-					char timestring[25];
-
-					tm = *localtime(&tv.tv_sec);
-					strftime(timestring, 24, "%Y-%m-%d %H:%M:%S", &tm);
-					printf("(%s.%06lu) ", timestring, tv.tv_usec);
-				}
-				break;
-
-				case 'd': /* delta */
-				case 'z': /* starting with zero */
-				{
-					struct timeval diff;
-
-					if (last_tv.tv_sec == 0)   /* first init */
-						last_tv = tv;
-					diff.tv_sec  = tv.tv_sec  - last_tv.tv_sec;
-					diff.tv_usec = tv.tv_usec - last_tv.tv_usec;
-					if (diff.tv_usec < 0)
-						diff.tv_sec--, diff.tv_usec += 1000000;
-					if (diff.tv_sec < 0)
-						diff.tv_sec = diff.tv_usec = 0;
-					printf("(%03lu.%06lu) ", diff.tv_sec, diff.tv_usec);
-				
-					if (timestamp == 'd')
-						last_tv = tv; /* update for delta calculation */
-				}
-				break;
-
-				default: /* no timestamp output */
-					break;
-				}
-
+			print_timestamp(timestamp, &tv, &last_tv);
 			printf(" %s", (color && (color < 3)) ? col_on[idx % MAXCOL] : "");
 			printf("%*s", max_devname_len, devname[idx]);
 
@@ -800,7 +834,6 @@ int main(int argc, char **argv)
 
 			printf("%s", (color > 1) ? col_off : "");
 			printf("\n");
-			}
 
  out_fflush:
 			fflush(stdout);
@@ -808,7 +841,9 @@ int main(int argc, char **argv)
 	}
 
 	for (i = 0; i < currmax; i++)
-		close(s[i]);
+		close(sock_info[i].s);
+
+	close(fd_epoll);
 
 	if (log)
 		fclose(logfile);

canfdtest.c

@@ -58,11 +58,11 @@ static void print_usage(char *prg)
 		"Usage: %s [options] <can-interface>\n"
 		"\n"
 		"Options:\n"
-		"         -v       (low verbosity)\n"
-		"         -vv      (high verbosity)\n"
+		"         -f COUNT (number of frames in flight, default: %d)\n"
 		"         -g       (generate messages)\n"
 		"         -l COUNT (test loop count)\n"
-		"         -f COUNT (number of frames in flight, default: %d)\n"
+		"         -v       (low verbosity)\n"
+		"         -vv      (high verbosity)\n"
 		"\n"
 		"With the option '-g' CAN messages are generated and checked\n"
 		"on <can-interface>, otherwise all messages received on the\n"
@@ -376,19 +376,20 @@ int main(int argc, char *argv[])
 
 	while ((opt = getopt(argc, argv, "f:gl:v?")) != -1) {
 		switch (opt) {
-		case 'v':
-			verbose++;
-			break;
 		case 'f':
 			inflight_count = atoi(optarg);
 			break;
 
+		case 'g':
+			echo_gen = 1;
+			break;
+
 		case 'l':
 			test_loops = atoi(optarg);
 			break;
 
-		case 'g':
-			echo_gen = 1;
+		case 'v':
+			verbose++;
 			break;
 			
 		case '?':

canframelen.c

@@ -236,13 +236,40 @@ static unsigned cfl_exact(struct can_frame *frame)
 		3;		/* IFS */
 }
 
+unsigned can_frame_dbitrate_length(struct canfd_frame *frame, enum cfl_mode mode, int mtu)
+{
+	if (mtu != CANFD_MTU || !(frame->flags & CANFD_BRS))
+		return 0;
+	switch (mode) {
+	case CFL_NO_BITSTUFFING:
+		return 1 /* brs/crcdel */ + 1 /* esi */ + 4 /* dlc */ +
+			((frame->len >= 16) ? 21 : 17) +
+			frame->len * 8;
+	case CFL_WORSTCASE:
+		return can_frame_dbitrate_length(frame, CFL_NO_BITSTUFFING, mtu) * 5 / 4;
+	default:
+		return 0;
+	}
+}
 
 unsigned can_frame_length(struct canfd_frame *frame, enum cfl_mode mode, int mtu)
 {
 	int eff = (frame->can_id & CAN_EFF_FLAG);
 
-	if (mtu != CAN_MTU)
-		return 0;	/* CANFD is not supported yet */
+	if (mtu == CANFD_MTU)
+		/* not correct, but close ? */
+		switch (mode) {
+		case CFL_NO_BITSTUFFING:
+			return 1 + (eff ? 29 : 11) + ((frame->len >= 16) ? 21 : 17) +
+				5 /* r1, ide, edl, r0, brs/crcdel, */ + 12 /* trail */ +
+				frame->len * 8;
+		case CFL_WORSTCASE:
+			return can_frame_length(frame, CFL_NO_BITSTUFFING, mtu) * 5 / 4;
+		case CFL_EXACT:
+			return 0; /* exact bittiming for CANFD not supported yet */
+		}
+	else if (mtu != CAN_MTU)
+		return 0; /* Only CAN2.0 and CANFD supported now */
 
 	switch (mode) {
 	case CFL_NO_BITSTUFFING:

canframelen.h

@@ -80,5 +80,6 @@ enum cfl_mode {
  * Mode determines how to deal with stuffed bits.
  */
 unsigned can_frame_length(struct canfd_frame *frame, enum cfl_mode mode, int mtu);
+unsigned can_frame_dbitrate_length(struct canfd_frame *frame, enum cfl_mode mode, int mtu);
 
 #endif

cangen.c

@@ -72,6 +72,8 @@
 #define MODE_RANDOM	0
 #define MODE_INCREMENT	1
 #define MODE_FIX	2
+#define MODE_RANDOM_EVEN	3
+#define MODE_RANDOM_ODD	4
 
 extern int optind, opterr, optopt;
 
@@ -92,7 +94,8 @@ void print_usage(char *prg)
 		" with bitrate switch (BRS))\n");
 	fprintf(stderr, "         -E            (generate CAN FD CAN frames"
 		" with error state (ESI))\n");
-	fprintf(stderr, "         -R            (send RTR frame)\n");
+	fprintf(stderr, "         -R            (generate RTR frames)\n");
+	fprintf(stderr, "         -8            (allow DLC values greater then 8 for Classic CAN frames)\n");
 	fprintf(stderr, "         -m            (mix -e -f -b -E -R frames)\n");
 	fprintf(stderr, "         -I <mode>     (CAN ID"
 		" generation mode - see below)\n");
@@ -108,14 +111,16 @@ void print_usage(char *prg)
 		" write() syscalls)\n");
 	fprintf(stderr, "         -x            (disable local loopback of "
 		"generated CAN frames)\n");
-	fprintf(stderr, "         -c            (number of messages to send in burst, "
+	fprintf(stderr, "         -c <count>    (number of messages to send in burst, "
 		"default 1)\n");
 	fprintf(stderr, "         -v            (increment verbose level for "
 		"printing sent CAN frames)\n\n");
 	fprintf(stderr, "Generation modes:\n");
 	fprintf(stderr, " 'r'     => random values (default)\n");
+	fprintf(stderr, " 'e'     => random values, even ID\n");
+	fprintf(stderr, " 'o'     => random values, odd ID\n");
 	fprintf(stderr, " 'i'     => increment values\n");
-	fprintf(stderr, " <hexvalue>  => fix value using <hexvalue>\n\n");
+	fprintf(stderr, " <value> => fixed value (in hexadecimal for -I and -D)\n\n");
 	fprintf(stderr, "When incrementing the CAN data the data length code "
 		"minimum is set to 1.\n");
 	fprintf(stderr, "CAN IDs and data content are given and expected in hexadecimal values.\n\n");
@@ -156,6 +161,7 @@ int main(int argc, char **argv)
 	unsigned char loopback_disable = 0;
 	unsigned char verbose = 0;
 	unsigned char rtr_frame = 0;
+	unsigned char len8_dlc = 0;
 	int count = 0;
 	unsigned long burst_sent_count = 0;
 	int mtu, maxdlen;
@@ -170,6 +176,7 @@ int main(int argc, char **argv)
 
 	struct sockaddr_can addr;
 	static struct canfd_frame frame;
+	struct can_frame *ccf = (struct can_frame *)&frame;
 	int nbytes;
 	int i;
 	struct ifreq ifr;
@@ -185,7 +192,7 @@ int main(int argc, char **argv)
 	signal(SIGHUP, sigterm);
 	signal(SIGINT, sigterm);
 
-	while ((opt = getopt(argc, argv, "ig:ebEfmI:L:D:xp:n:c:vRh?")) != -1) {
+	while ((opt = getopt(argc, argv, "ig:ebEfmI:L:D:xp:n:c:vR8h?")) != -1) {
 		switch (opt) {
 
 		case 'i':
@@ -224,6 +231,10 @@ int main(int argc, char **argv)
 				id_mode = MODE_RANDOM;
 			} else if (optarg[0] == 'i') {
 				id_mode = MODE_INCREMENT;
+			} else if (optarg[0] == 'e') {
+				id_mode = MODE_RANDOM_EVEN;
+			} else if (optarg[0] == 'o') {
+				id_mode = MODE_RANDOM_ODD;
 			} else {
 				id_mode = MODE_FIX;
 				frame.can_id = strtoul(optarg, NULL, 16);
@@ -271,6 +282,10 @@ int main(int argc, char **argv)
 			rtr_frame = 1;
 			break;
 
+		case '8':
+			len8_dlc = 1;
+			break;
+
 		case 'p':
 			polltimeout = strtoul(optarg, NULL, 10);
 			break;
@@ -360,11 +375,19 @@ int main(int argc, char **argv)
 		}
 
 		/* ensure discrete CAN FD length values 0..8, 12, 16, 20, 24, 32, 64 */
-		frame.len = can_dlc2len(can_len2dlc(frame.len));
+		frame.len = can_fd_dlc2len(can_fd_len2dlc(frame.len));
 	} else {
-		/* sanitize CAN 2.0 frame length */
-		if (frame.len > 8)
-			frame.len = 8;
+		/* sanitize Classical CAN 2.0 frame length */
+		if (len8_dlc) {
+			if (frame.len > CAN_MAX_RAW_DLC)
+				frame.len = CAN_MAX_RAW_DLC;
+
+			if (frame.len > CAN_MAX_DLEN)
+				ccf->len8_dlc = frame.len;
+		}
+
+		if (frame.len > CAN_MAX_DLEN)
+			frame.len = CAN_MAX_DLEN;
 	}
 
 	if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
@@ -397,6 +420,10 @@ int main(int argc, char **argv)
 
 		if (id_mode == MODE_RANDOM)
 			frame.can_id = random();
+		else if (id_mode == MODE_RANDOM_EVEN)
+			frame.can_id = random() & ~0x1;
+		else if (id_mode == MODE_RANDOM_ODD)
+			frame.can_id = random() | 0x1;
 
 		if (extended) {
 			frame.can_id &= CAN_EFF_MASK;
@@ -410,11 +437,19 @@ int main(int argc, char **argv)
 		if (dlc_mode == MODE_RANDOM) {
 
 			if (canfd)
-				frame.len = can_dlc2len(random() & 0xF);
+				frame.len = can_fd_dlc2len(random() & 0xF);
 			else {
 				frame.len = random() & 0xF;
-				if (frame.len & 8)
+
+				if (frame.len > CAN_MAX_DLEN) {
+					/* generate Classic CAN len8 DLCs? */
+					if (len8_dlc)
+						ccf->len8_dlc = frame.len;
+
 					frame.len = 8; /* for about 50% of the frames */
+				} else {
+					ccf->len8_dlc = 0;
+				}
 			}
 		}
 
@@ -493,12 +528,20 @@ resend:
 		if (dlc_mode == MODE_INCREMENT) {
 
 			incdlc++;
+			incdlc %= CAN_MAX_RAW_DLC + 1;
 
-			if (canfd && !mix) {
-				incdlc &= 0xF;
-				frame.len = can_dlc2len(incdlc);
+			if (canfd && !mix)
+				frame.len = can_fd_dlc2len(incdlc);
+			else if (len8_dlc) {
+				if (incdlc > CAN_MAX_DLEN) {
+					frame.len = CAN_MAX_DLEN;
+					ccf->len8_dlc = incdlc;
 				} else {
-				incdlc %= 9;
+					frame.len = incdlc;
+					ccf->len8_dlc = 0;
+				}
+			} else {
+				incdlc %= CAN_MAX_DLEN + 1;
 				frame.len = incdlc;
 			}
 		}

cangw.c

@@ -240,7 +240,7 @@ void print_usage(char *prg)
 	fprintf(stderr, "          -u <uid>  (user defined modification identifier)\n");
 	fprintf(stderr, "          -l <hops>  (limit the number of frame hops / routings)\n");
 	fprintf(stderr, "          -f <filter>  (set CAN filter)\n");
-	fprintf(stderr, "          -m <mod>  (set Classic CAN frame modifications)\n");
+	fprintf(stderr, "          -m <mod>  (set Classical CAN frame modifications)\n");
 	fprintf(stderr, "          -M <MOD>  (set CAN FD frame modifications)\n");
 	fprintf(stderr, "          -x <from_idx>:<to_idx>:<result_idx>:<init_xor_val>  (XOR checksum)\n");
 	fprintf(stderr, "          -c <from>:<to>:<result>:<init_val>:<xor_val>:<crctab[256]>  (CRC8 cs)\n");
@@ -251,12 +251,12 @@ void print_usage(char *prg)
 	fprintf(stderr, "  <can_id>:<can_mask>  (matches when <received_can_id> & mask == can_id & mask)\n");
 	fprintf(stderr, "  <can_id>~<can_mask>  (matches when <received_can_id> & mask != can_id & mask)\n");
 	fprintf(stderr, "\n");
-	fprintf(stderr, "<mod> is a CAN frame modification instruction consisting of\n");
+	fprintf(stderr, "<mod> is a Classical CAN frame modification instruction consisting of\n");
 	fprintf(stderr, "<instruction>:<can_frame-elements>:<can_id>.<can_dlc>.<can_data>\n");
 	fprintf(stderr, "  <instruction>  is one of 'AND' 'OR' 'XOR' 'SET'\n");
 	fprintf(stderr, "  <can_frame-elements>  is _one_ or _more_ of 'I'dentifier 'L'ength 'D'ata\n");
 	fprintf(stderr, "  <can_id>  is an u32 value containing the CAN Identifier\n");
-	fprintf(stderr, "  <can_dlc>  is an u8 value containing the data length code (0 .. 8)\n");
+	fprintf(stderr, "  <can_dlc>  is an u8 value containing the data length code in hex (0 .. F)\n");
 	fprintf(stderr, "  <can_data>  is always eight(!) u8 values containing the CAN frames data\n");
 	fprintf(stderr, "\n");
 	fprintf(stderr, "<MOD> is a CAN FD frame modification instruction consisting of\n");
@@ -265,7 +265,7 @@ void print_usage(char *prg)
 	fprintf(stderr, "  <canfd_frame-elements>  is _one_ or _more_ of 'I'd 'F'lags 'L'ength 'D'ata\n");
 	fprintf(stderr, "  <can_id>  is an u32 value containing the CAN FD Identifier\n");
 	fprintf(stderr, "  <flags>  is an u8 value containing CAN FD flags (CANFD_BRS, CANFD_ESI)\n");
-	fprintf(stderr, "  <len>  is an u8 value containing the data length (0 .. 64)\n");
+	fprintf(stderr, "  <len>  is an u8 value containing the data length in hex (0 .. 40)\n");
 	fprintf(stderr, "  <can_data>  is always 64(!) u8 values containing the CAN FD frames data\n");
 	fprintf(stderr, "The max. four modifications are performed in the order AND -> OR -> XOR -> SET\n");
 	fprintf(stderr, "\n");

canlogserver.c

@@ -162,7 +162,7 @@ void childdied(int i)
 }
 
 /*
- * This is a Signalhandler for a cought SIGTERM
+ * This is a Signalhandler for a caught SIGTERM
  */
 void shutdown_gra(int i)
 {

canplayer.c

@@ -87,6 +87,8 @@ void print_usage(char *prg)
                 "(Use 'i' for infinite loop - default: %d)\n", DEFAULT_LOOPS);
         fprintf(stderr, "         -t           (ignore timestamps: "
                 "send frames immediately)\n");
+        fprintf(stderr, "         -i           (interactive - wait "
+                "for ENTER key to process next frame)\n");
         fprintf(stderr, "         -g <ms>      (gap in milli "
                 "seconds - default: %d ms)\n", DEFAULT_GAP);
         fprintf(stderr, "         -s <s>       (skip gaps in "
@@ -139,7 +141,7 @@ static inline int frames_to_send(struct timeval *today, struct timeval *diff,
 	cmp.tv_sec  = log->tv_sec  + diff->tv_sec;
 	cmp.tv_usec = log->tv_usec + diff->tv_usec;
 
-	if (cmp.tv_usec > 1000000) {
+	if (cmp.tv_usec >= 1000000) {
 		cmp.tv_usec -= 1000000;
 		cmp.tv_sec++;
 	}
@@ -244,6 +246,7 @@ int main(int argc, char **argv)
 	FILE *infile = stdin;
 	unsigned long gap = DEFAULT_GAP; 
 	int use_timestamps = 1;
+	int interactive = 0; /* wait for ENTER keypress to process next frame */
 	static int verbose, opt, delay_loops;
 	static unsigned long skipgap;
 	static int loopback_disable = 0;
@@ -254,7 +257,7 @@ int main(int argc, char **argv)
 	int eof, txmtu, i, j;
 	char *fret;
 
-	while ((opt = getopt(argc, argv, "I:l:tg:s:xv?")) != -1) {
+	while ((opt = getopt(argc, argv, "I:l:tig:s:xv?")) != -1) {
 		switch (opt) {
 		case 'I':
 			infile = fopen(optarg, "r");
@@ -278,6 +281,10 @@ int main(int argc, char **argv)
 			use_timestamps = 0;
 			break;
 
+		case 'i':
+			interactive = 1;
+			break;
+
 		case 'g':
 			gap = strtoul(optarg, NULL, 10);
 			break;
@@ -320,6 +327,12 @@ int main(int argc, char **argv)
 			printf("%d loops\n", loops);
 	}
 
+	/* ignore timestamps from logfile when in single step keypress mode */
+	if (interactive) {
+		use_timestamps = 0;
+		printf("interactive mode: press ENTER to process next CAN frame ...\n");
+	}
+
 	sleep_ts.tv_sec  =  gap / 1000;
 	sleep_ts.tv_nsec = (gap % 1000) * 1000000;
 
@@ -413,6 +426,10 @@ int main(int argc, char **argv)
 			while ((!use_timestamps) ||
 			       (frames_to_send(&today_tv, &diff_tv, &log_tv) < 0)) {
 
+				/* wait for keypress to process next frame */
+				if (interactive)
+					getchar();
+
 				/* log_tv/device/ascframe are valid here */
 
 				if (strlen(device) >= IFNAMSIZ) {

cansend.c

@@ -61,8 +61,10 @@ void print_usage(char *prg)
 	fprintf(stderr, "%s - send CAN-frames via CAN_RAW sockets.\n", prg);
 	fprintf(stderr, "\nUsage: %s <device> <can_frame>.\n", prg);
 	fprintf(stderr, "\n<can_frame>:\n");
-	fprintf(stderr, " <can_id>#{data}          for 'classic' CAN 2.0 data frames\n");
-	fprintf(stderr, " <can_id>#R{len}          for 'classic' CAN 2.0 data frames\n");
+	fprintf(stderr, " <can_id>#{data}          for Classical CAN 2.0 data frames\n");
+	fprintf(stderr, " <can_id>#R{len}          for Classical CAN 2.0 data frames\n");
+	fprintf(stderr, " <can_id>#{data}_{dlc}    for Classical CAN 2.0 data frames\n");
+	fprintf(stderr, " <can_id>#R{len}_{dlc}    for Classical CAN 2.0 data frames\n");
 	fprintf(stderr, " <can_id>##<flags>{data}  for CAN FD frames\n\n");
 	fprintf(stderr, "<can_id>:\n"
 	        " 3 (SFF) or 8 (EFF) hex chars\n");
@@ -70,11 +72,13 @@ void print_usage(char *prg)
 	        " 0..8 (0..64 CAN FD) ASCII hex-values (optionally separated by '.')\n");
 	fprintf(stderr, "{len}:\n"
 		 " an optional 0..8 value as RTR frames can contain a valid dlc field\n");
+	fprintf(stderr, "_{dlc}:\n"
+		 " an optional 9..F data length code value when payload length is 8\n");
 	fprintf(stderr, "<flags>:\n"
 	        " a single ASCII Hex value (0 .. F) which defines canfd_frame.flags\n\n");
 	fprintf(stderr, "Examples:\n");
 	fprintf(stderr, "  5A1#11.2233.44556677.88 / 123#DEADBEEF / 5AA# / 123##1 / 213##311223344 /\n"
-		 "  1F334455#1122334455667788 / 123#R / 00000123#R3\n\n");
+		 "  1F334455#1122334455667788_B / 123#R / 00000123#R3 / 333#R8_E\n\n");
 }
 
 
@@ -143,7 +147,7 @@ int main(int argc, char **argv)
 		}
 
 		/* ensure discrete CAN FD length values 0..8, 12, 16, 20, 24, 32, 64 */
-		frame.len = can_dlc2len(can_len2dlc(frame.len));
+		frame.len = can_fd_dlc2len(can_fd_len2dlc(frame.len));
 	}
 
 	/* disable default receive filter on this RAW socket */

cansniffer.c

@@ -844,7 +844,7 @@ int sniftab_index(canid_t id)
 {
 	int i;
 
-	for (i = 0; i <= idx; i++)
+	for (i = 0; i < idx; i++)
 		if (id == sniftab[i].current.can_id)
 			return i;
 

configure.ac

@@ -19,7 +19,7 @@ CFLAGS="${CFLAGS} -Wall"
 AC_PROG_CC
 LT_INIT(win32-dll)
 
-AM_INIT_AUTOMAKE([foreign no-exeext dist-bzip2])
+AM_INIT_AUTOMAKE([foreign no-exeext dist-bzip2 subdir-objects])
 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
 
 #

include/linux/can.h

@@ -84,6 +84,7 @@ typedef __u32 can_err_mask_t;
 
 /* CAN payload length and DLC definitions according to ISO 11898-1 */
 #define CAN_MAX_DLC 8
+#define CAN_MAX_RAW_DLC 15
 #define CAN_MAX_DLEN 8
 
 /* CAN FD payload length and DLC definitions according to ISO 11898-7 */
@@ -91,30 +92,39 @@ typedef __u32 can_err_mask_t;
 #define CANFD_MAX_DLEN 64
 
 /**
- * struct can_frame - basic CAN frame structure
+ * struct can_frame - Classical CAN frame structure (aka CAN 2.0B)
  * @can_id:   CAN ID of the frame and CAN_*_FLAG flags, see canid_t definition
- * @can_dlc: frame payload length in byte (0 .. 8) aka data length code
- *           N.B. the DLC field from ISO 11898-1 Chapter 8.4.2.3 has a 1:1
- *           mapping of the 'data length code' to the real payload length
+ * @len:      CAN frame payload length in byte (0 .. 8)
+ * @can_dlc:  deprecated name for CAN frame payload length in byte (0 .. 8)
  * @__pad:    padding
  * @__res0:   reserved / padding
- * @__res1:  reserved / padding
+ * @len8_dlc: optional DLC value (9 .. 15) at 8 byte payload length
+ *            len8_dlc contains values from 9 .. 15 when the payload length is
+ *            8 bytes but the DLC value (see ISO 11898-1) is greater then 8.
+ *            CAN_CTRLMODE_CC_LEN8_DLC flag has to be enabled in CAN driver.
  * @data:     CAN frame payload (up to 8 byte)
  */
 struct can_frame {
 	canid_t can_id;  /* 32 bit CAN_ID + EFF/RTR/ERR flags */
-	__u8    can_dlc; /* frame payload length in byte (0 .. CAN_MAX_DLEN) */
+	union {
+		/* CAN frame payload length in byte (0 .. CAN_MAX_DLEN)
+		 * was previously named can_dlc so we need to carry that
+		 * name for legacy support
+		 */
+		__u8 len;
+		__u8 can_dlc; /* deprecated */
+	} __attribute__((packed)); /* disable padding added in some ABIs */
 	__u8 __pad; /* padding */
 	__u8 __res0; /* reserved / padding */
-	__u8    __res1;  /* reserved / padding */
+	__u8 len8_dlc; /* optional DLC for 8 byte payload length (9 .. 15) */
 	__u8 data[CAN_MAX_DLEN] __attribute__((aligned(8)));
 };
 
 /*
  * defined bits for canfd_frame.flags
  *
- * The use of struct canfd_frame implies the Extended Data Length (EDL) bit to
- * be set in the CAN frame bitstream on the wire. The EDL bit switch turns
+ * The use of struct canfd_frame implies the FD Frame (FDF) bit to
+ * be set in the CAN frame bitstream on the wire. The FDF bit switch turns
  * the CAN controllers bitstream processor into the CAN FD mode which creates
  * two new options within the CAN FD frame specification:
  *
@@ -125,9 +135,18 @@ struct can_frame {
  * controller only the CANFD_BRS bit is relevant for real CAN controllers when
  * building a CAN FD frame for transmission. Setting the CANFD_ESI bit can make
  * sense for virtual CAN interfaces to test applications with echoed frames.
+ *
+ * The struct can_frame and struct canfd_frame intentionally share the same
+ * layout to be able to write CAN frame content into a CAN FD frame structure.
+ * When this is done the former differentiation via CAN_MTU / CANFD_MTU gets
+ * lost. CANFD_FDF allows programmers to mark CAN FD frames in the case of
+ * using struct canfd_frame for mixed CAN / CAN FD content (dual use).
+ * N.B. the Kernel APIs do NOT provide mixed CAN / CAN FD content inside of
+ * struct canfd_frame therefore the CANFD_FDF flag is disregarded by Linux.
  */
 #define CANFD_BRS 0x01 /* bit rate switch (second bitrate for payload data) */
 #define CANFD_ESI 0x02 /* error state indicator of the transmitting node */
+#define CANFD_FDF 0x04 /* mark CAN FD for dual use of struct canfd_frame */
 
 /**
  * struct canfd_frame - CAN flexible data rate frame structure

include/linux/can/gw.h

@@ -98,8 +98,8 @@ enum {
 
 /* CAN frame elements that are affected by curr. 3 CAN frame modifications */
 #define CGW_MOD_ID	0x01
-#define CGW_MOD_DLC	0x02		/* contains the data length in bytes */
-#define CGW_MOD_LEN	CGW_MOD_DLC	/* CAN FD length representation */
+#define CGW_MOD_DLC	0x02		/* Classical CAN data length code */
+#define CGW_MOD_LEN	CGW_MOD_DLC	/* CAN FD (plain) data length */
 #define CGW_MOD_DATA	0x04
 #define CGW_MOD_FLAGS	0x08		/* CAN FD flags */
 

include/linux/can/isotp.h

@@ -135,7 +135,7 @@ struct can_isotp_ll_options {
 #define CAN_ISOTP_FORCE_RXSTMIN	0x100	/* ignore CFs depending on rx stmin */
 #define CAN_ISOTP_RX_EXT_ADDR	0x200	/* different rx extended addressing */
 #define CAN_ISOTP_WAIT_TX_DONE	0x400	/* wait for tx completion */
-
+#define CAN_ISOTP_SF_BROADCAST	0x800	/* 1-to-N functional addressing */
 
 /* default values */
 

include/linux/can/netlink.h

@@ -100,6 +100,7 @@ struct can_ctrlmode {
 #define CAN_CTRLMODE_FD			0x20	/* CAN FD mode */
 #define CAN_CTRLMODE_PRESUME_ACK	0x40	/* Ignore missing CAN ACKs */
 #define CAN_CTRLMODE_FD_NON_ISO		0x80	/* CAN FD in non-ISO mode */
+#define CAN_CTRLMODE_CC_LEN8_DLC	0x100	/* Classic CAN DLC option */
 
 /*
  * CAN device statistics

include/linux/kernel.h

@@ -0,0 +1,96 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef _LINUX_KERNEL_H
+#define _LINUX_KERNEL_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include <linux/can.h>
+
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint32_t __le32;
+
+struct mcp251xfd_mem;
+
+struct regmap {
+	struct mcp251xfd_mem *mem;
+};
+
+#define pr_info(...) fprintf(stdout, ## __VA_ARGS__)
+#define pr_cont(...) fprintf(stdout, ## __VA_ARGS__)
+#define netdev_info(ndev, ...) fprintf(stdout, ## __VA_ARGS__)
+#define BUILD_BUG_ON(...)
+
+#define BITS_PER_LONG (sizeof(long) * 8)
+
+#define ____cacheline_aligned
+
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+int regmap_bulk_read(struct regmap *map, unsigned int reg,
+		     void *val, size_t val_count);
+
+#define SZ_2K				0x00000800
+
+#define __packed                        __attribute__((__packed__))
+
+#define sizeof_field(TYPE, MEMBER) sizeof((((TYPE *)0)->MEMBER))
+
+#define BIT(nr)			(UL(1) << (nr))
+
+#define __stringify_1(x...)	#x
+#define __stringify(x...)	__stringify_1(x)
+
+#ifdef __ASSEMBLY__
+#define _AC(X,Y)	X
+#define _AT(T,X)	X
+#else
+#define __AC(X,Y)	(X##Y)
+#define _AC(X,Y)	__AC(X,Y)
+#define _AT(T,X)	((T)(X))
+#endif
+
+#define _UL(x)		(_AC(x, UL))
+#define _ULL(x)		(_AC(x, ULL))
+
+#define UL(x)		(_UL(x))
+#define ULL(x)		(_ULL(x))
+
+#define GENMASK(h, l) \
+	(((~UL(0)) - (UL(1) << (l)) + 1) & \
+	 (~UL(0) >> (BITS_PER_LONG - 1 - (h))))
+
+#define __bf_shf(x) (__builtin_ffsll(x) - 1)
+
+#define FIELD_PREP(_mask, _val)						\
+	({								\
+		((typeof(_mask))(_val) << __bf_shf(_mask)) & (_mask);	\
+	})
+
+#define FIELD_GET(_mask, _reg)						\
+	({								\
+		(typeof(_mask))(((_reg) & (_mask)) >> __bf_shf(_mask));	\
+	})
+
+#define min_t(type, x, y) ({			\
+	type __min1 = (x);			\
+	type __min2 = (y);			\
+	__min1 < __min2 ? __min1 : __min2; })
+
+#define get_canfd_dlc(i)	(min_t(__u8, (i), CANFD_MAX_DLC))
+
+static const u8 dlc2len[] = {0, 1, 2, 3, 4, 5, 6, 7,
+			     8, 12, 16, 20, 24, 32, 48, 64};
+
+/* get data length from can_dlc with sanitized can_dlc */
+static inline u8 can_dlc2len(u8 can_dlc)
+{
+	return dlc2len[can_dlc & 0x0F];
+}
+
+#endif /* _LINUX_KERNEL_H */

isotpsend.c

@@ -72,6 +72,7 @@ void print_usage(char *prg)
 	fprintf(stderr, "         -f <time ns>  (ignore FC and force local tx stmin value in nanosecs)\n");
 	fprintf(stderr, "         -D <len>      (send a fixed PDU with len bytes - no STDIN data)\n");
 	fprintf(stderr, "         -b            (block until the PDU transmission is completed)\n");
+	fprintf(stderr, "         -S            (SF broadcast mode for functional addressing)\n");
 	fprintf(stderr, "         -L <mtu>:<tx_dl>:<tx_flags>  (link layer options for CAN FD)\n");
 	fprintf(stderr, "\nCAN IDs and addresses are given and expected in hexadecimal values.\n");
 	fprintf(stderr, "The pdu data is expected on STDIN in space separated ASCII hex values.\n");
@@ -94,7 +95,7 @@ int main(int argc, char **argv)
 
     addr.can_addr.tp.tx_id = addr.can_addr.tp.rx_id = NO_CAN_ID;
 
-    while ((opt = getopt(argc, argv, "s:d:x:p:P:t:f:D:bL:?")) != -1) {
+    while ((opt = getopt(argc, argv, "s:d:x:p:P:t:f:D:bSL:?")) != -1) {
 	    switch (opt) {
 	    case 's':
 		    addr.can_addr.tp.tx_id = strtoul(optarg, (char **)NULL, 16);
@@ -181,6 +182,10 @@ int main(int argc, char **argv)
 		    opts.flags |= CAN_ISOTP_WAIT_TX_DONE;
 		    break;
 
+	    case 'S':
+		    opts.flags |= CAN_ISOTP_SF_BROADCAST;
+		    break;
+
 	    case 'L':
 		    if (sscanf(optarg, "%hhu:%hhu:%hhu",
 			       &llopts.mtu,
@@ -207,7 +212,8 @@ int main(int argc, char **argv)
 
     if ((argc - optind != 1) ||
 	(addr.can_addr.tp.tx_id == NO_CAN_ID) ||
-	(addr.can_addr.tp.rx_id == NO_CAN_ID)) {
+	((addr.can_addr.tp.rx_id == NO_CAN_ID) &&
+	 (!(opts.flags & CAN_ISOTP_SF_BROADCAST)))) {
 	    print_usage(basename(argv[0]));
 	    exit(1);
     }

j1939cat.c

@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
 
 #include <linux/errqueue.h>

lib.c

@@ -53,6 +53,7 @@
 #include "lib.h"
 
 #define CANID_DELIM '#'
+#define CC_DLC_DELIM '_'
 #define DATA_SEPERATOR '.'
 
 const char hex_asc_upper[] = "0123456789ABCDEF";
@@ -83,10 +84,10 @@ static inline void _put_id(char *buf, int end_offset, canid_t id)
 static const unsigned char dlc2len[] = {0, 1, 2, 3, 4, 5, 6, 7,
 					8, 12, 16, 20, 24, 32, 48, 64};
 
-/* get data length from can_dlc with sanitized can_dlc */
-unsigned char can_dlc2len(unsigned char can_dlc)
+/* get data length from raw data length code (DLC) */
+unsigned char can_fd_dlc2len(unsigned char dlc)
 {
-	return dlc2len[can_dlc & 0x0F];
+	return dlc2len[dlc & 0x0F];
 }
 
 static const unsigned char len2dlc[] = {0, 1, 2, 3, 4, 5, 6, 7, 8,		/* 0 - 8 */
@@ -101,7 +102,7 @@ static const unsigned char len2dlc[] = {0, 1, 2, 3, 4, 5, 6, 7, 8,		/* 0 - 8 */
 					15, 15, 15, 15, 15, 15, 15, 15};	/* 57 - 64 */
 
 /* map the sanitized data length to an appropriate data length code */
-unsigned char can_len2dlc(unsigned char len)
+unsigned char can_fd_len2dlc(unsigned char len)
 {
 	if (len > 64)
 		return 0xF;
@@ -195,9 +196,19 @@ int parse_canframe(char *cs, struct canfd_frame *cf) {
 		cf->can_id |= CAN_RTR_FLAG;
 
 		/* check for optional DLC value for CAN 2.0B frames */
-		if(cs[++idx] && (tmp = asc2nibble(cs[idx])) <= CAN_MAX_DLC)
+		if(cs[++idx] && (tmp = asc2nibble(cs[idx++])) <= CAN_MAX_DLEN) {
 			cf->len = tmp;
 
+			/* check for optional raw DLC value for CAN 2.0B frames */
+			if ((tmp == CAN_MAX_DLEN) && (cs[idx++] == CC_DLC_DELIM)) {
+				tmp = asc2nibble(cs[idx]);
+				if ((tmp > CAN_MAX_DLEN) && (tmp <= CAN_MAX_RAW_DLC)) {
+					struct can_frame *ccf = (struct can_frame *)cf;
+
+					ccf->len8_dlc = tmp;
+				}
+			}
+		}
 		return ret;
 	}
 
@@ -232,6 +243,17 @@ int parse_canframe(char *cs, struct canfd_frame *cf) {
 	}
 	cf->len = dlen;
 
+	/* check for extra DLC when having a Classic CAN with 8 bytes payload */
+	if ((maxdlen == CAN_MAX_DLEN) && (dlen == CAN_MAX_DLEN) && (cs[idx++] == CC_DLC_DELIM)) {
+		unsigned char dlc = asc2nibble(cs[idx]);
+
+		if ((dlc > CAN_MAX_DLEN) && (dlc <= CAN_MAX_RAW_DLC)) {
+			struct can_frame *ccf = (struct can_frame *)cf;
+
+			ccf->len8_dlc = dlc;
+		}
+	}
+
 	return ret;
 }
 
@@ -270,9 +292,20 @@ void sprint_canframe(char *buf , struct canfd_frame *cf, int sep, int maxdlen) {
 	if (maxdlen == CAN_MAX_DLEN && cf->can_id & CAN_RTR_FLAG) {
 		buf[offset++] = 'R';
 		/* print a given CAN 2.0B DLC if it's not zero */
-		if (cf->len && cf->len <= CAN_MAX_DLC)
+		if (cf->len && cf->len <= CAN_MAX_DLEN) {
 			buf[offset++] = hex_asc_upper_lo(cf->len);
 
+			/* check for optional raw DLC value for CAN 2.0B frames */
+			if (cf->len == CAN_MAX_DLEN) {
+				struct can_frame *ccf = (struct can_frame *)cf;
+
+				if ((ccf->len8_dlc > CAN_MAX_DLEN) && (ccf->len8_dlc <= CAN_MAX_RAW_DLC)) {
+					buf[offset++] = CC_DLC_DELIM;
+					buf[offset++] = hex_asc_upper_lo(ccf->len8_dlc);
+				}
+			}
+		}
+
 		buf[offset] = 0;
 		return;
 	}
@@ -292,6 +325,17 @@ void sprint_canframe(char *buf , struct canfd_frame *cf, int sep, int maxdlen) {
 			buf[offset++] = '.';
 	}
 
+	/* check for extra DLC when having a Classic CAN with 8 bytes payload */
+	if ((maxdlen == CAN_MAX_DLEN) && (len == CAN_MAX_DLEN)) {
+		struct can_frame *ccf = (struct can_frame *)cf;
+		unsigned char dlc = ccf->len8_dlc;
+
+		if ((dlc > CAN_MAX_DLEN) && (dlc <= CAN_MAX_RAW_DLC)) {
+			buf[offset++] = CC_DLC_DELIM;
+			buf[offset++] = hex_asc_upper_lo(dlc);
+		}
+	}
+
 	buf[offset] = 0;
 }
 
@@ -337,9 +381,23 @@ void sprint_long_canframe(char *buf , struct canfd_frame *cf, int view, int maxd
 
 	/* The len value is sanitized by maxdlen (see above) */
 	if (maxdlen == CAN_MAX_DLEN) {
+		if (view & CANLIB_VIEW_LEN8_DLC) {
+			struct can_frame *ccf = (struct can_frame *)cf;
+			unsigned char dlc = ccf->len8_dlc;
+
+			/* fall back to len if we don't have a valid DLC > 8 */
+			if (!((len == CAN_MAX_DLEN) && (dlc > CAN_MAX_DLEN) &&
+			      (dlc <= CAN_MAX_RAW_DLC)))
+				dlc = len;
+
+			buf[offset + 1] = '{';
+			buf[offset + 2] = hex_asc_upper[dlc];
+			buf[offset + 3] = '}';
+		} else {
 			buf[offset + 1] = '[';
 			buf[offset + 2] = len + '0';
 			buf[offset + 3] = ']';
+		}
 
 		/* standard CAN frames may have RTR enabled */
 		if (cf->can_id & CAN_RTR_FLAG) {

lib.h

@@ -61,11 +61,11 @@
 
 /* CAN DLC to real data length conversion helpers especially for CAN FD */
 
-/* get data length from can_dlc with sanitized can_dlc */
-unsigned char can_dlc2len(unsigned char can_dlc);
+/* get data length from raw data length code (DLC) */
+unsigned char can_fd_dlc2len(unsigned char dlc);
 
 /* map the sanitized data length to an appropriate data length code */
-unsigned char can_len2dlc(unsigned char len);
+unsigned char can_fd_len2dlc(unsigned char len);
 
 unsigned char asc2nibble(char c);
 /*
@@ -99,10 +99,11 @@ int parse_canframe(char *cs, struct canfd_frame *cf);
 /*
  * Transfers a valid ASCII string describing a CAN frame into struct canfd_frame.
  *
- * CAN 2.0 frames
- * - string layout <can_id>#{R{len}|data}
+ * CAN 2.0 frames (aka Classical CAN)
+ * - string layout <can_id>#{R{len}|data}{_len8_dlc}
  * - {data} has 0 to 8 hex-values that can (optionally) be separated by '.'
  * - {len} can take values from 0 to 8 and can be omitted if zero
+ * - {_len8_dlc} can take hex values from '_9' to '_F' when len is CAN_MAX_DLEN
  * - return value on successful parsing: CAN_MTU
  *
  * CAN FD frames
@@ -124,10 +125,12 @@ int parse_canframe(char *cs, struct canfd_frame *cf);
  * 123#R -> standard CAN-Id = 0x123, len = 0, RTR-frame
  * 123#R0 -> standard CAN-Id = 0x123, len = 0, RTR-frame
  * 123#R7 -> standard CAN-Id = 0x123, len = 7, RTR-frame
+ * 123#R8_9 -> standard CAN-Id = 0x123, len = 8, dlc = 9, RTR-frame
  * 7A1#r -> standard CAN-Id = 0x7A1, len = 0, RTR-frame
  *
  * 123#00 -> standard CAN-Id = 0x123, len = 1, data[0] = 0x00
  * 123#1122334455667788 -> standard CAN-Id = 0x123, len = 8
+ * 123#1122334455667788_E -> standard CAN-Id = 0x123, len = 8, dlc = 14
  * 123#11.22.33.44.55.66.77.88 -> standard CAN-Id = 0x123, len = 8
  * 123#11.2233.44556677.88 -> standard CAN-Id = 0x123, len = 8
  * 32345678#112233 -> error frame with CAN_ERR_FLAG (0x2000000) set
@@ -155,10 +158,11 @@ void sprint_canframe(char *buf , struct canfd_frame *cf, int sep, int maxdlen);
  * The CAN data[] is separated by '.' when sep != 0.
  *
  * The type of the CAN frame (CAN 2.0 / CAN FD) is specified by maxdlen:
- * maxdlen = 8 -> CAN2.0 frame
+ * maxdlen = 8 -> CAN2.0 frame (aka Classical CAN)
  * maxdlen = 64 -> CAN FD frame
  *
  * 12345678#112233 -> extended CAN-Id = 0x12345678, len = 3, data, sep = 0
+ * 123#1122334455667788_E -> standard CAN-Id = 0x123, len = 8, dlc = 14, data, sep = 0
  * 12345678#R -> extended CAN-Id = 0x12345678, RTR, len = 0
  * 12345678#R5 -> extended CAN-Id = 0x12345678, RTR, len = 5
  * 123#11.22.33.44.55.66.77.88 -> standard CAN-Id = 0x123, dlc = 8, sep = 1
@@ -178,6 +182,7 @@ void sprint_canframe(char *buf , struct canfd_frame *cf, int sep, int maxdlen);
 #define CANLIB_VIEW_SWAP	0x4
 #define CANLIB_VIEW_ERROR	0x8
 #define CANLIB_VIEW_INDENT_SFF	0x10
+#define CANLIB_VIEW_LEN8_DLC	0x20
 
 #define SWAP_DELIMITER '`'
 
@@ -187,14 +192,15 @@ void sprint_long_canframe(char *buf , struct canfd_frame *cf, int view, int maxd
  * Creates a CAN frame hexadecimal output in user readable format.
  *
  * The type of the CAN frame (CAN 2.0 / CAN FD) is specified by maxdlen:
- * maxdlen = 8 -> CAN2.0 frame
+ * maxdlen = 8 -> CAN2.0 frame (aka Classical CAN)
  * maxdlen = 64 -> CAN FD frame
  *
- * 12345678   [3]  11 22 33 -> extended CAN-Id = 0x12345678, dlc = 3, data
+ * 12345678   [3]  11 22 33 -> extended CAN-Id = 0x12345678, len = 3, data
  * 12345678   [0]  remote request -> extended CAN-Id = 0x12345678, RTR
  * 14B0DC51   [8]  4A 94 E8 2A EC 58 55 62   'J..*.XUb' -> (with ASCII output)
+ * 321   {B}  11 22 33 44 55 66 77 88 -> Classical CAN with raw '{DLC}' value B
  * 20001111   [7]  C6 23 7B 32 69 98 3C      ERRORFRAME -> (CAN_ERR_FLAG set)
- * 12345678  [03]  11 22 33 -> CAN FD with extended CAN-Id = 0x12345678, dlc = 3
+ * 12345678  [03]  11 22 33 -> CAN FD with extended CAN-Id = 0x12345678, len = 3
  *
  * 123   [3]  11 22 33         -> CANLIB_VIEW_INDENT_SFF == 0
  *      123   [3]  11 22 33    -> CANLIB_VIEW_INDENT_SFF == set
@@ -204,7 +210,7 @@ void sprint_long_canframe(char *buf , struct canfd_frame *cf, int view, int maxd
  * // CAN FD frame with eol to STDOUT
  * fprint_long_canframe(stdout, &frame, "\n", 0, CANFD_MAX_DLEN);
  *
- * // CAN 2.0 frame without eol to STDERR
+ * // Classical CAN 2.0 frame without eol to STDERR
  * fprint_long_canframe(stderr, &frame, NULL, 0, CAN_MAX_DLEN);
  *
  */

log2asc.c

@@ -116,6 +116,7 @@ void canfd_asc(struct canfd_frame *cf, int devno, int mtu, char *extra_info, FIL
 	char *dir = "Rx";
 	unsigned int flags = 0;
 	unsigned int dlen = cf->len;
+	unsigned int dlc = can_fd_len2dlc(dlen);
 
 	/* relevant flags in Flags field */
 #define ASC_F_RTR 0x00000010
@@ -137,7 +138,16 @@ void canfd_asc(struct canfd_frame *cf, int devno, int mtu, char *extra_info, FIL
 	fprintf(outfile, "%11s                                  ", id);
 	fprintf(outfile, "%c ", (cf->flags & CANFD_BRS)?'1':'0');
 	fprintf(outfile, "%c ", (cf->flags & CANFD_ESI)?'1':'0');
-	fprintf(outfile, "%x ", can_len2dlc(dlen));
+
+	/* check for extra DLC when having a Classic CAN with 8 bytes payload */
+	if ((mtu == CAN_MTU) && (dlen == CAN_MAX_DLEN)) {
+		struct can_frame *ccf = (struct can_frame *)cf;
+
+		if ((ccf->len8_dlc > CAN_MAX_DLEN) && (ccf->len8_dlc <= CAN_MAX_RAW_DLC))
+			dlc = ccf->len8_dlc;
+	}
+
+	fprintf(outfile, "%x ", dlc);
 
 	if (mtu == CAN_MTU) {
 		if (cf->can_id & CAN_RTR_FLAG) {

mcp251xfd/99-devcoredump.rules

@@ -0,0 +1 @@
+ACTION=="add", SUBSYSTEM=="devcoredump", RUN+="/usr/sbin/devcoredump"

mcp251xfd/devcoredump

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+set -e
+
+timestamp=$(date +%+4Y%m%d-%H%M%S)
+filename=/var/log/devcoredump-${timestamp}.dump
+
+cat /sys/${DEVPATH}/data > ${filename}
+echo 1 > /sys/${DEVPATH}/data
+
+echo "devcoredump ${DEVPATH}" | logger

mcp251xfd/mcp251xfd-dev-coredump.c

@@ -0,0 +1,257 @@
+// SPDX-License-Identifier: GPL-2.0
+//
+// Microchip MCP251xFD Family CAN controller debug tool
+//
+// Copyright (c) 2020, 2021 Pengutronix,
+//               Marc Kleine-Budde <kernel@pengutronix.de>
+//
+
+#include <endian.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <linux/kernel.h>
+
+#include "mcp251xfd.h"
+#include "mcp251xfd-dump-userspace.h"
+
+#define pr_err(fmt, args...)    fprintf(stderr, fmt, ##args)
+#define pr_no(fmt, args...)     while (0) { fprintf(stdout, fmt, ##args); }
+
+#ifdef DEBUG
+#define pr_debug(fmt, args...) pr_err(fmt, ##args)
+#else
+#define pr_debug(fmt, args...) pr_no(fmt, ##args)
+#endif
+
+
+struct mcp251xfd_dump_iter {
+	const void *start;
+	const struct mcp251xfd_dump_object_header *hdr;
+	const void *object_start;
+	const void *object_end;
+};
+
+static __attribute__((__unused__)) const char *
+get_object_type_str(enum mcp251xfd_dump_object_type object_type)
+{
+	switch (object_type) {
+	case MCP251XFD_DUMP_OBJECT_TYPE_REG:
+		return "reg";
+	case MCP251XFD_DUMP_OBJECT_TYPE_TEF:
+		return "tef";
+	case MCP251XFD_DUMP_OBJECT_TYPE_RX:
+		return "rx";
+	case MCP251XFD_DUMP_OBJECT_TYPE_TX:
+		return "tx";
+	case MCP251XFD_DUMP_OBJECT_TYPE_END:
+		return "end";
+	default:
+		return "<unknown>";
+	}
+}
+
+static __attribute__((__unused__)) const char *
+get_ring_key_str(enum mcp251xfd_dump_object_ring_key key)
+{
+	switch (key) {
+	case MCP251XFD_DUMP_OBJECT_RING_KEY_HEAD:
+		return "head";
+	case MCP251XFD_DUMP_OBJECT_RING_KEY_TAIL:
+		return "tail";
+	case MCP251XFD_DUMP_OBJECT_RING_KEY_BASE:
+		return "base";
+	case MCP251XFD_DUMP_OBJECT_RING_KEY_NR:
+		return "nr";
+	case MCP251XFD_DUMP_OBJECT_RING_KEY_FIFO_NR:
+		return "fifo-nr";
+	case MCP251XFD_DUMP_OBJECT_RING_KEY_OBJ_NUM:
+		return "obj-num";
+	case MCP251XFD_DUMP_OBJECT_RING_KEY_OBJ_SIZE:
+		return "obj-size";
+	default:
+		return "<unknown>";
+	}
+}
+
+static int
+do_dev_coredump_read_reg(const struct mcp251xfd_priv *priv,
+			 const struct mcp251xfd_dump_iter *iter,
+			 struct mcp251xfd_mem *mem)
+{
+	const struct mcp251xfd_dump_object_reg *object;
+
+	for (object = iter->object_start;
+	     (void *)(object + 1) <= iter->object_end;
+	     object++) {
+		uint32_t reg, val;
+
+		reg = le32toh(object->reg);
+		val = le32toh(object->val);
+
+		pr_debug("%s: object=0x%04zx reg=0x%04x - val=0x%08x\n",
+			 __func__,
+			 (void *)object - iter->start,
+			 reg, val);
+
+		if (reg > ARRAY_SIZE(mem->buf))
+			return -EINVAL;
+
+		*(uint32_t *)(mem->buf + reg) = val;
+	}
+
+	return 0;
+}
+
+static int
+do_dev_coredump_read_ring(const struct mcp251xfd_priv *priv,
+			  const struct mcp251xfd_dump_iter *iter,
+			  struct mcp251xfd_ring *ring)
+{
+	const struct mcp251xfd_dump_object_reg *object;
+
+	for (object = iter->object_start;
+	     (void *)(object + 1) <= iter->object_end;
+	     object++) {
+		enum mcp251xfd_dump_object_ring_key key;
+		uint32_t val;
+
+		key = le32toh(object->reg);
+		val = le32toh(object->val);
+
+		pr_debug("%s: reg=0x%04zx key=0x%02x: %8s - val=0x%08x\n",
+			 __func__,
+			 (void *)object - iter->start,
+			 key, get_ring_key_str(key), val);
+
+		switch (key) {
+		case MCP251XFD_DUMP_OBJECT_RING_KEY_HEAD:
+			ring->head = val;
+			break;
+		case MCP251XFD_DUMP_OBJECT_RING_KEY_TAIL:
+			ring->tail = val;
+			break;
+		case MCP251XFD_DUMP_OBJECT_RING_KEY_BASE:
+			ring->base = val;
+			break;
+		case MCP251XFD_DUMP_OBJECT_RING_KEY_NR:
+			ring->nr = val;
+			break;
+		case MCP251XFD_DUMP_OBJECT_RING_KEY_FIFO_NR:
+			ring->fifo_nr = val;
+			break;
+		case MCP251XFD_DUMP_OBJECT_RING_KEY_OBJ_NUM:
+			ring->obj_num = val;
+			break;
+		case MCP251XFD_DUMP_OBJECT_RING_KEY_OBJ_SIZE:
+			ring->obj_size = val;
+			break;
+		default:
+			return -EINVAL;
+		}
+	}
+
+	return 0;
+}
+
+static int
+do_dev_coredump_read(struct mcp251xfd_priv *priv,
+		     struct mcp251xfd_mem *mem,
+		     const void *dump, size_t dump_len)
+{
+	struct mcp251xfd_dump_iter iter[] = {
+		{
+			.start = dump,
+			.hdr = dump,
+		},
+	};
+
+	while ((void *)(iter->hdr + 1) <= iter->start + dump_len &&
+	       le32toh(iter->hdr->magic) == MCP251XFD_DUMP_MAGIC) {
+		const struct mcp251xfd_dump_object_header *hdr = iter->hdr;
+		enum mcp251xfd_dump_object_type object_type;
+		size_t object_offset, object_len;
+		int err;
+
+		object_type = le32toh(hdr->type);
+		object_offset = le32toh(hdr->offset);
+		object_len = le32toh(hdr->len);
+
+		if (object_offset + object_len > dump_len)
+			return -EFAULT;
+
+		iter->object_start = iter->start + object_offset;
+		iter->object_end = iter->object_start + object_len;
+
+		pr_debug("%s: hdr=0x%04zx type=0x%08x: %8s - offset=0x%04zx len=0x%04zx end=0x%04zx\n",
+			 __func__,
+			 (void *)iter->hdr - iter->start,
+			 object_type, get_object_type_str(object_type),
+			 object_offset, object_len, object_offset + object_len);
+
+		switch (object_type) {
+		case MCP251XFD_DUMP_OBJECT_TYPE_REG:
+			err = do_dev_coredump_read_reg(priv, iter, mem);
+			break;
+		case MCP251XFD_DUMP_OBJECT_TYPE_TEF:
+			err = do_dev_coredump_read_ring(priv, iter, priv->tef);
+			break;
+		case MCP251XFD_DUMP_OBJECT_TYPE_RX:
+			err = do_dev_coredump_read_ring(priv, iter, priv->rx);
+			break;
+		case MCP251XFD_DUMP_OBJECT_TYPE_TX:
+			err = do_dev_coredump_read_ring(priv, iter, priv->tx);
+			break;
+		case MCP251XFD_DUMP_OBJECT_TYPE_END:
+			return 0;
+		default:
+			return -EINVAL;
+		}
+
+		if (err)
+			return err;
+
+		iter->hdr++;
+	}
+
+	return -EINVAL;
+}
+
+int mcp251xfd_dev_coredump_read(struct mcp251xfd_priv *priv,
+				struct mcp251xfd_mem *mem,
+				const char *dump_path)
+{
+	struct stat statbuf;
+	size_t dump_len;
+	void *dump;
+	int fd, err;
+
+	fd = open(dump_path, O_RDONLY);
+	if (fd < 0)
+		return -errno;
+
+	err = fstat(fd, &statbuf);
+	if (err < 0) {
+		err = -errno;
+		goto out_close;
+	}
+	dump_len = statbuf.st_size;
+
+	dump = mmap(NULL, dump_len, PROT_READ, MAP_SHARED, fd, 0x0);
+	if (dump == MAP_FAILED) {
+		err = -errno;
+		goto out_close;
+	}
+
+	err = do_dev_coredump_read(priv, mem, dump, dump_len);
+
+	munmap(dump, dump_len);
+ out_close:
+	close(fd);
+	return err;
+}

mcp251xfd/mcp251xfd-dump-userspace.h

@@ -0,0 +1,61 @@
+/* SPDX-License-Identifier: GPL-2.0
+ *
+ * Microchip MCP251xFD Family CAN controller debug tool
+ *
+ * Copyright (c) 2019, 2020 Pengutronix,
+ *               Marc Kleine-Budde <kernel@pengutronix.de>
+ */
+
+#ifndef _MCP251XFD_DUMP_USERSPACE_H
+#define _MCP251XFD_DUMP_USERSPACE_H
+
+#include "mcp251xfd.h"
+#include "mcp251xfd-dump.h"
+
+#define MCP251XFD_TX_FIFO 1
+#define MCP251XFD_RX_FIFO(x) (MCP251XFD_TX_FIFO + 1 + (x))
+
+struct mcp251xfd_mem {
+	char buf[0x1000];
+};
+
+struct mcp251xfd_ring {
+	unsigned int head;
+	unsigned int tail;
+
+	u16 base;
+	u8 nr;
+	u8 fifo_nr;
+	u8 obj_num;
+	u8 obj_size;
+};
+
+struct mcp251xfd_priv {
+	struct regmap *map;
+
+	struct mcp251xfd_ring tef[1];
+	struct mcp251xfd_ring tx[1];
+	struct mcp251xfd_ring rx[1];
+
+	u8 rx_ring_num;
+};
+
+static inline u8 mcp251xfd_get_ring_head(const struct mcp251xfd_ring *ring)
+{
+	return ring->head & (ring->obj_num - 1);
+}
+
+static inline u8 mcp251xfd_get_ring_tail(const struct mcp251xfd_ring *ring)
+{
+	return ring->tail & (ring->obj_num - 1);
+}
+
+void mcp251xfd_dump(struct mcp251xfd_priv *priv);
+int mcp251xfd_dev_coredump_read(struct mcp251xfd_priv *priv,
+				struct mcp251xfd_mem *mem,
+				const char *file_path);
+int mcp251xfd_regmap_read(struct mcp251xfd_priv *priv,
+			  struct mcp251xfd_mem *mem,
+			  const char *file_path);
+
+#endif

mcp251xfd/mcp251xfd-dump.c

@@ -0,0 +1,863 @@
+// SPDX-License-Identifier: GPL-2.0
+//
+// Microchip MCP251xFD Family CAN controller debug tool
+//
+// Copyright (c) 2019, 2020, 2021 Pengutronix,
+//               Marc Kleine-Budde <kernel@pengutronix.de>
+//
+
+#include <linux/kernel.h>
+
+#include "mcp251xfd-dump-userspace.h"
+
+struct mcp251xfd_dump_regs_fifo {
+	u32 con;
+	u32 sta;
+	u32 ua;
+};
+
+struct mcp251xfd_dump_regs_filter {
+	u32 obj;
+	u32 mask;
+};
+
+struct mcp251xfd_dump_regs {
+	u32 con;
+	u32 nbtcfg;
+	u32 dbtcfg;
+	u32 tdc;
+	u32 tbc;
+	u32 tscon;
+	u32 vec;
+	u32 intf;
+	u32 rxif;
+	u32 txif;
+	u32 rxovif;
+	u32 txatif;
+	u32 txreq;
+	u32 trec;
+	u32 bdiag0;
+	u32 bdiag1;
+	union {
+		struct {
+			u32 tefcon;
+			u32 tefsta;
+			u32 tefua;
+		};
+		struct mcp251xfd_dump_regs_fifo tef;
+	};
+	u32 reserved0;
+	union {
+		struct {
+			struct mcp251xfd_dump_regs_fifo txq;
+			struct mcp251xfd_dump_regs_fifo tx_fifo;
+			struct mcp251xfd_dump_regs_fifo rx_fifo;
+		};
+		struct mcp251xfd_dump_regs_fifo fifo[32];
+	};
+	u32 fltcon[8];
+	struct mcp251xfd_dump_regs_filter filter[32];
+};
+
+struct mcp251xfd_dump_ram {
+	u8 ram[MCP251XFD_RAM_SIZE];
+};
+
+struct mcp251xfd_dump_regs_mcp251xfd {
+	u32 osc;
+	u32 iocon;
+	u32 crc;
+	u32 ecccon;
+	u32 eccstat;
+	u32 devid;
+};
+
+#define __dump_bit(val, prefix, bit, desc)	       \
+	pr_info("%16s   %s\t\t%s\n", __stringify(bit), \
+		(val) & prefix##_##bit ? "x" : " ", desc)
+
+#define __dump_mask(val, prefix, mask, fmt, desc) \
+	pr_info("%16s = " fmt "\t\t%s\n", \
+		__stringify(mask), \
+		FIELD_GET(prefix##_##mask##_MASK, (val)), \
+		desc)
+
+static void mcp251xfd_dump_reg_con(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("CON: con(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_mask(val, MCP251XFD_REG_CON, TXBWS, "0x%02lx", "Transmit Bandwidth Sharing");
+	__dump_bit(val, MCP251XFD_REG_CON, ABAT, "Abort All Pending Transmissions");
+	__dump_mask(val, MCP251XFD_REG_CON, REQOP, "0x%02lx", "Request Operation Mode");
+	__dump_mask(val, MCP251XFD_REG_CON, OPMOD, "0x%02lx", "Operation Mode Status");
+	__dump_bit(val, MCP251XFD_REG_CON, TXQEN, "Enable Transmit Queue");
+	__dump_bit(val, MCP251XFD_REG_CON, STEF, "Store in Transmit Event FIFO");
+	__dump_bit(val, MCP251XFD_REG_CON, SERR2LOM, "Transition to Listen Only Mode on System Error");
+	__dump_bit(val, MCP251XFD_REG_CON, ESIGM, "Transmit ESI in Gateway Mode");
+	__dump_bit(val, MCP251XFD_REG_CON, RTXAT, "Restrict Retransmission Attempts");
+	__dump_bit(val, MCP251XFD_REG_CON, BRSDIS, "Bit Rate Switching Disable");
+	__dump_bit(val, MCP251XFD_REG_CON, BUSY, "CAN Module is Busy");
+	__dump_mask(val, MCP251XFD_REG_CON, WFT, "0x%02lx", "Selectable Wake-up Filter Time");
+	__dump_bit(val, MCP251XFD_REG_CON, WAKFIL, "Enable CAN Bus Line Wake-up Filter");
+	__dump_bit(val, MCP251XFD_REG_CON, PXEDIS, "Protocol Exception Event Detection Disabled");
+	__dump_bit(val, MCP251XFD_REG_CON, ISOCRCEN, "Enable ISO CRC in CAN FD Frames");
+	__dump_mask(val, MCP251XFD_REG_CON, DNCNT, "0x%02lx", "Device Net Filter Bit Number");
+}
+
+static void mcp251xfd_dump_reg_nbtcfg(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("NBTCFG: nbtcfg(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_mask(val, MCP251XFD_REG_NBTCFG, BRP, "%3lu", "Baud Rate Prescaler");
+	__dump_mask(val, MCP251XFD_REG_NBTCFG, TSEG1, "%3lu", "Time Segment 1 (Propagation Segment + Phase Segment 1)");
+	__dump_mask(val, MCP251XFD_REG_NBTCFG, TSEG2, "%3lu", "Time Segment 2 (Phase Segment 2)");
+	__dump_mask(val, MCP251XFD_REG_NBTCFG, SJW, "%3lu", "Synchronization Jump Width");
+}
+
+static void mcp251xfd_dump_reg_dbtcfg(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("DBTCFG: dbtcfg(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_mask(val, MCP251XFD_REG_DBTCFG, BRP, "%3lu", "Baud Rate Prescaler");
+	__dump_mask(val, MCP251XFD_REG_DBTCFG, TSEG1, "%3lu", "Time Segment 1 (Propagation Segment + Phase Segment 1)");
+	__dump_mask(val, MCP251XFD_REG_DBTCFG, TSEG2, "%3lu", "Time Segment 2 (Phase Segment 2)");
+	__dump_mask(val, MCP251XFD_REG_DBTCFG, SJW, "%3lu", "Synchronization Jump Width");
+}
+
+static void mcp251xfd_dump_reg_tdc(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("TDC: tdc(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_bit(val, MCP251XFD_REG_TDC, EDGFLTEN, "Enable Edge Filtering during Bus Integration state");
+	__dump_bit(val, MCP251XFD_REG_TDC, SID11EN, "Enable 12-Bit SID in CAN FD Base Format Messages");
+	__dump_mask(val, MCP251XFD_REG_TDC, TDCMOD, "0x%02lx", "Transmitter Delay Compensation Mode");
+	__dump_mask(val, MCP251XFD_REG_TDC, TDCO, "0x%02lx", "Transmitter Delay Compensation Offset");
+	__dump_mask(val, MCP251XFD_REG_TDC, TDCV, "0x%02lx", "Transmitter Delay Compensation Value");
+}
+
+static void mcp251xfd_dump_reg_tbc(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("TBC: tbc(0x%03x)=0x%08x\n", addr, val);
+}
+
+static void mcp251xfd_dump_reg_vec(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	u8 rx_code, tx_code, i_code;
+
+	pr_info("VEC: vec(0x%03x)=0x%08x\n", addr, val);
+
+	rx_code = FIELD_GET(MCP251XFD_REG_VEC_RXCODE_MASK, val);
+	tx_code = FIELD_GET(MCP251XFD_REG_VEC_TXCODE_MASK, val);
+	i_code = FIELD_GET(MCP251XFD_REG_VEC_ICODE_MASK, val);
+
+	pr_info("\trxcode: ");
+	if (rx_code == 0x40)
+		pr_cont("No Interrupt");
+	else if (rx_code < 0x20)
+		pr_cont("FIFO %u", rx_code);
+	else
+		pr_cont("Reserved");
+	pr_cont(" (0x%02x)\n", rx_code);
+
+	pr_info("\ttxcode: ");
+	if (tx_code == 0x40)
+		pr_cont("No Interrupt");
+	else if (tx_code < 0x20)
+		pr_cont("FIFO %u", tx_code);
+	else
+		pr_cont("Reserved");
+	pr_cont(" (0x%02x)\n", tx_code);
+
+	pr_info("\ticode: ");
+	if (i_code == 0x4a)
+		pr_cont("Transmit Attempt Interrupt");
+	else if (i_code == 0x49)
+		pr_cont("Transmit Event FIFO Interrupt");
+	else if (i_code == 0x48)
+		pr_cont("Invalid Message Occurred");
+	else if (i_code == 0x47)
+		pr_cont("Operation Mode Changed");
+	else if (i_code == 0x46)
+		pr_cont("TBC Overflow");
+	else if (i_code == 0x45)
+		pr_cont("RX/TX MAB Overflow/Underflow");
+	else if (i_code == 0x44)
+		pr_cont("Address Error Interrupt");
+	else if (i_code == 0x43)
+		pr_cont("Receive FIFO Overflow Interrupt");
+	else if (i_code == 0x42)
+		pr_cont("Wake-up Interrupt");
+	else if (i_code == 0x41)
+		pr_cont("Error Interrupt");
+	else if (i_code == 0x40)
+		pr_cont("No Interrupt");
+	else if (i_code < 0x20)
+		pr_cont("FIFO %u", i_code);
+	else
+		pr_cont("Reserved");
+	pr_cont(" (0x%02x)\n", i_code);
+}
+
+#define __dump_int(val, bit, desc) \
+	pr_info("\t" __stringify(bit) "\t%s\t%s\t%s\t%s\n", \
+		 (val) & MCP251XFD_REG_INT_##bit##E ? "x" : "", \
+		 (val) & MCP251XFD_REG_INT_##bit##F ? "x" : "", \
+		 FIELD_GET(MCP251XFD_REG_INT_IF_MASK, val) & \
+		 FIELD_GET(MCP251XFD_REG_INT_IE_MASK, val) & \
+		 MCP251XFD_REG_INT_##bit##F ? "x" : "", \
+		 desc)
+
+static void mcp251xfd_dump_reg_intf(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("INT: intf(0x%03x)=0x%08x\n", addr, val);
+
+	pr_info("\t\tIE\tIF\tIE & IF\n");
+	__dump_int(val, IVMI, "Invalid Message Interrupt");
+	__dump_int(val, WAKI, "Bus Wake Up Interrupt");
+	__dump_int(val, CERRI, "CAN Bus Error Interrupt");
+	__dump_int(val, SERRI, "System Error Interrupt");
+	__dump_int(val, RXOVI, "Receive FIFO Overflow Interrupt");
+	__dump_int(val, TXATI, "Transmit Attempt Interrupt");
+	__dump_int(val, SPICRCI, "SPI CRC Error Interrupt");
+	__dump_int(val, ECCI, "ECC Error Interrupt");
+	__dump_int(val, TEFI, "Transmit Event FIFO Interrupt");
+	__dump_int(val, MODI, "Mode Change Interrupt");
+	__dump_int(val, TBCI, "Time Base Counter Interrupt");
+	__dump_int(val, RXI, "Receive FIFO Interrupt");
+	__dump_int(val, TXI, "Transmit FIFO Interrupt");
+}
+
+#undef __dump_int
+
+#define __create_dump_fifo_bitmask(fifo, name, description) \
+static void mcp251xfd_dump_reg_##fifo(const struct mcp251xfd_priv *priv, u32 val, u16 addr) \
+{ \
+	int i; \
+\
+	pr_info(__stringify(name) ": " __stringify(fifo) "(0x%03x)=0x%08x\n", addr, val); \
+	pr_info(description ":\n"); \
+	if (!val) { \
+		pr_info("\t\t-none-\n"); \
+		return; \
+	} \
+\
+	pr_info("\t\t"); \
+	for (i = 0; i < sizeof(val); i++) { \
+		if (val & BIT(i)) \
+			pr_cont("%d ", i); \
+	} \
+\
+	pr_cont("\n"); \
+}
+
+__create_dump_fifo_bitmask(rxif, RXIF, "Receive FIFO Interrupt Pending");
+__create_dump_fifo_bitmask(rxovif, RXOVIF, "Receive FIFO Overflow Interrupt Pending");
+__create_dump_fifo_bitmask(txif, TXIF, "Transmit FIFO Interrupt Pending");
+__create_dump_fifo_bitmask(txatif, TXATIF, "Transmit FIFO Attempt Interrupt Pending");
+__create_dump_fifo_bitmask(txreq, TXREQ, "Message Send Request");
+
+#undef __create_dump_fifo_bitmask
+
+static void mcp251xfd_dump_reg_trec(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("TREC: trec(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_bit(val, MCP251XFD_REG_TREC, TXBO, "Transmitter in Bus Off State");
+	__dump_bit(val, MCP251XFD_REG_TREC, TXBP, "Transmitter in Error Passive State");
+	__dump_bit(val, MCP251XFD_REG_TREC, RXBP, "Receiver in Error Passive State");
+	__dump_bit(val, MCP251XFD_REG_TREC, TXWARN, "Transmitter in Error Warning State");
+	__dump_bit(val, MCP251XFD_REG_TREC, RXWARN, "Receiver in Error Warning State");
+	__dump_bit(val, MCP251XFD_REG_TREC, EWARN, "Transmitter or Receiver is in Error Warning State");
+
+	__dump_mask(val, MCP251XFD_REG_TREC, TEC, "%3lu", "Transmit Error Counter");
+	__dump_mask(val, MCP251XFD_REG_TREC, REC, "%3lu", "Receive Error Counter");
+}
+
+static void mcp251xfd_dump_reg_bdiag0(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("BDIAG0: bdiag0(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_mask(val, MCP251XFD_REG_BDIAG0, DTERRCNT, "%3lu", "Data Bit Rate Transmit Error Counter");
+	__dump_mask(val, MCP251XFD_REG_BDIAG0, DRERRCNT, "%3lu", "Data Bit Rate Receive Error Counter");
+	__dump_mask(val, MCP251XFD_REG_BDIAG0, NTERRCNT, "%3lu", "Nominal Bit Rate Transmit Error Counter");
+	__dump_mask(val, MCP251XFD_REG_BDIAG0, NRERRCNT, "%3lu", "Nominal Bit Rate Receive Error Counter");
+}
+
+static void mcp251xfd_dump_reg_bdiag1(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("BDIAG1: bdiag1(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, DLCMM, "DLC Mismatch");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, ESI, "ESI flag of a received CAN FD message was set");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, DCRCERR, "Data CRC Error");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, DSTUFERR, "Data Bit Stuffing Error");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, DFORMERR, "Data Format Error");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, DBIT1ERR, "Data BIT1 Error");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, DBIT0ERR, "Data BIT0 Error");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, TXBOERR, "Device went to bus-off (and auto-recovered)");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, NCRCERR, "CRC Error");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, NSTUFERR, "Bit Stuffing Error");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, NFORMERR, "Format Error");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, NACKERR, "Transmitted message was not acknowledged");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, NBIT1ERR, "Bit1 Error");
+	__dump_bit(val, MCP251XFD_REG_BDIAG1, NBIT0ERR, "Bit0 Error");
+	__dump_mask(val, MCP251XFD_REG_BDIAG1, EFMSGCNT, "%3lu", "Error Free Message Counter");
+}
+
+static void mcp251xfd_dump_reg_osc(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("OSC: osc(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_bit(val, MCP251XFD_REG_OSC, SCLKRDY, "Synchronized SCLKDIV");
+	__dump_bit(val, MCP251XFD_REG_OSC, OSCRDY, "Clock Ready");
+	__dump_bit(val, MCP251XFD_REG_OSC, PLLRDY, "PLL Ready");
+	__dump_mask(val, MCP251XFD_REG_OSC, CLKODIV, "0x%02lu", "Clock Output Divisor");
+	__dump_bit(val, MCP251XFD_REG_OSC, SCLKDIV, "System Clock Divisor");
+	__dump_bit(val, MCP251XFD_REG_OSC, LPMEN, "Low Power Mode (LPM) Enable (MCP2518FD only)");
+	__dump_bit(val, MCP251XFD_REG_OSC, OSCDIS, "Clock (Oscillator) Disable");
+	__dump_bit(val, MCP251XFD_REG_OSC, PLLEN, "PLL Enable");
+}
+
+static void mcp251xfd_dump_reg_tefcon(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("TEFCON: tefcon(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_mask(val, MCP251XFD_REG_TEFCON, FSIZE, "%3lu", "FIFO Size");
+	__dump_bit(val, MCP251XFD_REG_TEFCON, FRESET, "FIFO Reset");
+	__dump_bit(val, MCP251XFD_REG_TEFCON, UINC, "Increment Tail");
+	__dump_bit(val, MCP251XFD_REG_TEFCON, TEFTSEN, "Transmit Event FIFO Time Stamp Enable");
+	__dump_bit(val, MCP251XFD_REG_TEFCON, TEFOVIE, "Transmit Event FIFO Overflow Interrupt Enable");
+	__dump_bit(val, MCP251XFD_REG_TEFCON, TEFFIE, "Transmit Event FIFO Full Interrupt Enable");
+	__dump_bit(val, MCP251XFD_REG_TEFCON, TEFHIE, "Transmit Event FIFO Half Full Interrupt Enable");
+	__dump_bit(val, MCP251XFD_REG_TEFCON, TEFNEIE, "Transmit Event FIFO Not Empty Interrupt Enable");
+}
+
+static void mcp251xfd_dump_reg_tefsta(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("TEFSTA: tefsta(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_bit(val, MCP251XFD_REG_TEFSTA, TEFOVIF, "Transmit Event FIFO Overflow Interrupt Flag");
+	__dump_bit(val, MCP251XFD_REG_TEFSTA, TEFFIF, "Transmit Event FIFO Full Interrupt Flag (0: not full)");
+	__dump_bit(val, MCP251XFD_REG_TEFSTA, TEFHIF, "Transmit Event FIFO Half Full Interrupt Flag (0: < half full)");
+	__dump_bit(val, MCP251XFD_REG_TEFSTA, TEFNEIF, "Transmit Event FIFO Not Empty Interrupt Flag (0: empty)");
+}
+
+static void mcp251xfd_dump_reg_tefua(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("TEFUA: tefua(0x%03x)=0x%08x\n", addr, val);
+}
+
+static void mcp251xfd_dump_reg_fifocon(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("FIFOCON: fifocon(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_mask(val, MCP251XFD_REG_FIFOCON, PLSIZE, "%3lu", "Payload Size");
+	__dump_mask(val, MCP251XFD_REG_FIFOCON, FSIZE, "%3lu", "FIFO Size");
+	__dump_mask(val, MCP251XFD_REG_FIFOCON, TXAT, "%3lu", "Retransmission Attempts");
+	__dump_mask(val, MCP251XFD_REG_FIFOCON, TXPRI, "%3lu", "Message Transmit Priority");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, FRESET, "FIFO Reset");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, TXREQ, "Message Send Request");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, UINC, "Increment Head/Tail");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, TXEN, "TX/RX FIFO Selection (0: RX, 1: TX)");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, RTREN, "Auto RTR Enable");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, RXTSEN, "Received Message Time Stamp Enable");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, TXATIE, "Transmit Attempts Exhausted Interrupt Enable");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, RXOVIE, "Overflow Interrupt Enable");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, TFERFFIE, "Transmit/Receive FIFO Empty/Full Interrupt Enable");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, TFHRFHIE, "Transmit/Receive FIFO Half Empty/Half Full Interrupt Enable");
+	__dump_bit(val, MCP251XFD_REG_FIFOCON, TFNRFNIE, "Transmit/Receive FIFO Not Full/Not Empty Interrupt Enable");
+}
+
+static void mcp251xfd_dump_reg_fifosta(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("FIFOSTA: fifosta(0x%03x)=0x%08x\n", addr, val);
+
+	__dump_mask(val, MCP251XFD_REG_FIFOSTA, FIFOCI, "%3lu", "FIFO Message Index");
+	__dump_bit(val, MCP251XFD_REG_FIFOSTA, TXABT, "Message Aborted Status (0: completed successfully, 1: aborted)");
+	__dump_bit(val, MCP251XFD_REG_FIFOSTA, TXLARB, "Message Lost Arbitration Status");
+	__dump_bit(val, MCP251XFD_REG_FIFOSTA, TXERR, "Error Detected During Transmission");
+	__dump_bit(val, MCP251XFD_REG_FIFOSTA, TXATIF, "Transmit Attempts Exhausted Interrupt Pending");
+	__dump_bit(val, MCP251XFD_REG_FIFOSTA, RXOVIF, "Receive FIFO Overflow Interrupt Flag");
+	__dump_bit(val, MCP251XFD_REG_FIFOSTA, TFERFFIF, "Transmit/Receive FIFO Empty/Full Interrupt Flag");
+	__dump_bit(val, MCP251XFD_REG_FIFOSTA, TFHRFHIF, "Transmit/Receive FIFO Half Empty/Half Full Interrupt Flag");
+	__dump_bit(val, MCP251XFD_REG_FIFOSTA, TFNRFNIF, "Transmit/Receive FIFO Not Full/Not Empty Interrupt Flag");
+}
+
+static void mcp251xfd_dump_reg_fifoua(const struct mcp251xfd_priv *priv, u32 val, u16 addr)
+{
+	pr_info("FIFOUA: fifoua(0x%03x)=0x%08x\n", addr, val);
+}
+
+#define __dump_call(regs, val) \
+do { \
+	mcp251xfd_dump_reg_##val(priv, (regs)->val, \
+				 (u16)(offsetof(typeof(*(regs)), val) + \
+				       (sizeof(*(regs)) == sizeof(struct mcp251xfd_dump_regs) ? \
+					0 : MCP251XFD_REG_OSC))); \
+	pr_info("\n"); \
+} while (0)
+
+#define __dump_call_fifo(reg, val) \
+do { \
+	mcp251xfd_dump_reg_##reg(priv, regs->val, (u16)offsetof(typeof(*regs), val)); \
+	pr_info("\n"); \
+} while (0)
+
+static void
+mcp251xfd_dump_regs(const struct mcp251xfd_priv *priv,
+		    const struct mcp251xfd_dump_regs *regs,
+		    const struct mcp251xfd_dump_regs_mcp251xfd *regs_mcp251xfd)
+{
+	netdev_info(priv->ndev, "-------------------- register dump --------------------\n");
+	__dump_call(regs, con);
+	__dump_call(regs, nbtcfg);
+	__dump_call(regs, dbtcfg);
+	__dump_call(regs, tdc);
+	__dump_call(regs, tbc);
+	__dump_call(regs, vec);
+	__dump_call(regs, intf);
+	__dump_call(regs, rxif);
+	__dump_call(regs, rxovif);
+	__dump_call(regs, txif);
+	__dump_call(regs, txatif);
+	__dump_call(regs, txreq);
+	__dump_call(regs, trec);
+	__dump_call(regs, bdiag0);
+	__dump_call(regs, bdiag1);
+	__dump_call(regs_mcp251xfd, osc);
+	pr_info("-------------------- TEF --------------------\n");
+	__dump_call(regs, tefcon);
+	__dump_call(regs, tefsta);
+	__dump_call(regs, tefua);
+	pr_info("-------------------- TX_FIFO --------------------\n");
+	__dump_call_fifo(fifocon, fifo[MCP251XFD_TX_FIFO].con);
+	__dump_call_fifo(fifosta, fifo[MCP251XFD_TX_FIFO].sta);
+	__dump_call_fifo(fifoua, fifo[MCP251XFD_TX_FIFO].ua);
+	pr_info(" -------------------- RX_FIFO --------------------\n");
+	__dump_call_fifo(fifocon, fifo[MCP251XFD_RX_FIFO(0)].con);
+	__dump_call_fifo(fifosta, fifo[MCP251XFD_RX_FIFO(0)].sta);
+	__dump_call_fifo(fifoua, fifo[MCP251XFD_RX_FIFO(0)].ua);
+	netdev_info(priv->ndev, "------------------------- end -------------------------\n");
+}
+
+#undef __dump_call
+#undef __dump_call_fifo
+
+static u8 mcp251xfd_dump_get_fifo_size(const struct mcp251xfd_priv *priv, const struct mcp251xfd_dump_regs *regs, u32 fifo_con)
+{
+	u8 obj_size;
+
+	obj_size = FIELD_GET(MCP251XFD_REG_FIFOCON_PLSIZE_MASK, fifo_con);
+	switch (obj_size) {
+	case MCP251XFD_REG_FIFOCON_PLSIZE_8:
+		return 8;
+	case MCP251XFD_REG_FIFOCON_PLSIZE_12:
+		return 12;
+	case MCP251XFD_REG_FIFOCON_PLSIZE_16:
+		return 16;
+	case MCP251XFD_REG_FIFOCON_PLSIZE_20:
+		return 20;
+	case MCP251XFD_REG_FIFOCON_PLSIZE_24:
+		return 24;
+	case MCP251XFD_REG_FIFOCON_PLSIZE_32:
+		return 32;
+	case MCP251XFD_REG_FIFOCON_PLSIZE_48:
+		return 48;
+	case MCP251XFD_REG_FIFOCON_PLSIZE_64:
+		return 64;
+	}
+
+	return 0;
+}
+
+static u8 mcp251xfd_dump_get_fifo_obj_num(const struct mcp251xfd_priv *priv, const struct mcp251xfd_dump_regs *regs, u32 fifo_con)
+{
+	u8 obj_num;
+
+	obj_num = FIELD_GET(MCP251XFD_REG_FIFOCON_FSIZE_MASK, fifo_con);
+
+	return obj_num + 1;
+}
+
+static void mcp251xfd_dump_ram_fifo_obj_data(const struct mcp251xfd_priv *priv, const u8 *data, u8 dlc)
+{
+	int i;
+	u8 len;
+
+	len = can_dlc2len(get_canfd_dlc(dlc));
+
+	if (!len) {
+		pr_info("%16s = -none-\n", "data");
+		return;
+	}
+
+	for (i = 0; i < len; i++) {
+		if ((i % 8) == 0) {
+			if (i == 0)
+				pr_info("%16s = %02x", "data", data[i]);
+			else
+				pr_info("                   %02x", data[i]);
+		} else if ((i % 4) == 0) {
+			pr_cont("  %02x", data[i]);
+		} else if ((i % 8) == 7) {
+			pr_cont(" %02x\n", data[i]);
+		} else {
+			pr_cont(" %02x", data[i]);
+		}
+	}
+
+	if (i % 8)
+		pr_cont("\n");
+}
+
+/* TEF */
+
+static u8
+mcp251xfd_dump_get_tef_obj_num(const struct mcp251xfd_priv *priv,
+			       const struct mcp251xfd_dump_regs *regs)
+{
+	return mcp251xfd_dump_get_fifo_obj_num(priv, regs, regs->tef.con);
+}
+
+static u8
+mcp251xfd_dump_get_tef_tail(const struct mcp251xfd_priv *priv,
+			    const struct mcp251xfd_dump_regs *regs)
+{
+	return regs->tefua / sizeof(struct mcp251xfd_hw_tef_obj);
+}
+
+static u16
+mcp251xfd_dump_get_tef_obj_rel_addr(const struct mcp251xfd_priv *priv,
+				    u8 n)
+{
+	return sizeof(struct mcp251xfd_hw_tef_obj) * n;
+}
+
+static u16
+mcp251xfd_dump_get_tef_obj_addr(const struct mcp251xfd_priv *priv,
+				u8 n)
+{
+	return mcp251xfd_dump_get_tef_obj_rel_addr(priv, n) +
+		MCP251XFD_RAM_START;
+}
+
+/* TX */
+
+static u8
+mcp251xfd_dump_get_tx_obj_size(const struct mcp251xfd_priv *priv,
+			       const struct mcp251xfd_dump_regs *regs)
+{
+	return sizeof(struct mcp251xfd_hw_tx_obj_can) -
+		sizeof_field(struct mcp251xfd_hw_tx_obj_can, data) +
+		mcp251xfd_dump_get_fifo_size(priv, regs, regs->tx_fifo.con);
+}
+
+static u8
+mcp251xfd_dump_get_tx_obj_num(const struct mcp251xfd_priv *priv,
+			      const struct mcp251xfd_dump_regs *regs)
+{
+	return mcp251xfd_dump_get_fifo_obj_num(priv, regs, regs->tx_fifo.con);
+}
+
+static u16
+mcp251xfd_dump_get_tx_obj_rel_addr(const struct mcp251xfd_priv *priv,
+				   const struct mcp251xfd_dump_regs *regs,
+				   u8 n)
+{
+	return mcp251xfd_dump_get_tef_obj_rel_addr(priv, mcp251xfd_dump_get_tef_obj_num(priv, regs)) +
+		mcp251xfd_dump_get_tx_obj_size(priv, regs) * n;
+}
+
+static u16
+mcp251xfd_dump_get_tx_obj_addr(const struct mcp251xfd_priv *priv,
+			       const struct mcp251xfd_dump_regs *regs, u8 n)
+{
+	return mcp251xfd_dump_get_tx_obj_rel_addr(priv, regs, n) +
+		MCP251XFD_RAM_START;
+}
+
+static u8
+mcp251xfd_dump_get_tx_tail(const struct mcp251xfd_priv *priv,
+			   const struct mcp251xfd_dump_regs *regs)
+{
+	return (regs->fifo[MCP251XFD_TX_FIFO].ua -
+		mcp251xfd_dump_get_tx_obj_rel_addr(priv, regs, 0)) /
+		mcp251xfd_dump_get_tx_obj_size(priv, regs);
+}
+
+static u8
+mcp251xfd_dump_get_tx_head(const struct mcp251xfd_priv *priv,
+			   const struct mcp251xfd_dump_regs *regs)
+{
+	return FIELD_GET(MCP251XFD_REG_FIFOSTA_FIFOCI_MASK,
+			 regs->fifo[MCP251XFD_TX_FIFO].sta);
+}
+
+/* RX */
+
+static u8
+mcp251xfd_dump_get_rx_obj_size(const struct mcp251xfd_priv *priv,
+			       const struct mcp251xfd_dump_regs *regs)
+{
+	return sizeof(struct mcp251xfd_hw_rx_obj_can) -
+		sizeof_field(struct mcp251xfd_hw_rx_obj_can, data) +
+		mcp251xfd_dump_get_fifo_size(priv, regs, regs->rx_fifo.con);
+}
+
+static u8
+mcp251xfd_dump_get_rx_obj_num(const struct mcp251xfd_priv *priv,
+			      const struct mcp251xfd_dump_regs *regs)
+{
+	return mcp251xfd_dump_get_fifo_obj_num(priv, regs, regs->rx_fifo.con);
+}
+
+static u16
+mcp251xfd_dump_get_rx_obj_rel_addr(const struct mcp251xfd_priv *priv,
+				   const struct mcp251xfd_dump_regs *regs, u8 n)
+{
+	return mcp251xfd_dump_get_tx_obj_rel_addr(priv, regs, mcp251xfd_dump_get_tx_obj_num(priv, regs)) +
+		mcp251xfd_dump_get_rx_obj_size(priv, regs) * n;
+}
+
+static u16
+mcp251xfd_dump_get_rx_obj_addr(const struct mcp251xfd_priv *priv,
+			       const struct mcp251xfd_dump_regs *regs, u8 n)
+{
+	return mcp251xfd_dump_get_rx_obj_rel_addr(priv, regs, n) + MCP251XFD_RAM_START;
+}
+
+static u8
+mcp251xfd_dump_get_rx_tail(const struct mcp251xfd_priv *priv,
+			   const struct mcp251xfd_dump_regs *regs)
+{
+	return (regs->fifo[MCP251XFD_RX_FIFO(0)].ua -
+		mcp251xfd_dump_get_rx_obj_rel_addr(priv, regs, 0)) /
+		mcp251xfd_dump_get_rx_obj_size(priv, regs);
+}
+
+static u8
+mcp251xfd_dump_get_rx_head(const struct mcp251xfd_priv *priv,
+			   const struct mcp251xfd_dump_regs *regs)
+{
+	return FIELD_GET(MCP251XFD_REG_FIFOSTA_FIFOCI_MASK, regs->fifo[MCP251XFD_RX_FIFO(0)].sta);
+}
+
+/* dump TEF */
+
+static void
+mcp251xfd_dump_ram_tef_obj_one(const struct mcp251xfd_priv *priv,
+			       const struct mcp251xfd_dump_regs *regs,
+			       const struct mcp251xfd_ring *tef,
+			       const struct mcp251xfd_hw_tef_obj *hw_tef_obj,
+			       u8 n)
+{
+	pr_info("TEF Object: 0x%02x (0x%03x)%s%s%s%s%s\n",
+		n, mcp251xfd_dump_get_tef_obj_addr(priv, n),
+		mcp251xfd_get_ring_head(tef) == n ? "  priv-HEAD" : "",
+		mcp251xfd_dump_get_tef_tail(priv, regs) == n ? "  chip-TAIL" : "",
+		mcp251xfd_get_ring_tail(tef) == n ? "  priv-TAIL" : "",
+		(mcp251xfd_dump_get_tef_tail(priv, regs) == n ?
+		 ((regs->tef.sta & MCP251XFD_REG_TEFSTA_TEFFIF) ? "  chip-FIFO-full" :
+		  !(regs->tef.sta & MCP251XFD_REG_TEFSTA_TEFNEIF) ? "  chip-FIFO-empty" : "") :
+		 ("")),
+		(mcp251xfd_get_ring_head(tef) == mcp251xfd_get_ring_tail(tef) &&
+		 mcp251xfd_get_ring_tail(tef) == n ?
+		 (priv->tef->head == priv->tef->tail ? "  priv-FIFO-empty" : "  priv-FIFO-full") :
+		 ("")));
+	pr_info("%16s = 0x%08x\n", "id", hw_tef_obj->id);
+	pr_info("%16s = 0x%08x\n", "flags", hw_tef_obj->flags);
+	pr_info("%16s = 0x%08x\n", "ts", hw_tef_obj->ts);
+	__dump_mask(hw_tef_obj->flags, MCP251XFD_OBJ_FLAGS, SEQ, "0x%06lx", "Sequence");
+	pr_info("\n");
+}
+
+static void
+mcp251xfd_dump_ram_tef_obj(const struct mcp251xfd_priv *priv,
+			   const struct mcp251xfd_dump_regs *regs,
+			   const struct mcp251xfd_dump_ram *ram,
+			   const struct mcp251xfd_ring *tef)
+{
+	int i;
+
+	pr_info("\nTEF Overview:\n");
+	pr_info("%16s =        0x%02x    0x%08x\n", "head (p)",
+		mcp251xfd_get_ring_head(tef),
+		tef->head);
+	pr_info("%16s = 0x%02x   0x%02x    0x%08x\n", "tail (c/p)",
+		mcp251xfd_dump_get_tef_tail(priv, regs),
+		mcp251xfd_get_ring_tail(tef),
+		tef->tail);
+	pr_info("\n");
+
+	for (i = 0; i < mcp251xfd_dump_get_tef_obj_num(priv, regs); i++) {
+		const struct mcp251xfd_hw_tef_obj *hw_tef_obj;
+		u16 hw_tef_obj_rel_addr;
+
+		hw_tef_obj_rel_addr = mcp251xfd_dump_get_tef_obj_rel_addr(priv, i);
+
+		hw_tef_obj = (const struct mcp251xfd_hw_tef_obj *)&ram->ram[hw_tef_obj_rel_addr];
+		mcp251xfd_dump_ram_tef_obj_one(priv, regs, tef, hw_tef_obj, i);
+	}
+}
+
+/* dump TX */
+
+static void
+mcp251xfd_dump_ram_tx_obj_one(const struct mcp251xfd_priv *priv,
+			      const struct mcp251xfd_dump_regs *regs,
+			      const struct mcp251xfd_ring *tx,
+			      const struct mcp251xfd_hw_tx_obj_canfd *hw_tx_obj,
+			      u8 n)
+{
+	pr_info("TX Object: 0x%02x (0x%03x)%s%s%s%s%s%s\n",
+		n, mcp251xfd_dump_get_tx_obj_addr(priv, regs, n),
+		mcp251xfd_dump_get_tx_head(priv, regs) == n ? "  chip-HEAD" : "",
+		mcp251xfd_get_ring_head(tx) == n ? "  priv-HEAD" : "",
+		mcp251xfd_dump_get_tx_tail(priv, regs) == n ? "  chip-TAIL" : "",
+		mcp251xfd_get_ring_tail(tx) == n ? "  priv-TAIL" : "",
+		mcp251xfd_dump_get_tx_tail(priv, regs) == n ?
+		(!(regs->tx_fifo.sta & MCP251XFD_REG_FIFOSTA_TFNRFNIF) ? "  chip-FIFO-full" :
+		 (regs->tx_fifo.sta & MCP251XFD_REG_FIFOSTA_TFERFFIF) ? "  chip-FIFO-empty" : "") :
+		(""),
+		(mcp251xfd_get_ring_head(tx) == mcp251xfd_get_ring_tail(tx) &&
+		 mcp251xfd_get_ring_tail(tx) == n ?
+		 (tx->head == tx->tail ? "  priv-FIFO-empty" : "  priv-FIFO-full") :
+		 ("")));
+	pr_info("%16s = 0x%08x\n", "id", hw_tx_obj->id);
+	pr_info("%16s = 0x%08x\n", "flags", hw_tx_obj->flags);
+	__dump_mask(hw_tx_obj->flags, MCP251XFD_OBJ_FLAGS, SEQ_MCP2517FD, "0x%06lx", "Sequence (MCP2517)");
+	__dump_mask(hw_tx_obj->flags, MCP251XFD_OBJ_FLAGS, SEQ_MCP2518FD, "0x%06lx", "Sequence (MCP2518)");
+	mcp251xfd_dump_ram_fifo_obj_data(priv,
+					 hw_tx_obj->data,
+					 FIELD_GET(MCP251XFD_OBJ_FLAGS_DLC, hw_tx_obj->flags));
+	pr_info("\n");
+}
+
+static void
+mcp251xfd_dump_ram_tx_obj(const struct mcp251xfd_priv *priv,
+			  const struct mcp251xfd_dump_regs *regs,
+			  const struct mcp251xfd_dump_ram *ram,
+			  const struct mcp251xfd_ring *tx)
+{
+	int i;
+
+	pr_info("\nTX Overview:\n");
+	pr_info("%16s = 0x%02x    0x%02x    0x%08x\n", "head (c/p)",
+		mcp251xfd_dump_get_tx_head(priv, regs),
+		mcp251xfd_get_ring_head(tx),
+		tx->head);
+	pr_info("%16s = 0x%02x    0x%02x    0x%08x\n", "tail (c/p)",
+		mcp251xfd_dump_get_tx_tail(priv, regs),
+		mcp251xfd_get_ring_tail(tx),
+		tx->tail);
+	pr_info("\n");
+
+	for (i = 0; i < mcp251xfd_dump_get_tx_obj_num(priv, regs); i++) {
+		const struct mcp251xfd_hw_tx_obj_canfd *hw_tx_obj;
+		u16 hw_tx_obj_rel_addr;
+
+		hw_tx_obj_rel_addr = mcp251xfd_dump_get_tx_obj_rel_addr(priv, regs, i);
+
+		hw_tx_obj = (const struct mcp251xfd_hw_tx_obj_canfd *)&ram->ram[hw_tx_obj_rel_addr];
+		mcp251xfd_dump_ram_tx_obj_one(priv, regs, tx, hw_tx_obj, i);
+	}
+}
+
+/* dump RX */
+
+static void
+mcp251xfd_dump_ram_rx_obj_one(const struct mcp251xfd_priv *priv,
+			      const struct mcp251xfd_dump_regs *regs,
+			      const struct mcp251xfd_ring *rx,
+			      const struct mcp251xfd_hw_rx_obj_canfd *hw_rx_obj,
+			      u8 n)
+{
+	pr_info("RX Object: 0x%02x (0x%03x)%s%s%s%s%s%s\n",
+		n, mcp251xfd_dump_get_rx_obj_addr(priv, regs, n),
+		mcp251xfd_dump_get_rx_head(priv, regs) == n ? "  chip-HEAD" : "",
+		mcp251xfd_get_ring_head(rx) == n ? "  priv-HEAD" : "",
+		mcp251xfd_dump_get_rx_tail(priv, regs) == n ? "  chip-TAIL" : "",
+		mcp251xfd_get_ring_tail(rx) == n ? "  priv-TAIL" : "",
+		mcp251xfd_dump_get_rx_tail(priv, regs) == n ?
+		((regs->rx_fifo.sta & MCP251XFD_REG_FIFOSTA_TFERFFIF) ? "  chip-FIFO-full" :
+		 !(regs->rx_fifo.sta & MCP251XFD_REG_FIFOSTA_TFNRFNIF) ? "  chip-FIFO-empty" : "") :
+		(""),
+		(mcp251xfd_get_ring_head(rx) == mcp251xfd_get_ring_tail(rx) &&
+		 mcp251xfd_get_ring_tail(rx) == n ?
+		 (priv->rx->head == priv->rx->tail ? "  priv-FIFO-empty" : "  priv-FIFO-full") :
+		 ("")));
+	pr_info("%16s = 0x%08x\n", "id", hw_rx_obj->id);
+	pr_info("%16s = 0x%08x\n", "flags", hw_rx_obj->flags);
+	pr_info("%16s = 0x%08x\n", "ts", hw_rx_obj->ts);
+	mcp251xfd_dump_ram_fifo_obj_data(priv, hw_rx_obj->data, FIELD_GET(MCP251XFD_OBJ_FLAGS_DLC, hw_rx_obj->flags));
+	pr_info("\n");
+}
+
+static void
+mcp251xfd_dump_ram_rx_obj(const struct mcp251xfd_priv *priv,
+			  const struct mcp251xfd_dump_regs *regs,
+			  const struct mcp251xfd_dump_ram *ram,
+			  const struct mcp251xfd_ring *rx)
+{
+	int i;
+
+	pr_info("\nRX Overview:\n");
+	pr_info("%16s = 0x%02x    0x%02x    0x%08x\n", "head (c/p)",
+		mcp251xfd_dump_get_rx_head(priv, regs),
+		mcp251xfd_get_ring_head(rx), rx->head);
+	pr_info("%16s = 0x%02x    0x%02x    0x%08x\n", "tail (c/p)",
+		mcp251xfd_dump_get_rx_tail(priv, regs),
+		mcp251xfd_get_ring_tail(rx), rx->tail);
+	pr_info("\n");
+
+	for (i = 0; i < mcp251xfd_dump_get_rx_obj_num(priv, regs); i++) {
+		const struct mcp251xfd_hw_rx_obj_canfd *hw_rx_obj;
+		u16 hw_rx_obj_rel_addr;
+
+		hw_rx_obj_rel_addr = mcp251xfd_dump_get_rx_obj_rel_addr(priv, regs, i);
+		hw_rx_obj = (const struct mcp251xfd_hw_rx_obj_canfd *)&ram->ram[hw_rx_obj_rel_addr];
+
+		mcp251xfd_dump_ram_rx_obj_one(priv, regs, rx, hw_rx_obj, i);
+	}
+}
+
+#undef __dump_mask
+#undef __dump_bit
+
+static void mcp251xfd_dump_ram(const struct mcp251xfd_priv *priv, const struct mcp251xfd_dump_regs *regs, const struct mcp251xfd_dump_ram *ram)
+{
+	netdev_info(priv->ndev, "----------------------- RAM dump ----------------------\n");
+	mcp251xfd_dump_ram_tef_obj(priv, regs, ram, priv->tef);
+	mcp251xfd_dump_ram_tx_obj(priv, regs, ram, priv->tx);
+	mcp251xfd_dump_ram_rx_obj(priv, regs, ram, priv->rx);
+	netdev_info(priv->ndev, "------------------------- end -------------------------\n");
+}
+
+void mcp251xfd_dump(struct mcp251xfd_priv *priv)
+{
+	struct mcp251xfd_dump_regs regs;
+	struct mcp251xfd_dump_ram ram;
+	struct mcp251xfd_dump_regs_mcp251xfd regs_mcp251xfd;
+	int err;
+
+	BUILD_BUG_ON(sizeof(struct mcp251xfd_dump_regs) !=
+		     MCP251XFD_REG_FIFOUA(31) - MCP251XFD_REG_CON + 4);
+
+	err = regmap_bulk_read(priv->map, MCP251XFD_REG_CON,
+			       &regs, sizeof(regs) / sizeof(u32));
+	if (err)
+		return;
+
+	err = regmap_bulk_read(priv->map, MCP251XFD_RAM_START,
+			       &ram, sizeof(ram) / sizeof(u32));
+	if (err)
+		return;
+
+	err = regmap_bulk_read(priv->map, MCP251XFD_REG_OSC,
+			       &regs_mcp251xfd, sizeof(regs_mcp251xfd) / sizeof(u32));
+	if (err)
+		return;
+
+	mcp251xfd_dump_regs(priv, &regs, &regs_mcp251xfd);
+	mcp251xfd_dump_ram(priv, &regs, &ram);
+}

mcp251xfd/mcp251xfd-dump.h

@@ -0,0 +1,45 @@
+/* SPDX-License-Identifier: GPL-2.0
+ *
+ * mcp251xfd - Microchip MCP251xFD Family CAN controller driver
+ *
+ * Copyright (c) 2019, 2020, 2021 Pengutronix,
+ *               Marc Kleine-Budde <kernel@pengutronix.de>
+ */
+
+#ifndef _MCP251XFD_DUMP_H
+#define _MCP251XFD_DUMP_H
+
+#define MCP251XFD_DUMP_MAGIC 0x1825434d
+
+enum mcp251xfd_dump_object_type {
+	MCP251XFD_DUMP_OBJECT_TYPE_REG,
+	MCP251XFD_DUMP_OBJECT_TYPE_TEF,
+	MCP251XFD_DUMP_OBJECT_TYPE_RX,
+	MCP251XFD_DUMP_OBJECT_TYPE_TX,
+	MCP251XFD_DUMP_OBJECT_TYPE_END = -1,
+};
+
+enum mcp251xfd_dump_object_ring_key {
+	MCP251XFD_DUMP_OBJECT_RING_KEY_HEAD,
+	MCP251XFD_DUMP_OBJECT_RING_KEY_TAIL,
+	MCP251XFD_DUMP_OBJECT_RING_KEY_BASE,
+	MCP251XFD_DUMP_OBJECT_RING_KEY_NR,
+	MCP251XFD_DUMP_OBJECT_RING_KEY_FIFO_NR,
+	MCP251XFD_DUMP_OBJECT_RING_KEY_OBJ_NUM,
+	MCP251XFD_DUMP_OBJECT_RING_KEY_OBJ_SIZE,
+	__MCP251XFD_DUMP_OBJECT_RING_KEY_MAX,
+};
+
+struct mcp251xfd_dump_object_header {
+	__le32 magic;
+	__le32 type;
+	__le32 offset;
+	__le32 len;
+};
+
+struct mcp251xfd_dump_object_reg {
+	__le32 reg;
+	__le32 val;
+};
+
+#endif

mcp251xfd/mcp251xfd-main.c

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: GPL-2.0
+//
+// Microchip MCP251xFD Family CAN controller debug tool
+//
+// Copyright (c) 2020, 2021 Pengutronix,
+//               Marc Kleine-Budde <kernel@pengutronix.de>
+//
+
+#include <errno.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <linux/kernel.h>
+
+#include "mcp251xfd-dump-userspace.h"
+
+static void print_usage(char *prg)
+{
+	fprintf(stderr,
+		"%s - decode chip and driver state of mcp251xfd.\n"
+		"\n"
+		"Usage: %s [options] <file>\n"
+		"\n"
+		"        <file>      path to dev coredump file\n"
+		"                        ('/var/log/devcoredump-19700101-234200.dump')\n"
+		"                    path to regmap register file\n"
+                "                        ('/sys/kernel/debug/regmap/spi1.0-crc/registers')\n"
+		"                    shortcut to regmap register file\n"
+		"                        ('spi0.0')\n"
+		"\n"
+		"Options:\n"
+		"        -h, --help  this help\n"
+		"\n",
+		prg, prg);
+}
+
+int regmap_bulk_read(struct regmap *map, unsigned int reg,
+		     void *val, size_t val_count)
+{
+	memcpy(val, map->mem->buf + reg,
+	       val_count * sizeof(uint32_t));
+
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	struct mcp251xfd_mem mem = { };
+	struct regmap map = {
+		.mem = &mem,
+	};
+	struct mcp251xfd_priv priv = {
+		.map = &map,
+	};
+	const char *file_path;
+	int opt, err;
+
+	struct option long_options[] = {
+		{ "help", no_argument, 0, 'h' },
+		{ 0, 0, 0, 0 },
+	};
+
+	while ((opt = getopt_long(argc, argv, "ei:pq::rvh", long_options, NULL)) != -1) {
+		switch (opt) {
+		case 'h':
+			print_usage(basename(argv[0]));
+			exit(EXIT_SUCCESS);
+			break;
+
+		default:
+			print_usage(basename(argv[0]));
+			exit(EXIT_FAILURE);
+			break;
+		}
+	}
+
+	file_path = argv[optind];
+
+	if (!file_path) {
+		print_usage(basename(argv[0]));
+		exit(EXIT_FAILURE);
+	}
+
+	err = mcp251xfd_dev_coredump_read(&priv, &mem, file_path);
+	if (err)
+		err = mcp251xfd_regmap_read(&priv, &mem, file_path);
+	if (err) {
+		fprintf(stderr, "Unable to read file: '%s'\n", file_path);
+		exit(EXIT_FAILURE);
+	}
+
+	mcp251xfd_dump(&priv);
+
+	exit(EXIT_SUCCESS);
+}

mcp251xfd/mcp251xfd-regmap.c

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: GPL-2.0
+//
+// Microchip MCP251xFD Family CAN controller debug tool
+//
+// Copyright (c) 2020 Pengutronix,
+//               Marc Kleine-Budde <kernel@pengutronix.de>
+//
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include <linux/kernel.h>
+
+#include "mcp251xfd.h"
+#include "mcp251xfd-dump-userspace.h"
+
+static int
+do_mcp251xfd_regmap_read(struct mcp251xfd_priv *priv,
+			 struct mcp251xfd_mem *mem,
+			 const char *file_path)
+{
+	FILE *reg_file;
+	uint16_t reg;
+	uint32_t val;
+
+	reg_file = fopen(file_path, "r");
+	if (!reg_file)
+		return -errno;
+
+	while (fscanf(reg_file, "%hx: %x\n", &reg, &val) == 2) {
+		if (reg >= ARRAY_SIZE(mem->buf))
+			return -EINVAL;
+
+		*(uint32_t *)(mem->buf + reg) = val;
+	}
+
+	fclose(reg_file);
+
+	return 0;
+}
+
+int mcp251xfd_regmap_read(struct mcp251xfd_priv *priv,
+			  struct mcp251xfd_mem *mem,
+			  const char *file_path)
+{
+	char *tmp;
+	int err;
+
+	err = do_mcp251xfd_regmap_read(priv, mem, file_path);
+	if (!err)
+		return 0;
+
+	/* maybe it's something like "spi0.0" */
+	tmp = strchr(file_path, '/');
+	if (tmp)
+		return -ENOENT;
+
+	/* first try literally */
+	err = asprintf(&tmp, "/sys/kernel/debug/regmap/%s/registers", file_path);
+	if (err == -1)
+		return -errno;
+
+	err = do_mcp251xfd_regmap_read(priv, mem, tmp);
+	free (tmp);
+	if (!err)
+		return 0;
+
+	/* then add "-crc" */
+	err = asprintf(&tmp, "/sys/kernel/debug/regmap/%s-crc/registers", file_path);
+	if (err == -1)
+		return -errno;
+
+	err = do_mcp251xfd_regmap_read(priv, mem, tmp);
+	free (tmp);
+
+	return err;
+}

mcp251xfd/mcp251xfd.h

@@ -0,0 +1,389 @@
+/* SPDX-License-Identifier: GPL-2.0
+ *
+ * mcp251xfd - Microchip MCP251xFD Family CAN controller driver
+ *
+ * Copyright (c) 2019, 2020 Pengutronix,
+ *               Marc Kleine-Budde <kernel@pengutronix.de>
+ * Copyright (c) 2019 Martin Sperl <kernel@martin.sperl.org>
+ */
+
+#ifndef _MCP251XFD_H
+#define _MCP251XFD_H
+
+/* MPC251x registers */
+
+/* CAN FD Controller Module SFR */
+#define MCP251XFD_REG_CON 0x00
+#define MCP251XFD_REG_CON_TXBWS_MASK GENMASK(31, 28)
+#define MCP251XFD_REG_CON_ABAT BIT(27)
+#define MCP251XFD_REG_CON_REQOP_MASK GENMASK(26, 24)
+#define MCP251XFD_REG_CON_MODE_MIXED 0
+#define MCP251XFD_REG_CON_MODE_SLEEP 1
+#define MCP251XFD_REG_CON_MODE_INT_LOOPBACK 2
+#define MCP251XFD_REG_CON_MODE_LISTENONLY 3
+#define MCP251XFD_REG_CON_MODE_CONFIG 4
+#define MCP251XFD_REG_CON_MODE_EXT_LOOPBACK 5
+#define MCP251XFD_REG_CON_MODE_CAN2_0 6
+#define MCP251XFD_REG_CON_MODE_RESTRICTED 7
+#define MCP251XFD_REG_CON_OPMOD_MASK GENMASK(23, 21)
+#define MCP251XFD_REG_CON_TXQEN BIT(20)
+#define MCP251XFD_REG_CON_STEF BIT(19)
+#define MCP251XFD_REG_CON_SERR2LOM BIT(18)
+#define MCP251XFD_REG_CON_ESIGM BIT(17)
+#define MCP251XFD_REG_CON_RTXAT BIT(16)
+#define MCP251XFD_REG_CON_BRSDIS BIT(12)
+#define MCP251XFD_REG_CON_BUSY BIT(11)
+#define MCP251XFD_REG_CON_WFT_MASK GENMASK(10, 9)
+#define MCP251XFD_REG_CON_WFT_T00FILTER 0x0
+#define MCP251XFD_REG_CON_WFT_T01FILTER 0x1
+#define MCP251XFD_REG_CON_WFT_T10FILTER 0x2
+#define MCP251XFD_REG_CON_WFT_T11FILTER 0x3
+#define MCP251XFD_REG_CON_WAKFIL BIT(8)
+#define MCP251XFD_REG_CON_PXEDIS BIT(6)
+#define MCP251XFD_REG_CON_ISOCRCEN BIT(5)
+#define MCP251XFD_REG_CON_DNCNT_MASK GENMASK(4, 0)
+
+#define MCP251XFD_REG_NBTCFG 0x04
+#define MCP251XFD_REG_NBTCFG_BRP_MASK GENMASK(31, 24)
+#define MCP251XFD_REG_NBTCFG_TSEG1_MASK GENMASK(23, 16)
+#define MCP251XFD_REG_NBTCFG_TSEG2_MASK GENMASK(14, 8)
+#define MCP251XFD_REG_NBTCFG_SJW_MASK GENMASK(6, 0)
+
+#define MCP251XFD_REG_DBTCFG 0x08
+#define MCP251XFD_REG_DBTCFG_BRP_MASK GENMASK(31, 24)
+#define MCP251XFD_REG_DBTCFG_TSEG1_MASK GENMASK(20, 16)
+#define MCP251XFD_REG_DBTCFG_TSEG2_MASK GENMASK(11, 8)
+#define MCP251XFD_REG_DBTCFG_SJW_MASK GENMASK(3, 0)
+
+#define MCP251XFD_REG_TDC 0x0c
+#define MCP251XFD_REG_TDC_EDGFLTEN BIT(25)
+#define MCP251XFD_REG_TDC_SID11EN BIT(24)
+#define MCP251XFD_REG_TDC_TDCMOD_MASK GENMASK(17, 16)
+#define MCP251XFD_REG_TDC_TDCMOD_AUTO 2
+#define MCP251XFD_REG_TDC_TDCMOD_MANUAL 1
+#define MCP251XFD_REG_TDC_TDCMOD_DISABLED 0
+#define MCP251XFD_REG_TDC_TDCO_MASK GENMASK(14, 8)
+#define MCP251XFD_REG_TDC_TDCV_MASK GENMASK(5, 0)
+
+#define MCP251XFD_REG_TBC 0x10
+
+#define MCP251XFD_REG_TSCON 0x14
+#define MCP251XFD_REG_TSCON_TSRES BIT(18)
+#define MCP251XFD_REG_TSCON_TSEOF BIT(17)
+#define MCP251XFD_REG_TSCON_TBCEN BIT(16)
+#define MCP251XFD_REG_TSCON_TBCPRE_MASK GENMASK(9, 0)
+
+#define MCP251XFD_REG_VEC 0x18
+#define MCP251XFD_REG_VEC_RXCODE_MASK GENMASK(30, 24)
+#define MCP251XFD_REG_VEC_TXCODE_MASK GENMASK(22, 16)
+#define MCP251XFD_REG_VEC_FILHIT_MASK GENMASK(12, 8)
+#define MCP251XFD_REG_VEC_ICODE_MASK GENMASK(6, 0)
+
+#define MCP251XFD_REG_INT 0x1c
+#define MCP251XFD_REG_INT_IF_MASK GENMASK(15, 0)
+#define MCP251XFD_REG_INT_IE_MASK GENMASK(31, 16)
+#define MCP251XFD_REG_INT_IVMIE BIT(31)
+#define MCP251XFD_REG_INT_WAKIE BIT(30)
+#define MCP251XFD_REG_INT_CERRIE BIT(29)
+#define MCP251XFD_REG_INT_SERRIE BIT(28)
+#define MCP251XFD_REG_INT_RXOVIE BIT(27)
+#define MCP251XFD_REG_INT_TXATIE BIT(26)
+#define MCP251XFD_REG_INT_SPICRCIE BIT(25)
+#define MCP251XFD_REG_INT_ECCIE BIT(24)
+#define MCP251XFD_REG_INT_TEFIE BIT(20)
+#define MCP251XFD_REG_INT_MODIE BIT(19)
+#define MCP251XFD_REG_INT_TBCIE BIT(18)
+#define MCP251XFD_REG_INT_RXIE BIT(17)
+#define MCP251XFD_REG_INT_TXIE BIT(16)
+#define MCP251XFD_REG_INT_IVMIF BIT(15)
+#define MCP251XFD_REG_INT_WAKIF BIT(14)
+#define MCP251XFD_REG_INT_CERRIF BIT(13)
+#define MCP251XFD_REG_INT_SERRIF BIT(12)
+#define MCP251XFD_REG_INT_RXOVIF BIT(11)
+#define MCP251XFD_REG_INT_TXATIF BIT(10)
+#define MCP251XFD_REG_INT_SPICRCIF BIT(9)
+#define MCP251XFD_REG_INT_ECCIF BIT(8)
+#define MCP251XFD_REG_INT_TEFIF BIT(4)
+#define MCP251XFD_REG_INT_MODIF BIT(3)
+#define MCP251XFD_REG_INT_TBCIF BIT(2)
+#define MCP251XFD_REG_INT_RXIF BIT(1)
+#define MCP251XFD_REG_INT_TXIF BIT(0)
+/* These IRQ flags must be cleared by SW in the CAN_INT register */
+#define MCP251XFD_REG_INT_IF_CLEARABLE_MASK \
+	(MCP251XFD_REG_INT_IVMIF | MCP251XFD_REG_INT_WAKIF | \
+	 MCP251XFD_REG_INT_CERRIF |  MCP251XFD_REG_INT_SERRIF | \
+	 MCP251XFD_REG_INT_MODIF)
+
+#define MCP251XFD_REG_RXIF 0x20
+#define MCP251XFD_REG_TXIF 0x24
+#define MCP251XFD_REG_RXOVIF 0x28
+#define MCP251XFD_REG_TXATIF 0x2c
+#define MCP251XFD_REG_TXREQ 0x30
+
+#define MCP251XFD_REG_TREC 0x34
+#define MCP251XFD_REG_TREC_TXBO BIT(21)
+#define MCP251XFD_REG_TREC_TXBP BIT(20)
+#define MCP251XFD_REG_TREC_RXBP BIT(19)
+#define MCP251XFD_REG_TREC_TXWARN BIT(18)
+#define MCP251XFD_REG_TREC_RXWARN BIT(17)
+#define MCP251XFD_REG_TREC_EWARN BIT(16)
+#define MCP251XFD_REG_TREC_TEC_MASK GENMASK(15, 8)
+#define MCP251XFD_REG_TREC_REC_MASK GENMASK(7, 0)
+
+#define MCP251XFD_REG_BDIAG0 0x38
+#define MCP251XFD_REG_BDIAG0_DTERRCNT_MASK GENMASK(31, 24)
+#define MCP251XFD_REG_BDIAG0_DRERRCNT_MASK GENMASK(23, 16)
+#define MCP251XFD_REG_BDIAG0_NTERRCNT_MASK GENMASK(15, 8)
+#define MCP251XFD_REG_BDIAG0_NRERRCNT_MASK GENMASK(7, 0)
+
+#define MCP251XFD_REG_BDIAG1 0x3c
+#define MCP251XFD_REG_BDIAG1_DLCMM BIT(31)
+#define MCP251XFD_REG_BDIAG1_ESI BIT(30)
+#define MCP251XFD_REG_BDIAG1_DCRCERR BIT(29)
+#define MCP251XFD_REG_BDIAG1_DSTUFERR BIT(28)
+#define MCP251XFD_REG_BDIAG1_DFORMERR BIT(27)
+#define MCP251XFD_REG_BDIAG1_DBIT1ERR BIT(25)
+#define MCP251XFD_REG_BDIAG1_DBIT0ERR BIT(24)
+#define MCP251XFD_REG_BDIAG1_TXBOERR BIT(23)
+#define MCP251XFD_REG_BDIAG1_NCRCERR BIT(21)
+#define MCP251XFD_REG_BDIAG1_NSTUFERR BIT(20)
+#define MCP251XFD_REG_BDIAG1_NFORMERR BIT(19)
+#define MCP251XFD_REG_BDIAG1_NACKERR BIT(18)
+#define MCP251XFD_REG_BDIAG1_NBIT1ERR BIT(17)
+#define MCP251XFD_REG_BDIAG1_NBIT0ERR BIT(16)
+#define MCP251XFD_REG_BDIAG1_BERR_MASK \
+	(MCP251XFD_REG_BDIAG1_DLCMM | MCP251XFD_REG_BDIAG1_ESI | \
+	 MCP251XFD_REG_BDIAG1_DCRCERR | MCP251XFD_REG_BDIAG1_DSTUFERR | \
+	 MCP251XFD_REG_BDIAG1_DFORMERR | MCP251XFD_REG_BDIAG1_DBIT1ERR | \
+	 MCP251XFD_REG_BDIAG1_DBIT0ERR | MCP251XFD_REG_BDIAG1_TXBOERR | \
+	 MCP251XFD_REG_BDIAG1_NCRCERR | MCP251XFD_REG_BDIAG1_NSTUFERR | \
+	 MCP251XFD_REG_BDIAG1_NFORMERR | MCP251XFD_REG_BDIAG1_NACKERR | \
+	 MCP251XFD_REG_BDIAG1_NBIT1ERR | MCP251XFD_REG_BDIAG1_NBIT0ERR)
+#define MCP251XFD_REG_BDIAG1_EFMSGCNT_MASK GENMASK(15, 0)
+
+#define MCP251XFD_REG_TEFCON 0x40
+#define MCP251XFD_REG_TEFCON_FSIZE_MASK GENMASK(28, 24)
+#define MCP251XFD_REG_TEFCON_FRESET BIT(10)
+#define MCP251XFD_REG_TEFCON_UINC BIT(8)
+#define MCP251XFD_REG_TEFCON_TEFTSEN BIT(5)
+#define MCP251XFD_REG_TEFCON_TEFOVIE BIT(3)
+#define MCP251XFD_REG_TEFCON_TEFFIE BIT(2)
+#define MCP251XFD_REG_TEFCON_TEFHIE BIT(1)
+#define MCP251XFD_REG_TEFCON_TEFNEIE BIT(0)
+
+#define MCP251XFD_REG_TEFSTA 0x44
+#define MCP251XFD_REG_TEFSTA_TEFOVIF BIT(3)
+#define MCP251XFD_REG_TEFSTA_TEFFIF BIT(2)
+#define MCP251XFD_REG_TEFSTA_TEFHIF BIT(1)
+#define MCP251XFD_REG_TEFSTA_TEFNEIF BIT(0)
+
+#define MCP251XFD_REG_TEFUA 0x48
+
+#define MCP251XFD_REG_TXQCON 0x50
+#define MCP251XFD_REG_TXQCON_PLSIZE_MASK GENMASK(31, 29)
+#define MCP251XFD_REG_TXQCON_PLSIZE_8 0
+#define MCP251XFD_REG_TXQCON_PLSIZE_12 1
+#define MCP251XFD_REG_TXQCON_PLSIZE_16 2
+#define MCP251XFD_REG_TXQCON_PLSIZE_20 3
+#define MCP251XFD_REG_TXQCON_PLSIZE_24 4
+#define MCP251XFD_REG_TXQCON_PLSIZE_32 5
+#define MCP251XFD_REG_TXQCON_PLSIZE_48 6
+#define MCP251XFD_REG_TXQCON_PLSIZE_64 7
+#define MCP251XFD_REG_TXQCON_FSIZE_MASK GENMASK(28, 24)
+#define MCP251XFD_REG_TXQCON_TXAT_UNLIMITED 3
+#define MCP251XFD_REG_TXQCON_TXAT_THREE_SHOT 1
+#define MCP251XFD_REG_TXQCON_TXAT_ONE_SHOT 0
+#define MCP251XFD_REG_TXQCON_TXAT_MASK GENMASK(22, 21)
+#define MCP251XFD_REG_TXQCON_TXPRI_MASK GENMASK(20, 16)
+#define MCP251XFD_REG_TXQCON_FRESET BIT(10)
+#define MCP251XFD_REG_TXQCON_TXREQ BIT(9)
+#define MCP251XFD_REG_TXQCON_UINC BIT(8)
+#define MCP251XFD_REG_TXQCON_TXEN BIT(7)
+#define MCP251XFD_REG_TXQCON_TXATIE BIT(4)
+#define MCP251XFD_REG_TXQCON_TXQEIE BIT(2)
+#define MCP251XFD_REG_TXQCON_TXQNIE BIT(0)
+
+#define MCP251XFD_REG_TXQSTA 0x54
+#define MCP251XFD_REG_TXQSTA_TXQCI_MASK GENMASK(12, 8)
+#define MCP251XFD_REG_TXQSTA_TXABT BIT(7)
+#define MCP251XFD_REG_TXQSTA_TXLARB BIT(6)
+#define MCP251XFD_REG_TXQSTA_TXERR BIT(5)
+#define MCP251XFD_REG_TXQSTA_TXATIF BIT(4)
+#define MCP251XFD_REG_TXQSTA_TXQEIF BIT(2)
+#define MCP251XFD_REG_TXQSTA_TXQNIF BIT(0)
+
+#define MCP251XFD_REG_TXQUA 0x58
+
+#define MCP251XFD_REG_FIFOCON(x) (0x50 + 0xc * (x))
+#define MCP251XFD_REG_FIFOCON_PLSIZE_MASK GENMASK(31, 29)
+#define MCP251XFD_REG_FIFOCON_PLSIZE_8 0
+#define MCP251XFD_REG_FIFOCON_PLSIZE_12 1
+#define MCP251XFD_REG_FIFOCON_PLSIZE_16 2
+#define MCP251XFD_REG_FIFOCON_PLSIZE_20 3
+#define MCP251XFD_REG_FIFOCON_PLSIZE_24 4
+#define MCP251XFD_REG_FIFOCON_PLSIZE_32 5
+#define MCP251XFD_REG_FIFOCON_PLSIZE_48 6
+#define MCP251XFD_REG_FIFOCON_PLSIZE_64 7
+#define MCP251XFD_REG_FIFOCON_FSIZE_MASK GENMASK(28, 24)
+#define MCP251XFD_REG_FIFOCON_TXAT_MASK GENMASK(22, 21)
+#define MCP251XFD_REG_FIFOCON_TXAT_ONE_SHOT 0
+#define MCP251XFD_REG_FIFOCON_TXAT_THREE_SHOT 1
+#define MCP251XFD_REG_FIFOCON_TXAT_UNLIMITED 3
+#define MCP251XFD_REG_FIFOCON_TXPRI_MASK GENMASK(20, 16)
+#define MCP251XFD_REG_FIFOCON_FRESET BIT(10)
+#define MCP251XFD_REG_FIFOCON_TXREQ BIT(9)
+#define MCP251XFD_REG_FIFOCON_UINC BIT(8)
+#define MCP251XFD_REG_FIFOCON_TXEN BIT(7)
+#define MCP251XFD_REG_FIFOCON_RTREN BIT(6)
+#define MCP251XFD_REG_FIFOCON_RXTSEN BIT(5)
+#define MCP251XFD_REG_FIFOCON_TXATIE BIT(4)
+#define MCP251XFD_REG_FIFOCON_RXOVIE BIT(3)
+#define MCP251XFD_REG_FIFOCON_TFERFFIE BIT(2)
+#define MCP251XFD_REG_FIFOCON_TFHRFHIE BIT(1)
+#define MCP251XFD_REG_FIFOCON_TFNRFNIE BIT(0)
+
+#define MCP251XFD_REG_FIFOSTA(x) (0x54 + 0xc * (x))
+#define MCP251XFD_REG_FIFOSTA_FIFOCI_MASK GENMASK(12, 8)
+#define MCP251XFD_REG_FIFOSTA_TXABT BIT(7)
+#define MCP251XFD_REG_FIFOSTA_TXLARB BIT(6)
+#define MCP251XFD_REG_FIFOSTA_TXERR BIT(5)
+#define MCP251XFD_REG_FIFOSTA_TXATIF BIT(4)
+#define MCP251XFD_REG_FIFOSTA_RXOVIF BIT(3)
+#define MCP251XFD_REG_FIFOSTA_TFERFFIF BIT(2)
+#define MCP251XFD_REG_FIFOSTA_TFHRFHIF BIT(1)
+#define MCP251XFD_REG_FIFOSTA_TFNRFNIF BIT(0)
+
+#define MCP251XFD_REG_FIFOUA(x) (0x58 + 0xc * (x))
+
+#define MCP251XFD_REG_FLTCON(x) (0x1d0 + 0x4 * (x))
+#define MCP251XFD_REG_FLTCON_FLTEN3 BIT(31)
+#define MCP251XFD_REG_FLTCON_F3BP_MASK GENMASK(28, 24)
+#define MCP251XFD_REG_FLTCON_FLTEN2 BIT(23)
+#define MCP251XFD_REG_FLTCON_F2BP_MASK GENMASK(20, 16)
+#define MCP251XFD_REG_FLTCON_FLTEN1 BIT(15)
+#define MCP251XFD_REG_FLTCON_F1BP_MASK GENMASK(12, 8)
+#define MCP251XFD_REG_FLTCON_FLTEN0 BIT(7)
+#define MCP251XFD_REG_FLTCON_F0BP_MASK GENMASK(4, 0)
+#define MCP251XFD_REG_FLTCON_FLTEN(x) (BIT(7) << 8 * ((x) & 0x3))
+#define MCP251XFD_REG_FLTCON_FLT_MASK(x) (GENMASK(7, 0) << (8 * ((x) & 0x3)))
+#define MCP251XFD_REG_FLTCON_FBP(x, fifo) ((fifo) << 8 * ((x) & 0x3))
+
+#define MCP251XFD_REG_FLTOBJ(x) (0x1f0 + 0x8 * (x))
+#define MCP251XFD_REG_FLTOBJ_EXIDE BIT(30)
+#define MCP251XFD_REG_FLTOBJ_SID11 BIT(29)
+#define MCP251XFD_REG_FLTOBJ_EID_MASK GENMASK(28, 11)
+#define MCP251XFD_REG_FLTOBJ_SID_MASK GENMASK(10, 0)
+
+#define MCP251XFD_REG_FLTMASK(x) (0x1f4 + 0x8 * (x))
+#define MCP251XFD_REG_MASK_MIDE BIT(30)
+#define MCP251XFD_REG_MASK_MSID11 BIT(29)
+#define MCP251XFD_REG_MASK_MEID_MASK GENMASK(28, 11)
+#define MCP251XFD_REG_MASK_MSID_MASK GENMASK(10, 0)
+
+/* RAM */
+#define MCP251XFD_RAM_START 0x400
+#define MCP251XFD_RAM_SIZE SZ_2K
+
+/* Message Object */
+#define MCP251XFD_OBJ_ID_SID11 BIT(29)
+#define MCP251XFD_OBJ_ID_EID_MASK GENMASK(28, 11)
+#define MCP251XFD_OBJ_ID_SID_MASK GENMASK(10, 0)
+#define MCP251XFD_OBJ_FLAGS_SEQ_MCP2518FD_MASK GENMASK(31, 9)
+#define MCP251XFD_OBJ_FLAGS_SEQ_MCP2517FD_MASK GENMASK(15, 9)
+#define MCP251XFD_OBJ_FLAGS_SEQ_MASK MCP251XFD_OBJ_FLAGS_SEQ_MCP2518FD_MASK
+#define MCP251XFD_OBJ_FLAGS_ESI BIT(8)
+#define MCP251XFD_OBJ_FLAGS_FDF BIT(7)
+#define MCP251XFD_OBJ_FLAGS_BRS BIT(6)
+#define MCP251XFD_OBJ_FLAGS_RTR BIT(5)
+#define MCP251XFD_OBJ_FLAGS_IDE BIT(4)
+#define MCP251XFD_OBJ_FLAGS_DLC GENMASK(3, 0)
+
+#define MCP251XFD_REG_FRAME_EFF_SID_MASK GENMASK(28, 18)
+#define MCP251XFD_REG_FRAME_EFF_EID_MASK GENMASK(17, 0)
+
+/* MCP2517/18FD SFR */
+#define MCP251XFD_REG_OSC 0xe00
+#define MCP251XFD_REG_OSC_SCLKRDY BIT(12)
+#define MCP251XFD_REG_OSC_OSCRDY BIT(10)
+#define MCP251XFD_REG_OSC_PLLRDY BIT(8)
+#define MCP251XFD_REG_OSC_CLKODIV_10 3
+#define MCP251XFD_REG_OSC_CLKODIV_4 2
+#define MCP251XFD_REG_OSC_CLKODIV_2 1
+#define MCP251XFD_REG_OSC_CLKODIV_1 0
+#define MCP251XFD_REG_OSC_CLKODIV_MASK GENMASK(6, 5)
+#define MCP251XFD_REG_OSC_SCLKDIV BIT(4)
+#define MCP251XFD_REG_OSC_LPMEN BIT(3)	/* MCP2518FD only */
+#define MCP251XFD_REG_OSC_OSCDIS BIT(2)
+#define MCP251XFD_REG_OSC_PLLEN BIT(0)
+
+#define MCP251XFD_REG_IOCON 0xe04
+#define MCP251XFD_REG_IOCON_INTOD BIT(30)
+#define MCP251XFD_REG_IOCON_SOF BIT(29)
+#define MCP251XFD_REG_IOCON_TXCANOD BIT(28)
+#define MCP251XFD_REG_IOCON_PM1 BIT(25)
+#define MCP251XFD_REG_IOCON_PM0 BIT(24)
+#define MCP251XFD_REG_IOCON_GPIO1 BIT(17)
+#define MCP251XFD_REG_IOCON_GPIO0 BIT(16)
+#define MCP251XFD_REG_IOCON_LAT1 BIT(9)
+#define MCP251XFD_REG_IOCON_LAT0 BIT(8)
+#define MCP251XFD_REG_IOCON_XSTBYEN BIT(6)
+#define MCP251XFD_REG_IOCON_TRIS1 BIT(1)
+#define MCP251XFD_REG_IOCON_TRIS0 BIT(0)
+
+#define MCP251XFD_REG_CRC 0xe08
+#define MCP251XFD_REG_CRC_FERRIE BIT(25)
+#define MCP251XFD_REG_CRC_CRCERRIE BIT(24)
+#define MCP251XFD_REG_CRC_FERRIF BIT(17)
+#define MCP251XFD_REG_CRC_CRCERRIF BIT(16)
+#define MCP251XFD_REG_CRC_IF_MASK GENMASK(17, 16)
+#define MCP251XFD_REG_CRC_MASK GENMASK(15, 0)
+
+#define MCP251XFD_REG_ECCCON 0xe0c
+#define MCP251XFD_REG_ECCCON_PARITY_MASK GENMASK(14, 8)
+#define MCP251XFD_REG_ECCCON_DEDIE BIT(2)
+#define MCP251XFD_REG_ECCCON_SECIE BIT(1)
+#define MCP251XFD_REG_ECCCON_ECCEN BIT(0)
+
+#define MCP251XFD_REG_ECCSTAT 0xe10
+#define MCP251XFD_REG_ECCSTAT_ERRADDR_MASK GENMASK(27, 16)
+#define MCP251XFD_REG_ECCSTAT_IF_MASK GENMASK(2, 1)
+#define MCP251XFD_REG_ECCSTAT_DEDIF BIT(2)
+#define MCP251XFD_REG_ECCSTAT_SECIF BIT(1)
+
+#define MCP251XFD_REG_DEVID 0xe14	/* MCP2518FD only */
+#define MCP251XFD_REG_DEVID_ID_MASK GENMASK(7, 4)
+#define MCP251XFD_REG_DEVID_REV_MASK GENMASK(3, 0)
+
+struct mcp251xfd_hw_tef_obj {
+	u32 id;
+	u32 flags;
+	u32 ts;
+};
+
+struct mcp251xfd_hw_tx_obj_can {
+	u32 id;
+	u32 flags;
+	u8 data[sizeof_field(struct can_frame, data)];
+};
+
+struct mcp251xfd_hw_tx_obj_canfd {
+	u32 id;
+	u32 flags;
+	u8 data[sizeof_field(struct canfd_frame, data)];
+};
+
+struct mcp251xfd_hw_rx_obj_can {
+	u32 id;
+	u32 flags;
+	u32 ts;
+	u8 data[sizeof_field(struct can_frame, data)];
+};
+
+struct mcp251xfd_hw_rx_obj_canfd {
+	u32 id;
+	u32 flags;
+	u32 ts;
+	u8 data[sizeof_field(struct canfd_frame, data)];
+};
+
+#endif

slcan_attach.c

@@ -69,6 +69,18 @@ void print_usage(char *prg)
 	fprintf(stderr, "         -d          (only detach line discipline)\n");
 	fprintf(stderr, "         -w          (attach - wait for keypess - detach)\n");
 	fprintf(stderr, "         -n <name>   (assign created netdevice name)\n");
+	fprintf(stderr, "\n"
+			"    <speed>          Bitrate\n"
+			"          0            10 Kbit/s\n"
+			"          1            20 Kbit/s\n"
+			"          2            50 Kbit/s\n"
+			"          3           100 Kbit/s\n"
+			"          4           125 Kbit/s\n"
+			"          5           250 Kbit/s\n"
+			"          6           500 Kbit/s\n"
+			"          7           800 Kbit/s\n"
+			"          8          1000 Kbit/s\n"
+			"\n");
 	fprintf(stderr, "\nExamples:\n");
 	fprintf(stderr, "slcan_attach -w -o -f -s6 -c /dev/ttyS1\n\n");
 	fprintf(stderr, "slcan_attach /dev/ttyS1\n\n");