auxdisplay.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022-2023 Jamie McCrae
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_AUXDISPLAY_H_
#define ZEPHYR_INCLUDE_DRIVERS_AUXDISPLAY_H_

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

#define AUXDISPLAY_LIGHT_NOT_SUPPORTED 0

typedef uint32_t auxdisplay_mode_t;

enum auxdisplay_position {
        AUXDISPLAY_POSITION_ABSOLUTE = 0,

        AUXDISPLAY_POSITION_RELATIVE,

        AUXDISPLAY_POSITION_RELATIVE_DIRECTION,
 
        AUXDISPLAY_POSITION_COUNT,
};

enum auxdisplay_direction {
        AUXDISPLAY_DIRECTION_RIGHT = 0,

        AUXDISPLAY_DIRECTION_LEFT,
 
        AUXDISPLAY_DIRECTION_COUNT,
};

struct auxdisplay_light {
        uint8_t minimum;

        uint8_t maximum;
};

struct auxdisplay_capabilities {
        uint16_t columns;

        uint16_t rows;

        auxdisplay_mode_t mode;

        struct auxdisplay_light brightness;

        struct auxdisplay_light backlight;

        uint8_t custom_characters;

        uint8_t custom_character_width;

        uint8_t custom_character_height;
};

struct auxdisplay_custom_data {
        uint8_t *data;

        uint16_t len;

        uint32_t options;
};

struct auxdisplay_character {
        uint8_t index;

        uint8_t *data;

        uint8_t character_code;
};


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

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

typedef int (*auxdisplay_cursor_set_enabled_t)(const struct device *dev, bool enabled);

typedef int (*auxdisplay_position_blinking_set_enabled_t)(const struct device *dev,
                                                          bool enabled);

typedef int (*auxdisplay_cursor_shift_set_t)(const struct device *dev, uint8_t direction,
                                             bool display_shift);

typedef int (*auxdisplay_cursor_position_set_t)(const struct device *dev,
                                                enum auxdisplay_position type,
                                                int16_t x, int16_t y);

typedef int (*auxdisplay_cursor_position_get_t)(const struct device *dev, int16_t *x,
                                                int16_t *y);

typedef int (*auxdisplay_display_position_set_t)(const struct device *dev,
                                                 enum auxdisplay_position type,
                                                 int16_t x, int16_t y);

typedef int (*auxdisplay_display_position_get_t)(const struct device *dev, int16_t *x,
                                                 int16_t *y);

typedef int (*auxdisplay_capabilities_get_t)(const struct device *dev,
                                             struct auxdisplay_capabilities *capabilities);

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

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

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

typedef int (*auxdisplay_backlight_get_t)(const struct device *dev, uint8_t *backlight);

typedef int (*auxdisplay_backlight_set_t)(const struct device *dev, uint8_t backlight);

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

typedef int (*auxdisplay_custom_character_set_t)(const struct device *dev,
                                                 struct auxdisplay_character *character);

typedef int (*auxdisplay_write_t)(const struct device *dev, const uint8_t *data, uint16_t len);

typedef int (*auxdisplay_custom_command_t)(const struct device *dev,
                                           struct auxdisplay_custom_data *command);

typedef int (*auxdisplay_custom_indicator_set_t)(const struct device *dev,
                                                 uint8_t index, bool enable);

__subsystem struct auxdisplay_driver_api {
        auxdisplay_display_on_t display_on;
        auxdisplay_display_off_t display_off;
        auxdisplay_cursor_set_enabled_t cursor_set_enabled;
        auxdisplay_position_blinking_set_enabled_t position_blinking_set_enabled;
        auxdisplay_cursor_shift_set_t cursor_shift_set;
        auxdisplay_cursor_position_set_t cursor_position_set;
        auxdisplay_cursor_position_get_t cursor_position_get;
        auxdisplay_display_position_set_t display_position_set;
        auxdisplay_display_position_get_t display_position_get;
        auxdisplay_capabilities_get_t capabilities_get;
        auxdisplay_clear_t clear;
        auxdisplay_brightness_get_t brightness_get;
        auxdisplay_brightness_set_t brightness_set;
        auxdisplay_backlight_get_t backlight_get;
        auxdisplay_backlight_set_t backlight_set;
        auxdisplay_is_busy_t is_busy;
        auxdisplay_custom_character_set_t custom_character_set;
        auxdisplay_write_t write;
        auxdisplay_custom_command_t custom_command;
        auxdisplay_custom_indicator_set_t custom_indicator_set;
};


