7 files changed, 278 insertions, 83 deletions

diff --git a/drivers/base/core.c b/drivers/base/core.c
index cadf165651d8..21d13038534e 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -12,6 +12,7 @@
 
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/fwnode.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -2144,3 +2145,53 @@ define_dev_printk_level(dev_notice, KERN_NOTICE);
 define_dev_printk_level(_dev_info, KERN_INFO);
 
 #endif
+
+static inline bool fwnode_is_primary(struct fwnode_handle *fwnode)
+{
+        return fwnode && !IS_ERR(fwnode->secondary);
+}
+
+/**
+ * set_primary_fwnode - Change the primary firmware node of a given device.
+ * @dev: Device to handle.
+ * @fwnode: New primary firmware node of the device.
+ *
+ * Set the device's firmware node pointer to @fwnode, but if a secondary
+ * firmware node of the device is present, preserve it.
+ */
+void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
+{
+        if (fwnode) {
+                struct fwnode_handle *fn = dev->fwnode;
+
+                if (fwnode_is_primary(fn))
+                        fn = fn->secondary;
+
+                fwnode->secondary = fn;
+                dev->fwnode = fwnode;
+        } else {
+                dev->fwnode = fwnode_is_primary(dev->fwnode) ?
+                        dev->fwnode->secondary : NULL;
+        }
+}
+EXPORT_SYMBOL_GPL(set_primary_fwnode);
+
+/**
+ * set_secondary_fwnode - Change the secondary firmware node of a given device.
+ * @dev: Device to handle.
+ * @fwnode: New secondary firmware node of the device.
+ *
+ * If a primary firmware node of the device is present, set its secondary
+ * pointer to @fwnode.  Otherwise, set the device's firmware node pointer to
+ * @fwnode.
+ */
+void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
+{
+        if (fwnode)
+                fwnode->secondary = ERR_PTR(-ENODEV);
+
+        if (fwnode_is_primary(dev->fwnode))
+                dev->fwnode->secondary = fwnode;
+        else
+                dev->fwnode = fwnode;
+}
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 49a4a12fafef..e843fdbe4925 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -298,6 +298,12 @@ static int really_probe(struct device *dev, struct device_driver *drv)
                 goto probe_failed;
         }
 
+        if (dev->pm_domain && dev->pm_domain->activate) {
+                ret = dev->pm_domain->activate(dev);
+                if (ret)
+                        goto probe_failed;
+        }
+
         if (dev->bus->probe) {
                 ret = dev->bus->probe(dev);
                 if (ret)
@@ -308,6 +314,9 @@ static int really_probe(struct device *dev, struct device_driver *drv)
                         goto probe_failed;
         }
 
+        if (dev->pm_domain && dev->pm_domain->sync)
+                dev->pm_domain->sync(dev);
+
         driver_bound(dev);
         ret = 1;
         pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
@@ -319,6 +328,8 @@ probe_failed:
         driver_sysfs_remove(dev);
         dev->driver = NULL;
         dev_set_drvdata(dev, NULL);
