keyboards/infinity60/led_controller.c

   1 /*
   2 Copyright 2016 flabbergast <s3+flabbergast@sdfeu.org>
   3
   4 This program is free software: you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation, either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 /*
  19  * LED controller code
  20  * WF uses IS31FL3731C matrix LED driver from ISSI
  21  * datasheet: http://www.issi.com/WW/pdf/31FL3731C.pdf
  22  */
  23
  24 #include "ch.h"
  25 #include "hal.h"
  26 #include "print.h"
  27
  28 #include "led_controller.h"
  29
  30 #include "suspend.h"
  31
  32 #include "usb_main.h"
  33
  34 /* Infinity60 LED MAP
  35     - digits mean "row" and "col", i.e. 45 means C4-5 in the IS31 datasheet, matrix A
  36
  37   11 12 13 14 15 16 17 18 21 22 23 24 25  26 27*
  38    28 31 32 33 34 35 36 37 38 41 42 43 44 45
  39    46 47 48 51 52 53 54 55 56 57 58 61    62
  40     63 64 65 66 67 68 71 72 73 74 75      76 77*
  41   78  81  82       83         84  85  86  87
  42
  43 *Unused in Alphabet Layout
  44 */
  45
  46 /*
  47   each page has 0xB4 bytes
  48   0 - 0x11: LED control (on/off):
  49     order: CA1, CB1, CA2, CB2, .... (CA - matrix A, CB - matrix B)
  50       CAn controls Cn-8 .. Cn-1 (LSbit)
  51   0x12 - 0x23: blink control (like "LED control")
  52   0x24 - 0xB3: PWM control: byte per LED, 0xFF max on
  53     order same as above (CA 1st row (8bytes), CB 1st row (8bytes), ...)
  54 */
  55
  56 /* Which LED should be used for CAPS LOCK indicator
  57  * The usual Caps Lock position is C4-6, so the address is
  58  * 0x24 + (4-1)*0x10 + (8-1) = 0x59 */
  59 #if !defined(CAPS_LOCK_LED_ADDRESS)
  60 #define CAPS_LOCK_LED_ADDRESS 0x46
  61 #endif
  62
  63 #if !defined(NUM_LOCK_LED_ADDRESS)
  64 #define NUM_LOCK_LED_ADDRESS 0x85
  65 #endif
  66
  67 /* Which LED should breathe during sleep */
  68 #if !defined(BREATHE_LED_ADDRESS)
  69 #define BREATHE_LED_ADDRESS CAPS_LOCK_LED_ADDRESS
  70 #endif
  71
  72 /* =================
  73  * ChibiOS I2C setup
  74  * ================= */
  75 static const I2CConfig i2ccfg = {
  76   400000 // clock speed (Hz); 400kHz max for IS31
  77 };
  78
  79 /* ==============
  80  *   variables
  81  * ============== */
  82 // internal communication buffers
  83 uint8_t tx[2] __attribute__((aligned(2)));
  84 uint8_t rx[1] __attribute__((aligned(2)));
  85
  86 // buffer for sending the whole page at once (used also as a temp buffer)
  87 uint8_t full_page[0xB4+1] = {0};
  88
  89 // LED mask (which LEDs are present, selected by bits)
  90 // See page comment above, control alternates CA matrix/CB matrix
  91 // IC60 pcb uses only CA matrix.
  92 // Each byte is a control pin for 8 leds ordered 8-1
  93 const uint8_t is31_ic60_leds_mask[0x12] = {
  94   0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
  95   0x00, 0xFF, 0x00, 0xFF, 0x00, 0x7F, 0x00, 0x00, 0x00
  96 };
  97
  98 // array to hold brightness pwm steps
  99 const uint8_t pwm_levels[5] = {
 100     0x00, 0x16, 0x4E, 0xA1, 0xFF
 101 };
 102
 103 // array to write to pwm register
 104 uint8_t pwm_reg_array[9] = {0};
 105
 106
 107 /* ============================
 108  *   communication functions
 109  * ============================ */
 110 msg_t is31_select_page(uint8_t page) {
 111   tx[0] = IS31_COMMANDREGISTER;
 112   tx[1] = page;
 113   return i2cMasterTransmitTimeout(&I2CD1, IS31_ADDR_DEFAULT, tx, 2, NULL, 0, US2ST(IS31_TIMEOUT));
 114 }
 115
 116 msg_t is31_write_data(uint8_t page, uint8_t *buffer, uint8_t size) {
 117   is31_select_page(page);
 118   return i2cMasterTransmitTimeout(&I2CD1, IS31_ADDR_DEFAULT, buffer, size, NULL, 0, US2ST(IS31_TIMEOUT));
 119 }
 120
 121 msg_t is31_write_register(uint8_t page, uint8_t reg, uint8_t data) {
 122   is31_select_page(page);
 123   tx[0] = reg;
 124   tx[1] = data;
 125     xprintf("page display: %X\n", page);
 126   return i2cMasterTransmitTimeout(&I2CD1, IS31_ADDR_DEFAULT, tx, 2, NULL, 0, US2ST(IS31_TIMEOUT));
 127 }
 128
 129 msg_t is31_read_register(uint8_t page, uint8_t reg, uint8_t *result) {
 130   is31_select_page(page);
 131
 132   tx[0] = reg;
 133   return i2cMasterTransmitTimeout(&I2CD1, IS31_ADDR_DEFAULT, tx, 1, result, 1, US2ST(IS31_TIMEOUT));
 134 }
 135
 136 /* ========================
 137  * initialise the IS31 chip
 138  * ======================== */
 139 void is31_init(void) {
 140   // just to be sure that it's all zeroes
 141   __builtin_memset(full_page,0,0xB4+1);
 142   // zero function page, all registers (assuming full_page is all zeroes)
 143   is31_write_data(IS31_FUNCTIONREG, full_page, 0xD + 1);
 144   // disable hardware shutdown
 145   palSetPadMode(GPIOB, 16, PAL_MODE_OUTPUT_PUSHPULL);
 146   palSetPad(GPIOB, 16);
 147   chThdSleepMilliseconds(10);
 148   // software shutdown
 149   is31_write_register(IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, 0);
 150   chThdSleepMilliseconds(10);
 151   // TODO: This already done above, remove?
 152   // zero function page, all registers
 153   is31_write_data(IS31_FUNCTIONREG, full_page, 0xD + 1);
 154   chThdSleepMilliseconds(10);
 155   // software shutdown disable (i.e. turn stuff on)
 156   is31_write_register(IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_ON);
 157   chThdSleepMilliseconds(10);
 158   // zero all LED registers on all 8 pages
 159   uint8_t i;
 160   for(i=0; i<8; i++) {
 161     is31_write_data(i, full_page, 0xB4 + 1);
 162     chThdSleepMilliseconds(1);
 163   }
 164 }
 165
 166 /* ==================
 167  * LED control thread
 168  * ================== */
 169 #define LED_MAILBOX_NUM_MSGS 5
 170 static msg_t led_mailbox_queue[LED_MAILBOX_NUM_MSGS];
 171 mailbox_t led_mailbox;
 172 static THD_WORKING_AREA(waLEDthread, 256);
 173 static THD_FUNCTION(LEDthread, arg) {
 174   (void)arg;
 175   chRegSetThreadName("LEDthread");
 176
 177   uint8_t i, page;
 178
 179   //persistent status variables
 180   uint8_t backlight_status, lock_status, led_step, active_layer;
 181   uint8_t led_control_reg[0x13] = {0};//led control register start address + 0x12 bytes
 182
 183   //mailbox variables
 184   uint8_t temp, msg_type, msg_led;
 185   msg_t msg;
 186
 187 /*  //control register variables
 188   uint8_t page, save_page, save_breath1, save_breath2;
 189   msg_t msg, retval;
 190 */
 191
 192 // initialize persistent variables
 193 backlight_status = 0;
 194 lock_status = 0;//TODO: does keyboard remember locks?
 195 led_step = 4; //full brightness
 196 active_layer = 0;
 197
 198   while(true) {
 199     // wait for a message (asynchronous)
 200     // (messages are queued (up to LED_MAILBOX_NUM_MSGS) if they can't
 201     //  be processed right away)
 202     chMBFetch(&led_mailbox, &msg, TIME_INFINITE);
 203     msg_type = (msg >> 8) & 0xFF; //first byte is msg type
 204     msg_led = (msg) & 0xFF; //second byte is action information
 205
 206     xprintf("--------------------\n");
 207     xprintf("mailbox fetch\nmsg: %X\n", msg);
 208     xprintf("type: %X - led: %X\n", msg_type, msg_led); //test if msg_type is 1 or 2 bytes after mask
 209   switch (msg_type){
 210     case KEY_LIGHT:
 211     //TODO: lighting key led on keypress
 212     break;
 213
 214     case TOGGLE_LED:
 215       //TODO: toggle existing indicator off, or let user do this, but write frame 7 for every led change
 216       //turn on single led, msg_led = row/col of led
 217       set_led_bit(led_control_reg, msg_led, 1);
 218
 219       is31_write_data (7, led_control_reg, 0x12+1);
 220       is31_write_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, 7);
 221       active_layer = 7;
 222       is31_read_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, &temp);
 223     xprintf("page display: %X\n", temp);
 224       break;
 225
 226     case TOGGLE_ALL:
 227     xprintf("TOGGLE_ALL\n");
 228       //msg_led = unused, TODO: consider using msg_led to toggle layer display
 229       is31_read_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, &temp);
 230
 231     xprintf("temp: %X\n", temp);
 232       //if LED_ALL is on then toggle off, any other layer, turn on LED_ALL
 233       if(temp == 1) {
 234     xprintf("page display true: %X\n", temp);
 235         is31_write_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, 0);
 236       } else {
 237     xprintf("page display false: %X\n", temp);
 238         is31_write_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, 1);
 239       }
 240       is31_read_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, &temp);
 241     xprintf("page display: %X\n", temp);
 242       break;
 243
 244     case TOGGLE_BACKLIGHT:
 245       //msg_led = unused
 246       backlight_status ^= 1;
 247       is31_read_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, &temp);
 248       active_layer = temp;
 249
 250       page = backlight_status == 0 ? 0 : active_layer;
 251       is31_write_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, page);
 252       break;
 253
 254     case TOGGLE_LAYER_LEDS://show layer indicator or full map of layer keys.
 255       //TODO: change so user can flag which they want, indiv or full map in fn_actions
 256       //msg_led = layer to toggle on
 257       is31_read_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, &temp);
 258
 259       if(temp == msg_led) {
 260         is31_write_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, 7);
 261         active_layer = 7;
 262       } else {
 263         is31_write_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, msg_led);
 264         active_layer = msg_led;
 265       }
 266       break;
 267
 268     case TOGGLE_LOCK_LED:
 269       //msg_led = 0-3 for lock flags
 270       lock_status ^= msg_led; //TODO: confirm toggling works and doesn't get out of sync
 271       set_lock_leds(led_control_reg, lock_status);
 272       break;
 273
 274     case MODE_BREATH:
 275       break;
 276     case STEP_BRIGHTNESS:
 277       //pwm_levels[] bounds checking, loop through array
 278       //TODO: find a cleaner way to walk through this logic
 279       if (msg_led == 0) {
 280           if (led_step == 0) {
 281               led_step = 4;
 282           } else {
 283               led_step--;
 284           }
 285       } else {
 286           if (led_step == 4) {
 287               led_step = 0;
 288           } else {
 289               led_step++;
 290           }
 291       }
 292
 293       //TODO: this seems a messy way to populate the pwm register
 294       //populate the 9 byte rows to be written to each pin, first byte is register (pin) address
 295       for(i=1; i<9; i++) {
 296         pwm_reg_array[i]=pwm_levels[led_step];
 297       }
 298       for(i=0; i<8; i++) {
 299         pwm_reg_array[0] = 0x24 + (i * 0x10);//first byte of 9 bytes must be register address
 300         is31_write_data(0, pwm_reg_array, 9);
 301         chThdSleepMilliseconds(5);
 302       }
 303       break;
 304
 305 /*      case LED_MSG_SLEEP_LED_ON:
 306         // save current settings
 307         is31_read_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, &save_page);
 308         is31_read_register(IS31_FUNCTIONREG, IS31_REG_BREATHCTRL1, &save_breath1);
 309         is31_read_register(IS31_FUNCTIONREG, IS31_REG_BREATHCTRL2, &save_breath2);
 310         // use pages 7 and 8 for (hardware) breathing (assuming they're empty)
 311         is31_write_register(6, BREATHE_LED_ADDRESS, 0xFF);
 312         is31_write_register(7, BREATHE_LED_ADDRESS, 0x00);
 313         is31_write_register(IS31_FUNCTIONREG, IS31_REG_BREATHCTRL1, (6<<4)|6);
 314         is31_write_register(IS31_FUNCTIONREG, IS31_REG_BREATHCTRL2, IS31_REG_BREATHCTRL2_ENABLE|3);
 315         retval = MSG_TIMEOUT;
 316         temp = 6;
 317         while(retval == MSG_TIMEOUT) {
 318           // switch to the other page
 319           is31_write_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, temp);
 320           temp = (temp == 6 ? 7 : 6);
 321           // the times should be sufficiently long for IS31 to finish switching pages
 322           retval = chMBFetch(&led_mailbox, &msg, MS2ST(temp == 6 ? 4000 : 6000));
 323         }
 324         // received a message (should be a wakeup), so restore previous state
 325         chThdSleepMilliseconds(3000); // need to wait until the page change finishes
 326         // note: any other messages are queued
 327         is31_write_register(IS31_FUNCTIONREG, IS31_REG_BREATHCTRL1, save_breath1);
 328         is31_write_register(IS31_FUNCTIONREG, IS31_REG_BREATHCTRL2, save_breath2);
 329         is31_write_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, save_page);
 330         break;
 331       case LED_MSG_SLEEP_LED_OFF:
 332         // should not get here; wakeup should be received in the branch above break;
 333         break;
 334       default:
 335         //TODO: individual led state unchanged if page arrays are selected in code above
 336         //avoidable if full pages are written on the fly
 337         //or use pg8 for individual leds, have pointer to currently on led address for toggling
 338         if (msg == 0x59 || msg == 0x84) {
 339           //toggle lock keys on all layers
 340           for (i=0,i<8,i++) {
 341             is31_read_register(0, msg, &temp);
 342             pwm = (temp > 0x00 ? 0x00 : 0xFF);
 343             is31_write_register(i,msg,pwm);
 344           }
 345
 346         } else if(msg >= 0x24) {
 347           xprintf("Power pre-read\ntemp: %X - msg: %X - pwm: %X\n", temp, msg, pwm);
 348           is31_read_register(7, msg, &temp);
 349           xprintf("Post-read\ntemp: %X - msg: %X - pwm: %X\n", temp, msg, pwm);
 350           if (msg == active_led) {
 351             //toggle led power
 352             pwm = (temp > 0x00 ? 0x00 : 0xFF);
 353
 354             //Use 8th led page for individual led indicators
 355             is31_write_register(7, msg, pwm);
 356           } else {
 357             is31_write_register(7, active_led, 0x00);
 358             is31_write_register(7, msg, 0xFF);
 359           }
 360           xprintf("Power post-change\ntemp: %X - msg: %X - pwm: %X\n", temp, msg, pwm);
 361           is31_write_register(IS31_FUNCTIONREG, IS31_REG_PICTDISP, 7);
 362           }
 363           break;
 364 */
 365     }
 366     xprintf("--------------------\n");
 367   }
 368 }
 369
 370
 371 /* ========================
 372  *    led bit processing
 373  * ======================== */
 374 void set_led_bit (uint8_t *led_control_reg, uint8_t msg_led, uint8_t toggle_on) {
 375   uint8_t row_byte, column_bit;
 376   //msg_led tens column is pin#, A-control register is every other 8 bits
 377   //ones column is bit position in 8-bit mask
 378   //control register will be one bit shifted into position along register's full 0x12 bytes
 379   ////first byte is register address 0x00
 380   row_byte = ((msg_led / 10) % 10 - 1 ) * 2 + 1;
 381   column_bit = 1<<(msg_led % 10 - 1);
 382
 383   if (toggle_on) {
 384     led_control_reg[row_byte] |= 1<<(column_bit);
 385   } else {
 386     led_control_reg[row_byte] &= ~1<<(column_bit);
 387   }
 388 }
 389
 390 void set_lock_leds(uint8_t *led_control_reg, uint8_t lock_status) {
 391   uint8_t i;
 392
 393   switch (lock_status) {
 394     case 1:
 395       set_led_bit(led_control_reg, CAPS_LOCK_LED_ADDRESS, 1);//TODO: define lock addresses by matrix#, and loop for all frames
 396       set_led_bit(led_control_reg, NUM_LOCK_LED_ADDRESS, 0);
 397       break;
 398     case 2:
 399       set_led_bit(led_control_reg, CAPS_LOCK_LED_ADDRESS, 0);
 400       set_led_bit(led_control_reg, NUM_LOCK_LED_ADDRESS, 1);
 401       break;
 402     case 3:
 403       set_led_bit(led_control_reg, NUM_LOCK_LED_ADDRESS, 1);
 404       set_led_bit(led_control_reg, CAPS_LOCK_LED_ADDRESS, 1);
 405       break;
 406   }
 407
 408   for(i=1; i<8; i++) { //keep LED_OFF layer all off, including locks
 409     is31_write_data (i, led_control_reg, 0x12+1);
 410     chThdSleepMilliseconds(5);
 411   }
 412 }
 413
 414 void write_led_page (uint8_t page, const uint8_t *led_array, uint8_t led_count) {
 415 //TODO: init function that accepts array of led addresses and sets them by row
 416   uint8_t i;
 417   uint8_t row, col;
 418   uint8_t temp_control_reg[0x13] = {0};//led control register start address + 0x12 bytes
 419     xprintf("-------------\n");
 420     xprintf("write page %X\n", page);
 421
 422   for(i=0;i<led_count;i++){
 423     row = ((led_array[i] / 10) % 10 - 1 ) * 2 + 1;//includes 1 byte shift for 0x00 address
 424     col = 1<<(led_array[i] % 10 - 1);
 425
 426     temp_control_reg[row] |= 1<<(col);
 427   }
 428
 429   is31_write_data(page, temp_control_reg, 0x13);
 430     xprintf("-------------\n");
 431 }
 432 /* =====================
 433  * hook into user keymap
 434  * ===================== */
 435 void led_controller_init(void) {
 436   uint8_t i;
 437
 438   /* initialise I2C */
 439   /* I2C pins */
 440   palSetPadMode(GPIOB, 0, PAL_MODE_ALTERNATIVE_2); // PTB0/I2C0/SCL
 441   palSetPadMode(GPIOB, 1, PAL_MODE_ALTERNATIVE_2); // PTB1/I2C0/SDA
 442   /* start I2C */
 443   i2cStart(&I2CD1, &i2ccfg);
 444   // try high drive (from kiibohd)
 445   I2CD1.i2c->C2 |= I2Cx_C2_HDRS;
 446   // try glitch fixing (from kiibohd)
 447   I2CD1.i2c->FLT = 4;
 448
 449   chThdSleepMilliseconds(10);
 450
 451   /* initialise IS31 chip */
 452   is31_init();
 453
 454   /* enable LEDs on all pages */
 455   full_page[0] = 0;
 456   __builtin_memcpy(full_page+1, is31_ic60_leds_mask, 0x12);
 457   for(i=0; i<8; i++) {
 458     is31_write_data(i, full_page, 1+0x12);
 459   }
 460
 461   //set Display Option Register so all pwm intensity is controlled from Frame 1
 462   is31_write_register(IS31_FUNCTIONREG, IS31_REG_DISPLAYOPT, IS31_REG_DISPLAYOPT_INTENSITY_SAME);
 463
 464   /* enable breathing when the displayed page changes */
 465   // Fade-in Fade-out, time = 26ms * 2^N, N=3
 466   is31_write_register(IS31_FUNCTIONREG, IS31_REG_BREATHCTRL1, (3<<4)|3);
 467   is31_write_register(IS31_FUNCTIONREG, IS31_REG_BREATHCTRL2, IS31_REG_BREATHCTRL2_ENABLE|3);
 468
 469   // clean up the lock LEDs
 470   //TODO: adjust for new addressing and additional frames
 471   //is31_write_register(1, CAPS_LOCK_LED_ADDRESS, 0);
 472   //is31_write_register(2, CAPS_LOCK_LED_ADDRESS, 0);
 473
 474   /* more time consuming LED processing should be offloaded into
 475    * a thread, with asynchronous messaging. */
 476   chMBObjectInit(&led_mailbox, led_mailbox_queue, LED_MAILBOX_NUM_MSGS);
 477   chThdCreateStatic(waLEDthread, sizeof(waLEDthread), LOWPRIO, LEDthread, NULL);
 478 }
 479
 480 //TODO: Don't know equivalent QMK hooks for these
 481 //
 482 //void hook_usb_suspend_entry(void) {
 483 //#ifdef SLEEP_LED_ENABLE
 484 //  chSysLockFromISR();
 485 //  chMBPostI(&led_mailbox, LED_MSG_SLEEP_LED_ON);
 486 //  chSysUnlockFromISR();
 487 //#endif /* SLEEP_LED_ENABLE */
 488 //}
 489 //
 490 //void hook_usb_suspend_loop(void) {
 491 //  chThdSleepMilliseconds(100);
 492 //  /* Remote wakeup */
 493 //  if((USB_DRIVER.status & 2) && suspend_wakeup_condition()) {
 494 //    send_remote_wakeup(&USB_DRIVER);
 495 //  }
 496 //}
 497 //
 498 //void hook_usb_wakeup(void) {
 499 //#ifdef SLEEP_LED_ENABLE
 500 //  chSysLockFromISR();
 501 //  chMBPostI(&led_mailbox, LED_MSG_SLEEP_LED_OFF);
 502 //  chSysUnlockFromISR();
 503 //#endif /* SLEEP_LED_ENABLE */
 504 //}
 505 //*/