keyboards/zeal60/rgb_backlight.c

   1 /* Copyright 2017 Jason Williams (Wilba)
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16 #if RGB_BACKLIGHT_ENABLED
  17
  18 #if defined (RGB_BACKLIGHT_ZEAL60) || defined (RGB_BACKLIGHT_ZEAL65) || defined (RGB_BACKLIGHT_M60_A)
  19 #else
  20 #error None of the following was defined: RGB_BACKLIGHT_ZEAL60, RGB_BACKLIGHT_ZEAL65, RGB_BACKLIGHT_M60_A
  21 #endif
  22
  23 #include "zeal60.h"
  24 #include "rgb_backlight.h"
  25 #include "rgb_backlight_api.h"
  26 #include "rgb_backlight_keycodes.h"
  27
  28 #include <avr/io.h>
  29 #include <util/delay.h>
  30 #include <avr/interrupt.h>
  31 #include "progmem.h"
  32
  33 #include "quantum/color.h"
  34 #include "drivers/avr/i2c_master.h"
  35 #include "drivers/issi/is31fl3731.h"
  36
  37 #define BACKLIGHT_EFFECT_MAX 10
  38
  39 backlight_config g_config = {
  40         .use_split_backspace = RGB_BACKLIGHT_USE_SPLIT_BACKSPACE,
  41         .use_split_left_shift = RGB_BACKLIGHT_USE_SPLIT_LEFT_SHIFT,
  42         .use_split_right_shift = RGB_BACKLIGHT_USE_SPLIT_RIGHT_SHIFT,
  43         .use_7u_spacebar = RGB_BACKLIGHT_USE_7U_SPACEBAR,
  44         .use_iso_enter = RGB_BACKLIGHT_USE_ISO_ENTER,
  45         .disable_hhkb_blocker_leds = RGB_BACKLIGHT_DISABLE_HHKB_BLOCKER_LEDS,
  46         .disable_when_usb_suspended = RGB_BACKLIGHT_DISABLE_WHEN_USB_SUSPENDED,
  47         .disable_after_timeout = RGB_BACKLIGHT_DISABLE_AFTER_TIMEOUT,
  48         .brightness = 255,
  49         .effect = RGB_BACKLIGHT_EFFECT,
  50         .effect_speed = 0,
  51         .color_1 = { .h = 0, .s = 255, .v = 255 },
  52         .color_2 = { .h = 127, .s = 255, .v = 255 },
  53         .caps_lock_indicator = { .color = { .h = 0, .s = 0, .v = 255 }, .index = 255 },
  54         .layer_1_indicator = { .color = { .h = 0, .s = 0, .v = 255 }, .index = 255 },
  55         .layer_2_indicator = { .color = { .h = 0, .s = 0, .v = 255 }, .index = 255 },
  56         .layer_3_indicator = { .color = { .h = 0, .s = 0, .v = 255 }, .index = 255 },
  57         .alphas_mods = {
  58                 RGB_BACKLIGHT_ALPHAS_MODS_ROW_0,
  59                 RGB_BACKLIGHT_ALPHAS_MODS_ROW_1,
  60                 RGB_BACKLIGHT_ALPHAS_MODS_ROW_2,
  61                 RGB_BACKLIGHT_ALPHAS_MODS_ROW_3,
  62                 RGB_BACKLIGHT_ALPHAS_MODS_ROW_4 }
  63 };
  64
  65 bool g_suspend_state = false;
  66 uint8_t g_indicator_state = 0;
  67
  68 // Global tick at 20 Hz
  69 uint32_t g_tick = 0;
  70
  71 // Ticks since this key was last hit.
  72 uint8_t g_key_hit[72];
  73
  74 // Ticks since any key was last hit.
  75 uint32_t g_any_key_hit = 0;
  76
  77 // This is a 7-bit address, that gets left-shifted and bit 0
  78 // set to 0 for write, 1 for read (as per I2C protocol)
  79 #define ISSI_ADDR_1 0x74
  80 #define ISSI_ADDR_2 0x76
  81
  82 const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
  83 /* Refer to IS31 manual for these locations
  84  *   driver
  85  *   |  R location
  86  *   |  |      G location
  87  *   |  |      |      B location
  88  *   |  |      |      | */
  89         {0, C2_1,  C3_1,  C4_1},  // LA0
  90         {0, C1_1,  C3_2, C4_2},   // LA1
  91         {0, C1_2,  C2_2, C4_3},   // LA2
  92         {0, C1_3,  C2_3, C3_3},   // LA3
  93         {0, C1_4,  C2_4, C3_4},   // LA4
  94         {0, C1_5,  C2_5, C3_5},   // LA5
  95         {0, C1_6,  C2_6, C3_6},   // LA6
  96         {0, C1_7,  C2_7, C3_7},   // LA7
  97         {0, C1_8,  C2_8, C3_8},   // LA8
  98         {0, C9_1,  C8_1,  C7_1},  // LA9
  99         {0, C9_2,  C8_2, C7_2},   // LA10
 100         {0, C9_3,  C8_3, C7_3},   // LA11
 101         {0, C9_4,  C8_4, C7_4},   // LA12
 102         {0, C9_5,  C8_5, C7_5},   // LA13
 103         {0, C9_6,  C8_6, C7_6},   // LA14
 104         {0, C9_7,  C8_7, C6_6},   // LA15
 105         {0, C9_8,  C7_7, C6_7},   // LA16
 106         {0, C8_8,  C7_8, C6_8},   // LA17
 107
 108         {0, C2_9,  C3_9,  C4_9},  // LB0
 109         {0, C1_9,  C3_10, C4_10}, // LB1
 110         {0, C1_10, C2_10, C4_11}, // LB2
 111         {0, C1_11, C2_11, C3_11}, // LB3
 112         {0, C1_12, C2_12, C3_12}, // LB4
 113         {0, C1_13, C2_13, C3_13}, // LB5
 114         {0, C1_14, C2_14, C3_14}, // LB6
 115         {0, C1_15, C2_15, C3_15}, // LB7
 116         {0, C1_16, C2_16, C3_16}, // LB8
 117         {0, C9_9,  C8_9,  C7_9},  // LB9
 118         {0, C9_10, C8_10, C7_10}, // LB10
 119         {0, C9_11, C8_11, C7_11}, // LB11
 120         {0, C9_12, C8_12, C7_12}, // LB12
 121         {0, C9_13, C8_13, C7_13}, // LB13
 122         {0, C9_14, C8_14, C7_14}, // LB14
 123         {0, C9_15, C8_15, C6_14}, // LB15
 124         {0, C9_16, C7_15, C6_15}, // LB16
 125         {0, C8_16, C7_16, C6_16}, // LB17
 126
 127         {1, C2_1,  C3_1,  C4_1},  // LC0
 128         {1, C1_1,  C3_2, C4_2},   // LC1
 129         {1, C1_2,  C2_2, C4_3},   // LC2
 130         {1, C1_3,  C2_3, C3_3},   // LC3
 131         {1, C1_4,  C2_4, C3_4},   // LC4
 132         {1, C1_5,  C2_5, C3_5},   // LC5
 133         {1, C1_6,  C2_6, C3_6},   // LC6
 134         {1, C1_7,  C2_7, C3_7},   // LC7
 135         {1, C1_8,  C2_8, C3_8},   // LC8
 136         {1, C9_1,  C8_1,  C7_1},  // LC9
 137         {1, C9_2,  C8_2, C7_2},   // LC10
 138         {1, C9_3,  C8_3, C7_3},   // LC11
 139         {1, C9_4,  C8_4, C7_4},   // LC12
 140         {1, C9_5,  C8_5, C7_5},   // LC13
 141         {1, C9_6,  C8_6, C7_6},   // LC14
 142         {1, C9_7,  C8_7, C6_6},   // LC15
 143         {1, C9_8,  C7_7, C6_7},   // LC16
 144         {1, C8_8,  C7_8, C6_8},   // LC17
 145
 146         {1, C2_9,  C3_9,  C4_9},  // LD0
 147         {1, C1_9,  C3_10, C4_10}, // LD1
 148         {1, C1_10, C2_10, C4_11}, // LD2
 149         {1, C1_11, C2_11, C3_11}, // LD3
 150         {1, C1_12, C2_12, C3_12}, // LD4
 151         {1, C1_13, C2_13, C3_13}, // LD5
 152         {1, C1_14, C2_14, C3_14}, // LD6
 153         {1, C1_15, C2_15, C3_15}, // LD7
 154         {1, C1_16, C2_16, C3_16}, // LD8
 155         {1, C9_9,  C8_9,  C7_9},  // LD9
 156         {1, C9_10, C8_10, C7_10}, // LD10
 157         {1, C9_11, C8_11, C7_11}, // LD11
 158         {1, C9_12, C8_12, C7_12}, // LD12
 159         {1, C9_13, C8_13, C7_13}, // LD13
 160         {1, C9_14, C8_14, C7_14}, // LD14
 161         {1, C9_15, C8_15, C6_14}, // LD15
 162         {1, C9_16, C7_15, C6_15}, // LD16
 163         {1, C8_16, C7_16, C6_16}, // LD17
 164 };
 165
 166
 167
 168 typedef struct Point {
 169         uint8_t x;
 170         uint8_t y;
 171 } Point;
 172
 173
 174 // index in range 0..71 (LA0..LA17, LB0..LB17, LC0..LC17, LD0..LD17)
 175 // point values in range x=0..224 y=0..64
 176 // origin is center of top-left key (i.e Esc)
 177 #if defined (RGB_BACKLIGHT_ZEAL65)
 178 const Point g_map_led_to_point[72] PROGMEM = {
 179         // LA0..LA17
 180         {120,16}, {104,16}, {88,16}, {72,16}, {56,16}, {40,16}, {24,16}, {4,16}, {4,32},
 181         {128,0}, {112,0}, {96,0}, {80,0}, {64,0}, {48,0}, {32,0}, {16,0}, {0,0},
 182         // LB0..LB17
 183         {144,0}, {160,0}, {176,0}, {192,0}, {216,0}, {224,0}, {240,0}, {240,16}, {240,32},
 184         {136,16}, {152,16}, {168,16}, {184,16}, {200,16}, {220,16}, {240,48}, {240,64}, {224,64},
 185         // LC0..LC17
 186         {96,64}, {100,48}, {84,48}, {68,48}, {52,48}, {36,48}, {255,255}, {48,60}, {28,64},
 187         {108,32}, {92,32}, {76,32}, {60,32}, {44,32}, {28,32}, {20,44}, {10,48}, {4,64},
 188         // LD0..LD17
 189         {124,32}, {140,32}, {156,32}, {172,32}, {188,32}, {214,32}, {180,48}, {202,48}, {224,48},
 190         {116,48}, {132,48}, {148,48}, {164,48}, {255,255}, {144,60}, {164,64}, {188,64}, {208,64}
 191 };
 192 const Point g_map_led_to_point_polar[72] PROGMEM = {
 193         // LA0..LA17
 194         {64,128}, {75,132}, {84,145}, {91,164}, {97,187}, {102,213}, {105,242}, {109,255}, {128,247},
 195         {61,255}, {67,255}, {72,255}, {77,255}, {82,255}, {86,255}, {90,255}, {93,255}, {96,255},
 196         // LB0..LB17
 197         {56,255}, {51,255}, {46,255}, {42,255}, {37,255}, {35,255}, {32,255}, {19,255}, {0,255},
 198         {53,132}, {44,145}, {37,164}, {31,187}, {26,213}, {22,249}, {237,255}, {224,255}, {221,255},
 199         // LC0..LC17
 200         {184,255}, {179,135}, {170,149}, {163,169}, {157,193}, {153,220}, {255,255}, {167,255}, {165,255},
 201         {128,26}, {128,60}, {128,94}, {128,128}, {128,162}, {128,196}, {145,233}, {148,255}, {161,255},
 202         // LD0..LD17
 203         {0,9}, {0,43}, {0,77}, {0,111}, {0,145}, {255,201}, {224,181}, {230,217}, {235,255},
 204         {189,128}, {200,131}, {210,141}, {218,159}, {201,228}, {201,228}, {206,255}, {213,255}, {218,255}
 205 };
 206 #elif defined (RGB_BACKLIGHT_ZEAL60) || defined (RGB_BACKLIGHT_M60_A)
 207 const Point g_map_led_to_point[72] PROGMEM = {
 208         // LA0..LA17
 209         {120,16}, {104,16}, {88,16}, {72,16}, {56,16}, {40,16}, {24,16}, {4,16}, {4,32},
 210         {128,0}, {112,0}, {96,0}, {80,0}, {64,0}, {48,0}, {32,0}, {16,0}, {0,0},
 211         // LB0..LB17
 212         {144,0}, {160,0}, {176,0}, {192,0}, {216,0}, {224,0}, {255,255}, {255,255}, {255,255},
 213         {136,16}, {152,16}, {168,16}, {184,16}, {200,16}, {220,16}, {255,255}, {255,255}, {255,255},
 214         // LC0..LC17
 215         {102,64}, {100,48}, {84,48}, {68,48}, {52,48}, {36,48}, {60,64}, {43,64}, {23,64},
 216         {108,32}, {92,32}, {76,32}, {60,32}, {44,32}, {28,32}, {20,48}, {2,48}, {3,64},
 217         // LD0..LD17
 218         {124,32}, {140,32}, {156,32}, {172,32}, {188,32}, {214,32}, {180,48}, {210,48}, {224,48},
 219         {116,48}, {132,48}, {148,48}, {164,48}, {144,64}, {161,64}, {181,64}, {201,64}, {221,64}
 220 };
 221 const Point g_map_led_to_point_polar[72] PROGMEM = {
 222         // LA0..LA17
 223         {58,129}, {70,129}, {80,139}, {89,157}, {96,181}, {101,208}, {105,238}, {109,255}, {128,247}, {58,255},
 224         {64,255}, {70,255}, {75,255}, {80,255}, {85,255}, {89,255}, {93,255}, {96,255},
 225         // LB0..LB17
 226         {53,255}, {48,255}, {43,255}, {39,255}, {34,255}, {32,255}, {255,255}, {255,255}, {255,255},
 227         {48,139}, {39,157}, {32,181}, {27,208}, {23,238}, {19,255}, {255,255}, {255,255}, {255,255},
 228         // LC0..LC17
 229         {188,255}, {183,131}, {173,143}, {165,163}, {159,188}, {154,216}, {172,252}, {170,255}, {165,255},
 230         {128,9}, {128,46}, {128,82}, {128,119}, {128,155}, {128,192}, {150,244}, {147,255}, {161,255},
 231         // LD0..LD17
 232         {0,27}, {0,64}, {0,101}, {0,137}, {0,174}, {255,233}, {228,201}, {235,255}, {237,255},
 233         {195,128}, {206,136}, {215,152}, {222,175}, {205,234}, {209,255}, {214,255}, {219,255}, {223,255}
 234 };
 235 #endif
 236
 237 // This may seem counter-intuitive, but it's quite flexible.
 238 // For each LED, get it's position to decide what color to make it.
 239 // This solves the issue of LEDs (and switches) not aligning to a grid,
 240 // or having a large "bitmap" and sampling them.
 241 void map_led_to_point( uint8_t index, Point *point )
 242 {
 243         // Slightly messy way to get Point structs out of progmem.
 244         uint8_t *addr = (uint8_t*)&g_map_led_to_point[index];
 245         point->x = pgm_read_byte(addr);
 246         point->y = pgm_read_byte(addr+1);
 247
 248         switch (index)
 249         {
 250                 case 18+4: // LB4A
 251                         if ( g_config.use_split_backspace )
 252                                 point->x -= 8;
 253                         break;
 254                 case 18+14: // LB14A
 255                         if ( g_config.use_iso_enter )
 256                                 point->y += 8; // extremely pedantic
 257                         break;
 258 #if defined (RGB_BACKLIGHT_ZEAL60) || defined (RGB_BACKLIGHT_M60_A)
 259                 case 36+0: // LC0A
 260                         if ( g_config.use_7u_spacebar )
 261                                 point->x += 10;
 262                         break;
 263                 case 36+6: // LC6A
 264                         if ( g_config.use_7u_spacebar )
 265                                 point->x += 4;
 266                         break;
 267 #endif
 268                 case 36+16: // LC16A
 269                         if ( !g_config.use_split_left_shift )
 270                                 point->x += 8;
 271                         break;
 272                 case 54+5: // LD5A
 273                         if ( !g_config.use_iso_enter )
 274                                 point->x -= 10;
 275                         break;
 276                 case 54+7: // LD7A
 277                         if ( !g_config.use_split_right_shift )
 278                                 point->x -= 8;
 279                         break;
 280         }
 281 }
 282
 283 void map_led_to_point_polar( uint8_t index, Point *point )
 284 {
 285         // Slightly messy way to get Point structs out of progmem.
 286         uint8_t *addr = (uint8_t*)&g_map_led_to_point_polar[index];
 287         point->x = pgm_read_byte(addr);
 288         point->y = pgm_read_byte(addr+1);
 289 }
 290
 291 //
 292 // Maps switch matrix coordinate (row,col) to LED index
 293 //
 294
 295
 296 #if defined (RGB_BACKLIGHT_ZEAL65)
 297 // Note: Left spacebar stab is at 4,3 (LC7)
 298 // Right spacebar stab is at 4,9 (D14)
 299 //
 300 // A17, A16, A15, A14, A13, A12, A11, A10,  A9,  B0,  B1,  B2,  B3,  B4,  B6
 301 //  A7,  A6,  A5,  A4,  A3,  A2,  A1,  A0,  B9, B10, B11, B12, B13, B14,  B7
 302 //  A8, C14, C13, C12, C11, C10,  C9,  D0,  D1,  D2,  D3,  D4,  D5,  B5,  B8
 303 // C16, C15,  C5,  C4,  C3,  C2,  C1,  D9, D10, D11, D12,  D6,  D7,  D8, B15
 304 // C17,  C8,  C7, ---, ---, ---, ---,  C0, ---, D14, D15, D16, D17, B17, B16
 305 const uint8_t g_map_row_column_to_led[MATRIX_ROWS][MATRIX_COLS] PROGMEM = {
 306         {  0+17,  0+16,  0+15,  0+14,  0+13,  0+12,  0+11,  0+10,   0+9,  18+0,  18+1,  18+2,  18+3,  18+4,  18+6 },
 307         {   0+7,   0+6,   0+5,   0+4,   0+3,   0+2,   0+1,   0+0,  18+9, 18+10, 18+11, 18+12, 18+13, 18+14,  18+7 },
 308         {   0+8, 36+14, 36+13, 36+12, 36+11, 36+10,  36+9,  54+0,  54+1,  54+2,  54+3,  54+4,  54+5,  18+5,  18+8 },
 309         { 36+16, 36+15,  36+5,  36+4,  36+3,  36+2,  36+1,  54+9, 54+10, 54+11, 54+12,  54+6,  54+7,  54+8, 18+15 },
 310         { 36+17,  36+8,  36+7,   255,   255,   255,   255,  36+0,  255,  54+14, 54+15, 54+16, 54+17, 18+17, 18+16 }
 311 };
 312 #elif defined (RGB_BACKLIGHT_ZEAL60) || defined (RGB_BACKLIGHT_M60_A)
 313 // Note: Left spacebar stab is at 4,3 (LC6)
 314 // Right spacebar stab is at 4,9 (LD13) or 4,10 (LD14)
 315 //
 316 // A17, A16, A15, A14, A13, A12, A11, A10,  A9,  B0,  B1,  B2,  B3,  B4,
 317 //  A7,  A6,  A5,  A4,  A3,  A2,  A1,  A0,  B9, B10, B11, B12, B13, B14,
 318 //  A8, C14, C13, C12, C11, C10,  C9,  D0,  D1,  D2,  D3,  D4,  D5,  B5,
 319 // C16, C15,  C5,  C4,  C3,  C2,  C1,  D9, D10, D11, D12,  D6,  D7,  D8,
 320 // C17,  C8,  C7,  C6, ---, ---, ---,  C0, ---, D13, D14, D15, D16, D17,
 321 const uint8_t g_map_row_column_to_led[MATRIX_ROWS][MATRIX_COLS] PROGMEM = {
 322         {  0+17,  0+16,  0+15,  0+14,  0+13,  0+12,  0+11,  0+10,   0+9,  18+0,  18+1,  18+2,  18+3,  18+4 },
 323         {   0+7,   0+6,   0+5,   0+4,   0+3,   0+2,   0+1,   0+0,  18+9, 18+10, 18+11, 18+12, 18+13, 18+14 },
 324         {   0+8, 36+14, 36+13, 36+12, 36+11, 36+10,  36+9,  54+0,  54+1,  54+2,  54+3,  54+4,  54+5,  18+5 },
 325         { 36+16, 36+15,  36+5,  36+4,  36+3,  36+2,  36+1,  54+9, 54+10, 54+11, 54+12,  54+6,  54+7,  54+8 },
 326         { 36+17,  36+8,  36+7,  36+6,   255,   255,   255,  36+0,  255,  54+13, 54+14, 54+15, 54+16, 54+17 }
 327 };
 328 #endif
 329
 330 void map_row_column_to_led( uint8_t row, uint8_t column, uint8_t *led )
 331 {
 332         *led = 255;
 333         if ( row < MATRIX_ROWS && column < MATRIX_COLS )
 334         {
 335                 *led = pgm_read_byte(&g_map_row_column_to_led[row][column]);
 336         }
 337 }
 338
 339 void backlight_update_pwm_buffers(void)
 340 {
 341         IS31FL3731_update_pwm_buffers( ISSI_ADDR_1, ISSI_ADDR_2 );
 342         IS31FL3731_update_led_control_registers( ISSI_ADDR_1, ISSI_ADDR_2 );
 343 }
 344
 345 void backlight_set_color( int index, uint8_t red, uint8_t green, uint8_t blue )
 346 {
 347         IS31FL3731_set_color( index, red, green, blue );
 348 }
 349
 350 void backlight_set_color_all( uint8_t red, uint8_t green, uint8_t blue )
 351 {
 352         IS31FL3731_set_color_all( red, green, blue );
 353 }
 354
 355 void backlight_set_key_hit(uint8_t row, uint8_t column)
 356 {
 357         uint8_t led;
 358         map_row_column_to_led(row,column,&led);
 359         g_key_hit[led] = 0;
 360
 361         g_any_key_hit = 0;
 362 }
 363
 364 // This is (F_CPU/1024) / 20 Hz
 365 // = 15625 Hz / 20 Hz
 366 // = 781
 367 #define TIMER3_TOP 781
 368
 369 void backlight_timer_init(void)
 370 {
 371         static uint8_t backlight_timer_is_init = 0;
 372         if ( backlight_timer_is_init )
 373         {
 374                 return;
 375         }
 376         backlight_timer_is_init = 1;
 377
 378         // Timer 3 setup
 379         TCCR3B = _BV(WGM32) |                   // CTC mode OCR3A as TOP
 380                          _BV(CS32) | _BV(CS30); // prescale by /1024
 381         // Set TOP value
 382         uint8_t sreg = SREG;
 383         cli();
 384
 385         OCR3AH = (TIMER3_TOP >> 8) & 0xff;
 386         OCR3AL = TIMER3_TOP & 0xff;
 387         SREG = sreg;
 388 }
 389
 390 void backlight_timer_enable(void)
 391 {
 392         TIMSK3 |= _BV(OCIE3A);
 393 }
 394
 395 void backlight_timer_disable(void)
 396 {
 397         TIMSK3 &= ~_BV(OCIE3A);
 398 }
 399
 400 void backlight_set_suspend_state(bool state)
 401 {
 402         g_suspend_state = state;
 403 }
 404
 405 void backlight_set_indicator_state(uint8_t state)
 406 {
 407         g_indicator_state = state;
 408 }
 409
 410 void backlight_effect_rgb_test(void)
 411 {
 412         // Mask out bits 4 and 5
 413         // This 2-bit value will stay the same for 16 ticks.
 414         switch ( (g_tick & 0x30) >> 4 )
 415         {
 416                 case 0:
 417                 {
 418                         backlight_set_color_all( 255, 0, 0 );
 419                         break;
 420                 }
 421                 case 1:
 422                 {
 423                         backlight_set_color_all( 0, 255, 0 );
 424                         break;
 425                 }
 426                 case 2:
 427                 {
 428                         backlight_set_color_all( 0, 0, 255 );
 429                         break;
 430                 }
 431                 case 3:
 432                 {
 433                         backlight_set_color_all( 255, 255, 255 );
 434                         break;
 435                 }
 436         }
 437 }
 438
 439 // This tests the LEDs
 440 // Note that it will change the LED control registers
 441 // in the LED drivers, and leave them in an invalid
 442 // state for other backlight effects.
 443 // ONLY USE THIS FOR TESTING LEDS!
 444 void backlight_effect_single_LED_test(void)
 445 {
 446         static uint8_t color = 0; // 0,1,2 for R,G,B
 447         static uint8_t row = 0;
 448         static uint8_t column = 0;
 449
 450         static uint8_t tick = 0;
 451         tick++;
 452
 453         if ( tick > 2 )
 454         {
 455                 tick = 0;
 456                 column++;
 457         }
 458         if ( column > 14 )
 459         {
 460                 column = 0;
 461                 row++;
 462         }
 463         if ( row > 4 )
 464         {
 465                 row = 0;
 466                 color++;
 467         }
 468         if ( color > 2 )
 469         {
 470                 color = 0;
 471         }
 472
 473         uint8_t led;
 474         map_row_column_to_led( row, column, &led );
 475         backlight_set_color_all( 255, 255, 255 );
 476         backlight_test_led( led, color==0, color==1, color==2 );
 477 }
 478
 479 // All LEDs off
 480 void backlight_effect_all_off(void)
 481 {
 482         backlight_set_color_all( 0, 0, 0 );
 483 }
 484
 485 // Solid color
 486 void backlight_effect_solid_color(void)
 487 {
 488         HSV hsv = { .h = g_config.color_1.h, .s = g_config.color_1.s, .v = g_config.brightness };
 489         RGB rgb = hsv_to_rgb( hsv );
 490         backlight_set_color_all( rgb.r, rgb.g, rgb.b );
 491 }
 492
 493 // alphas = color1, mods = color2
 494 void backlight_effect_alphas_mods(void)
 495 {
 496         RGB rgb1 = hsv_to_rgb( (HSV){ .h = g_config.color_1.h, .s = g_config.color_1.s, .v = g_config.brightness } );
 497         RGB rgb2 = hsv_to_rgb( (HSV){ .h = g_config.color_2.h, .s = g_config.color_2.s, .v = g_config.brightness } );
 498
 499         for ( int row = 0; row < MATRIX_ROWS; row++ )
 500         {
 501                 for ( int column = 0; column < MATRIX_COLS; column++ )
 502                 {
 503                         uint8_t index;
 504                         map_row_column_to_led( row, column, &index );
 505                         if ( index < 72 )
 506                         {
 507                                 if ( ( g_config.alphas_mods[row] & (1<<column) ) == 0 )
 508                                 {
 509                                         backlight_set_color( index, rgb1.r, rgb1.g, rgb1.b );
 510                                 }
 511                                 else
 512                                 {
 513                                         backlight_set_color( index, rgb2.r, rgb2.g, rgb2.b );
 514                                 }
 515                         }
 516                 }
 517         }
 518 }
 519
 520 void backlight_effect_gradient_up_down(void)
 521 {
 522         int16_t h1 = g_config.color_1.h;
 523         int16_t h2 = g_config.color_2.h;
 524         int16_t deltaH = h2 - h1;
 525
 526         // Take the shortest path between hues
 527         if ( deltaH > 127 )
 528         {
 529                 deltaH -= 256;
 530         }
 531         else if ( deltaH < -127 )
 532         {
 533                 deltaH += 256;
 534         }
 535         // Divide delta by 4, this gives the delta per row
 536         deltaH /= 4;
 537
 538         int16_t s1 = g_config.color_1.s;
 539         int16_t s2 = g_config.color_2.s;
 540         int16_t deltaS = ( s2 - s1 ) / 4;
 541
 542         HSV hsv = { .h = 0, .s = 255, .v = g_config.brightness };
 543         RGB rgb;
 544         Point point;
 545         for ( int i=0; i<72; i++ )
 546         {
 547                 map_led_to_point( i, &point );
 548                 // The y range will be 0..64, map this to 0..4
 549                 uint8_t y = (point.y>>4);
 550                 // Relies on hue being 8-bit and wrapping
 551                 hsv.h = g_config.color_1.h + ( deltaH * y );
 552                 hsv.s = g_config.color_1.s + ( deltaS * y );
 553                 rgb = hsv_to_rgb( hsv );
 554                 backlight_set_color( i, rgb.r, rgb.g, rgb.b );
 555         }
 556 }
 557
 558 void backlight_effect_raindrops(bool initialize)
 559 {
 560         int16_t h1 = g_config.color_1.h;
 561         int16_t h2 = g_config.color_2.h;
 562         int16_t deltaH = h2 - h1;
 563         deltaH /= 4;
 564
 565         // Take the shortest path between hues
 566         if ( deltaH > 127 )
 567         {
 568                 deltaH -= 256;
 569         }
 570         else if ( deltaH < -127 )
 571         {
 572                 deltaH += 256;
 573         }
 574
 575         int16_t s1 = g_config.color_1.s;
 576         int16_t s2 = g_config.color_2.s;
 577         int16_t deltaS = ( s2 - s1 ) / 4;
 578
 579         HSV hsv;
 580         RGB rgb;
 581
 582         // Change one LED every tick
 583         uint8_t led_to_change = ( g_tick & 0x000 ) == 0 ? rand() % 72 : 255;
 584
 585         for ( int i=0; i<72; i++ )
 586         {
 587                 // If initialize, all get set to random colors
 588                 // If not, all but one will stay the same as before.
 589                 if ( initialize || i == led_to_change )
 590                 {
 591                         hsv.h = h1 + ( deltaH * ( rand() & 0x03 ) );
 592                         hsv.s = s1 + ( deltaS * ( rand() & 0x03 ) );
 593                         // Override brightness with global brightness control
 594                         hsv.v = g_config.brightness;;
 595
 596                         rgb = hsv_to_rgb( hsv );
 597                         backlight_set_color( i, rgb.r, rgb.g, rgb.b );
 598                 }
 599         }
 600 }
 601
 602 void backlight_effect_cycle_all(void)
 603 {
 604         uint8_t offset = ( g_tick << g_config.effect_speed ) & 0xFF;
 605
 606         // Relies on hue being 8-bit and wrapping
 607         for ( int i=0; i<72; i++ )
 608         {
 609                 uint16_t offset2 = g_key_hit[i]<<2;
 610                 // stabilizer LEDs use spacebar hits
 611                 if ( i == 36+6 || i == 54+13 || // LC6, LD13
 612                                 ( g_config.use_7u_spacebar && i == 54+14 ) ) // LD14
 613                 {
 614                         offset2 = g_key_hit[36+0]<<2;
 615                 }
 616                 offset2 = (offset2<=63) ? (63-offset2) : 0;
 617
 618                 HSV hsv = { .h = offset+offset2, .s = 255, .v = g_config.brightness };
 619                 RGB rgb = hsv_to_rgb( hsv );
 620                 backlight_set_color( i, rgb.r, rgb.g, rgb.b );
 621         }
 622 }
 623
 624 void backlight_effect_cycle_left_right(void)
 625 {
 626         uint8_t offset = ( g_tick << g_config.effect_speed ) & 0xFF;
 627         HSV hsv = { .h = 0, .s = 255, .v = g_config.brightness };
 628         RGB rgb;
 629         Point point;
 630         for ( int i=0; i<72; i++ )
 631         {
 632                 uint16_t offset2 = g_key_hit[i]<<2;
 633                 // stabilizer LEDs use spacebar hits
 634                 if ( i == 36+6 || i == 54+13 || // LC6, LD13
 635                                 ( g_config.use_7u_spacebar && i == 54+14 ) ) // LD14
 636                 {
 637                         offset2 = g_key_hit[36+0]<<2;
 638                 }
 639                 offset2 = (offset2<=63) ? (63-offset2) : 0;
 640
 641                 map_led_to_point( i, &point );
 642                 // Relies on hue being 8-bit and wrapping
 643                 hsv.h = point.x + offset + offset2;
 644                 rgb = hsv_to_rgb( hsv );
 645                 backlight_set_color( i, rgb.r, rgb.g, rgb.b );
 646         }
 647 }
 648
 649 void backlight_effect_cycle_up_down(void)
 650 {
 651         uint8_t offset = ( g_tick << g_config.effect_speed ) & 0xFF;
 652         HSV hsv = { .h = 0, .s = 255, .v = g_config.brightness };
 653         RGB rgb;
 654         Point point;
 655         for ( int i=0; i<72; i++ )
 656         {
 657                 uint16_t offset2 = g_key_hit[i]<<2;
 658                 // stabilizer LEDs use spacebar hits
 659                 if ( i == 36+6 || i == 54+13 || // LC6, LD13
 660                                 ( g_config.use_7u_spacebar && i == 54+14 ) ) // LD14
 661                 {
 662                         offset2 = g_key_hit[36+0]<<2;
 663                 }
 664                 offset2 = (offset2<=63) ? (63-offset2) : 0;
 665
 666                 map_led_to_point( i, &point );
 667                 // Relies on hue being 8-bit and wrapping
 668                 hsv.h = point.y + offset + offset2;
 669                 rgb = hsv_to_rgb( hsv );
 670                 backlight_set_color( i, rgb.r, rgb.g, rgb.b );
 671         }
 672 }
 673
 674 void backlight_effect_jellybean_raindrops( bool initialize )
 675 {
 676         HSV hsv;
 677         RGB rgb;
 678
 679         // Change one LED every tick
 680         uint8_t led_to_change = ( g_tick & 0x000 ) == 0 ? rand() % 72 : 255;
 681
 682         for ( int i=0; i<72; i++ )
 683         {
 684                 // If initialize, all get set to random colors
 685                 // If not, all but one will stay the same as before.
 686                 if ( initialize || i == led_to_change )
 687                 {
 688                         hsv.h = rand() & 0xFF;
 689                         hsv.s = rand() & 0xFF;
 690                         // Override brightness with global brightness control
 691                         hsv.v = g_config.brightness;;
 692
 693                         rgb = hsv_to_rgb( hsv );
 694                         backlight_set_color( i, rgb.r, rgb.g, rgb.b );
 695                 }
 696         }
 697 }
 698
 699 void backlight_effect_cycle_radial1(void)
 700 {
 701         uint8_t offset = ( g_tick << g_config.effect_speed ) & 0xFF;
 702         HSV hsv = { .h = 0, .s = 255, .v = g_config.brightness };
 703         RGB rgb;
 704         Point point;
 705         for ( int i=0; i<72; i++ )
 706         {
 707                 map_led_to_point_polar( i, &point );
 708                 // Relies on hue being 8-bit and wrapping
 709                 hsv.h = point.x + offset;
 710                 hsv.s = point.y;
 711                 rgb = hsv_to_rgb( hsv );
 712                 backlight_set_color( i, rgb.r, rgb.g, rgb.b );
 713         }
 714 }
 715
 716 void backlight_effect_cycle_radial2(void)
 717 {
 718         uint8_t offset = ( g_tick << g_config.effect_speed ) & 0xFF;
 719
 720         HSV hsv = { .h = 0, .s = g_config.color_1.s, .v = g_config.brightness };
 721         RGB rgb;
 722         Point point;
 723         for ( int i=0; i<72; i++ )
 724         {
 725                 map_led_to_point_polar( i, &point );
 726                 uint8_t offset2 = offset + point.x;
 727                 if ( offset2 & 0x80 )
 728                 {
 729                         offset2 = ~offset2;
 730                 }
 731                 offset2 = offset2 >> 2;
 732                 hsv.h = g_config.color_1.h + offset2;
 733                 hsv.s = 127 + ( point.y >> 1 );
 734                 rgb = hsv_to_rgb( hsv );
 735                 backlight_set_color( i, rgb.r, rgb.g, rgb.b );
 736         }
 737 }
 738
 739 void backlight_effect_indicators_set_colors( uint8_t index, HSV hsv )
 740 {
 741         RGB rgb = hsv_to_rgb( hsv );
 742         if ( index == 254 )
 743         {
 744                 backlight_set_color_all( rgb.r, rgb.g, rgb.b );
 745         }
 746         else
 747         {
 748                 backlight_set_color( index, rgb.r, rgb.g, rgb.b );
 749
 750                 // If the spacebar LED is the indicator,
 751                 // do the same for the spacebar stabilizers
 752                 if ( index == 36+0 ) // LC0
 753                 {
 754 #if defined (RGB_BACKLIGHT_ZEAL65)
 755                         backlight_set_color( 36+7, rgb.r, rgb.g, rgb.b ); // LC7
 756                         backlight_set_color( 54+14, rgb.r, rgb.g, rgb.b ); // LD14
 757 #elif defined (RGB_BACKLIGHT_ZEAL60) || defined (RGB_BACKLIGHT_M60_A)
 758                         backlight_set_color( 36+6, rgb.r, rgb.g, rgb.b ); // LC6
 759                         backlight_set_color( 54+13, rgb.r, rgb.g, rgb.b ); // LD13
 760                         if ( g_config.use_7u_spacebar )
 761                         {
 762                                 backlight_set_color( 54+14, rgb.r, rgb.g, rgb.b ); // LD14
 763                         }
 764 #endif
 765                 }
 766         }
 767 }
 768
 769 // This runs after another backlight effect and replaces
 770 // colors already set
 771 void backlight_effect_indicators(void)
 772 {
 773         if ( g_config.caps_lock_indicator.index != 255 &&
 774                         ( g_indicator_state & (1<<USB_LED_CAPS_LOCK) ) )
 775         {
 776                 backlight_effect_indicators_set_colors( g_config.caps_lock_indicator.index, g_config.caps_lock_indicator.color );
 777         }
 778
 779         // This if/else if structure allows higher layers to
 780         // override lower ones. If we set layer 3's indicator
 781         // to none, then it will NOT show layer 2 or layer 1
 782         // indicators, even if those layers are on via the
 783         // MO13/MO23 Fn combo magic.
 784         //
 785         // Basically we want to handle the case where layer 3 is
 786         // still the backlight configuration layer and we don't
 787         // want "all LEDs" indicators hiding the backlight effect,
 788         // but still allow end users to do whatever they want.
 789         if ( IS_LAYER_ON(3) )
 790         {
 791                 if ( g_config.layer_3_indicator.index != 255 )
 792                 {
 793                         backlight_effect_indicators_set_colors( g_config.layer_3_indicator.index, g_config.layer_3_indicator.color );
 794                 }
 795         }
 796         else if ( IS_LAYER_ON(2) )
 797         {
 798                 if ( g_config.layer_2_indicator.index != 255 )
 799                 {
 800                         backlight_effect_indicators_set_colors( g_config.layer_2_indicator.index, g_config.layer_2_indicator.color );
 801                 }
 802         }
 803         else if ( IS_LAYER_ON(1) )
 804         {
 805                 if ( g_config.layer_1_indicator.index != 255 )
 806                 {
 807                         backlight_effect_indicators_set_colors( g_config.layer_1_indicator.index, g_config.layer_1_indicator.color );
 808                 }
 809         }
 810 }
 811
 812 ISR(TIMER3_COMPA_vect)
 813 {
 814         // delay 1 second before driving LEDs or doing anything else
 815         static uint8_t startup_tick = 0;
 816         if ( startup_tick < 20 )
 817         {
 818                 startup_tick++;
 819                 return;
 820         }
 821
 822         g_tick++;
 823
 824         if ( g_any_key_hit < 0xFFFFFFFF )
 825         {
 826                 g_any_key_hit++;
 827         }
 828
 829         for ( int led = 0; led < 72; led++ )
 830         {
 831                 if ( g_key_hit[led] < 255 )
 832                 {
 833                         g_key_hit[led]++;
 834                 }
 835         }
 836
 837         // Factory default magic value
 838         if ( g_config.effect == 255 )
 839         {
 840                 backlight_effect_rgb_test();
 841                 return;
 842         }
 843
 844         // Ideally we would also stop sending zeros to the LED driver PWM buffers
 845         // while suspended and just do a software shutdown. This is a cheap hack for now.
 846         bool suspend_backlight = ((g_suspend_state && g_config.disable_when_usb_suspended) ||
 847                         (g_config.disable_after_timeout > 0 && g_any_key_hit > g_config.disable_after_timeout * 60 * 20));
 848         uint8_t effect = suspend_backlight ? 0 : g_config.effect;
 849
 850         // Keep track of the effect used last time,
 851         // detect change in effect, so each effect can
 852         // have an optional initialization.
 853         static uint8_t effect_last = 255;
 854         bool initialize = effect != effect_last;
 855         effect_last = effect;
 856
 857         // this gets ticked at 20 Hz.
 858         // each effect can opt to do calculations
 859         // and/or request PWM buffer updates.
 860         switch ( effect )
 861         {
 862                 case 0:
 863                         backlight_effect_all_off();
 864                         break;
 865                 case 1:
 866                         backlight_effect_solid_color();
 867                         break;
 868                 case 2:
 869                         backlight_effect_alphas_mods();
 870                         break;
 871                 case 3:
 872                         backlight_effect_gradient_up_down();
 873                         break;
 874                 case 4:
 875                         backlight_effect_raindrops( initialize );
 876                         break;
 877                 case 5:
 878                         backlight_effect_cycle_all();
 879                         break;
 880                 case 6:
 881                         backlight_effect_cycle_left_right();
 882                         break;
 883                 case 7:
 884                         backlight_effect_cycle_up_down();
 885                         break;
 886                 case 8:
 887                         backlight_effect_jellybean_raindrops( initialize );
 888                         break;
 889                 case 9:
 890                         backlight_effect_cycle_radial1();
 891                         break;
 892                 case 10:
 893                         backlight_effect_cycle_radial2();
 894                         break;
 895                 default:
 896                         backlight_effect_all_off();
 897                         break;
 898         }
 899
 900         if ( ! suspend_backlight )
 901         {
 902                 backlight_effect_indicators();
 903         }
 904 }
 905
 906 void backlight_set_indicator_index( uint8_t *index, uint8_t row, uint8_t column )
 907 {
 908         if ( row >= MATRIX_ROWS )
 909         {
 910                 // Special value, 255=none, 254=all
 911                 *index = row;
 912         }
 913         else
 914         {
 915                 map_row_column_to_led( row, column, index );
 916         }
 917 }
 918
 919 void backlight_get_indicator_row_col( uint8_t index, uint8_t *row, uint8_t *column )
 920 {
 921         if ( index == 255 || index == 254 )
 922         {
 923                 // Special value, 255=none, 254=all
 924                 *row = index;
 925                 *column = 0;
 926                 return;
 927         }
 928         for ( uint8_t r = 0; r < MATRIX_ROWS; r++ )
 929         {
 930                 for ( uint8_t c = 0; c < MATRIX_COLS; c++ )
 931                 {
 932                         uint8_t i = 255;
 933                         map_row_column_to_led( r, c, &i );
 934                         if ( i == index )
 935                         {
 936                                 *row = r;
 937                                 *column = c;
 938                                 return;
 939                         }
 940                 }
 941         }
 942 }
 943
 944 // Some helpers for setting/getting HSV
 945 void _set_color( HSV *color, uint8_t *data )
 946 {
 947         color->h = data[0];
 948         color->s = data[1];
 949         color->v = data[2];
 950 }
 951
 952 void _get_color( HSV *color, uint8_t *data )
 953 {
 954         data[0] = color->h;
 955         data[1] = color->s;
 956         data[2] = color->v;
 957 }
 958
 959 void backlight_config_set_value( uint8_t *data )
 960 {
 961         bool reinitialize = false;
 962         uint8_t *value_id = &(data[0]);
 963         uint8_t *value_data = &(data[1]);
 964         switch ( *value_id )
 965         {
 966 #if defined (RGB_BACKLIGHT_ZEAL60) || defined(RGB_BACKLIGHT_ZEAL65)
 967                 case id_use_split_backspace:
 968                 {
 969                         g_config.use_split_backspace = (bool)*value_data;
 970                         reinitialize = true;
 971                         break;
 972                 }
 973 #endif
 974 #if defined (RGB_BACKLIGHT_ZEAL60)
 975                 case id_use_split_left_shift:
 976                 {
 977                         g_config.use_split_left_shift = (bool)*value_data;
 978                         reinitialize = true;
 979                         break;
 980                 }
 981                 case id_use_split_right_shift:
 982                 {
 983                         g_config.use_split_right_shift = (bool)*value_data;
 984                         reinitialize = true;
 985                         break;
 986                 }
 987                 case id_use_7u_spacebar:
 988                 {
 989                         g_config.use_7u_spacebar = (bool)*value_data;
 990                         reinitialize = true;
 991                         break;
 992                 }
 993                 case id_use_iso_enter:
 994                 {
 995                         g_config.use_iso_enter = (bool)*value_data;
 996                         reinitialize = true;
 997                         break;
 998                 }
 999                 case id_disable_hhkb_blocker_leds:
1000                 {
1001                         g_config.disable_hhkb_blocker_leds = (bool)*value_data;
1002                         reinitialize = true;
1003                         break;
1004                 }
1005 #endif
1006                 case id_disable_when_usb_suspended:
1007                 {
1008                         g_config.disable_when_usb_suspended = (bool)*value_data;
1009                         break;
1010                 }
1011                 case id_disable_after_timeout:
1012                 {
1013                         g_config.disable_after_timeout = *value_data;
1014                         break;
1015                 }
1016                 case id_brightness:
1017                 {
1018                         g_config.brightness = *value_data;
1019                         break;
1020                 }
1021                 case id_effect:
1022                 {
1023                         g_config.effect = *value_data;
1024                         break;
1025                 }
1026                 case id_effect_speed:
1027                 {
1028                         g_config.effect_speed = *value_data;
1029                         break;
1030                 }
1031                 case id_color_1:
1032                 {
1033                         _set_color( &(g_config.color_1), value_data );
1034                         break;
1035                 }
1036                 case id_color_2:
1037                 {
1038                         _set_color( &(g_config.color_2), value_data );
1039                         break;
1040                 }
1041                 case id_caps_lock_indicator_color:
1042                 {
1043                         _set_color( &(g_config.caps_lock_indicator.color), value_data );
1044                         break;
1045                 }
1046                 case id_caps_lock_indicator_row_col:
1047                 {
1048                         backlight_set_indicator_index( &(g_config.caps_lock_indicator.index), value_data[0], value_data[1] );
1049                         break;
1050                 }
1051                 case id_layer_1_indicator_color:
1052                 {
1053                         _set_color( &(g_config.layer_1_indicator.color), value_data );
1054                         break;
1055                 }
1056                 case id_layer_1_indicator_row_col:
1057                 {
1058                         backlight_set_indicator_index( &(g_config.layer_1_indicator.index), value_data[0], value_data[1] );
1059                         break;
1060                 }
1061                 case id_layer_2_indicator_color:
1062                 {
1063                         _set_color( &(g_config.layer_2_indicator.color), value_data );
1064                         break;
1065                 }
1066                 case id_layer_2_indicator_row_col:
1067                 {
1068                         backlight_set_indicator_index( &(g_config.layer_2_indicator.index), value_data[0], value_data[1] );
1069                         break;
1070                 }
1071                 case id_layer_3_indicator_color:
1072                 {
1073                         _set_color( &(g_config.layer_3_indicator.color), value_data );
1074                         break;
1075                 }
1076                 case id_layer_3_indicator_row_col:
1077                 {
1078                         backlight_set_indicator_index( &(g_config.layer_3_indicator.index), value_data[0], value_data[1] );
1079                         break;
1080                 }
1081                 case id_alphas_mods:
1082                 {
1083                         for ( int i=0; i<5; i++ )
1084                         {
1085                                 g_config.alphas_mods[i] = ( *(value_data+i*2) << 8 ) | ( *(value_data+i*2+1) );
1086                         }
1087                 }
1088         }
1089
1090         if ( reinitialize )
1091         {
1092                 backlight_init_drivers();
1093         }
1094 }
1095
1096 void backlight_config_get_value( uint8_t *data )
1097 {
1098         uint8_t *value_id = &(data[0]);
1099         uint8_t *value_data = &(data[1]);
1100         switch ( *value_id )
1101         {
1102                 case id_use_split_backspace:
1103                 {
1104                         *value_data = ( g_config.use_split_backspace ? 1 : 0 );
1105                         break;
1106                 }
1107                 case id_use_split_left_shift:
1108                 {
1109                         *value_data = ( g_config.use_split_left_shift ? 1 : 0 );
1110                         break;
1111                 }
1112                 case id_use_split_right_shift:
1113                 {
1114                         *value_data = ( g_config.use_split_right_shift ? 1 : 0 );
1115                         break;
1116                 }
1117                 case id_use_7u_spacebar:
1118                 {
1119                         *value_data = ( g_config.use_7u_spacebar ? 1 : 0 );
1120                         break;
1121                 }
1122                 case id_use_iso_enter:
1123                 {
1124                         *value_data = ( g_config.use_iso_enter ? 1 : 0 );
1125                         break;
1126                 }
1127                 case id_disable_when_usb_suspended:
1128                 {
1129                         *value_data = ( g_config.disable_when_usb_suspended ? 1 : 0 );
1130                         break;
1131                 }
1132                 case id_disable_hhkb_blocker_leds:
1133                 {
1134                         *value_data = ( g_config.disable_hhkb_blocker_leds ? 1 : 0 );
1135                         break;
1136                 }
1137                 case id_disable_after_timeout:
1138                 {
1139                         *value_data = g_config.disable_after_timeout;
1140                         break;
1141                 }
1142                 case id_brightness:
1143                 {
1144                         *value_data = g_config.brightness;
1145                         break;
1146                 }
1147                 case id_effect:
1148                 {
1149                         *value_data = g_config.effect;
1150                         break;
1151                 }
1152                 case id_effect_speed:
1153                 {
1154                         *value_data = g_config.effect_speed;
1155                         break;
1156                 }
1157                 case id_color_1:
1158                 {
1159                         _get_color( &(g_config.color_1), value_data );
1160                         break;
1161                 }
1162                 case id_color_2:
1163                 {
1164                         _get_color( &(g_config.color_2), value_data );
1165                         break;
1166                 }
1167                 case id_caps_lock_indicator_color:
1168                 {
1169                         _get_color( &(g_config.caps_lock_indicator.color), value_data );
1170                         break;
1171                 }
1172                 case id_caps_lock_indicator_row_col:
1173                 {
1174                         backlight_get_indicator_row_col( g_config.caps_lock_indicator.index, &(value_data[0]), &(value_data[1]) );
1175                         break;
1176                 }
1177                 case id_layer_1_indicator_color:
1178                 {
1179                         _get_color( &(g_config.layer_1_indicator.color), value_data );
1180                         break;
1181                 }
1182                 case id_layer_1_indicator_row_col:
1183                 {
1184                         backlight_get_indicator_row_col( g_config.layer_1_indicator.index, &(value_data[0]), &(value_data[1]) );
1185                         break;
1186                 }
1187                 case id_layer_2_indicator_color:
1188                 {
1189                         _get_color( &(g_config.layer_2_indicator.color), value_data );
1190                         break;
1191                 }
1192                 case id_layer_2_indicator_row_col:
1193                 {
1194                         backlight_get_indicator_row_col( g_config.layer_2_indicator.index, &(value_data[0]), &(value_data[1]) );
1195                         break;
1196                 }
1197                 case id_layer_3_indicator_color:
1198                 {
1199                         _get_color( &(g_config.layer_3_indicator.color), value_data );
1200                         break;
1201                 }
1202                 case id_layer_3_indicator_row_col:
1203                 {
1204                         backlight_get_indicator_row_col( g_config.layer_3_indicator.index, &(value_data[0]), &(value_data[1]) );
1205                         break;
1206                 }
1207                 case id_alphas_mods:
1208                 {
1209                         for ( int i=0; i<5; i++ )
1210                         {
1211                                 *(value_data+i*2) = g_config.alphas_mods[i] >> 8;
1212                                 *(value_data+i*2+1)     = g_config.alphas_mods[i] & 0xFF;
1213                         }
1214                 }
1215         }
1216 }
1217
1218 void backlight_config_set_alphas_mods( uint16_t *alphas_mods )
1219 {
1220         for ( int i=0; i<5; i++ )
1221         {
1222                 g_config.alphas_mods[i] = alphas_mods[i];
1223         }
1224
1225         backlight_config_save();
1226 }
1227
1228 void backlight_config_load(void)
1229 {
1230         eeprom_read_block( &g_config, ((void*)RGB_BACKLIGHT_CONFIG_EEPROM_ADDR), sizeof(backlight_config) );
1231 }
1232
1233 void backlight_config_save(void)
1234 {
1235         eeprom_update_block( &g_config, ((void*)RGB_BACKLIGHT_CONFIG_EEPROM_ADDR), sizeof(backlight_config) );
1236 }
1237
1238 void backlight_init_drivers(void)
1239 {
1240         // Initialize I2C
1241         i2c_init();
1242         IS31FL3731_init( ISSI_ADDR_1 );
1243         IS31FL3731_init( ISSI_ADDR_2 );
1244
1245         for ( int index = 0; index < 72; index++ )
1246         {
1247                 // OR the possible "disabled" cases together, then NOT the result to get the enabled state
1248                 // LC6 LD13 not present on Zeal65
1249 #if defined (RGB_BACKLIGHT_ZEAL65)
1250                 bool enabled = !( ( index == 18+5 && !g_config.use_split_backspace ) || // LB5
1251                                                   ( index == 36+15 && !g_config.use_split_left_shift ) || // LC15
1252                                                   ( index == 54+8 && !g_config.use_split_right_shift ) || // LD8
1253                                                   ( index == 36+6 ) || // LC6
1254                                                   ( index == 54+13 ) ); // LD13
1255 #elif defined (RGB_BACKLIGHT_M60_A)
1256                 bool enabled = !(
1257                 // LB6 LB7 LB8 LB15 LB16 LB17 not present on M60-A
1258                                                   ( index == 18+6 ) || // LB6
1259                                                   ( index == 18+7 ) || // LB7
1260                                                   ( index == 18+8 ) || // LB8
1261                                                   ( index == 18+15 ) || // LB15
1262                                                   ( index == 18+16 ) || // LB16
1263                                                   ( index == 18+17 ) || // LB17
1264                 // HHKB blockers (LC17, LD17) and ISO extra keys (LC15,LD13) not present on M60-A
1265                                                   ( index == 36+17 ) || // LC17
1266                                                   ( index == 54+17 ) || // LD17
1267                                                   ( index == 36+15 ) || // LC15
1268                                                   ( index == 54+13 ) ); // LD13
1269 #elif defined (RGB_BACKLIGHT_ZEAL60)
1270                 // LB6 LB7 LB8 LB15 LB16 LB17 not present on Zeal60
1271                 bool enabled = !( ( index == 18+5 && !g_config.use_split_backspace ) || // LB5
1272                                                   ( index == 36+15 && !g_config.use_split_left_shift ) || // LC15
1273                                                   ( index == 54+8 && !g_config.use_split_right_shift ) || // LD8
1274                                                   ( index == 54+13 && g_config.use_7u_spacebar ) || // LD13
1275                                                   ( index == 36+17 && g_config.disable_hhkb_blocker_leds ) || // LC17
1276                                                   ( index == 54+17 && g_config.disable_hhkb_blocker_leds ) ||  // LD17
1277                                                   ( index == 18+6 ) || // LB6
1278                                                   ( index == 18+7 ) || // LB7
1279                                                   ( index == 18+8 ) || // LB8
1280                                                   ( index == 18+15 ) || // LB15
1281                                                   ( index == 18+16 ) || // LB16
1282                                                   ( index == 18+17 ) ); // LB17
1283 #endif
1284                 // This only caches it for later
1285                 IS31FL3731_set_led_control_register( index, enabled, enabled, enabled );
1286         }
1287         // This actually updates the LED drivers
1288         IS31FL3731_update_led_control_registers( ISSI_ADDR_1, ISSI_ADDR_2 );
1289
1290         // TODO: put the 1 second startup delay here?
1291
1292         // clear the key hits
1293         for ( int led=0; led<72; led++ )
1294         {
1295                 g_key_hit[led] = 255;
1296         }
1297 }
1298
1299 bool process_record_backlight(uint16_t keycode, keyrecord_t *record)
1300 {
1301         // Record keypresses for backlight effects
1302         if ( record->event.pressed )
1303         {
1304                 backlight_set_key_hit( record->event.key.row, record->event.key.col );
1305         }
1306
1307         switch(keycode)
1308         {
1309                 case BR_INC:
1310                         if (record->event.pressed)
1311                         {
1312                                 backlight_brightness_increase();
1313                         }
1314                         return false;
1315                         break;
1316                 case BR_DEC:
1317                         if (record->event.pressed)
1318                         {
1319                                 backlight_brightness_decrease();
1320                         }
1321                         return false;
1322                         break;
1323                 case EF_INC:
1324                         if (record->event.pressed)
1325                         {
1326                                 backlight_effect_increase();
1327                         }
1328                         return false;
1329                         break;
1330                 case EF_DEC:
1331                         if (record->event.pressed)
1332                         {
1333                                 backlight_effect_decrease();
1334                         }
1335                         return false;
1336                         break;
1337                 case ES_INC:
1338                         if (record->event.pressed)
1339                         {
1340                                 backlight_effect_speed_increase();
1341                         }
1342                         return false;
1343                         break;
1344                 case ES_DEC:
1345                         if (record->event.pressed)
1346                         {
1347                                 backlight_effect_speed_decrease();
1348                         }
1349                         return false;
1350                         break;
1351                 case H1_INC:
1352                         if (record->event.pressed)
1353                         {
1354                                 backlight_color_1_hue_increase();
1355                         }
1356                         return false;
1357                         break;
1358                 case H1_DEC:
1359                         if (record->event.pressed)
1360                         {
1361                                 backlight_color_1_hue_decrease();
1362                         }
1363                         return false;
1364                         break;
1365                 case S1_INC:
1366                         if (record->event.pressed)
1367                         {
1368                                 backlight_color_1_sat_increase();
1369                         }
1370                         return false;
1371                         break;
1372                 case S1_DEC:
1373                         if (record->event.pressed)
1374                         {
1375                                 backlight_color_1_sat_decrease();
1376                                 break;
1377                         }
1378                         return false;
1379                         break;
1380                 case H2_INC:
1381                         if (record->event.pressed)
1382                         {
1383                                 backlight_color_2_hue_increase();
1384                         }
1385                         return false;
1386                         break;
1387                 case H2_DEC:
1388                         if (record->event.pressed)
1389                         {
1390                                 backlight_color_2_hue_decrease();
1391                         }
1392                         return false;
1393                         break;
1394                 case S2_INC:
1395                         if (record->event.pressed)
1396                         {
1397                                 backlight_color_2_sat_increase();
1398                         }
1399                         return false;
1400                         break;
1401                 case S2_DEC:
1402                         if (record->event.pressed)
1403                         {
1404                                 backlight_color_2_sat_decrease();
1405                                 break;
1406                         }
1407                         return false;
1408                         break;
1409         }
1410
1411         return true;
1412 }
1413
1414 // Deals with the messy details of incrementing an integer
1415 uint8_t increment( uint8_t value, uint8_t step, uint8_t min, uint8_t max )
1416 {
1417         int16_t new_value = value;
1418         new_value += step;
1419         return MIN( MAX( new_value, min ), max );
1420 }
1421
1422 uint8_t decrement( uint8_t value, uint8_t step, uint8_t min, uint8_t max )
1423 {
1424         int16_t new_value = value;
1425         new_value -= step;
1426         return MIN( MAX( new_value, min ), max );
1427 }
1428
1429 void backlight_effect_increase(void)
1430 {
1431         g_config.effect = increment( g_config.effect, 1, 0, BACKLIGHT_EFFECT_MAX );
1432         backlight_config_save();
1433 }
1434
1435 void backlight_effect_decrease(void)
1436 {
1437         g_config.effect = decrement( g_config.effect, 1, 0, BACKLIGHT_EFFECT_MAX );
1438         backlight_config_save();
1439 }
1440
1441 void backlight_effect_speed_increase(void)
1442 {
1443         g_config.effect_speed = increment( g_config.effect_speed, 1, 0, 3 );
1444         backlight_config_save();
1445 }
1446
1447 void backlight_effect_speed_decrease(void)
1448 {
1449         g_config.effect_speed = decrement( g_config.effect_speed, 1, 0, 3 );
1450         backlight_config_save();
1451 }
1452
1453 void backlight_brightness_increase(void)
1454 {
1455         g_config.brightness = increment( g_config.brightness, 8, 0, 255 );
1456         backlight_config_save();
1457 }
1458
1459 void backlight_brightness_decrease(void)
1460 {
1461         g_config.brightness = decrement( g_config.brightness, 8, 0, 255 );
1462         backlight_config_save();
1463 }
1464
1465 void backlight_color_1_hue_increase(void)
1466 {
1467         g_config.color_1.h = increment( g_config.color_1.h, 8, 0, 255 );
1468         backlight_config_save();
1469 }
1470
1471 void backlight_color_1_hue_decrease(void)
1472 {
1473         g_config.color_1.h = decrement( g_config.color_1.h, 8, 0, 255 );
1474         backlight_config_save();
1475 }
1476
1477 void backlight_color_1_sat_increase(void)
1478 {
1479         g_config.color_1.s = increment( g_config.color_1.s, 8, 0, 255 );
1480         backlight_config_save();
1481 }
1482
1483 void backlight_color_1_sat_decrease(void)
1484 {
1485         g_config.color_1.s = decrement( g_config.color_1.s, 8, 0, 255 );
1486         backlight_config_save();
1487 }
1488
1489 void backlight_color_2_hue_increase(void)
1490 {
1491         g_config.color_2.h = increment( g_config.color_2.h, 8, 0, 255 );
1492         backlight_config_save();
1493 }
1494
1495 void backlight_color_2_hue_decrease(void)
1496 {
1497         g_config.color_2.h = decrement( g_config.color_2.h, 8, 0, 255 );
1498         backlight_config_save();
1499 }
1500
1501 void backlight_color_2_sat_increase(void)
1502 {
1503         g_config.color_2.s = increment( g_config.color_2.s, 8, 0, 255 );
1504         backlight_config_save();
1505 }
1506
1507 void backlight_color_2_sat_decrease(void)
1508 {
1509         g_config.color_2.s = decrement( g_config.color_2.s, 8, 0, 255 );
1510         backlight_config_save();
1511 }
1512
1513 void backlight_test_led( uint8_t index, bool red, bool green, bool blue )
1514 {
1515         for ( int i=0; i<72; i++ )
1516         {
1517                 if ( i == index )
1518                 {
1519                         IS31FL3731_set_led_control_register( i, red, green, blue );
1520                 }
1521                 else
1522                 {
1523                         IS31FL3731_set_led_control_register( i, false, false, false );
1524                 }
1525         }
1526 }
1527
1528 void backlight_debug_led( bool state )
1529 {
1530         if (state)
1531         {
1532                 // Output high.
1533                 DDRE |= (1<<6);
1534                 PORTE |= (1<<6);
1535         }
1536         else
1537         {
1538                 // Output low.
1539                 DDRE &= ~(1<<6);
1540                 PORTE &= ~(1<<6);
1541         }
1542 }
1543
1544 #endif // BACKLIGHT_ENABLED