+        if (dev->pm_domain && dev->pm_domain->dismiss)
+                dev->pm_domain->dismiss(dev);
 
         switch (ret) {
         case -EPROBE_DEFER:
@@ -529,6 +540,9 @@ static void __device_release_driver(struct device *dev)
                 devres_release_all(dev);
                 dev->driver = NULL;
                 dev_set_drvdata(dev, NULL);
+                if (dev->pm_domain && dev->pm_domain->dismiss)
+                        dev->pm_domain->dismiss(dev);
+
                 klist_remove(&dev->p->knode_driver);
                 if (dev->bus)
                         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index e68ab79df28b..ebf034b97278 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -463,7 +463,7 @@ struct platform_device *platform_device_register_full(
                 goto err_alloc;
 
         pdev->dev.parent = pdevinfo->parent;
-        ACPI_COMPANION_SET(&pdev->dev, pdevinfo->acpi_node.companion);
+        pdev->dev.fwnode = pdevinfo->fwnode;
 
         if (pdevinfo->dma_mask) {
                 /*
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index 45937f88e77c..2327613d4539 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -68,7 +68,36 @@ static struct generic_pm_domain *pm_genpd_lookup_name(const char *domain_name)
         return genpd;
 }
 
-struct generic_pm_domain *dev_to_genpd(struct device *dev)
+/*
+ * Get the generic PM domain for a particular struct device.
+ * This validates the struct device pointer, the PM domain pointer,
+ * and checks that the PM domain pointer is a real generic PM domain.
+ * Any failure results in NULL being returned.
+ */
+struct generic_pm_domain *pm_genpd_lookup_dev(struct device *dev)
+{
+        struct generic_pm_domain *genpd = NULL, *gpd;
+
+        if (IS_ERR_OR_NULL(dev) || IS_ERR_OR_NULL(dev->pm_domain))
+                return NULL;
+
+        mutex_lock(&gpd_list_lock);
+        list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
+                if (&gpd->domain == dev->pm_domain) {
+                        genpd = gpd;
+                        break;
+                }
+        }
+        mutex_unlock(&gpd_list_lock);
+
+        return genpd;
+}
+
+/*
+ * This should only be used where we are certain that the pm_domain
+ * attached to the device is a genpd domain.
+ */
+static struct generic_pm_domain *dev_to_genpd(struct device *dev)
 {
         if (IS_ERR_OR_NULL(dev->pm_domain))
                 return ERR_PTR(-EINVAL);
@@ -173,8 +202,8 @@ static int genpd_power_on(struct generic_pm_domain *genpd)
         genpd->power_on_latency_ns = elapsed_ns;
         genpd->max_off_time_changed = true;
         genpd_recalc_cpu_exit_latency(genpd);
-        pr_warn("%s: Power-%s latency exceeded, new value %lld ns\n",
-                genpd->name, "on", elapsed_ns);
+        pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n",
+                 genpd->name, "on", elapsed_ns);
 
         return ret;
 }
@@ -199,8 +228,8 @@ static int genpd_power_off(struct generic_pm_domain *genpd)
 
         genpd->power_off_latency_ns = elapsed_ns;
         genpd->max_off_time_changed = true;
-        pr_warn("%s: Power-%s latency exceeded, new value %lld ns\n",
-                genpd->name, "off", elapsed_ns);
+        pr_debug("%s: Power-%s latency exceeded, new value %lld ns\n",
+                 genpd->name, "off", elapsed_ns);
 
         return ret;
 }
@@ -1513,9 +1542,7 @@ int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 
         dev_dbg(dev, "%s()\n", __func__);
 
-        if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev)
-            ||  IS_ERR_OR_NULL(dev->pm_domain)
-            ||  pd_to_genpd(dev->pm_domain) != genpd)
+        if (!genpd || genpd != pm_genpd_lookup_dev(dev))
                 return -EINVAL;
 
         /* The above validation also means we have existing domain_data. */
@@ -2093,21 +2120,10 @@ EXPORT_SYMBOL_GPL(of_genpd_get_from_provider);
  */
 static void genpd_dev_pm_detach(struct device *dev, bool power_off)
 {
-        struct generic_pm_domain *pd = NULL, *gpd;
+        struct generic_pm_domain *pd;
         int ret = 0;
 
-        if (!dev->pm_domain)
-                return;
-
-        mutex_lock(&gpd_list_lock);
-        list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
-                if (&gpd->domain == dev->pm_domain) {
-                        pd = gpd;
-                        break;
-                }
-        }
-        mutex_unlock(&gpd_list_lock);
-
+        pd = pm_genpd_lookup_dev(dev);
         if (!pd)
                 return;
 
@@ -2130,6 +2146,17 @@ static void genpd_dev_pm_detach(struct device *dev, bool power_off)
         genpd_queue_power_off_work(pd);
 }
 
