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/property.h> 14 #include <linux/export.h> 15 #include <linux/acpi.h> 16 #include <linux/of.h> 17 18 /** 19 * device_property_present - check if a property of a device is present 20 * @dev: Device whose property is being checked 21 * @propname: Name of the property 22 * 23 * Check if property @propname is present in the device firmware description. 24 */ 25 bool device_property_present(struct device *dev, const char *propname) 26 { 27 if (IS_ENABLED(CONFIG_OF) && dev->of_node) 28 return of_property_read_bool(dev->of_node, propname); 29 30 return !acpi_dev_prop_get(ACPI_COMPANION(dev), propname, NULL); 31 } 32 EXPORT_SYMBOL_GPL(device_property_present); 33 34 /** 35 * fwnode_property_present - check if a property of a firmware node is present 36 * @fwnode: Firmware node whose property to check 37 * @propname: Name of the property 38 */ 39 bool fwnode_property_present(struct fwnode_handle *fwnode, const char *propname) 40 { 41 if (is_of_node(fwnode)) 42 return of_property_read_bool(of_node(fwnode), propname); 43 else if (is_acpi_node(fwnode)) 44 return !acpi_dev_prop_get(acpi_node(fwnode), propname, NULL); 45 46 return false; 47 } 48 EXPORT_SYMBOL_GPL(fwnode_property_present); 49 50 #define OF_DEV_PROP_READ_ARRAY(node, propname, type, val, nval) \ 51 (val) ? of_property_read_##type##_array((node), (propname), (val), (nval)) \ 52 : of_property_count_elems_of_size((node), (propname), sizeof(type)) 53 54 #define DEV_PROP_READ_ARRAY(_dev_, _propname_, _type_, _proptype_, _val_, _nval_) \ 55 IS_ENABLED(CONFIG_OF) && _dev_->of_node ? \ 56 (OF_DEV_PROP_READ_ARRAY(_dev_->of_node, _propname_, _type_, \ 57 _val_, _nval_)) : \ 58 acpi_dev_prop_read(ACPI_COMPANION(_dev_), _propname_, \ 59 _proptype_, _val_, _nval_) 60 61 /** 62 * device_property_read_u8_array - return a u8 array property of a device 63 * @dev: Device to get the property of 64 * @propname: Name of the property 65 * @val: The values are stored here 66 * @nval: Size of the @val array 67 * 68 * Function reads an array of u8 properties with @propname from the device 69 * firmware description and stores them to @val if found. 70 * 71 * Return: %0 if the property was found (success), 72 * %-EINVAL if given arguments are not valid, 73 * %-ENODATA if the property does not have a value, 74 * %-EPROTO if the property is not an array of numbers, 75 * %-EOVERFLOW if the size of the property is not as expected. 76 */ 77 int device_property_read_u8_array(struct device *dev, const char *propname, 78 u8 *val, size_t nval) 79 { 80 return DEV_PROP_READ_ARRAY(dev, propname, u8, DEV_PROP_U8, val, nval); 81 } 82 EXPORT_SYMBOL_GPL(device_property_read_u8_array); 83 84 /** 85 * device_property_read_u16_array - return a u16 array property of a device 86 * @dev: Device to get the property of 87 * @propname: Name of the property 88 * @val: The values are stored here 89 * @nval: Size of the @val array 90 * 91 * Function reads an array of u16 properties with @propname from the device 92 * firmware description and stores them to @val if found. 93 * 94 * Return: %0 if the property was found (success), 95 * %-EINVAL if given arguments are not valid, 96 * %-ENODATA if the property does not have a value, 97 * %-EPROTO if the property is not an array of numbers, 98 * %-EOVERFLOW if the size of the property is not as expected. 99 */ 100 int device_property_read_u16_array(struct device *dev, const char *propname, 101 u16 *val, size_t nval) 102 { 103 return DEV_PROP_READ_ARRAY(dev, propname, u16, DEV_PROP_U16, val, nval); 104 } 105 EXPORT_SYMBOL_GPL(device_property_read_u16_array); 106 107 /** 108 * device_property_read_u32_array - return a u32 array property of a device 109 * @dev: Device to get the property of 110 * @propname: Name of the property 111 * @val: The values are stored here 112 * @nval: Size of the @val array 113 * 114 * Function reads an array of u32 properties with @propname from the device 115 * firmware description and stores them to @val if found. 116 * 117 * Return: %0 if the property was found (success), 118 * %-EINVAL if given arguments are not valid, 119 * %-ENODATA if the property does not have a value, 120 * %-EPROTO if the property is not an array of numbers, 121 * %-EOVERFLOW if the size of the property is not as expected. 122 */ 123 int device_property_read_u32_array(struct device *dev, const char *propname, 124 u32 *val, size_t nval) 125 { 126 return DEV_PROP_READ_ARRAY(dev, propname, u32, DEV_PROP_U32, val, nval); 127 } 128 EXPORT_SYMBOL_GPL(device_property_read_u32_array); 129 130 /** 131 * device_property_read_u64_array - return a u64 array property of a device 132 * @dev: Device to get the property of 133 * @propname: Name of the property 134 * @val: The values are stored here 135 * @nval: Size of the @val array 136 * 137 * Function reads an array of u64 properties with @propname from the device 138 * firmware description and stores them to @val if found. 139 * 140 * Return: %0 if the property was found (success), 141 * %-EINVAL if given arguments are not valid, 142 * %-ENODATA if the property does not have a value, 143 * %-EPROTO if the property is not an array of numbers, 144 * %-EOVERFLOW if the size of the property is not as expected. 145 */ 146 int device_property_read_u64_array(struct device *dev, const char *propname, 147 u64 *val, size_t nval) 148 { 149 return DEV_PROP_READ_ARRAY(dev, propname, u64, DEV_PROP_U64, val, nval); 150 } 151 EXPORT_SYMBOL_GPL(device_property_read_u64_array); 152 153 /** 154 * device_property_read_string_array - return a string array property of device 155 * @dev: Device to get the property of 156 * @propname: Name of the property 157 * @val: The values are stored here 158 * @nval: Size of the @val array 159 * 160 * Function reads an array of string properties with @propname from the device 161 * firmware description and stores them to @val if found. 162 * 163 * Return: %0 if the property was found (success), 164 * %-EINVAL if given arguments are not valid, 165 * %-ENODATA if the property does not have a value, 166 * %-EPROTO or %-EILSEQ if the property is not an array of strings, 167 * %-EOVERFLOW if the size of the property is not as expected. 168 */ 169 int device_property_read_string_array(struct device *dev, const char *propname, 170 const char **val, size_t nval) 171 { 172 return IS_ENABLED(CONFIG_OF) && dev->of_node ? 173 of_property_read_string_array(dev->of_node, propname, val, nval) : 174 acpi_dev_prop_read(ACPI_COMPANION(dev), propname, 175 DEV_PROP_STRING, val, nval); 176 } 177 EXPORT_SYMBOL_GPL(device_property_read_string_array); 178 179 /** 180 * device_property_read_string - return a string property of a device 181 * @dev: Device to get the property of 182 * @propname: Name of the property 183 * @val: The value is stored here 184 * 185 * Function reads property @propname from the device firmware description and 186 * stores the value into @val if found. The value is checked to be a string. 187 * 188 * Return: %0 if the property was found (success), 189 * %-EINVAL if given arguments are not valid, 190 * %-ENODATA if the property does not have a value, 191 * %-EPROTO or %-EILSEQ if the property type is not a string. 192 */ 193 int device_property_read_string(struct device *dev, const char *propname, 194 const char **val) 195 { 196 return IS_ENABLED(CONFIG_OF) && dev->of_node ? 197 of_property_read_string(dev->of_node, propname, val) : 198 acpi_dev_prop_read(ACPI_COMPANION(dev), propname, 199 DEV_PROP_STRING, val, 1); 200 } 201 EXPORT_SYMBOL_GPL(device_property_read_string); 202 203 #define FWNODE_PROP_READ_ARRAY(_fwnode_, _propname_, _type_, _proptype_, _val_, _nval_) \ 204 ({ \ 205 int _ret_; \ 206 if (is_of_node(_fwnode_)) \ 207 _ret_ = OF_DEV_PROP_READ_ARRAY(of_node(_fwnode_), _propname_, \ 208 _type_, _val_, _nval_); \ 209 else if (is_acpi_node(_fwnode_)) \ 210 _ret_ = acpi_dev_prop_read(acpi_node(_fwnode_), _propname_, \ 211 _proptype_, _val_, _nval_); \ 212 else \ 213 _ret_ = -ENXIO; \ 214 _ret_; \ 215 }) 216 217 /** 218 * fwnode_property_read_u8_array - return a u8 array property of firmware node 219 * @fwnode: Firmware node to get the property of 220 * @propname: Name of the property 221 * @val: The values are stored here 222 * @nval: Size of the @val array 223 * 224 * Read an array of u8 properties with @propname from @fwnode and stores them to 225 * @val if found. 226 * 227 * Return: %0 if the property was found (success), 228 * %-EINVAL if given arguments are not valid, 229 * %-ENODATA if the property does not have a value, 230 * %-EPROTO if the property is not an array of numbers, 231 * %-EOVERFLOW if the size of the property is not as expected, 232 * %-ENXIO if no suitable firmware interface is present. 233 */ 234 int fwnode_property_read_u8_array(struct fwnode_handle *fwnode, 235 const char *propname, u8 *val, size_t nval) 236 { 237 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u8, DEV_PROP_U8, 238 val, nval); 239 } 240 EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array); 241 242 /** 243 * fwnode_property_read_u16_array - return a u16 array property of firmware node 244 * @fwnode: Firmware node to get the property of 245 * @propname: Name of the property 246 * @val: The values are stored here 247 * @nval: Size of the @val array 248 * 249 * Read an array of u16 properties with @propname from @fwnode and store them to 250 * @val if found. 251 * 252 * Return: %0 if the property was found (success), 253 * %-EINVAL if given arguments are not valid, 254 * %-ENODATA if the property does not have a value, 255 * %-EPROTO if the property is not an array of numbers, 256 * %-EOVERFLOW if the size of the property is not as expected, 257 * %-ENXIO if no suitable firmware interface is present. 258 */ 259 int fwnode_property_read_u16_array(struct fwnode_handle *fwnode, 260 const char *propname, u16 *val, size_t nval) 261 { 262 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u16, DEV_PROP_U16, 263 val, nval); 264 } 265 EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array); 266 267 /** 268 * fwnode_property_read_u32_array - return a u32 array property of firmware node 269 * @fwnode: Firmware node to get the property of 270 * @propname: Name of the property 271 * @val: The values are stored here 272 * @nval: Size of the @val array 273 * 274 * Read an array of u32 properties with @propname from @fwnode store them to 275 * @val if found. 276 * 277 * Return: %0 if the property was found (success), 278 * %-EINVAL if given arguments are not valid, 279 * %-ENODATA if the property does not have a value, 280 * %-EPROTO if the property is not an array of numbers, 281 * %-EOVERFLOW if the size of the property is not as expected, 282 * %-ENXIO if no suitable firmware interface is present. 283 */ 284 int fwnode_property_read_u32_array(struct fwnode_handle *fwnode, 285 const char *propname, u32 *val, size_t nval) 286 { 287 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u32, DEV_PROP_U32, 288 val, nval); 289 } 290 EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array); 291 292 /** 293 * fwnode_property_read_u64_array - return a u64 array property firmware node 294 * @fwnode: Firmware node to get the property of 295 * @propname: Name of the property 296 * @val: The values are stored here 297 * @nval: Size of the @val array 298 * 299 * Read an array of u64 properties with @propname from @fwnode and store them to 300 * @val if found. 301 * 302 * Return: %0 if the property was found (success), 303 * %-EINVAL if given arguments are not valid, 304 * %-ENODATA if the property does not have a value, 305 * %-EPROTO if the property is not an array of numbers, 306 * %-EOVERFLOW if the size of the property is not as expected, 307 * %-ENXIO if no suitable firmware interface is present. 308 */ 309 int fwnode_property_read_u64_array(struct fwnode_handle *fwnode, 310 const char *propname, u64 *val, size_t nval) 311 { 312 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u64, DEV_PROP_U64, 313 val, nval); 314 } 315 EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array); 316 317 /** 318 * fwnode_property_read_string_array - return string array property of a node 319 * @fwnode: Firmware node to get the property of 320 * @propname: Name of the property 321 * @val: The values are stored here 322 * @nval: Size of the @val array 323 * 324 * Read an string list property @propname from the given firmware node and store 325 * them to @val if found. 326 * 327 * Return: %0 if the property was found (success), 328 * %-EINVAL if given arguments are not valid, 329 * %-ENODATA if the property does not have a value, 330 * %-EPROTO if the property is not an array of strings, 331 * %-EOVERFLOW if the size of the property is not as expected, 332 * %-ENXIO if no suitable firmware interface is present. 333 */ 334 int fwnode_property_read_string_array(struct fwnode_handle *fwnode, 335 const char *propname, const char **val, 336 size_t nval) 337 { 338 if (is_of_node(fwnode)) 339 return of_property_read_string_array(of_node(fwnode), propname, 340 val, nval); 341 else if (is_acpi_node(fwnode)) 342 return acpi_dev_prop_read(acpi_node(fwnode), propname, 343 DEV_PROP_STRING, val, nval); 344 345 return -ENXIO; 346 } 347 EXPORT_SYMBOL_GPL(fwnode_property_read_string_array); 348 349 /** 350 * fwnode_property_read_string - return a string property of a firmware node 351 * @fwnode: Firmware node to get the property of 352 * @propname: Name of the property 353 * @val: The value is stored here 354 * 355 * Read property @propname from the given firmware node and store the value into 356 * @val if found. The value is checked to be a string. 357 * 358 * Return: %0 if the property was found (success), 359 * %-EINVAL if given arguments are not valid, 360 * %-ENODATA if the property does not have a value, 361 * %-EPROTO or %-EILSEQ if the property is not a string, 362 * %-ENXIO if no suitable firmware interface is present. 363 */ 364 int fwnode_property_read_string(struct fwnode_handle *fwnode, 365 const char *propname, const char **val) 366 { 367 if (is_of_node(fwnode)) 368 return of_property_read_string(of_node(fwnode),propname, val); 369 else if (is_acpi_node(fwnode)) 370 return acpi_dev_prop_read(acpi_node(fwnode), propname, 371 DEV_PROP_STRING, val, 1); 372 373 return -ENXIO; 374 } 375 EXPORT_SYMBOL_GPL(fwnode_property_read_string); 376 377 /** 378 * device_get_next_child_node - Return the next child node handle for a device 379 * @dev: Device to find the next child node for. 380 * @child: Handle to one of the device's child nodes or a null handle. 381 */ 382 struct fwnode_handle *device_get_next_child_node(struct device *dev, 383 struct fwnode_handle *child) 384 { 385 if (IS_ENABLED(CONFIG_OF) && dev->of_node) { 386 struct device_node *node; 387 388 node = of_get_next_available_child(dev->of_node, of_node(child)); 389 if (node) 390 return &node->fwnode; 391 } else if (IS_ENABLED(CONFIG_ACPI)) { 392 struct acpi_device *node; 393 394 node = acpi_get_next_child(dev, acpi_node(child)); 395 if (node) 396 return acpi_fwnode_handle(node); 397 } 398 return NULL; 399 } 400 EXPORT_SYMBOL_GPL(device_get_next_child_node); 401 402 /** 403 * fwnode_handle_put - Drop reference to a device node 404 * @fwnode: Pointer to the device node to drop the reference to. 405 * 406 * This has to be used when terminating device_for_each_child_node() iteration 407 * with break or return to prevent stale device node references from being left 408 * behind. 409 */ 410 void fwnode_handle_put(struct fwnode_handle *fwnode) 411 { 412 if (is_of_node(fwnode)) 413 of_node_put(of_node(fwnode)); 414 } 415 EXPORT_SYMBOL_GPL(fwnode_handle_put); 416 417 /** 418 * device_get_child_node_count - return the number of child nodes for device 419 * @dev: Device to cound the child nodes for 420 */ 421 unsigned int device_get_child_node_count(struct device *dev) 422 { 423 struct fwnode_handle *child; 424 unsigned int count = 0; 425 426 device_for_each_child_node(dev, child) 427 count++; 428 429 return count; 430 } 431 EXPORT_SYMBOL_GPL(device_get_child_node_count); 432