led.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Linaro Limited
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_LED_H_
#define ZEPHYR_INCLUDE_DRIVERS_LED_H_

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

#define LED_BRIGHTNESS_MAX 100u

struct led_info {
        const char *label;
        uint32_t index;
        uint8_t num_colors;
        const uint8_t *color_mapping;
};

typedef int (*led_api_blink)(const struct device *dev, uint32_t led,
                             uint32_t delay_on, uint32_t delay_off);

typedef int (*led_api_get_info)(const struct device *dev, uint32_t led,
                                const struct led_info **info);

typedef int (*led_api_set_brightness)(const struct device *dev, uint32_t led,
                                      uint8_t value);
typedef int (*led_api_set_color)(const struct device *dev, uint32_t led,
                                 uint8_t num_colors, const uint8_t *color);

typedef int (*led_api_on)(const struct device *dev, uint32_t led);

typedef int (*led_api_off)(const struct device *dev, uint32_t led);

typedef int (*led_api_write_channels)(const struct device *dev,
                                      uint32_t start_channel,
                                      uint32_t num_channels,
                                      const uint8_t *buf);

__subsystem struct led_driver_api {
        /* Mandatory callbacks, either on/off or set_brightness. */
        led_api_on on;
        led_api_off off;
        led_api_set_brightness set_brightness;
        /* Optional callbacks. */
        led_api_blink blink;
        led_api_get_info get_info;
        led_api_set_color set_color;
        led_api_write_channels write_channels;
};

__syscall int led_blink(const struct device *dev, uint32_t led,
                            uint32_t delay_on, uint32_t delay_off);
 
static inline int z_impl_led_blink(const struct device *dev, uint32_t led,
                                   uint32_t delay_on, uint32_t delay_off)
{
        const struct led_driver_api *api = DEVICE_API_GET(led, dev);
 
        if (api->blink == NULL) {
                return -ENOSYS;
        }
        return api->blink(dev, led, delay_on, delay_off);
}

__syscall int led_get_info(const struct device *dev, uint32_t led,
                           const struct led_info **info);
 
static inline int z_impl_led_get_info(const struct device *dev, uint32_t led,
                                      const struct led_info **info)
{
        const struct led_driver_api *api = DEVICE_API_GET(led, dev);
 
        if (api->get_info == NULL) {
                *info = NULL;
                return -ENOSYS;
        }
        return api->get_info(dev, led, info);
}

__syscall int led_set_brightness(const struct device *dev, uint32_t led,
                                     uint8_t value);
 
static inline int z_impl_led_set_brightness(const struct device *dev,
                                            uint32_t led,
                                            uint8_t value)
{
        const struct led_driver_api *api = DEVICE_API_GET(led, dev);
 
        if (api->set_brightness == NULL) {
                if (api->on == NULL || api->off == NULL) {
                        return -ENOSYS;
                }
        }
 
        if (value > LED_BRIGHTNESS_MAX) {
                return -EINVAL;
        }
 
        if (api->set_brightness == NULL) {
                if (value) {
                        return api->on(dev, led);
                } else {
                        return api->off(dev, led);
                }
        }
 
        return api->set_brightness(dev, led, value);
}

__syscall int led_write_channels(const struct device *dev,
                                 uint32_t start_channel,
                                 uint32_t num_channels, const uint8_t *buf);
 
static inline int
z_impl_led_write_channels(const struct device *dev, uint32_t start_channel,
                          uint32_t num_channels, const uint8_t *buf)
{
        const struct led_driver_api *api = DEVICE_API_GET(led, dev);
 
        if (api->write_channels == NULL) {
                return -ENOSYS;
        }
        return api->write_channels(dev, start_channel, num_channels, buf);
}

__syscall int led_set_channel(const struct device *dev,
                              uint32_t channel, uint8_t value);
 
static inline int z_impl_led_set_channel(const struct device *dev,
                                         uint32_t channel, uint8_t value)
{
        return z_impl_led_write_channels(dev, channel, 1, &value);
}

__syscall int led_set_color(const struct device *dev, uint32_t led,
                            uint8_t num_colors, const uint8_t *color);
 
static inline int z_impl_led_set_color(const struct device *dev, uint32_t led,
                                       uint8_t num_colors, const uint8_t *color)
{
        const struct led_driver_api *api = DEVICE_API_GET(led, dev);
 
        if (api->set_color == NULL) {
                return -ENOSYS;
        }
        return api->set_color(dev, led, num_colors, color);
}

__syscall int led_on(const struct device *dev, uint32_t led);
 
static inline int z_impl_led_on(const struct device *dev, uint32_t led)
{
        const struct led_driver_api *api = DEVICE_API_GET(led, dev);
 
        if (api->set_brightness == NULL && api->on == NULL) {
                return -ENOSYS;
        }
 
        if (api->on == NULL) {
                return api->set_brightness(dev, led, LED_BRIGHTNESS_MAX);
        }
 
        return api->on(dev, led);
}

__syscall int led_off(const struct device *dev, uint32_t led);
 
static inline int z_impl_led_off(const struct device *dev, uint32_t led)
{
        const struct led_driver_api *api = DEVICE_API_GET(led, dev);
 
        if (api->set_brightness == NULL && api->off == NULL) {
                return -ENOSYS;
        }
 
        if (api->off == NULL) {
                return api->set_brightness(dev, led, 0);
        }
 
        return api->off(dev, led);
}
 
/*
 * LED DT helpers.
 */

struct led_dt_spec {
        const struct device *dev;
        uint32_t index;
};

static inline int led_blink_dt(const struct led_dt_spec *spec, uint32_t delay_on,
                               uint32_t delay_off)
{
        return led_blink(spec->dev, spec->index, delay_on, delay_off);
}

static inline int led_get_info_dt(const struct led_dt_spec *spec, const struct led_info **info)
{
        return led_get_info(spec->dev, spec->index, info);
}

static inline int led_set_brightness_dt(const struct led_dt_spec *spec,
                                        uint8_t value)
{
        return led_set_brightness(spec->dev, spec->index, value);
}

static inline int led_set_color_dt(const struct led_dt_spec *spec, uint8_t num_colors,
                                   const uint8_t *color)
{
        return led_set_color(spec->dev, spec->index, num_colors, color);
}

static inline int led_on_dt(const struct led_dt_spec *spec)
{
        return led_on(spec->dev, spec->index);
}

static inline int led_off_dt(const struct led_dt_spec *spec)
{
        return led_off(spec->dev, spec->index);
}

static inline bool led_is_ready_dt(const struct led_dt_spec *spec)
{
        return device_is_ready(spec->dev);
}

#define LED_DT_SPEC_GET(node_id)                                               \
        {                                                                      \
                .dev = DEVICE_DT_GET(DT_PARENT(node_id)),                      \
                .index = DT_NODE_CHILD_IDX(node_id),                           \
        }

#define LED_DT_SPEC_GET_OR(node_id, default_value)                             \
        COND_CODE_1(DT_NODE_EXISTS(node_id),                                   \
                    (LED_DT_SPEC_GET(node_id)),                                \
                    (default_value))

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/led.h>
 
#endif  /* ZEPHYR_INCLUDE_DRIVERS_LED_H_ */