diff options
Diffstat (limited to 'drivers/led/issi/is31fl3737.c')
-rw-r--r-- | drivers/led/issi/is31fl3737.c | 222 |
1 files changed, 222 insertions, 0 deletions
diff --git a/drivers/led/issi/is31fl3737.c b/drivers/led/issi/is31fl3737.c new file mode 100644 index 000000000..0bb4ddd42 --- /dev/null +++ b/drivers/led/issi/is31fl3737.c | |||
@@ -0,0 +1,222 @@ | |||
1 | /* Copyright 2017 Jason Williams | ||
2 | * Copyright 2018 Jack Humbert | ||
3 | * Copyright 2018 Yiancar | ||
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 "is31fl3737.h" | ||
20 | #include "i2c_master.h" | ||
21 | #include "wait.h" | ||
22 | |||
23 | // This is a 7-bit address, that gets left-shifted and bit 0 | ||
24 | // set to 0 for write, 1 for read (as per I2C protocol) | ||
25 | // The address will vary depending on your wiring: | ||
26 | // 00 <-> GND | ||
27 | // 01 <-> SCL | ||
28 | // 10 <-> SDA | ||
29 | // 11 <-> VCC | ||
30 | // ADDR1 represents A1:A0 of the 7-bit address. | ||
31 | // ADDR2 represents A3:A2 of the 7-bit address. | ||
32 | // The result is: 0b101(ADDR2)(ADDR1) | ||
33 | #define ISSI_ADDR_DEFAULT 0x50 | ||
34 | |||
35 | #define ISSI_COMMANDREGISTER 0xFD | ||
36 | #define ISSI_COMMANDREGISTER_WRITELOCK 0xFE | ||
37 | #define ISSI_INTERRUPTMASKREGISTER 0xF0 | ||
38 | #define ISSI_INTERRUPTSTATUSREGISTER 0xF1 | ||
39 | |||
40 | #define ISSI_PAGE_LEDCONTROL 0x00 // PG0 | ||
41 | #define ISSI_PAGE_PWM 0x01 // PG1 | ||
42 | #define ISSI_PAGE_AUTOBREATH 0x02 // PG2 | ||
43 | #define ISSI_PAGE_FUNCTION 0x03 // PG3 | ||
44 | |||
45 | #define ISSI_REG_CONFIGURATION 0x00 // PG3 | ||
46 | #define ISSI_REG_GLOBALCURRENT 0x01 // PG3 | ||
47 | #define ISSI_REG_RESET 0x11 // PG3 | ||
48 | #define ISSI_REG_SWPULLUP 0x0F // PG3 | ||
49 | #define ISSI_REG_CSPULLUP 0x10 // PG3 | ||
50 | |||
51 | #ifndef ISSI_TIMEOUT | ||
52 | # define ISSI_TIMEOUT 100 | ||
53 | #endif | ||
54 | |||
55 | #ifndef ISSI_PERSISTENCE | ||
56 | # define ISSI_PERSISTENCE 0 | ||
57 | #endif | ||
58 | |||
59 | // Transfer buffer for TWITransmitData() | ||
60 | uint8_t g_twi_transfer_buffer[20]; | ||
61 | |||
62 | // These buffers match the IS31FL3737 PWM registers. | ||
63 | // The control buffers match the PG0 LED On/Off registers. | ||
64 | // Storing them like this is optimal for I2C transfers to the registers. | ||
65 | // We could optimize this and take out the unused registers from these | ||
66 | // buffers and the transfers in IS31FL3737_write_pwm_buffer() but it's | ||
67 | // probably not worth the extra complexity. | ||
68 | |||
69 | uint8_t g_pwm_buffer[DRIVER_COUNT][192]; | ||
70 | bool g_pwm_buffer_update_required[DRIVER_COUNT] = {false}; | ||
71 | |||
72 | uint8_t g_led_control_registers[DRIVER_COUNT][24] = {0}; | ||
73 | bool g_led_control_registers_update_required[DRIVER_COUNT] = {false}; | ||
74 | |||
75 | void IS31FL3737_write_register(uint8_t addr, uint8_t reg, uint8_t data) { | ||
76 | g_twi_transfer_buffer[0] = reg; | ||
77 | g_twi_transfer_buffer[1] = data; | ||
78 | |||
79 | #if ISSI_PERSISTENCE > 0 | ||
80 | for (uint8_t i = 0; i < ISSI_PERSISTENCE; i++) { | ||
81 | if (i2c_transmit(addr << 1, g_twi_transfer_buffer, 2, ISSI_TIMEOUT) == 0) break; | ||
82 | } | ||
83 | #else | ||
84 | i2c_transmit(addr << 1, g_twi_transfer_buffer, 2, ISSI_TIMEOUT); | ||
85 | #endif | ||
86 | } | ||
87 | |||
88 | void IS31FL3737_write_pwm_buffer(uint8_t addr, uint8_t *pwm_buffer) { | ||
89 | // assumes PG1 is already selected | ||
90 | |||
91 | // transmit PWM registers in 12 transfers of 16 bytes | ||
92 | // g_twi_transfer_buffer[] is 20 bytes | ||
93 | |||
94 | // iterate over the pwm_buffer contents at 16 byte intervals | ||
95 | for (int i = 0; i < 192; i += 16) { | ||
96 | g_twi_transfer_buffer[0] = i; | ||
97 | // copy the data from i to i+15 | ||
98 | // device will auto-increment register for data after the first byte | ||
99 | // thus this sets registers 0x00-0x0F, 0x10-0x1F, etc. in one transfer | ||
100 | for (int j = 0; j < 16; j++) { | ||
101 | g_twi_transfer_buffer[1 + j] = pwm_buffer[i + j]; | ||
102 | } | ||
103 | |||
104 | #if ISSI_PERSISTENCE > 0 | ||
105 | for (uint8_t i = 0; i < ISSI_PERSISTENCE; i++) { | ||
106 | if (i2c_transmit(addr << 1, g_twi_transfer_buffer, 17, ISSI_TIMEOUT) == 0) break; | ||
107 | } | ||
108 | #else | ||
109 | i2c_transmit(addr << 1, g_twi_transfer_buffer, 17, ISSI_TIMEOUT); | ||
110 | #endif | ||
111 | } | ||
112 | } | ||
113 | |||
114 | void IS31FL3737_init(uint8_t addr) { | ||
115 | // In order to avoid the LEDs being driven with garbage data | ||
116 | // in the LED driver's PWM registers, shutdown is enabled last. | ||
117 | // Set up the mode and other settings, clear the PWM registers, | ||
118 | // then disable software shutdown. | ||
119 | |||
120 | // Unlock the command register. | ||
121 | IS31FL3737_write_register(addr, ISSI_COMMANDREGISTER_WRITELOCK, 0xC5); | ||
122 | |||
123 | // Select PG0 | ||
124 | IS31FL3737_write_register(addr, ISSI_COMMANDREGISTER, ISSI_PAGE_LEDCONTROL); | ||
125 | // Turn off all LEDs. | ||
126 | for (int i = 0x00; i <= 0x17; i++) { | ||
127 | IS31FL3737_write_register(addr, i, 0x00); | ||
128 | } | ||
129 | |||
130 | // Unlock the command register. | ||
131 | IS31FL3737_write_register(addr, ISSI_COMMANDREGISTER_WRITELOCK, 0xC5); | ||
132 | |||
133 | // Select PG1 | ||
134 | IS31FL3737_write_register(addr, ISSI_COMMANDREGISTER, ISSI_PAGE_PWM); | ||
135 | // Set PWM on all LEDs to 0 | ||
136 | // No need to setup Breath registers to PWM as that is the default. | ||
137 | for (int i = 0x00; i <= 0xBF; i++) { | ||
138 | IS31FL3737_write_register(addr, i, 0x00); | ||
139 | } | ||
140 | |||
141 | // Unlock the command register. | ||
142 | IS31FL3737_write_register(addr, ISSI_COMMANDREGISTER_WRITELOCK, 0xC5); | ||
143 | |||
144 | // Select PG3 | ||
145 | IS31FL3737_write_register(addr, ISSI_COMMANDREGISTER, ISSI_PAGE_FUNCTION); | ||
146 | // Set global current to maximum. | ||
147 | IS31FL3737_write_register(addr, ISSI_REG_GLOBALCURRENT, 0xFF); | ||
148 | // Disable software shutdown. | ||
149 | IS31FL3737_write_register(addr, ISSI_REG_CONFIGURATION, 0x01); | ||
150 | |||
151 | // Wait 10ms to ensure the device has woken up. | ||
152 | wait_ms(10); | ||
153 | } | ||
154 | |||
155 | void IS31FL3737_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) { | ||
156 | if (index >= 0 && index < DRIVER_LED_TOTAL) { | ||
157 | is31_led led = g_is31_leds[index]; | ||
158 | |||
159 | g_pwm_buffer[led.driver][led.r] = red; | ||
160 | g_pwm_buffer[led.driver][led.g] = green; | ||
161 | g_pwm_buffer[led.driver][led.b] = blue; | ||
162 | g_pwm_buffer_update_required[led.driver] = true; | ||
163 | } | ||
164 | } | ||
165 | |||
166 | void IS31FL3737_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { | ||
167 | for (int i = 0; i < DRIVER_LED_TOTAL; i++) { | ||
168 | IS31FL3737_set_color(i, red, green, blue); | ||
169 | } | ||
170 | } | ||
171 | |||
172 | void IS31FL3737_set_led_control_register(uint8_t index, bool red, bool green, bool blue) { | ||
173 | is31_led led = g_is31_leds[index]; | ||
174 | |||
175 | uint8_t control_register_r = led.r / 8; | ||
176 | uint8_t control_register_g = led.g / 8; | ||
177 | uint8_t control_register_b = led.b / 8; | ||
178 | uint8_t bit_r = led.r % 8; | ||
179 | uint8_t bit_g = led.g % 8; | ||
180 | uint8_t bit_b = led.b % 8; | ||
181 | |||
182 | if (red) { | ||
183 | g_led_control_registers[led.driver][control_register_r] |= (1 << bit_r); | ||
184 | } else { | ||
185 | g_led_control_registers[led.driver][control_register_r] &= ~(1 << bit_r); | ||
186 | } | ||
187 | if (green) { | ||
188 | g_led_control_registers[led.driver][control_register_g] |= (1 << bit_g); | ||
189 | } else { | ||
190 | g_led_control_registers[led.driver][control_register_g] &= ~(1 << bit_g); | ||
191 | } | ||
192 | if (blue) { | ||
193 | g_led_control_registers[led.driver][control_register_b] |= (1 << bit_b); | ||
194 | } else { | ||
195 | g_led_control_registers[led.driver][control_register_b] &= ~(1 << bit_b); | ||
196 | } | ||
197 | |||
198 | g_led_control_registers_update_required[led.driver] = true; | ||
199 | } | ||
200 | |||
201 | void IS31FL3737_update_pwm_buffers(uint8_t addr, uint8_t index) { | ||
202 | if (g_pwm_buffer_update_required[index]) { | ||
203 | // Firstly we need to unlock the command register and select PG1 | ||
204 | IS31FL3737_write_register(addr, ISSI_COMMANDREGISTER_WRITELOCK, 0xC5); | ||
205 | IS31FL3737_write_register(addr, ISSI_COMMANDREGISTER, ISSI_PAGE_PWM); | ||
206 | |||
207 | IS31FL3737_write_pwm_buffer(addr, g_pwm_buffer[index]); | ||
208 | } | ||
209 | g_pwm_buffer_update_required[index] = false; | ||
210 | } | ||
211 | |||
212 | void IS31FL3737_update_led_control_registers(uint8_t addr, uint8_t index) { | ||
213 | if (g_led_control_registers_update_required[index]) { | ||
214 | // Firstly we need to unlock the command register and select PG0 | ||
215 | IS31FL3737_write_register(addr, ISSI_COMMANDREGISTER_WRITELOCK, 0xC5); | ||
216 | IS31FL3737_write_register(addr, ISSI_COMMANDREGISTER, ISSI_PAGE_LEDCONTROL); | ||
217 | for (int i = 0; i < 24; i++) { | ||
218 | IS31FL3737_write_register(addr, i, g_led_control_registers[index][i]); | ||
219 | } | ||
220 | } | ||
221 | g_led_control_registers_update_required[index] = false; | ||
222 | } | ||