1/* 2 * property.c - Unified device property interface. 3 * 4 * Copyright (C) 2014, Intel Corporation 5 * Authors: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 6 * Mika Westerberg <mika.westerberg@linux.intel.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13#include <linux/acpi.h> 14#include <linux/export.h> 15#include <linux/kernel.h> 16#include <linux/of.h> 17#include <linux/property.h> 18 19/** 20 * device_add_property_set - Add a collection of properties to a device object. 21 * @dev: Device to add properties to. 22 * @pset: Collection of properties to add. 23 * 24 * Associate a collection of device properties represented by @pset with @dev 25 * as its secondary firmware node. 26 */ 27void device_add_property_set(struct device *dev, struct property_set *pset) 28{ 29 if (!pset) 30 return; 31 32 pset->fwnode.type = FWNODE_PDATA; 33 set_secondary_fwnode(dev, &pset->fwnode); 34} 35EXPORT_SYMBOL_GPL(device_add_property_set); 36 37static inline bool is_pset(struct fwnode_handle *fwnode) 38{ 39 return fwnode && fwnode->type == FWNODE_PDATA; 40} 41 42static inline struct property_set *to_pset(struct fwnode_handle *fwnode) 43{ 44 return is_pset(fwnode) ? 45 container_of(fwnode, struct property_set, fwnode) : NULL; 46} 47 48static struct property_entry *pset_prop_get(struct property_set *pset, 49 const char *name) 50{ 51 struct property_entry *prop; 52 53 if (!pset || !pset->properties) 54 return NULL; 55 56 for (prop = pset->properties; prop->name; prop++) 57 if (!strcmp(name, prop->name)) 58 return prop; 59 60 return NULL; 61} 62 63static int pset_prop_read_array(struct property_set *pset, const char *name, 64 enum dev_prop_type type, void *val, size_t nval) 65{ 66 struct property_entry *prop; 67 unsigned int item_size; 68 69 prop = pset_prop_get(pset, name); 70 if (!prop) 71 return -ENODATA; 72 73 if (prop->type != type) 74 return -EPROTO; 75 76 if (!val) 77 return prop->nval; 78 79 if (prop->nval < nval) 80 return -EOVERFLOW; 81 82 switch (type) { 83 case DEV_PROP_U8: 84 item_size = sizeof(u8); 85 break; 86 case DEV_PROP_U16: 87 item_size = sizeof(u16); 88 break; 89 case DEV_PROP_U32: 90 item_size = sizeof(u32); 91 break; 92 case DEV_PROP_U64: 93 item_size = sizeof(u64); 94 break; 95 case DEV_PROP_STRING: 96 item_size = sizeof(const char *); 97 break; 98 default: 99 return -EINVAL; 100 } 101 memcpy(val, prop->value.raw_data, nval * item_size); 102 return 0; 103} 104 105static inline struct fwnode_handle *dev_fwnode(struct device *dev) 106{ 107 return IS_ENABLED(CONFIG_OF) && dev->of_node ? 108 &dev->of_node->fwnode : dev->fwnode; 109} 110 111/** 112 * device_property_present - check if a property of a device is present 113 * @dev: Device whose property is being checked 114 * @propname: Name of the property 115 * 116 * Check if property @propname is present in the device firmware description. 117 */ 118bool device_property_present(struct device *dev, const char *propname) 119{ 120 return fwnode_property_present(dev_fwnode(dev), propname); 121} 122EXPORT_SYMBOL_GPL(device_property_present); 123 124/** 125 * fwnode_property_present - check if a property of a firmware node is present 126 * @fwnode: Firmware node whose property to check 127 * @propname: Name of the property 128 */ 129bool fwnode_property_present(struct fwnode_handle *fwnode, const char *propname) 130{ 131 if (is_of_node(fwnode)) 132 return of_property_read_bool(of_node(fwnode), propname); 133 else if (is_acpi_node(fwnode)) 134 return !acpi_dev_prop_get(acpi_node(fwnode), propname, NULL); 135 136 return !!pset_prop_get(to_pset(fwnode), propname); 137} 138EXPORT_SYMBOL_GPL(fwnode_property_present); 139 140/** 141 * device_property_read_u8_array - return a u8 array property of a device 142 * @dev: Device to get the property of 143 * @propname: Name of the property 144 * @val: The values are stored here or %NULL to return the number of values 145 * @nval: Size of the @val array 146 * 147 * Function reads an array of u8 properties with @propname from the device 148 * firmware description and stores them to @val if found. 149 * 150 * Return: number of values if @val was %NULL, 151 * %0 if the property was found (success), 152 * %-EINVAL if given arguments are not valid, 153 * %-ENODATA if the property does not have a value, 154 * %-EPROTO if the property is not an array of numbers, 155 * %-EOVERFLOW if the size of the property is not as expected. 156 */ 157int device_property_read_u8_array(struct device *dev, const char *propname, 158 u8 *val, size_t nval) 159{ 160 return fwnode_property_read_u8_array(dev_fwnode(dev), propname, val, nval); 161} 162EXPORT_SYMBOL_GPL(device_property_read_u8_array); 163 164/** 165 * device_property_read_u16_array - return a u16 array property of a device 166 * @dev: Device to get the property of 167 * @propname: Name of the property 168 * @val: The values are stored here or %NULL to return the number of values 169 * @nval: Size of the @val array 170 * 171 * Function reads an array of u16 properties with @propname from the device 172 * firmware description and stores them to @val if found. 173 * 174 * Return: number of values if @val was %NULL, 175 * %0 if the property was found (success), 176 * %-EINVAL if given arguments are not valid, 177 * %-ENODATA if the property does not have a value, 178 * %-EPROTO if the property is not an array of numbers, 179 * %-EOVERFLOW if the size of the property is not as expected. 180 */ 181int device_property_read_u16_array(struct device *dev, const char *propname, 182 u16 *val, size_t nval) 183{ 184 return fwnode_property_read_u16_array(dev_fwnode(dev), propname, val, nval); 185} 186EXPORT_SYMBOL_GPL(device_property_read_u16_array); 187 188/** 189 * device_property_read_u32_array - return a u32 array property of a device 190 * @dev: Device to get the property of 191 * @propname: Name of the property 192 * @val: The values are stored here or %NULL to return the number of values 193 * @nval: Size of the @val array 194 * 195 * Function reads an array of u32 properties with @propname from the device 196 * firmware description and stores them to @val if found. 197 * 198 * Return: number of values if @val was %NULL, 199 * %0 if the property was found (success), 200 * %-EINVAL if given arguments are not valid, 201 * %-ENODATA if the property does not have a value, 202 * %-EPROTO if the property is not an array of numbers, 203 * %-EOVERFLOW if the size of the property is not as expected. 204 */ 205int device_property_read_u32_array(struct device *dev, const char *propname, 206 u32 *val, size_t nval) 207{ 208 return fwnode_property_read_u32_array(dev_fwnode(dev), propname, val, nval); 209} 210EXPORT_SYMBOL_GPL(device_property_read_u32_array); 211 212/** 213 * device_property_read_u64_array - return a u64 array property of a device 214 * @dev: Device to get the property of 215 * @propname: Name of the property 216 * @val: The values are stored here or %NULL to return the number of values 217 * @nval: Size of the @val array 218 * 219 * Function reads an array of u64 properties with @propname from the device 220 * firmware description and stores them to @val if found. 221 * 222 * Return: number of values if @val was %NULL, 223 * %0 if the property was found (success), 224 * %-EINVAL if given arguments are not valid, 225 * %-ENODATA if the property does not have a value, 226 * %-EPROTO if the property is not an array of numbers, 227 * %-EOVERFLOW if the size of the property is not as expected. 228 */ 229int device_property_read_u64_array(struct device *dev, const char *propname, 230 u64 *val, size_t nval) 231{ 232 return fwnode_property_read_u64_array(dev_fwnode(dev), propname, val, nval); 233} 234EXPORT_SYMBOL_GPL(device_property_read_u64_array); 235 236/** 237 * device_property_read_string_array - return a string array property of device 238 * @dev: Device to get the property of 239 * @propname: Name of the property 240 * @val: The values are stored here or %NULL to return the number of values 241 * @nval: Size of the @val array 242 * 243 * Function reads an array of string properties with @propname from the device 244 * firmware description and stores them to @val if found. 245 * 246 * Return: number of values if @val was %NULL, 247 * %0 if the property was found (success), 248 * %-EINVAL if given arguments are not valid, 249 * %-ENODATA if the property does not have a value, 250 * %-EPROTO or %-EILSEQ if the property is not an array of strings, 251 * %-EOVERFLOW if the size of the property is not as expected. 252 */ 253int device_property_read_string_array(struct device *dev, const char *propname, 254 const char **val, size_t nval) 255{ 256 return fwnode_property_read_string_array(dev_fwnode(dev), propname, val, nval); 257} 258EXPORT_SYMBOL_GPL(device_property_read_string_array); 259 260/** 261 * device_property_read_string - return a string property of a device 262 * @dev: Device to get the property of 263 * @propname: Name of the property 264 * @val: The value is stored here 265 * 266 * Function reads property @propname from the device firmware description and 267 * stores the value into @val if found. The value is checked to be a string. 268 * 269 * Return: %0 if the property was found (success), 270 * %-EINVAL if given arguments are not valid, 271 * %-ENODATA if the property does not have a value, 272 * %-EPROTO or %-EILSEQ if the property type is not a string. 273 */ 274int device_property_read_string(struct device *dev, const char *propname, 275 const char **val) 276{ 277 return fwnode_property_read_string(dev_fwnode(dev), propname, val); 278} 279EXPORT_SYMBOL_GPL(device_property_read_string); 280 281#define OF_DEV_PROP_READ_ARRAY(node, propname, type, val, nval) \ 282 (val) ? of_property_read_##type##_array((node), (propname), (val), (nval)) \ 283 : of_property_count_elems_of_size((node), (propname), sizeof(type)) 284 285#define FWNODE_PROP_READ_ARRAY(_fwnode_, _propname_, _type_, _proptype_, _val_, _nval_) \ 286({ \ 287 int _ret_; \ 288 if (is_of_node(_fwnode_)) \ 289 _ret_ = OF_DEV_PROP_READ_ARRAY(of_node(_fwnode_), _propname_, \ 290 _type_, _val_, _nval_); \ 291 else if (is_acpi_node(_fwnode_)) \ 292 _ret_ = acpi_dev_prop_read(acpi_node(_fwnode_), _propname_, \ 293 _proptype_, _val_, _nval_); \ 294 else \ 295 _ret_ = pset_prop_read_array(to_pset(_fwnode_), _propname_, \ 296 _proptype_, _val_, _nval_); \ 297 _ret_; \ 298}) 299 300/** 301 * fwnode_property_read_u8_array - return a u8 array property of firmware node 302 * @fwnode: Firmware node to get the property of 303 * @propname: Name of the property 304 * @val: The values are stored here or %NULL to return the number of values 305 * @nval: Size of the @val array 306 * 307 * Read an array of u8 properties with @propname from @fwnode and stores them to 308 * @val if found. 309 * 310 * Return: number of values if @val was %NULL, 311 * %0 if the property was found (success), 312 * %-EINVAL if given arguments are not valid, 313 * %-ENODATA if the property does not have a value, 314 * %-EPROTO if the property is not an array of numbers, 315 * %-EOVERFLOW if the size of the property is not as expected, 316 * %-ENXIO if no suitable firmware interface is present. 317 */ 318int fwnode_property_read_u8_array(struct fwnode_handle *fwnode, 319 const char *propname, u8 *val, size_t nval) 320{ 321 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u8, DEV_PROP_U8, 322 val, nval); 323} 324EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array); 325 326/** 327 * fwnode_property_read_u16_array - return a u16 array property of firmware node 328 * @fwnode: Firmware node to get the property of 329 * @propname: Name of the property 330 * @val: The values are stored here or %NULL to return the number of values 331 * @nval: Size of the @val array 332 * 333 * Read an array of u16 properties with @propname from @fwnode and store them to 334 * @val if found. 335 * 336 * Return: number of values if @val was %NULL, 337 * %0 if the property was found (success), 338 * %-EINVAL if given arguments are not valid, 339 * %-ENODATA if the property does not have a value, 340 * %-EPROTO if the property is not an array of numbers, 341 * %-EOVERFLOW if the size of the property is not as expected, 342 * %-ENXIO if no suitable firmware interface is present. 343 */ 344int fwnode_property_read_u16_array(struct fwnode_handle *fwnode, 345 const char *propname, u16 *val, size_t nval) 346{ 347 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u16, DEV_PROP_U16, 348 val, nval); 349} 350EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array); 351 352/** 353 * fwnode_property_read_u32_array - return a u32 array property of firmware node 354 * @fwnode: Firmware node to get the property of 355 * @propname: Name of the property 356 * @val: The values are stored here or %NULL to return the number of values 357 * @nval: Size of the @val array 358 * 359 * Read an array of u32 properties with @propname from @fwnode store them to 360 * @val if found. 361 * 362 * Return: number of values if @val was %NULL, 363 * %0 if the property was found (success), 364 * %-EINVAL if given arguments are not valid, 365 * %-ENODATA if the property does not have a value, 366 * %-EPROTO if the property is not an array of numbers, 367 * %-EOVERFLOW if the size of the property is not as expected, 368 * %-ENXIO if no suitable firmware interface is present. 369 */ 370int fwnode_property_read_u32_array(struct fwnode_handle *fwnode, 371 const char *propname, u32 *val, size_t nval) 372{ 373 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u32, DEV_PROP_U32, 374 val, nval); 375} 376EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array); 377 378/** 379 * fwnode_property_read_u64_array - return a u64 array property firmware node 380 * @fwnode: Firmware node to get the property of 381 * @propname: Name of the property 382 * @val: The values are stored here or %NULL to return the number of values 383 * @nval: Size of the @val array 384 * 385 * Read an array of u64 properties with @propname from @fwnode and store them to 386 * @val if found. 387 * 388 * Return: number of values if @val was %NULL, 389 * %0 if the property was found (success), 390 * %-EINVAL if given arguments are not valid, 391 * %-ENODATA if the property does not have a value, 392 * %-EPROTO if the property is not an array of numbers, 393 * %-EOVERFLOW if the size of the property is not as expected, 394 * %-ENXIO if no suitable firmware interface is present. 395 */ 396int fwnode_property_read_u64_array(struct fwnode_handle *fwnode, 397 const char *propname, u64 *val, size_t nval) 398{ 399 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u64, DEV_PROP_U64, 400 val, nval); 401} 402EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array); 403 404/** 405 * fwnode_property_read_string_array - return string array property of a node 406 * @fwnode: Firmware node to get the property of 407 * @propname: Name of the property 408 * @val: The values are stored here or %NULL to return the number of values 409 * @nval: Size of the @val array 410 * 411 * Read an string list property @propname from the given firmware node and store 412 * them to @val if found. 413 * 414 * Return: number of values if @val was %NULL, 415 * %0 if the property was found (success), 416 * %-EINVAL if given arguments are not valid, 417 * %-ENODATA if the property does not have a value, 418 * %-EPROTO if the property is not an array of strings, 419 * %-EOVERFLOW if the size of the property is not as expected, 420 * %-ENXIO if no suitable firmware interface is present. 421 */ 422int fwnode_property_read_string_array(struct fwnode_handle *fwnode, 423 const char *propname, const char **val, 424 size_t nval) 425{ 426 if (is_of_node(fwnode)) 427 return val ? 428 of_property_read_string_array(of_node(fwnode), propname, 429 val, nval) : 430 of_property_count_strings(of_node(fwnode), propname); 431 else if (is_acpi_node(fwnode)) 432 return acpi_dev_prop_read(acpi_node(fwnode), propname, 433 DEV_PROP_STRING, val, nval); 434 435 return pset_prop_read_array(to_pset(fwnode), propname, 436 DEV_PROP_STRING, val, nval); 437} 438EXPORT_SYMBOL_GPL(fwnode_property_read_string_array); 439 440/** 441 * fwnode_property_read_string - return a string property of a firmware node 442 * @fwnode: Firmware node to get the property of 443 * @propname: Name of the property 444 * @val: The value is stored here 445 * 446 * Read property @propname from the given firmware node and store the value into 447 * @val if found. The value is checked to be a string. 448 * 449 * Return: %0 if the property was found (success), 450 * %-EINVAL if given arguments are not valid, 451 * %-ENODATA if the property does not have a value, 452 * %-EPROTO or %-EILSEQ if the property is not a string, 453 * %-ENXIO if no suitable firmware interface is present. 454 */ 455int fwnode_property_read_string(struct fwnode_handle *fwnode, 456 const char *propname, const char **val) 457{ 458 if (is_of_node(fwnode)) 459 return of_property_read_string(of_node(fwnode), propname, val); 460 else if (is_acpi_node(fwnode)) 461 return acpi_dev_prop_read(acpi_node(fwnode), propname, 462 DEV_PROP_STRING, val, 1); 463 464 return -ENXIO; 465} 466EXPORT_SYMBOL_GPL(fwnode_property_read_string); 467 468/** 469 * device_get_next_child_node - Return the next child node handle for a device 470 * @dev: Device to find the next child node for. 471 * @child: Handle to one of the device's child nodes or a null handle. 472 */ 473struct fwnode_handle *device_get_next_child_node(struct device *dev, 474 struct fwnode_handle *child) 475{ 476 if (IS_ENABLED(CONFIG_OF) && dev->of_node) { 477 struct device_node *node; 478 479 node = of_get_next_available_child(dev->of_node, of_node(child)); 480 if (node) 481 return &node->fwnode; 482 } else if (IS_ENABLED(CONFIG_ACPI)) { 483 struct acpi_device *node; 484 485 node = acpi_get_next_child(dev, acpi_node(child)); 486 if (node) 487 return acpi_fwnode_handle(node); 488 } 489 return NULL; 490} 491EXPORT_SYMBOL_GPL(device_get_next_child_node); 492 493/** 494 * fwnode_handle_put - Drop reference to a device node 495 * @fwnode: Pointer to the device node to drop the reference to. 496 * 497 * This has to be used when terminating device_for_each_child_node() iteration 498 * with break or return to prevent stale device node references from being left 499 * behind. 500 */ 501void fwnode_handle_put(struct fwnode_handle *fwnode) 502{ 503 if (is_of_node(fwnode)) 504 of_node_put(of_node(fwnode)); 505} 506EXPORT_SYMBOL_GPL(fwnode_handle_put); 507 508/** 509 * device_get_child_node_count - return the number of child nodes for device 510 * @dev: Device to cound the child nodes for 511 */ 512unsigned int device_get_child_node_count(struct device *dev) 513{ 514 struct fwnode_handle *child; 515 unsigned int count = 0; 516 517 device_for_each_child_node(dev, child) 518 count++; 519 520 return count; 521} 522EXPORT_SYMBOL_GPL(device_get_child_node_count); 523