247 lines
6.1 KiB
C
247 lines
6.1 KiB
C
/*
|
|
* Copyright (c) 2017 Linaro Limited
|
|
* Copyright (c) 2019, Nordic Semiconductor ASA
|
|
* Copyright (c) 2021 Seagate Technology LLC
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#define DT_DRV_COMPAT worldsemi_ws2812_spi
|
|
|
|
#include <zephyr/drivers/led_strip.h>
|
|
|
|
#include <string.h>
|
|
|
|
#define LOG_LEVEL CONFIG_LED_STRIP_LOG_LEVEL
|
|
#include <zephyr/logging/log.h>
|
|
LOG_MODULE_REGISTER(ws2812_spi);
|
|
|
|
#include <zephyr/kernel.h>
|
|
#include <zephyr/device.h>
|
|
#include <zephyr/drivers/spi.h>
|
|
#include <zephyr/sys/math_extras.h>
|
|
#include <zephyr/sys/util.h>
|
|
#include <zephyr/dt-bindings/led/led.h>
|
|
|
|
/* spi-one-frame and spi-zero-frame in DT are for 8-bit frames. */
|
|
#define SPI_FRAME_BITS 8
|
|
|
|
/*
|
|
* SPI master configuration:
|
|
*
|
|
* - mode 0 (the default), 8 bit, MSB first (arbitrary), one-line SPI
|
|
* - no shenanigans (don't hold CS, don't hold the device lock, this
|
|
* isn't an EEPROM)
|
|
*/
|
|
#define SPI_OPER(idx) (SPI_OP_MODE_MASTER | SPI_TRANSFER_MSB | \
|
|
SPI_WORD_SET(SPI_FRAME_BITS))
|
|
|
|
struct ws2812_spi_cfg {
|
|
struct spi_dt_spec bus;
|
|
uint8_t *px_buf;
|
|
size_t px_buf_size;
|
|
uint8_t one_frame;
|
|
uint8_t zero_frame;
|
|
uint8_t num_colors;
|
|
const uint8_t *color_mapping;
|
|
uint16_t reset_delay;
|
|
};
|
|
|
|
static const struct ws2812_spi_cfg *dev_cfg(const struct device *dev)
|
|
{
|
|
return dev->config;
|
|
}
|
|
|
|
/*
|
|
* Serialize an 8-bit color channel value into an equivalent sequence
|
|
* of SPI frames, MSbit first, where a one bit becomes SPI frame
|
|
* one_frame, and zero bit becomes zero_frame.
|
|
*/
|
|
static inline void ws2812_spi_ser(uint8_t buf[8], uint8_t color,
|
|
const uint8_t one_frame, const uint8_t zero_frame)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
buf[i] = color & BIT(7 - i) ? one_frame : zero_frame;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Returns true if and only if cfg->px_buf is big enough to convert
|
|
* num_pixels RGB color values into SPI frames.
|
|
*/
|
|
static inline bool num_pixels_ok(const struct ws2812_spi_cfg *cfg,
|
|
size_t num_pixels)
|
|
{
|
|
size_t nbytes;
|
|
bool overflow;
|
|
|
|
overflow = size_mul_overflow(num_pixels, cfg->num_colors * 8, &nbytes);
|
|
return !overflow && (nbytes <= cfg->px_buf_size);
|
|
}
|
|
|
|
/*
|
|
* Latch current color values on strip and reset its state machines.
|
|
*/
|
|
static inline void ws2812_reset_delay(uint16_t delay)
|
|
{
|
|
k_usleep(delay);
|
|
}
|
|
|
|
static int ws2812_strip_update_rgb(const struct device *dev,
|
|
struct led_rgb *pixels,
|
|
size_t num_pixels)
|
|
{
|
|
const struct ws2812_spi_cfg *cfg = dev_cfg(dev);
|
|
const uint8_t one = cfg->one_frame, zero = cfg->zero_frame;
|
|
struct spi_buf buf = {
|
|
.buf = cfg->px_buf,
|
|
.len = cfg->px_buf_size,
|
|
};
|
|
const struct spi_buf_set tx = {
|
|
.buffers = &buf,
|
|
.count = 1
|
|
};
|
|
uint8_t *px_buf = cfg->px_buf;
|
|
size_t i;
|
|
int rc;
|
|
|
|
if (!num_pixels_ok(cfg, num_pixels)) {
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/*
|
|
* Convert pixel data into SPI frames. Each frame has pixel data
|
|
* in color mapping on-wire format (e.g. GRB, GRBW, RGB, etc).
|
|
*/
|
|
for (i = 0; i < num_pixels; i++) {
|
|
uint8_t j;
|
|
|
|
for (j = 0; j < cfg->num_colors; j++) {
|
|
uint8_t pixel;
|
|
|
|
switch (cfg->color_mapping[j]) {
|
|
/* White channel is not supported by LED strip API. */
|
|
case LED_COLOR_ID_WHITE:
|
|
pixel = 0;
|
|
break;
|
|
case LED_COLOR_ID_RED:
|
|
pixel = pixels[i].r;
|
|
break;
|
|
case LED_COLOR_ID_GREEN:
|
|
pixel = pixels[i].g;
|
|
break;
|
|
case LED_COLOR_ID_BLUE:
|
|
pixel = pixels[i].b;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
ws2812_spi_ser(px_buf, pixel, one, zero);
|
|
px_buf += 8;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Display the pixel data.
|
|
*/
|
|
rc = spi_write_dt(&cfg->bus, &tx);
|
|
ws2812_reset_delay(cfg->reset_delay);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int ws2812_strip_update_channels(const struct device *dev,
|
|
uint8_t *channels,
|
|
size_t num_channels)
|
|
{
|
|
LOG_ERR("update_channels not implemented");
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
static int ws2812_spi_init(const struct device *dev)
|
|
{
|
|
const struct ws2812_spi_cfg *cfg = dev_cfg(dev);
|
|
uint8_t i;
|
|
|
|
if (!spi_is_ready_dt(&cfg->bus)) {
|
|
LOG_ERR("SPI device %s not ready", cfg->bus.bus->name);
|
|
return -ENODEV;
|
|
}
|
|
|
|
for (i = 0; i < cfg->num_colors; i++) {
|
|
switch (cfg->color_mapping[i]) {
|
|
case LED_COLOR_ID_WHITE:
|
|
case LED_COLOR_ID_RED:
|
|
case LED_COLOR_ID_GREEN:
|
|
case LED_COLOR_ID_BLUE:
|
|
break;
|
|
default:
|
|
LOG_ERR("%s: invalid channel to color mapping."
|
|
"Check the color-mapping DT property",
|
|
dev->name);
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct led_strip_driver_api ws2812_spi_api = {
|
|
.update_rgb = ws2812_strip_update_rgb,
|
|
.update_channels = ws2812_strip_update_channels,
|
|
};
|
|
|
|
#define WS2812_SPI_NUM_PIXELS(idx) \
|
|
(DT_INST_PROP(idx, chain_length))
|
|
#define WS2812_SPI_HAS_WHITE(idx) \
|
|
(DT_INST_PROP(idx, has_white_channel) == 1)
|
|
#define WS2812_SPI_ONE_FRAME(idx) \
|
|
(DT_INST_PROP(idx, spi_one_frame))
|
|
#define WS2812_SPI_ZERO_FRAME(idx) \
|
|
(DT_INST_PROP(idx, spi_zero_frame))
|
|
#define WS2812_SPI_BUFSZ(idx) \
|
|
(WS2812_NUM_COLORS(idx) * 8 * WS2812_SPI_NUM_PIXELS(idx))
|
|
|
|
/*
|
|
* Retrieve the channel to color mapping (e.g. RGB, BGR, GRB, ...) from the
|
|
* "color-mapping" DT property.
|
|
*/
|
|
#define WS2812_COLOR_MAPPING(idx) \
|
|
static const uint8_t ws2812_spi_##idx##_color_mapping[] = \
|
|
DT_INST_PROP(idx, color_mapping)
|
|
|
|
#define WS2812_NUM_COLORS(idx) (DT_INST_PROP_LEN(idx, color_mapping))
|
|
|
|
/* Get the latch/reset delay from the "reset-delay" DT property. */
|
|
#define WS2812_RESET_DELAY(idx) DT_INST_PROP(idx, reset_delay)
|
|
|
|
#define WS2812_SPI_DEVICE(idx) \
|
|
\
|
|
static uint8_t ws2812_spi_##idx##_px_buf[WS2812_SPI_BUFSZ(idx)]; \
|
|
\
|
|
WS2812_COLOR_MAPPING(idx); \
|
|
\
|
|
static const struct ws2812_spi_cfg ws2812_spi_##idx##_cfg = { \
|
|
.bus = SPI_DT_SPEC_INST_GET(idx, SPI_OPER(idx), 0), \
|
|
.px_buf = ws2812_spi_##idx##_px_buf, \
|
|
.px_buf_size = WS2812_SPI_BUFSZ(idx), \
|
|
.one_frame = WS2812_SPI_ONE_FRAME(idx), \
|
|
.zero_frame = WS2812_SPI_ZERO_FRAME(idx), \
|
|
.num_colors = WS2812_NUM_COLORS(idx), \
|
|
.color_mapping = ws2812_spi_##idx##_color_mapping, \
|
|
.reset_delay = WS2812_RESET_DELAY(idx), \
|
|
}; \
|
|
\
|
|
DEVICE_DT_INST_DEFINE(idx, \
|
|
ws2812_spi_init, \
|
|
NULL, \
|
|
NULL, \
|
|
&ws2812_spi_##idx##_cfg, \
|
|
POST_KERNEL, \
|
|
CONFIG_LED_STRIP_INIT_PRIORITY, \
|
|
&ws2812_spi_api);
|
|
|
|
DT_INST_FOREACH_STATUS_OKAY(WS2812_SPI_DEVICE)
|