memc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2026 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_MEMC_H_
#define ZEPHYR_INCLUDE_DRIVERS_MEMC_H_

 
#include <zephyr/types.h>
#include <stddef.h>
#include <zephyr/device.h>
#include <string.h>
 
#ifdef __cplusplus
extern "C" {
#endif


typedef int (*memc_api_read)(const struct device *dev, uint32_t addr, uint8_t *data, size_t len);

typedef int (*memc_api_write)(const struct device *dev, uint32_t addr, const uint8_t *data,
                              size_t len);

typedef int (*memc_api_get_size)(const struct device *dev, uint64_t *size);

typedef int (*memc_api_read_id)(const struct device *dev, uint8_t *id, size_t len);

typedef void *(*memc_api_get_mem_base)(const struct device *dev);

__subsystem struct memc_driver_api {
        memc_api_read read;
        memc_api_write write;
        memc_api_get_mem_base get_mem_base;
        memc_api_get_size get_size;
        memc_api_read_id read_id;
};


__syscall int memc_read(const struct device *dev, uint32_t addr, uint8_t *data, size_t len);
 
static inline int z_impl_memc_read(const struct device *dev, uint32_t addr, uint8_t *data,
                                   size_t len)
{
        if (!DEVICE_API_IS(memc, dev)) {
                return -ENOTSUP;
        }
 
        const struct memc_driver_api *api = DEVICE_API_GET(memc, dev);
 
        if (api->get_mem_base != NULL) {
                void *base = api->get_mem_base(dev);
 
                if (base != NULL) {
                        memcpy(data, (const uint8_t *)base + addr, len);
                        return 0;
                }
        }
 
        if (api->read != NULL) {
                return api->read(dev, addr, data, len);
        }
 
        return -ENOTSUP;
}

__syscall int memc_write(const struct device *dev, uint32_t addr, const uint8_t *data, size_t len);
 
static inline int z_impl_memc_write(const struct device *dev, uint32_t addr, const uint8_t *data,
                                    size_t len)
{
        if (!DEVICE_API_IS(memc, dev)) {
                return -ENOTSUP;
        }
 
        const struct memc_driver_api *api = DEVICE_API_GET(memc, dev);
 
        if (api->get_mem_base != NULL) {
                void *base = api->get_mem_base(dev);
 
                if (base != NULL) {
                        memcpy((uint8_t *)base + addr, data, len);
                        return 0;
                }
        }
 
        if (api->write != NULL) {
                return api->write(dev, addr, data, len);
        }
 
        return -ENOTSUP;
}

static inline void *memc_get_mem_base(const struct device *dev)
{
        if (!DEVICE_API_IS(memc, dev)) {
                return NULL;
        }
 
        const struct memc_driver_api *api = DEVICE_API_GET(memc, dev);
 
        if (api->get_mem_base == NULL) {
                return NULL;
        }
 
        return api->get_mem_base(dev);
}

__syscall int memc_get_size(const struct device *dev, uint64_t *size);
 
static inline int z_impl_memc_get_size(const struct device *dev, uint64_t *size)
{
        if (!DEVICE_API_IS(memc, dev)) {
                return -ENOTSUP;
        }
 
        const struct memc_driver_api *api = DEVICE_API_GET(memc, dev);
 
        if (api->get_size == NULL) {
                return -ENOTSUP;
        }
 
        return api->get_size(dev, size);
}

__syscall int memc_read_id(const struct device *dev, uint8_t *id, size_t len);
 
static inline int z_impl_memc_read_id(const struct device *dev, uint8_t *id, size_t len)
{
        if (!DEVICE_API_IS(memc, dev)) {
                return -ENOTSUP;
        }
 
        const struct memc_driver_api *api = DEVICE_API_GET(memc, dev);
 
        if (api->read_id == NULL) {
                return -ENOTSUP;
        }
 
        return api->read_id(dev, id, len);
}

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/memc.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_MEMC_H_ */