display.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Jan Van Winkel <jan.van_winkel@dxplore.eu>
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_DISPLAY_H_
#define ZEPHYR_INCLUDE_DRIVERS_DISPLAY_H_

 
#include <zephyr/device.h>
#include <errno.h>
#include <stddef.h>
#include <zephyr/types.h>
#include <zephyr/dt-bindings/display/panel.h>
 
#ifdef __cplusplus
extern "C" {
#endif

enum display_pixel_format {
        PIXEL_FORMAT_RGB_888            = BIT(0), 

        PIXEL_FORMAT_MONO01             = BIT(1), 
        PIXEL_FORMAT_MONO10             = BIT(2), 

        PIXEL_FORMAT_ARGB_8888          = BIT(3), 

        PIXEL_FORMAT_RGB_565            = BIT(4),

        PIXEL_FORMAT_RGB_565X           = BIT(5),

        PIXEL_FORMAT_L_8                = BIT(6), 

        PIXEL_FORMAT_AL_88              = BIT(7), 

        PIXEL_FORMAT_PRIV_START = (PIXEL_FORMAT_AL_88 << 1),
};

#define DISPLAY_BITS_PER_PIXEL(fmt)                                             \
        ((((fmt & PIXEL_FORMAT_RGB_888) >> 0) * 24U) +                          \
        (((fmt & PIXEL_FORMAT_MONO01) >> 1) * 1U) +                             \
        (((fmt & PIXEL_FORMAT_MONO10) >> 2) * 1U) +                             \
        (((fmt & PIXEL_FORMAT_ARGB_8888) >> 3) * 32U) +                         \
        (((fmt & PIXEL_FORMAT_RGB_565) >> 4) * 16U) +                           \
        (((fmt & PIXEL_FORMAT_RGB_565X) >> 5) * 16U) +                          \
        (((fmt & PIXEL_FORMAT_L_8) >> 6) * 8U) +                                \
        (((fmt & PIXEL_FORMAT_AL_88) >> 7) * 16U))

enum display_screen_info {
        SCREEN_INFO_MONO_VTILED         = BIT(0),
        SCREEN_INFO_MONO_MSB_FIRST      = BIT(1),
        SCREEN_INFO_EPD                 = BIT(2),
        SCREEN_INFO_DOUBLE_BUFFER       = BIT(3),
        SCREEN_INFO_X_ALIGNMENT_WIDTH   = BIT(4),
};

enum display_orientation {
        DISPLAY_ORIENTATION_NORMAL,      
        DISPLAY_ORIENTATION_ROTATED_90,  
        DISPLAY_ORIENTATION_ROTATED_180, 
        DISPLAY_ORIENTATION_ROTATED_270, 
};

struct display_capabilities {
        uint16_t x_resolution;
        uint16_t y_resolution;
        uint32_t supported_pixel_formats;
        uint32_t screen_info;
        enum display_pixel_format current_pixel_format;
        enum display_orientation current_orientation;
};

struct display_buffer_descriptor {
        uint32_t buf_size;
        uint16_t width;
        uint16_t height;
        uint16_t pitch;
        bool frame_incomplete;
};

typedef int (*display_blanking_on_api)(const struct device *dev);

typedef int (*display_blanking_off_api)(const struct device *dev);

typedef int (*display_write_api)(const struct device *dev, const uint16_t x,
                                 const uint16_t y,
                                 const struct display_buffer_descriptor *desc,
                                 const void *buf);

typedef int (*display_read_api)(const struct device *dev, const uint16_t x,
                                const uint16_t y,
                                const struct display_buffer_descriptor *desc,
                                void *buf);

typedef int (*display_clear_api)(const struct device *dev);

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

typedef int (*display_set_brightness_api)(const struct device *dev,
                                          const uint8_t brightness);

typedef int (*display_set_contrast_api)(const struct device *dev,
                                        const uint8_t contrast);

typedef void (*display_get_capabilities_api)(const struct device *dev,
                                             struct display_capabilities *
                                             capabilities);

typedef int (*display_set_pixel_format_api)(const struct device *dev,
                                            const enum display_pixel_format
                                            pixel_format);

typedef int (*display_set_orientation_api)(const struct device *dev,
                                           const enum display_orientation
                                           orientation);

__subsystem struct display_driver_api {
        display_blanking_on_api blanking_on;
        display_blanking_off_api blanking_off;
        display_write_api write;
        display_read_api read;
        display_clear_api clear;
        display_get_framebuffer_api get_framebuffer;
        display_set_brightness_api set_brightness;
        display_set_contrast_api set_contrast;
        display_get_capabilities_api get_capabilities;
        display_set_pixel_format_api set_pixel_format;
        display_set_orientation_api set_orientation;
};

static inline int display_write(const struct device *dev, const uint16_t x,
                                const uint16_t y,
                                const struct display_buffer_descriptor *desc,
                                const void *buf)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        return api->write(dev, x, y, desc, buf);
}

static inline int display_read(const struct device *dev, const uint16_t x,
                               const uint16_t y,
                               const struct display_buffer_descriptor *desc,
                               void *buf)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        if (api->read == NULL) {
                return -ENOSYS;
        }
 
        return api->read(dev, x, y, desc, buf);
}

static inline int display_clear(const struct device *dev)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        if (api->clear == NULL) {
                return -ENOSYS;
        }
 
        return api->clear(dev);
}

static inline void *display_get_framebuffer(const struct device *dev)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        if (api->get_framebuffer == NULL) {
                return NULL;
        }
 
        return api->get_framebuffer(dev);
}

static inline int display_blanking_on(const struct device *dev)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        if (api->blanking_on == NULL) {
                return -ENOSYS;
        }
 
        return api->blanking_on(dev);
}

static inline int display_blanking_off(const struct device *dev)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        if (api->blanking_off == NULL) {
                return -ENOSYS;
        }
 
        return api->blanking_off(dev);
}

static inline int display_set_brightness(const struct device *dev,
                                         uint8_t brightness)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        if (api->set_brightness == NULL) {
                return -ENOSYS;
        }
 
        return api->set_brightness(dev, brightness);
}

static inline int display_set_contrast(const struct device *dev, uint8_t contrast)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        if (api->set_contrast == NULL) {
                return -ENOSYS;
        }
 
        return api->set_contrast(dev, contrast);
}

static inline void display_get_capabilities(const struct device *dev,
                                            struct display_capabilities *
                                            capabilities)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        api->get_capabilities(dev, capabilities);
}

static inline int
display_set_pixel_format(const struct device *dev,
                         const enum display_pixel_format pixel_format)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        if (api->set_pixel_format == NULL) {
                return -ENOSYS;
        }
 
        return api->set_pixel_format(dev, pixel_format);
}

static inline int display_set_orientation(const struct device *dev,
                                          const enum display_orientation
                                          orientation)
{
        struct display_driver_api *api =
                (struct display_driver_api *)dev->api;
 
        if (api->set_orientation == NULL) {
                return -ENOSYS;
        }
 
        return api->set_orientation(dev, orientation);
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_DRIVERS_DISPLAY_H_ */