quantum/quantum.c

   1 /* Copyright 2016-2017 Jack Humbert
   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
  17 #include "quantum.h"
  18
  19 #if !defined(RGBLIGHT_ENABLE) && !defined(RGB_MATRIX_ENABLE)
  20         #include "rgb.h"
  21 #endif
  22
  23 #ifdef PROTOCOL_LUFA
  24 #include "outputselect.h"
  25 #endif
  26
  27 #ifndef TAPPING_TERM
  28 #define TAPPING_TERM 200
  29 #endif
  30
  31 #ifndef BREATHING_PERIOD
  32 #define BREATHING_PERIOD 6
  33 #endif
  34
  35 #include "backlight.h"
  36 extern backlight_config_t backlight_config;
  37
  38 #ifdef FAUXCLICKY_ENABLE
  39 #include "fauxclicky.h"
  40 #endif
  41
  42 #ifdef API_ENABLE
  43 #include "api.h"
  44 #endif
  45
  46 #ifdef MIDI_ENABLE
  47 #include "process_midi.h"
  48 #endif
  49
  50 #ifdef VELOCIKEY_ENABLE
  51 #include "velocikey.h"
  52 #endif
  53
  54 #ifdef HAPTIC_ENABLE
  55     #include "haptic.h"
  56 #endif
  57
  58 #ifdef ENCODER_ENABLE
  59 #include "encoder.h"
  60 #endif
  61
  62 #ifdef AUDIO_ENABLE
  63   #ifndef GOODBYE_SONG
  64     #define GOODBYE_SONG SONG(GOODBYE_SOUND)
  65   #endif
  66   #ifndef AG_NORM_SONG
  67     #define AG_NORM_SONG SONG(AG_NORM_SOUND)
  68   #endif
  69   #ifndef AG_SWAP_SONG
  70     #define AG_SWAP_SONG SONG(AG_SWAP_SOUND)
  71   #endif
  72   float goodbye_song[][2] = GOODBYE_SONG;
  73   float ag_norm_song[][2] = AG_NORM_SONG;
  74   float ag_swap_song[][2] = AG_SWAP_SONG;
  75   #ifdef DEFAULT_LAYER_SONGS
  76     float default_layer_songs[][16][2] = DEFAULT_LAYER_SONGS;
  77   #endif
  78 #endif
  79
  80 static void do_code16 (uint16_t code, void (*f) (uint8_t)) {
  81   switch (code) {
  82   case QK_MODS ... QK_MODS_MAX:
  83     break;
  84   default:
  85     return;
  86   }
  87
  88   if (code & QK_LCTL)
  89     f(KC_LCTL);
  90   if (code & QK_LSFT)
  91     f(KC_LSFT);
  92   if (code & QK_LALT)
  93     f(KC_LALT);
  94   if (code & QK_LGUI)
  95     f(KC_LGUI);
  96
  97   if (code < QK_RMODS_MIN) return;
  98
  99   if (code & QK_RCTL)
 100     f(KC_RCTL);
 101   if (code & QK_RSFT)
 102     f(KC_RSFT);
 103   if (code & QK_RALT)
 104     f(KC_RALT);
 105   if (code & QK_RGUI)
 106     f(KC_RGUI);
 107 }
 108
 109 static inline void qk_register_weak_mods(uint8_t kc) {
 110     add_weak_mods(MOD_BIT(kc));
 111     send_keyboard_report();
 112 }
 113
 114 static inline void qk_unregister_weak_mods(uint8_t kc) {
 115     del_weak_mods(MOD_BIT(kc));
 116     send_keyboard_report();
 117 }
 118
 119 static inline void qk_register_mods(uint8_t kc) {
 120     add_weak_mods(MOD_BIT(kc));
 121     send_keyboard_report();
 122 }
 123
 124 static inline void qk_unregister_mods(uint8_t kc) {
 125     del_weak_mods(MOD_BIT(kc));
 126     send_keyboard_report();
 127 }
 128
 129 void register_code16 (uint16_t code) {
 130   if (IS_MOD(code) || code == KC_NO) {
 131       do_code16 (code, qk_register_mods);
 132   } else {
 133       do_code16 (code, qk_register_weak_mods);
 134   }
 135   register_code (code);
 136 }
 137
 138 void unregister_code16 (uint16_t code) {
 139   unregister_code (code);
 140   if (IS_MOD(code) || code == KC_NO) {
 141       do_code16 (code, qk_unregister_mods);
 142   } else {
 143       do_code16 (code, qk_unregister_weak_mods);
 144   }
 145 }
 146
 147 void tap_code16(uint16_t code) {
 148   register_code16(code);
 149   #if TAP_CODE_DELAY > 0
 150     wait_ms(TAP_CODE_DELAY);
 151   #endif
 152   unregister_code16(code);
 153 }
 154
 155 __attribute__ ((weak))
 156 bool process_action_kb(keyrecord_t *record) {
 157   return true;
 158 }
 159
 160 __attribute__ ((weak))
 161 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
 162   return process_record_user(keycode, record);
 163 }
 164
 165 __attribute__ ((weak))
 166 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 167   return true;
 168 }
 169
 170 void reset_keyboard(void) {
 171   clear_keyboard();
 172 #if defined(MIDI_ENABLE) && defined(MIDI_BASIC)
 173   process_midi_all_notes_off();
 174 #endif
 175 #ifdef AUDIO_ENABLE
 176   #ifndef NO_MUSIC_MODE
 177     music_all_notes_off();
 178   #endif
 179   uint16_t timer_start = timer_read();
 180   PLAY_SONG(goodbye_song);
 181   shutdown_user();
 182   while(timer_elapsed(timer_start) < 250)
 183     wait_ms(1);
 184   stop_all_notes();
 185 #else
 186   shutdown_user();
 187   wait_ms(250);
 188 #endif
 189 #ifdef HAPTIC_ENABLE
 190   haptic_shutdown();
 191 #endif
 192 // this is also done later in bootloader.c - not sure if it's neccesary here
 193 #ifdef BOOTLOADER_CATERINA
 194   *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific
 195 #endif
 196   bootloader_jump();
 197 }
 198
 199 // Shift / paren setup
 200
 201 #ifndef LSPO_KEY
 202   #define LSPO_KEY KC_9
 203 #endif
 204 #ifndef RSPC_KEY
 205   #define RSPC_KEY KC_0
 206 #endif
 207
 208 #ifndef LSPO_MOD
 209   #define LSPO_MOD KC_LSFT
 210 #endif
 211 #ifndef RSPC_MOD
 212   #define RSPC_MOD KC_RSFT
 213 #endif
 214
 215 // Shift / Enter setup
 216 #ifndef SFTENT_KEY
 217   #define SFTENT_KEY KC_ENT
 218 #endif
 219
 220 static bool shift_interrupted[2] = {0, 0};
 221 static uint16_t scs_timer[2] = {0, 0};
 222
 223 /* true if the last press of GRAVE_ESC was shifted (i.e. GUI or SHIFT were pressed), false otherwise.
 224  * Used to ensure that the correct keycode is released if the key is released.
 225  */
 226 static bool grave_esc_was_shifted = false;
 227
 228 /* Convert record into usable keycode via the contained event. */
 229 uint16_t get_record_keycode(keyrecord_t *record) {
 230   return get_event_keycode(record->event);
 231 }
 232
 233
 234 /* Convert event into usable keycode. Checks the layer cache to ensure that it
 235  * retains the correct keycode after a layer change, if the key is still pressed.
 236  */
 237 uint16_t get_event_keycode(keyevent_t event) {
 238
 239   #if !defined(NO_ACTION_LAYER) && !defined(STRICT_LAYER_RELEASE)
 240     /* TODO: Use store_or_get_action() or a similar function. */
 241     if (!disable_action_cache) {
 242       uint8_t layer;
 243
 244       if (event.pressed) {
 245         layer = layer_switch_get_layer(event.key);
 246         update_source_layers_cache(event.key, layer);
 247       } else {
 248         layer = read_source_layers_cache(event.key);
 249       }
 250       return keymap_key_to_keycode(layer, event.key);
 251     } else
 252   #endif
 253     return keymap_key_to_keycode(layer_switch_get_layer(event.key), event.key);
 254 }
 255
 256 /* Main keycode processing function. Hands off handling to other functions,
 257  * then processes internal Quantum keycodes, then processes ACTIONs.
 258  */
 259 bool process_record_quantum(keyrecord_t *record) {
 260     uint16_t keycode = get_record_keycode(record);
 261
 262     // This is how you use actions here
 263     // if (keycode == KC_LEAD) {
 264     //   action_t action;
 265     //   action.code = ACTION_DEFAULT_LAYER_SET(0);
 266     //   process_action(record, action);
 267     //   return false;
 268     // }
 269
 270   #ifdef VELOCIKEY_ENABLE
 271     if (velocikey_enabled() && record->event.pressed) { velocikey_accelerate(); }
 272   #endif
 273
 274   #ifdef TAP_DANCE_ENABLE
 275     preprocess_tap_dance(keycode, record);
 276   #endif
 277
 278   if (!(
 279   #if defined(KEY_LOCK_ENABLE)
 280     // Must run first to be able to mask key_up events.
 281     process_key_lock(&keycode, record) &&
 282   #endif
 283   #if defined(AUDIO_ENABLE) && defined(AUDIO_CLICKY)
 284     process_clicky(keycode, record) &&
 285   #endif //AUDIO_CLICKY
 286   #ifdef HAPTIC_ENABLE
 287     process_haptic(keycode, record) &&
 288   #endif //HAPTIC_ENABLE
 289   #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYREACTIVE_ENABLED)
 290     process_rgb_matrix(keycode, record) &&
 291   #endif
 292     process_record_kb(keycode, record) &&
 293   #if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED)
 294     process_midi(keycode, record) &&
 295   #endif
 296   #ifdef AUDIO_ENABLE
 297     process_audio(keycode, record) &&
 298   #endif
 299   #ifdef STENO_ENABLE
 300     process_steno(keycode, record) &&
 301   #endif
 302   #if (defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))) && !defined(NO_MUSIC_MODE)
 303     process_music(keycode, record) &&
 304   #endif
 305   #ifdef TAP_DANCE_ENABLE
 306     process_tap_dance(keycode, record) &&
 307   #endif
 308   #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
 309     process_unicode_common(keycode, record) &&
 310   #endif
 311   #ifdef LEADER_ENABLE
 312     process_leader(keycode, record) &&
 313   #endif
 314   #ifdef COMBO_ENABLE
 315     process_combo(keycode, record) &&
 316   #endif
 317   #ifdef PRINTING_ENABLE
 318     process_printer(keycode, record) &&
 319   #endif
 320   #ifdef AUTO_SHIFT_ENABLE
 321     process_auto_shift(keycode, record) &&
 322   #endif
 323   #ifdef TERMINAL_ENABLE
 324     process_terminal(keycode, record) &&
 325   #endif
 326       true)) {
 327     return false;
 328   }
 329
 330   // Shift / paren setup
 331
 332   switch(keycode) {
 333     case RESET:
 334       if (record->event.pressed) {
 335         reset_keyboard();
 336       }
 337     return false;
 338     case DEBUG:
 339       if (record->event.pressed) {
 340           debug_enable = true;
 341           print("DEBUG: enabled.\n");
 342       }
 343     return false;
 344     case EEPROM_RESET:
 345       if (record->event.pressed) {
 346           eeconfig_init();
 347       }
 348     return false;
 349   #ifdef FAUXCLICKY_ENABLE
 350   case FC_TOG:
 351     if (record->event.pressed) {
 352       FAUXCLICKY_TOGGLE;
 353     }
 354     return false;
 355   case FC_ON:
 356     if (record->event.pressed) {
 357       FAUXCLICKY_ON;
 358     }
 359     return false;
 360   case FC_OFF:
 361     if (record->event.pressed) {
 362       FAUXCLICKY_OFF;
 363     }
 364     return false;
 365   #endif
 366   #if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
 367   case RGB_TOG:
 368     // Split keyboards need to trigger on key-up for edge-case issue
 369     #ifndef SPLIT_KEYBOARD
 370     if (record->event.pressed) {
 371     #else
 372     if (!record->event.pressed) {
 373     #endif
 374       rgblight_toggle();
 375     }
 376     return false;
 377   case RGB_MODE_FORWARD:
 378     if (record->event.pressed) {
 379       uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
 380       if(shifted) {
 381         rgblight_step_reverse();
 382       }
 383       else {
 384         rgblight_step();
 385       }
 386     }
 387     return false;
 388   case RGB_MODE_REVERSE:
 389     if (record->event.pressed) {
 390       uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
 391       if(shifted) {
 392         rgblight_step();
 393       }
 394       else {
 395         rgblight_step_reverse();
 396       }
 397     }
 398     return false;
 399   case RGB_HUI:
 400     // Split keyboards need to trigger on key-up for edge-case issue
 401     #ifndef SPLIT_KEYBOARD
 402     if (record->event.pressed) {
 403     #else
 404     if (!record->event.pressed) {
 405     #endif
 406       rgblight_increase_hue();
 407     }
 408     return false;
 409   case RGB_HUD:
 410     // Split keyboards need to trigger on key-up for edge-case issue
 411     #ifndef SPLIT_KEYBOARD
 412     if (record->event.pressed) {
 413     #else
 414     if (!record->event.pressed) {
 415     #endif
 416       rgblight_decrease_hue();
 417     }
 418     return false;
 419   case RGB_SAI:
 420     // Split keyboards need to trigger on key-up for edge-case issue
 421     #ifndef SPLIT_KEYBOARD
 422     if (record->event.pressed) {
 423     #else
 424     if (!record->event.pressed) {
 425     #endif
 426       rgblight_increase_sat();
 427     }
 428     return false;
 429   case RGB_SAD:
 430     // Split keyboards need to trigger on key-up for edge-case issue
 431     #ifndef SPLIT_KEYBOARD
 432     if (record->event.pressed) {
 433     #else
 434     if (!record->event.pressed) {
 435     #endif
 436       rgblight_decrease_sat();
 437     }
 438     return false;
 439   case RGB_VAI:
 440     // Split keyboards need to trigger on key-up for edge-case issue
 441     #ifndef SPLIT_KEYBOARD
 442     if (record->event.pressed) {
 443     #else
 444     if (!record->event.pressed) {
 445     #endif
 446       rgblight_increase_val();
 447     }
 448     return false;
 449   case RGB_VAD:
 450     // Split keyboards need to trigger on key-up for edge-case issue
 451     #ifndef SPLIT_KEYBOARD
 452     if (record->event.pressed) {
 453     #else
 454     if (!record->event.pressed) {
 455     #endif
 456       rgblight_decrease_val();
 457     }
 458     return false;
 459   case RGB_SPI:
 460     if (record->event.pressed) {
 461       rgblight_increase_speed();
 462     }
 463     return false;
 464   case RGB_SPD:
 465     if (record->event.pressed) {
 466       rgblight_decrease_speed();
 467     }
 468     return false;
 469   case RGB_MODE_PLAIN:
 470     if (record->event.pressed) {
 471       rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
 472     }
 473     return false;
 474   case RGB_MODE_BREATHE:
 475   #ifdef RGBLIGHT_EFFECT_BREATHING
 476     if (record->event.pressed) {
 477       if ((RGBLIGHT_MODE_BREATHING <= rgblight_get_mode()) &&
 478           (rgblight_get_mode() < RGBLIGHT_MODE_BREATHING_end)) {
 479         rgblight_step();
 480       } else {
 481         rgblight_mode(RGBLIGHT_MODE_BREATHING);
 482       }
 483     }
 484   #endif
 485     return false;
 486   case RGB_MODE_RAINBOW:
 487   #ifdef RGBLIGHT_EFFECT_RAINBOW_MOOD
 488     if (record->event.pressed) {
 489       if ((RGBLIGHT_MODE_RAINBOW_MOOD <= rgblight_get_mode()) &&
 490           (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_MOOD_end)) {
 491         rgblight_step();
 492       } else {
 493         rgblight_mode(RGBLIGHT_MODE_RAINBOW_MOOD);
 494       }
 495     }
 496   #endif
 497     return false;
 498   case RGB_MODE_SWIRL:
 499   #ifdef RGBLIGHT_EFFECT_RAINBOW_SWIRL
 500     if (record->event.pressed) {
 501       if ((RGBLIGHT_MODE_RAINBOW_SWIRL <= rgblight_get_mode()) &&
 502           (rgblight_get_mode() < RGBLIGHT_MODE_RAINBOW_SWIRL_end)) {
 503         rgblight_step();
 504       } else {
 505         rgblight_mode(RGBLIGHT_MODE_RAINBOW_SWIRL);
 506       }
 507     }
 508   #endif
 509     return false;
 510   case RGB_MODE_SNAKE:
 511   #ifdef RGBLIGHT_EFFECT_SNAKE
 512     if (record->event.pressed) {
 513       if ((RGBLIGHT_MODE_SNAKE <= rgblight_get_mode()) &&
 514           (rgblight_get_mode() < RGBLIGHT_MODE_SNAKE_end)) {
 515         rgblight_step();
 516       } else {
 517         rgblight_mode(RGBLIGHT_MODE_SNAKE);
 518       }
 519     }
 520   #endif
 521     return false;
 522   case RGB_MODE_KNIGHT:
 523   #ifdef RGBLIGHT_EFFECT_KNIGHT
 524     if (record->event.pressed) {
 525       if ((RGBLIGHT_MODE_KNIGHT <= rgblight_get_mode()) &&
 526           (rgblight_get_mode() < RGBLIGHT_MODE_KNIGHT_end)) {
 527         rgblight_step();
 528       } else {
 529         rgblight_mode(RGBLIGHT_MODE_KNIGHT);
 530       }
 531     }
 532   #endif
 533     return false;
 534   case RGB_MODE_XMAS:
 535   #ifdef RGBLIGHT_EFFECT_CHRISTMAS
 536     if (record->event.pressed) {
 537       rgblight_mode(RGBLIGHT_MODE_CHRISTMAS);
 538     }
 539   #endif
 540     return false;
 541   case RGB_MODE_GRADIENT:
 542   #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT
 543     if (record->event.pressed) {
 544       if ((RGBLIGHT_MODE_STATIC_GRADIENT <= rgblight_get_mode()) &&
 545           (rgblight_get_mode() < RGBLIGHT_MODE_STATIC_GRADIENT_end)) {
 546         rgblight_step();
 547       } else {
 548         rgblight_mode(RGBLIGHT_MODE_STATIC_GRADIENT);
 549       }
 550     }
 551   #endif
 552     return false;
 553   case RGB_MODE_RGBTEST:
 554   #ifdef RGBLIGHT_EFFECT_RGB_TEST
 555     if (record->event.pressed) {
 556       rgblight_mode(RGBLIGHT_MODE_RGB_TEST);
 557     }
 558   #endif
 559     return false;
 560   #endif // defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
 561   #ifdef VELOCIKEY_ENABLE
 562     case VLK_TOG:
 563       if (record->event.pressed) {
 564         velocikey_toggle();
 565       }
 566       return false;
 567   #endif
 568   #ifdef PROTOCOL_LUFA
 569     case OUT_AUTO:
 570       if (record->event.pressed) {
 571         set_output(OUTPUT_AUTO);
 572       }
 573       return false;
 574     case OUT_USB:
 575       if (record->event.pressed) {
 576         set_output(OUTPUT_USB);
 577       }
 578       return false;
 579     #ifdef BLUETOOTH_ENABLE
 580     case OUT_BT:
 581       if (record->event.pressed) {
 582         set_output(OUTPUT_BLUETOOTH);
 583       }
 584       return false;
 585     #endif
 586     #endif
 587     case MAGIC_SWAP_CONTROL_CAPSLOCK ... MAGIC_TOGGLE_NKRO:
 588       if (record->event.pressed) {
 589         // MAGIC actions (BOOTMAGIC without the boot)
 590         if (!eeconfig_is_enabled()) {
 591             eeconfig_init();
 592         }
 593         /* keymap config */
 594         keymap_config.raw = eeconfig_read_keymap();
 595         switch (keycode)
 596         {
 597           case MAGIC_SWAP_CONTROL_CAPSLOCK:
 598             keymap_config.swap_control_capslock = true;
 599             break;
 600           case MAGIC_CAPSLOCK_TO_CONTROL:
 601             keymap_config.capslock_to_control = true;
 602             break;
 603           case MAGIC_SWAP_LALT_LGUI:
 604             keymap_config.swap_lalt_lgui = true;
 605             break;
 606           case MAGIC_SWAP_RALT_RGUI:
 607             keymap_config.swap_ralt_rgui = true;
 608             break;
 609           case MAGIC_NO_GUI:
 610             keymap_config.no_gui = true;
 611             break;
 612           case MAGIC_SWAP_GRAVE_ESC:
 613             keymap_config.swap_grave_esc = true;
 614             break;
 615           case MAGIC_SWAP_BACKSLASH_BACKSPACE:
 616             keymap_config.swap_backslash_backspace = true;
 617             break;
 618           case MAGIC_HOST_NKRO:
 619             keymap_config.nkro = true;
 620             break;
 621           case MAGIC_SWAP_ALT_GUI:
 622             keymap_config.swap_lalt_lgui = true;
 623             keymap_config.swap_ralt_rgui = true;
 624             #ifdef AUDIO_ENABLE
 625               PLAY_SONG(ag_swap_song);
 626             #endif
 627             break;
 628           case MAGIC_UNSWAP_CONTROL_CAPSLOCK:
 629             keymap_config.swap_control_capslock = false;
 630             break;
 631           case MAGIC_UNCAPSLOCK_TO_CONTROL:
 632             keymap_config.capslock_to_control = false;
 633             break;
 634           case MAGIC_UNSWAP_LALT_LGUI:
 635             keymap_config.swap_lalt_lgui = false;
 636             break;
 637           case MAGIC_UNSWAP_RALT_RGUI:
 638             keymap_config.swap_ralt_rgui = false;
 639             break;
 640           case MAGIC_UNNO_GUI:
 641             keymap_config.no_gui = false;
 642             break;
 643           case MAGIC_UNSWAP_GRAVE_ESC:
 644             keymap_config.swap_grave_esc = false;
 645             break;
 646           case MAGIC_UNSWAP_BACKSLASH_BACKSPACE:
 647             keymap_config.swap_backslash_backspace = false;
 648             break;
 649           case MAGIC_UNHOST_NKRO:
 650             keymap_config.nkro = false;
 651             break;
 652           case MAGIC_UNSWAP_ALT_GUI:
 653             keymap_config.swap_lalt_lgui = false;
 654             keymap_config.swap_ralt_rgui = false;
 655             #ifdef AUDIO_ENABLE
 656               PLAY_SONG(ag_norm_song);
 657             #endif
 658             break;
 659           case MAGIC_TOGGLE_ALT_GUI:
 660             keymap_config.swap_lalt_lgui = !keymap_config.swap_lalt_lgui;
 661             keymap_config.swap_ralt_rgui = !keymap_config.swap_ralt_rgui;
 662             #ifdef AUDIO_ENABLE
 663               if (keymap_config.swap_ralt_rgui) {
 664                 PLAY_SONG(ag_swap_song);
 665               } else {
 666                 PLAY_SONG(ag_norm_song);
 667               }
 668             #endif
 669             break;
 670           case MAGIC_TOGGLE_NKRO:
 671             keymap_config.nkro = !keymap_config.nkro;
 672             break;
 673           default:
 674             break;
 675         }
 676         eeconfig_update_keymap(keymap_config.raw);
 677         clear_keyboard(); // clear to prevent stuck keys
 678
 679         return false;
 680       }
 681       break;
 682     case KC_LSPO: {
 683       if (record->event.pressed) {
 684         shift_interrupted[0] = false;
 685         scs_timer[0] = timer_read ();
 686         register_mods(MOD_BIT(KC_LSFT));
 687       }
 688       else {
 689         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 690           if (get_mods() & MOD_BIT(RSPC_MOD)) {
 691             shift_interrupted[0] = true;
 692             shift_interrupted[1] = true;
 693           }
 694         #endif
 695         if (!shift_interrupted[0] && timer_elapsed(scs_timer[0]) < TAPPING_TERM) {
 696           #ifdef DISABLE_SPACE_CADET_MODIFIER
 697             unregister_mods(MOD_BIT(KC_LSFT));
 698           #else
 699             if( LSPO_MOD != KC_LSFT ){
 700               unregister_mods(MOD_BIT(KC_LSFT));
 701               register_mods(MOD_BIT(LSPO_MOD));
 702             }
 703           #endif
 704           register_code(LSPO_KEY);
 705           unregister_code(LSPO_KEY);
 706           #ifndef DISABLE_SPACE_CADET_MODIFIER
 707             if( LSPO_MOD != KC_LSFT ){
 708               unregister_mods(MOD_BIT(LSPO_MOD));
 709             }
 710           #endif
 711         }
 712         unregister_mods(MOD_BIT(KC_LSFT));
 713       }
 714       return false;
 715     }
 716
 717     case KC_RSPC: {
 718       if (record->event.pressed) {
 719         shift_interrupted[1] = false;
 720         scs_timer[1] = timer_read ();
 721         register_mods(MOD_BIT(KC_RSFT));
 722       }
 723       else {
 724         #ifdef DISABLE_SPACE_CADET_ROLLOVER
 725           if (get_mods() & MOD_BIT(LSPO_MOD)) {
 726             shift_interrupted[0] = true;
 727             shift_interrupted[1] = true;
 728           }
 729         #endif
 730         if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
 731           #ifdef DISABLE_SPACE_CADET_MODIFIER
 732             unregister_mods(MOD_BIT(KC_RSFT));
 733           #else
 734             if( RSPC_MOD != KC_RSFT ){
 735               unregister_mods(MOD_BIT(KC_RSFT));
 736               register_mods(MOD_BIT(RSPC_MOD));
 737             }
 738           #endif
 739           register_code(RSPC_KEY);
 740           unregister_code(RSPC_KEY);
 741           #ifndef DISABLE_SPACE_CADET_MODIFIER
 742             if ( RSPC_MOD != KC_RSFT ){
 743               unregister_mods(MOD_BIT(RSPC_MOD));
 744             }
 745           #endif
 746         }
 747         unregister_mods(MOD_BIT(KC_RSFT));
 748       }
 749       return false;
 750     }
 751
 752     case KC_SFTENT: {
 753       if (record->event.pressed) {
 754         shift_interrupted[1] = false;
 755         scs_timer[1] = timer_read ();
 756         register_mods(MOD_BIT(KC_RSFT));
 757       }
 758       else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
 759         unregister_mods(MOD_BIT(KC_RSFT));
 760         register_code(SFTENT_KEY);
 761         unregister_code(SFTENT_KEY);
 762       }
 763       else {
 764         unregister_mods(MOD_BIT(KC_RSFT));
 765       }
 766       return false;
 767     }
 768
 769     case GRAVE_ESC: {
 770       uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
 771                                       |MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));
 772
 773 #ifdef GRAVE_ESC_ALT_OVERRIDE
 774       // if ALT is pressed, ESC is always sent
 775       // this is handy for the cmd+opt+esc shortcut on macOS, among other things.
 776       if (get_mods() & (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT))) {
 777         shifted = 0;
 778       }
 779 #endif
 780
 781 #ifdef GRAVE_ESC_CTRL_OVERRIDE
 782       // if CTRL is pressed, ESC is always sent
 783       // this is handy for the ctrl+shift+esc shortcut on windows, among other things.
 784       if (get_mods() & (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL))) {
 785         shifted = 0;
 786       }
 787 #endif
 788
 789 #ifdef GRAVE_ESC_GUI_OVERRIDE
 790       // if GUI is pressed, ESC is always sent
 791       if (get_mods() & (MOD_BIT(KC_LGUI) | MOD_BIT(KC_RGUI))) {
 792         shifted = 0;
 793       }
 794 #endif
 795
 796 #ifdef GRAVE_ESC_SHIFT_OVERRIDE
 797       // if SHIFT is pressed, ESC is always sent
 798       if (get_mods() & (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) {
 799         shifted = 0;
 800       }
 801 #endif
 802
 803       if (record->event.pressed) {
 804         grave_esc_was_shifted = shifted;
 805         add_key(shifted ? KC_GRAVE : KC_ESCAPE);
 806       }
 807       else {
 808         del_key(grave_esc_was_shifted ? KC_GRAVE : KC_ESCAPE);
 809       }
 810
 811       send_keyboard_report();
 812       return false;
 813     }
 814
 815 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING)
 816     case BL_BRTG: {
 817       if (record->event.pressed)
 818         breathing_toggle();
 819       return false;
 820     }
 821 #endif
 822
 823     default: {
 824       shift_interrupted[0] = true;
 825       shift_interrupted[1] = true;
 826       break;
 827     }
 828   }
 829
 830   return process_action_kb(record);
 831 }
 832
 833 __attribute__ ((weak))
 834 const bool ascii_to_shift_lut[0x80] PROGMEM = {
 835     0, 0, 0, 0, 0, 0, 0, 0,
 836     0, 0, 0, 0, 0, 0, 0, 0,
 837     0, 0, 0, 0, 0, 0, 0, 0,
 838     0, 0, 0, 0, 0, 0, 0, 0,
 839     0, 1, 1, 1, 1, 1, 1, 0,
 840     1, 1, 1, 1, 0, 0, 0, 0,
 841     0, 0, 0, 0, 0, 0, 0, 0,
 842     0, 0, 1, 0, 1, 0, 1, 1,
 843     1, 1, 1, 1, 1, 1, 1, 1,
 844     1, 1, 1, 1, 1, 1, 1, 1,
 845     1, 1, 1, 1, 1, 1, 1, 1,
 846     1, 1, 1, 0, 0, 0, 1, 1,
 847     0, 0, 0, 0, 0, 0, 0, 0,
 848     0, 0, 0, 0, 0, 0, 0, 0,
 849     0, 0, 0, 0, 0, 0, 0, 0,
 850     0, 0, 0, 1, 1, 1, 1, 0
 851 };
 852
 853 __attribute__ ((weak))
 854 const bool ascii_to_alt_lut[0x80] PROGMEM = {
 855     0, 0, 0, 0, 0, 0, 0, 0,
 856     0, 0, 0, 0, 0, 0, 0, 0,
 857     0, 0, 0, 0, 0, 0, 0, 0,
 858     0, 0, 0, 0, 0, 0, 0, 0,
 859     0, 0, 0, 0, 0, 0, 0, 0,
 860     0, 0, 0, 0, 0, 0, 0, 0,
 861     0, 0, 0, 0, 0, 0, 0, 0,
 862     0, 0, 0, 0, 0, 0, 0, 0,
 863     0, 0, 0, 0, 0, 0, 0, 0,
 864     0, 0, 0, 0, 0, 0, 0, 0,
 865     0, 0, 0, 0, 0, 0, 0, 0,
 866     0, 0, 0, 0, 0, 0, 0, 0,
 867     0, 0, 0, 0, 0, 0, 0, 0,
 868     0, 0, 0, 0, 0, 0, 0, 0,
 869     0, 0, 0, 0, 0, 0, 0, 0,
 870     0, 0, 0, 0, 0, 0, 0, 0
 871 };
 872
 873 __attribute__ ((weak))
 874 const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = {
 875     0, 0, 0, 0, 0, 0, 0, 0,
 876     KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0,
 877     0, 0, 0, 0, 0, 0, 0, 0,
 878     0, 0, 0, KC_ESC, 0, 0, 0, 0,
 879     KC_SPC, KC_1, KC_QUOT, KC_3, KC_4, KC_5, KC_7, KC_QUOT,
 880     KC_9, KC_0, KC_8, KC_EQL, KC_COMM, KC_MINS, KC_DOT, KC_SLSH,
 881     KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7,
 882     KC_8, KC_9, KC_SCLN, KC_SCLN, KC_COMM, KC_EQL, KC_DOT, KC_SLSH,
 883     KC_2, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 884     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 885     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 886     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_6, KC_MINS,
 887     KC_GRV, KC_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G,
 888     KC_H, KC_I, KC_J, KC_K, KC_L, KC_M, KC_N, KC_O,
 889     KC_P, KC_Q, KC_R, KC_S, KC_T, KC_U, KC_V, KC_W,
 890     KC_X, KC_Y, KC_Z, KC_LBRC, KC_BSLS, KC_RBRC, KC_GRV, KC_DEL
 891 };
 892
 893 void send_string(const char *str) {
 894   send_string_with_delay(str, 0);
 895 }
 896
 897 void send_string_P(const char *str) {
 898   send_string_with_delay_P(str, 0);
 899 }
 900
 901 void send_string_with_delay(const char *str, uint8_t interval) {
 902     while (1) {
 903         char ascii_code = *str;
 904         if (!ascii_code) break;
 905         if (ascii_code == SS_TAP_CODE) {
 906           // tap
 907           uint8_t keycode = *(++str);
 908           register_code(keycode);
 909           unregister_code(keycode);
 910         } else if (ascii_code == SS_DOWN_CODE) {
 911           // down
 912           uint8_t keycode = *(++str);
 913           register_code(keycode);
 914         } else if (ascii_code == SS_UP_CODE) {
 915           // up
 916           uint8_t keycode = *(++str);
 917           unregister_code(keycode);
 918         } else {
 919           send_char(ascii_code);
 920         }
 921         ++str;
 922         // interval
 923         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 924     }
 925 }
 926
 927 void send_string_with_delay_P(const char *str, uint8_t interval) {
 928     while (1) {
 929         char ascii_code = pgm_read_byte(str);
 930         if (!ascii_code) break;
 931         if (ascii_code == SS_TAP_CODE) {
 932           // tap
 933           uint8_t keycode = pgm_read_byte(++str);
 934           register_code(keycode);
 935           unregister_code(keycode);
 936         } else if (ascii_code == SS_DOWN_CODE) {
 937           // down
 938           uint8_t keycode = pgm_read_byte(++str);
 939           register_code(keycode);
 940         } else if (ascii_code == SS_UP_CODE) {
 941           // up
 942           uint8_t keycode = pgm_read_byte(++str);
 943           unregister_code(keycode);
 944         } else {
 945           send_char(ascii_code);
 946         }
 947         ++str;
 948         // interval
 949         { uint8_t ms = interval; while (ms--) wait_ms(1); }
 950     }
 951 }
 952
 953 void send_char(char ascii_code) {
 954   uint8_t keycode;
 955   bool is_shifted = false;
 956   bool is_alted = false;
 957
 958   keycode = pgm_read_byte(&ascii_to_keycode_lut[(uint8_t)ascii_code]);
 959   if (pgm_read_byte(&ascii_to_shift_lut[(uint8_t)ascii_code])) {
 960     is_shifted = true;
 961   }
 962   if (pgm_read_byte(&ascii_to_alt_lut[(uint8_t)ascii_code])) {
 963     is_alted = true;
 964   }
 965
 966   if (is_shifted) {
 967     register_code(KC_LSFT);
 968   }
 969   if (is_alted) {
 970     register_code(KC_RALT);
 971   }
 972
 973   tap_code(keycode);
 974
 975   if (is_alted) {
 976     unregister_code(KC_RALT);
 977   }
 978   if (is_shifted) {
 979     unregister_code(KC_LSFT);
 980   }
 981 }
 982
 983 void set_single_persistent_default_layer(uint8_t default_layer) {
 984   #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
 985     PLAY_SONG(default_layer_songs[default_layer]);
 986   #endif
 987   eeconfig_update_default_layer(1U<<default_layer);
 988   default_layer_set(1U<<default_layer);
 989 }
 990
 991 uint32_t update_tri_layer_state(uint32_t state, uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 992   uint32_t mask12 = (1UL << layer1) | (1UL << layer2);
 993   uint32_t mask3 = 1UL << layer3;
 994   return (state & mask12) == mask12 ? (state | mask3) : (state & ~mask3);
 995 }
 996
 997 void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
 998   layer_state_set(update_tri_layer_state(layer_state, layer1, layer2, layer3));
 999 }
