diff --git a/device_tree.c b/device_tree.c
index 048b8e1..ca2a88d 100644
--- a/device_tree.c
+++ b/device_tree.c
@@ -4,8 +4,10 @@
  * interface.
  *
  * Copyright 2008 IBM Corporation.
+ * Copyright 2013 Xilinx Inc.
  * Authors: Jerone Young <jyoung5@us.ibm.com>
  *          Hollis Blanchard <hollisb@us.ibm.com>
+ *          Peter Crosthwaite <peter.crosthwaite@xilinx.com>
  *
  * This work is licensed under the GNU GPL license version 2 or later.
  *
@@ -126,19 +128,25 @@ static int findnode_nofail(void *fdt, const char *node_path)
     return offset;
 }
 
-int qemu_fdt_setprop(void *fdt, const char *node_path,
-                     const char *property, const void *val, int size)
+void qemu_fdt_setprop(void *fdt, const char *node_path, const char *property,
+                      const void *val, int size, Error **errp)
 {
     int r;
 
     r = fdt_setprop(fdt, findnode_nofail(fdt, node_path), property, val, size);
     if (r < 0) {
-        fprintf(stderr, "%s: Couldn't set %s/%s: %s\n", __func__, node_path,
-                property, fdt_strerror(r));
-        exit(1);
+        error_setg(errp, "%s: Couldn't set %s/%s: %s\n", __func__, node_path,
+                   property, fdt_strerror(r));
     }
+}
 
