path: root/configs/platform-v7a/patches/barebox-2016.05.0/0001-bootstate-add-framework-for-redundant-boot-scenarios.patch

From: Marc Kleine-Budde <mkl@pengutronix.de>
Date: Fri, 20 Feb 2015 09:19:14 +0100
Subject: [PATCH] bootstate: add framework for redundant boot scenarios

There are several use cases where a redundant Linux system is needed. The
barebox,bootstate framework provides the building blocks to model different
use cases without the need to start from the scratch over and over again.

Signed-off-by: Marc Kleine-Budde <mkl@pengutronix.de>
---
 .../bindings/barebox/barebox,bootstate.rst         | 236 +++++++
 arch/sandbox/dts/sandbox.dts                       |  83 +++
 commands/Kconfig                                   |   5 +
 commands/Makefile                                  |   1 +
 commands/bootchooser.c                             | 101 +++
 common/Kconfig                                     |   8 +
 common/Makefile                                    |   1 +
 common/bootstate.c                                 | 781 +++++++++++++++++++++
 drivers/misc/Kconfig                               |   5 +
 drivers/misc/Makefile                              |   1 +
 drivers/misc/bootstate.c                           |  79 +++
 include/bootstate.h                                |  39 +
 12 files changed, 1340 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/barebox/barebox,bootstate.rst
 create mode 100644 commands/bootchooser.c
 create mode 100644 common/bootstate.c
 create mode 100644 drivers/misc/bootstate.c
 create mode 100644 include/bootstate.h