+static void genpd_dev_pm_sync(struct device *dev)
+{
+        struct generic_pm_domain *pd;
+
+        pd = dev_to_genpd(dev);
+        if (IS_ERR(pd))
+                return;
+
+        genpd_queue_power_off_work(pd);
+}
+
 /**
  * genpd_dev_pm_attach - Attach a device to its PM domain using DT.
  * @dev: Device to attach.
@@ -2196,6 +2223,7 @@ int genpd_dev_pm_attach(struct device *dev)
         }
 
         dev->pm_domain->detach = genpd_dev_pm_detach;
+        dev->pm_domain->sync = genpd_dev_pm_sync;
         pm_genpd_poweron(pd);
 
         return 0;
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 9717d5f20139..3d874eca7104 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -23,7 +23,7 @@
 #include <linux/mutex.h>
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
-#include <linux/resume-trace.h>
+#include <linux/pm-trace.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
 #include <linux/async.h>
@@ -1017,6 +1017,9 @@ static int __device_suspend_noirq(struct device *dev, pm_message_t state, bool a
         char *info = NULL;
         int error = 0;
 
+        TRACE_DEVICE(dev);
+        TRACE_SUSPEND(0);
+
         if (async_error)
                 goto Complete;
 
@@ -1057,6 +1060,7 @@ static int __device_suspend_noirq(struct device *dev, pm_message_t state, bool a
 
 Complete:
         complete_all(&dev->power.completion);
+        TRACE_SUSPEND(error);
         return error;
 }
 
@@ -1078,7 +1082,7 @@ static int device_suspend_noirq(struct device *dev)
 {
         reinit_completion(&dev->power.completion);
 
-        if (pm_async_enabled && dev->power.async_suspend) {
+        if (is_async(dev)) {
                 get_device(dev);
                 async_schedule(async_suspend_noirq, dev);
                 return 0;
@@ -1157,6 +1161,9 @@ static int __device_suspend_late(struct device *dev, pm_message_t state, bool as
         char *info = NULL;
         int error = 0;
 
+        TRACE_DEVICE(dev);
+        TRACE_SUSPEND(0);
+
         __pm_runtime_disable(dev, false);
 
         if (async_error)
@@ -1198,6 +1205,7 @@ static int __device_suspend_late(struct device *dev, pm_message_t state, bool as
                 async_error = error;
 
 Complete:
+        TRACE_SUSPEND(error);
         complete_all(&dev->power.completion);
         return error;
 }
@@ -1219,7 +1227,7 @@ static int device_suspend_late(struct device *dev)
 {
         reinit_completion(&dev->power.completion);
 
-        if (pm_async_enabled && dev->power.async_suspend) {
+        if (is_async(dev)) {
                 get_device(dev);
                 async_schedule(async_suspend_late, dev);
                 return 0;
@@ -1338,6 +1346,9 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
         int error = 0;
         DECLARE_DPM_WATCHDOG_ON_STACK(wd);
 
+        TRACE_DEVICE(dev);
+        TRACE_SUSPEND(0);
+
         dpm_wait_for_children(dev, async);
 
         if (async_error)
@@ -1444,6 +1455,7 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
         if (error)
                 async_error = error;
 
+        TRACE_SUSPEND(error);
         return error;
 }
 
@@ -1465,7 +1477,7 @@ static int device_suspend(struct device *dev)
 {
         reinit_completion(&dev->power.completion);
 
-        if (pm_async_enabled && dev->power.async_suspend) {
+        if (is_async(dev)) {
                 get_device(dev);
                 async_schedule(async_suspend, dev);
                 return 0;
diff --git a/drivers/base/power/trace.c b/drivers/base/power/trace.c
index d94a1f5121cf..a311cfa4c5bd 100644
--- a/drivers/base/power/trace.c
+++ b/drivers/base/power/trace.c
@@ -7,7 +7,7 @@
  * devices may be working.
  */
 
-#include <linux/resume-trace.h>
+#include <linux/pm-trace.h>
 #include <linux/export.h>
 #include <linux/rtc.h>
 
@@ -154,7 +154,7 @@ EXPORT_SYMBOL(set_trace_device);
  * it's not any guarantee, but it's a high _likelihood_ that
  * the match is valid).
  */
-void generate_resume_trace(const void *tracedata, unsigned int user)
+void generate_pm_trace(const void *tracedata, unsigned int user)
 {
         unsigned short lineno = *(unsigned short *)tracedata;
         const char *file = *(const char **)(tracedata + 2);
@@ -164,7 +164,7 @@ void generate_resume_trace(const void *tracedata, unsigned int user)
         file_hash_value = hash_string(lineno, file, FILEHASH);
         set_magic_time(user_hash_value, file_hash_value, dev_hash_value);
 }
-EXPORT_SYMBOL(generate_resume_trace);
+EXPORT_SYMBOL(generate_pm_trace);
 
 extern char __tracedata_start, __tracedata_end;
 static int show_file_hash(unsigned int value)
