|
|
@@ -1146,16 +1146,18 @@ EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);
|
|
|
*
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
* @propname: name of the property to be searched.
|
|
|
- * @len: requested length of property value
|
|
|
+ * @min: minimum allowed length of property value
|
|
|
+ * @max: maximum allowed length of property value (0 means unlimited)
|
|
|
+ * @len: if !=NULL, actual length is written to here
|
|
|
*
|
|
|
* Search for a property in a device node and valid the requested size.
|
|
|
* Returns the property value on success, -EINVAL if the property does not
|
|
|
* exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
- * property data isn't large enough.
|
|
|
+ * property data is too small or too large.
|
|
|
*
|
|
|
*/
|
|
|
static void *of_find_property_value_of_size(const struct device_node *np,
|
|
|
- const char *propname, u32 len)
|
|
|
+ const char *propname, u32 min, u32 max, size_t *len)
|
|
|
{
|
|
|
struct property *prop = of_find_property(np, propname, NULL);
|
|
|
|
|
|
@@ -1163,9 +1165,14 @@ static void *of_find_property_value_of_size(const struct device_node *np,
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
if (!prop->value)
|
|
|
return ERR_PTR(-ENODATA);
|
|
|
- if (len > prop->length)
|
|
|
+ if (prop->length < min)
|
|
|
+ return ERR_PTR(-EOVERFLOW);
|
|
|
+ if (max && prop->length > max)
|
|
|
return ERR_PTR(-EOVERFLOW);
|
|
|
|
|
|
+ if (len)
|
|
|
+ *len = prop->length;
|
|
|
+
|
|
|
return prop->value;
|
|
|
}
|
|
|
|
|
|
@@ -1189,7 +1196,9 @@ int of_property_read_u32_index(const struct device_node *np,
|
|
|
u32 index, u32 *out_value)
|
|
|
{
|
|
|
const u32 *val = of_find_property_value_of_size(np, propname,
|
|
|
- ((index + 1) * sizeof(*out_value)));
|
|
|
+ ((index + 1) * sizeof(*out_value)),
|
|
|
+ 0,
|
|
|
+ NULL);
|
|
|
|
|
|
if (IS_ERR(val))
|
|
|
return PTR_ERR(val);
|
|
|
@@ -1200,102 +1209,145 @@ int of_property_read_u32_index(const struct device_node *np,
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_u32_index);
|
|
|
|
|
|
/**
|
|
|
- * of_property_read_u8_array - Find and read an array of u8 from a property.
|
|
|
+ * of_property_read_variable_u8_array - Find and read an array of u8 from a
|
|
|
+ * property, with bounds on the minimum and maximum array size.
|
|
|
*
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
* @propname: name of the property to be searched.
|
|
|
* @out_values: pointer to return value, modified only if return value is 0.
|
|
|
- * @sz: number of array elements to read
|
|
|
+ * @sz_min: minimum number of array elements to read
|
|
|
+ * @sz_max: maximum number of array elements to read, if zero there is no
|
|
|
+ * upper limit on the number of elements in the dts entry but only
|
|
|
+ * sz_min will be read.
|
|
|
*
|
|
|
* Search for a property in a device node and read 8-bit value(s) from
|
|
|
- * it. Returns 0 on success, -EINVAL if the property does not exist,
|
|
|
- * -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
- * property data isn't large enough.
|
|
|
+ * it. Returns number of elements read on success, -EINVAL if the property
|
|
|
+ * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
|
|
|
+ * if the property data is smaller than sz_min or longer than sz_max.
|
|
|
*
|
|
|
* dts entry of array should be like:
|
|
|
* property = /bits/ 8 <0x50 0x60 0x70>;
|
|
|
*
|
|
|
* The out_values is modified only if a valid u8 value can be decoded.
|
|
|
*/
|
|
|
-int of_property_read_u8_array(const struct device_node *np,
|
|
|
- const char *propname, u8 *out_values, size_t sz)
|
|
|
+int of_property_read_variable_u8_array(const struct device_node *np,
|
|
|
+ const char *propname, u8 *out_values,
|
|
|
+ size_t sz_min, size_t sz_max)
|
|
|
{
|
|
|
+ size_t sz, count;
|
|
|
const u8 *val = of_find_property_value_of_size(np, propname,
|
|
|
- (sz * sizeof(*out_values)));
|
|
|
+ (sz_min * sizeof(*out_values)),
|
|
|
+ (sz_max * sizeof(*out_values)),
|
|
|
+ &sz);
|
|
|
|
|
|
if (IS_ERR(val))
|
|
|
return PTR_ERR(val);
|
|
|
|
|
|
- while (sz--)
|
|
|
+ if (!sz_max)
|
|
|
+ sz = sz_min;
|
|
|
+ else
|
|
|
+ sz /= sizeof(*out_values);
|
|
|
+
|
|
|
+ count = sz;
|
|
|
+ while (count--)
|
|
|
*out_values++ = *val++;
|
|
|
- return 0;
|
|
|
+
|
|
|
+ return sz;
|
|
|
}
|
|
|
-EXPORT_SYMBOL_GPL(of_property_read_u8_array);
|
|
|
+EXPORT_SYMBOL_GPL(of_property_read_variable_u8_array);
|
|
|
|
|
|
/**
|
|
|
- * of_property_read_u16_array - Find and read an array of u16 from a property.
|
|
|
+ * of_property_read_variable_u16_array - Find and read an array of u16 from a
|
|
|
+ * property, with bounds on the minimum and maximum array size.
|
|
|
*
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
* @propname: name of the property to be searched.
|
|
|
* @out_values: pointer to return value, modified only if return value is 0.
|
|
|
- * @sz: number of array elements to read
|
|
|
+ * @sz_min: minimum number of array elements to read
|
|
|
+ * @sz_max: maximum number of array elements to read, if zero there is no
|
|
|
+ * upper limit on the number of elements in the dts entry but only
|
|
|
+ * sz_min will be read.
|
|
|
*
|
|
|
* Search for a property in a device node and read 16-bit value(s) from
|
|
|
- * it. Returns 0 on success, -EINVAL if the property does not exist,
|
|
|
- * -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
- * property data isn't large enough.
|
|
|
+ * it. Returns number of elements read on success, -EINVAL if the property
|
|
|
+ * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
|
|
|
+ * if the property data is smaller than sz_min or longer than sz_max.
|
|
|
*
|
|
|
* dts entry of array should be like:
|
|
|
* property = /bits/ 16 <0x5000 0x6000 0x7000>;
|
|
|
*
|
|
|
* The out_values is modified only if a valid u16 value can be decoded.
|
|
|
*/
|
|
|
-int of_property_read_u16_array(const struct device_node *np,
|
|
|
- const char *propname, u16 *out_values, size_t sz)
|
|
|
+int of_property_read_variable_u16_array(const struct device_node *np,
|
|
|
+ const char *propname, u16 *out_values,
|
|
|
+ size_t sz_min, size_t sz_max)
|
|
|
{
|
|
|
+ size_t sz, count;
|
|
|
const __be16 *val = of_find_property_value_of_size(np, propname,
|
|
|
- (sz * sizeof(*out_values)));
|
|
|
+ (sz_min * sizeof(*out_values)),
|
|
|
+ (sz_max * sizeof(*out_values)),
|
|
|
+ &sz);
|
|
|
|
|
|
if (IS_ERR(val))
|
|
|
return PTR_ERR(val);
|
|
|
|
|
|
- while (sz--)
|
|
|
+ if (!sz_max)
|
|
|
+ sz = sz_min;
|
|
|
+ else
|
|
|
+ sz /= sizeof(*out_values);
|
|
|
+
|
|
|
+ count = sz;
|
|
|
+ while (count--)
|
|
|
*out_values++ = be16_to_cpup(val++);
|
|
|
- return 0;
|
|
|
+
|
|
|
+ return sz;
|
|
|
}
|
|
|
-EXPORT_SYMBOL_GPL(of_property_read_u16_array);
|
|
|
+EXPORT_SYMBOL_GPL(of_property_read_variable_u16_array);
|
|
|
|
|
|
/**
|
|
|
- * of_property_read_u32_array - Find and read an array of 32 bit integers
|
|
|
- * from a property.
|
|
|
+ * of_property_read_variable_u32_array - Find and read an array of 32 bit
|
|
|
+ * integers from a property, with bounds on the minimum and maximum array size.
|
|
|
*
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
* @propname: name of the property to be searched.
|
|
|
* @out_values: pointer to return value, modified only if return value is 0.
|
|
|
- * @sz: number of array elements to read
|
|
|
+ * @sz_min: minimum number of array elements to read
|
|
|
+ * @sz_max: maximum number of array elements to read, if zero there is no
|
|
|
+ * upper limit on the number of elements in the dts entry but only
|
|
|
+ * sz_min will be read.
|
|
|
*
|
|
|
* Search for a property in a device node and read 32-bit value(s) from
|
|
|
- * it. Returns 0 on success, -EINVAL if the property does not exist,
|
|
|
- * -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
- * property data isn't large enough.
|
|
|
+ * it. Returns number of elements read on success, -EINVAL if the property
|
|
|
+ * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
|
|
|
+ * if the property data is smaller than sz_min or longer than sz_max.
|
|
|
*
|
|
|
* The out_values is modified only if a valid u32 value can be decoded.
|
|
|
*/
|
|
|
-int of_property_read_u32_array(const struct device_node *np,
|
|
|
+int of_property_read_variable_u32_array(const struct device_node *np,
|
|
|
const char *propname, u32 *out_values,
|
|
|
- size_t sz)
|
|
|
+ size_t sz_min, size_t sz_max)
|
|
|
{
|
|
|
+ size_t sz, count;
|
|
|
const __be32 *val = of_find_property_value_of_size(np, propname,
|
|
|
- (sz * sizeof(*out_values)));
|
|
|
+ (sz_min * sizeof(*out_values)),
|
|
|
+ (sz_max * sizeof(*out_values)),
|
|
|
+ &sz);
|
|
|
|
|
|
if (IS_ERR(val))
|
|
|
return PTR_ERR(val);
|
|
|
|
|
|
- while (sz--)
|
|
|
+ if (!sz_max)
|
|
|
+ sz = sz_min;
|
|
|
+ else
|
|
|
+ sz /= sizeof(*out_values);
|
|
|
+
|
|
|
+ count = sz;
|
|
|
+ while (count--)
|
|
|
*out_values++ = be32_to_cpup(val++);
|
|
|
- return 0;
|
|
|
+
|
|
|
+ return sz;
|
|
|
}
|
|
|
-EXPORT_SYMBOL_GPL(of_property_read_u32_array);
|
|
|
+EXPORT_SYMBOL_GPL(of_property_read_variable_u32_array);
|
|
|
|
|
|
/**
|
|
|
* of_property_read_u64 - Find and read a 64 bit integer from a property
|
|
|
@@ -1314,7 +1366,9 @@ int of_property_read_u64(const struct device_node *np, const char *propname,
|
|
|
u64 *out_value)
|
|
|
{
|
|
|
const __be32 *val = of_find_property_value_of_size(np, propname,
|
|
|
- sizeof(*out_value));
|
|
|
+ sizeof(*out_value),
|
|
|
+ 0,
|
|
|
+ NULL);
|
|
|
|
|
|
if (IS_ERR(val))
|
|
|
return PTR_ERR(val);
|
|
|
@@ -1325,38 +1379,51 @@ int of_property_read_u64(const struct device_node *np, const char *propname,
|
|
|
EXPORT_SYMBOL_GPL(of_property_read_u64);
|
|
|
|
|
|
/**
|
|
|
- * of_property_read_u64_array - Find and read an array of 64 bit integers
|
|
|
- * from a property.
|
|
|
+ * of_property_read_variable_u64_array - Find and read an array of 64 bit
|
|
|
+ * integers from a property, with bounds on the minimum and maximum array size.
|
|
|
*
|
|
|
* @np: device node from which the property value is to be read.
|
|
|
* @propname: name of the property to be searched.
|
|
|
* @out_values: pointer to return value, modified only if return value is 0.
|
|
|
- * @sz: number of array elements to read
|
|
|
+ * @sz_min: minimum number of array elements to read
|
|
|
+ * @sz_max: maximum number of array elements to read, if zero there is no
|
|
|
+ * upper limit on the number of elements in the dts entry but only
|
|
|
+ * sz_min will be read.
|
|
|
*
|
|
|
* Search for a property in a device node and read 64-bit value(s) from
|
|
|
- * it. Returns 0 on success, -EINVAL if the property does not exist,
|
|
|
- * -ENODATA if property does not have a value, and -EOVERFLOW if the
|
|
|
- * property data isn't large enough.
|
|
|
+ * it. Returns number of elements read on success, -EINVAL if the property
|
|
|
+ * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW
|
|
|
+ * if the property data is smaller than sz_min or longer than sz_max.
|
|
|
*
|
|
|
* The out_values is modified only if a valid u64 value can be decoded.
|
|
|
*/
|
|
|
-int of_property_read_u64_array(const struct device_node *np,
|
|
|
+int of_property_read_variable_u64_array(const struct device_node *np,
|
|
|
const char *propname, u64 *out_values,
|
|
|
- size_t sz)
|
|
|
+ size_t sz_min, size_t sz_max)
|
|
|
{
|
|
|
+ size_t sz, count;
|
|
|
const __be32 *val = of_find_property_value_of_size(np, propname,
|
|
|
- (sz * sizeof(*out_values)));
|
|
|
+ (sz_min * sizeof(*out_values)),
|
|
|
+ (sz_max * sizeof(*out_values)),
|
|
|
+ &sz);
|
|
|
|
|
|
if (IS_ERR(val))
|
|
|
return PTR_ERR(val);
|
|
|
|
|
|
- while (sz--) {
|
|
|
+ if (!sz_max)
|
|
|
+ sz = sz_min;
|
|
|
+ else
|
|
|
+ sz /= sizeof(*out_values);
|
|
|
+
|
|
|
+ count = sz;
|
|
|
+ while (count--) {
|
|
|
*out_values++ = of_read_number(val, 2);
|
|
|
val += 2;
|
|
|
}
|
|
|
- return 0;
|
|
|
+
|
|
|
+ return sz;
|
|
|
}
|
|
|
-EXPORT_SYMBOL_GPL(of_property_read_u64_array);
|
|
|
+EXPORT_SYMBOL_GPL(of_property_read_variable_u64_array);
|
|
|
|
|
|
/**
|
|
|
* of_property_read_string - Find and read a string from a property
|
Linus Torvalds