drivers/issi/is31fl3737.c

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