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