1000
1001 void tap_random_base64(void) {
1002   #if defined(__AVR_ATmega32U4__)
1003     uint8_t key = (TCNT0 + TCNT1 + TCNT3 + TCNT4) % 64;
1004   #else
1005     uint8_t key = rand() % 64;
1006   #endif
1007   switch (key) {
1008     case 0 ... 25:
1009       register_code(KC_LSFT);
1010       register_code(key + KC_A);
1011       unregister_code(key + KC_A);
1012       unregister_code(KC_LSFT);
1013       break;
1014     case 26 ... 51:
1015       register_code(key - 26 + KC_A);
1016       unregister_code(key - 26 + KC_A);
1017       break;
1018     case 52:
1019       register_code(KC_0);
1020       unregister_code(KC_0);
1021       break;
1022     case 53 ... 61:
1023       register_code(key - 53 + KC_1);
1024       unregister_code(key - 53 + KC_1);
1025       break;
1026     case 62:
1027       register_code(KC_LSFT);
1028       register_code(KC_EQL);
1029       unregister_code(KC_EQL);
1030       unregister_code(KC_LSFT);
1031       break;
1032     case 63:
1033       register_code(KC_SLSH);
1034       unregister_code(KC_SLSH);
1035       break;
1036   }
1037 }
1038
1039 __attribute__((weak))
1040 void bootmagic_lite(void) {
1041   // The lite version of TMK's bootmagic based on Wilba.
1042   // 100% less potential for accidentally making the
1043   // keyboard do stupid things.
1044
1045   // We need multiple scans because debouncing can't be turned off.
1046   matrix_scan();
1047   #if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
1048     wait_ms(DEBOUNCING_DELAY * 2);
1049   #elif defined(DEBOUNCE) && DEBOUNCE > 0
1050     wait_ms(DEBOUNCE * 2);
1051   #else
1052     wait_ms(30);
1053   #endif
1054   matrix_scan();
1055
1056   // If the Esc and space bar are held down on power up,
1057   // reset the EEPROM valid state and jump to bootloader.
1058   // Assumes Esc is at [0,0].
1059   // This isn't very generalized, but we need something that doesn't
1060   // rely on user's keymaps in firmware or EEPROM.
1061   if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
1062     eeconfig_disable();
1063     // Jump to bootloader.
1064     bootloader_jump();
1065   }
1066 }
1067
1068 void matrix_init_quantum() {
1069   #ifdef BOOTMAGIC_LITE
1070     bootmagic_lite();
1071   #endif
1072   if (!eeconfig_is_enabled()) {
1073     eeconfig_init();
1074   }
1075   #ifdef BACKLIGHT_ENABLE
1076     #ifdef LED_MATRIX_ENABLE
1077         led_matrix_init();
1078     #else
1079         backlight_init_ports();
1080     #endif
1081   #endif
1082   #ifdef AUDIO_ENABLE
1083     audio_init();
1084   #endif
1085   #ifdef RGB_MATRIX_ENABLE
1086     rgb_matrix_init();
1087   #endif
1088   #ifdef ENCODER_ENABLE
1089     encoder_init();
1090   #endif
1091   #if defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE)
1092     unicode_input_mode_init();
1093   #endif
1094   #ifdef HAPTIC_ENABLE
1095     haptic_init();
1096   #endif
1097   matrix_init_kb();
1098 }
1099
1100 void matrix_scan_quantum() {
1101   #if defined(AUDIO_ENABLE) && !defined(NO_MUSIC_MODE)
1102     matrix_scan_music();
1103   #endif
1104
1105   #ifdef TAP_DANCE_ENABLE
1106     matrix_scan_tap_dance();
1107   #endif
1108
1109   #ifdef COMBO_ENABLE
1110     matrix_scan_combo();
1111   #endif
1112
1113   #if defined(BACKLIGHT_ENABLE)
1114     #if defined(LED_MATRIX_ENABLE)
1115         led_matrix_task();
1116     #elif defined(BACKLIGHT_PIN)
1117         backlight_task();
1118     #endif
1119   #endif
1120
1121   #ifdef RGB_MATRIX_ENABLE
1122     rgb_matrix_task();
1123   #endif
1124
1125   #ifdef ENCODER_ENABLE
1126     encoder_read();
1127   #endif
1128
1129   #ifdef HAPTIC_ENABLE
1130     haptic_task();
1131   #endif
1132
1133   matrix_scan_kb();
1134 }
1135 #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_PIN)
1136
1137 static const uint8_t backlight_pin = BACKLIGHT_PIN;
1138
1139 // depending on the pin, we use a different output compare unit
1140 #if BACKLIGHT_PIN == B7
1141 #  define TCCRxA TCCR1A
1142 #  define TCCRxB TCCR1B
1143 #  define COMxx1 COM1C1
1144 #  define OCRxx  OCR1C
1145 #  define ICRx   ICR1
1146 #elif BACKLIGHT_PIN == B6
1147 #  define TCCRxA TCCR1A
1148 #  define TCCRxB TCCR1B
1149 #  define COMxx1 COM1B1
1150 #  define OCRxx  OCR1B
1151 #  define ICRx   ICR1
1152 #elif BACKLIGHT_PIN == B5
1153 #  define TCCRxA TCCR1A
1154 #  define TCCRxB TCCR1B
1155 #  define COMxx1 COM1A1
1156 #  define OCRxx  OCR1A
1157 #  define ICRx   ICR1
1158 #elif BACKLIGHT_PIN == C6
1159 #  define TCCRxA TCCR3A
1160 #  define TCCRxB TCCR3B
1161 #  define COMxx1 COM1A1
1162 #  define OCRxx  OCR3A
1163 #  define ICRx   ICR3
1164 #elif defined(__AVR_ATmega32A__) && BACKLIGHT_PIN == D4
1165 #  define TCCRxA TCCR1A
1166 #  define TCCRxB TCCR1B
1167 #  define COMxx1 COM1B1
1168 #  define OCRxx  OCR1B
1169 #  define ICRx   ICR1
1170 #  define TIMSK1 TIMSK
1171 #else
1172 #  define NO_HARDWARE_PWM
1173 #endif
1174
1175 #ifndef BACKLIGHT_ON_STATE
1176 #define BACKLIGHT_ON_STATE 0
1177 #endif
1178
1179 #ifdef NO_HARDWARE_PWM // pwm through software
1180
1181 __attribute__ ((weak))
1182 void backlight_init_ports(void)
1183 {
1184   // Setup backlight pin as output and output to on state.
1185   // DDRx |= n
1186   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1187   #if BACKLIGHT_ON_STATE == 0
1188     // PORTx &= ~n
1189     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1190   #else
1191     // PORTx |= n
1192     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1193   #endif
1194 }
1195
1196 __attribute__ ((weak))
1197 void backlight_set(uint8_t level) {}
1198
1199 uint8_t backlight_tick = 0;
1200
1201 #ifndef BACKLIGHT_CUSTOM_DRIVER
1202 void backlight_task(void) {
1203   if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) {
1204     #if BACKLIGHT_ON_STATE == 0
1205       // PORTx &= ~n
1206       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1207     #else
1208       // PORTx |= n
1209       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1210     #endif
1211   } else {
1212     #if BACKLIGHT_ON_STATE == 0
1213       // PORTx |= n
1214       _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1215     #else
1216       // PORTx &= ~n
1217       _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1218     #endif
1219   }
1220   backlight_tick = (backlight_tick + 1) % 16;
1221 }
1222 #endif
1223
1224 #ifdef BACKLIGHT_BREATHING
1225   #ifndef BACKLIGHT_CUSTOM_DRIVER
1226   #error "Backlight breathing only available with hardware PWM. Please disable."
1227   #endif
1228 #endif
1229
1230 #else // pwm through timer
1231
1232 #define TIMER_TOP 0xFFFFU
1233
1234 // See http://jared.geek.nz/2013/feb/linear-led-pwm
1235 static uint16_t cie_lightness(uint16_t v) {
1236   if (v <= 5243) // if below 8% of max
1237     return v / 9; // same as dividing by 900%
1238   else {
1239     uint32_t y = (((uint32_t) v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare
1240     // to get a useful result with integer division, we shift left in the expression above
1241     // and revert what we've done again after squaring.
1242     y = y * y * y >> 8;
1243     if (y > 0xFFFFUL) // prevent overflow
1244       return 0xFFFFU;
1245     else
1246       return (uint16_t) y;
1247   }
1248 }
1249
1250 // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val.
1251 static inline void set_pwm(uint16_t val) {
1252         OCRxx = val;
1253 }
1254
1255 #ifndef BACKLIGHT_CUSTOM_DRIVER
1256 __attribute__ ((weak))
1257 void backlight_set(uint8_t level) {
1258   if (level > BACKLIGHT_LEVELS)
1259     level = BACKLIGHT_LEVELS;
1260
1261   if (level == 0) {
1262     // Turn off PWM control on backlight pin
1263     TCCRxA &= ~(_BV(COMxx1));
1264   } else {
1265     // Turn on PWM control of backlight pin
1266     TCCRxA |= _BV(COMxx1);
1267   }
1268   // Set the brightness
1269   set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS));
1270 }
1271
1272 void backlight_task(void) {}
1273 #endif  // BACKLIGHT_CUSTOM_DRIVER
1274
1275 #ifdef BACKLIGHT_BREATHING
1276
1277 #define BREATHING_NO_HALT  0
1278 #define BREATHING_HALT_OFF 1
1279 #define BREATHING_HALT_ON  2
1280 #define BREATHING_STEPS 128
1281
1282 static uint8_t breathing_period = BREATHING_PERIOD;
1283 static uint8_t breathing_halt = BREATHING_NO_HALT;
1284 static uint16_t breathing_counter = 0;
1285
1286 bool is_breathing(void) {
1287     return !!(TIMSK1 & _BV(TOIE1));
1288 }
1289
1290 #define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0)
1291 #define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0)
1292 #define breathing_min() do {breathing_counter = 0;} while (0)
1293 #define breathing_max() do {breathing_counter = breathing_period * 244 / 2;} while (0)
1294
1295 void breathing_enable(void)
1296 {
1297   breathing_counter = 0;
1298   breathing_halt = BREATHING_NO_HALT;
1299   breathing_interrupt_enable();
1300 }
1301
1302 void breathing_pulse(void)
1303 {
1304     if (get_backlight_level() == 0)
1305       breathing_min();
1306     else
1307       breathing_max();
1308     breathing_halt = BREATHING_HALT_ON;
1309     breathing_interrupt_enable();
1310 }
1311
1312 void breathing_disable(void)
1313 {
1314     breathing_interrupt_disable();
1315     // Restore backlight level
1316     backlight_set(get_backlight_level());
1317 }
1318
1319 void breathing_self_disable(void)
1320 {
1321   if (get_backlight_level() == 0)
1322     breathing_halt = BREATHING_HALT_OFF;
1323   else
1324     breathing_halt = BREATHING_HALT_ON;
1325 }
1326
1327 void breathing_toggle(void) {
1328   if (is_breathing())
1329     breathing_disable();
1330   else
1331     breathing_enable();
1332 }
1333
1334 void breathing_period_set(uint8_t value)
1335 {
1336   if (!value)
1337     value = 1;
1338   breathing_period = value;
1339 }
1340
1341 void breathing_period_default(void) {
1342   breathing_period_set(BREATHING_PERIOD);
1343 }
1344
1345 void breathing_period_inc(void)
1346 {
1347   breathing_period_set(breathing_period+1);
1348 }
1349
1350 void breathing_period_dec(void)
1351 {
1352   breathing_period_set(breathing_period-1);
1353 }
1354
1355 /* To generate breathing curve in python:
1356  * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)]
1357  */
1358 static const uint8_t breathing_table[BREATHING_STEPS] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 17, 20, 24, 28, 32, 36, 41, 46, 51, 57, 63, 70, 76, 83, 91, 98, 106, 113, 121, 129, 138, 146, 154, 162, 170, 178, 185, 193, 200, 207, 213, 220, 225, 231, 235, 240, 244, 247, 250, 252, 253, 254, 255, 254, 253, 252, 250, 247, 244, 240, 235, 231, 225, 220, 213, 207, 200, 193, 185, 178, 170, 162, 154, 146, 138, 129, 121, 113, 106, 98, 91, 83, 76, 70, 63, 57, 51, 46, 41, 36, 32, 28, 24, 20, 17, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1359
1360 // Use this before the cie_lightness function.
1361 static inline uint16_t scale_backlight(uint16_t v) {
1362   return v / BACKLIGHT_LEVELS * get_backlight_level();
1363 }
1364
1365 /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run
1366  * about 244 times per second.
1367  */
1368 ISR(TIMER1_OVF_vect)
1369 {
1370   uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS;
1371   // resetting after one period to prevent ugly reset at overflow.
1372   breathing_counter = (breathing_counter + 1) % (breathing_period * 244);
1373   uint8_t index = breathing_counter / interval % BREATHING_STEPS;
1374
1375   if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) ||
1376       ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1)))
1377   {
1378       breathing_interrupt_disable();
1379   }
1380
1381   set_pwm(cie_lightness(scale_backlight((uint16_t) pgm_read_byte(&breathing_table[index]) * 0x0101U)));
1382 }
1383
1384 #endif // BACKLIGHT_BREATHING
1385
1386 __attribute__ ((weak))
1387 void backlight_init_ports(void)
1388 {
1389   // Setup backlight pin as output and output to on state.
1390   // DDRx |= n
1391   _SFR_IO8((backlight_pin >> 4) + 1) |= _BV(backlight_pin & 0xF);
1392   #if BACKLIGHT_ON_STATE == 0
1393     // PORTx &= ~n
1394     _SFR_IO8((backlight_pin >> 4) + 2) &= ~_BV(backlight_pin & 0xF);
1395   #else
1396     // PORTx |= n
1397     _SFR_IO8((backlight_pin >> 4) + 2) |= _BV(backlight_pin & 0xF);
1398   #endif
1399   // I could write a wall of text here to explain... but TL;DW
1400   // Go read the ATmega32u4 datasheet.
1401   // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on
1402
1403   // Pin PB7 = OCR1C (Timer 1, Channel C)
1404   // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0
1405   // (i.e. start high, go low when counter matches.)
1406   // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0
1407   // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1
1408
1409   /*
1410   14.8.3:
1411   "In fast PWM mode, the compare units allow generation of PWM waveforms on the OCnx pins. Setting the COMnx1:0 bits to two will produce a non-inverted PWM [..]."
1412   "In fast PWM mode the counter is incremented until the counter value matches either one of the fixed values 0x00FF, 0x01FF, or 0x03FF (WGMn3:0 = 5, 6, or 7), the value in ICRn (WGMn3:0 = 14), or the value in OCRnA (WGMn3:0 = 15)."
1413   */
1414   TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010;
1415   TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001;
1416   // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0.
1417   ICRx = TIMER_TOP;
1418
1419   backlight_init();
1420   #ifdef BACKLIGHT_BREATHING
1421     breathing_enable();
1422   #endif
1423 }
1424
1425 #endif // NO_HARDWARE_PWM
1426
1427 #else // backlight
1428
1429 __attribute__ ((weak))
1430 void backlight_init_ports(void) {}
1431
1432 __attribute__ ((weak))
1433 void backlight_set(uint8_t level) {}
1434
1435 #endif // backlight
1436
1437 #ifdef HD44780_ENABLED
1438 #include "hd44780.h"
1439 #endif
1440
1441
1442 // Functions for spitting out values
1443 //
1444
1445 void send_dword(uint32_t number) { // this might not actually work
1446     uint16_t word = (number >> 16);
1447     send_word(word);
1448     send_word(number & 0xFFFFUL);
1449 }
1450
1451 void send_word(uint16_t number) {
1452     uint8_t byte = number >> 8;
1453     send_byte(byte);
1454     send_byte(number & 0xFF);
1455 }
1456
1457 void send_byte(uint8_t number) {
1458     uint8_t nibble = number >> 4;
1459     send_nibble(nibble);
1460     send_nibble(number & 0xF);
1461 }
1462
1463 void send_nibble(uint8_t number) {
1464     switch (number) {
1465         case 0:
1466             register_code(KC_0);
1467             unregister_code(KC_0);
1468             break;
1469         case 1 ... 9:
1470             register_code(KC_1 + (number - 1));
1471             unregister_code(KC_1 + (number - 1));
1472             break;
1473         case 0xA ... 0xF:
1474             register_code(KC_A + (number - 0xA));
1475             unregister_code(KC_A + (number - 0xA));
1476             break;
1477     }
1478 }
1479
1480
1481 __attribute__((weak))
1482 uint16_t hex_to_keycode(uint8_t hex)
1483 {
1484   hex = hex & 0xF;
1485   if (hex == 0x0) {
1486     return KC_0;
1487   } else if (hex < 0xA) {
1488     return KC_1 + (hex - 0x1);
1489   } else {
1490     return KC_A + (hex - 0xA);
1491   }
1492 }
1493
1494 void api_send_unicode(uint32_t unicode) {
1495 #ifdef API_ENABLE
1496     uint8_t chunk[4];
1497     dword_to_bytes(unicode, chunk);
1498     MT_SEND_DATA(DT_UNICODE, chunk, 5);
1499 #endif
1500 }
1501
1502 __attribute__ ((weak))
1503 void led_set_user(uint8_t usb_led) {
1504
1505 }
1506
1507 __attribute__ ((weak))
1508 void led_set_kb(uint8_t usb_led) {
1509     led_set_user(usb_led);
1510 }
1511
1512 __attribute__ ((weak))
1513 void led_init_ports(void)
1514 {
1515
1516 }
1517
1518 __attribute__ ((weak))
1519 void led_set(uint8_t usb_led)
1520 {
1521
1522   // Example LED Code
1523   //
1524     // // Using PE6 Caps Lock LED
1525     // if (usb_led & (1<<USB_LED_CAPS_LOCK))
1526     // {
1527     //     // Output high.
1528     //     DDRE |= (1<<6);
1529     //     PORTE |= (1<<6);
1530     // }
1531     // else
1532     // {
1533     //     // Output low.
1534     //     DDRE &= ~(1<<6);
1535     //     PORTE &= ~(1<<6);
1536     // }
1537
1538 #if defined(BACKLIGHT_CAPS_LOCK) && defined(BACKLIGHT_ENABLE)
1539   // Use backlight as Caps Lock indicator
1540   uint8_t bl_toggle_lvl = 0;
1541
1542   if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK) && !backlight_config.enable) {
1543     // Turning Caps Lock ON and backlight is disabled in config
1544     // Toggling backlight to the brightest level
1545     bl_toggle_lvl = BACKLIGHT_LEVELS;
1546   } else if (IS_LED_OFF(usb_led, USB_LED_CAPS_LOCK) && backlight_config.enable) {
1547     // Turning Caps Lock OFF and backlight is enabled in config
1548     // Toggling backlight and restoring config level
1549     bl_toggle_lvl = backlight_config.level;
1550   }
1551
1552   // Set level without modify backlight_config to keep ability to restore state
1553   backlight_set(bl_toggle_lvl);
1554 #endif
1555
1556   led_set_kb(usb_led);
1557 }
1558
1559
1560 //------------------------------------------------------------------------------
1561 // Override these functions in your keymap file to play different tunes on
1562 // different events such as startup and bootloader jump
1563
1564 __attribute__ ((weak))
1565 void startup_user() {}
1566
1567 __attribute__ ((weak))
1568 void shutdown_user() {}
1569
1570 //------------------------------------------------------------------------------