diff --git a/Documentation/devicetree/bindings/barebox/barebox,bootstate.rst b/Documentation/devicetree/bindings/barebox/barebox,bootstate.rst
new file mode 100644
index 000000000000..0f7131536798
--- /dev/null
+++ b/Documentation/devicetree/bindings/barebox/barebox,bootstate.rst
@@ -0,0 +1,236 @@
+barebox bootstate
+=================
+
+Overview
+--------
+
+There are several use cases where a redundant Linux system is needed.
+The ``barebox,bootstate`` framework provides the building blocks to
+model different use cases without the need to start from the scratch
+over and over again.
+
+The ``barebox,bootstate`` works on abstract boot targets, each with a
+set of properties and implements an algorithm which selects the
+highest priority target to boot.
+
+A set of boot targets can be described in a devicetree node. This
+node could be part of the regular devicetree blob or it could be an
+extra devicetree for the bootstate.
+
+A bootstate node contains a description of a set of boot targets along
+with a place where to store the mutable state. Currently implemented
+backends are :ref:`barebox,state` and ``nv`` (:ref:`command_nv`)
+variables.
+
+Required properties:
+
+* ``compatible``: should be ``barebox,bootstate``;
+* ``backend-type``: should be ``state`` or ``nv``.
+
+Optional properties:
+
+* ``backend``: phandle to the :ref:`barebox,state` backend
+
+
+boot target nodes - immutable description
+-----------------------------------------
+
+These are subnodes of a bootstate node, each describing a boot
+target. The node name may end with ``@<ADDRESS>``, but the suffix is
+stripped from the target name.
+
+Optional properties:
+
+* ``default_attempts``: If the boot attempts counter is reset, this
+  value is used.
+
+Example::
+
+  bootstate: bootstate {
+	compatible = "barebox,bootstate";
+	backend-type = "state";
+	backend = <&state>;
+
+	system0 {
+		default_attempts = <3>;
+	};
+
+	system1 {
+		default_attempts = <3>;
+	};
+  };
+
+In this example a bootstate, using a :ref:`barebox,state` backend with
+two boot target nodes ``system0`` and ``system1`` is defined. When the
+boot attempts counter is reset, the default value of ``3`` is used for
+both targets.
+
+
+boot target nodes - mutable state
+---------------------------------
+
+The above example uses a :ref:`barebox,state` backend, which requires
+some additional configuration to hold the mutable
+state. :ref:`barebox,state` has to be explicidly configured, while
+``nv`` (:ref:`command_nv`) variables are created on the fly.
+
+The state of each boot target consists of the following ``uint32``
+varibles:
+
+* ``remaining_attempts``: holds the number of remaining boot attempts.
+  This variable is changed by the bootstate algorithm during boot.
+* ``priority``: defines the priority of the boot target. Higher number
+  indicate a higher priority, If two boot targets have the same
+  priority the one defined first in the device tree has precedence.
+  The ``priority`` can optionally be changed by the algorithm to 0, if
+  the boot target is decremented to ``0`` remaining boot attempts. A
+  ``priority`` of ``0`` means the boot target is **deactivated** and
+  will not be considered a valid target during further boots. If the
+  remaining attempts counter is reset, a target with priority 0 is
+  **not** changed.
+* ``ok``: this is an opaque value, it's not accessed by the bootstate
+  algorithm. It can be used be the Linux system to track the first
+  boot after an update.
+
+The bootstate can also hold a default watchdog timeout (in seconds),
+which can be activated by the bootstate algorithm.
+
+Example::
+
+  state: state {
+	magic = <0x4d433230>;
+	compatible = "barebox,state";
+	backend-type = "raw";
+	backend = <&backend_state>;
+	#address-cells = <1>;
+	#size-cells = <1>;
+
+	bootstate {
+		#address-cells = <1>;
+		#size-cells = <1>;
+
+		system0 {
+			#address-cells = <1>;
+			#size-cells = <1>;
+
+			remaining_attempts {
+				reg = <0x0 0x4>;
+				type = "uint32";
+			};
+			priority {
+				reg = <0x4 0x4>;
+				type = "uint32";
+			};
+			ok {
+				reg = <0x8 0x4>;
+				type = "uint32";
+			};
+		};
+
+		system1 {
+			#address-cells = <1>;
+			#size-cells = <1>;
+
+			remaining_attempts {
+				reg = <0x10 0x4>;
+				type = "uint32";
+			};
+			priority {
+				reg = <0x14 0x4>;
+				type = "uint32";
+			};
+			ok {
+				reg = <0x18 0x4>;
+				type = "uint32";
+			};
+		};
+
+		watchdog_timeout {
+			reg = <0x20 0x4>;
+			type = "uint32";
+			default = <60>;
+		};
+	};
+  };
+
+This example defines two boot targets (``system0`` and ``system1``) and
+a watchdog timeout of ``60`` seconds.
+
+
+Backends
+--------
+
+Currently two backends exist. The :ref:`barebox,state` backend is a
+bit more complicated to setup, as all boot target have to be described
+in the referenced :ref:`barebox,state` in the device tree. On the
+upside, the advantages of the (possible redundant storage, etc...) of
+the :ref:`barebox,state` is gained for free.
+
+The :ref:`command_nv` backend is a lot simpler, no special setup is
+needed, it should run on every board, which already implements a
+read/writeable barebox environment.
+
+
+Algorithm
+---------
+
+The low level algorithm is implemented by the
+``bootstate_get_target()`` function. Its job is to iterate over all
+boot sources and return the name (as a string) of the choosen boot
+target.
+
+The algorithm iterates over all boot targets defined under the
+associated device tree node and picks the one with the highest
+``priority`` (higher number have a higher priority) where the
+``remaining_attempts`` is greater than zero. A pointer to the name of
+the boot target is returned, the string should be freed via ``free()``.
+
+The behaviour can be modified with the flags paramter. The following
+flags are currently supported:
+
+* ``BOOTCHOOSER_FLAG_ATTEMPTS_KEEP``: the ``remaining_attempts``
+  counter of the choosen boot target is not changed.
+* ``BOOTCHOOSER_FLAG_ATTEMPTS_DEC``: the ``remaining_attempts``
+  counter of the choosen boot target is decremented by one.
+* ``BOOTCHOOSER_FLAG_ATTEMPTS_RESET``: the ``remaining_attempts``
+  counter of all *active* boot targets (those with ``priority > 0``)
+  are reset to their default values as defined in the immutable
+  description by ``default_attempts``.
+* ``BOOTCHOOSER_FLAG_DEACTIVATE_ON_ZERO_ATTEMPTS``: if used together
+  with ``BOOTCHOOSER_FLAG_ATTEMPTS_DEC`` and the
+  ``remaining_attempts`` counter of the choosen boot target is
+  decremented to ``0``, the boot target is deactivated for further
+  boot attempts (although *this* boot is attemped as usual). This is
+  done by setting the ``priority`` to ``0``.
+* ``BOOTCHOOSER_FLAG_VERBOSE``: increases the verbosity of the output
+
+
+Frontend
+--------
+
+The shell command ``bootchooser`` (:ref:`command_bootchooser`) can be
+used to choose and start a boot target by a shell one-liner. The
+command picks the boot target with the highest priority and calls the
+``boot`` (:ref:`command_boot`) command with the selected boot target
+as its first and only parameter.
+
+The ``bootchooser`` command implements command line paramter versions
+of the above described flags:
+
+* ``-k``: keep boot attempts
+* ``-d``: decrement boot attempts
+* ``-r``: reset boot attempts
+* ``-z``: deactivate on zero remaining attempts
+* ``-v``: verbose output
+
+Next to the standard parameters, these additional options are
+implemented:
+
+* ``-D``: dryrun - do not boot (all other functionality is active) - a
+  specified watchdog timeout will be activated.
+* ``-R``: retry - if booting fails, then chose next target, but
+  decrement its attempts. Note: if the current target has still the
+  highest priority and remaining attemts, it will be selected again.
+* ``-w <TIMEOUT_IN_SEC>``: activate watchdog - if no parameter is
+  given, the timeout from the device tree is used. A given parameter
+  overwrites the device tree default.
diff --git a/arch/sandbox/dts/sandbox.dts b/arch/sandbox/dts/sandbox.dts
index 2595aa13fa62..e2bc8f76c2e3 100644
--- a/arch/sandbox/dts/sandbox.dts
+++ b/arch/sandbox/dts/sandbox.dts
@@ -3,5 +3,88 @@
 #include "skeleton.dtsi"
 
 / {
+	aliases {
+		state = &state;
+	};
 
+	state: state {
+		magic = <0x4d433230>;
+		compatible = "barebox,state";
+		backend-type = "dtb";
+		backend = "/fd0";
+
+		bootstate {
+			system0 {
+				#address-cells = <1>;
+				#size-cells = <1>;
+
+				remaining_attempts {
+					reg = <0x0 0x4>;
+					type = "uint32";
+				};
+				priority {
+					reg = <0x4 0x4>;
+					type = "uint32";
+				};
+				ok {
+					reg = <0x8 0x4>;
+					type = "uint32";
+				};
+			};
+
+			system1 {
+				#address-cells = <1>;
+				#size-cells = <1>;
+
+				remaining_attempts {
+					reg = <0x10 0x4>;
+					type = "uint32";
+				};
+				priority {
+					reg = <0x14 0x4>;
+					type = "uint32";
+				};
+				ok {
+					reg = <0x18 0x4>;
+					type = "uint32";
+				};
+			};
+
+			factory {
+				#address-cells = <1>;
+				#size-cells = <1>;
+
+				remaining_attempts {
+					reg = <0x20 0x4>;
+					type = "uint32";
+				};
+				priority {
+					reg = <0x24 0x4>;
+					type = "uint32";
+				};
+				ok {
+					reg = <0x28 0x4>;
+					type = "uint32";
+				};
+			};
+		};
+	};
+
+	bootstate: bootstate {
+		compatible = "barebox,bootstate";
+		backend-type = "state"; // or "nv", or "efivar"
+		backend = <&state>;
+
+		system0 {
+			default_attempts = <3>;
+		};
+
+		system1 {
+			default_attempts = <3>;
+		};
+
+		factory {
+			default_attempts = <3>;
+		};
+	};
 };
diff --git a/commands/Kconfig b/commands/Kconfig
index 875c5f4f01ed..603e887b15ec 100644
--- a/commands/Kconfig
+++ b/commands/Kconfig
@@ -2189,6 +2189,11 @@ config CMD_SPD_DECODE
 	help
 	  decode spd eeprom
 