diff --git a/drivers/base/property.c b/drivers/base/property.c
index 423df593f262..1d0b116cae95 100644
--- a/drivers/base/property.c
+++ b/drivers/base/property.c
@@ -10,10 +10,102 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/property.h>
-#include <linux/export.h>
 #include <linux/acpi.h>
+#include <linux/export.h>
+#include <linux/kernel.h>
 #include <linux/of.h>
+#include <linux/property.h>
+
+/**
+ * device_add_property_set - Add a collection of properties to a device object.
+ * @dev: Device to add properties to.
+ * @pset: Collection of properties to add.
+ *
+ * Associate a collection of device properties represented by @pset with @dev
+ * as its secondary firmware node.
+ */
+void device_add_property_set(struct device *dev, struct property_set *pset)
+{
+        if (pset)
+                pset->fwnode.type = FWNODE_PDATA;
+
+        set_secondary_fwnode(dev, &pset->fwnode);
+}
+EXPORT_SYMBOL_GPL(device_add_property_set);
+
+static inline bool is_pset(struct fwnode_handle *fwnode)
+{
+        return fwnode && fwnode->type == FWNODE_PDATA;
+}
+
+static inline struct property_set *to_pset(struct fwnode_handle *fwnode)
+{
+        return is_pset(fwnode) ?
+                container_of(fwnode, struct property_set, fwnode) : NULL;
+}
+
+static struct property_entry *pset_prop_get(struct property_set *pset,
+                                            const char *name)
+{
+        struct property_entry *prop;
+
+        if (!pset || !pset->properties)
+                return NULL;
+
+        for (prop = pset->properties; prop->name; prop++)
+                if (!strcmp(name, prop->name))
+                        return prop;
+
+        return NULL;
+}
+
+static int pset_prop_read_array(struct property_set *pset, const char *name,
+                                enum dev_prop_type type, void *val, size_t nval)
+{
+        struct property_entry *prop;
+        unsigned int item_size;
+
+        prop = pset_prop_get(pset, name);
+        if (!prop)
+                return -ENODATA;
+
+        if (prop->type != type)
+                return -EPROTO;
+
+        if (!val)
+                return prop->nval;
+
+        if (prop->nval < nval)
+                return -EOVERFLOW;
+
+        switch (type) {
+        case DEV_PROP_U8:
+                item_size = sizeof(u8);
+                break;
+        case DEV_PROP_U16:
+                item_size = sizeof(u16);
+                break;
+        case DEV_PROP_U32:
+                item_size = sizeof(u32);
+                break;
+        case DEV_PROP_U64:
+                item_size = sizeof(u64);
+                break;
+        case DEV_PROP_STRING:
+                item_size = sizeof(const char *);
+                break;
+        default:
+                return -EINVAL;
+        }
+        memcpy(val, prop->value.raw_data, nval * item_size);
+        return 0;
+}
+
+static inline struct fwnode_handle *dev_fwnode(struct device *dev)
+{
+        return IS_ENABLED(CONFIG_OF) && dev->of_node ?
+                &dev->of_node->fwnode : dev->fwnode;
+}
 
 /**
  * device_property_present - check if a property of a device is present
@@ -24,10 +116,7 @@
  */
 bool device_property_present(struct device *dev, const char *propname)
 {
-        if (IS_ENABLED(CONFIG_OF) && dev->of_node)
-                return of_property_read_bool(dev->of_node, propname);
-
-        return !acpi_dev_prop_get(ACPI_COMPANION(dev), propname, NULL);
+        return fwnode_property_present(dev_fwnode(dev), propname);
 }
 EXPORT_SYMBOL_GPL(device_property_present);
 
@@ -43,32 +132,22 @@ bool fwnode_property_present(struct fwnode_handle *fwnode, const char *propname)
         else if (is_acpi_node(fwnode))
                 return !acpi_dev_prop_get(acpi_node(fwnode), propname, NULL);
 
-        return false;
+        return !!pset_prop_get(to_pset(fwnode), propname);
 }
 EXPORT_SYMBOL_GPL(fwnode_property_present);
 
