Subversion Repositories Kolibri OS

Rev

Rev 6936 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  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/fwnode.h>
  17. #include <linux/types.h>
  18.  
  19. struct device;
  20.  
  21. enum dev_prop_type {
  22.         DEV_PROP_U8,
  23.         DEV_PROP_U16,
  24.         DEV_PROP_U32,
  25.         DEV_PROP_U64,
  26.         DEV_PROP_STRING,
  27.         DEV_PROP_MAX,
  28. };
  29.  
  30. enum dev_dma_attr {
  31.         DEV_DMA_NOT_SUPPORTED,
  32.         DEV_DMA_NON_COHERENT,
  33.         DEV_DMA_COHERENT,
  34. };
  35.  
  36. bool device_property_present(struct device *dev, const char *propname);
  37. int device_property_read_u8_array(struct device *dev, const char *propname,
  38.                                   u8 *val, size_t nval);
  39. int device_property_read_u16_array(struct device *dev, const char *propname,
  40.                                    u16 *val, size_t nval);
  41. int device_property_read_u32_array(struct device *dev, const char *propname,
  42.                                    u32 *val, size_t nval);
  43. int device_property_read_u64_array(struct device *dev, const char *propname,
  44.                                    u64 *val, size_t nval);
  45. int device_property_read_string_array(struct device *dev, const char *propname,
  46.                                       const char **val, size_t nval);
  47. int device_property_read_string(struct device *dev, const char *propname,
  48.                                 const char **val);
  49. int device_property_match_string(struct device *dev,
  50.                                  const char *propname, const char *string);
  51.  
  52. bool fwnode_property_present(struct fwnode_handle *fwnode, const char *propname);
  53. int fwnode_property_read_u8_array(struct fwnode_handle *fwnode,
  54.                                   const char *propname, u8 *val,
  55.                                   size_t nval);
  56. int fwnode_property_read_u16_array(struct fwnode_handle *fwnode,
  57.                                    const char *propname, u16 *val,
  58.                                    size_t nval);
  59. int fwnode_property_read_u32_array(struct fwnode_handle *fwnode,
  60.                                    const char *propname, u32 *val,
  61.                                    size_t nval);
  62. int fwnode_property_read_u64_array(struct fwnode_handle *fwnode,
  63.                                    const char *propname, u64 *val,
  64.                                    size_t nval);
  65. int fwnode_property_read_string_array(struct fwnode_handle *fwnode,
  66.                                       const char *propname, const char **val,
  67.                                       size_t nval);
  68. int fwnode_property_read_string(struct fwnode_handle *fwnode,
  69.                                 const char *propname, const char **val);
  70. int fwnode_property_match_string(struct fwnode_handle *fwnode,
  71.                                  const char *propname, const char *string);
  72.  
  73. struct fwnode_handle *device_get_next_child_node(struct device *dev,
  74.                                                  struct fwnode_handle *child);
  75.  
  76. #define device_for_each_child_node(dev, child)                          \
  77.         for (child = device_get_next_child_node(dev, NULL); child;      \
  78.              child = device_get_next_child_node(dev, child))
  79.  
  80. void fwnode_handle_put(struct fwnode_handle *fwnode);
  81.  
  82. unsigned int device_get_child_node_count(struct device *dev);
  83.  
  84. static inline bool device_property_read_bool(struct device *dev,
  85.                                              const char *propname)
  86. {
  87.         return device_property_present(dev, propname);
  88. }
  89.  
  90. static inline int device_property_read_u8(struct device *dev,
  91.                                           const char *propname, u8 *val)
  92. {
  93.         return device_property_read_u8_array(dev, propname, val, 1);
  94. }
  95.  
  96. static inline int device_property_read_u16(struct device *dev,
  97.                                            const char *propname, u16 *val)
  98. {
  99.         return device_property_read_u16_array(dev, propname, val, 1);
  100. }
  101.  
  102. static inline int device_property_read_u32(struct device *dev,
  103.                                            const char *propname, u32 *val)
  104. {
  105.         return device_property_read_u32_array(dev, propname, val, 1);
  106. }
  107.  
  108. static inline int device_property_read_u64(struct device *dev,
  109.                                            const char *propname, u64 *val)
  110. {
  111.         return device_property_read_u64_array(dev, propname, val, 1);
  112. }
  113.  
  114. static inline bool fwnode_property_read_bool(struct fwnode_handle *fwnode,
  115.                                              const char *propname)
  116. {
  117.         return fwnode_property_present(fwnode, propname);
  118. }
  119.  
  120. static inline int fwnode_property_read_u8(struct fwnode_handle *fwnode,
  121.                                           const char *propname, u8 *val)
  122. {
  123.         return fwnode_property_read_u8_array(fwnode, propname, val, 1);
  124. }
  125.  
  126. static inline int fwnode_property_read_u16(struct fwnode_handle *fwnode,
  127.                                            const char *propname, u16 *val)
  128. {
  129.         return fwnode_property_read_u16_array(fwnode, propname, val, 1);
  130. }
  131.  
  132. static inline int fwnode_property_read_u32(struct fwnode_handle *fwnode,
  133.                                            const char *propname, u32 *val)
  134. {
  135.         return fwnode_property_read_u32_array(fwnode, propname, val, 1);
  136. }
  137.  
  138. static inline int fwnode_property_read_u64(struct fwnode_handle *fwnode,
  139.                                            const char *propname, u64 *val)
  140. {
  141.         return fwnode_property_read_u64_array(fwnode, propname, val, 1);
  142. }
  143.  
  144. /**
  145.  * struct property_entry - "Built-in" device property representation.
  146.  * @name: Name of the property.
  147.  * @length: Length of data making up the value.
  148.  * @is_array: True when the property is an array.
  149.  * @is_string: True when property is a string.
  150.  * @pointer: Pointer to the property (an array of items of the given type).
  151.  * @value: Value of the property (when it is a single item of the given type).
  152.  */
  153. struct property_entry {
  154.         const char *name;
  155.         size_t length;
  156.         bool is_array;
  157.         bool is_string;
  158.         union {
  159.                 union {
  160.                         void *raw_data;
  161.                         u8 *u8_data;
  162.                         u16 *u16_data;
  163.                         u32 *u32_data;
  164.                         u64 *u64_data;
  165.                         const char **str;
  166.                 } pointer;
  167.                 union {
  168.                         unsigned long long raw_data;
  169.                         u8 u8_data;
  170.                         u16 u16_data;
  171.                         u32 u32_data;
  172.                         u64 u64_data;
  173.                         const char *str;
  174.                 } value;
  175.         };
  176. };
  177.  
  178. /*
  179.  * Note: the below four initializers for the anonymous union are carefully
  180.  * crafted to avoid gcc-4.4.4's problems with initialization of anon unions
  181.  * and structs.
  182.  */
  183.  
  184. #define PROPERTY_ENTRY_INTEGER_ARRAY(_name_, _type_, _val_)     \
  185. {                                                               \
  186.         .name = _name_,                                         \
  187.         .length = ARRAY_SIZE(_val_) * sizeof(_type_),           \
  188.         .is_array = true,                                       \
  189.         .is_string = false,                                     \
  190.         { .pointer = { _type_##_data = _val_ } },               \
  191. }
  192.  
  193. #define PROPERTY_ENTRY_U8_ARRAY(_name_, _val_)                  \
  194.         PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u8, _val_)
  195. #define PROPERTY_ENTRY_U16_ARRAY(_name_, _val_)                 \
  196.         PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u16, _val_)
  197. #define PROPERTY_ENTRY_U32_ARRAY(_name_, _val_)                 \
  198.         PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u32, _val_)
  199. #define PROPERTY_ENTRY_U64_ARRAY(_name_, _val_)                 \
  200.         PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u64, _val_)
  201.  
  202. #define PROPERTY_ENTRY_STRING_ARRAY(_name_, _val_)              \
  203. {                                                               \
  204.         .name = _name_,                                         \
  205.         .length = ARRAY_SIZE(_val_) * sizeof(const char *),     \
  206.         .is_array = true,                                       \
  207.         .is_string = true,                                      \
  208.         { .pointer = { .str = _val_ } },                        \
  209. }
  210.  
  211. #define PROPERTY_ENTRY_INTEGER(_name_, _type_, _val_)   \
  212. {                                                       \
  213.         .name = _name_,                                 \
  214.         .length = sizeof(_type_),                       \
  215.         .is_string = false,                             \
  216.         { .value = { ._type_##_data = _val_ } },        \
  217. }
  218.  
  219. #define PROPERTY_ENTRY_U8(_name_, _val_)                \
  220.         PROPERTY_ENTRY_INTEGER(_name_, u8, _val_)
  221. #define PROPERTY_ENTRY_U16(_name_, _val_)               \
  222.         PROPERTY_ENTRY_INTEGER(_name_, u16, _val_)
  223. #define PROPERTY_ENTRY_U32(_name_, _val_)               \
  224.         PROPERTY_ENTRY_INTEGER(_name_, u32, _val_)
  225. #define PROPERTY_ENTRY_U64(_name_, _val_)               \
  226.         PROPERTY_ENTRY_INTEGER(_name_, u64, _val_)
  227.  
  228. #define PROPERTY_ENTRY_STRING(_name_, _val_)            \
  229. {                                                       \
  230.         .name = _name_,                                 \
  231.         .length = sizeof(_val_),                        \
  232.         .is_string = true,                              \
  233.         { .value = { .str = _val_ } },                  \
  234. }
  235.  
  236. #define PROPERTY_ENTRY_BOOL(_name_)             \
  237. {                                               \
  238.         .name = _name_,                         \
  239. }
  240.  
  241. /**
  242.  * struct property_set - Collection of "built-in" device properties.
  243.  * @fwnode: Handle to be pointed to by the fwnode field of struct device.
  244.  * @properties: Array of properties terminated with a null entry.
  245.  */
  246. struct property_set {
  247.         struct fwnode_handle fwnode;
  248.         struct property_entry *properties;
  249. };
  250.  
  251. int device_add_property_set(struct device *dev, const struct property_set *pset);
  252. void device_remove_property_set(struct device *dev);
  253.  
  254. bool device_dma_supported(struct device *dev);
  255.  
  256. enum dev_dma_attr device_get_dma_attr(struct device *dev);
  257.  
  258. int device_get_phy_mode(struct device *dev);
  259.  
  260. void *device_get_mac_address(struct device *dev, char *addr, int alen);
  261.  
  262. #endif /* _LINUX_PROPERTY_H_ */
  263.