From 7a198c349dea5da06b621b901216b1266d5074dc Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Sun, 26 Jan 2025 00:50:15 +1100 Subject: [PATCH 01/12] add ws2812 optimisations to not send if there are no changes --- platforms/avr/drivers/ws2812_bitbang.c | 3 +++ platforms/avr/drivers/ws2812_i2c.c | 3 +++ platforms/chibios/drivers/ws2812_bitbang.c | 3 +++ platforms/chibios/drivers/ws2812_spi.c | 6 ++++-- 4 files changed, 13 insertions(+), 2 deletions(-) diff --git a/platforms/avr/drivers/ws2812_bitbang.c b/platforms/avr/drivers/ws2812_bitbang.c index 183690c9674..23bab5256ca 100644 --- a/platforms/avr/drivers/ws2812_bitbang.c +++ b/platforms/avr/drivers/ws2812_bitbang.c @@ -152,6 +152,7 @@ static inline void ws2812_sendarray_mask(uint8_t *data, uint16_t datlen, uint8_t } ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; +bool ws2812_dirty = false; void ws2812_init(void) { DDRx_ADDRESS(WS2812_DI_PIN) |= pinmask(WS2812_DI_PIN); @@ -161,6 +162,7 @@ void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { ws2812_leds[index].r = red; ws2812_leds[index].g = green; ws2812_leds[index].b = blue; + ws2812_dirty = true; #if defined(WS2812_RGBW) ws2812_rgb_to_rgbw(&ws2812_leds[index]); #endif @@ -173,6 +175,7 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { } void ws2812_flush(void) { + if (!ws2812_dirty) return; uint8_t masklo = ~(pinmask(WS2812_DI_PIN)) & PORTx_ADDRESS(WS2812_DI_PIN); uint8_t maskhi = pinmask(WS2812_DI_PIN) | PORTx_ADDRESS(WS2812_DI_PIN); diff --git a/platforms/avr/drivers/ws2812_i2c.c b/platforms/avr/drivers/ws2812_i2c.c index e6b922f4bfe..7ab92b61d13 100644 --- a/platforms/avr/drivers/ws2812_i2c.c +++ b/platforms/avr/drivers/ws2812_i2c.c @@ -17,6 +17,7 @@ #endif ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; +bool ws2812_dirty = false; void ws2812_init(void) { i2c_init(); @@ -26,6 +27,7 @@ void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { ws2812_leds[index].r = red; ws2812_leds[index].g = green; ws2812_leds[index].b = blue; + ws2812_dirty = true; } void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { @@ -35,5 +37,6 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { } void ws2812_flush(void) { + if (!ws2812_dirty) return; i2c_transmit(WS2812_I2C_ADDRESS, (uint8_t *)ws2812_leds, WS2812_LED_COUNT * sizeof(ws2812_led_t), WS2812_I2C_TIMEOUT); } diff --git a/platforms/chibios/drivers/ws2812_bitbang.c b/platforms/chibios/drivers/ws2812_bitbang.c index a88c5ff619d..93fbb6db7ec 100644 --- a/platforms/chibios/drivers/ws2812_bitbang.c +++ b/platforms/chibios/drivers/ws2812_bitbang.c @@ -77,6 +77,7 @@ void sendByte(uint8_t byte) { } ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; +bool ws2812_dirty = false; void ws2812_init(void) { palSetLineMode(WS2812_DI_PIN, WS2812_OUTPUT_MODE); @@ -86,6 +87,7 @@ void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { ws2812_leds[index].r = red; ws2812_leds[index].g = green; ws2812_leds[index].b = blue; + ws2812_dirty = true; #if defined(WS2812_RGBW) ws2812_rgb_to_rgbw(&ws2812_leds[index]); #endif @@ -98,6 +100,7 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { } void ws2812_flush(void) { + if (!ws2812_dirty) return; // this code is very time dependent, so we need to disable interrupts chSysLock(); diff --git a/platforms/chibios/drivers/ws2812_spi.c b/platforms/chibios/drivers/ws2812_spi.c index d1792b871bf..4ccea138887 100644 --- a/platforms/chibios/drivers/ws2812_spi.c +++ b/platforms/chibios/drivers/ws2812_spi.c @@ -165,6 +165,7 @@ static void set_led_color_rgb(ws2812_led_t color, int pos) { } ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; +bool ws2812_dirty = false; void ws2812_init(void) { palSetLineMode(WS2812_DI_PIN, WS2812_MOSI_OUTPUT_MODE); @@ -188,8 +189,7 @@ void ws2812_init(void) { 0, WS2812_SPI_DIVISOR # else - WS2812_SPI_DIVISOR_CR1_BR_X, - 0 + WS2812_SPI_DIVISOR_CR1_BR_X, 0 # endif #else // HAL_SPI_V2 @@ -228,6 +228,7 @@ void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { ws2812_leds[index].r = red; ws2812_leds[index].g = green; ws2812_leds[index].b = blue; + ws2812_dirty = true; #if defined(WS2812_RGBW) ws2812_rgb_to_rgbw(&ws2812_leds[index]); #endif @@ -248,6 +249,7 @@ void ws2812_flush(void) { // Instead spiSend can be used to send synchronously (or the thread logic can be added back). #ifndef WS2812_SPI_USE_CIRCULAR_BUFFER # ifdef WS2812_SPI_SYNC + if (!ws2812_dirty) return; spiSend(&WS2812_SPI_DRIVER, ARRAY_SIZE(txbuf), txbuf); # else spiStartSend(&WS2812_SPI_DRIVER, ARRAY_SIZE(txbuf), txbuf); From c93e8e0af23f79ea6f582a80bdbe87cb3ac8fd74 Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Sun, 26 Jan 2025 00:50:32 +1100 Subject: [PATCH 02/12] initial batch of issi led --- drivers/led/issi/is31fl3729.c | 35 ++++++++++---- drivers/led/issi/is31fl3731-mono.c | 34 ++++++++++---- drivers/led/issi/is31fl3731.c | 42 ++++++++++++----- drivers/led/issi/is31fl3733.c | 42 ++++++++++++----- drivers/led/issi/is31fl3741.c | 73 ++++++++++++++++++++++++------ 5 files changed, 170 insertions(+), 56 deletions(-) diff --git a/drivers/led/issi/is31fl3729.c b/drivers/led/issi/is31fl3729.c index 80acb22fa28..79005686ddc 100644 --- a/drivers/led/issi/is31fl3729.c +++ b/drivers/led/issi/is31fl3729.c @@ -64,6 +64,9 @@ # define IS31FL3729_PWM_FREQUENCY IS31FL3729_PWM_FREQUENCY_32K_HZ #endif +#define IS31FL3729_PWM_REGISTERS_PER_CHUNK 13 +#define IS31FL3729_CHUNK_COUNT (IS31FL3729_PWM_REGISTER_COUNT / IS31FL3729_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = { IS31FL3729_I2C_ADDRESS_1, #ifdef IS31FL3729_I2C_ADDRESS_2 @@ -81,14 +84,14 @@ const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = { // Storing them like this is optimal for I2C transfers to the registers. typedef struct is31fl3729_driver_t { uint8_t pwm_buffer[IS31FL3729_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3729_CHUNK_COUNT]; uint8_t scaling_buffer[IS31FL3729_SCALING_REGISTER_COUNT]; bool scaling_buffer_dirty; } PACKED is31fl3729_driver_t; is31fl3729_driver_t driver_buffers[IS31FL3729_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .scaling_buffer_dirty = false, }}; @@ -107,13 +110,21 @@ void is31fl3729_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 11 transfers of 13 bytes. // Iterate over the pwm_buffer contents at 13 byte intervals. - for (uint8_t i = 0; i <= IS31FL3729_PWM_REGISTER_COUNT; i += 13) { + for (uint8_t i = 0; i <= IS31FL3729_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3729_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3729_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3729_I2C_PERSISTENCE; j++) { if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 13, IS31FL3729_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 13, IS31FL3729_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3729_PWM_REGISTERS_PER_CHUNK, IS31FL3729_I2C_TIMEOUT); #endif } } @@ -167,7 +178,10 @@ void is31fl3729_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.b] = blue; - driver_buffers[led.driver].pwm_buffer_dirty = true; + + driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3729_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3729_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3729_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -195,10 +209,13 @@ void is31fl3729_set_scaling_register(uint8_t index, uint8_t red, uint8_t green, } void is31fl3729_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3729_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3729_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3729_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3731-mono.c b/drivers/led/issi/is31fl3731-mono.c index 33a863b982f..077fc16ce87 100644 --- a/drivers/led/issi/is31fl3731-mono.c +++ b/drivers/led/issi/is31fl3731-mono.c @@ -33,6 +33,9 @@ # define IS31FL3731_I2C_PERSISTENCE 0 #endif +#define IS31FL3731_PWM_REGISTERS_PER_CHUNK 16 +#define IS31FL3731_CHUNK_COUNT (IS31FL3731_PWM_REGISTER_COUNT / IS31FL3731_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { IS31FL3731_I2C_ADDRESS_1, #ifdef IS31FL3731_I2C_ADDRESS_2 @@ -53,14 +56,14 @@ const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct is31fl3731_driver_t { uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3731_CHUNK_COUNT]; uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT]; bool led_control_buffer_dirty; } PACKED is31fl3731_driver_t; is31fl3731_driver_t driver_buffers[IS31FL3731_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, }}; @@ -84,13 +87,21 @@ void is31fl3731_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 9 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < IS31FL3731_PWM_REGISTER_COUNT; i += 16) { + for (uint8_t i = 0; i < IS31FL3731_PWM_REGISTER_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3731_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3731_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3731_I2C_PERSISTENCE; j++) { if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3731_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3731_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3731_PWM_REGISTERS_PER_CHUNK, IS31FL3731_I2C_TIMEOUT); #endif } } @@ -178,8 +189,8 @@ void is31fl3731_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.v] = value; + driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3731_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -206,10 +217,13 @@ void is31fl3731_set_led_control_register(uint8_t index, bool value) { } void is31fl3731_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3731_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3731_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3731_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3731.c b/drivers/led/issi/is31fl3731.c index 86d953ef25d..6ea50cac74a 100644 --- a/drivers/led/issi/is31fl3731.c +++ b/drivers/led/issi/is31fl3731.c @@ -32,6 +32,9 @@ # define IS31FL3731_I2C_PERSISTENCE 0 #endif +#define IS31FL3731_PWM_REGISTERS_PER_CHUNK 16 +#define IS31FL3731_CHUNK_COUNT (IS31FL3731_PWM_REGISTER_COUNT / IS31FL3731_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { IS31FL3731_I2C_ADDRESS_1, #ifdef IS31FL3731_I2C_ADDRESS_2 @@ -51,15 +54,15 @@ const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { // buffers and the transfers in is31fl3731_write_pwm_buffer() but it's // probably not worth the extra complexity. typedef struct is31fl3731_driver_t { - uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; - uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT]; - bool led_control_buffer_dirty; + uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT]; + bool pwm_buffer_dirty[IS31FL3731_CHUNK_COUNT]; + uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT]; + bool led_control_buffer_dirty; } PACKED is31fl3731_driver_t; is31fl3731_driver_t driver_buffers[IS31FL3731_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, }}; @@ -83,13 +86,21 @@ void is31fl3731_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 9 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < IS31FL3731_PWM_REGISTER_COUNT; i += 16) { + for (uint8_t i = 0; i < IS31FL3731_CHUNK_COUNT; i ++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3731_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3731_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3731_I2C_PERSISTENCE; j++) { if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3731_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3731_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3731_PWM_REGISTERS_PER_CHUNK, IS31FL3731_I2C_TIMEOUT); #endif } } @@ -180,7 +191,11 @@ void is31fl3731_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.b] = blue; - driver_buffers[led.driver].pwm_buffer_dirty = true; + + // update the dirty bitfield for the PWM registers + driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3731_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3731_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3731_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -221,10 +236,13 @@ void is31fl3731_set_led_control_register(uint8_t index, bool red, bool green, bo } void is31fl3731_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3731_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3731_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3731_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3733.c b/drivers/led/issi/is31fl3733.c index a1d68991149..339a310a1f1 100644 --- a/drivers/led/issi/is31fl3733.c +++ b/drivers/led/issi/is31fl3733.c @@ -21,6 +21,7 @@ #include "i2c_master.h" #include "gpio.h" #include "wait.h" +#include "bit_array.h" #define IS31FL3733_PWM_REGISTER_COUNT 192 #define IS31FL3733_LED_CONTROL_REGISTER_COUNT 24 @@ -62,6 +63,9 @@ # define IS31FL3733_SYNC_4 IS31FL3733_SYNC_NONE #endif +#define IS31FL3733_PWM_REGISTERS_PER_CHUNK 16 +#define IS31FL3733_CHUNK_COUNT (IS31FL3733_PWM_REGISTER_COUNT / IS31FL3733_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3733_DRIVER_COUNT] = { IS31FL3733_I2C_ADDRESS_1, #ifdef IS31FL3733_I2C_ADDRESS_2 @@ -96,16 +100,17 @@ const uint8_t driver_sync[IS31FL3733_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct is31fl3733_driver_t { uint8_t pwm_buffer[IS31FL3733_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3733_CHUNK_COUNT]; uint8_t led_control_buffer[IS31FL3733_LED_CONTROL_REGISTER_COUNT]; bool led_control_buffer_dirty; } PACKED is31fl3733_driver_t; is31fl3733_driver_t driver_buffers[IS31FL3733_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, + .led_control_bitfield = {0}, }}; void is31fl3733_write_register(uint8_t index, uint8_t reg, uint8_t data) { @@ -128,13 +133,21 @@ void is31fl3733_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 12 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < IS31FL3733_PWM_REGISTER_COUNT; i += 16) { + for (uint8_t i = 0; i < IS31FL3733_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3733_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3733_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3733_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3733_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3733_PWM_REGISTERS_PER_CHUNK, IS31FL3733_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3733_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3733_PWM_REGISTERS_PER_CHUNK, IS31FL3733_I2C_TIMEOUT); #endif } } @@ -211,7 +224,10 @@ void is31fl3733_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.b] = blue; - driver_buffers[led.driver].pwm_buffer_dirty = true; + + driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3733_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3733_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3733_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -252,12 +268,14 @@ void is31fl3733_set_led_control_register(uint8_t index, bool red, bool green, bo } void is31fl3733_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3733_select_page(index, IS31FL3733_COMMAND_PWM); - - is31fl3733_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3733_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3733_select_page(index, IS31FL3733_COMMAND_PWM); + is31fl3733_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3741.c b/drivers/led/issi/is31fl3741.c index 3614d1c104c..ed51d9d442b 100644 --- a/drivers/led/issi/is31fl3741.c +++ b/drivers/led/issi/is31fl3741.c @@ -55,6 +55,11 @@ # define IS31FL3741_GLOBAL_CURRENT 0xFF #endif +#define IS31FL3741_PWM_0_REGISTERS_PER_CHUNK 30 +#define IS31FL3741_PWM_1_REGISTERS_PER_CHUNK 19 +#define IS31FL3741_PAGE_0_CHUNK_COUNT (IS31FL3741_PWM_0_REGISTER_COUNT / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK) +#define IS31FL3741_PAGE_1_CHUNK_COUNT (IS31FL3741_PWM_1_REGISTER_COUNT / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = { IS31FL3741_I2C_ADDRESS_1, #ifdef IS31FL3741_I2C_ADDRESS_2 @@ -77,19 +82,21 @@ const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = { typedef struct is31fl3741_driver_t { uint8_t pwm_buffer_0[IS31FL3741_PWM_0_REGISTER_COUNT]; uint8_t pwm_buffer_1[IS31FL3741_PWM_1_REGISTER_COUNT]; - bool pwm_buffer_dirty; uint8_t scaling_buffer_0[IS31FL3741_SCALING_0_REGISTER_COUNT]; uint8_t scaling_buffer_1[IS31FL3741_SCALING_1_REGISTER_COUNT]; bool scaling_buffer_dirty; + bool pwm_buffer_0_dirty[IS31FL3741_PAGE_0_CHUNK_COUNT]; + bool pwm_buffer_1_dirty[IS31FL3741_PAGE_1_CHUNK_COUNT]; } PACKED is31fl3741_driver_t; is31fl3741_driver_t driver_buffers[IS31FL3741_DRIVER_COUNT] = {{ .pwm_buffer_0 = {0}, .pwm_buffer_1 = {0}, - .pwm_buffer_dirty = false, .scaling_buffer_0 = {0}, .scaling_buffer_1 = {0}, .scaling_buffer_dirty = false, + .pwm_buffer_0_dirty = {0}, + .pwm_buffer_1_dirty = {0}, }}; void is31fl3741_write_register(uint8_t index, uint8_t reg, uint8_t data) { @@ -113,13 +120,21 @@ void is31fl3741_write_pwm_buffer(uint8_t index) { // Transmit PWM0 registers in 6 transfers of 30 bytes. // Iterate over the pwm_buffer_0 contents at 30 byte intervals. - for (uint8_t i = 0; i < IS31FL3741_PWM_0_REGISTER_COUNT; i += 30) { + for (uint8_t i = 0; i < IS31FL3741_PAGE_0_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_0_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_0_dirty[i] = false; + + uint8_t offset = i * IS31FL3741_PWM_0_REGISTERS_PER_CHUNK; + #if IS31FL3741_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3741_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + i, 30, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + offset, IS31FL3741_PWM_0_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + i, 30, IS31FL3741_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer_0 + offset, IS31FL3741_PWM_0_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT); #endif } @@ -128,13 +143,21 @@ void is31fl3741_write_pwm_buffer(uint8_t index) { // Transmit PWM1 registers in 9 transfers of 19 bytes. // Iterate over the pwm_buffer_1 contents at 19 byte intervals. - for (uint8_t i = 0; i < IS31FL3741_PWM_1_REGISTER_COUNT; i += 19) { + for (uint8_t i = 0; i < IS31FL3741_PAGE_1_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_1_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_1_dirty[i] = false; + + uint8_t offset = i * IS31FL3741_PWM_1_REGISTERS_PER_CHUNK; + #if IS31FL3741_I2C_PERSISTENCE > 0 for (uint8_t i = 0; i < IS31FL3741_I2C_PERSISTENCE; i++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + i, 19, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + offset, IS31FL3741_PWM_1_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + i, 19, IS31FL3741_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer_1 + offset, IS31FL3741_PWM_1_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT); #endif } } @@ -201,6 +224,14 @@ void set_pwm_value(uint8_t driver, uint16_t reg, uint8_t value) { } } +void dirty_bitfield_set_bit(uint8_t driver, uint16_t reg) { + if (reg & 0x100) { + driver_buffers[driver].pwm_buffer_1_dirty[(reg & 0xFF) / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK] = true; + } else { + driver_buffers[driver].pwm_buffer_0_dirty[reg / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK] = true; + } +} + void is31fl3741_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { is31fl3741_led_t led; @@ -214,7 +245,10 @@ void is31fl3741_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { set_pwm_value(led.driver, led.r, red); set_pwm_value(led.driver, led.g, green); set_pwm_value(led.driver, led.b, blue); - driver_buffers[led.driver].pwm_buffer_dirty = true; + + dirty_bitfield_set_bit(led.driver, led.r); + dirty_bitfield_set_bit(led.driver, led.g); + dirty_bitfield_set_bit(led.driver, led.b); } } @@ -244,10 +278,20 @@ void is31fl3741_set_led_control_register(uint8_t index, bool red, bool green, bo } void is31fl3741_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3741_write_pwm_buffer(index); + // Check if any of the PWM buffers are dirty. + for (uint8_t i = 0; i < IS31FL3741_PAGE_0_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_0_dirty[i]) { + is31fl3741_write_pwm_buffer(index); + // return since we update both pages at the same time + return; + } + } - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3741_PAGE_1_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_1_dirty[i]) { + is31fl3741_write_pwm_buffer(index); + return; + } } } @@ -255,7 +299,10 @@ void is31fl3741_set_pwm_buffer(const is31fl3741_led_t *pled, uint8_t red, uint8_ set_pwm_value(pled->driver, pled->r, red); set_pwm_value(pled->driver, pled->g, green); set_pwm_value(pled->driver, pled->b, blue); - driver_buffers[pled->driver].pwm_buffer_dirty = true; + + dirty_bitfield_set_bit(pled->driver, pled->r); + dirty_bitfield_set_bit(pled->driver, pled->g); + dirty_bitfield_set_bit(pled->driver, pled->b); } void is31fl3741_update_led_control_registers(uint8_t index) { From eba10a7f22f9865d45e8e2620faf9941e31381b2 Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Sun, 26 Jan 2025 11:55:57 +1100 Subject: [PATCH 03/12] update initial batch --- drivers/led/issi/is31fl3729-mono.c | 34 +++++++++++++++++++-------- drivers/led/issi/is31fl3729.c | 2 +- drivers/led/issi/is31fl3731-mono.c | 2 +- drivers/led/issi/is31fl3731.c | 2 +- drivers/led/issi/is31fl3733-mono.c | 37 ++++++++++++++++++++---------- 5 files changed, 52 insertions(+), 25 deletions(-) diff --git a/drivers/led/issi/is31fl3729-mono.c b/drivers/led/issi/is31fl3729-mono.c index 13d5146877f..884862b8a1c 100644 --- a/drivers/led/issi/is31fl3729-mono.c +++ b/drivers/led/issi/is31fl3729-mono.c @@ -64,6 +64,9 @@ # define IS31FL3729_PWM_FREQUENCY IS31FL3729_PWM_FREQUENCY_32K_HZ #endif +#define IS31FL3729_PWM_REGISTERS_PER_CHUNK 13 +#define IS31FL3729_CHUNK_COUNT (IS31FL3729_PWM_REGISTER_COUNT / IS31FL3729_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = { IS31FL3729_I2C_ADDRESS_1, #ifdef IS31FL3729_I2C_ADDRESS_2 @@ -81,14 +84,14 @@ const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = { // Storing them like this is optimal for I2C transfers to the registers. typedef struct is31fl3729_driver_t { uint8_t pwm_buffer[IS31FL3729_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3729_CHUNK_COUNT]; uint8_t scaling_buffer[IS31FL3729_SCALING_REGISTER_COUNT]; bool scaling_buffer_dirty; } PACKED is31fl3729_driver_t; is31fl3729_driver_t driver_buffers[IS31FL3729_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .scaling_buffer_dirty = false, }}; @@ -107,13 +110,21 @@ void is31fl3729_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 11 transfers of 13 bytes. // Iterate over the pwm_buffer contents at 13 byte intervals. - for (uint8_t i = 0; i <= IS31FL3729_PWM_REGISTER_COUNT; i += 13) { + for (uint8_t i = 0; i <= IS31FL3729_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3729_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3729_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3729_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 13, IS31FL3729_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3729_PWM_REGISTERS_PER_CHUNK, IS31FL3729_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 13, IS31FL3729_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3729_PWM_REGISTERS_PER_CHUNK, IS31FL3729_I2C_TIMEOUT); #endif } } @@ -165,7 +176,7 @@ void is31fl3729_set_value(int index, uint8_t value) { } driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3729_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -189,10 +200,13 @@ void is31fl3729_set_scaling_register(uint8_t index, uint8_t value) { } void is31fl3729_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3729_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3729_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3729_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3729.c b/drivers/led/issi/is31fl3729.c index 79005686ddc..af9f49958c5 100644 --- a/drivers/led/issi/is31fl3729.c +++ b/drivers/led/issi/is31fl3729.c @@ -121,7 +121,7 @@ void is31fl3729_write_pwm_buffer(uint8_t index) { #if IS31FL3729_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3729_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 13, IS31FL3729_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3729_PWM_REGISTERS_PER_CHUNK, IS31FL3729_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3729_PWM_REGISTERS_PER_CHUNK, IS31FL3729_I2C_TIMEOUT); diff --git a/drivers/led/issi/is31fl3731-mono.c b/drivers/led/issi/is31fl3731-mono.c index 077fc16ce87..30d6bd8f960 100644 --- a/drivers/led/issi/is31fl3731-mono.c +++ b/drivers/led/issi/is31fl3731-mono.c @@ -98,7 +98,7 @@ void is31fl3731_write_pwm_buffer(uint8_t index) { #if IS31FL3731_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3731_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3731_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3731_PWM_REGISTERS_PER_CHUNK, IS31FL3731_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3731_PWM_REGISTERS_PER_CHUNK, IS31FL3731_I2C_TIMEOUT); diff --git a/drivers/led/issi/is31fl3731.c b/drivers/led/issi/is31fl3731.c index 6ea50cac74a..af56dd92e41 100644 --- a/drivers/led/issi/is31fl3731.c +++ b/drivers/led/issi/is31fl3731.c @@ -97,7 +97,7 @@ void is31fl3731_write_pwm_buffer(uint8_t index) { #if IS31FL3731_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3731_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3731_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3731_PWM_REGISTERS_PER_CHUNK, IS31FL3731_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else i2c_write_register(i2c_addresses[index] << 1, IS31FL3731_FRAME_REG_PWM + offset, driver_buffers[index].pwm_buffer + offset, IS31FL3731_PWM_REGISTERS_PER_CHUNK, IS31FL3731_I2C_TIMEOUT); diff --git a/drivers/led/issi/is31fl3733-mono.c b/drivers/led/issi/is31fl3733-mono.c index 740fe060970..bf3e1103783 100644 --- a/drivers/led/issi/is31fl3733-mono.c +++ b/drivers/led/issi/is31fl3733-mono.c @@ -63,6 +63,9 @@ # define IS31FL3733_SYNC_4 IS31FL3733_SYNC_NONE #endif +#define IS31FL3733_PWM_REGISTERS_PER_CHUNK 16 +#define IS31FL3733_CHUNK_COUNT (IS31FL3733_PWM_REGISTER_COUNT / IS31FL3733_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3733_DRIVER_COUNT] = { IS31FL3733_I2C_ADDRESS_1, #ifdef IS31FL3733_I2C_ADDRESS_2 @@ -97,14 +100,14 @@ const uint8_t driver_sync[IS31FL3733_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct is31fl3733_driver_t { uint8_t pwm_buffer[IS31FL3733_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3733_CHUNK_COUNT]; uint8_t led_control_buffer[IS31FL3733_LED_CONTROL_REGISTER_COUNT]; bool led_control_buffer_dirty; } PACKED is31fl3733_driver_t; is31fl3733_driver_t driver_buffers[IS31FL3733_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, }}; @@ -129,13 +132,21 @@ void is31fl3733_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 12 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < IS31FL3733_PWM_REGISTER_COUNT; i += 16) { + for (uint8_t i = 0; i < IS31FL3733_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3733_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3733_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3733_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3733_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3733_PWM_REGISTERS_PER_CHUNK, IS31FL3733_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3733_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3733_PWM_REGISTERS_PER_CHUNK, IS31FL3733_I2C_TIMEOUT); #endif } } @@ -210,7 +221,7 @@ void is31fl3733_set_value(int index, uint8_t value) { } driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3733_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -237,12 +248,14 @@ void is31fl3733_set_led_control_register(uint8_t index, bool value) { } void is31fl3733_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3733_select_page(index, IS31FL3733_COMMAND_PWM); - - is31fl3733_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3733_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3733_select_page(index, IS31FL3733_COMMAND_PWM); + is31fl3733_write_pwm_buffer(index); + return; + } } } From 8d23dd4270438140b2c4ea1b63c787237a293db1 Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Sun, 26 Jan 2025 12:36:24 +1100 Subject: [PATCH 04/12] all led drivers --- drivers/led/apa102.c | 3 + drivers/led/issi/is31fl3729-mono.c | 2 +- drivers/led/issi/is31fl3731.c | 10 ++-- drivers/led/issi/is31fl3733-mono.c | 2 +- drivers/led/issi/is31fl3736-mono.c | 39 ++++++++----- drivers/led/issi/is31fl3736.c | 45 ++++++++++----- drivers/led/issi/is31fl3737-mono.c | 37 ++++++++---- drivers/led/issi/is31fl3737.c | 40 +++++++++---- drivers/led/issi/is31fl3741-mono.c | 65 ++++++++++++++++++---- drivers/led/issi/is31fl3741.c | 8 +-- drivers/led/issi/is31fl3742a-mono.c | 39 ++++++++----- drivers/led/issi/is31fl3742a.c | 45 ++++++++++----- drivers/led/issi/is31fl3743a-mono.c | 39 ++++++++----- drivers/led/issi/is31fl3743a.c | 45 ++++++++++----- drivers/led/issi/is31fl3745-mono.c | 39 ++++++++----- drivers/led/issi/is31fl3745.c | 45 ++++++++++----- drivers/led/issi/is31fl3746a-mono.c | 39 ++++++++----- drivers/led/issi/is31fl3746a.c | 45 ++++++++++----- drivers/led/snled27351-mono.c | 39 ++++++++----- drivers/led/snled27351.c | 45 ++++++++++----- platforms/avr/drivers/ws2812_bitbang.c | 3 +- platforms/avr/drivers/ws2812_i2c.c | 1 + platforms/chibios/drivers/ws2812_bitbang.c | 1 + platforms/chibios/drivers/ws2812_pwm.c | 8 ++- platforms/chibios/drivers/ws2812_spi.c | 4 +- 25 files changed, 469 insertions(+), 219 deletions(-) diff --git a/drivers/led/apa102.c b/drivers/led/apa102.c index 6a131533743..c7bfc65b709 100644 --- a/drivers/led/apa102.c +++ b/drivers/led/apa102.c @@ -55,6 +55,7 @@ rgb_t apa102_leds[APA102_LED_COUNT]; uint8_t apa102_led_brightness = APA102_DEFAULT_BRIGHTNESS; +bool apa102_dirty = false; static void apa102_send_byte(uint8_t byte) { APA102_SEND_BIT(byte, 7); @@ -126,6 +127,7 @@ void apa102_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { apa102_leds[index].r = red; apa102_leds[index].g = green; apa102_leds[index].b = blue; + apa102_dirty = true; } void apa102_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { @@ -135,6 +137,7 @@ void apa102_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { } void apa102_flush(void) { + if (!apa102_dirty) return; apa102_start_frame(); for (uint8_t i = 0; i < APA102_LED_COUNT; i++) { apa102_send_frame(apa102_leds[i].r, apa102_leds[i].g, apa102_leds[i].b, apa102_led_brightness); diff --git a/drivers/led/issi/is31fl3729-mono.c b/drivers/led/issi/is31fl3729-mono.c index 884862b8a1c..a6d8adf04da 100644 --- a/drivers/led/issi/is31fl3729-mono.c +++ b/drivers/led/issi/is31fl3729-mono.c @@ -175,7 +175,7 @@ void is31fl3729_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; + driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3729_PWM_REGISTERS_PER_CHUNK] = true; } } diff --git a/drivers/led/issi/is31fl3731.c b/drivers/led/issi/is31fl3731.c index af56dd92e41..ca6174df8ea 100644 --- a/drivers/led/issi/is31fl3731.c +++ b/drivers/led/issi/is31fl3731.c @@ -54,10 +54,10 @@ const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { // buffers and the transfers in is31fl3731_write_pwm_buffer() but it's // probably not worth the extra complexity. typedef struct is31fl3731_driver_t { - uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty[IS31FL3731_CHUNK_COUNT]; - uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT]; - bool led_control_buffer_dirty; + uint8_t pwm_buffer[IS31FL3731_PWM_REGISTER_COUNT]; + bool pwm_buffer_dirty[IS31FL3731_CHUNK_COUNT]; + uint8_t led_control_buffer[IS31FL3731_LED_CONTROL_REGISTER_COUNT]; + bool led_control_buffer_dirty; } PACKED is31fl3731_driver_t; is31fl3731_driver_t driver_buffers[IS31FL3731_DRIVER_COUNT] = {{ @@ -86,7 +86,7 @@ void is31fl3731_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 9 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < IS31FL3731_CHUNK_COUNT; i ++) { + for (uint8_t i = 0; i < IS31FL3731_CHUNK_COUNT; i++) { if (!driver_buffers[index].pwm_buffer_dirty[i]) { continue; } diff --git a/drivers/led/issi/is31fl3733-mono.c b/drivers/led/issi/is31fl3733-mono.c index bf3e1103783..5ace321a5a6 100644 --- a/drivers/led/issi/is31fl3733-mono.c +++ b/drivers/led/issi/is31fl3733-mono.c @@ -220,7 +220,7 @@ void is31fl3733_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; + driver_buffers[led.driver].pwm_buffer[led.v] = value; driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3733_PWM_REGISTERS_PER_CHUNK] = true; } } diff --git a/drivers/led/issi/is31fl3736-mono.c b/drivers/led/issi/is31fl3736-mono.c index 7a5415c7259..a4192e7dc19 100644 --- a/drivers/led/issi/is31fl3736-mono.c +++ b/drivers/led/issi/is31fl3736-mono.c @@ -47,6 +47,9 @@ # define IS31FL3736_GLOBAL_CURRENT 0xFF #endif +#define IS31FL3736_PWM_REGISTERS_PER_CHUNK 16 +#define IS31FL3736_CHUNK_COUNT (IS31FL3736_PWM_REGISTER_COUNT / IS31FL3736_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = { IS31FL3736_I2C_ADDRESS_1, #ifdef IS31FL3736_I2C_ADDRESS_2 @@ -68,14 +71,14 @@ const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct is31fl3736_driver_t { uint8_t pwm_buffer[IS31FL3736_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3736_CHUNK_COUNT]; uint8_t led_control_buffer[IS31FL3736_LED_CONTROL_REGISTER_COUNT]; bool led_control_buffer_dirty; } PACKED is31fl3736_driver_t; is31fl3736_driver_t driver_buffers[IS31FL3736_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, }}; @@ -100,13 +103,21 @@ void is31fl3736_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 12 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < IS31FL3736_PWM_REGISTER_COUNT; i += 16) { + for (uint8_t i = 0; i < IS31FL3736_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3736_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3736_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3736_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3736_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3736_PWM_REGISTERS_PER_CHUNK, IS31FL3736_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3736_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3736_PWM_REGISTERS_PER_CHUNK, IS31FL3736_I2C_TIMEOUT); #endif } } @@ -178,8 +189,8 @@ void is31fl3736_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.v] = value; + driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3736_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -212,12 +223,14 @@ void is31fl3736_set_led_control_register(uint8_t index, bool value) { } void is31fl3736_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3736_select_page(index, IS31FL3736_COMMAND_PWM); - - is31fl3736_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3736_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3736_select_page(index, IS31FL3736_COMMAND_PWM); + is31fl3736_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3736.c b/drivers/led/issi/is31fl3736.c index 3ab42e2f7c3..044eab17750 100644 --- a/drivers/led/issi/is31fl3736.c +++ b/drivers/led/issi/is31fl3736.c @@ -47,6 +47,9 @@ # define IS31FL3736_GLOBAL_CURRENT 0xFF #endif +#define IS31FL3736_PWM_REGISTERS_PER_CHUNK 16 +#define IS31FL3736_CHUNK_COUNT (IS31FL3736_PWM_REGISTER_COUNT / IS31FL3736_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = { IS31FL3736_I2C_ADDRESS_1, #ifdef IS31FL3736_I2C_ADDRESS_2 @@ -68,14 +71,14 @@ const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct is31fl3736_driver_t { uint8_t pwm_buffer[IS31FL3736_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3736_CHUNK_COUNT]; uint8_t led_control_buffer[IS31FL3736_LED_CONTROL_REGISTER_COUNT]; bool led_control_buffer_dirty; } PACKED is31fl3736_driver_t; is31fl3736_driver_t driver_buffers[IS31FL3736_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, }}; @@ -100,13 +103,21 @@ void is31fl3736_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 12 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < IS31FL3736_PWM_REGISTER_COUNT; i += 16) { + for (uint8_t i = 0; i < IS31FL3736_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3736_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3736_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3736_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3736_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3736_PWM_REGISTERS_PER_CHUNK, IS31FL3736_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3736_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3736_PWM_REGISTERS_PER_CHUNK, IS31FL3736_I2C_TIMEOUT); #endif } } @@ -178,10 +189,12 @@ void is31fl3736_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { return; } - driver_buffers[led.driver].pwm_buffer[led.r] = red; - driver_buffers[led.driver].pwm_buffer[led.g] = green; - driver_buffers[led.driver].pwm_buffer[led.b] = blue; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.r] = red; + driver_buffers[led.driver].pwm_buffer[led.g] = green; + driver_buffers[led.driver].pwm_buffer[led.b] = blue; + driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3736_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3736_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3736_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -229,12 +242,14 @@ void is31fl3736_set_led_control_register(uint8_t index, bool red, bool green, bo } void is31fl3736_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3736_select_page(index, IS31FL3736_COMMAND_PWM); - - is31fl3736_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3736_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3736_select_page(index, IS31FL3736_COMMAND_PWM); + is31fl3736_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3737-mono.c b/drivers/led/issi/is31fl3737-mono.c index 7b2e5a35763..8f4e68d1aee 100644 --- a/drivers/led/issi/is31fl3737-mono.c +++ b/drivers/led/issi/is31fl3737-mono.c @@ -49,6 +49,9 @@ # define IS31FL3737_GLOBAL_CURRENT 0xFF #endif +#define IS31FL3737_PWM_REGISTERS_PER_CHUNK 16 +#define IS31FL3737_CHUNK_COUNT (IS31FL3737_PWM_REGISTER_COUNT / IS31FL3737_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = { IS31FL3737_I2C_ADDRESS_1, #ifdef IS31FL3737_I2C_ADDRESS_2 @@ -70,7 +73,7 @@ const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct is31fl3737_driver_t { uint8_t pwm_buffer[IS31FL3737_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3737_CHUNK_COUNT]; uint8_t led_control_buffer[IS31FL3737_LED_CONTROL_REGISTER_COUNT]; bool led_control_buffer_dirty; } PACKED is31fl3737_driver_t; @@ -102,13 +105,21 @@ void is31fl3737_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 12 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < IS31FL3737_PWM_REGISTER_COUNT; i += 16) { + for (uint8_t i = 0; i < IS31FL3737_CHUNK_COUNT; i += 16) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3737_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3737_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3737_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3737_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3737_PWM_REGISTERS_PER_CHUNK, IS31FL3737_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3737_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3737_PWM_REGISTERS_PER_CHUNK, IS31FL3737_I2C_TIMEOUT); #endif } } @@ -180,8 +191,8 @@ void is31fl3737_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.v] = value; + driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3737_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -208,12 +219,14 @@ void is31fl3737_set_led_control_register(uint8_t index, bool value) { } void is31fl3737_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3737_select_page(index, IS31FL3737_COMMAND_PWM); - - is31fl3737_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3737_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3737_select_page(index, IS31FL3737_COMMAND_PWM); + is31fl3737_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3737.c b/drivers/led/issi/is31fl3737.c index b27a4cbb0f2..7ce56d41e99 100644 --- a/drivers/led/issi/is31fl3737.c +++ b/drivers/led/issi/is31fl3737.c @@ -49,6 +49,9 @@ # define IS31FL3737_GLOBAL_CURRENT 0xFF #endif +#define IS31FL3737_PWM_REGISTERS_PER_CHUNK 16 +#define IS31FL3737_CHUNK_COUNT (IS31FL3737_PWM_REGISTER_COUNT / IS31FL3737_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = { IS31FL3737_I2C_ADDRESS_1, #ifdef IS31FL3737_I2C_ADDRESS_2 @@ -70,14 +73,14 @@ const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct is31fl3737_driver_t { uint8_t pwm_buffer[IS31FL3737_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3737_CHUNK_COUNT]; uint8_t led_control_buffer[IS31FL3737_LED_CONTROL_REGISTER_COUNT]; bool led_control_buffer_dirty; } PACKED is31fl3737_driver_t; is31fl3737_driver_t driver_buffers[IS31FL3737_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, }}; @@ -102,13 +105,21 @@ void is31fl3737_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 12 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < IS31FL3737_PWM_REGISTER_COUNT; i += 16) { + for (uint8_t i = 0; i < IS31FL3737_CHUNK_COUNT; i += 16) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3737_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3737_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3737_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3737_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3737_PWM_REGISTERS_PER_CHUNK, IS31FL3737_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3737_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3737_PWM_REGISTERS_PER_CHUNK, IS31FL3737_I2C_TIMEOUT); #endif } } @@ -183,7 +194,10 @@ void is31fl3737_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { driver_buffers[led.driver].pwm_buffer[led.r] = red; driver_buffers[led.driver].pwm_buffer[led.g] = green; driver_buffers[led.driver].pwm_buffer[led.b] = blue; - driver_buffers[led.driver].pwm_buffer_dirty = true; + + driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3737_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3737_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3737_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -224,12 +238,14 @@ void is31fl3737_set_led_control_register(uint8_t index, bool red, bool green, bo } void is31fl3737_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3737_select_page(index, IS31FL3737_COMMAND_PWM); - - is31fl3737_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3737_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3737_select_page(index, IS31FL3737_COMMAND_PWM); + is31fl3737_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3741-mono.c b/drivers/led/issi/is31fl3741-mono.c index dbccba0fc8d..92d2e63dbc0 100644 --- a/drivers/led/issi/is31fl3741-mono.c +++ b/drivers/led/issi/is31fl3741-mono.c @@ -55,6 +55,11 @@ # define IS31FL3741_GLOBAL_CURRENT 0xFF #endif +#define IS31FL3741_PWM_0_REGISTERS_PER_CHUNK 30 +#define IS31FL3741_PWM_1_REGISTERS_PER_CHUNK 19 +#define IS31FL3741_PAGE_0_CHUNK_COUNT (IS31FL3741_PWM_0_REGISTER_COUNT / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK) +#define IS31FL3741_PAGE_1_CHUNK_COUNT (IS31FL3741_PWM_1_REGISTER_COUNT / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = { IS31FL3741_I2C_ADDRESS_1, #ifdef IS31FL3741_I2C_ADDRESS_2 @@ -77,19 +82,21 @@ const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = { typedef struct is31fl3741_driver_t { uint8_t pwm_buffer_0[IS31FL3741_PWM_0_REGISTER_COUNT]; uint8_t pwm_buffer_1[IS31FL3741_PWM_1_REGISTER_COUNT]; - bool pwm_buffer_dirty; uint8_t scaling_buffer_0[IS31FL3741_SCALING_0_REGISTER_COUNT]; uint8_t scaling_buffer_1[IS31FL3741_SCALING_1_REGISTER_COUNT]; bool scaling_buffer_dirty; + bool pwm_buffer_0_dirty[IS31FL3741_PAGE_0_CHUNK_COUNT]; + bool pwm_buffer_1_dirty[IS31FL3741_PAGE_1_CHUNK_COUNT]; } PACKED is31fl3741_driver_t; is31fl3741_driver_t driver_buffers[IS31FL3741_DRIVER_COUNT] = {{ .pwm_buffer_0 = {0}, .pwm_buffer_1 = {0}, - .pwm_buffer_dirty = false, .scaling_buffer_0 = {0}, .scaling_buffer_1 = {0}, .scaling_buffer_dirty = false, + .pwm_buffer_0_dirty = {0}, + .pwm_buffer_1_dirty = {0}, }}; void is31fl3741_write_register(uint8_t index, uint8_t reg, uint8_t data) { @@ -113,13 +120,21 @@ void is31fl3741_write_pwm_buffer(uint8_t index) { // Transmit PWM0 registers in 6 transfers of 30 bytes. // Iterate over the pwm_buffer_0 contents at 30 byte intervals. - for (uint8_t i = 0; i < IS31FL3741_PWM_0_REGISTER_COUNT; i += 30) { + for (uint8_t i = 0; i < IS31FL3741_PAGE_0_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_0_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_0_dirty[i] = false; + + uint8_t offset = i * IS31FL3741_PWM_0_REGISTERS_PER_CHUNK; + #if IS31FL3741_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3741_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + i, 30, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + offset, IS31FL3741_PWM_0_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_0 + i, 30, IS31FL3741_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer_0 + offset, IS31FL3741_PWM_0_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT); #endif } @@ -128,13 +143,21 @@ void is31fl3741_write_pwm_buffer(uint8_t index) { // Transmit PWM1 registers in 9 transfers of 19 bytes. // Iterate over the pwm_buffer_1 contents at 19 byte intervals. - for (uint8_t i = 0; i < IS31FL3741_PWM_1_REGISTER_COUNT; i += 19) { + for (uint8_t i = 0; i < IS31FL3741_PAGE_1_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_1_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_1_dirty[i] = false; + + uint8_t offset = i * IS31FL3741_PWM_1_REGISTERS_PER_CHUNK; + #if IS31FL3741_I2C_PERSISTENCE > 0 for (uint8_t i = 0; i < IS31FL3741_I2C_PERSISTENCE; i++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + i, 19, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + offset, IS31FL3741_PWM_1_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer_1 + i, 19, IS31FL3741_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer_1 + offset, IS31FL3741_PWM_1_REGISTERS_PER_CHUNK, IS31FL3741_I2C_TIMEOUT); #endif } } @@ -201,6 +224,14 @@ void set_pwm_value(uint8_t driver, uint16_t reg, uint8_t value) { } } +void dirty_bitfield_set(uint8_t driver, uint16_t reg) { + if (reg & 0x100) { + driver_buffers[driver].pwm_buffer_1_dirty[(reg & 0xFF) / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK] = true; + } else { + driver_buffers[driver].pwm_buffer_0_dirty[reg / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK] = true; + } +} + void is31fl3741_set_value(int index, uint8_t value) { is31fl3741_led_t led; @@ -212,7 +243,7 @@ void is31fl3741_set_value(int index, uint8_t value) { } set_pwm_value(led.driver, led.v, value); - driver_buffers[led.driver].pwm_buffer_dirty = true; + dirty_bitfield_set(led.driver, led.v); } } @@ -240,10 +271,20 @@ void is31fl3741_set_led_control_register(uint8_t index, bool value) { } void is31fl3741_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3741_write_pwm_buffer(index); + // Check if any of the PWM buffers are dirty. + for (uint8_t i = 0; i < IS31FL3741_PAGE_0_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_0_dirty[i]) { + is31fl3741_write_pwm_buffer(index); + // return since we update both pages at the same time + return; + } + } - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3741_PAGE_1_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_1_dirty[i]) { + is31fl3741_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3741.c b/drivers/led/issi/is31fl3741.c index ed51d9d442b..5e6cf8e1ad7 100644 --- a/drivers/led/issi/is31fl3741.c +++ b/drivers/led/issi/is31fl3741.c @@ -224,7 +224,7 @@ void set_pwm_value(uint8_t driver, uint16_t reg, uint8_t value) { } } -void dirty_bitfield_set_bit(uint8_t driver, uint16_t reg) { +void dirty_bitfield_set(uint8_t driver, uint16_t reg) { if (reg & 0x100) { driver_buffers[driver].pwm_buffer_1_dirty[(reg & 0xFF) / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK] = true; } else { @@ -246,9 +246,9 @@ void is31fl3741_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { set_pwm_value(led.driver, led.g, green); set_pwm_value(led.driver, led.b, blue); - dirty_bitfield_set_bit(led.driver, led.r); - dirty_bitfield_set_bit(led.driver, led.g); - dirty_bitfield_set_bit(led.driver, led.b); + dirty_bitfield_set(led.driver, led.r); + dirty_bitfield_set(led.driver, led.g); + dirty_bitfield_set(led.driver, led.b); } } diff --git a/drivers/led/issi/is31fl3742a-mono.c b/drivers/led/issi/is31fl3742a-mono.c index c63db1a7fc9..844daa81f6b 100644 --- a/drivers/led/issi/is31fl3742a-mono.c +++ b/drivers/led/issi/is31fl3742a-mono.c @@ -54,6 +54,9 @@ # define IS31FL3742A_GLOBAL_CURRENT 0xFF #endif +#define IS31FL3742A_PWM_REGISTERS_PER_CHUNK 30 +#define IS31FL3742A_CHUNK_COUNT (IS31FL3742A_PWM_REGISTER_COUNT / IS31FL3742A_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = { IS31FL3742A_I2C_ADDRESS_1, #ifdef IS31FL3742A_I2C_ADDRESS_2 @@ -69,14 +72,14 @@ const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = { typedef struct is31fl3742a_driver_t { uint8_t pwm_buffer[IS31FL3742A_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3742A_CHUNK_COUNT]; uint8_t scaling_buffer[IS31FL3742A_SCALING_REGISTER_COUNT]; bool scaling_buffer_dirty; } PACKED is31fl3742a_driver_t; is31fl3742a_driver_t driver_buffers[IS31FL3742A_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .scaling_buffer_dirty = false, }}; @@ -101,13 +104,21 @@ void is31fl3742a_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 6 transfers of 30 bytes. // Iterate over the pwm_buffer contents at 30 byte intervals. - for (uint8_t i = 0; i < IS31FL3742A_PWM_REGISTER_COUNT; i += 30) { + for (uint8_t i = 0; i < IS31FL3742A_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3742A_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3742A_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3742A_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 30, IS31FL3742A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3742A_PWM_REGISTERS_PER_CHUNK, IS31FL3742A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 30, IS31FL3742A_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3742A_PWM_REGISTERS_PER_CHUNK, IS31FL3742A_I2C_TIMEOUT); #endif } } @@ -173,8 +184,8 @@ void is31fl3742a_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.v] = value; + driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3742A_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -193,12 +204,14 @@ void is31fl3742a_set_scaling_register(uint8_t index, uint8_t value) { } void is31fl3742a_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3742a_select_page(index, IS31FL3742A_COMMAND_PWM); - - is31fl3742a_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3742A_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3742a_select_page(index, IS31FL3742A_COMMAND_PWM); + is31fl3742a_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3742a.c b/drivers/led/issi/is31fl3742a.c index b8e9a587590..d9879df7a64 100644 --- a/drivers/led/issi/is31fl3742a.c +++ b/drivers/led/issi/is31fl3742a.c @@ -54,6 +54,9 @@ # define IS31FL3742A_GLOBAL_CURRENT 0xFF #endif +#define IS31FL3742A_PWM_REGISTERS_PER_CHUNK 30 +#define IS31FL3742A_CHUNK_COUNT (IS31FL3742A_PWM_REGISTER_COUNT / IS31FL3742A_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = { IS31FL3742A_I2C_ADDRESS_1, #ifdef IS31FL3742A_I2C_ADDRESS_2 @@ -69,14 +72,14 @@ const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = { typedef struct is31fl3742a_driver_t { uint8_t pwm_buffer[IS31FL3742A_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3742A_CHUNK_COUNT]; uint8_t scaling_buffer[IS31FL3742A_SCALING_REGISTER_COUNT]; bool scaling_buffer_dirty; } PACKED is31fl3742a_driver_t; is31fl3742a_driver_t driver_buffers[IS31FL3742A_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .scaling_buffer_dirty = false, }}; @@ -101,13 +104,21 @@ void is31fl3742a_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 6 transfers of 30 bytes. // Iterate over the pwm_buffer contents at 30 byte intervals. - for (uint8_t i = 0; i < IS31FL3742A_PWM_REGISTER_COUNT; i += 30) { + for (uint8_t i = 0; i < IS31FL3742A_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3742A_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3742A_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3742A_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 30, IS31FL3742A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3742A_PWM_REGISTERS_PER_CHUNK, IS31FL3742A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 30, IS31FL3742A_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, IS31FL3742A_PWM_REGISTERS_PER_CHUNK, IS31FL3742A_I2C_TIMEOUT); #endif } } @@ -173,10 +184,12 @@ void is31fl3742a_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) return; } - driver_buffers[led.driver].pwm_buffer[led.r] = red; - driver_buffers[led.driver].pwm_buffer[led.g] = green; - driver_buffers[led.driver].pwm_buffer[led.b] = blue; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.r] = red; + driver_buffers[led.driver].pwm_buffer[led.g] = green; + driver_buffers[led.driver].pwm_buffer[led.b] = blue; + driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3742A_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3742A_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3742A_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -197,12 +210,14 @@ void is31fl3742a_set_scaling_register(uint8_t index, uint8_t red, uint8_t green, } void is31fl3742a_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3742a_select_page(index, IS31FL3742A_COMMAND_PWM); - - is31fl3742a_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3742A_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3742a_select_page(index, IS31FL3742A_COMMAND_PWM); + is31fl3742a_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3743a-mono.c b/drivers/led/issi/is31fl3743a-mono.c index 6413dbef04a..3840f21fc3f 100644 --- a/drivers/led/issi/is31fl3743a-mono.c +++ b/drivers/led/issi/is31fl3743a-mono.c @@ -63,6 +63,9 @@ # define IS31FL3743A_SYNC_4 IS31FL3743A_SYNC_NONE #endif +#define IS31FL3743A_PWM_REGISTERS_PER_CHUNK 18 +#define IS31FL3743A_CHUNK_COUNT (IS31FL3743A_PWM_REGISTER_COUNT / IS31FL3743A_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3743A_DRIVER_COUNT] = { IS31FL3743A_I2C_ADDRESS_1, #ifdef IS31FL3743A_I2C_ADDRESS_2 @@ -91,14 +94,14 @@ const uint8_t driver_sync[IS31FL3743A_DRIVER_COUNT] = { typedef struct is31fl3743a_driver_t { uint8_t pwm_buffer[IS31FL3743A_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3743A_CHUNK_COUNT]; uint8_t scaling_buffer[IS31FL3743A_SCALING_REGISTER_COUNT]; bool scaling_buffer_dirty; } PACKED is31fl3743a_driver_t; is31fl3743a_driver_t driver_buffers[IS31FL3743A_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .scaling_buffer_dirty = false, }}; @@ -123,13 +126,21 @@ void is31fl3743a_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 11 transfers of 18 bytes. // Iterate over the pwm_buffer contents at 18 byte intervals. - for (uint8_t i = 0; i < IS31FL3743A_PWM_REGISTER_COUNT; i += 18) { + for (uint8_t i = 0; i < IS31FL3743A_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3743A_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3743A_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3743A_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3743A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3743A_PWM_REGISTERS_PER_CHUNK, IS31FL3743A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3743A_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3743A_PWM_REGISTERS_PER_CHUNK, IS31FL3743A_I2C_TIMEOUT); #endif } } @@ -197,8 +208,8 @@ void is31fl3743a_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.v] = value; + driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3743A_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -217,12 +228,14 @@ void is31fl3743a_set_scaling_register(uint8_t index, uint8_t value) { } void is31fl3743a_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3743a_select_page(index, IS31FL3743A_COMMAND_PWM); - - is31fl3743a_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3743A_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3743a_select_page(index, IS31FL3743A_COMMAND_PWM); + is31fl3743a_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3743a.c b/drivers/led/issi/is31fl3743a.c index 6f13925f27a..a59d371df60 100644 --- a/drivers/led/issi/is31fl3743a.c +++ b/drivers/led/issi/is31fl3743a.c @@ -63,6 +63,9 @@ # define IS31FL3743A_SYNC_4 IS31FL3743A_SYNC_NONE #endif +#define IS31FL3743A_PWM_REGISTERS_PER_CHUNK 18 +#define IS31FL3743A_CHUNK_COUNT (IS31FL3743A_PWM_REGISTER_COUNT / IS31FL3743A_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3743A_DRIVER_COUNT] = { IS31FL3743A_I2C_ADDRESS_1, #ifdef IS31FL3743A_I2C_ADDRESS_2 @@ -91,14 +94,14 @@ const uint8_t driver_sync[IS31FL3743A_DRIVER_COUNT] = { typedef struct is31fl3743a_driver_t { uint8_t pwm_buffer[IS31FL3743A_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3743A_CHUNK_COUNT]; uint8_t scaling_buffer[IS31FL3743A_SCALING_REGISTER_COUNT]; bool scaling_buffer_dirty; } PACKED is31fl3743a_driver_t; is31fl3743a_driver_t driver_buffers[IS31FL3743A_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .scaling_buffer_dirty = false, }}; @@ -123,13 +126,21 @@ void is31fl3743a_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 11 transfers of 18 bytes. // Iterate over the pwm_buffer contents at 18 byte intervals. - for (uint8_t i = 0; i < IS31FL3743A_PWM_REGISTER_COUNT; i += 18) { + for (uint8_t i = 0; i < IS31FL3743A_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3743A_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3743A_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3743A_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3743A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3743A_PWM_REGISTERS_PER_CHUNK, IS31FL3743A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3743A_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3743A_PWM_REGISTERS_PER_CHUNK, IS31FL3743A_I2C_TIMEOUT); #endif } } @@ -197,10 +208,12 @@ void is31fl3743a_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) return; } - driver_buffers[led.driver].pwm_buffer[led.r] = red; - driver_buffers[led.driver].pwm_buffer[led.g] = green; - driver_buffers[led.driver].pwm_buffer[led.b] = blue; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.r] = red; + driver_buffers[led.driver].pwm_buffer[led.g] = green; + driver_buffers[led.driver].pwm_buffer[led.b] = blue; + driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3743A_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3743A_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3743A_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -221,12 +234,14 @@ void is31fl3743a_set_scaling_register(uint8_t index, uint8_t red, uint8_t green, } void is31fl3743a_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3743a_select_page(index, IS31FL3743A_COMMAND_PWM); - - is31fl3743a_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3743A_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3743a_select_page(index, IS31FL3743A_COMMAND_PWM); + is31fl3743a_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3745-mono.c b/drivers/led/issi/is31fl3745-mono.c index a6ab6992457..76c760c8833 100644 --- a/drivers/led/issi/is31fl3745-mono.c +++ b/drivers/led/issi/is31fl3745-mono.c @@ -63,6 +63,9 @@ # define IS31FL3745_SYNC_4 IS31FL3745_SYNC_NONE #endif +#define IS31FL3745_PWM_REGISTERS_PER_CHUNK 18 +#define IS31FL3745_CHUNK_COUNT (IS31FL3745_PWM_REGISTER_COUNT / IS31FL3745_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3745_DRIVER_COUNT] = { IS31FL3745_I2C_ADDRESS_1, #ifdef IS31FL3745_I2C_ADDRESS_2 @@ -91,14 +94,14 @@ const uint8_t driver_sync[IS31FL3745_DRIVER_COUNT] = { typedef struct is31fl3745_driver_t { uint8_t pwm_buffer[IS31FL3745_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3745_CHUNK_COUNT]; uint8_t scaling_buffer[IS31FL3745_SCALING_REGISTER_COUNT]; bool scaling_buffer_dirty; } PACKED is31fl3745_driver_t; is31fl3745_driver_t driver_buffers[IS31FL3745_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .scaling_buffer_dirty = false, }}; @@ -123,13 +126,21 @@ void is31fl3745_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 8 transfers of 18 bytes. // Iterate over the pwm_buffer contents at 18 byte intervals. - for (uint8_t i = 0; i < IS31FL3745_PWM_REGISTER_COUNT; i += 18) { + for (uint8_t i = 0; i < IS31FL3745_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3745_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3745_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3745_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3745_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3745_PWM_REGISTERS_PER_CHUNK, IS31FL3745_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3745_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3745_PWM_REGISTERS_PER_CHUNK, IS31FL3745_I2C_TIMEOUT); #endif } } @@ -197,8 +208,8 @@ void is31fl3745_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.v] = value; + driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3745_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -217,12 +228,14 @@ void is31fl3745_set_scaling_register(uint8_t index, uint8_t value) { } void is31fl3745_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3745_select_page(index, IS31FL3745_COMMAND_PWM); - - is31fl3745_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3745_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3745a_select_page(index, IS31FL3745_COMMAND_PWM); + is31fl3745a_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3745.c b/drivers/led/issi/is31fl3745.c index 1e3b437e02a..b972a9f9e61 100644 --- a/drivers/led/issi/is31fl3745.c +++ b/drivers/led/issi/is31fl3745.c @@ -63,6 +63,9 @@ # define IS31FL3745_SYNC_4 IS31FL3745_SYNC_NONE #endif +#define IS31FL3745_PWM_REGISTERS_PER_CHUNK 18 +#define IS31FL3745_CHUNK_COUNT (IS31FL3745_PWM_REGISTER_COUNT / IS31FL3745_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3745_DRIVER_COUNT] = { IS31FL3745_I2C_ADDRESS_1, #ifdef IS31FL3745_I2C_ADDRESS_2 @@ -91,14 +94,14 @@ const uint8_t driver_sync[IS31FL3745_DRIVER_COUNT] = { typedef struct is31fl3745_driver_t { uint8_t pwm_buffer[IS31FL3745_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3745_CHUNK_COUNT]; uint8_t scaling_buffer[IS31FL3745_SCALING_REGISTER_COUNT]; bool scaling_buffer_dirty; } PACKED is31fl3745_driver_t; is31fl3745_driver_t driver_buffers[IS31FL3745_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .scaling_buffer_dirty = false, }}; @@ -123,13 +126,21 @@ void is31fl3745_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 8 transfers of 18 bytes. // Iterate over the pwm_buffer contents at 18 byte intervals. - for (uint8_t i = 0; i < IS31FL3745_PWM_REGISTER_COUNT; i += 18) { + for (uint8_t i = 0; i < IS31FL3745_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3745_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3745_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3745_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3745_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3745_PWM_REGISTERS_PER_CHUNK, IS31FL3745_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3745_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3745_PWM_REGISTERS_PER_CHUNK, IS31FL3745_I2C_TIMEOUT); #endif } } @@ -197,10 +208,12 @@ void is31fl3745_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { return; } - driver_buffers[led.driver].pwm_buffer[led.r] = red; - driver_buffers[led.driver].pwm_buffer[led.g] = green; - driver_buffers[led.driver].pwm_buffer[led.b] = blue; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.r] = red; + driver_buffers[led.driver].pwm_buffer[led.g] = green; + driver_buffers[led.driver].pwm_buffer[led.b] = blue; + driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3745_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3745_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3745_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -221,12 +234,14 @@ void is31fl3745_set_scaling_register(uint8_t index, uint8_t red, uint8_t green, } void is31fl3745_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3745_select_page(index, IS31FL3745_COMMAND_PWM); - - is31fl3745_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3745_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3745_select_page(index, IS31FL3745_COMMAND_PWM); + is31fl3745_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3746a-mono.c b/drivers/led/issi/is31fl3746a-mono.c index 6bff10723fd..1c2e80ad878 100644 --- a/drivers/led/issi/is31fl3746a-mono.c +++ b/drivers/led/issi/is31fl3746a-mono.c @@ -54,6 +54,9 @@ # define IS31FL3746A_GLOBAL_CURRENT 0xFF #endif +#define IS31FL3746A_PWM_REGISTERS_PER_CHUNK 18 +#define IS31FL3746A_CHUNK_COUNT (IS31FL3746A_PWM_REGISTER_COUNT / IS31FL3746A_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = { IS31FL3746A_I2C_ADDRESS_1, #ifdef IS31FL3746A_I2C_ADDRESS_2 @@ -69,14 +72,14 @@ const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = { typedef struct is31fl3746a_driver_t { uint8_t pwm_buffer[IS31FL3746A_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3746A_CHUNK_COUNT]; uint8_t scaling_buffer[IS31FL3746A_SCALING_REGISTER_COUNT]; bool scaling_buffer_dirty; } PACKED is31fl3746a_driver_t; is31fl3746a_driver_t driver_buffers[IS31FL3746A_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .scaling_buffer_dirty = false, }}; @@ -101,13 +104,21 @@ void is31fl3746a_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 4 transfers of 18 bytes. // Iterate over the pwm_buffer contents at 18 byte intervals. - for (uint8_t i = 0; i < IS31FL3746A_PWM_REGISTER_COUNT; i += 18) { + for (uint8_t i = 0; i < IS31FL3746A_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3746A_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3746A_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3746A_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3746A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3746A_PWM_REGISTERS_PER_CHUNK, IS31FL3746A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3746A_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3746A_PWM_REGISTERS_PER_CHUNK, IS31FL3746A_I2C_TIMEOUT); #endif } } @@ -174,8 +185,8 @@ void is31fl3746a_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.v] = value; + driver_buffers[led.driver].pwm_buffer_dirty[led.v / IS31FL3746A_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -194,12 +205,14 @@ void is31fl3746a_set_scaling_register(uint8_t index, uint8_t value) { } void is31fl3746a_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3746a_select_page(index, IS31FL3746A_COMMAND_PWM); - - is31fl3746a_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3746A_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3746a_select_page(index, IS31FL3746A_COMMAND_PWM); + is31fl3746a_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/issi/is31fl3746a.c b/drivers/led/issi/is31fl3746a.c index 1ef0b2d6322..d509a335c93 100644 --- a/drivers/led/issi/is31fl3746a.c +++ b/drivers/led/issi/is31fl3746a.c @@ -54,6 +54,9 @@ # define IS31FL3746A_GLOBAL_CURRENT 0xFF #endif +#define IS31FL3746A_PWM_REGISTERS_PER_CHUNK 18 +#define IS31FL3746A_CHUNK_COUNT (IS31FL3746A_PWM_REGISTER_COUNT / IS31FL3746A_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = { IS31FL3746A_I2C_ADDRESS_1, #ifdef IS31FL3746A_I2C_ADDRESS_2 @@ -69,14 +72,14 @@ const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = { typedef struct is31fl3746a_driver_t { uint8_t pwm_buffer[IS31FL3746A_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[IS31FL3746A_CHUNK_COUNT]; uint8_t scaling_buffer[IS31FL3746A_SCALING_REGISTER_COUNT]; bool scaling_buffer_dirty; } PACKED is31fl3746a_driver_t; is31fl3746a_driver_t driver_buffers[IS31FL3746A_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .scaling_buffer = {0}, .scaling_buffer_dirty = false, }}; @@ -101,13 +104,21 @@ void is31fl3746a_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 4 transfers of 18 bytes. // Iterate over the pwm_buffer contents at 18 byte intervals. - for (uint8_t i = 0; i < IS31FL3746A_PWM_REGISTER_COUNT; i += 18) { + for (uint8_t i = 0; i < IS31FL3746A_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * IS31FL3746A_PWM_REGISTERS_PER_CHUNK; + #if IS31FL3746A_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < IS31FL3746A_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3746A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3746A_PWM_REGISTERS_PER_CHUNK, IS31FL3746A_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i + 1, driver_buffers[index].pwm_buffer + i, 18, IS31FL3746A_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset + 1, driver_buffers[index].pwm_buffer + offset, IS31FL3746A_PWM_REGISTERS_PER_CHUNK, IS31FL3746A_I2C_TIMEOUT); #endif } } @@ -174,10 +185,12 @@ void is31fl3746a_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) return; } - driver_buffers[led.driver].pwm_buffer[led.r] = red; - driver_buffers[led.driver].pwm_buffer[led.g] = green; - driver_buffers[led.driver].pwm_buffer[led.b] = blue; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.r] = red; + driver_buffers[led.driver].pwm_buffer[led.g] = green; + driver_buffers[led.driver].pwm_buffer[led.b] = blue; + driver_buffers[led.driver].pwm_buffer_dirty[led.r / IS31FL3746A_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.g / IS31FL3746A_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.b / IS31FL3746A_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -198,12 +211,14 @@ void is31fl3746a_set_scaling_register(uint8_t index, uint8_t red, uint8_t green, } void is31fl3746a_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - is31fl3746a_select_page(index, IS31FL3746A_COMMAND_PWM); - - is31fl3746a_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < IS31FL3746A_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + is31fl3746a_select_page(index, IS31FL3746A_COMMAND_PWM); + is31fl3746a_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/snled27351-mono.c b/drivers/led/snled27351-mono.c index d87b856db69..2136776dc79 100644 --- a/drivers/led/snled27351-mono.c +++ b/drivers/led/snled27351-mono.c @@ -38,6 +38,9 @@ { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF } #endif +#define SNLED27351_PWM_REGISTERS_PER_CHUNK 16 +#define SNLED27351_CHUNK_COUNT (SNLED27351_PWM_REGISTER_COUNT / SNLED27351_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = { SNLED27351_I2C_ADDRESS_1, #ifdef SNLED27351_I2C_ADDRESS_2 @@ -59,14 +62,14 @@ const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct snled27351_driver_t { uint8_t pwm_buffer[SNLED27351_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[SNLED27351_CHUNK_COUNT]; uint8_t led_control_buffer[SNLED27351_LED_CONTROL_REGISTER_COUNT]; bool led_control_buffer_dirty; } PACKED snled27351_driver_t; snled27351_driver_t driver_buffers[SNLED27351_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, }}; @@ -90,13 +93,21 @@ void snled27351_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 12 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < SNLED27351_PWM_REGISTER_COUNT; i += 16) { + for (uint8_t i = 0; i < SNLED27351_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * SNLED27351_PWM_REGISTERS_PER_CHUNK; + #if SNLED27351_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < SNLED27351_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, SNLED27351_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, SNLED27351_PWM_REGISTERS_PER_CHUNK, SNLED27351_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, SNLED27351_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, SNLED27351_PWM_REGISTERS_PER_CHUNK, SNLED27351_I2C_TIMEOUT); #endif } } @@ -178,8 +189,8 @@ void snled27351_set_value(int index, uint8_t value) { return; } - driver_buffers[led.driver].pwm_buffer[led.v] = value; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.v] = value; + driver_buffers[led.driver].pwm_buffer_dirty[led.v / SNLED27351_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -206,12 +217,14 @@ void snled27351_set_led_control_register(uint8_t index, bool value) { } void snled27351_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - snled27351_select_page(index, SNLED27351_COMMAND_PWM); - - snled27351_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < SNLED27351_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + snled27351_select_page(index, SNLED27351_COMMAND_PWM); + snled27351_write_pwm_buffer(index); + return; + } } } diff --git a/drivers/led/snled27351.c b/drivers/led/snled27351.c index 8ebf681bdb6..3185305f368 100644 --- a/drivers/led/snled27351.c +++ b/drivers/led/snled27351.c @@ -38,6 +38,9 @@ { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF } #endif +#define SNLED27351_PWM_REGISTERS_PER_CHUNK 16 +#define SNLED27351_CHUNK_COUNT (SNLED27351_PWM_REGISTER_COUNT / SNLED27351_PWM_REGISTERS_PER_CHUNK) + const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = { SNLED27351_I2C_ADDRESS_1, #ifdef SNLED27351_I2C_ADDRESS_2 @@ -59,14 +62,14 @@ const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = { // probably not worth the extra complexity. typedef struct snled27351_driver_t { uint8_t pwm_buffer[SNLED27351_PWM_REGISTER_COUNT]; - bool pwm_buffer_dirty; + bool pwm_buffer_dirty[SNLED27351_CHUNK_COUNT]; uint8_t led_control_buffer[SNLED27351_LED_CONTROL_REGISTER_COUNT]; bool led_control_buffer_dirty; } PACKED snled27351_driver_t; snled27351_driver_t driver_buffers[SNLED27351_DRIVER_COUNT] = {{ .pwm_buffer = {0}, - .pwm_buffer_dirty = false, + .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, }}; @@ -90,13 +93,21 @@ void snled27351_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 12 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < SNLED27351_PWM_REGISTER_COUNT; i += 16) { + for (uint8_t i = 0; i < SNLED27351_CHUNK_COUNT; i++) { + if (!driver_buffers[index].pwm_buffer_dirty[i]) { + continue; + } + + driver_buffers[index].pwm_buffer_dirty[i] = false; + + uint8_t offset = i * SNLED27351_PWM_REGISTERS_PER_CHUNK; + #if SNLED27351_I2C_PERSISTENCE > 0 for (uint8_t j = 0; j < SNLED27351_I2C_PERSISTENCE; j++) { - if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, SNLED27351_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; + if (i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, SNLED27351_PWM_REGISTERS_PER_CHUNK, SNLED27351_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; } #else - i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, SNLED27351_I2C_TIMEOUT); + i2c_write_register(i2c_addresses[index] << 1, offset, driver_buffers[index].pwm_buffer + offset, SNLED27351_PWM_REGISTERS_PER_CHUNK, SNLED27351_I2C_TIMEOUT); #endif } } @@ -178,10 +189,12 @@ void snled27351_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { return; } - driver_buffers[led.driver].pwm_buffer[led.r] = red; - driver_buffers[led.driver].pwm_buffer[led.g] = green; - driver_buffers[led.driver].pwm_buffer[led.b] = blue; - driver_buffers[led.driver].pwm_buffer_dirty = true; + driver_buffers[led.driver].pwm_buffer[led.r] = red; + driver_buffers[led.driver].pwm_buffer[led.g] = green; + driver_buffers[led.driver].pwm_buffer[led.b] = blue; + driver_buffers[led.driver].pwm_buffer_dirty[led.r / SNLED27351_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.g / SNLED27351_PWM_REGISTERS_PER_CHUNK] = true; + driver_buffers[led.driver].pwm_buffer_dirty[led.b / SNLED27351_PWM_REGISTERS_PER_CHUNK] = true; } } @@ -222,12 +235,14 @@ void snled27351_set_led_control_register(uint8_t index, bool red, bool green, bo } void snled27351_update_pwm_buffers(uint8_t index) { - if (driver_buffers[index].pwm_buffer_dirty) { - snled27351_select_page(index, SNLED27351_COMMAND_PWM); - - snled27351_write_pwm_buffer(index); - - driver_buffers[index].pwm_buffer_dirty = false; + for (uint8_t i = 0; i < SNLED27351_CHUNK_COUNT; i++) { + if (driver_buffers[index].pwm_buffer_dirty[i]) { + // if any of these are true then write PWM buffer + // then exit the loop + snled27351_select_page(index, SNLED27351_COMMAND_PWM); + snled27351_write_pwm_buffer(index); + return; + } } } diff --git a/platforms/avr/drivers/ws2812_bitbang.c b/platforms/avr/drivers/ws2812_bitbang.c index 23bab5256ca..7de356754a4 100644 --- a/platforms/avr/drivers/ws2812_bitbang.c +++ b/platforms/avr/drivers/ws2812_bitbang.c @@ -152,7 +152,7 @@ static inline void ws2812_sendarray_mask(uint8_t *data, uint16_t datlen, uint8_t } ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; -bool ws2812_dirty = false; +bool ws2812_dirty = false; void ws2812_init(void) { DDRx_ADDRESS(WS2812_DI_PIN) |= pinmask(WS2812_DI_PIN); @@ -176,6 +176,7 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { void ws2812_flush(void) { if (!ws2812_dirty) return; + ws2812_dirty = false; uint8_t masklo = ~(pinmask(WS2812_DI_PIN)) & PORTx_ADDRESS(WS2812_DI_PIN); uint8_t maskhi = pinmask(WS2812_DI_PIN) | PORTx_ADDRESS(WS2812_DI_PIN); diff --git a/platforms/avr/drivers/ws2812_i2c.c b/platforms/avr/drivers/ws2812_i2c.c index 7ab92b61d13..4b6ade1ec5d 100644 --- a/platforms/avr/drivers/ws2812_i2c.c +++ b/platforms/avr/drivers/ws2812_i2c.c @@ -38,5 +38,6 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { void ws2812_flush(void) { if (!ws2812_dirty) return; + ws2812_dirty = false; i2c_transmit(WS2812_I2C_ADDRESS, (uint8_t *)ws2812_leds, WS2812_LED_COUNT * sizeof(ws2812_led_t), WS2812_I2C_TIMEOUT); } diff --git a/platforms/chibios/drivers/ws2812_bitbang.c b/platforms/chibios/drivers/ws2812_bitbang.c index 93fbb6db7ec..712b6785670 100644 --- a/platforms/chibios/drivers/ws2812_bitbang.c +++ b/platforms/chibios/drivers/ws2812_bitbang.c @@ -101,6 +101,7 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { void ws2812_flush(void) { if (!ws2812_dirty) return; + ws2812_dirty = false; // this code is very time dependent, so we need to disable interrupts chSysLock(); diff --git a/platforms/chibios/drivers/ws2812_pwm.c b/platforms/chibios/drivers/ws2812_pwm.c index 50927b849a4..e12a5979bc7 100644 --- a/platforms/chibios/drivers/ws2812_pwm.c +++ b/platforms/chibios/drivers/ws2812_pwm.c @@ -291,6 +291,7 @@ typedef uint8_t ws2812_buffer_t; #endif static ws2812_buffer_t ws2812_frame_buffer[WS2812_BIT_N + 1]; /**< Buffer for a frame */ +bool ws2812_dirty = false; /* --- PUBLIC FUNCTIONS ----------------------------------------------------- */ /* @@ -310,7 +311,7 @@ void ws2812_init(void) { palSetLineMode(WS2812_DI_PIN, WS2812_OUTPUT_MODE); // PWM Configuration - //#pragma GCC diagnostic ignored "-Woverride-init" // Turn off override-init warning for this struct. We use the overriding ability to set a "default" channel config + // #pragma GCC diagnostic ignored "-Woverride-init" // Turn off override-init warning for this struct. We use the overriding ability to set a "default" channel config static const PWMConfig ws2812_pwm_config = { .frequency = WS2812_PWM_TICK_FREQUENCY, .period = WS2812_PWM_PERIOD, // Mit dieser Periode wird UDE-Event erzeugt und ein neuer Wert (Länge WS2812_BIT_N) vom DMA ins CCR geschrieben @@ -328,7 +329,7 @@ void ws2812_init(void) { .dier = TIM_DIER_UDE, // DMA on update event for next period #endif }; - //#pragma GCC diagnostic pop // Restore command-line warning options + // #pragma GCC diagnostic pop // Restore command-line warning options // Configure DMA // dmaInit(); // Joe added this @@ -398,6 +399,7 @@ void ws2812_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { ws2812_leds[index].r = red; ws2812_leds[index].g = green; ws2812_leds[index].b = blue; + ws2812_dirty = true; #if defined(WS2812_RGBW) ws2812_rgb_to_rgbw(&ws2812_leds[index]); #endif @@ -410,6 +412,8 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { } void ws2812_flush(void) { + if (!ws2812_dirty) return; + ws2812_dirty = false; for (int i = 0; i < WS2812_LED_COUNT; i++) { #if defined(WS2812_RGBW) ws2812_write_led_rgbw(i, ws2812_leds[i].r, ws2812_leds[i].g, ws2812_leds[i].b, ws2812_leds[i].w); diff --git a/platforms/chibios/drivers/ws2812_spi.c b/platforms/chibios/drivers/ws2812_spi.c index 4ccea138887..b0fcbc847c7 100644 --- a/platforms/chibios/drivers/ws2812_spi.c +++ b/platforms/chibios/drivers/ws2812_spi.c @@ -241,6 +241,9 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { } void ws2812_flush(void) { + if (!ws2812_dirty) return; + ws2812_dirty = false; + for (int i = 0; i < WS2812_LED_COUNT; i++) { set_led_color_rgb(ws2812_leds[i], i); } @@ -249,7 +252,6 @@ void ws2812_flush(void) { // Instead spiSend can be used to send synchronously (or the thread logic can be added back). #ifndef WS2812_SPI_USE_CIRCULAR_BUFFER # ifdef WS2812_SPI_SYNC - if (!ws2812_dirty) return; spiSend(&WS2812_SPI_DRIVER, ARRAY_SIZE(txbuf), txbuf); # else spiStartSend(&WS2812_SPI_DRIVER, ARRAY_SIZE(txbuf), txbuf); From 4575716686972162d3c27f6e36f4bb923b4750d4 Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Sun, 26 Jan 2025 13:08:26 +1100 Subject: [PATCH 05/12] fix up lint --- platforms/avr/drivers/ws2812_bitbang.c | 2 +- platforms/chibios/drivers/ws2812_spi.c | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/platforms/avr/drivers/ws2812_bitbang.c b/platforms/avr/drivers/ws2812_bitbang.c index 7de356754a4..c3c651da347 100644 --- a/platforms/avr/drivers/ws2812_bitbang.c +++ b/platforms/avr/drivers/ws2812_bitbang.c @@ -176,7 +176,7 @@ void ws2812_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { void ws2812_flush(void) { if (!ws2812_dirty) return; - ws2812_dirty = false; + ws2812_dirty = false; uint8_t masklo = ~(pinmask(WS2812_DI_PIN)) & PORTx_ADDRESS(WS2812_DI_PIN); uint8_t maskhi = pinmask(WS2812_DI_PIN) | PORTx_ADDRESS(WS2812_DI_PIN); diff --git a/platforms/chibios/drivers/ws2812_spi.c b/platforms/chibios/drivers/ws2812_spi.c index b0fcbc847c7..6654c0ce2f0 100644 --- a/platforms/chibios/drivers/ws2812_spi.c +++ b/platforms/chibios/drivers/ws2812_spi.c @@ -189,7 +189,8 @@ void ws2812_init(void) { 0, WS2812_SPI_DIVISOR # else - WS2812_SPI_DIVISOR_CR1_BR_X, 0 + WS2812_SPI_DIVISOR_CR1_BR_X, + 0 # endif #else // HAL_SPI_V2 From ce4deab51f361fef67b99dcda8c1084289a78304 Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Sun, 26 Jan 2025 20:52:24 +1100 Subject: [PATCH 06/12] fix up bool for avr --- platforms/avr/drivers/ws2812_bitbang.c | 1 + 1 file changed, 1 insertion(+) diff --git a/platforms/avr/drivers/ws2812_bitbang.c b/platforms/avr/drivers/ws2812_bitbang.c index c3c651da347..9033abed437 100644 --- a/platforms/avr/drivers/ws2812_bitbang.c +++ b/platforms/avr/drivers/ws2812_bitbang.c @@ -25,6 +25,7 @@ #include #include "ws2812.h" #include "pin_defs.h" +#include #define pinmask(pin) (_BV((pin)&0xF)) From 8c2444b2523414334390630188d117fc1bdd9e52 Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Sun, 26 Jan 2025 22:26:32 +1100 Subject: [PATCH 07/12] remove old include --- drivers/led/issi/is31fl3733.c | 1 - 1 file changed, 1 deletion(-) diff --git a/drivers/led/issi/is31fl3733.c b/drivers/led/issi/is31fl3733.c index 339a310a1f1..55935f8610a 100644 --- a/drivers/led/issi/is31fl3733.c +++ b/drivers/led/issi/is31fl3733.c @@ -21,7 +21,6 @@ #include "i2c_master.h" #include "gpio.h" #include "wait.h" -#include "bit_array.h" #define IS31FL3733_PWM_REGISTER_COUNT 192 #define IS31FL3733_LED_CONTROL_REGISTER_COUNT 24 From 46545e9f916562a6e237de512e79a64a57d69e52 Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Sun, 26 Jan 2025 22:27:28 +1100 Subject: [PATCH 08/12] fix up function name --- drivers/led/issi/is31fl3741.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/drivers/led/issi/is31fl3741.c b/drivers/led/issi/is31fl3741.c index 5e6cf8e1ad7..e8158e26478 100644 --- a/drivers/led/issi/is31fl3741.c +++ b/drivers/led/issi/is31fl3741.c @@ -300,9 +300,9 @@ void is31fl3741_set_pwm_buffer(const is31fl3741_led_t *pled, uint8_t red, uint8_ set_pwm_value(pled->driver, pled->g, green); set_pwm_value(pled->driver, pled->b, blue); - dirty_bitfield_set_bit(pled->driver, pled->r); - dirty_bitfield_set_bit(pled->driver, pled->g); - dirty_bitfield_set_bit(pled->driver, pled->b); + dirty_bitfield_set(pled->driver, pled->r); + dirty_bitfield_set(pled->driver, pled->g); + dirty_bitfield_set(pled->driver, pled->b); } void is31fl3741_update_led_control_registers(uint8_t index) { From 53453965998c4b2496a71d7f80aa7f69982eab43 Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Sun, 26 Jan 2025 22:28:03 +1100 Subject: [PATCH 09/12] fix up bool include --- platforms/avr/drivers/ws2812_i2c.c | 1 + 1 file changed, 1 insertion(+) diff --git a/platforms/avr/drivers/ws2812_i2c.c b/platforms/avr/drivers/ws2812_i2c.c index 4b6ade1ec5d..82a003f4e25 100644 --- a/platforms/avr/drivers/ws2812_i2c.c +++ b/platforms/avr/drivers/ws2812_i2c.c @@ -1,6 +1,7 @@ // Copyright 2024 QMK // SPDX-License-Identifier: GPL-2.0-or-later +#include #include "ws2812.h" #include "i2c_master.h" From 02fa1fefa91976564d55336f6799a10966e40b13 Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Mon, 27 Jan 2025 00:17:25 +1100 Subject: [PATCH 10/12] fix up --- drivers/led/issi/is31fl3731-mono.c | 2 +- drivers/led/issi/is31fl3733.c | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/drivers/led/issi/is31fl3731-mono.c b/drivers/led/issi/is31fl3731-mono.c index 30d6bd8f960..09e5c8dfbbb 100644 --- a/drivers/led/issi/is31fl3731-mono.c +++ b/drivers/led/issi/is31fl3731-mono.c @@ -87,7 +87,7 @@ void is31fl3731_write_pwm_buffer(uint8_t index) { // Transmit PWM registers in 9 transfers of 16 bytes. // Iterate over the pwm_buffer contents at 16 byte intervals. - for (uint8_t i = 0; i < IS31FL3731_PWM_REGISTER_COUNT; i++) { + for (uint8_t i = 0; i < IS31FL3731_CHUNK_COUNT; i++) { if (!driver_buffers[index].pwm_buffer_dirty[i]) { continue; } diff --git a/drivers/led/issi/is31fl3733.c b/drivers/led/issi/is31fl3733.c index 55935f8610a..d3a812e64e8 100644 --- a/drivers/led/issi/is31fl3733.c +++ b/drivers/led/issi/is31fl3733.c @@ -109,7 +109,6 @@ is31fl3733_driver_t driver_buffers[IS31FL3733_DRIVER_COUNT] = {{ .pwm_buffer_dirty = {0}, .led_control_buffer = {0}, .led_control_buffer_dirty = false, - .led_control_bitfield = {0}, }}; void is31fl3733_write_register(uint8_t index, uint8_t reg, uint8_t data) { From 2fb81fc8cd7fbb3c485a049735b20832c0cefd75 Mon Sep 17 00:00:00 2001 From: Xelus22 <> Date: Mon, 27 Jan 2025 11:41:55 +1100 Subject: [PATCH 11/12] move to static --- platforms/avr/drivers/ws2812_bitbang.c | 2 +- platforms/avr/drivers/ws2812_i2c.c | 2 +- platforms/chibios/drivers/ws2812_bitbang.c | 2 +- platforms/chibios/drivers/ws2812_pwm.c | 2 +- platforms/chibios/drivers/ws2812_spi.c | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/platforms/avr/drivers/ws2812_bitbang.c b/platforms/avr/drivers/ws2812_bitbang.c index 9033abed437..ae6ab9d2d3d 100644 --- a/platforms/avr/drivers/ws2812_bitbang.c +++ b/platforms/avr/drivers/ws2812_bitbang.c @@ -153,7 +153,7 @@ static inline void ws2812_sendarray_mask(uint8_t *data, uint16_t datlen, uint8_t } ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; -bool ws2812_dirty = false; +static bool ws2812_dirty = false; void ws2812_init(void) { DDRx_ADDRESS(WS2812_DI_PIN) |= pinmask(WS2812_DI_PIN); diff --git a/platforms/avr/drivers/ws2812_i2c.c b/platforms/avr/drivers/ws2812_i2c.c index 82a003f4e25..d18a946b619 100644 --- a/platforms/avr/drivers/ws2812_i2c.c +++ b/platforms/avr/drivers/ws2812_i2c.c @@ -18,7 +18,7 @@ #endif ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; -bool ws2812_dirty = false; +static bool ws2812_dirty = false; void ws2812_init(void) { i2c_init(); diff --git a/platforms/chibios/drivers/ws2812_bitbang.c b/platforms/chibios/drivers/ws2812_bitbang.c index 712b6785670..5d24e83addf 100644 --- a/platforms/chibios/drivers/ws2812_bitbang.c +++ b/platforms/chibios/drivers/ws2812_bitbang.c @@ -77,7 +77,7 @@ void sendByte(uint8_t byte) { } ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; -bool ws2812_dirty = false; +static bool ws2812_dirty = false; void ws2812_init(void) { palSetLineMode(WS2812_DI_PIN, WS2812_OUTPUT_MODE); diff --git a/platforms/chibios/drivers/ws2812_pwm.c b/platforms/chibios/drivers/ws2812_pwm.c index e12a5979bc7..108af2cd6ad 100644 --- a/platforms/chibios/drivers/ws2812_pwm.c +++ b/platforms/chibios/drivers/ws2812_pwm.c @@ -291,7 +291,7 @@ typedef uint8_t ws2812_buffer_t; #endif static ws2812_buffer_t ws2812_frame_buffer[WS2812_BIT_N + 1]; /**< Buffer for a frame */ -bool ws2812_dirty = false; +static bool ws2812_dirty = false; /* --- PUBLIC FUNCTIONS ----------------------------------------------------- */ /* diff --git a/platforms/chibios/drivers/ws2812_spi.c b/platforms/chibios/drivers/ws2812_spi.c index 6654c0ce2f0..0224a775e9f 100644 --- a/platforms/chibios/drivers/ws2812_spi.c +++ b/platforms/chibios/drivers/ws2812_spi.c @@ -165,7 +165,7 @@ static void set_led_color_rgb(ws2812_led_t color, int pos) { } ws2812_led_t ws2812_leds[WS2812_LED_COUNT]; -bool ws2812_dirty = false; +static bool ws2812_dirty = false; void ws2812_init(void) { palSetLineMode(WS2812_DI_PIN, WS2812_MOSI_OUTPUT_MODE); From 5777f3108ed6bcceb4f4661f71a0127bc862ed57 Mon Sep 17 00:00:00 2001 From: Xelus22 <17491233+Xelus22@users.noreply.github.com> Date: Fri, 16 May 2025 20:55:37 +1000 Subject: [PATCH 12/12] fix up chunk --- drivers/led/issi/is31fl3729-mono.c | 2 +- drivers/led/issi/is31fl3729.c | 2 +- drivers/led/issi/is31fl3731-mono.c | 2 +- drivers/led/issi/is31fl3731.c | 2 +- drivers/led/issi/is31fl3733-mono.c | 2 +- drivers/led/issi/is31fl3733.c | 2 +- drivers/led/issi/is31fl3736-mono.c | 2 +- drivers/led/issi/is31fl3736.c | 2 +- drivers/led/issi/is31fl3737-mono.c | 2 +- drivers/led/issi/is31fl3737.c | 2 +- drivers/led/issi/is31fl3741-mono.c | 4 ++-- drivers/led/issi/is31fl3741.c | 4 ++-- drivers/led/issi/is31fl3742a-mono.c | 2 +- drivers/led/issi/is31fl3742a.c | 2 +- drivers/led/issi/is31fl3743a-mono.c | 2 +- drivers/led/issi/is31fl3743a.c | 2 +- drivers/led/issi/is31fl3745-mono.c | 2 +- drivers/led/issi/is31fl3745.c | 2 +- drivers/led/issi/is31fl3746a-mono.c | 2 +- drivers/led/issi/is31fl3746a.c | 2 +- drivers/led/snled27351-mono.c | 2 +- drivers/led/snled27351.c | 2 +- 22 files changed, 24 insertions(+), 24 deletions(-) diff --git a/drivers/led/issi/is31fl3729-mono.c b/drivers/led/issi/is31fl3729-mono.c index a6d8adf04da..52e41e61d76 100644 --- a/drivers/led/issi/is31fl3729-mono.c +++ b/drivers/led/issi/is31fl3729-mono.c @@ -65,7 +65,7 @@ #endif #define IS31FL3729_PWM_REGISTERS_PER_CHUNK 13 -#define IS31FL3729_CHUNK_COUNT (IS31FL3729_PWM_REGISTER_COUNT / IS31FL3729_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3729_CHUNK_COUNT ((IS31FL3729_PWM_REGISTER_COUNT + IS31FL3729_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3729_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = { IS31FL3729_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3729.c b/drivers/led/issi/is31fl3729.c index af9f49958c5..fe81fde8f58 100644 --- a/drivers/led/issi/is31fl3729.c +++ b/drivers/led/issi/is31fl3729.c @@ -65,7 +65,7 @@ #endif #define IS31FL3729_PWM_REGISTERS_PER_CHUNK 13 -#define IS31FL3729_CHUNK_COUNT (IS31FL3729_PWM_REGISTER_COUNT / IS31FL3729_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3729_CHUNK_COUNT ((IS31FL3729_PWM_REGISTER_COUNT + IS31FL3729_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3729_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = { IS31FL3729_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3731-mono.c b/drivers/led/issi/is31fl3731-mono.c index 09e5c8dfbbb..275150d69a3 100644 --- a/drivers/led/issi/is31fl3731-mono.c +++ b/drivers/led/issi/is31fl3731-mono.c @@ -34,7 +34,7 @@ #endif #define IS31FL3731_PWM_REGISTERS_PER_CHUNK 16 -#define IS31FL3731_CHUNK_COUNT (IS31FL3731_PWM_REGISTER_COUNT / IS31FL3731_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3731_CHUNK_COUNT ((IS31FL3731_PWM_REGISTER_COUNT + IS31FL3731_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3731_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { IS31FL3731_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3731.c b/drivers/led/issi/is31fl3731.c index ca6174df8ea..e3a23eaf84c 100644 --- a/drivers/led/issi/is31fl3731.c +++ b/drivers/led/issi/is31fl3731.c @@ -33,7 +33,7 @@ #endif #define IS31FL3731_PWM_REGISTERS_PER_CHUNK 16 -#define IS31FL3731_CHUNK_COUNT (IS31FL3731_PWM_REGISTER_COUNT / IS31FL3731_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3731_CHUNK_COUNT ((IS31FL3731_PWM_REGISTER_COUNT + IS31FL3731_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3731_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3731_DRIVER_COUNT] = { IS31FL3731_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3733-mono.c b/drivers/led/issi/is31fl3733-mono.c index 5ace321a5a6..186e7253791 100644 --- a/drivers/led/issi/is31fl3733-mono.c +++ b/drivers/led/issi/is31fl3733-mono.c @@ -64,7 +64,7 @@ #endif #define IS31FL3733_PWM_REGISTERS_PER_CHUNK 16 -#define IS31FL3733_CHUNK_COUNT (IS31FL3733_PWM_REGISTER_COUNT / IS31FL3733_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3733_CHUNK_COUNT ((IS31FL3733_PWM_REGISTER_COUNT + IS31FL3733_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3733_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3733_DRIVER_COUNT] = { IS31FL3733_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3733.c b/drivers/led/issi/is31fl3733.c index d3a812e64e8..fb2e53aca07 100644 --- a/drivers/led/issi/is31fl3733.c +++ b/drivers/led/issi/is31fl3733.c @@ -63,7 +63,7 @@ #endif #define IS31FL3733_PWM_REGISTERS_PER_CHUNK 16 -#define IS31FL3733_CHUNK_COUNT (IS31FL3733_PWM_REGISTER_COUNT / IS31FL3733_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3733_CHUNK_COUNT ((IS31FL3733_PWM_REGISTER_COUNT + IS31FL3733_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3733_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3733_DRIVER_COUNT] = { IS31FL3733_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3736-mono.c b/drivers/led/issi/is31fl3736-mono.c index a4192e7dc19..6e3de77cd3b 100644 --- a/drivers/led/issi/is31fl3736-mono.c +++ b/drivers/led/issi/is31fl3736-mono.c @@ -48,7 +48,7 @@ #endif #define IS31FL3736_PWM_REGISTERS_PER_CHUNK 16 -#define IS31FL3736_CHUNK_COUNT (IS31FL3736_PWM_REGISTER_COUNT / IS31FL3736_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3736_CHUNK_COUNT ((IS31FL3736_PWM_REGISTER_COUNT + IS31FL3736_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3736_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = { IS31FL3736_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3736.c b/drivers/led/issi/is31fl3736.c index 044eab17750..1f102e71e7b 100644 --- a/drivers/led/issi/is31fl3736.c +++ b/drivers/led/issi/is31fl3736.c @@ -48,7 +48,7 @@ #endif #define IS31FL3736_PWM_REGISTERS_PER_CHUNK 16 -#define IS31FL3736_CHUNK_COUNT (IS31FL3736_PWM_REGISTER_COUNT / IS31FL3736_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3736_CHUNK_COUNT ((IS31FL3736_PWM_REGISTER_COUNT + IS31FL3736_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3736_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3736_DRIVER_COUNT] = { IS31FL3736_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3737-mono.c b/drivers/led/issi/is31fl3737-mono.c index 8f4e68d1aee..43b41660714 100644 --- a/drivers/led/issi/is31fl3737-mono.c +++ b/drivers/led/issi/is31fl3737-mono.c @@ -50,7 +50,7 @@ #endif #define IS31FL3737_PWM_REGISTERS_PER_CHUNK 16 -#define IS31FL3737_CHUNK_COUNT (IS31FL3737_PWM_REGISTER_COUNT / IS31FL3737_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3737_CHUNK_COUNT ((IS31FL3737_PWM_REGISTER_COUNT + IS31FL3737_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3737_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = { IS31FL3737_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3737.c b/drivers/led/issi/is31fl3737.c index 7ce56d41e99..6b34f325e48 100644 --- a/drivers/led/issi/is31fl3737.c +++ b/drivers/led/issi/is31fl3737.c @@ -50,7 +50,7 @@ #endif #define IS31FL3737_PWM_REGISTERS_PER_CHUNK 16 -#define IS31FL3737_CHUNK_COUNT (IS31FL3737_PWM_REGISTER_COUNT / IS31FL3737_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3737_CHUNK_COUNT ((IS31FL3737_PWM_REGISTER_COUNT + IS31FL3737_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3737_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = { IS31FL3737_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3741-mono.c b/drivers/led/issi/is31fl3741-mono.c index 92d2e63dbc0..bfd185f0d22 100644 --- a/drivers/led/issi/is31fl3741-mono.c +++ b/drivers/led/issi/is31fl3741-mono.c @@ -57,8 +57,8 @@ #define IS31FL3741_PWM_0_REGISTERS_PER_CHUNK 30 #define IS31FL3741_PWM_1_REGISTERS_PER_CHUNK 19 -#define IS31FL3741_PAGE_0_CHUNK_COUNT (IS31FL3741_PWM_0_REGISTER_COUNT / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK) -#define IS31FL3741_PAGE_1_CHUNK_COUNT (IS31FL3741_PWM_1_REGISTER_COUNT / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK) +#define IS31FL3741_PAGE_0_CHUNK_COUNT ((IS31FL3741_PWM_0_REGISTER_COUNT + IS31FL3741_PWM_0_REGISTERS_PER_CHUNK - 1) / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK) +#define IS31FL3741_PAGE_1_CHUNK_COUNT ((IS31FL3741_PWM_1_REGISTER_COUNT + IS31FL3741_PWM_1_REGISTERS_PER_CHUNK - 1) / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = { IS31FL3741_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3741.c b/drivers/led/issi/is31fl3741.c index e8158e26478..40906713a61 100644 --- a/drivers/led/issi/is31fl3741.c +++ b/drivers/led/issi/is31fl3741.c @@ -57,8 +57,8 @@ #define IS31FL3741_PWM_0_REGISTERS_PER_CHUNK 30 #define IS31FL3741_PWM_1_REGISTERS_PER_CHUNK 19 -#define IS31FL3741_PAGE_0_CHUNK_COUNT (IS31FL3741_PWM_0_REGISTER_COUNT / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK) -#define IS31FL3741_PAGE_1_CHUNK_COUNT (IS31FL3741_PWM_1_REGISTER_COUNT / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK) +#define IS31FL3741_PAGE_0_CHUNK_COUNT ((IS31FL3741_PWM_0_REGISTER_COUNT + IS31FL3741_PWM_0_REGISTERS_PER_CHUNK - 1) / IS31FL3741_PWM_0_REGISTERS_PER_CHUNK) +#define IS31FL3741_PAGE_1_CHUNK_COUNT ((IS31FL3741_PWM_1_REGISTER_COUNT + IS31FL3741_PWM_1_REGISTERS_PER_CHUNK - 1) / IS31FL3741_PWM_1_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3741_DRIVER_COUNT] = { IS31FL3741_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3742a-mono.c b/drivers/led/issi/is31fl3742a-mono.c index 844daa81f6b..2fbcfc0808f 100644 --- a/drivers/led/issi/is31fl3742a-mono.c +++ b/drivers/led/issi/is31fl3742a-mono.c @@ -55,7 +55,7 @@ #endif #define IS31FL3742A_PWM_REGISTERS_PER_CHUNK 30 -#define IS31FL3742A_CHUNK_COUNT (IS31FL3742A_PWM_REGISTER_COUNT / IS31FL3742A_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3742A_CHUNK_COUNT ((IS31FL3742A_PWM_REGISTER_COUNT + IS31FL3742A_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3742A_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = { IS31FL3742A_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3742a.c b/drivers/led/issi/is31fl3742a.c index d9879df7a64..0e39ab4bb84 100644 --- a/drivers/led/issi/is31fl3742a.c +++ b/drivers/led/issi/is31fl3742a.c @@ -55,7 +55,7 @@ #endif #define IS31FL3742A_PWM_REGISTERS_PER_CHUNK 30 -#define IS31FL3742A_CHUNK_COUNT (IS31FL3742A_PWM_REGISTER_COUNT / IS31FL3742A_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3742A_CHUNK_COUNT ((IS31FL3742A_PWM_REGISTER_COUNT + IS31FL3742A_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3742A_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3742A_DRIVER_COUNT] = { IS31FL3742A_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3743a-mono.c b/drivers/led/issi/is31fl3743a-mono.c index 3840f21fc3f..f033a991715 100644 --- a/drivers/led/issi/is31fl3743a-mono.c +++ b/drivers/led/issi/is31fl3743a-mono.c @@ -64,7 +64,7 @@ #endif #define IS31FL3743A_PWM_REGISTERS_PER_CHUNK 18 -#define IS31FL3743A_CHUNK_COUNT (IS31FL3743A_PWM_REGISTER_COUNT / IS31FL3743A_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3743A_CHUNK_COUNT ((IS31FL3743A_PWM_REGISTER_COUNT + IS31FL3743A_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3743A_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3743A_DRIVER_COUNT] = { IS31FL3743A_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3743a.c b/drivers/led/issi/is31fl3743a.c index a59d371df60..bcdbb5d4c9f 100644 --- a/drivers/led/issi/is31fl3743a.c +++ b/drivers/led/issi/is31fl3743a.c @@ -64,7 +64,7 @@ #endif #define IS31FL3743A_PWM_REGISTERS_PER_CHUNK 18 -#define IS31FL3743A_CHUNK_COUNT (IS31FL3743A_PWM_REGISTER_COUNT / IS31FL3743A_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3743A_CHUNK_COUNT ((IS31FL3743A_PWM_REGISTER_COUNT + IS31FL3743A_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3743A_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3743A_DRIVER_COUNT] = { IS31FL3743A_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3745-mono.c b/drivers/led/issi/is31fl3745-mono.c index 76c760c8833..b535f314508 100644 --- a/drivers/led/issi/is31fl3745-mono.c +++ b/drivers/led/issi/is31fl3745-mono.c @@ -64,7 +64,7 @@ #endif #define IS31FL3745_PWM_REGISTERS_PER_CHUNK 18 -#define IS31FL3745_CHUNK_COUNT (IS31FL3745_PWM_REGISTER_COUNT / IS31FL3745_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3745_CHUNK_COUNT ((IS31FL3745_PWM_REGISTER_COUNT + IS31FL3745_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3745_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3745_DRIVER_COUNT] = { IS31FL3745_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3745.c b/drivers/led/issi/is31fl3745.c index b972a9f9e61..294d3bb6b54 100644 --- a/drivers/led/issi/is31fl3745.c +++ b/drivers/led/issi/is31fl3745.c @@ -64,7 +64,7 @@ #endif #define IS31FL3745_PWM_REGISTERS_PER_CHUNK 18 -#define IS31FL3745_CHUNK_COUNT (IS31FL3745_PWM_REGISTER_COUNT / IS31FL3745_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3745_CHUNK_COUNT ((IS31FL3745_PWM_REGISTER_COUNT + IS31FL3745_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3745_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3745_DRIVER_COUNT] = { IS31FL3745_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3746a-mono.c b/drivers/led/issi/is31fl3746a-mono.c index 1c2e80ad878..0f48bd062ef 100644 --- a/drivers/led/issi/is31fl3746a-mono.c +++ b/drivers/led/issi/is31fl3746a-mono.c @@ -55,7 +55,7 @@ #endif #define IS31FL3746A_PWM_REGISTERS_PER_CHUNK 18 -#define IS31FL3746A_CHUNK_COUNT (IS31FL3746A_PWM_REGISTER_COUNT / IS31FL3746A_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3746A_CHUNK_COUNT ((IS31FL3746A_PWM_REGISTER_COUNT + IS31FL3746A_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3746A_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = { IS31FL3746A_I2C_ADDRESS_1, diff --git a/drivers/led/issi/is31fl3746a.c b/drivers/led/issi/is31fl3746a.c index d509a335c93..e89ebbbaf41 100644 --- a/drivers/led/issi/is31fl3746a.c +++ b/drivers/led/issi/is31fl3746a.c @@ -55,7 +55,7 @@ #endif #define IS31FL3746A_PWM_REGISTERS_PER_CHUNK 18 -#define IS31FL3746A_CHUNK_COUNT (IS31FL3746A_PWM_REGISTER_COUNT / IS31FL3746A_PWM_REGISTERS_PER_CHUNK) +#define IS31FL3746A_CHUNK_COUNT ((IS31FL3746A_PWM_REGISTER_COUNT + IS31FL3746A_PWM_REGISTERS_PER_CHUNK - 1) / IS31FL3746A_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[IS31FL3746A_DRIVER_COUNT] = { IS31FL3746A_I2C_ADDRESS_1, diff --git a/drivers/led/snled27351-mono.c b/drivers/led/snled27351-mono.c index 2136776dc79..6e2e936230e 100644 --- a/drivers/led/snled27351-mono.c +++ b/drivers/led/snled27351-mono.c @@ -39,7 +39,7 @@ #endif #define SNLED27351_PWM_REGISTERS_PER_CHUNK 16 -#define SNLED27351_CHUNK_COUNT (SNLED27351_PWM_REGISTER_COUNT / SNLED27351_PWM_REGISTERS_PER_CHUNK) +#define SNLED27351_CHUNK_COUNT ((SNLED27351_PWM_REGISTER_COUNT + SNLED27351_PWM_REGISTERS_PER_CHUNK - 1) / SNLED27351_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = { SNLED27351_I2C_ADDRESS_1, diff --git a/drivers/led/snled27351.c b/drivers/led/snled27351.c index 3185305f368..e3c01509b07 100644 --- a/drivers/led/snled27351.c +++ b/drivers/led/snled27351.c @@ -39,7 +39,7 @@ #endif #define SNLED27351_PWM_REGISTERS_PER_CHUNK 16 -#define SNLED27351_CHUNK_COUNT (SNLED27351_PWM_REGISTER_COUNT / SNLED27351_PWM_REGISTERS_PER_CHUNK) +#define SNLED27351_CHUNK_COUNT ((SNLED27351_PWM_REGISTER_COUNT + SNLED27351_PWM_REGISTERS_PER_CHUNK - 1) / SNLED27351_PWM_REGISTERS_PER_CHUNK) const uint8_t i2c_addresses[SNLED27351_DRIVER_COUNT] = { SNLED27351_I2C_ADDRESS_1,