1 /* 2 * property.h - 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 #ifndef _LINUX_PROPERTY_H_ 14 #define _LINUX_PROPERTY_H_ 15 16 #include <linux/bits.h> 17 #include <linux/fwnode.h> 18 #include <linux/types.h> 19 20 struct device; 21 22 enum dev_prop_type { 23 DEV_PROP_U8, 24 DEV_PROP_U16, 25 DEV_PROP_U32, 26 DEV_PROP_U64, 27 DEV_PROP_STRING, 28 DEV_PROP_MAX, 29 }; 30 31 enum dev_dma_attr { 32 DEV_DMA_NOT_SUPPORTED, 33 DEV_DMA_NON_COHERENT, 34 DEV_DMA_COHERENT, 35 }; 36 37 struct fwnode_handle *dev_fwnode(struct device *dev); 38 39 bool device_property_present(struct device *dev, const char *propname); 40 int device_property_read_u8_array(struct device *dev, const char *propname, 41 u8 *val, size_t nval); 42 int device_property_read_u16_array(struct device *dev, const char *propname, 43 u16 *val, size_t nval); 44 int device_property_read_u32_array(struct device *dev, const char *propname, 45 u32 *val, size_t nval); 46 int device_property_read_u64_array(struct device *dev, const char *propname, 47 u64 *val, size_t nval); 48 int device_property_read_string_array(struct device *dev, const char *propname, 49 const char **val, size_t nval); 50 int device_property_read_string(struct device *dev, const char *propname, 51 const char **val); 52 int device_property_match_string(struct device *dev, 53 const char *propname, const char *string); 54 55 bool fwnode_device_is_available(const struct fwnode_handle *fwnode); 56 bool fwnode_property_present(const struct fwnode_handle *fwnode, 57 const char *propname); 58 int fwnode_property_read_u8_array(const struct fwnode_handle *fwnode, 59 const char *propname, u8 *val, 60 size_t nval); 61 int fwnode_property_read_u16_array(const struct fwnode_handle *fwnode, 62 const char *propname, u16 *val, 63 size_t nval); 64 int fwnode_property_read_u32_array(const struct fwnode_handle *fwnode, 65 const char *propname, u32 *val, 66 size_t nval); 67 int fwnode_property_read_u64_array(const struct fwnode_handle *fwnode, 68 const char *propname, u64 *val, 69 size_t nval); 70 int fwnode_property_read_string_array(const struct fwnode_handle *fwnode, 71 const char *propname, const char **val, 72 size_t nval); 73 int fwnode_property_read_string(const struct fwnode_handle *fwnode, 74 const char *propname, const char **val); 75 int fwnode_property_match_string(const struct fwnode_handle *fwnode, 76 const char *propname, const char *string); 77 int fwnode_property_get_reference_args(const struct fwnode_handle *fwnode, 78 const char *prop, const char *nargs_prop, 79 unsigned int nargs, unsigned int index, 80 struct fwnode_reference_args *args); 81 82 struct fwnode_handle *fwnode_get_parent(const struct fwnode_handle *fwnode); 83 struct fwnode_handle *fwnode_get_next_parent( 84 struct fwnode_handle *fwnode); 85 struct fwnode_handle *fwnode_get_next_child_node( 86 const struct fwnode_handle *fwnode, struct fwnode_handle *child); 87 struct fwnode_handle *fwnode_get_next_available_child_node( 88 const struct fwnode_handle *fwnode, struct fwnode_handle *child); 89 90 #define fwnode_for_each_child_node(fwnode, child) \ 91 for (child = fwnode_get_next_child_node(fwnode, NULL); child; \ 92 child = fwnode_get_next_child_node(fwnode, child)) 93 94 #define fwnode_for_each_available_child_node(fwnode, child) \ 95 for (child = fwnode_get_next_available_child_node(fwnode, NULL); child;\ 96 child = fwnode_get_next_available_child_node(fwnode, child)) 97 98 struct fwnode_handle *device_get_next_child_node( 99 struct device *dev, struct fwnode_handle *child); 100 101 #define device_for_each_child_node(dev, child) \ 102 for (child = device_get_next_child_node(dev, NULL); child; \ 103 child = device_get_next_child_node(dev, child)) 104 105 struct fwnode_handle *fwnode_get_named_child_node( 106 const struct fwnode_handle *fwnode, const char *childname); 107 struct fwnode_handle *device_get_named_child_node(struct device *dev, 108 const char *childname); 109 110 struct fwnode_handle *fwnode_handle_get(struct fwnode_handle *fwnode); 111 void fwnode_handle_put(struct fwnode_handle *fwnode); 112 113 int fwnode_irq_get(struct fwnode_handle *fwnode, unsigned int index); 114 115 unsigned int device_get_child_node_count(struct device *dev); 116 117 static inline bool device_property_read_bool(struct device *dev, 118 const char *propname) 119 { 120 return device_property_present(dev, propname); 121 } 122 123 static inline int device_property_read_u8(struct device *dev, 124 const char *propname, u8 *val) 125 { 126 return device_property_read_u8_array(dev, propname, val, 1); 127 } 128 129 static inline int device_property_read_u16(struct device *dev, 130 const char *propname, u16 *val) 131 { 132 return device_property_read_u16_array(dev, propname, val, 1); 133 } 134 135 static inline int device_property_read_u32(struct device *dev, 136 const char *propname, u32 *val) 137 { 138 return device_property_read_u32_array(dev, propname, val, 1); 139 } 140 141 static inline int device_property_read_u64(struct device *dev, 142 const char *propname, u64 *val) 143 { 144 return device_property_read_u64_array(dev, propname, val, 1); 145 } 146 147 static inline bool fwnode_property_read_bool(const struct fwnode_handle *fwnode, 148 const char *propname) 149 { 150 return fwnode_property_present(fwnode, propname); 151 } 152 153 static inline int fwnode_property_read_u8(const struct fwnode_handle *fwnode, 154 const char *propname, u8 *val) 155 { 156 return fwnode_property_read_u8_array(fwnode, propname, val, 1); 157 } 158 159 static inline int fwnode_property_read_u16(const struct fwnode_handle *fwnode, 160 const char *propname, u16 *val) 161 { 162 return fwnode_property_read_u16_array(fwnode, propname, val, 1); 163 } 164 165 static inline int fwnode_property_read_u32(const struct fwnode_handle *fwnode, 166 const char *propname, u32 *val) 167 { 168 return fwnode_property_read_u32_array(fwnode, propname, val, 1); 169 } 170 171 static inline int fwnode_property_read_u64(const struct fwnode_handle *fwnode, 172 const char *propname, u64 *val) 173 { 174 return fwnode_property_read_u64_array(fwnode, propname, val, 1); 175 } 176 177 /** 178 * struct property_entry - "Built-in" device property representation. 179 * @name: Name of the property. 180 * @length: Length of data making up the value. 181 * @is_array: True when the property is an array. 182 * @type: Type of the data in unions. 183 * @pointer: Pointer to the property (an array of items of the given type). 184 * @value: Value of the property (when it is a single item of the given type). 185 */ 186 struct property_entry { 187 const char *name; 188 size_t length; 189 bool is_array; 190 enum dev_prop_type type; 191 union { 192 union { 193 const u8 *u8_data; 194 const u16 *u16_data; 195 const u32 *u32_data; 196 const u64 *u64_data; 197 const char * const *str; 198 } pointer; 199 union { 200 u8 u8_data; 201 u16 u16_data; 202 u32 u32_data; 203 u64 u64_data; 204 const char *str; 205 } value; 206 }; 207 }; 208 209 /* 210 * Note: the below four initializers for the anonymous union are carefully 211 * crafted to avoid gcc-4.4.4's problems with initialization of anon unions 212 * and structs. 213 */ 214 215 #define PROPERTY_ENTRY_INTEGER_ARRAY(_name_, _type_, _Type_, _val_) \ 216 (struct property_entry) { \ 217 .name = _name_, \ 218 .length = ARRAY_SIZE(_val_) * sizeof(_type_), \ 219 .is_array = true, \ 220 .type = DEV_PROP_##_Type_, \ 221 { .pointer = { ._type_##_data = _val_ } }, \ 222 } 223 224 #define PROPERTY_ENTRY_U8_ARRAY(_name_, _val_) \ 225 PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u8, U8, _val_) 226 #define PROPERTY_ENTRY_U16_ARRAY(_name_, _val_) \ 227 PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u16, U16, _val_) 228 #define PROPERTY_ENTRY_U32_ARRAY(_name_, _val_) \ 229 PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u32, U32, _val_) 230 #define PROPERTY_ENTRY_U64_ARRAY(_name_, _val_) \ 231 PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u64, U64, _val_) 232 233 #define PROPERTY_ENTRY_STRING_ARRAY(_name_, _val_) \ 234 (struct property_entry) { \ 235 .name = _name_, \ 236 .length = ARRAY_SIZE(_val_) * sizeof(const char *), \ 237 .is_array = true, \ 238 .type = DEV_PROP_STRING, \ 239 { .pointer = { .str = _val_ } }, \ 240 } 241 242 #define PROPERTY_ENTRY_INTEGER(_name_, _type_, _Type_, _val_) \ 243 (struct property_entry) { \ 244 .name = _name_, \ 245 .length = sizeof(_type_), \ 246 .type = DEV_PROP_##_Type_, \ 247 { .value = { ._type_##_data = _val_ } }, \ 248 } 249 250 #define PROPERTY_ENTRY_U8(_name_, _val_) \ 251 PROPERTY_ENTRY_INTEGER(_name_, u8, U8, _val_) 252 #define PROPERTY_ENTRY_U16(_name_, _val_) \ 253 PROPERTY_ENTRY_INTEGER(_name_, u16, U16, _val_) 254 #define PROPERTY_ENTRY_U32(_name_, _val_) \ 255 PROPERTY_ENTRY_INTEGER(_name_, u32, U32, _val_) 256 #define PROPERTY_ENTRY_U64(_name_, _val_) \ 257 PROPERTY_ENTRY_INTEGER(_name_, u64, U64, _val_) 258 259 #define PROPERTY_ENTRY_STRING(_name_, _val_) \ 260 (struct property_entry) { \ 261 .name = _name_, \ 262 .length = sizeof(const char *), \ 263 .type = DEV_PROP_STRING, \ 264 { .value = { .str = _val_ } }, \ 265 } 266 267 #define PROPERTY_ENTRY_BOOL(_name_) \ 268 (struct property_entry) { \ 269 .name = _name_, \ 270 } 271 272 struct property_entry * 273 property_entries_dup(const struct property_entry *properties); 274 275 void property_entries_free(const struct property_entry *properties); 276 277 int device_add_properties(struct device *dev, 278 const struct property_entry *properties); 279 void device_remove_properties(struct device *dev); 280 281 bool device_dma_supported(struct device *dev); 282 283 enum dev_dma_attr device_get_dma_attr(struct device *dev); 284 285 const void *device_get_match_data(struct device *dev); 286 287 int device_get_phy_mode(struct device *dev); 288 289 void *device_get_mac_address(struct device *dev, char *addr, int alen); 290 291 int fwnode_get_phy_mode(struct fwnode_handle *fwnode); 292 void *fwnode_get_mac_address(struct fwnode_handle *fwnode, 293 char *addr, int alen); 294 struct fwnode_handle *fwnode_graph_get_next_endpoint( 295 const struct fwnode_handle *fwnode, struct fwnode_handle *prev); 296 struct fwnode_handle * 297 fwnode_graph_get_port_parent(const struct fwnode_handle *fwnode); 298 struct fwnode_handle *fwnode_graph_get_remote_port_parent( 299 const struct fwnode_handle *fwnode); 300 struct fwnode_handle *fwnode_graph_get_remote_port( 301 const struct fwnode_handle *fwnode); 302 struct fwnode_handle *fwnode_graph_get_remote_endpoint( 303 const struct fwnode_handle *fwnode); 304 struct fwnode_handle * 305 fwnode_graph_get_remote_node(const struct fwnode_handle *fwnode, u32 port, 306 u32 endpoint); 307 308 /* 309 * Fwnode lookup flags 310 * 311 * @FWNODE_GRAPH_ENDPOINT_NEXT: In the case of no exact match, look for the 312 * closest endpoint ID greater than the specified 313 * one. 314 * @FWNODE_GRAPH_DEVICE_DISABLED: That the device to which the remote 315 * endpoint of the given endpoint belongs to, 316 * may be disabled. 317 */ 318 #define FWNODE_GRAPH_ENDPOINT_NEXT BIT(0) 319 #define FWNODE_GRAPH_DEVICE_DISABLED BIT(1) 320 321 struct fwnode_handle * 322 fwnode_graph_get_endpoint_by_id(const struct fwnode_handle *fwnode, 323 u32 port, u32 endpoint, unsigned long flags); 324 325 #define fwnode_graph_for_each_endpoint(fwnode, child) \ 326 for (child = NULL; \ 327 (child = fwnode_graph_get_next_endpoint(fwnode, child)); ) 328 329 int fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode, 330 struct fwnode_endpoint *endpoint); 331 332 /* -------------------------------------------------------------------------- */ 333 /* Software fwnode support - when HW description is incomplete or missing */ 334 335 bool is_software_node(const struct fwnode_handle *fwnode); 336 337 int software_node_notify(struct device *dev, unsigned long action); 338 339 struct fwnode_handle * 340 fwnode_create_software_node(const struct property_entry *properties, 341 const struct fwnode_handle *parent); 342 void fwnode_remove_software_node(struct fwnode_handle *fwnode); 343 344 #endif /* _LINUX_PROPERTY_H_ */ 345