include/linux/nvmem-consumer.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * nvmem framework consumer.
   4  *
   5  * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
   6  * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
   7  */
   8
   9 #ifndef _LINUX_NVMEM_CONSUMER_H
  10 #define _LINUX_NVMEM_CONSUMER_H
  11
  12 #include <linux/err.h>
  13 #include <linux/errno.h>
  14 #include <linux/notifier.h>
  15
  16 struct device;
  17 struct device_node;
  18 /* consumer cookie */
  19 struct nvmem_cell;
  20 struct nvmem_device;
  21 struct nvmem_cell_info;
  22
  23 /**
  24  * struct nvmem_cell_lookup - cell lookup entry
  25  *
  26  * @nvmem_name: Name of the provider.
  27  * @cell_name:  Name of the nvmem cell as defined in the name field of
  28  *              struct nvmem_cell_info.
  29  * @dev_id:     Name of the consumer device that will be associated with
  30  *              this cell.
  31  * @con_id:     Connector id for this cell lookup.
  32  */
  33 struct nvmem_cell_lookup {
  34         const char              *nvmem_name;
  35         const char              *cell_name;
  36         const char              *dev_id;
  37         const char              *con_id;
  38         struct list_head        node;
  39 };
  40
  41 enum {
  42         NVMEM_ADD = 1,
  43         NVMEM_REMOVE,
  44         NVMEM_CELL_ADD,
  45         NVMEM_CELL_REMOVE,
  46         NVMEM_LAYOUT_ADD,
  47         NVMEM_LAYOUT_REMOVE,
  48 };
  49
  50 #if IS_ENABLED(CONFIG_NVMEM)
  51
  52 /* Cell based interface */
  53 struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *id);
  54 struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *id);
  55 void nvmem_cell_put(struct nvmem_cell *cell);
  56 void devm_nvmem_cell_put(struct device *dev, struct nvmem_cell *cell);
  57 void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len);
  58 int nvmem_cell_write(struct nvmem_cell *cell, void *buf, size_t len);
  59 int nvmem_cell_read_u8(struct device *dev, const char *cell_id, u8 *val);
  60 int nvmem_cell_read_u16(struct device *dev, const char *cell_id, u16 *val);
  61 int nvmem_cell_read_u32(struct device *dev, const char *cell_id, u32 *val);
  62 int nvmem_cell_read_u64(struct device *dev, const char *cell_id, u64 *val);
  63 int nvmem_cell_read_variable_le_u32(struct device *dev, const char *cell_id,
  64                                     u32 *val);
  65 int nvmem_cell_read_variable_le_u64(struct device *dev, const char *cell_id,
  66                                     u64 *val);
  67
  68 /* direct nvmem device read/write interface */
  69 struct nvmem_device *nvmem_device_get(struct device *dev, const char *name);
  70 struct nvmem_device *devm_nvmem_device_get(struct device *dev,
  71                                            const char *name);
  72 void nvmem_device_put(struct nvmem_device *nvmem);
  73 void devm_nvmem_device_put(struct device *dev, struct nvmem_device *nvmem);
  74 int nvmem_device_read(struct nvmem_device *nvmem, unsigned int offset,
  75                       size_t bytes, void *buf);
  76 int nvmem_device_write(struct nvmem_device *nvmem, unsigned int offset,
  77                        size_t bytes, void *buf);
  78 ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
  79                            struct nvmem_cell_info *info, void *buf);
  80 int nvmem_device_cell_write(struct nvmem_device *nvmem,
  81                             struct nvmem_cell_info *info, void *buf);
  82
  83 const char *nvmem_dev_name(struct nvmem_device *nvmem);
  84 size_t nvmem_dev_size(struct nvmem_device *nvmem);
  85
  86 void nvmem_add_cell_lookups(struct nvmem_cell_lookup *entries,
  87                             size_t nentries);
  88 void nvmem_del_cell_lookups(struct nvmem_cell_lookup *entries,
  89                             size_t nentries);
  90
  91 int nvmem_register_notifier(struct notifier_block *nb);
  92 int nvmem_unregister_notifier(struct notifier_block *nb);
  93
  94 struct nvmem_device *nvmem_device_find(void *data,
  95                         int (*match)(struct device *dev, const void *data));
  96
  97 #else
  98
  99 static inline struct nvmem_cell *nvmem_cell_get(struct device *dev,
 100                                                 const char *id)
 101 {
 102         return ERR_PTR(-EOPNOTSUPP);
 103 }
 104
 105 static inline struct nvmem_cell *devm_nvmem_cell_get(struct device *dev,
 106                                                      const char *id)
 107 {
 108         return ERR_PTR(-EOPNOTSUPP);
 109 }
 110
 111 static inline void devm_nvmem_cell_put(struct device *dev,
 112                                        struct nvmem_cell *cell)
 113 {
 114
 115 }
 116 static inline void nvmem_cell_put(struct nvmem_cell *cell)
 117 {
 118 }
 119
 120 static inline void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len)
 121 {
 122         return ERR_PTR(-EOPNOTSUPP);
 123 }
 124
 125 static inline int nvmem_cell_write(struct nvmem_cell *cell,
 126                                    void *buf, size_t len)
 127 {
 128         return -EOPNOTSUPP;
 129 }
 130
 131 static inline int nvmem_cell_read_u8(struct device *dev,
 132                                      const char *cell_id, u8 *val)
 133 {
 134         return -EOPNOTSUPP;
 135 }
 136
 137 static inline int nvmem_cell_read_u16(struct device *dev,
 138                                       const char *cell_id, u16 *val)
 139 {
 140         return -EOPNOTSUPP;
 141 }
 142
 143 static inline int nvmem_cell_read_u32(struct device *dev,
 144                                       const char *cell_id, u32 *val)
 145 {
 146         return -EOPNOTSUPP;
 147 }
 148
 149 static inline int nvmem_cell_read_u64(struct device *dev,
 150                                       const char *cell_id, u64 *val)
 151 {
 152         return -EOPNOTSUPP;
 153 }
 154
 155 static inline int nvmem_cell_read_variable_le_u32(struct device *dev,
 156                                                  const char *cell_id,
 157                                                  u32 *val)
 158 {
 159         return -EOPNOTSUPP;
 160 }
 161
 162 static inline int nvmem_cell_read_variable_le_u64(struct device *dev,
 163                                                   const char *cell_id,
 164                                                   u64 *val)
 165 {
 166         return -EOPNOTSUPP;
 167 }
 168
 169 static inline struct nvmem_device *nvmem_device_get(struct device *dev,
 170                                                     const char *name)
 171 {
 172         return ERR_PTR(-EOPNOTSUPP);
 173 }
 174
 175 static inline struct nvmem_device *devm_nvmem_device_get(struct device *dev,
 176                                                          const char *name)
 177 {
 178         return ERR_PTR(-EOPNOTSUPP);
 179 }
 180
 181 static inline void nvmem_device_put(struct nvmem_device *nvmem)
 182 {
 183 }
 184
 185 static inline void devm_nvmem_device_put(struct device *dev,
 186                                          struct nvmem_device *nvmem)
 187 {
 188 }
 189
 190 static inline ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
 191                                          struct nvmem_cell_info *info,
 192                                          void *buf)
 193 {
 194         return -EOPNOTSUPP;
 195 }
 196
 197 static inline int nvmem_device_cell_write(struct nvmem_device *nvmem,
 198                                           struct nvmem_cell_info *info,
 199                                           void *buf)
 200 {
 201         return -EOPNOTSUPP;
 202 }
 203
 204 static inline int nvmem_device_read(struct nvmem_device *nvmem,
 205                                     unsigned int offset, size_t bytes,
 206                                     void *buf)
 207 {
 208         return -EOPNOTSUPP;
 209 }
 210
 211 static inline int nvmem_device_write(struct nvmem_device *nvmem,
 212                                      unsigned int offset, size_t bytes,
 213                                      void *buf)
 214 {
 215         return -EOPNOTSUPP;
 216 }
 217
 218 static inline const char *nvmem_dev_name(struct nvmem_device *nvmem)
 219 {
 220         return NULL;
 221 }
 222
 223 static inline void
 224 nvmem_add_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries) {}
 225 static inline void
 226 nvmem_del_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries) {}
 227
 228 static inline int nvmem_register_notifier(struct notifier_block *nb)
 229 {
 230         return -EOPNOTSUPP;
 231 }
 232
 233 static inline int nvmem_unregister_notifier(struct notifier_block *nb)
 234 {
 235         return -EOPNOTSUPP;
 236 }
 237
 238 static inline struct nvmem_device *nvmem_device_find(void *data,
 239                         int (*match)(struct device *dev, const void *data))
 240 {
 241         return NULL;
 242 }
 243
 244 #endif /* CONFIG_NVMEM */
 245
 246 #if IS_ENABLED(CONFIG_NVMEM) && IS_ENABLED(CONFIG_OF)
 247 struct nvmem_cell *of_nvmem_cell_get(struct device_node *np,
 248                                      const char *id);
 249 struct nvmem_device *of_nvmem_device_get(struct device_node *np,
 250                                          const char *name);
 251 #else
 252 static inline struct nvmem_cell *of_nvmem_cell_get(struct device_node *np,
 253                                                    const char *id)
 254 {
 255         return ERR_PTR(-EOPNOTSUPP);
 256 }
 257
 258 static inline struct nvmem_device *of_nvmem_device_get(struct device_node *np,
 259                                                        const char *name)
 260 {
 261         return ERR_PTR(-EOPNOTSUPP);
 262 }
 263 #endif /* CONFIG_NVMEM && CONFIG_OF */
 264
 265 #endif  /* ifndef _LINUX_NVMEM_CONSUMER_H */