-#define OF_DEV_PROP_READ_ARRAY(node, propname, type, val, nval) \
-        (val) ? of_property_read_##type##_array((node), (propname), (val), (nval)) \
-              : of_property_count_elems_of_size((node), (propname), sizeof(type))
-
-#define DEV_PROP_READ_ARRAY(_dev_, _propname_, _type_, _proptype_, _val_, _nval_) \
-        IS_ENABLED(CONFIG_OF) && _dev_->of_node ? \
-                (OF_DEV_PROP_READ_ARRAY(_dev_->of_node, _propname_, _type_, \
-                                        _val_, _nval_)) : \
-                acpi_dev_prop_read(ACPI_COMPANION(_dev_), _propname_, \
-                                   _proptype_, _val_, _nval_)
-
 /**
  * device_property_read_u8_array - return a u8 array property of a device
  * @dev: Device to get the property of
  * @propname: Name of the property
- * @val: The values are stored here
+ * @val: The values are stored here or %NULL to return the number of values
  * @nval: Size of the @val array
  *
  * Function reads an array of u8 properties with @propname from the device
  * firmware description and stores them to @val if found.
  *
- * Return: %0 if the property was found (success),
+ * Return: number of values if @val was %NULL,
+ *         %0 if the property was found (success),
  *         %-EINVAL if given arguments are not valid,
  *         %-ENODATA if the property does not have a value,
  *         %-EPROTO if the property is not an array of numbers,
@@ -77,7 +156,7 @@ EXPORT_SYMBOL_GPL(fwnode_property_present);
 int device_property_read_u8_array(struct device *dev, const char *propname,
                                   u8 *val, size_t nval)
 {
-        return DEV_PROP_READ_ARRAY(dev, propname, u8, DEV_PROP_U8, val, nval);
+        return fwnode_property_read_u8_array(dev_fwnode(dev), propname, val, nval);
 }
 EXPORT_SYMBOL_GPL(device_property_read_u8_array);
 
@@ -85,13 +164,14 @@ EXPORT_SYMBOL_GPL(device_property_read_u8_array);
  * device_property_read_u16_array - return a u16 array property of a device
  * @dev: Device to get the property of
  * @propname: Name of the property
- * @val: The values are stored here
+ * @val: The values are stored here or %NULL to return the number of values
  * @nval: Size of the @val array
  *
  * Function reads an array of u16 properties with @propname from the device
  * firmware description and stores them to @val if found.
  *
- * Return: %0 if the property was found (success),
+ * Return: number of values if @val was %NULL,
+ *         %0 if the property was found (success),
  *         %-EINVAL if given arguments are not valid,
  *         %-ENODATA if the property does not have a value,
  *         %-EPROTO if the property is not an array of numbers,
@@ -100,7 +180,7 @@ EXPORT_SYMBOL_GPL(device_property_read_u8_array);
 int device_property_read_u16_array(struct device *dev, const char *propname,
                                    u16 *val, size_t nval)
 {
-        return DEV_PROP_READ_ARRAY(dev, propname, u16, DEV_PROP_U16, val, nval);
+        return fwnode_property_read_u16_array(dev_fwnode(dev), propname, val, nval);
 }
 EXPORT_SYMBOL_GPL(device_property_read_u16_array);
 
@@ -108,13 +188,14 @@ EXPORT_SYMBOL_GPL(device_property_read_u16_array);
  * device_property_read_u32_array - return a u32 array property of a device
  * @dev: Device to get the property of
  * @propname: Name of the property
- * @val: The values are stored here
+ * @val: The values are stored here or %NULL to return the number of values
  * @nval: Size of the @val array
  *
  * Function reads an array of u32 properties with @propname from the device
  * firmware description and stores them to @val if found.
  *
- * Return: %0 if the property was found (success),
+ * Return: number of values if @val was %NULL,
+ *         %0 if the property was found (success),
  *         %-EINVAL if given arguments are not valid,
  *         %-ENODATA if the property does not have a value,
  *         %-EPROTO if the property is not an array of numbers,
@@ -123,7 +204,7 @@ EXPORT_SYMBOL_GPL(device_property_read_u16_array);
 int device_property_read_u32_array(struct device *dev, const char *propname,
                                    u32 *val, size_t nval)
 {
-        return DEV_PROP_READ_ARRAY(dev, propname, u32, DEV_PROP_U32, val, nval);
+        return fwnode_property_read_u32_array(dev_fwnode(dev), propname, val, nval);
 }
 EXPORT_SYMBOL_GPL(device_property_read_u32_array);
 
@@ -131,13 +212,14 @@ EXPORT_SYMBOL_GPL(device_property_read_u32_array);
  * device_property_read_u64_array - return a u64 array property of a device
  * @dev: Device to get the property of
  * @propname: Name of the property
- * @val: The values are stored here
+ * @val: The values are stored here or %NULL to return the number of values
  * @nval: Size of the @val array
  *
  * Function reads an array of u64 properties with @propname from the device
  * firmware description and stores them to @val if found.
  *
- * Return: %0 if the property was found (success),
+ * Return: number of values if @val was %NULL,
+ *         %0 if the property was found (success),
  *         %-EINVAL if given arguments are not valid,
  *         %-ENODATA if the property does not have a value,
  *         %-EPROTO if the property is not an array of numbers,
@@ -146,7 +228,7 @@ EXPORT_SYMBOL_GPL(device_property_read_u32_array);
 int device_property_read_u64_array(struct device *dev, const char *propname,
                                    u64 *val, size_t nval)
 {
-        return DEV_PROP_READ_ARRAY(dev, propname, u64, DEV_PROP_U64, val, nval);
+        return fwnode_property_read_u64_array(dev_fwnode(dev), propname, val, nval);
 }
 EXPORT_SYMBOL_GPL(device_property_read_u64_array);
 
@@ -154,13 +236,14 @@ EXPORT_SYMBOL_GPL(device_property_read_u64_array);
  * device_property_read_string_array - return a string array property of device
  * @dev: Device to get the property of
  * @propname: Name of the property
- * @val: The values are stored here
+ * @val: The values are stored here or %NULL to return the number of values
  * @nval: Size of the @val array
  *
  * Function reads an array of string properties with @propname from the device
  * firmware description and stores them to @val if found.
  *
- * Return: %0 if the property was found (success),
+ * Return: number of values if @val was %NULL,
+ *         %0 if the property was found (success),
  *         %-EINVAL if given arguments are not valid,
  *         %-ENODATA if the property does not have a value,
  *         %-EPROTO or %-EILSEQ if the property is not an array of strings,
@@ -169,10 +252,7 @@ EXPORT_SYMBOL_GPL(device_property_read_u64_array);
 int device_property_read_string_array(struct device *dev, const char *propname,
                                       const char **val, size_t nval)
 {
-        return IS_ENABLED(CONFIG_OF) && dev->of_node ?
-                of_property_read_string_array(dev->of_node, propname, val, nval) :
-                acpi_dev_prop_read(ACPI_COMPANION(dev), propname,
-                                   DEV_PROP_STRING, val, nval);
+        return fwnode_property_read_string_array(dev_fwnode(dev), propname, val, nval);
 }
 EXPORT_SYMBOL_GPL(device_property_read_string_array);
 
@@ -193,13 +273,14 @@ EXPORT_SYMBOL_GPL(device_property_read_string_array);
 int device_property_read_string(struct device *dev, const char *propname,
                                 const char **val)
 {
-        return IS_ENABLED(CONFIG_OF) && dev->of_node ?
-                of_property_read_string(dev->of_node, propname, val) :
-                acpi_dev_prop_read(ACPI_COMPANION(dev), propname,
-                                   DEV_PROP_STRING, val, 1);
+        return fwnode_property_read_string(dev_fwnode(dev), propname, val);
 }
 EXPORT_SYMBOL_GPL(device_property_read_string);
 
+#define OF_DEV_PROP_READ_ARRAY(node, propname, type, val, nval) \
+        (val) ? of_property_read_##type##_array((node), (propname), (val), (nval)) \
+              : of_property_count_elems_of_size((node), (propname), sizeof(type))
+
 #define FWNODE_PROP_READ_ARRAY(_fwnode_, _propname_, _type_, _proptype_, _val_, _nval_) \
 ({ \
         int _ret_; \
@@ -210,7 +291,8 @@ EXPORT_SYMBOL_GPL(device_property_read_string);
                 _ret_ = acpi_dev_prop_read(acpi_node(_fwnode_), _propname_, \
                                            _proptype_, _val_, _nval_); \
         else \
-                _ret_ = -ENXIO; \
+                _ret_ = pset_prop_read_array(to_pset(_fwnode_), _propname_, \
+                                             _proptype_, _val_, _nval_); \
         _ret_; \
 })
 
@@ -218,13 +300,14 @@ EXPORT_SYMBOL_GPL(device_property_read_string);
  * fwnode_property_read_u8_array - return a u8 array property of firmware node
  * @fwnode: Firmware node to get the property of
  * @propname: Name of the property
- * @val: The values are stored here
+ * @val: The values are stored here or %NULL to return the number of values
  * @nval: Size of the @val array
  *
  * Read an array of u8 properties with @propname from @fwnode and stores them to
  * @val if found.
  *
- * Return: %0 if the property was found (success),
+ * Return: number of values if @val was %NULL,
+ *         %0 if the property was found (success),
  *         %-EINVAL if given arguments are not valid,
  *         %-ENODATA if the property does not have a value,
  *         %-EPROTO if the property is not an array of numbers,
@@ -243,13 +326,14 @@ EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array);
  * fwnode_property_read_u16_array - return a u16 array property of firmware node
  * @fwnode: Firmware node to get the property of
  * @propname: Name of the property
- * @val: The values are stored here
+ * @val: The values are stored here or %NULL to return the number of values
  * @nval: Size of the @val array
  *
  * Read an array of u16 properties with @propname from @fwnode and store them to
  * @val if found.
  *
- * Return: %0 if the property was found (success),
+ * Return: number of values if @val was %NULL,
+ *         %0 if the property was found (success),
  *         %-EINVAL if given arguments are not valid,
  *         %-ENODATA if the property does not have a value,
  *         %-EPROTO if the property is not an array of numbers,
@@ -268,13 +352,14 @@ EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array);
  * fwnode_property_read_u32_array - return a u32 array property of firmware node
  * @fwnode: Firmware node to get the property of
  * @propname: Name of the property
- * @val: The values are stored here
+ * @val: The values are stored here or %NULL to return the number of values
  * @nval: Size of the @val array
  *
  * Read an array of u32 properties with @propname from @fwnode store them to
  * @val if found.
  *
- * Return: %0 if the property was found (success),
+ * Return: number of values if @val was %NULL,
+ *         %0 if the property was found (success),
  *         %-EINVAL if given arguments are not valid,
  *         %-ENODATA if the property does not have a value,
  *         %-EPROTO if the property is not an array of numbers,
@@ -293,13 +378,14 @@ EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array);
  * fwnode_property_read_u64_array - return a u64 array property firmware node
  * @fwnode: Firmware node to get the property of
  * @propname: Name of the property
- * @val: The values are stored here
+ * @val: The values are stored here or %NULL to return the number of values
  * @nval: Size of the @val array
  *
  * Read an array of u64 properties with @propname from @fwnode and store them to
  * @val if found.
  *
- * Return: %0 if the property was found (success),
+ * Return: number of values if @val was %NULL,
+ *         %0 if the property was found (success),
  *         %-EINVAL if given arguments are not valid,
  *         %-ENODATA if the property does not have a value,
  *         %-EPROTO if the property is not an array of numbers,
@@ -318,13 +404,14 @@ EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array);
  * fwnode_property_read_string_array - return string array property of a node
  * @fwnode: Firmware node to get the property of
  * @propname: Name of the property
- * @val: The values are stored here
+ * @val: The values are stored here or %NULL to return the number of values
  * @nval: Size of the @val array
  *
  * Read an string list property @propname from the given firmware node and store
  * them to @val if found.
  *
- * Return: %0 if the property was found (success),
+ * Return: number of values if @val was %NULL,
+ *         %0 if the property was found (success),
  *         %-EINVAL if given arguments are not valid,
  *         %-ENODATA if the property does not have a value,
  *         %-EPROTO if the property is not an array of strings,
@@ -336,13 +423,16 @@ int fwnode_property_read_string_array(struct fwnode_handle *fwnode,
                                       size_t nval)
 {
         if (is_of_node(fwnode))
-                return of_property_read_string_array(of_node(fwnode), propname,
-                                                     val, nval);
+                return val ?
+                        of_property_read_string_array(of_node(fwnode), propname,
+                                                      val, nval) :
+                        of_property_count_strings(of_node(fwnode), propname);
         else if (is_acpi_node(fwnode))
                 return acpi_dev_prop_read(acpi_node(fwnode), propname,
                                           DEV_PROP_STRING, val, nval);
 
-        return -ENXIO;
+        return pset_prop_read_array(to_pset(fwnode), propname,
+                                    DEV_PROP_STRING, val, nval);
 }
 EXPORT_SYMBOL_GPL(fwnode_property_read_string_array);