struct property_set {
        struct fwnode_handle fwnode;
-       struct property_entry *properties;
+       const struct property_entry *properties;
 };
 
 static inline bool is_pset_node(struct fwnode_handle *fwnode)
                container_of(fwnode, struct property_set, fwnode) : NULL;
 }
 
-static struct property_entry *pset_prop_get(struct property_set *pset,
-                                           const char *name)
+static const struct property_entry *pset_prop_get(struct property_set *pset,
+                                                 const char *name)
 {
-       struct property_entry *prop;
+       const struct property_entry *prop;
 
        if (!pset || !pset->properties)
                return NULL;
        return NULL;
 }
 
-static void *pset_prop_find(struct property_set *pset, const char *propname,
-                           size_t length)
+static const void *pset_prop_find(struct property_set *pset,
+                                 const char *propname, size_t length)
 {
-       struct property_entry *prop;
-       void *pointer;
+       const struct property_entry *prop;
+       const void *pointer;
 
        prop = pset_prop_get(pset, propname);
        if (!prop)
                                   const char *propname,
                                   u8 *values, size_t nval)
 {
-       void *pointer;
+       const void *pointer;
        size_t length = nval * sizeof(*values);
 
        pointer = pset_prop_find(pset, propname, length);
                                    const char *propname,
                                    u16 *values, size_t nval)
 {
-       void *pointer;
+       const void *pointer;
        size_t length = nval * sizeof(*values);
 
        pointer = pset_prop_find(pset, propname, length);
                                    const char *propname,
                                    u32 *values, size_t nval)
 {
-       void *pointer;
+       const void *pointer;
        size_t length = nval * sizeof(*values);
 
        pointer = pset_prop_find(pset, propname, length);
                                    const char *propname,
                                    u64 *values, size_t nval)
 {
-       void *pointer;
+       const void *pointer;
        size_t length = nval * sizeof(*values);
 
        pointer = pset_prop_find(pset, propname, length);
 static int pset_prop_count_elems_of_size(struct property_set *pset,
                                         const char *propname, size_t length)
 {
-       struct property_entry *prop;
+       const struct property_entry *prop;
 
        prop = pset_prop_get(pset, propname);
        if (!prop)
                                       const char *propname,
                                       const char **strings, size_t nval)
 {
-       void *pointer;
+       const void *pointer;
        size_t length = nval * sizeof(*strings);
 
        pointer = pset_prop_find(pset, propname, length);
 static int pset_prop_read_string(struct property_set *pset,
                                 const char *propname, const char **strings)
 {
-       struct property_entry *prop;
-       const char **pointer;
+       const struct property_entry *prop;
+       const char * const *pointer;
 
        prop = pset_prop_get(pset, propname);
        if (!prop)
  */
 static struct property_set *pset_copy_set(const struct property_set *pset)
 {
-       const struct property_entry *entry;
+       struct property_entry *props;
        struct property_set *p;
        size_t i, n = 0;
 
        while (pset->properties[n].name)
                n++;
 
-       p->properties = kcalloc(n + 1, sizeof(*entry), GFP_KERNEL);
+       p->properties = props = kcalloc(n + 1, sizeof(*props), GFP_KERNEL);
        if (!p->properties) {
                kfree(p);
                return ERR_PTR(-ENOMEM);
        }
 
        for (i = 0; i < n; i++) {
-               int ret = pset_copy_entry(&p->properties[i],
+               int ret = pset_copy_entry(&props[i],
                                          &pset->properties[i]);
                if (ret) {
                        pset_free_set(p);
  * @dev as its secondary firmware node. The function takes a copy of
  * @properties.
  */
-int device_add_properties(struct device *dev, struct property_entry *properties)
+int device_add_properties(struct device *dev,
+                         const struct property_entry *properties)
 {
        struct property_set *p, pset;