nvmem.h

Go to the documentation of this file.

/*
 * Copyright (c) 2025 Basalte bv
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_NVMEM_H_
#define ZEPHYR_INCLUDE_NVMEM_H_

 
#include <sys/types.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/devicetree/nvmem.h>
#include <zephyr/sys/byteorder.h>
 
#ifdef __cplusplus
extern "C" {
#endif

struct nvmem_cell {
        /* @cond INTERNAL_HIDDEN */

        const struct device *dev;
        off_t offset;
        size_t size;
        bool read_only;
 
        /* @endcond */
};

#define NVMEM_CELL_INIT(node_id)                                                                   \
        {                                                                                          \
                .dev = DEVICE_DT_GET(DT_MTD_FROM_NVMEM_CELL(node_id)),                             \
                .offset = DT_REG_ADDR(node_id),                                                    \
                .size = DT_REG_SIZE(node_id),                                                      \
                .read_only = DT_PROP(node_id, read_only),                                          \
        }

#define NVMEM_CELL_GET_BY_NAME(node_id, name) NVMEM_CELL_INIT(DT_NVMEM_CELL_BY_NAME(node_id, name))

#define NVMEM_CELL_INST_GET_BY_NAME(inst, name) NVMEM_CELL_GET_BY_NAME(DT_DRV_INST(inst), name)

#define NVMEM_CELL_GET_BY_NAME_OR(node_id, name, default_value)                                    \
        COND_CODE_1(DT_PROP_HAS_NAME(node_id, nvmem_cells, name),                                  \
                    (NVMEM_CELL_GET_BY_NAME(node_id, name)),                                       \
                    (default_value))

#define NVMEM_CELL_INST_GET_BY_NAME_OR(inst, name, default_value)                                  \
        NVMEM_CELL_GET_BY_NAME_OR(DT_DRV_INST(inst), name, default_value)

#define NVMEM_CELL_GET_BY_IDX(node_id, idx) NVMEM_CELL_INIT(DT_NVMEM_CELL_BY_IDX(node_id, idx))

#define NVMEM_CELL_INST_GET_BY_IDX(inst, idx) NVMEM_CELL_GET_BY_IDX(DT_DRV_INST(inst), idx)

#define NVMEM_CELL_GET_BY_IDX_OR(node_id, idx, default_value)                                      \
        COND_CODE_1(DT_PROP_HAS_IDX(node_id, nvmem_cells, idx),                                    \
                    (NVMEM_CELL_GET_BY_IDX(node_id, idx)),                                         \
                    (default_value))

#define NVMEM_CELL_INST_GET_BY_IDX_OR(inst, idx, default_value)                                    \
        NVMEM_CELL_GET_BY_IDX_OR(DT_DRV_INST(inst), idx, default_value)

int nvmem_cell_read(const struct nvmem_cell *cell, void *data, off_t off, size_t len);

int nvmem_cell_write(const struct nvmem_cell *cell, const void *data, off_t off, size_t len);

static inline bool nvmem_cell_is_ready(const struct nvmem_cell *cell)
{
        return cell != NULL && device_is_ready(cell->dev);
}

static inline bool nvmem_cell_is_read_only(const struct nvmem_cell *cell)
{
        return cell->read_only;
}

static inline int nvmem_cell_read_le16(const struct nvmem_cell *cell, uint16_t *val, off_t off)
{
        uint8_t buf[sizeof(uint16_t)];
        int ret;
 
        ret = nvmem_cell_read(cell, buf, off, sizeof(buf));
        if (ret == 0) {
                *val = sys_get_le16(buf);
        }
 
        return ret;
}

static inline int nvmem_cell_read_be16(const struct nvmem_cell *cell, uint16_t *val, off_t off)
{
        uint8_t buf[sizeof(uint16_t)];
        int ret;
 
        ret = nvmem_cell_read(cell, buf, off, sizeof(buf));
        if (ret == 0) {
                *val = sys_get_be16(buf);
        }
 
        return ret;
}

static inline int nvmem_cell_read_le32(const struct nvmem_cell *cell, uint32_t *val, off_t off)
{
        uint8_t buf[sizeof(uint32_t)];
        int ret;
 
        ret = nvmem_cell_read(cell, buf, off, sizeof(buf));
        if (ret == 0) {
                *val = sys_get_le32(buf);
        }
 
        return ret;
}