+config CMD_BOOTCHOOSER
+	tristate
+	depends on BOOTSTATE
+	prompt "bootchooser"
+
 # end Miscellaneous commands
 endmenu
 
diff --git a/commands/Makefile b/commands/Makefile
index f1b482f04934..bb3b40809af5 100644
--- a/commands/Makefile
+++ b/commands/Makefile
@@ -117,3 +117,4 @@ obj-$(CONFIG_CMD_DHRYSTONE)	+= dhrystone.o
 obj-$(CONFIG_CMD_SPD_DECODE)	+= spd_decode.o
 obj-$(CONFIG_CMD_MMC_EXTCSD)	+= mmc_extcsd.o
 obj-$(CONFIG_CMD_NAND_BITFLIP)	+= nand-bitflip.o
+obj-$(CONFIG_CMD_BOOTCHOOSER)	+= bootchooser.o
diff --git a/commands/bootchooser.c b/commands/bootchooser.c
new file mode 100644
index 000000000000..06ca5e41d527
--- /dev/null
+++ b/commands/bootchooser.c
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2012 Jan Luebbe <j.luebbe@pengutronix.de>
+ * Copyright (C) 2015 Marc Kleine-Budde <mkl@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <bootstate.h>
+#include <command.h>
+#include <common.h>
+#include <getopt.h>
+#include <malloc.h>
+#include <stdio.h>
+
+static int do_bootchooser(int argc, char *argv[])
+{
+	unsigned flags = 0, timeout = 0;
+	char *name = NULL;
+	int opt, ret;
+
+	while ((opt = getopt(argc, argv, "kdrzvDRw::")) > 0) {
+		switch (opt) {
+		case 'k':
+			flags |= BOOTCHOOSER_FLAG_ATTEMPTS_KEEP;
+			break;
+		case 'd':
+			flags |= BOOTCHOOSER_FLAG_ATTEMPTS_DEC;
+			break;
+		case 'r':
+			flags |= BOOTCHOOSER_FLAG_ATTEMPTS_RESET;
+			break;
+		case 'z':
+			flags |= BOOTCHOOSER_FLAG_DEACTIVATE_ON_ZERO_ATTEMPTS;
+			break;
+		case 'v':
+			flags |= BOOTCHOOSER_FLAG_VERBOSE;
+			break;
+		case 'D':
+			flags |= BOOTCHOOSER_FLAG_DRYRUN;
+			break;
+		case 'R':
+			flags |= BOOTCHOOSER_FLAG_RETRY_WITH_DEC;
+			break;
+		case 'w':
+			if (optarg)
+				timeout = simple_strtoul(optarg, NULL, 0);
+			else
+				flags |= BOOTCHOOSER_FLAG_WATCHDOG_TIMEOUT_FROM_STATE;
+			flags |= BOOTCHOOSER_FLAG_WATCHDOG_ENABLE;
+			break;
+		default:
+			return COMMAND_ERROR_USAGE;
+		}
+	}
+
+	if (optind < argc)
+		name = argv[optind];
+
+	if (!(flags & (BOOTCHOOSER_FLAG_ATTEMPTS_KEEP |
+		       BOOTCHOOSER_FLAG_ATTEMPTS_DEC |
+		       BOOTCHOOSER_FLAG_ATTEMPTS_RESET))) {
+		bootstate_info();
+		return 0;
+	}
+
+	if ((flags & BOOTCHOOSER_FLAG_ATTEMPTS_KEEP) &&
+	    (flags & (BOOTCHOOSER_FLAG_ATTEMPTS_DEC | BOOTCHOOSER_FLAG_ATTEMPTS_RESET)))
+		return COMMAND_ERROR_USAGE;
+
+	ret = bootstate_bootchooser(name, flags, timeout);
+
+	return ret ? COMMAND_ERROR : COMMAND_SUCCESS;
+}
+
+BAREBOX_CMD_HELP_START(bootchooser)
+BAREBOX_CMD_HELP_TEXT("Options:")
+BAREBOX_CMD_HELP_OPT ("-k","keep - boot, don't modify attempts counter")
+BAREBOX_CMD_HELP_OPT ("-d","decrement - boot, but decrement attempts counter by one")
+BAREBOX_CMD_HELP_OPT ("-r","reset - boot, but reset _all_ attempts counters to default")
+BAREBOX_CMD_HELP_OPT ("-z","deactivate chosen target on zero remaining boot attempts")
+BAREBOX_CMD_HELP_OPT ("-v","verbose output")
+BAREBOX_CMD_HELP_OPT ("-D","dryrun - do not boot, but handle watchdog and reset")
+BAREBOX_CMD_HELP_OPT ("-R","retry - boot, retry next boot target and decrement attempts")
+BAREBOX_CMD_HELP_OPT ("-w","activate watchdog, use timeout specified in <BOOTSTATE>.watchdog_timeout")
+BAREBOX_CMD_HELP_END
+
+BAREBOX_CMD_START(bootchooser)
+	.cmd = do_bootchooser,
+	BAREBOX_CMD_DESC("automatically select a boot target and boot")
+	BAREBOX_CMD_OPTS("[-kdrzvDR] -w <TIMEOUT> [BOOTSTATE]")
+	BAREBOX_CMD_GROUP(CMD_GRP_MISC)
+	BAREBOX_CMD_HELP(cmd_bootchooser_help)
+BAREBOX_CMD_END
diff --git a/common/Kconfig b/common/Kconfig
index 7c09e8c117f1..f17769661ee6 100644
--- a/common/Kconfig
+++ b/common/Kconfig
@@ -792,6 +792,14 @@ config STATE_CRYPTO
 	  See Documentation/devicetree/bindings/barebox/barebox,state.rst
 	  for more information.
 
+config BOOTSTATE
+	bool "bootstate infrastructure"
+	depends on OF_BAREBOX_DRIVERS
+	select ENVIRONMENT_VARIABLES
+	select OFTREE
+	select PARAMETER
+	select BOOTSTATE_DRV
+
 config RESET_SOURCE
 	bool "detect Reset cause"
 	depends on GLOBALVAR
