logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

is31fl3737.c (9032B)

    

  1. /* Copyright 2017 Jason Williams
  2.  * Copyright 2018 Jack Humbert
  3.  * Copyright 2018 Yiancar
  4.  * Copyright 2021 Doni Crosby
  5.  *
  6.  * This program is free software: you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation, either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  */
  20. #include "is31fl3737.h"
  21. #include "i2c_master.h"
  22. #include "gpio.h"
  23. #include "wait.h"
  25. #define IS31FL3737_PWM_REGISTER_COUNT 192 // actually 144
  26. #define IS31FL3737_LED_CONTROL_REGISTER_COUNT 24
  28. #ifndef IS31FL3737_I2C_TIMEOUT
  29. #    define IS31FL3737_I2C_TIMEOUT 100
  30. #endif
  32. #ifndef IS31FL3737_I2C_PERSISTENCE
  33. #    define IS31FL3737_I2C_PERSISTENCE 0
  34. #endif
  36. #ifndef IS31FL3737_PWM_FREQUENCY
  37. #    define IS31FL3737_PWM_FREQUENCY IS31FL3737_PWM_FREQUENCY_8K4_HZ // PFS - IS31FL3737B only
  38. #endif
  40. #ifndef IS31FL3737_SW_PULLUP
  41. #    define IS31FL3737_SW_PULLUP IS31FL3737_PUR_0_OHM
  42. #endif
  44. #ifndef IS31FL3737_CS_PULLDOWN
  45. #    define IS31FL3737_CS_PULLDOWN IS31FL3737_PDR_0_OHM
  46. #endif
  48. #ifndef IS31FL3737_GLOBAL_CURRENT
  49. #    define IS31FL3737_GLOBAL_CURRENT 0xFF
  50. #endif
  52. const uint8_t i2c_addresses[IS31FL3737_DRIVER_COUNT] = {
  53.     IS31FL3737_I2C_ADDRESS_1,
  54. #ifdef IS31FL3737_I2C_ADDRESS_2
  55.     IS31FL3737_I2C_ADDRESS_2,
  56. #    ifdef IS31FL3737_I2C_ADDRESS_3
  57.     IS31FL3737_I2C_ADDRESS_3,
  58. #        ifdef IS31FL3737_I2C_ADDRESS_4
  59.     IS31FL3737_I2C_ADDRESS_4,
  60. #        endif
  61. #    endif
  62. #endif
  63. };
  65. // These buffers match the IS31FL3737 PWM registers.
  66. // The control buffers match the page 0 LED On/Off registers.
  67. // Storing them like this is optimal for I2C transfers to the registers.
  68. // We could optimize this and take out the unused registers from these
  69. // buffers and the transfers in is31fl3737_write_pwm_buffer() but it's
  70. // probably not worth the extra complexity.
  71. typedef struct is31fl3737_driver_t {
  72.     uint8_t pwm_buffer[IS31FL3737_PWM_REGISTER_COUNT];
  73.     bool    pwm_buffer_dirty;
  74.     uint8_t led_control_buffer[IS31FL3737_LED_CONTROL_REGISTER_COUNT];
  75.     bool    led_control_buffer_dirty;
  76. } PACKED is31fl3737_driver_t;
  78. is31fl3737_driver_t driver_buffers[IS31FL3737_DRIVER_COUNT] = {{
  79.     .pwm_buffer               = {0},
  80.     .pwm_buffer_dirty         = false,
  81.     .led_control_buffer       = {0},
  82.     .led_control_buffer_dirty = false,
  83. }};
  85. void is31fl3737_write_register(uint8_t index, uint8_t reg, uint8_t data) {
  86. #if IS31FL3737_I2C_PERSISTENCE > 0
  87.     for (uint8_t i = 0; i < IS31FL3737_I2C_PERSISTENCE; i++) {
  88.         if (i2c_write_register(i2c_addresses[index] << 1, reg, &data, 1, IS31FL3737_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
  89.     }
  90. #else
  91.     i2c_write_register(i2c_addresses[index] << 1, reg, &data, 1, IS31FL3737_I2C_TIMEOUT);
  92. #endif
  93. }
  95. void is31fl3737_select_page(uint8_t index, uint8_t page) {
  96.     is31fl3737_write_register(index, IS31FL3737_REG_COMMAND_WRITE_LOCK, IS31FL3737_COMMAND_WRITE_LOCK_MAGIC);
  97.     is31fl3737_write_register(index, IS31FL3737_REG_COMMAND, page);
  98. }
  100. void is31fl3737_write_pwm_buffer(uint8_t index) {
  101.     // Assumes page 1 is already selected.
  102.     // Transmit PWM registers in 12 transfers of 16 bytes.
  104.     // Iterate over the pwm_buffer contents at 16 byte intervals.
  105.     for (uint8_t i = 0; i < IS31FL3737_PWM_REGISTER_COUNT; i += 16) {
  106. #if IS31FL3737_I2C_PERSISTENCE > 0
  107.         for (uint8_t j = 0; j < IS31FL3737_I2C_PERSISTENCE; j++) {
  108.             if (i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3737_I2C_TIMEOUT) == I2C_STATUS_SUCCESS) break;
  109.         }
  110. #else
  111.         i2c_write_register(i2c_addresses[index] << 1, i, driver_buffers[index].pwm_buffer + i, 16, IS31FL3737_I2C_TIMEOUT);
  112. #endif
  113.     }
  114. }
  116. void is31fl3737_init_drivers(void) {
  117.     i2c_init();
  119. #if defined(IS31FL3737_SDB_PIN)
  120.     gpio_set_pin_output(IS31FL3737_SDB_PIN);
  121.     gpio_write_pin_high(IS31FL3737_SDB_PIN);
  122. #endif
  124.     for (uint8_t i = 0; i < IS31FL3737_DRIVER_COUNT; i++) {
  125.         is31fl3737_init(i);
  126.     }
  128.     for (int i = 0; i < IS31FL3737_LED_COUNT; i++) {
  129.         is31fl3737_set_led_control_register(i, true, true, true);
  130.     }
  132.     for (uint8_t i = 0; i < IS31FL3737_DRIVER_COUNT; i++) {
  133.         is31fl3737_update_led_control_registers(i);
  134.     }
  135. }
  137. void is31fl3737_init(uint8_t index) {
  138.     // In order to avoid the LEDs being driven with garbage data
  139.     // in the LED driver's PWM registers, shutdown is enabled last.
  140.     // Set up the mode and other settings, clear the PWM registers,
  141.     // then disable software shutdown.
  143.     is31fl3737_select_page(index, IS31FL3737_COMMAND_LED_CONTROL);
  145.     // Turn off all LEDs.
  146.     for (uint8_t i = 0; i < IS31FL3737_LED_CONTROL_REGISTER_COUNT; i++) {
  147.         is31fl3737_write_register(index, i, 0x00);
  148.     }
  150.     is31fl3737_select_page(index, IS31FL3737_COMMAND_PWM);
  152.     // Set PWM on all LEDs to 0
  153.     // No need to setup Breath registers to PWM as that is the default.
  154.     for (uint8_t i = 0; i < IS31FL3737_PWM_REGISTER_COUNT; i++) {
  155.         is31fl3737_write_register(index, i, 0x00);
  156.     }
  158.     is31fl3737_select_page(index, IS31FL3737_COMMAND_FUNCTION);
  160.     // Set de-ghost pull-up resistors (SWx)
  161.     is31fl3737_write_register(index, IS31FL3737_FUNCTION_REG_SW_PULLUP, IS31FL3737_SW_PULLUP);
  162.     // Set de-ghost pull-down resistors (CSx)
  163.     is31fl3737_write_register(index, IS31FL3737_FUNCTION_REG_CS_PULLDOWN, IS31FL3737_CS_PULLDOWN);
  164.     // Set global current to maximum.
  165.     is31fl3737_write_register(index, IS31FL3737_FUNCTION_REG_GLOBAL_CURRENT, IS31FL3737_GLOBAL_CURRENT);
  166.     // Disable software shutdown.
  167.     is31fl3737_write_register(index, IS31FL3737_FUNCTION_REG_CONFIGURATION, ((IS31FL3737_PWM_FREQUENCY & 0b111) << 3) | 0x01);
  169.     // Wait 10ms to ensure the device has woken up.
  170.     wait_ms(10);
  171. }
  173. void is31fl3737_set_color(int index, uint8_t red, uint8_t green, uint8_t blue) {
  174.     is31fl3737_led_t led;
  176.     if (index >= 0 && index < IS31FL3737_LED_COUNT) {
  177.         memcpy_P(&led, (&g_is31fl3737_leds[index]), sizeof(led));
  179.         if (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) {
  180.             return;
  181.         }
  183.         driver_buffers[led.driver].pwm_buffer[led.r] = red;
  184.         driver_buffers[led.driver].pwm_buffer[led.g] = green;
  185.         driver_buffers[led.driver].pwm_buffer[led.b] = blue;
  186.         driver_buffers[led.driver].pwm_buffer_dirty  = true;
  187.     }
  188. }
  190. void is31fl3737_set_color_all(uint8_t red, uint8_t green, uint8_t blue) {
  191.     for (int i = 0; i < IS31FL3737_LED_COUNT; i++) {
  192.         is31fl3737_set_color(i, red, green, blue);
  193.     }
  194. }
  196. void is31fl3737_set_led_control_register(uint8_t index, bool red, bool green, bool blue) {
  197.     is31fl3737_led_t led;
  198.     memcpy_P(&led, (&g_is31fl3737_leds[index]), sizeof(led));
  200.     uint8_t control_register_r = led.r / 8;
  201.     uint8_t control_register_g = led.g / 8;
  202.     uint8_t control_register_b = led.b / 8;
  203.     uint8_t bit_r              = led.r % 8;
  204.     uint8_t bit_g              = led.g % 8;
  205.     uint8_t bit_b              = led.b % 8;
  207.     if (red) {
  208.         driver_buffers[led.driver].led_control_buffer[control_register_r] |= (1 << bit_r);
  209.     } else {
  210.         driver_buffers[led.driver].led_control_buffer[control_register_r] &= ~(1 << bit_r);
  211.     }
  212.     if (green) {
  213.         driver_buffers[led.driver].led_control_buffer[control_register_g] |= (1 << bit_g);
  214.     } else {
  215.         driver_buffers[led.driver].led_control_buffer[control_register_g] &= ~(1 << bit_g);
  216.     }
  217.     if (blue) {
  218.         driver_buffers[led.driver].led_control_buffer[control_register_b] |= (1 << bit_b);
  219.     } else {
  220.         driver_buffers[led.driver].led_control_buffer[control_register_b] &= ~(1 << bit_b);
  221.     }
  223.     driver_buffers[led.driver].led_control_buffer_dirty = true;
  224. }
  226. void is31fl3737_update_pwm_buffers(uint8_t index) {
  227.     if (driver_buffers[index].pwm_buffer_dirty) {
  228.         is31fl3737_select_page(index, IS31FL3737_COMMAND_PWM);
  230.         is31fl3737_write_pwm_buffer(index);
  232.         driver_buffers[index].pwm_buffer_dirty = false;
  233.     }
  234. }
  236. void is31fl3737_update_led_control_registers(uint8_t index) {
  237.     if (driver_buffers[index].led_control_buffer_dirty) {
  238.         is31fl3737_select_page(index, IS31FL3737_COMMAND_LED_CONTROL);
  240.         for (uint8_t i = 0; i < IS31FL3737_LED_CONTROL_REGISTER_COUNT; i++) {
  241.             is31fl3737_write_register(index, i, driver_buffers[index].led_control_buffer[i]);
  242.         }
  244.         driver_buffers[index].led_control_buffer_dirty = false;
  245.     }
  246. }
  248. void is31fl3737_flush(void) {
  249.     for (uint8_t i = 0; i < IS31FL3737_DRIVER_COUNT; i++) {
  250.         is31fl3737_update_pwm_buffers(i);
  251.     }
  252. }