__syscall int auxdisplay_display_on(const struct device *dev);
 
static inline int z_impl_auxdisplay_display_on(const struct device *dev)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->display_on) {
                return -ENOSYS;
        }
 
        return api->display_on(dev);
}

__syscall int auxdisplay_display_off(const struct device *dev);
 
static inline int z_impl_auxdisplay_display_off(const struct device *dev)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->display_off) {
                return -ENOSYS;
        }
 
        return api->display_off(dev);
}

__syscall int auxdisplay_cursor_set_enabled(const struct device *dev,
                                            bool enabled);
 
static inline int z_impl_auxdisplay_cursor_set_enabled(const struct device *dev,
                                                       bool enabled)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->cursor_set_enabled) {
                return -ENOSYS;
        }
 
        return api->cursor_set_enabled(dev, enabled);
}

__syscall int auxdisplay_position_blinking_set_enabled(const struct device *dev,
                                                       bool enabled);
 
static inline int z_impl_auxdisplay_position_blinking_set_enabled(const struct device *dev,
                                                                  bool enabled)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->position_blinking_set_enabled) {
                return -ENOSYS;
        }
 
        return api->position_blinking_set_enabled(dev, enabled);
}

__syscall int auxdisplay_cursor_shift_set(const struct device *dev,
                                          uint8_t direction, bool display_shift);
 
static inline int z_impl_auxdisplay_cursor_shift_set(const struct device *dev,
                                                     uint8_t direction,
                                                     bool display_shift)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->cursor_shift_set) {
                return -ENOSYS;
        }
 
        if (direction >= AUXDISPLAY_DIRECTION_COUNT) {
                return -EINVAL;
        }
 
        return api->cursor_shift_set(dev, direction, display_shift);
}

__syscall int auxdisplay_cursor_position_set(const struct device *dev,
                                             enum auxdisplay_position type,
                                             int16_t x, int16_t y);
 
static inline int z_impl_auxdisplay_cursor_position_set(const struct device *dev,
                                                        enum auxdisplay_position type,
                                                        int16_t x, int16_t y)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->cursor_position_set) {
                return -ENOSYS;
        } else if (type >= AUXDISPLAY_POSITION_COUNT) {
                return -EINVAL;
        } else if (type == AUXDISPLAY_POSITION_ABSOLUTE && (x < 0 || y < 0)) {
                return -EINVAL;
        }
 
        return api->cursor_position_set(dev, type, x, y);
}

__syscall int auxdisplay_cursor_position_get(const struct device *dev,
                                             int16_t *x, int16_t *y);
 
static inline int z_impl_auxdisplay_cursor_position_get(const struct device *dev,
                                                        int16_t *x, int16_t *y)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->cursor_position_get) {
                return -ENOSYS;
        }
 
        return api->cursor_position_get(dev, x, y);
}

__syscall int auxdisplay_display_position_set(const struct device *dev,
                                              enum auxdisplay_position type,
                                              int16_t x, int16_t y);
 
static inline int z_impl_auxdisplay_display_position_set(const struct device *dev,
                                                         enum auxdisplay_position type,
                                                         int16_t x, int16_t y)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->display_position_set) {
                return -ENOSYS;
        } else if (type >= AUXDISPLAY_POSITION_COUNT) {
                return -EINVAL;
        } else if (type == AUXDISPLAY_POSITION_ABSOLUTE && (x < 0 || y < 0)) {
                return -EINVAL;
        }
 
        return api->display_position_set(dev, type, x, y);
}

__syscall int auxdisplay_display_position_get(const struct device *dev,
                                              int16_t *x, int16_t *y);
 
