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