Sparx5 and LAN969x Watchdog

watchdog: watchdog@600106000 {
	compatible = "microchip,sparx5-wdt", "snps,dw-wdt";
	reg = <0x6 0x00106000 0x1000>;
	interrupts = <GIC_SPI 5 IRQ_TYPE_EDGE_RISING>;
	clocks = <&ahb_clk>;
};

switch: switch@600000000 {
	...
	interrupt-names = "xtr", "fdma", "ptp", "wdt";
	interrupts = <GIC_SPI 30 IRQ_TYPE_LEVEL_HIGH>,
		     <GIC_SPI 25 IRQ_TYPE_LEVEL_HIGH>,
		     <GIC_SPI 27 IRQ_TYPE_LEVEL_HIGH>,
		     <GIC_SPI  5 IRQ_TYPE_EDGE_RISING>;
	...
};

switch: switch@e0000000 {
	...
	interrupt-names = "xtr", "fdma", "ptp", "ptp-ext", "oam-vop", "wdt";
	interrupts = <GIC_SPI 10 IRQ_TYPE_LEVEL_HIGH>,
		     <GIC_SPI 88 IRQ_TYPE_LEVEL_HIGH>,
		     <GIC_SPI  9 IRQ_TYPE_LEVEL_HIGH>,
		     <GIC_SPI  8 IRQ_TYPE_LEVEL_HIGH>,
		     <GIC_SPI 74 IRQ_TYPE_LEVEL_HIGH>,
		     <GIC_SPI 36 IRQ_TYPE_EDGE_RISING>;
	...
};

// SPDX-License-Identifier: GPL-2.0+
/* Feed /dev/watchdog0 for a while, then stop and let it reset the board. */

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <time.h>
#include <linux/watchdog.h>

static void usage(const char *me)
{
	fprintf(stderr, "usage: %s [-d dev] [-t secs] [-k secs] [-p] [-e] runtime\n", me);
	fprintf(stderr, "  runtime  keep it alive this many seconds before stopping\n");
	fprintf(stderr, "  -d dev   watchdog device, default /dev/watchdog0\n");
	fprintf(stderr, "  -t secs  set the timeout, default leaves it alone\n");
	fprintf(stderr, "  -k secs  keepalive interval, default 5\n");
	fprintf(stderr, "  -p       restore interrupt mode if it was cleared\n");
	fprintf(stderr, "  -e       clear the pretimeout once it fires, then keep it alive\n");
	exit(1);
}

/* seconds since the reference taken at t0 */
static int elapsed(const struct timespec *t0)
{
	struct timespec now;

	clock_gettime(CLOCK_MONOTONIC, &now);
	return (int)(now.tv_sec - t0->tv_sec);
}

int main(int argc, char **argv)
{
	const char *dev = "/dev/watchdog0";
	int timeout = 0, runtime = 0, pretimeout = 0, keepalive = 5;
	int escape = 0, escaped = 0;
	int fd, val, pre, opt;
	struct timespec t0;

	while ((opt = getopt(argc, argv, "d:t:k:pe")) != -1) {
		switch (opt) {
		case 'd': dev = optarg; break;
		case 't': timeout = atoi(optarg); break;
		case 'k': keepalive = atoi(optarg); break;
		case 'p': pretimeout = 1; break;
		case 'e': escape = 1; break;
		default: usage(argv[0]);
		}
	}

	/* the runtime is the only positional argument */
	if (optind != argc - 1)
		usage(argv[0]);

	runtime = atoi(argv[optind]);
	if (runtime < 1 || keepalive < 1)
		usage(argv[0]);

	/* opening the device arms the watchdog and counts as the first ping */
	fd = open(dev, O_WRONLY);
	if (fd < 0) {
		perror(dev);
		return 1;
	}

	/* any non-zero pretimeout puts dw_wdt in interrupt mode, the value is a flag */
	if (pretimeout) {
		val = 1;
		if (ioctl(fd, WDIOC_SETPRETIMEOUT, &val))
			perror("WDIOC_SETPRETIMEOUT");
	}

	if (timeout) {
		val = timeout;
		if (ioctl(fd, WDIOC_SETTIMEOUT, &val))
			perror("WDIOC_SETTIMEOUT");
	}

	if (ioctl(fd, WDIOC_GETTIMEOUT, &timeout))
		timeout = 0;
	if (ioctl(fd, WDIOC_GETPRETIMEOUT, &pre))
		pre = 0;

	printf("timeout %d s, pretimeout %d s, keepalive every %d s, kept alive for %d s\n",
	       timeout, pre, keepalive, runtime);
	fflush(stdout);

	clock_gettime(CLOCK_MONOTONIC, &t0);

	/* keepalive phase, the board must stay up throughout */
	while (elapsed(&t0) < runtime) {
		sleep(keepalive);
		if (write(fd, "1", 1) != 1)
			perror("keepalive");
		if (ioctl(fd, WDIOC_GETTIMELEFT, &val))
			val = -1;
		printf("fed at %3d s, timeleft %d s\n", elapsed(&t0), val);
		fflush(stdout);
	}

	printf("stopped keepalive at %d s, expecting a reset within %d s\n",
	       elapsed(&t0), timeout + pre);
	fflush(stdout);

	/* hold the fd open without pinging, a close would let the kernel take over */
	clock_gettime(CLOCK_MONOTONIC, &t0);
	for (;;) {
		sleep(1);
		if (ioctl(fd, WDIOC_GETTIMELEFT, &val))
			val = -1;

		/* timeleft drops below the pretimeout once the interrupt has latched */
		if (escape && !escaped && pre > 0 && val >= 0 && val < pre) {
			int zero = 0;

			if (ioctl(fd, WDIOC_SETPRETIMEOUT, &zero))
				perror("WDIOC_SETPRETIMEOUT");
			printf("WDIOC_SETPRETIMEOUT 0 at %d s, feeding from now\n",
			       elapsed(&t0));
			escaped = 1;
		}

		if (escaped && write(fd, "1", 1) != 1)
			perror("keepalive");

		printf("%s %3d s, timeleft %d s\n",
		       escaped ? "fed, ignored" : "unfed for", elapsed(&t0), val);
		fflush(stdout);
	}
	return 0;
}