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