static inline int z_impl_auxdisplay_display_position_get(const struct device *dev,
                                                         int16_t *x, int16_t *y)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->display_position_get) {
                return -ENOSYS;
        }
 
        return api->display_position_get(dev, x, y);
}

__syscall int auxdisplay_capabilities_get(const struct device *dev,
                                          struct auxdisplay_capabilities *capabilities);
 
static inline int z_impl_auxdisplay_capabilities_get(const struct device *dev,
                                                     struct auxdisplay_capabilities *capabilities)
{
        return DEVICE_API_GET(auxdisplay, dev)->capabilities_get(dev, capabilities);
}

__syscall int auxdisplay_clear(const struct device *dev);
 
static inline int z_impl_auxdisplay_clear(const struct device *dev)
{
        return DEVICE_API_GET(auxdisplay, dev)->clear(dev);
}

__syscall int auxdisplay_brightness_get(const struct device *dev,
                                        uint8_t *brightness);
 
static inline int z_impl_auxdisplay_brightness_get(const struct device *dev,
                                                   uint8_t *brightness)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->brightness_get) {
                return -ENOSYS;
        }
 
        return api->brightness_get(dev, brightness);
}

__syscall int auxdisplay_brightness_set(const struct device *dev,
                                        uint8_t brightness);
 
static inline int z_impl_auxdisplay_brightness_set(const struct device *dev,
                                                   uint8_t brightness)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->brightness_set) {
                return -ENOSYS;
        }
 
        return api->brightness_set(dev, brightness);
}

__syscall int auxdisplay_backlight_get(const struct device *dev,
                                       uint8_t *backlight);
 
static inline int z_impl_auxdisplay_backlight_get(const struct device *dev,
                                                  uint8_t *backlight)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->backlight_get) {
                return -ENOSYS;
        }
 
        return api->backlight_get(dev, backlight);
}

__syscall int auxdisplay_backlight_set(const struct device *dev,
                                       uint8_t backlight);
 
static inline int z_impl_auxdisplay_backlight_set(const struct device *dev,
                                                  uint8_t backlight)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->backlight_set) {
                return -ENOSYS;
        }
 
        return api->backlight_set(dev, backlight);
}

__syscall int auxdisplay_is_busy(const struct device *dev);
 
static inline int z_impl_auxdisplay_is_busy(const struct device *dev)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->is_busy) {
                return -ENOSYS;
        }
 
        return api->is_busy(dev);
}

__syscall int auxdisplay_custom_character_set(const struct device *dev,
                                              struct auxdisplay_character *character);
 
static inline int z_impl_auxdisplay_custom_character_set(const struct device *dev,
                                                         struct auxdisplay_character *character)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->custom_character_set) {
                return -ENOSYS;
        }
 
        return api->custom_character_set(dev, character);
}

__syscall int auxdisplay_write(const struct device *dev, const uint8_t *data,
                               uint16_t len);
 
static inline int z_impl_auxdisplay_write(const struct device *dev,
                                          const uint8_t *data, uint16_t len)
{
        return DEVICE_API_GET(auxdisplay, dev)->write(dev, data, len);
}

__syscall int auxdisplay_custom_command(const struct device *dev,
                                        struct auxdisplay_custom_data *data);
 
static inline int z_impl_auxdisplay_custom_command(const struct device *dev,
                                                   struct auxdisplay_custom_data *data)
{
        const struct auxdisplay_driver_api *api = DEVICE_API_GET(auxdisplay, dev);
 
        if (!api->custom_command) {
                return -ENOSYS;
        }
 
        return api->custom_command(dev, data);
}

__syscall int auxdisplay_custom_indicator_set(const struct device *dev,
                                              uint8_t index, bool enable);
 
static inline int z_impl_auxdisplay_custom_indicator_set(const struct device *dev,
                                                         uint8_t index, bool enable)
{
        struct auxdisplay_driver_api *api = (struct auxdisplay_driver_api *)dev->api;
 
        if (!api->custom_indicator_set) {
                return -ENOSYS;
        }
 
        return api->custom_indicator_set(dev, index, enable);
}
 
#ifdef __cplusplus
}
#endif

 
#include <zephyr/syscalls/auxdisplay.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_AUXDISPLAY_H_ */