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_DT_SPI_DEV(node_id)                                    \
        DT_PHANDLE(DT_PARENT(node_id), spi_dev)

#define MIPI_DBI_SPI_DEV_HAS_CS_GPIOS(node_id)                          \
        DT_PROP_HAS_IDX(MIPI_DBI_DT_SPI_DEV(node_id), cs_gpios,         \
                        DT_REG_ADDR_RAW(node_id))

#define MIPI_DBI_SPI_CS_GPIOS_DT_SPEC_GET(node_id)                      \
        GPIO_DT_SPEC_GET_BY_IDX_OR(MIPI_DBI_DT_SPI_DEV(node_id),        \
                cs_gpios, DT_REG_ADDR_RAW(node_id), {})
 
#define MIPI_DBI_SPI_CS_CONTROL_INIT_GPIO(node_id, delay_)              \
        .gpio = MIPI_DBI_SPI_CS_GPIOS_DT_SPEC_GET(node_id),             \
        .delay = delay_,

#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)),       \
                .peripheral = DT_REG_ADDR(node_id),                             \
                .cs = {                                                                 \
                        COND_CODE_1(MIPI_DBI_SPI_DEV_HAS_CS_GPIOS(node_id),                     \
                        (MIPI_DBI_SPI_CS_CONTROL_INIT_GPIO(node_id, delay_)),           \
                        (SPI_CS_CONTROL_INIT_NATIVE(node_id)))                          \
                        .cs_is_gpio = MIPI_DBI_SPI_DEV_HAS_CS_GPIOS(node_id),           \
                },                                                                      \
        }

#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),      \
                .color_coding = DT_STRING_UPPER_TOKEN_OR(node_id, color_coding, 0), \
                .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;
        uint8_t color_coding;
        struct spi_config config;
};

typedef int (*mipi_dbi_command_write_t)(const struct device *dev,
                                        const struct mipi_dbi_config *config, uint8_t cmd,
                                        const uint8_t *data, size_t len);

typedef int (*mipi_dbi_command_read_t)(const struct device *dev,
                                       const struct mipi_dbi_config *config, uint8_t *cmds,
                                       size_t num_cmds, uint8_t *response, size_t len);

typedef int (*mipi_dbi_write_display_t)(const struct device *dev,
                                        const struct mipi_dbi_config *config,
                                        const uint8_t *framebuf,
                                        struct display_buffer_descriptor *desc,
                                        enum display_pixel_format pixfmt);

typedef int (*mipi_dbi_reset_t)(const struct device *dev, k_timeout_t delay);

typedef int (*mipi_dbi_release_t)(const struct device *dev, const struct mipi_dbi_config *config);

typedef int (*mipi_dbi_configure_te_t)(const struct device *dev, uint8_t edge, k_timeout_t delay);

__subsystem struct mipi_dbi_driver_api {
        mipi_dbi_command_write_t command_write;
        mipi_dbi_command_read_t command_read;
        mipi_dbi_write_display_t write_display;
        mipi_dbi_reset_t reset;
        mipi_dbi_release_t release;
        mipi_dbi_configure_te_t configure_te;
};


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 = DEVICE_API_GET(mipi_dbi, dev);
 
        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 = DEVICE_API_GET(mipi_dbi, dev);
 
        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 = DEVICE_API_GET(mipi_dbi, dev);
 
        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 = DEVICE_API_GET(mipi_dbi, dev);
 
        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 = DEVICE_API_GET(mipi_dbi, dev);
 
        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 = DEVICE_API_GET(mipi_dbi, dev);
 
        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_ */