diff --git a/Makefile.dtc b/Makefile.dtc
index bf19564..b75da69 100644
--- a/Makefile.dtc
+++ b/Makefile.dtc
@@ -13,7 +13,12 @@ DTC_SRCS = \
 	srcpos.c \
 	treesource.c \
 	util.c \
-	schemas/schema.c
+	schemas/mmio-bus.c \
+	schemas/schema.c \
+	schemas/clock/clock.c \
+	schemas/gpio/gpio.c \
+	schemas/i2c/i2c.c \
+	schemas/interrupt-controller/interrupts.c \
 
 DTC_GEN_SRCS = dtc-lexer.lex.c dtc-parser.tab.c dtss-lexer.lex.c dtss-parser.tab.c
 DTC_OBJS = $(DTC_SRCS:%.c=%.o) $(DTC_GEN_SRCS:%.c=%.o)
diff --git a/schemas/clock/clock.c b/schemas/clock/clock.c
new file mode 100644
index 0000000..d22b759
--- /dev/null
+++ b/schemas/clock/clock.c
@@ -0,0 +1,77 @@
+#include "dtc.h"
+#include "schema.h"
+
+static void clocks_check_names(struct node *root, struct node *node,
+			       struct property *names, bool optional)
+{
+	const char *name = NULL;
+	struct property *clocks, *clock_names;
+
+	clocks = require_property(node, "clocks");
+	clock_names = require_property(node, "clock-names");
+
+	if (!clocks || !clock_names)
+		return;
+
+	for_each_propval_string(names, name) {
+		struct of_phandle_args args;
+		int ret;
+
+		ret = propval_match_string(clock_names, name);
+		if (ret < 0) {
+			if (optional)
+				continue;
+
+			pr_err("clock '%s' not specified in node '%s'\n",
+				name, node->fullpath);
+			continue;
+		}
+
+		ret = propval_parse_phandle_with_args(root, clocks,
+							"#clock-cells", ret,
+							&args);
+		if (ret < 0)
+			pr_err("failed to parse specifier of clock '%s' in node '%s'\n",
+				name, node->fullpath);
+	}
+}
+
+static void clocks_check_count(struct node *root, struct node *node,
+			       struct property *count_prop)
+{
+	struct property *clocks;
+	cell_t count = propval_cell(count_prop);
+	int ret;
+
+	clocks = require_property(node, "clocks");
+	if (!clocks)
+		return;
+
+	ret = propval_count_phandle_with_args(root, clocks, "#clock-cells");
+	if (ret < 0)
+		pr_err("failed to parse clocks property\n");
+	else if (ret < count)
+		pr_err("not enough clock specifiers (expected %u, got %d)\n",
+			count, ret);
+}
+
+static void generic_checkfn_clocks(const struct generic_schema *schema,
+				   struct node *root, struct node *node,
+				   struct node *params, bool required)
+{
+	struct property *prop;
+
+	if (!params) {
+		pr_err("schema clocks requires arguments\n");
+		return;
+	}
+
+	prop = get_property(params, "names");
+	if (prop)
+		clocks_check_names(root, node, prop, !required);
+
+	prop = get_property(params, "count");
+	if (prop)
+		clocks_check_count(root, node, prop);
+}
+GENERIC_SCHEMA("clocks", clocks);
diff --git a/schemas/gpio/gpio.c b/schemas/gpio/gpio.c
new file mode 100644
index 0000000..9100c95
--- /dev/null
+++ b/schemas/gpio/gpio.c
@@ -0,0 +1,93 @@
+#include "schema.h"
+
+static void check_gpios_named(const struct generic_schema *schema,
+			      struct node *root, struct node *node,
+			      struct node *params, bool required,
+			      const char *prop_name)
+{
+	struct property *prop;
+	cell_t count;
+	int ret;
+	int i;
+
+	ret = schema_get_param_cell(params, "count", &count);
+	if (ret < 0) {
+		schema_err(schema, "missing schema argument: 'count'\n");
+		return;
+	}
+
+	if (required)
+		prop = require_property(node, prop_name);
+	else
+		prop = get_property(node, prop_name);
+	if (!prop)
+		return;
+
+	for (i = 0; i < count; ++i) {
+		struct of_phandle_args args;
+
+		ret = propval_parse_phandle_with_args(root, prop,
+						"#gpio-cells", i, &args);
+		if (ret < 0)
+			pr_err("failed to parse gpio specifier %d in '%s' property of node '%s'\n",
+				i, prop_name, node->fullpath);
+	}
+}
+
+static void generic_checkfn_gpios(const struct generic_schema *schema,
+				  struct node *root, struct node *node,
+				  struct node *params, bool required)
+{
+	check_gpios_named(schema, root, node, params, required, "gpios");
+}
+GENERIC_SCHEMA("gpios", gpios);
+
+static void generic_checkfn_named_gpios(const struct generic_schema *schema,
+					struct node *root, struct node *node,
+					struct node *params, bool required)
+{
+	struct property *prop;
+	const char *name;
+
+	prop = schema_get_param(params, "name");
+	if (!prop) {
+		schema_err(schema, "missing schema argument: 'name'\n");
+		return;
+	}
+
+	name = propval_next_string(prop, NULL);
+
+	check_gpios_named(schema, root, node, params, required, name);
+}
+GENERIC_SCHEMA("named-gpios", named_gpios);
+
+static void generic_checkfn_gpio_provider(const struct generic_schema *schema,
+					  struct node *root, struct node *node,
+					  struct node *params, bool required)
+{
+	struct property *prop;
+	cell_t cells, val;
+	int ret;
+
+	ret = schema_get_param_cell(params, "cells", &cells);
+	if (ret < 0) {
+		schema_err(schema, "missing schema argument: 'cells'\n");
+		return;
+	}
+
+	prop = require_property(node, "gpio-controller");
+	if (!prop)
+		return;
+
+	prop = require_property(node, "#gpio-cells");
+	if (!prop)
+		return;
+
+	val = propval_cell(prop);
+	if (val != cells) {
+		pr_err("wrong value of #interrupt-cells property in node '%s' (expected %u, got %u)\n",
+			node->fullpath, cells, val);
+		return;
+	}
+}
+GENERIC_SCHEMA("gpio-provider", gpio_provider);
diff --git a/schemas/i2c/i2c.c b/schemas/i2c/i2c.c
new file mode 100644
index 0000000..ba8fd34
--- /dev/null
+++ b/schemas/i2c/i2c.c
@@ -0,0 +1,42 @@
+#include "schema.h"
+
+static void generic_checkfn_i2c_device(const struct generic_schema *schema,
+				       struct node *root, struct node *node,
+				       struct node *params, bool required)
+{
+	struct property *prop;
+	prop = require_property(node, "reg");
+	if (!prop)
+		return;
+
+	if (prop->val.len != sizeof(cell_t))
+		node_err(node, "i2c-bus expects reg property to be a single cell\n");
+
+	/* TODO: Check if parent device is an i2c bus. */
+}
+GENERIC_SCHEMA("i2c-device", i2c_device);
+
+static void generic_checkfn_i2c_bus(const struct generic_schema *schema,
+				    struct node *root, struct node *node,
+				    struct node *params, bool required)
+{
+	struct property *prop;
+	cell_t val;
+
+	prop = require_property(node, "#address-cells");
+	if (!prop)
+		return;
+
+	val = propval_cell(prop);
+	if (val != 1)
+		node_err(node, "i2c-bus requires #address-cells == 1\n");
+
+	prop = require_property(node, "#size-cells");
+	if (!prop)
+		return;
+
+	val = propval_cell(prop);
+	if (val != 0)
+		node_err(node, "i2c-bus requires #size-cells == 0\n");
+}
+GENERIC_SCHEMA("i2c-bus", i2c_bus);
diff --git a/schemas/interrupt-controller/interrupts.c b/schemas/interrupt-controller/interrupts.c
new file mode 100644
index 0000000..7eda441
--- /dev/null
+++ b/schemas/interrupt-controller/interrupts.c
@@ -0,0 +1,452 @@
+#include "schema.h"
+
+/*******************************************************************************
+ * Copypasta from kernel's drivers/of/irq.c starts here.
+ * (Well, maybe with some minor changes to make it compile here.)
+ ******************************************************************************/
+
+/* Adaptation glue... */
+
+#define pr_debug(...)
+typedef cell_t __be32;
+typedef cell_t phandle;
+#define of_node_get(node)	(node)
+#define of_node_put(node)
+#define of_irq_workarounds	(0)
+#define OF_IMAP_OLDWORLD_MAC	0x00000001
+#define OF_IMAP_NO_PHANDLE	0x00000002
+#define of_irq_dflt_pic		(NULL)
+#define be32_to_cpu(val)	fdt32_to_cpu((val))
+#define be32_to_cpup(ptr)	be32_to_cpu(*(ptr))
+#define cpu_to_be32(val)	cpu_to_fdt32(val)
+#define raw_spin_lock_irqsave(...)
+#define raw_spin_unlock_irqrestore(...)
+typedef uint32_t u32;
+#define WARN_ON(x)		(x)
+#define of_irq_parse_oldworld(...)	(-EINVAL)
+#define of_node_full_name(x)	((x)->fullpath)
+
+static const cell_t dummy = 0;
+
+static const void *of_get_property(struct node *np, const char *name,
+				     int *lenp)
+{
+	struct property *prop;
+
+	prop = get_property(np, name);
+	if(!prop)
+		return NULL;
+
+	if (lenp)
+		*lenp = prop->val.len;
+
+	if (!prop->val.val)
+		return &dummy;
+
+	return prop->val.val;
+}
+
+static struct node *of_get_parent(const struct node *node)
+{
+	return node ? node->parent : NULL;
+}
+
+static int of_device_is_available(struct node *device)
+{
+	const char *status;
+	int statlen;
+
+	if (!device)
+		return 0;
+
+	status = of_get_property(device, "status", &statlen);
+	if (status == NULL)
+		return 1;
+
+	if (statlen > 0) {
+		if (!strcmp(status, "okay") || !strcmp(status, "ok"))
+			return 1;
+	}
+
+	return 0;
+}
+
+/* End of adaptation glue. */
+
+/**
+ * of_irq_find_parent - Given a device node, find its interrupt parent node
+ * @child: pointer to device node
+ *
+ * Returns a pointer to the interrupt parent node, or NULL if the interrupt
+ * parent could not be determined.
+ */
+static struct node *of_irq_find_parent(struct node *root, struct node *child)
+{
+	struct node *p;
+	const __be32 *parp;
+
+	if (!of_node_get(child))
+		return NULL;
+
+	do {
+		parp = of_get_property(child, "interrupt-parent", NULL);
+		if (parp == NULL)
+			p = of_get_parent(child);
+		else {
+			if (of_irq_workarounds & OF_IMAP_NO_PHANDLE)
+				p = of_node_get(of_irq_dflt_pic);
+			else
+				p = get_node_by_phandle(root,
+							be32_to_cpup(parp));
+		}
+		of_node_put(child);
+		child = p;
+	} while (p && of_get_property(p, "#interrupt-cells", NULL) == NULL);
+
+	return p;
+}
+
+/**
+ * of_irq_parse_raw - Low level interrupt tree parsing
+ * @parent:	the device interrupt parent
+ * @addr:	address specifier (start of "reg" property of the device) in be32 format
+ * @out_irq:	structure of_irq updated by this function
+ *
+ * Returns 0 on success and a negative number on error
+ *
+ * This function is a low-level interrupt tree walking function. It
+ * can be used to do a partial walk with synthetized reg and interrupts
+ * properties, for example when resolving PCI interrupts when no device
+ * node exist for the parent. It takes an interrupt specifier structure as
+ * input, walks the tree looking for any interrupt-map properties, translates
+ * the specifier for each map, and then returns the translated map.
+ */
+static int of_irq_parse_raw(struct node *root,
+			    const __be32 *addr, struct of_phandle_args *out_irq)
+{
+	struct node *ipar, *tnode, *old = NULL, *newpar = NULL;
+	__be32 initial_match_array[MAX_PHANDLE_ARGS];
+	const __be32 *match_array = initial_match_array;
+	const __be32 *tmp, *imap, *imask, dummy_imask[] = { [0 ... MAX_PHANDLE_ARGS] = ~0 };
+	u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0;
+	int imaplen, match, i;
+
+#ifdef DEBUG
+	of_print_phandle_args("of_irq_parse_raw: ", out_irq);
+#endif
+
+	ipar = of_node_get(out_irq->np);
+
+	/* First get the #interrupt-cells property of the current cursor
+	 * that tells us how to interpret the passed-in intspec. If there
+	 * is none, we are nice and just walk up the tree
+	 */
+	do {
+		tmp = of_get_property(ipar, "#interrupt-cells", NULL);
+		if (tmp != NULL) {
+			intsize = be32_to_cpu(*tmp);
+			break;
+		}
+		tnode = ipar;
+		ipar = of_irq_find_parent(root, ipar);
+		of_node_put(tnode);
+	} while (ipar);
+	if (ipar == NULL) {
+		pr_debug(" -> no parent found !\n");
+		goto fail;
+	}
+
+	pr_debug("of_irq_parse_raw: ipar=%s, size=%d\n", of_node_full_name(ipar), intsize);
+
+	if (out_irq->args_count != intsize)
+		return -EINVAL;
+
+	/* Look for this #address-cells. We have to implement the old linux
+	 * trick of looking for the parent here as some device-trees rely on it
+	 */
+	old = of_node_get(ipar);
+	do {
+		tmp = of_get_property(old, "#address-cells", NULL);
+		tnode = of_get_parent(old);
+		of_node_put(old);
+		old = tnode;
+	} while (old && tmp == NULL);
+	of_node_put(old);
+	old = NULL;
+	addrsize = (tmp == NULL) ? 2 : be32_to_cpu(*tmp);
+
+	pr_debug(" -> addrsize=%d\n", addrsize);
+
+	/* Range check so that the temporary buffer doesn't overflow */
+	if (WARN_ON(addrsize + intsize > MAX_PHANDLE_ARGS))
+		goto fail;
+
+	/* Precalculate the match array - this simplifies match loop */
+	for (i = 0; i < addrsize; i++)
+		initial_match_array[i] = addr ? addr[i] : 0;
+	for (i = 0; i < intsize; i++)
+		initial_match_array[addrsize + i] = cpu_to_be32(out_irq->args[i]);
+
+	/* Now start the actual "proper" walk of the interrupt tree */
+	while (ipar != NULL) {
+		/* Now check if cursor is an interrupt-controller and if it is
+		 * then we are done
+		 */
+		if (of_get_property(ipar, "interrupt-controller", NULL) !=
+				NULL) {
+			pr_debug(" -> got it !\n");
+			return 0;
+		}
+
+		/*
+		 * interrupt-map parsing does not work without a reg
+		 * property when #address-cells != 0
+		 */
+		if (addrsize && !addr) {
+			pr_debug(" -> no reg passed in when needed !\n");
+			goto fail;
+		}
+
+		/* Now look for an interrupt-map */
+		imap = of_get_property(ipar, "interrupt-map", &imaplen);
+		/* No interrupt map, check for an interrupt parent */
+		if (imap == NULL) {
+			pr_debug(" -> no map, getting parent\n");
+			newpar = of_irq_find_parent(root, ipar);
+			goto skiplevel;
+		}
+		imaplen /= sizeof(u32);
+
+		/* Look for a mask */
+		imask = of_get_property(ipar, "interrupt-map-mask", NULL);
+		if (!imask)
+			imask = dummy_imask;
+
+		/* Parse interrupt-map */
+		match = 0;
+		while (imaplen > (addrsize + intsize + 1) && !match) {
+			/* Compare specifiers */
+			match = 1;
+			for (i = 0; i < (addrsize + intsize); i++, imaplen--)
+				match &= !((match_array[i] ^ *imap++) & imask[i]);
+
+			pr_debug(" -> match=%d (imaplen=%d)\n", match, imaplen);
+
+			/* Get the interrupt parent */
+			if (of_irq_workarounds & OF_IMAP_NO_PHANDLE)
+				newpar = of_node_get(of_irq_dflt_pic);
+			else
+				newpar = get_node_by_phandle(root,
+							be32_to_cpup(imap));
+			imap++;
+			--imaplen;
+
+			/* Check if not found */
+			if (newpar == NULL) {
+				pr_debug(" -> imap parent not found !\n");
+				goto fail;
+			}
+
+			if (!of_device_is_available(newpar))
+				match = 0;
+
+			/* Get #interrupt-cells and #address-cells of new
+			 * parent
+			 */
+			tmp = of_get_property(newpar, "#interrupt-cells", NULL);
+			if (tmp == NULL) {
+				pr_debug(" -> parent lacks #interrupt-cells!\n");
+				goto fail;
+			}
+			newintsize = be32_to_cpu(*tmp);
+			tmp = of_get_property(newpar, "#address-cells", NULL);
+			newaddrsize = (tmp == NULL) ? 0 : be32_to_cpu(*tmp);
+
+			pr_debug(" -> newintsize=%d, newaddrsize=%d\n",
+			    newintsize, newaddrsize);
+
+			/* Check for malformed properties */
+			if (WARN_ON(newaddrsize + newintsize > MAX_PHANDLE_ARGS))
+				goto fail;
+			if (imaplen < (newaddrsize + newintsize))
+				goto fail;
+
+			imap += newaddrsize + newintsize;
+			imaplen -= newaddrsize + newintsize;
+
+			pr_debug(" -> imaplen=%d\n", imaplen);
+		}
+		if (!match)
+			goto fail;
+
+		/*
+		 * Successfully parsed an interrrupt-map translation; copy new
+		 * interrupt specifier into the out_irq structure
+		 */
+		out_irq->np = newpar;
+
+		match_array = imap - newaddrsize - newintsize;
+		for (i = 0; i < newintsize; i++)
+			out_irq->args[i] = be32_to_cpup(imap - newintsize + i);
+		out_irq->args_count = intsize = newintsize;
+		addrsize = newaddrsize;
+
+	skiplevel:
+		/* Iterate again with new parent */
+		pr_debug(" -> new parent: %s\n", of_node_full_name(newpar));
+		of_node_put(ipar);
+		ipar = newpar;
+		newpar = NULL;
+	}
+ fail:
+	of_node_put(ipar);
+	of_node_put(newpar);
+
+	return -EINVAL;
+}
+
+/**
+ * of_irq_parse_one - Resolve an interrupt for a device
+ * @device: the device whose interrupt is to be resolved
+ * @index: index of the interrupt to resolve
+ * @out_irq: structure of_irq filled by this function
+ *
+ * This function resolves an interrupt for a node by walking the interrupt tree,
+ * finding which interrupt controller node it is attached to, and returning the
+ * interrupt specifier that can be used to retrieve a Linux IRQ number.
+ */
+static int of_irq_parse_one(struct node *root, struct node *device,
+			    int index, struct of_phandle_args *out_irq)
+{
+	struct node *p;
+	const __be32 *intspec, *tmp, *addr;
+	u32 intsize, intlen;
+	int i, res = -EINVAL;
+
+	pr_debug("of_irq_parse_one: dev=%s, index=%d\n", of_node_full_name(device), index);
+
+	/* OldWorld mac stuff is "special", handle out of line */
+	if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
+		return of_irq_parse_oldworld(device, index, out_irq);
+
+	/* Get the reg property (if any) */
+	addr = of_get_property(device, "reg", NULL);
+
+	/* Get the interrupts property */
+	intspec = of_get_property(device, "interrupts", (int *)&intlen);
+	if (intspec == NULL) {
+		struct property *prop;
+
+		prop = get_property(device, "interrupts-extended");
+		if (!prop)
+			return -EINVAL;
+
+		/* Try the new-style interrupts-extended */
+		res = propval_parse_phandle_with_args(root, prop,
+							"#interrupt-cells",
+							index, out_irq);
+		if (res)
+			return -EINVAL;
+		return of_irq_parse_raw(root, addr, out_irq);
+	}
+	intlen /= sizeof(*intspec);
+
+	pr_debug(" intspec=%d intlen=%d\n", be32_to_cpup(intspec), intlen);
+
+	/* Look for the interrupt parent. */
+	p = of_irq_find_parent(root, device);
+	if (p == NULL)
+		return -EINVAL;
+
+	/* Get size of interrupt specifier */
+	tmp = of_get_property(p, "#interrupt-cells", NULL);
+	if (tmp == NULL)
+		goto out;
+	intsize = be32_to_cpu(*tmp);
+
+	pr_debug(" intsize=%d intlen=%d\n", intsize, intlen);
+
+	/* Check index */
+	if ((index + 1) * intsize > intlen)
+		goto out;
+
+	/* Copy intspec into irq structure */
+	intspec += index * intsize;
+	out_irq->np = p;
+	out_irq->args_count = intsize;
+	for (i = 0; i < intsize; i++)
+		out_irq->args[i] = be32_to_cpup(intspec++);
+
+	/* Check if there are any interrupt-map translations to process */
+	res = of_irq_parse_raw(root, addr, out_irq);
+ out:
+	of_node_put(p);
+	return res;
+}
+
+/*******************************************************************************
+ * Copypasta ends here.
+ ******************************************************************************/
+
+static void generic_checkfn_interrupts(const struct generic_schema *schema,
+				       struct node *root, struct node *node,
+				       struct node *params, bool required)
+{
+	struct of_phandle_args irq;
+	cell_t count;
+	int ret;
+	int i;
+
+	ret = schema_get_param_cell(params, "count", &count);
+	if (ret < 0) {
+		schema_err(schema, "missing schema argument: 'count'\n");
+		return;
+	}
+
+	if (!required
+	    && !get_property(node, "interrupts")
+	    && !get_property(node, "interrupts-extended"))
+		return;
+
+	for (i = 0; i < count; ++i) {
+		ret = of_irq_parse_one(root, node, i, &irq);
+		if (ret < 0)
+			pr_err("failed to parse interrupt entry %d of node '%s'\n",
+				i, node->fullpath);
+	}
+}
+GENERIC_SCHEMA("interrupts", interrupts);
+
+static void generic_checkfn_interrupt_controller(
+					const struct generic_schema *schema,
+					struct node *root,
+					struct node *node,
+					struct node *params,
+					bool required)
+{
+	struct property *prop;
+	cell_t cells, val;
+	int ret;
+
+	ret = schema_get_param_cell(params, "cells", &cells);
+	if (ret < 0) {
+		schema_err(schema, "missing schema argument: 'cells'\n");
+		return;
+	}
+
+	prop = require_property(node, "interrupt-controller");
+	if (!prop)
+		return;
+
+	prop = require_property(node, "#interrupt-cells");
+	if (!prop)
+		return;
+
+	val = propval_cell(prop);
+	if (val != cells) {
+		pr_err("wrong value of #interrupt-cells property in node '%s' (expected %u, got %u)\n",
+			node->fullpath, cells, val);
+		return;
+	}
+}
+GENERIC_SCHEMA("interrupt-controller", interrupt_controller);
diff --git a/schemas/mmio-bus.c b/schemas/mmio-bus.c
new file mode 100644
index 0000000..bd7888d
--- /dev/null
+++ b/schemas/mmio-bus.c
@@ -0,0 +1,97 @@
+#include "schema.h"
+
+static unsigned int get_address_cells(struct node *node)
+{
+	struct property *prop;
+
+	prop = get_property(node->parent, "#address-cells");
+	if (!prop) {
+		pr_warn("missing #address-cells property, assuming 2\n");
+		return 2;
+	}
+
+	return propval_cell(prop);
+}
+
+static unsigned int get_size_cells(struct node *node)
+{
+	struct property *prop;
+
+	prop = get_property(node->parent, "#size-cells");
+	if (!prop) {
+		pr_warn("missing #size-cells property, assuming 1\n");
+		return 1;
+	}
+
+	return propval_cell(prop);
+}
+
+static void generic_checkfn_mmio_device(const struct generic_schema *schema,
+					struct node *root, struct node *node,
+					struct node *params, bool required)
+{
+	struct property *prop;
+	cell_t count;
+	unsigned int address_cells, size_cells;
+
+	if (!params) {
+		pr_err("schema mmio-device requires arguments\n");
+		return;
+	}
+
+	prop = get_property(params, "reg-count");
+	if (!prop) {
+		pr_err("schema mmio-device requires reg-count argument\n");
+		return;
+	}
+
+	count = propval_cell(prop);
+	if (!count) {
+		pr_err("wrong number of reg entries requested\n");
+		return;
+	}
+
+	if (!node->parent) {
+		pr_err("root node can not be an mmio-device\n");
+		return;
+	}
+
+	address_cells = get_address_cells(node);
+	size_cells = get_size_cells(node);
+
+	prop = require_property(node, "reg");
+	if (!prop)
+		return;
+
+	if (prop->val.len % (address_cells + size_cells))
+		pr_err("malformed reg property - not a multiple of (#address-cells + #size-cells)\n");
+
+	if (prop->val.len < count * (address_cells + size_cells))
+		pr_err("not enough entries in reg property - expected %u\n", count);
+}
+GENERIC_SCHEMA("mmio-device", mmio_device);
+
+static void generic_checkfn_mmio_bus(const struct generic_schema *schema,
+				     struct node *root, struct node *node,
+				     struct node *params, bool required)
+{
+	struct property *prop;
+	cell_t val;
+
+	prop = require_property(node, "#address-cells");
+	if (!prop)
+		return;
+
+	val = propval_cell(prop);
+	if (val < 1)
+		pr_err("mmio-bus requires positive #address-cells value\n");
+
+	prop = require_property(node, "#size-cells");
+	if (!prop)
+		return;
+
+	val = propval_cell(prop);
+	if (val < 1)
+		pr_err("mmio-bus requires positive #size-cells value\n");
+}
+GENERIC_SCHEMA("mmio-bus", mmio_bus);