diff --git a/common/Makefile b/common/Makefile
index d99ca7b7ac74..5505449874ad 100644
--- a/common/Makefile
+++ b/common/Makefile
@@ -46,6 +46,7 @@ obj-$(CONFIG_SHELL_HUSH)	+= hush.o
 obj-$(CONFIG_SHELL_SIMPLE)	+= parser.o
 obj-$(CONFIG_STATE)		+= state.o
 obj-$(CONFIG_RATP)		+= ratp.o
+obj-$(CONFIG_BOOTSTATE)		+= bootstate.o
 obj-$(CONFIG_UIMAGE)		+= image.o uimage.o
 obj-$(CONFIG_FITIMAGE)		+= image-fit.o
 obj-$(CONFIG_MENUTREE)		+= menutree.o
diff --git a/common/bootstate.c b/common/bootstate.c
new file mode 100644
index 000000000000..3dc18813064d
--- /dev/null
+++ b/common/bootstate.c
@@ -0,0 +1,781 @@
+/*
+ * Copyright (C) 2012 Jan Luebbe <j.luebbe@pengutronix.de>
+ * Copyright (C) 2015 Marc Kleine-Budde <mkl@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <bootstate.h>
+#include <common.h>
+#include <envfs.h>
+#include <environment.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <fs.h>
+#include <globalvar.h>
+#include <init.h>
+#include <ioctl.h>
+#include <libbb.h>
+#include <libfile.h>
+#include <malloc.h>
+#include <net.h>
+#include <printk.h>
+#include <state.h>
+#include <stdio.h>
+#include <watchdog.h>
+#include <xfuncs.h>
+
+#include <linux/err.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/mtd/mtd-abi.h>
+#include <linux/mtd/mtd.h>
+
+#include <asm/unaligned.h>
+
+/* list of all registered bootstate instances */
+static LIST_HEAD(bootstate_list);
+
+struct state_backend;
+
+struct bootstate {
+	struct device_d dev;
+	const char *name;
+	struct list_head list;
+	struct list_head targets;
+	struct list_head targets_unsorted;
+	struct bootstate_backend *backend;
+	bool dirty;
+};
+
+struct bootstate_backend {
+	int (*load)(struct bootstate_backend *backend, struct bootstate *bootstate);
+	int (*save)(struct bootstate_backend *backend, struct bootstate *bootstate);
+	const char *name;
+	const char *path;
+};
+
+struct bootstate_target {
+	struct list_head list;
+	struct list_head list_unsorted;
+
+	/* state */
+	unsigned int priority;
+	unsigned int remaining_attempts;
+	bool ok;
+
+	/* spec */
+	const char *name;
+	unsigned int default_attempts;
+};
+
+static void pr_target(struct bootstate *bootstate, struct bootstate_target *target)
+{
+	printf("%s: target: name=%s prio=%u, ok=%d, rem=%u, def=%u\n",
+	       bootstate->name, target->name, target->priority, target->ok,
+	       target->remaining_attempts, target->default_attempts);
+}
+
+static struct bootstate *bootstate_new(const char *name)
+{
+	struct bootstate *bootstate;
+	int ret;
+
+	bootstate = xzalloc(sizeof(*bootstate));
+	safe_strncpy(bootstate->dev.name, name, MAX_DRIVER_NAME);
+	bootstate->name = bootstate->dev.name;
+	bootstate->dev.id = DEVICE_ID_DYNAMIC;
+	INIT_LIST_HEAD(&bootstate->targets);
+	INIT_LIST_HEAD(&bootstate->targets_unsorted);
+
+	ret = register_device(&bootstate->dev);
+	if (ret) {
+		free(bootstate);
+		return ERR_PTR(ret);
+	}
+
+	list_add_tail(&bootstate->list, &bootstate_list);
+
+	return bootstate;
+}
+
+void bootstate_release(struct bootstate *bootstate)
+{
+	list_del(&bootstate->list);
+	unregister_device(&bootstate->dev);
+	free(bootstate);
+}
+
+static int bootstate_target_compare(struct list_head *a, struct list_head *b)
+{
+	struct bootstate_target *bootstate_a = list_entry(a, struct bootstate_target, list);
+	struct bootstate_target *bootstate_b = list_entry(b, struct bootstate_target, list);
+
+	/* order descending */
+	return bootstate_a->priority >= bootstate_b->priority ? -1 : 1;
+}
+
+static void bootstate_target_add(struct bootstate *bootstate, struct bootstate_target *target)
+{
+	list_del(&target->list);
+	list_add_sort(&target->list, &bootstate->targets, bootstate_target_compare);
+}
+
+static int bootstate_variable_read_u32(const struct bootstate *bootstate,
+				       const char *name, uint32_t *out_val)
+{
+	char *var;
+	int ret;
+
+	var = asprintf("%s.%s.%s", bootstate->backend->path, bootstate->name, name);
+	ret = getenv_uint(var, out_val);
+	free(var);
+
+	return ret;
+}
+
+static int bootstate_backend_variable_read_target_u32(const struct bootstate_backend *backend,
+						      const struct bootstate *bootstate,
+						      const struct bootstate_target *target,
+						      const char *name, uint32_t *out_val)
+{
+	char *var;
+	int ret;
+
+	var = asprintf("%s.%s.%s.%s", backend->path, bootstate->name,
+		       target->name, name);
+	ret = getenv_uint(var, out_val);
+	free(var);
+
+	return ret;
+}
+
+static int bootstate_backend_variable_write_target_u32(const struct bootstate_backend *backend,
+						       const struct bootstate *bootstate,
+						       const struct bootstate_target *target,
+						       const char *name, uint32_t in_val)
+{
+	char *var;
+	char *val;
+	int ret;
+
+	var = asprintf("%s.%s.%s.%s", backend->path, bootstate->name,
+		       target->name, name);
+	val = asprintf("%d", in_val);
+	ret = setenv(var, val);
+	free(val);
+	free(var);
+
+	return ret;
+}
+
+static int bootstate_variable_nv_init_u32(const struct bootstate_backend *backend,
+					  const struct bootstate *bootstate,
+					  const struct bootstate_target *target,
+					  const char *name)
+{
+	char *var;
+	int ret;
+
+	var = asprintf("%s.%s.%s", bootstate->name, target->name, name);
+	ret = nvvar_add(var, "0");
+	free(var);
+
+	return ret;
+}
+
+static struct bootstate_target *bootstate_target_find(const struct bootstate *bootstate,
+						      const char *name)
+{
+	struct bootstate_target *target;
+
+	list_for_each_entry(target, &bootstate->targets, list) {
+		if (!strcmp(target->name, name))
+			return target;
+	}
+
+	return ERR_PTR(-ENOENT);
+}
+
+static int bootstate_target_from_node(struct bootstate *bootstate, const struct device_node *node, bool create)
+{
+	struct bootstate_target *target;
+	char *name, *indexs;
+	int ret;
+
+	name = xstrdup(node->name);
+	indexs = strchr(name, '@');
+	if (indexs)
+		*indexs++ = 0;
+
+	if (create) {
+		/* create*/
+		target = xzalloc(sizeof(*target));
+
+		target->name = xstrdup(name);
+		list_add_tail(&target->list, &bootstate->targets);
+		list_add_tail(&target->list_unsorted,
+			      &bootstate->targets_unsorted);
+	} else {
+		target = bootstate_target_find(bootstate, name);
+		if (IS_ERR(target)) {
+			int ret = PTR_ERR(target);
+			pr_err("no such boot target: %s: %s\n",
+			       name, strerror(-ret));
+			return ret;
+		}
+	}
+
+	/* init */
+	ret = of_property_read_u32(node, "default_attempts",
+				   &target->default_attempts);
+	if (ret)
+		return ret;
+
+	free(name);
+
+	return 0;
+}
+
+static int bootstate_from_node(struct bootstate *bootstate,
+			       const struct device_node *node, bool create)
+{
+	struct device_node *child;
+	int ret;
+
+	for_each_child_of_node(node, child) {
+		ret = bootstate_target_from_node(bootstate, child, create);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int bootstate_backend_load_one(const struct bootstate_backend *backend,
+				      const struct bootstate *bootstate,
+				      struct bootstate_target *target)
+{
+	uint32_t tmp;
+	int ret;
+
+	ret = bootstate_backend_variable_read_target_u32(backend, bootstate, target,
+							 "remaining_attempts",
+							 &target->remaining_attempts);
+	if (ret)
+		return ret;
+
+	ret = bootstate_backend_variable_read_target_u32(backend, bootstate, target,
+							 "priority", &target->priority);
+	if (ret)
+		return ret;
+
+	ret = bootstate_backend_variable_read_target_u32(backend, bootstate, target,
+							 "ok", &tmp);
+	if (ret)
+		return ret;
+
+	target->ok = !!tmp;
+
+	return ret;
+}
+
+static int bootstate_backend_load(struct bootstate_backend *backend,
+				  struct bootstate *bootstate)
+{
+	struct bootstate_target *target;
+	int ret;
+
+	list_for_each_entry(target, &bootstate->targets_unsorted, list_unsorted) {
+		ret = bootstate_backend_load_one(backend, bootstate, target);
+		if (ret)
+			return ret;
+		bootstate_target_add(bootstate, target);
+	}
+
+	return 0;
+}
+
+static int bootstate_backend_save_one(const struct bootstate_backend *backend,
+				      const struct bootstate *bootstate,
+				      struct bootstate_target *target)
+{
+	int ret;
+
+	ret = bootstate_backend_variable_write_target_u32(backend, bootstate, target,
+							  "remaining_attempts",
+							  target->remaining_attempts);
+	if (ret)
+		return ret;
+
+	ret = bootstate_backend_variable_write_target_u32(backend, bootstate, target,
+							  "priority", target->priority);
+	if (ret)
+		return ret;
+
+	ret = bootstate_backend_variable_write_target_u32(backend, bootstate, target,
+							  "ok", target->ok);
+	if (ret)
+		return ret;
+
+	return 0;
+}
+
+static int bootstate_backend_save(const struct bootstate_backend *backend,
+				  const struct bootstate *bootstate)
+{
+	struct bootstate_target *target;
+	int ret;
+
+	list_for_each_entry(target, &bootstate->targets, list) {
+		ret = bootstate_backend_save_one(backend, bootstate, target);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int bootstate_backend_nv_init_one(const struct bootstate_backend *backend,
+					 const struct bootstate *bootstate,
+					 struct bootstate_target *target)
+{
+	int ret;
+
+	ret = bootstate_variable_nv_init_u32(backend, bootstate, target,
+					     "remaining_attempts");
+	if (ret)
+		return ret;
+
+	ret = bootstate_variable_nv_init_u32(backend, bootstate, target,
+					     "priority");
+	if (ret)
+		return ret;
+
+	ret = bootstate_variable_nv_init_u32(backend, bootstate, target,
+					     "ok");
+	if (ret)
+		return ret;
+
+	return 0;
+}
+
+static int bootstate_backend_nv_init(struct bootstate_backend *backend,
+				     struct bootstate *bootstate)
+{
+	struct bootstate_target *target;
+	int ret;
+
+	list_for_each_entry(target, &bootstate->targets_unsorted, list_unsorted) {
+		ret = bootstate_backend_nv_init_one(backend, bootstate, target);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int bootstate_backend_nv_save(struct bootstate_backend *backend,
+				     struct bootstate *bootstate)
+{
+	int ret;
+
+	ret = bootstate_backend_save(backend, bootstate);
+	if (ret)
+		return ret;
+
+	return envfs_save(NULL, NULL, 0);
+}
+
+static int bootstate_backend_nv_load(struct bootstate_backend *backend,
+				     struct bootstate *bootstate)
+{
+	return bootstate_backend_load(backend, bootstate);
+}
+
+struct bootstate_backend_nv {
+	struct bootstate_backend backend;
+};
+
+int bootstate_backend_nv(struct bootstate *bootstate)
+{
+	struct bootstate_backend_nv *backend_nv;
+	struct bootstate_backend *backend;
+
+	if (bootstate->backend)
+		return -EBUSY;
+
+	backend_nv = xzalloc(sizeof(*backend_nv));
+	backend = &backend_nv->backend;
+
+	backend->load = bootstate_backend_nv_load;
+	backend->save = bootstate_backend_nv_save;
+	backend->name = "nv";
+	backend->path = "nv";
+
+	bootstate->backend = backend;
+
+	return bootstate_backend_nv_init(backend, bootstate);
+}
+
+struct bootstate_backend_state {
+	struct bootstate_backend backend;
+	struct state *state;
+};
+
+static int bootstate_backend_state_save(struct bootstate_backend *backend,
+					struct bootstate *bootstate)
+{
+	struct bootstate_backend_state *backend_state =
+		container_of(backend, struct bootstate_backend_state, backend);
+	int ret;
+
+	ret = bootstate_backend_save(backend, bootstate);
+	if (ret)
+		return ret;
+
+	return state_save(backend_state->state);
+}
+
+static int bootstate_backend_state_load(struct bootstate_backend *backend,
+					struct bootstate *bootstate)
+{
+	return bootstate_backend_load(backend, bootstate);
+}
+
+int bootstate_backend_state(struct bootstate *bootstate, const struct device_node *node)
+{
+	struct bootstate_backend_state *backend_state;
+	struct bootstate_backend *backend;
+	const struct device_node *state_node;
+	struct state *state;
+
+	if (bootstate->backend)
+		return -EBUSY;
+
+	state_node = of_parse_phandle(node, "backend", 0);
+	if (!state_node)
+		return -EINVAL;
+
+	state = state_by_node(state_node);
+	if (!state)
+		return -EPROBE_DEFER;
+
+	backend_state = xzalloc(sizeof(*backend_state));
+	backend_state->state = state;
+
+	backend = &backend_state->backend;
+	backend->load = bootstate_backend_state_load;
+	backend->save = bootstate_backend_state_save;
+	backend->name = "state";
+
+	bootstate->backend = backend;
+
+	return state_get_name(backend_state->state, &backend->path);
+}
+
+/*
+ * bootstate_new_from_node - create a new bootstate instance from a device_node
+ *
+ * @name	The name of the new bootstate instance
+ * @node	The device_node describing the new bootstate instance
+ */
+struct bootstate *bootstate_new_from_node(const char *name, const struct device_node *node)
+{
+	struct bootstate *bootstate;
+	int ret;
+
+	pr_debug("%s: node=%s, name=%s\n", __func__, node->full_name, name);
+
+	bootstate = bootstate_new(name);
+	if (!bootstate)
+		return ERR_PTR(-EINVAL);
+
+	ret = bootstate_from_node(bootstate, node, true);
+	if (ret) {
+		bootstate_release(bootstate);
+		return ERR_PTR(ret);
+	}
+
+	return bootstate;
+}
+
+/*
+ * bootstate_by_name - find a bootstate instance by name
+ *
+ * @name	The name of the state instance
+ */
+struct bootstate *bootstate_by_name(const char *name)
+{
+	struct bootstate *bs;
+
+	list_for_each_entry(bs, &bootstate_list, list) {
+		if (!strcmp(name, bs->name))
+			return bs;
+	}
+
+	return NULL;
+}
+
+/*
+ * bootstate_load - load a bootstate from the backing store
+ *
+ * @bootstate	The state instance to load
+ */
+static int bootstate_load(struct bootstate *bootstate)
+{
+	int ret;
+
+	if (!bootstate->backend)
+		return -ENOSYS;
+
+	ret = bootstate->backend->load(bootstate->backend, bootstate);
+	if (ret)
+		bootstate->dirty = 1;
+	else
+		bootstate->dirty = 0;
+
+	return ret;
+}
+
+/*
+ * bootstate_save - save a bootstate to the backing store
+ *
+ * @bootstate	The bootstate instance to save
+ */
+static int bootstate_save(struct bootstate *bootstate)
+{
+	int ret;
+
+	if (!bootstate->dirty)
+		return 0;
+
+	if (!bootstate->backend)
+		return -ENOSYS;
+
+	ret = bootstate->backend->save(bootstate->backend, bootstate);
+	if (ret)
+		return ret;
+
+	bootstate->dirty = 0;
+
+	return 0;
+}
+
+void bootstate_info(void)
+{
+	struct bootstate *bootstate;
+
+	printf("registered bootstate instances:\n");
+
+	list_for_each_entry(bootstate, &bootstate_list, list) {
+		printf("%-20s ", bootstate->name);
+		printf("(backend: %s, path: %s)\n",
+		       bootstate->backend->name, bootstate->backend->path);
+	}
+}
+
+#define __BF(arg) [__BOOTCHOOSER_FLAG_##arg##_SHIFT] = __stringify(arg)
+
+static const char * const bootstate_flags_str[] = {
+	__BF(ATTEMPTS_KEEP),
+	__BF(ATTEMPTS_DEC),
+	__BF(ATTEMPTS_RESET),
+	__BF(DEACTIVATE_ON_ZERO_ATTEMPTS),
+	__BF(VERBOSE),
+	__BF(DRYRUN),
+	__BF(RETRY_WITH_DEC),
+	__BF(WATCHDOG_ENABLE),
+	__BF(WATCHDOG_TIMEOUT_FROM_STATE),
+};
+
+#undef __BF
+
+#define pr(verbose, format, args...) \
+	({ \
+		(verbose) ? pr_info((format), ##args) : 0; \
+	})
+
+void _pr_flags(struct bootstate *bootstate, unsigned flags)
+{
+	int i;
+
+	pr_info("%s: flags=0x%08x\n", bootstate->name, flags);
+
+	for (i = 0; i < ARRAY_SIZE(bootstate_flags_str); i++) {
+		if (flags & (1 << i))
+			pr_info("%s: -> %s\n", bootstate->name,
+				bootstate_flags_str[i]);
+	}
+}
+
+#define pr_flags(verbose, bootstate, flags) \
+	({ \
+		(verbose) ? _pr_flags(bootstate, flags) : 0; \
+	})
+
+/*
+ * bootstate_get_target - create a new state instance from a device_node
+ *
+ * @bootstate	the bootstate instance to work in
+ * @flags	supported flags:
+ *		BOOTCHOOSER_FLAG_VERBOSE
+ *		BOOTCHOOSER_FLAG_ATTEMPTS_KEEP
+ *		BOOTCHOOSER_FLAG_ATTEMPTS_DEC
+ *		BOOTCHOOSER_FLAG_ATTEMPTS_RESET
+ *		BOOTCHOOSER_FLAG_DEACTIVATE_ON_ZERO_ATTEMPTS
+ * @target_out	a string to the choosen boot target is returned via
+ *		this paramater
+ */
+int bootstate_get_target(struct bootstate *bootstate, unsigned flags, char **target_out)
+{
+	struct bootstate_target *target;
+	int ret;
+	bool found = false;
+	bool v = flags & BOOTCHOOSER_FLAG_VERBOSE;
+
+	pr_flags(v, bootstate, flags);
+
+	ret = bootstate_load(bootstate);
+	if (ret)
+		return ret;
+
+	if (flags & BOOTCHOOSER_FLAG_ATTEMPTS_RESET) {
+		list_for_each_entry(target, &bootstate->targets, list) {
+			if (target->priority ==  0)
+				continue;
+
+			target->remaining_attempts = target->default_attempts;
+			bootstate->dirty = true;
+
+			pr(v, "%s: target: name=%s setting rem to %d due to %s\n",
+			   bootstate->name, target->name, target->default_attempts,
+			   bootstate_flags_str[__BOOTCHOOSER_FLAG_ATTEMPTS_RESET_SHIFT]);
+		}
+		pr(v, "%s: --------\n", bootstate->name);
+	}
+
+	list_for_each_entry(target, &bootstate->targets, list) {
+		pr_target(bootstate, target);
+
+		if (found)
+			continue;
+
+		if (target->priority == 0) {
+			pr(v, "%s: name=%s prio=%d - trying next\n",
+			   bootstate->name, target->name, target->priority);
+			continue;
+		}
+
+		if (target->remaining_attempts == 0) {
+			pr(v, "%s: name=%s remaining attempts == 0 - trying next\n",
+			   bootstate->name, target->name);
+			continue;
+		}
+
+		if (flags & BOOTCHOOSER_FLAG_ATTEMPTS_DEC) {
+			bootstate->dirty = true;
+			target->remaining_attempts--;
+
+			pr(v, "%s: name=%s decrementing remaining_attempts to %d due to %s\n",
+			   bootstate->name, target->name,
+			   target->remaining_attempts,
+			   bootstate_flags_str[__BOOTCHOOSER_FLAG_ATTEMPTS_DEC_SHIFT]);
+
+			if ((target->remaining_attempts == 0) &&
+			    (flags & BOOTCHOOSER_FLAG_DEACTIVATE_ON_ZERO_ATTEMPTS)) {
+				target->priority = 0;
+
+				pr(v, "%s: name=%s deactivating target (setting priority = 0) due to %s\n",
+				   bootstate->name, target->name,
+				   bootstate_flags_str[__BOOTCHOOSER_FLAG_DEACTIVATE_ON_ZERO_ATTEMPTS_SHIFT]);
+			}
+		}
+
+		found = true;
+		*target_out = strdup(target->name);
+		pr_debug("%s: selected target '%s'\n", __func__, target->name);
+		if (!v)
+			goto out;
+
+		pr(v, "%s: --- other bootsources ---\n", bootstate->name);
+	}
+
+ out:
+	bootstate_save(bootstate);
+
+	if (!found)
+		return -ENOENT;
+
+	return 0;
+}
+
+int bootstate_bootchooser(char *name, unsigned flags, unsigned timeout)
+{
+	struct bootstate *bootstate;
+	bool v = flags & BOOTCHOOSER_FLAG_VERBOSE;
+	char *target;
+	int ret;
+
+	if (!name)
+		name = "bootstate";
+
+	bootstate = bootstate_by_name(name);
+	if (!bootstate) {
+		pr_err("Bootstate '%s' not found.\n", name);
+		return -ENODEV;
+	}
+
+	if (flags & BOOTCHOOSER_FLAG_WATCHDOG_ENABLE) {
+		if (flags & BOOTCHOOSER_FLAG_WATCHDOG_TIMEOUT_FROM_STATE) {
+			ret = bootstate_variable_read_u32(bootstate, "watchdog_timeout",
+							  &timeout);
+			if (ret)
+				return ret;
+		}
+
+		if (timeout != 0) {
+			pr(v, "%s: starting watchdog with timeout=%ds\n",
+			   __func__, timeout);
+
+			ret = watchdog_set_timeout(timeout);
+			if (ret)
+				return ret;
+		}
+	}
+
+	while (true) {
+		char *cmd;
+
+		ret = bootstate_get_target(bootstate, flags, &target);
+		if (ret)
+			return ret;
+
+		cmd = asprintf("boot %s", target);
+		free(target);
+		pr_info("%srunning: %s...\n",
+			flags & BOOTCHOOSER_FLAG_DRYRUN ? "not " : "", cmd);
+		if (!(flags & BOOTCHOOSER_FLAG_DRYRUN))
+			ret = run_command(cmd);
+		free(cmd);
+
+		if (flags & BOOTCHOOSER_FLAG_RETRY_WITH_DEC) {
+			flags |= BOOTCHOOSER_FLAG_ATTEMPTS_DEC;
+			flags &= ~(BOOTCHOOSER_FLAG_ATTEMPTS_RESET |
+				   BOOTCHOOSER_FLAG_ATTEMPTS_KEEP);
+			continue;
+		}
+
+		return ret;
+	}
+
+	return -ENOENT;
+}
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 7a5b14697efd..2459051e1db1 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -19,4 +19,9 @@ config STATE_DRV
 	tristate "state driver"
 	depends on STATE
 
+config BOOTSTATE_DRV
+	tristate "bootstate driver"
+	depends on BOOTSTATE
+	depends on STATE
+
 endmenu
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index 487e4b8ba2e5..603e14ebb5de 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -5,3 +5,4 @@
 obj-$(CONFIG_JTAG)		+= jtag.o
 obj-$(CONFIG_SRAM)		+= sram.o
 obj-$(CONFIG_STATE_DRV)		+= state.o
+obj-$(CONFIG_BOOTSTATE_DRV)	+= bootstate.o
diff --git a/drivers/misc/bootstate.c b/drivers/misc/bootstate.c
new file mode 100644
index 000000000000..3ec9b8fda86b
--- /dev/null
+++ b/drivers/misc/bootstate.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2013 Sascha Hauer <s.hauer@pengutronix.de>
+ * Copyright (C) 2015 Marc Kleine-Budde <mkl@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <bootstate.h>
+#include <driver.h>
+#include <init.h>
+#include <malloc.h>
+#include <of.h>
+#include <printk.h>
+#include <string.h>
+
+#include <linux/err.h>
+
+static int bootstate_probe(struct device_d *dev)
+{
+	struct device_node *np = dev->device_node;
+	struct bootstate *bootstate;
+	const char *alias;
+	const char *backend_type = NULL;
+	int ret;
+
+	if (!np)
+		return -EINVAL;
+
+	alias = of_alias_get(np);
+	if (!alias)
+		alias = "bootstate";
+
+	bootstate = bootstate_new_from_node(alias, np);
+	if (IS_ERR(bootstate))
+		return PTR_ERR(bootstate);
+
+	of_property_read_string(np, "backend-type", &backend_type);
+	if (!strcmp(backend_type, "state")) {
+		ret = bootstate_backend_state(bootstate, np);
+	} else if (!strcmp(backend_type, "nv")) {
+		ret = bootstate_backend_nv(bootstate);
+	} else {
+		dev_warn(dev, "invalid backend type: %s\n", backend_type);
+		ret = -ENODEV;
+		goto out_release;
+	}
+
+	if (ret)
+		goto out_release;
+
+	return 0;
+
+ out_release:
+	bootstate_release(bootstate);
+	return ret;
+}
+
+static __maybe_unused struct of_device_id bootstate_ids[] = {
+	{
+		.compatible = "barebox,bootstate",
+	}, {
+		/* sentinel */
+	}
+};
+
+static struct driver_d bootstate_driver = {
+	.name = "bootstate",
+	.probe = bootstate_probe,
+	.of_compatible = DRV_OF_COMPAT(bootstate_ids),
+};
+device_platform_driver(bootstate_driver);
diff --git a/include/bootstate.h b/include/bootstate.h
new file mode 100644
index 000000000000..22631c902f60
--- /dev/null
+++ b/include/bootstate.h
@@ -0,0 +1,39 @@
+#ifndef __BOOTSTATE_H
+#define __BOOTSTATE_H
+
+#include <of.h>
+
+struct bootstate *bootstate_new_from_node(const char *name, const struct device_node *node);
+struct bootstate *bootstate_find_by_name(const char *name);
+struct bootstate *bootstate_by_name(const char *name);
+void bootstate_release(struct bootstate *bootstate);
+void bootstate_info(void);
+int bootstate_backend_nv(struct bootstate *bootstate);
+int bootstate_backend_state(struct bootstate *bootstate, const struct device_node *node);
+
+enum {
+	__BOOTCHOOSER_FLAG_ATTEMPTS_KEEP_SHIFT,
+	__BOOTCHOOSER_FLAG_ATTEMPTS_DEC_SHIFT,
+	__BOOTCHOOSER_FLAG_ATTEMPTS_RESET_SHIFT,
+	__BOOTCHOOSER_FLAG_DEACTIVATE_ON_ZERO_ATTEMPTS_SHIFT,
+	__BOOTCHOOSER_FLAG_VERBOSE_SHIFT,
+	__BOOTCHOOSER_FLAG_DRYRUN_SHIFT,
+	__BOOTCHOOSER_FLAG_RETRY_WITH_DEC_SHIFT,
+	__BOOTCHOOSER_FLAG_WATCHDOG_ENABLE_SHIFT,
+	__BOOTCHOOSER_FLAG_WATCHDOG_TIMEOUT_FROM_STATE_SHIFT,
+};
+
+#define BOOTCHOOSER_FLAG_ATTEMPTS_KEEP (1 << __BOOTCHOOSER_FLAG_ATTEMPTS_KEEP_SHIFT)
+#define BOOTCHOOSER_FLAG_ATTEMPTS_DEC (1 << __BOOTCHOOSER_FLAG_ATTEMPTS_DEC_SHIFT)
+#define BOOTCHOOSER_FLAG_ATTEMPTS_RESET (1 << __BOOTCHOOSER_FLAG_ATTEMPTS_RESET_SHIFT)
+#define BOOTCHOOSER_FLAG_DEACTIVATE_ON_ZERO_ATTEMPTS (1 << __BOOTCHOOSER_FLAG_DEACTIVATE_ON_ZERO_ATTEMPTS_SHIFT)
+#define BOOTCHOOSER_FLAG_VERBOSE (1 << __BOOTCHOOSER_FLAG_VERBOSE_SHIFT)
+#define BOOTCHOOSER_FLAG_DRYRUN (1 << __BOOTCHOOSER_FLAG_DRYRUN_SHIFT)
+#define BOOTCHOOSER_FLAG_RETRY_WITH_DEC (1 << __BOOTCHOOSER_FLAG_RETRY_WITH_DEC_SHIFT)
+#define BOOTCHOOSER_FLAG_WATCHDOG_ENABLE (1 << __BOOTCHOOSER_FLAG_WATCHDOG_ENABLE_SHIFT)
+#define BOOTCHOOSER_FLAG_WATCHDOG_TIMEOUT_FROM_STATE (1 << __BOOTCHOOSER_FLAG_WATCHDOG_TIMEOUT_FROM_STATE_SHIFT)
+
+int bootstate_get_target(struct bootstate *bootstate, unsigned flags, char **target_out);
+int bootstate_bootchooser(char *name, unsigned flags, unsigned watchdog_timeout_s);
+
+#endif /* __BOOTSTATE_H */