static inline int nvmem_cell_read_be32(const struct nvmem_cell *cell, uint32_t *val, off_t off)
{
        uint8_t buf[sizeof(uint32_t)];
        int ret;
 
        ret = nvmem_cell_read(cell, buf, off, sizeof(buf));
        if (ret == 0) {
                *val = sys_get_be32(buf);
        }
 
        return ret;
}

static inline int nvmem_cell_read_le48(const struct nvmem_cell *cell, uint64_t *val, off_t off)
{
        uint8_t buf[6];
        int ret;
 
        ret = nvmem_cell_read(cell, buf, off, sizeof(buf));
        if (ret == 0) {
                *val = sys_get_le48(buf);
        }
 
        return ret;
}

static inline int nvmem_cell_read_be48(const struct nvmem_cell *cell, uint64_t *val, off_t off)
{
        uint8_t buf[6];
        int ret;
 
        ret = nvmem_cell_read(cell, buf, off, sizeof(buf));
        if (ret == 0) {
                *val = sys_get_be48(buf);
        }
 
        return ret;
}

static inline int nvmem_cell_read_le64(const struct nvmem_cell *cell, uint64_t *val, off_t off)
{
        uint8_t buf[sizeof(uint64_t)];
        int ret;
 
        ret = nvmem_cell_read(cell, buf, off, sizeof(buf));
        if (ret == 0) {
                *val = sys_get_le64(buf);
        }
 
        return ret;
}

static inline int nvmem_cell_read_be64(const struct nvmem_cell *cell, uint64_t *val, off_t off)
{
        uint8_t buf[sizeof(uint64_t)];
        int ret;
 
        ret = nvmem_cell_read(cell, buf, off, sizeof(buf));
        if (ret == 0) {
                *val = sys_get_be64(buf);
        }
 
        return ret;
}

static inline int nvmem_cell_write_le16(const struct nvmem_cell *cell, uint16_t val, off_t off)
{
        uint8_t buf[sizeof(uint16_t)];
 
        sys_put_le16(val, buf);
 
        return nvmem_cell_write(cell, buf, off, sizeof(buf));
}

static inline int nvmem_cell_write_be16(const struct nvmem_cell *cell, uint16_t val, off_t off)
{
        uint8_t buf[sizeof(uint16_t)];
 
        sys_put_be16(val, buf);
 
        return nvmem_cell_write(cell, buf, off, sizeof(buf));
}

static inline int nvmem_cell_write_le32(const struct nvmem_cell *cell, uint32_t val, off_t off)
{
        uint8_t buf[sizeof(uint32_t)];
 
        sys_put_le32(val, buf);
 
        return nvmem_cell_write(cell, buf, off, sizeof(buf));
}

static inline int nvmem_cell_write_be32(const struct nvmem_cell *cell, uint32_t val, off_t off)
{
        uint8_t buf[sizeof(uint32_t)];
 
        sys_put_be32(val, buf);
 
        return nvmem_cell_write(cell, buf, off, sizeof(buf));
}

static inline int nvmem_cell_write_le48(const struct nvmem_cell *cell, uint64_t val, off_t off)
{
        uint8_t buf[6];
 
        sys_put_le48(val, buf);
 
        return nvmem_cell_write(cell, buf, off, sizeof(buf));
}

static inline int nvmem_cell_write_be48(const struct nvmem_cell *cell, uint64_t val, off_t off)
{
        uint8_t buf[6];
 
        sys_put_be48(val, buf);
 
        return nvmem_cell_write(cell, buf, off, sizeof(buf));
}

static inline int nvmem_cell_write_le64(const struct nvmem_cell *cell, uint64_t val, off_t off)
{
        uint8_t buf[sizeof(uint64_t)];
 
        sys_put_le64(val, buf);
 
        return nvmem_cell_write(cell, buf, off, sizeof(buf));
}

static inline int nvmem_cell_write_be64(const struct nvmem_cell *cell, uint64_t val, off_t off)
{
        uint8_t buf[sizeof(uint64_t)];
 
        sys_put_be64(val, buf);
 
        return nvmem_cell_write(cell, buf, off, sizeof(buf));
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_NVMEM_H_ */