-    return r;
+void qemu_fdt_setprop_assert(void *fdt, const char *node_path,
+                             const char *property, const void *val, int size)
+{
+    Error *errp = NULL;
+
+    qemu_fdt_setprop(fdt, node_path, property, val, size, &errp);
+    assert_no_error(errp);
 }
 
 int qemu_fdt_setprop_cell(void *fdt, const char *node_path,
@@ -156,11 +164,20 @@ int qemu_fdt_setprop_cell(void *fdt, const char *node_path,
     return r;
 }
 
-int qemu_fdt_setprop_u64(void *fdt, const char *node_path,
-                         const char *property, uint64_t val)
+void qemu_fdt_setprop_u64(void *fdt, const char *node_path,
+                          const char *property, uint64_t val, Error **errp)
 {
     val = cpu_to_be64(val);
-    return qemu_fdt_setprop(fdt, node_path, property, &val, sizeof(val));
+    qemu_fdt_setprop(fdt, node_path, property, &val, sizeof(val), errp);
+}
+
+void qemu_fdt_setprop_u64_assert(void *fdt, const char *node_path,
+                                 const char *property, uint64_t val)
+{
+    Error *errp = NULL;
+
+    qemu_fdt_setprop_u64(fdt, node_path, property, val, &errp);
+    assert_no_error(errp);
 }
 
 int qemu_fdt_setprop_string(void *fdt, const char *node_path,
diff --git a/hw/arm/boot.c b/hw/arm/boot.c
index 2768b2b..9164bb9 100644
--- a/hw/arm/boot.c
+++ b/hw/arm/boot.c
@@ -233,6 +233,7 @@ static int load_dtb(hwaddr addr, const struct arm_boot_info *binfo)
     char *filename;
     int size, rc;
     uint32_t acells, scells, hival;
+    Error *errp = NULL;
 
     filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, binfo->dtb_filename);
     if (!filename) {
@@ -276,9 +277,9 @@ static int load_dtb(hwaddr addr, const struct arm_boot_info *binfo)
         goto fail;
     }
 
-    rc = qemu_fdt_setprop(fdt, "/memory", "reg", mem_reg_property,
-                          mem_reg_propsize * sizeof(uint32_t));
-    if (rc < 0) {
+    qemu_fdt_setprop(fdt, "/memory", "reg", mem_reg_property,
+                     mem_reg_propsize * sizeof(uint32_t), &errp);
+    if (errp) {
         fprintf(stderr, "couldn't set /memory/reg\n");
         goto fail;
     }
diff --git a/hw/ppc/e500.c b/hw/ppc/e500.c
index 0c2b54d..4ce5e78 100644
--- a/hw/ppc/e500.c
+++ b/hw/ppc/e500.c
@@ -111,10 +111,10 @@ static void dt_serial_create(void *fdt, unsigned long long offset,
     qemu_fdt_add_subnode(fdt, ser);
     qemu_fdt_setprop_string(fdt, ser, "device_type", "serial");
     qemu_fdt_setprop_string(fdt, ser, "compatible", "ns16550");
-    qemu_fdt_setprop_cells(fdt, ser, "reg", offset, 0x100);
+    qemu_fdt_setprop_cells_assert(fdt, ser, "reg", offset, 0x100);
     qemu_fdt_setprop_cell(fdt, ser, "cell-index", idx);
     qemu_fdt_setprop_cell(fdt, ser, "clock-frequency", 0);
-    qemu_fdt_setprop_cells(fdt, ser, "interrupts", 42, 2);
+    qemu_fdt_setprop_cells_assert(fdt, ser, "interrupts", 42, 2);
     qemu_fdt_setprop_phandle(fdt, ser, "interrupt-parent", mpic);
     qemu_fdt_setprop_string(fdt, "/aliases", alias, ser);
 
@@ -192,8 +192,8 @@ static int ppce500_load_device_tree(CPUPPCState *env,
 
     qemu_fdt_add_subnode(fdt, "/memory");
     qemu_fdt_setprop_string(fdt, "/memory", "device_type", "memory");
-    qemu_fdt_setprop(fdt, "/memory", "reg", mem_reg_property,
-                     sizeof(mem_reg_property));
+    qemu_fdt_setprop_assert(fdt, "/memory", "reg", mem_reg_property,
+                            sizeof(mem_reg_property));
 
     qemu_fdt_add_subnode(fdt, "/chosen");
     if (initrd_size) {
@@ -225,11 +225,11 @@ static int ppce500_load_device_tree(CPUPPCState *env,
         qemu_fdt_setprop_string(fdt, "/hypervisor", "compatible",
                                 "linux,kvm");
         kvmppc_get_hypercall(env, hypercall, sizeof(hypercall));
-        qemu_fdt_setprop(fdt, "/hypervisor", "hcall-instructions",
-                         hypercall, sizeof(hypercall));
+        qemu_fdt_setprop_assert(fdt, "/hypervisor", "hcall-instructions",
+                                hypercall, sizeof(hypercall));
         /* if KVM supports the idle hcall, set property indicating this */
         if (kvmppc_get_hasidle(env)) {
-            qemu_fdt_setprop(fdt, "/hypervisor", "has-idle", NULL, 0);
+            qemu_fdt_setprop_assert(fdt, "/hypervisor", "has-idle", NULL, 0);
         }
     }
 
@@ -269,8 +269,8 @@ static int ppce500_load_device_tree(CPUPPCState *env,
             qemu_fdt_setprop_string(fdt, cpu_name, "status", "disabled");
             qemu_fdt_setprop_string(fdt, cpu_name, "enable-method",
                                     "spin-table");
-            qemu_fdt_setprop_u64(fdt, cpu_name, "cpu-release-addr",
-                                 cpu_release_addr);
+            qemu_fdt_setprop_u64_assert(fdt, cpu_name, "cpu-release-addr",
+                                        cpu_release_addr);
         } else {
             qemu_fdt_setprop_string(fdt, cpu_name, "status", "okay");
         }
@@ -281,13 +281,13 @@ static int ppce500_load_device_tree(CPUPPCState *env,
     snprintf(soc, sizeof(soc), "/soc@%llx", MPC8544_CCSRBAR_BASE);
     qemu_fdt_add_subnode(fdt, soc);
     qemu_fdt_setprop_string(fdt, soc, "device_type", "soc");
-    qemu_fdt_setprop(fdt, soc, "compatible", compatible_sb,
-                     sizeof(compatible_sb));
+    qemu_fdt_setprop_assert(fdt, soc, "compatible", compatible_sb,
+                            sizeof(compatible_sb));
     qemu_fdt_setprop_cell(fdt, soc, "#address-cells", 1);
     qemu_fdt_setprop_cell(fdt, soc, "#size-cells", 1);
-    qemu_fdt_setprop_cells(fdt, soc, "ranges", 0x0,
-                           MPC8544_CCSRBAR_BASE >> 32, MPC8544_CCSRBAR_BASE,
-                           MPC8544_CCSRBAR_SIZE);
+    qemu_fdt_setprop_cells_assert(fdt, soc, "ranges", 0x0,
+                                  MPC8544_CCSRBAR_BASE >> 32,
+                                  MPC8544_CCSRBAR_BASE, MPC8544_CCSRBAR_SIZE);
     /* XXX should contain a reasonable value */
     qemu_fdt_setprop_cell(fdt, soc, "bus-frequency", 0);
 
@@ -295,14 +295,14 @@ static int ppce500_load_device_tree(CPUPPCState *env,
     qemu_fdt_add_subnode(fdt, mpic);
     qemu_fdt_setprop_string(fdt, mpic, "device_type", "open-pic");
     qemu_fdt_setprop_string(fdt, mpic, "compatible", "fsl,mpic");
-    qemu_fdt_setprop_cells(fdt, mpic, "reg", MPC8544_MPIC_REGS_OFFSET,
-                           0x40000);
+    qemu_fdt_setprop_cells_assert(fdt, mpic, "reg", MPC8544_MPIC_REGS_OFFSET,
+                                  0x40000);
     qemu_fdt_setprop_cell(fdt, mpic, "#address-cells", 0);
     qemu_fdt_setprop_cell(fdt, mpic, "#interrupt-cells", 2);
     mpic_ph = qemu_fdt_alloc_phandle(fdt);
     qemu_fdt_setprop_cell(fdt, mpic, "phandle", mpic_ph);
     qemu_fdt_setprop_cell(fdt, mpic, "linux,phandle", mpic_ph);
-    qemu_fdt_setprop(fdt, mpic, "interrupt-controller", NULL, 0);
+    qemu_fdt_setprop_assert(fdt, mpic, "interrupt-controller", NULL, 0);
 
     /*
      * We have to generate ser1 first, because Linux takes the first
@@ -318,17 +318,19 @@ static int ppce500_load_device_tree(CPUPPCState *env,
              MPC8544_UTIL_OFFSET);
     qemu_fdt_add_subnode(fdt, gutil);
     qemu_fdt_setprop_string(fdt, gutil, "compatible", "fsl,mpc8544-guts");
-    qemu_fdt_setprop_cells(fdt, gutil, "reg", MPC8544_UTIL_OFFSET, 0x1000);
-    qemu_fdt_setprop(fdt, gutil, "fsl,has-rstcr", NULL, 0);
+    qemu_fdt_setprop_cells_assert(fdt, gutil, "reg", MPC8544_UTIL_OFFSET,
+                                  0x1000);
+    qemu_fdt_setprop_assert(fdt, gutil, "fsl,has-rstcr", NULL, 0);
 
     snprintf(msi, sizeof(msi), "/%s/msi@%llx", soc, MPC8544_MSI_REGS_OFFSET);
     qemu_fdt_add_subnode(fdt, msi);
     qemu_fdt_setprop_string(fdt, msi, "compatible", "fsl,mpic-msi");
-    qemu_fdt_setprop_cells(fdt, msi, "reg", MPC8544_MSI_REGS_OFFSET, 0x200);
+    qemu_fdt_setprop_cells_assert(fdt, msi, "reg", MPC8544_MSI_REGS_OFFSET,
+                                  0x200);
     msi_ph = qemu_fdt_alloc_phandle(fdt);
-    qemu_fdt_setprop_cells(fdt, msi, "msi-available-ranges", 0x0, 0x100);
+    qemu_fdt_setprop_cells_assert(fdt, msi, "msi-available-ranges", 0x0, 0x100);
     qemu_fdt_setprop_phandle(fdt, msi, "interrupt-parent", mpic);
-    qemu_fdt_setprop_cells(fdt, msi, "interrupts",
+    qemu_fdt_setprop_cells_assert(fdt, msi, "interrupts",
         0xe0, 0x0,
         0xe1, 0x0,
         0xe2, 0x0,
@@ -345,22 +347,22 @@ static int ppce500_load_device_tree(CPUPPCState *env,
     qemu_fdt_setprop_cell(fdt, pci, "cell-index", 0);
     qemu_fdt_setprop_string(fdt, pci, "compatible", "fsl,mpc8540-pci");
     qemu_fdt_setprop_string(fdt, pci, "device_type", "pci");
-    qemu_fdt_setprop_cells(fdt, pci, "interrupt-map-mask", 0xf800, 0x0,
-                           0x0, 0x7);
+    qemu_fdt_setprop_cells_assert(fdt, pci, "interrupt-map-mask", 0xf800, 0x0,
+                                  0x0, 0x7);
     pci_map = pci_map_create(fdt, qemu_fdt_get_phandle(fdt, mpic),
                              params->pci_first_slot, params->pci_nr_slots,
                              &len);
-    qemu_fdt_setprop(fdt, pci, "interrupt-map", pci_map, len);
+    qemu_fdt_setprop_assert(fdt, pci, "interrupt-map", pci_map, len);
     qemu_fdt_setprop_phandle(fdt, pci, "interrupt-parent", mpic);
-    qemu_fdt_setprop_cells(fdt, pci, "interrupts", 24, 2);
-    qemu_fdt_setprop_cells(fdt, pci, "bus-range", 0, 255);
+    qemu_fdt_setprop_cells_assert(fdt, pci, "interrupts", 24, 2);
+    qemu_fdt_setprop_cells_assert(fdt, pci, "bus-range", 0, 255);
     for (i = 0; i < 14; i++) {
         pci_ranges[i] = cpu_to_be32(pci_ranges[i]);
     }
     qemu_fdt_setprop_cell(fdt, pci, "fsl,msi", msi_ph);
-    qemu_fdt_setprop(fdt, pci, "ranges", pci_ranges, sizeof(pci_ranges));
-    qemu_fdt_setprop_cells(fdt, pci, "reg", MPC8544_PCI_REGS_BASE >> 32,
-                           MPC8544_PCI_REGS_BASE, 0, 0x1000);
+    qemu_fdt_setprop_assert(fdt, pci, "ranges", pci_ranges, sizeof(pci_ranges));
+    qemu_fdt_setprop_cells_assert(fdt, pci, "reg", MPC8544_PCI_REGS_BASE >> 32,
+                                  MPC8544_PCI_REGS_BASE, 0, 0x1000);
     qemu_fdt_setprop_cell(fdt, pci, "clock-frequency", 66666666);
     qemu_fdt_setprop_cell(fdt, pci, "#interrupt-cells", 1);
     qemu_fdt_setprop_cell(fdt, pci, "#size-cells", 2);
@@ -370,8 +372,8 @@ static int ppce500_load_device_tree(CPUPPCState *env,
     params->fixup_devtree(params, fdt);
 
     if (toplevel_compat) {
-        qemu_fdt_setprop(fdt, "/", "compatible", toplevel_compat,
-                         strlen(toplevel_compat) + 1);
+        qemu_fdt_setprop_assert(fdt, "/", "compatible", toplevel_compat,
+                                strlen(toplevel_compat) + 1);
     }
 
 done:
diff --git a/hw/ppc/e500plat.c b/hw/ppc/e500plat.c
index 6eecdc5..16c0282 100644
--- a/hw/ppc/e500plat.c
+++ b/hw/ppc/e500plat.c
@@ -23,9 +23,9 @@ static void e500plat_fixup_devtree(PPCE500Params *params, void *fdt)
     const char model[] = "QEMU ppce500";
     const char compatible[] = "fsl,qemu-e500";
 
-    qemu_fdt_setprop(fdt, "/", "model", model, sizeof(model));
-    qemu_fdt_setprop(fdt, "/", "compatible", compatible,
-                     sizeof(compatible));
+    qemu_fdt_setprop_assert(fdt, "/", "model", model, sizeof(model));
+    qemu_fdt_setprop_assert(fdt, "/", "compatible", compatible,
+                            sizeof(compatible));
 }
 
 static void e500plat_init(QEMUMachineInitArgs *args)
diff --git a/hw/ppc/mpc8544ds.c b/hw/ppc/mpc8544ds.c
index 4ed66f1..113fd13 100644
--- a/hw/ppc/mpc8544ds.c
+++ b/hw/ppc/mpc8544ds.c
@@ -21,9 +21,9 @@ static void mpc8544ds_fixup_devtree(PPCE500Params *params, void *fdt)
     const char model[] = "MPC8544DS";
     const char compatible[] = "MPC8544DS\0MPC85xxDS";
 
-    qemu_fdt_setprop(fdt, "/", "model", model, sizeof(model));
-    qemu_fdt_setprop(fdt, "/", "compatible", compatible,
-                     sizeof(compatible));
+    qemu_fdt_setprop_assert(fdt, "/", "model", model, sizeof(model));
+    qemu_fdt_setprop_assert(fdt, "/", "compatible", compatible,
+                            sizeof(compatible));
 }
 
 static void mpc8544ds_init(QEMUMachineInitArgs *args)
diff --git a/hw/ppc/ppc440_bamboo.c b/hw/ppc/ppc440_bamboo.c
index db9d38b..39badfa 100644
--- a/hw/ppc/ppc440_bamboo.c
+++ b/hw/ppc/ppc440_bamboo.c
@@ -64,6 +64,7 @@ static int bamboo_load_device_tree(hwaddr addr,
     void *fdt;
     uint32_t tb_freq = 400000000;
     uint32_t clock_freq = 400000000;
+    Error *errp = NULL;
 
     filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, BINARY_DEVICE_TREE_FILE);
     if (!filename) {
@@ -77,10 +78,11 @@ static int bamboo_load_device_tree(hwaddr addr,
 
     /* Manipulate device tree in memory. */
 
-    ret = qemu_fdt_setprop(fdt, "/memory", "reg", mem_reg_property,
-                           sizeof(mem_reg_property));
-    if (ret < 0)
+    qemu_fdt_setprop(fdt, "/memory", "reg", mem_reg_property,
+                     sizeof(mem_reg_property), &errp);
+    if (errp) {
         fprintf(stderr, "couldn't set /memory/reg\n");
+    }
 
     ret = qemu_fdt_setprop_cell(fdt, "/chosen", "linux,initrd-start",
                                 initrd_base);
diff --git a/include/sysemu/device_tree.h b/include/sysemu/device_tree.h
index b4650c5..adaf5c2 100644
--- a/include/sysemu/device_tree.h
+++ b/include/sysemu/device_tree.h
@@ -4,8 +4,10 @@
  * interface.
  *
  * Copyright 2008 IBM Corporation.
+ * Copyright 2013 Xilinx Inc.
  * Authors: Jerone Young <jyoung5@us.ibm.com>
  *          Hollis Blanchard <hollisb@us.ibm.com>
+ *          Peter Crosthwaite <peter.crosthwaite@xilinx.com>
  *
  * This work is licensed under the GNU GPL license version 2 or later.
  *
@@ -14,15 +16,68 @@
 #ifndef __DEVICE_TREE_H__
 #define __DEVICE_TREE_H__
 
+#include "qapi/qmp/qerror.h"
+
 void *create_device_tree(int *sizep);
 void *load_device_tree(const char *filename_path, int *sizep);
 
-int qemu_fdt_setprop(void *fdt, const char *node_path,
-                     const char *property, const void *val, int size);
+/**
+ * qemu_fdt_setprop - create or change a property
+ * @fdt: pointer to the device tree blob
+ * @node_path: node-path of the node whose property to change
+ * @property: name of the property to change
+ * @val: pointer to data to set the property value to
+ * @size: length of the property value
+ * @errp: Error to populate incase of error
+ *
+ * qemu_fdt_setprop() sets the value of the named property in the given
+ * node to the given value and length, creating the property if it
+ * does not already exist.
+ */
+
+void qemu_fdt_setprop(void *fdt, const char *node_path, const char *property,
+                      const void *val, int size, Error **errp);
+
+/**
+ * qemu_fdt_setprop_assert - create or change a property and assert success
+ *
+ * Same as qemu_fdt_setprop() except no errp argument required, and
+ * asserts the success of the operation.
+ */
+
+void qemu_fdt_setprop_assert(void *fdt, const char *node_path,
+                             const char *property, const void *val, int size);
+
 int qemu_fdt_setprop_cell(void *fdt, const char *node_path,
                           const char *property, uint32_t val);
-int qemu_fdt_setprop_u64(void *fdt, const char *node_path,
-                         const char *property, uint64_t val);
+
+/**
+ * qemu_fdt_setprop_u64 - create or change a 64bit int property
+ * @fdt: pointer to the device tree blob
+ * @node_path: node-path of the node whose property to change
+ * @property: name of the property to change
+ * @val: value to set
+ * @errp: Error to populate incase of error
+ *
+ * qemu_fdt_setprop_u64() sets the value of the named property in the given
+ * node to the given uint64_t value. The value is converted to big endian
+ * format as per device tree formatting.
+ */
+
+void qemu_fdt_setprop_u64(void *fdt, const char *node_path,
+                          const char *property, uint64_t val, Error **errp);
+
+/**
+ * qemu_fdt_setprop_u64_assert - create or change a 64 bit int property and
+ * assert success
+ *
+ * Same as qemu_fdt_setprop_u64() except no errp argument required, and
+ * asserts the success of the operation.
+ */
+
+void qemu_fdt_setprop_u64_assert(void *fdt, const char *node_path,
+                                 const char *property, uint64_t val);
+
 int qemu_fdt_setprop_string(void *fdt, const char *node_path,
                             const char *property, const char *string);
 int qemu_fdt_setprop_phandle(void *fdt, const char *node_path,
@@ -37,7 +92,21 @@ uint32_t qemu_fdt_alloc_phandle(void *fdt);
 int qemu_fdt_nop_node(void *fdt, const char *node_path);
 int qemu_fdt_add_subnode(void *fdt, const char *name);
 
-#define qemu_fdt_setprop_cells(fdt, node_path, property, ...)                 \
+/**
+ * qemu_fdt_setprop_cells - create or change a multi-cell property
+ * @fdt: pointer to the device tree blob
+ * @node_path: node-path of the node whose property to change
+ * @property: name of the property to change
+ * @errp: Error to populate incase of error
+ * @...: varargs list of cells to write to property
+ *
+ * qemu_fdt_setprop_cells() sets the value of the named property in the given
+ * node to a list of cells. The varargs are converted to an appropriate length
+ * uint32_t array and converted to big endian. The array is then written as
+ * the property value.
+ */
+
+#define qemu_fdt_setprop_cells(fdt, node_path, property, errp, ...)           \
     do {                                                                      \
         uint32_t qdt_tmp[] = { __VA_ARGS__ };                                 \
         int i;                                                                \
@@ -46,7 +115,23 @@ int qemu_fdt_add_subnode(void *fdt, const char *name);
             qdt_tmp[i] = cpu_to_be32(qdt_tmp[i]);                             \
         }                                                                     \
         qemu_fdt_setprop(fdt, node_path, property, qdt_tmp,                   \
-                         sizeof(qdt_tmp));                                    \
+                         sizeof(qdt_tmp), errp);                              \
+    } while (0)
+
+/**
+ * qemu_fdt_setprop_cells_assert - create or change a mult-cell property and
+ * assert success
+ *
+ * Same as qemu_fdt_setprop_cells() except no errp argument required, and
+ * asserts the success of the operation.
+ */
+
+#define qemu_fdt_setprop_cells_assert(fdt, node_path, property, ...)          \
+    do {                                                                      \
+        Error *errp = NULL;                                                   \
+                                                                              \
+        qemu_fdt_setprop_cells(fdt, node_path, property, &errp, __VA_ARGS__); \
+        assert_no_error(errp);                                                \
     } while (0)
 
 void qemu_fdt_dumpdtb(void *fdt, int size);
