mipi_dbi.h

Go to the documentation of this file.

/*
 * Copyright 2023 NXP
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_MIPI_DBI_H_
#define ZEPHYR_INCLUDE_DRIVERS_MIPI_DBI_H_
 
#include <zephyr/device.h>
#include <zephyr/drivers/display.h>
#include <zephyr/display/mipi_display.h>
#include <zephyr/drivers/spi.h>
#include <zephyr/dt-bindings/mipi_dbi/mipi_dbi.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define MIPI_DBI_SPI_CONFIG_DT(node_id, operation_, delay_)             \
        {                                                               \
                .frequency = DT_PROP(node_id, mipi_max_frequency),      \
                .operation = (operation_) |                             \
                        DT_PROP_OR(node_id, duplex, 0) |                        \
                        COND_CODE_1(DT_PROP(node_id, mipi_cpol), SPI_MODE_CPOL, (0)) |  \
                        COND_CODE_1(DT_PROP(node_id, mipi_cpha), SPI_MODE_CPHA, (0)) |  \
                        COND_CODE_1(DT_PROP(node_id, mipi_hold_cs), SPI_HOLD_ON_CS, (0)),       \
                .slave = DT_REG_ADDR(node_id),                          \
                .cs = {                                                 \
                        .gpio = GPIO_DT_SPEC_GET_BY_IDX_OR(DT_PHANDLE(DT_PARENT(node_id), \
                                                           spi_dev), cs_gpios, \
                                                           DT_REG_ADDR_RAW(node_id), \
                                                           {}),         \
                        .delay = (delay_),                              \
                },                                                      \
        }
 
#define MIPI_DBI_SPI_CONFIG_DT_INST(inst, operation_, delay_)           \
        MIPI_DBI_SPI_CONFIG_DT(DT_DRV_INST(inst), operation_, delay_)
 
#define MIPI_DBI_CONFIG_DT(node_id, operation_, delay_)                 \
        {                                                               \
                .mode = DT_STRING_UPPER_TOKEN(node_id, mipi_mode),      \
                .config = MIPI_DBI_SPI_CONFIG_DT(node_id, operation_, delay_), \
        }
 
#define MIPI_DBI_CONFIG_DT_INST(inst, operation_, delay_)               \
        MIPI_DBI_CONFIG_DT(DT_DRV_INST(inst), operation_, delay_)
 
#define MIPI_DBI_TE_MODE_DT(node_id, edge_prop)                           \
        DT_STRING_UPPER_TOKEN(node_id, edge_prop)
 
#define MIPI_DBI_TE_MODE_DT_INST(inst, edge_prop)                         \
        DT_STRING_UPPER_TOKEN(DT_DRV_INST(inst), edge_prop)
 
struct mipi_dbi_config {
        uint8_t mode;
        struct spi_config config;
};
 
 
__subsystem struct mipi_dbi_driver_api {
        int (*command_write)(const struct device *dev,
                             const struct mipi_dbi_config *config, uint8_t cmd,
                             const uint8_t *data, size_t len);
        int (*command_read)(const struct device *dev,
                            const struct mipi_dbi_config *config, uint8_t *cmds,
                            size_t num_cmds, uint8_t *response, size_t len);
        int (*write_display)(const struct device *dev,
                             const struct mipi_dbi_config *config,
                             const uint8_t *framebuf,
                             struct display_buffer_descriptor *desc,
                             enum display_pixel_format pixfmt);
        int (*reset)(const struct device *dev, k_timeout_t delay);
        int (*release)(const struct device *dev,
                       const struct mipi_dbi_config *config);
        int (*configure_te)(const struct device *dev,
                            uint8_t edge,
                            k_timeout_t delay);
};
 
static inline int mipi_dbi_command_write(const struct device *dev,
                                         const struct mipi_dbi_config *config,
                                         uint8_t cmd, const uint8_t *data,
                                         size_t len)
{
        const struct mipi_dbi_driver_api *api =
                (const struct mipi_dbi_driver_api *)dev->api;
 
        if (api->command_write == NULL) {
                return -ENOSYS;
        }
        return api->command_write(dev, config, cmd, data, len);
}
 
static inline int mipi_dbi_command_read(const struct device *dev,
                                        const struct mipi_dbi_config *config,
                                        uint8_t *cmds, size_t num_cmd,
                                        uint8_t *response, size_t len)
{
        const struct mipi_dbi_driver_api *api =
                (const struct mipi_dbi_driver_api *)dev->api;
 
        if (api->command_read == NULL) {
                return -ENOSYS;
        }
        return api->command_read(dev, config, cmds, num_cmd, response, len);
}
 
static inline int mipi_dbi_write_display(const struct device *dev,
                                         const struct mipi_dbi_config *config,
                                         const uint8_t *framebuf,
                                         struct display_buffer_descriptor *desc,
                                         enum display_pixel_format pixfmt)
{
        const struct mipi_dbi_driver_api *api =
                (const struct mipi_dbi_driver_api *)dev->api;
 
        if (api->write_display == NULL) {
                return -ENOSYS;
        }
        return api->write_display(dev, config, framebuf, desc, pixfmt);
}
 
static inline int mipi_dbi_reset(const struct device *dev, uint32_t delay_ms)
{
        const struct mipi_dbi_driver_api *api =
                (const struct mipi_dbi_driver_api *)dev->api;
 
        if (api->reset == NULL) {
                return -ENOSYS;
        }
        return api->reset(dev, K_MSEC(delay_ms));
}
 
static inline int mipi_dbi_release(const struct device *dev,
                                   const struct mipi_dbi_config *config)
{
        const struct mipi_dbi_driver_api *api =
                (const struct mipi_dbi_driver_api *)dev->api;
 
        if (api->release == NULL) {
                return -ENOSYS;
        }
        return api->release(dev, config);
}
 
static inline int mipi_dbi_configure_te(const struct device *dev,
                                        uint8_t edge,
                                        uint32_t delay_us)
{
        const struct mipi_dbi_driver_api *api =
                (const struct mipi_dbi_driver_api *)dev->api;
 
        if (api->configure_te == NULL) {
                return -ENOSYS;
        }
        return api->configure_te(dev, edge, K_USEC(delay_us));
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_MIPI_DBI_H_ */