is31fl3729-mono.c (7444B)
1 /* Copyright 2024 HorrorTroll <https://github.com/HorrorTroll> 2 * Copyright 2024 Harrison Chan (Xelus) 3 * Copyright 2024 Dimitris Mantzouranis <d3xter93@gmail.com> 4 * 5 * This program is free software: you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation, either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program. If not, see <http://www.gnu.org/licenses/>. 17 */ 18 19 #include "is31fl3729-mono.h" 20 #include "i2c_master.h" 21 #include "gpio.h" 22 #include "wait.h" 23 24 #define IS31FL3729_PWM_REGISTER_COUNT 143 25 #define IS31FL3729_SCALING_REGISTER_COUNT 16 26 27 #ifndef IS31FL3729_I2C_TIMEOUT 28 # define IS31FL3729_I2C_TIMEOUT 100 29 #endif 30 31 #ifndef IS31FL3729_I2C_PERSISTENCE 32 # define IS31FL3729_I2C_PERSISTENCE 0 33 #endif 34 35 #ifndef IS31FL3729_CONFIGURATION 36 # define IS31FL3729_CONFIGURATION IS31FL3729_CONFIG_SWS_15_9 37 #endif 38 39 #ifndef IS31FL3729_GLOBAL_CURRENT 40 # define IS31FL3729_GLOBAL_CURRENT 0x40 41 #endif 42 43 #ifndef IS31FL3729_SW_PULLDOWN 44 # define IS31FL3729_SW_PULLDOWN IS31FL3729_SW_PULLDOWN_2K_OHM_SW_OFF 45 #endif 46 47 #ifndef IS31FL3729_CS_PULLUP 48 # define IS31FL3729_CS_PULLUP IS31FL3729_CS_PULLUP_2K_OHM_CS_OFF 49 #endif 50 51 #ifndef IS31FL3729_SPREAD_SPECTRUM 52 # define IS31FL3729_SPREAD_SPECTRUM IS31FL3729_SPREAD_SPECTRUM_DISABLE 53 #endif 54 55 #ifndef IS31FL3729_SPREAD_SPECTRUM_RANGE 56 # define IS31FL3729_SPREAD_SPECTRUM_RANGE IS31FL3729_SPREAD_SPECTRUM_RANGE_5_PERCENT 57 #endif 58 59 #ifndef IS31FL3729_SPREAD_SPECTRUM_CYCLE_TIME 60 # define IS31FL3729_SPREAD_SPECTRUM_CYCLE_TIME IS31FL3729_SPREAD_SPECTRUM_CYCLE_TIME_1980_US 61 #endif 62 63 #ifndef IS31FL3729_PWM_FREQUENCY 64 # define IS31FL3729_PWM_FREQUENCY IS31FL3729_PWM_FREQUENCY_32K_HZ 65 #endif 66 67 const uint8_t i2c_addresses[IS31FL3729_DRIVER_COUNT] = { 68 IS31FL3729_I2C_ADDRESS_1, 69 #ifdef IS31FL3729_I2C_ADDRESS_2 70 IS31FL3729_I2C_ADDRESS_2, 71 # ifdef IS31FL3729_I2C_ADDRESS_3 72 IS31FL3729_I2C_ADDRESS_3, 73 # ifdef IS31FL3729_I2C_ADDRESS_4 74 IS31FL3729_I2C_ADDRESS_4, 75 # endif 76 # endif 77 #endif 78 }; 79 80 // These buffers match the PWM & scaling registers. 81 // Storing them like this is optimal for I2C transfers to the registers. 82 typedef struct is31fl3729_driver_t { 83 uint8_t pwm_buffer[IS31FL3729_PWM_REGISTER_COUNT]; 84 bool pwm_buffer_dirty; 85 uint8_t scaling_buffer[IS31FL3729_SCALING_REGISTER_COUNT]; 86 bool scaling_buffer_dirty; 87 } PACKED is31fl3729_driver_t; 88 89 is31fl3729_driver_t driver_buffers[IS31FL3729_DRIVER_COUNT] = {{ 90 .pwm_buffer = {0}, 91 .pwm_buffer_dirty = false, 92 .scaling_buffer = {0}, 93 .scaling_buffer_dirty = false, 94 }}; 95 96 void is31fl3729_write_register(uint8_t index, uint8_t reg, uint8_t data) { 97 #if IS31FL3729_I2C_PERSISTENCE > 0 98 for (uint8_t i = 0; i < IS31FL3729_I2C_PERSISTENCE; i++) { 99 if (i2c_write_register(i2c_addresses[index] << 1, reg, &data, 1, IS31FL3729_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break; 100 } 101 #else 102 i2c_write_register(i2c_addresses[index] << 1, reg, &data, 1, IS31FL3729_I2C_TIMEOUT); 103 #endif 104 } 105 106 void is31fl3729_write_pwm_buffer(uint8_t index) { 107 // Transmit PWM registers in 11 transfers of 13 bytes. 108 109 // Iterate over the pwm_buffer contents at 13 byte intervals. 110 for (uint8_t i = 0; i <= IS31FL3729_PWM_REGISTER_COUNT; i += 13) { 111 #if IS31FL3729_I2C_PERSISTENCE > 0 112 for (uint8_t j = 0; j < IS31FL3729_I2C_PERSISTENCE; j++) { 113 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; 114 } 115 #else 116 i2c_write_register(i2c_addresses[index] << 1, IS31FL3729_REG_PWM + i, driver_buffers[index].pwm_buffer + i, 13, IS31FL3729_I2C_TIMEOUT); 117 #endif 118 } 119 } 120 121 void is31fl3729_init_drivers(void) { 122 i2c_init(); 123 124 #if defined(IS31FL3729_SDB_PIN) 125 gpio_set_pin_output(IS31FL3729_SDB_PIN); 126 gpio_write_pin_high(IS31FL3729_SDB_PIN); 127 #endif 128 129 for (uint8_t i = 0; i < IS31FL3729_DRIVER_COUNT; i++) { 130 is31fl3729_init(i); 131 } 132 133 for (int i = 0; i < IS31FL3729_LED_COUNT; i++) { 134 is31fl3729_set_scaling_register(i, 0xFF); 135 } 136 137 for (uint8_t i = 0; i < IS31FL3729_DRIVER_COUNT; i++) { 138 is31fl3729_update_scaling_registers(i); 139 } 140 } 141 142 void is31fl3729_init(uint8_t index) { 143 // In order to avoid the LEDs being driven with garbage data 144 // in the LED driver's PWM registers, shutdown is enabled last. 145 // Set up the mode and other settings, clear the PWM registers, 146 // then disable software shutdown. 147 148 is31fl3729_write_register(index, IS31FL3729_REG_PULLDOWNUP, ((IS31FL3729_SW_PULLDOWN & 0b111) << 4) | (IS31FL3729_CS_PULLUP & 0b111)); 149 is31fl3729_write_register(index, IS31FL3729_REG_SPREAD_SPECTRUM, ((IS31FL3729_SPREAD_SPECTRUM & 0b1) << 4) | ((IS31FL3729_SPREAD_SPECTRUM_RANGE & 0b11) << 2) | (IS31FL3729_SPREAD_SPECTRUM_CYCLE_TIME & 0b11)); 150 is31fl3729_write_register(index, IS31FL3729_REG_PWM_FREQUENCY, IS31FL3729_PWM_FREQUENCY); 151 is31fl3729_write_register(index, IS31FL3729_REG_GLOBAL_CURRENT, IS31FL3729_GLOBAL_CURRENT); 152 is31fl3729_write_register(index, IS31FL3729_REG_CONFIGURATION, IS31FL3729_CONFIGURATION); 153 154 // Wait 10ms to ensure the device has woken up. 155 wait_ms(10); 156 } 157 158 void is31fl3729_set_value(int index, uint8_t value) { 159 is31fl3729_led_t led; 160 if (index >= 0 && index < IS31FL3729_LED_COUNT) { 161 memcpy_P(&led, (&g_is31fl3729_leds[index]), sizeof(led)); 162 163 if (driver_buffers[led.driver].pwm_buffer[led.v] == value) { 164 return; 165 } 166 167 driver_buffers[led.driver].pwm_buffer[led.v] = value; 168 driver_buffers[led.driver].pwm_buffer_dirty = true; 169 } 170 } 171 172 void is31fl3729_set_value_all(uint8_t value) { 173 for (int i = 0; i < IS31FL3729_LED_COUNT; i++) { 174 is31fl3729_set_value(i, value); 175 } 176 } 177 178 void is31fl3729_set_scaling_register(uint8_t index, uint8_t value) { 179 is31fl3729_led_t led; 180 memcpy_P(&led, (&g_is31fl3729_leds[index]), sizeof(led)); 181 182 // need to do a bit of checking here since 3729 scaling is per CS pin. 183 // not the usual per single LED key as per other ISSI drivers 184 // only enable them, since they should be default disabled 185 int cs_value = (led.v & 0x0F) - 1; 186 187 driver_buffers[led.driver].scaling_buffer[cs_value] = value; 188 driver_buffers[led.driver].scaling_buffer_dirty = true; 189 } 190 191 void is31fl3729_update_pwm_buffers(uint8_t index) { 192 if (driver_buffers[index].pwm_buffer_dirty) { 193 is31fl3729_write_pwm_buffer(index); 194 195 driver_buffers[index].pwm_buffer_dirty = false; 196 } 197 } 198 199 void is31fl3729_update_scaling_registers(uint8_t index) { 200 if (driver_buffers[index].scaling_buffer_dirty) { 201 for (uint8_t i = 0; i < IS31FL3729_SCALING_REGISTER_COUNT; i++) { 202 is31fl3729_write_register(index, IS31FL3729_REG_SCALING + i, driver_buffers[index].scaling_buffer[i]); 203 } 204 205 driver_buffers[index].scaling_buffer_dirty = false; 206 } 207 } 208 209 void is31fl3729_flush(void) { 210 for (uint8_t i = 0; i < IS31FL3729_DRIVER_COUNT; i++) { 211 is31fl3729_update_pwm_buffers(i); 212 } 213 }