aboutsummaryrefslogtreecommitdiff
path: root/quantum/eeconfig.c
blob: f14e6ddf97c0bb462e9bdb43d07bc3db53845ff5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include "debug.h"
#include "eeconfig.h"
#include "action_layer.h"
#include "nvm_eeconfig.h"
#include "keycode_config.h"

#ifdef BACKLIGHT_ENABLE
#    include "backlight.h"
#endif // BACKLIGHT_ENABLE

#ifdef AUDIO_ENABLE
#    include "audio.h"
#endif // AUDIO_ENABLE

#ifdef RGBLIGHT_ENABLE
#    include "rgblight.h"
#endif // RGBLIGHT_ENABLE

#ifdef RGB_MATRIX_ENABLE
#    include "rgb_matrix_types.h"
#endif // RGB_MATRIX_ENABLE

#ifdef LED_MATRIX_ENABLE
#    include "led_matrix_types.h"
#endif // LED_MATRIX_ENABLE

#ifdef UNICODE_COMMON_ENABLE
#    include "unicode.h"
#endif // UNICODE_COMMON_ENABLE

#ifdef HAPTIC_ENABLE
#    include "haptic.h"
#endif // HAPTIC_ENABLE

#ifdef CONNECTION_ENABLE
#    include "connection.h"
#endif // CONNECTION_ENABLE

#ifdef VIA_ENABLE
bool via_eeprom_is_valid(void);
void via_eeprom_set_valid(bool valid);
void eeconfig_init_via(void);
#else
void dynamic_keymap_reset(void);
#endif // VIA_ENABLE

#ifndef NKRO_DEFAULT_ON
#    define NKRO_DEFAULT_ON false
#endif

__attribute__((weak)) void eeconfig_init_user(void) {
#if (EECONFIG_USER_DATA_SIZE) == 0
    // Reset user EEPROM value to blank, rather than to a set value
    eeconfig_update_user(0);
#endif // (EECONFIG_USER_DATA_SIZE) == 0
}

__attribute__((weak)) void eeconfig_init_kb(void) {
#if (EECONFIG_KB_DATA_SIZE) == 0
    // Reset Keyboard EEPROM value to blank, rather than to a set value
    eeconfig_update_kb(0);
#endif // (EECONFIG_KB_DATA_SIZE) == 0

    eeconfig_init_user();
}

void eeconfig_init_quantum(void) {
    nvm_eeconfig_erase();

    eeconfig_enable();

    debug_config_t debug_config = {0};
    eeconfig_update_debug(&debug_config);

    default_layer_state = (layer_state_t)1 << 0;
    eeconfig_update_default_layer(default_layer_state);

    keymap_config_t keymap_config = {
        .swap_control_capslock    = false,
        .capslock_to_control      = false,
        .swap_lalt_lgui           = false,
        .swap_ralt_rgui           = false,
        .no_gui                   = false,
        .swap_grave_esc           = false,
        .swap_backslash_backspace = false,
        .nkro                     = NKRO_DEFAULT_ON,
        .swap_lctl_lgui           = false,
        .swap_rctl_rgui           = false,
        .oneshot_enable           = true, // Enable oneshot by default
        .swap_escape_capslock     = false,
        .autocorrect_enable       = true, // Enable autocorrect by default
    };
    eeconfig_update_keymap(&keymap_config);

#ifdef BACKLIGHT_ENABLE
    backlight_config_t backlight_config = {0};
    eeconfig_update_backlight(&backlight_config);
#endif // BACKLIGHT_ENABLE

#ifdef AUDIO_ENABLE
    audio_config_t audio_config = {0};
    eeconfig_update_audio(&audio_config);
#endif // AUDIO_ENABLE

#ifdef RGBLIGHT_ENABLE
    extern void eeconfig_update_rgblight_default(void);
    eeconfig_update_rgblight_default();
#endif // RGBLIGHT_ENABLE

#ifdef UNICODE_COMMON_ENABLE
    unicode_config_t unicode_config = {0};
    eeconfig_update_unicode_mode(&unicode_config);
#endif // UNICODE_COMMON_ENABLE

#ifdef STENO_ENABLE
    eeconfig_update_steno_mode(0);
#endif // STENO_ENABLE

#ifdef RGB_MATRIX_ENABLE
    extern void eeconfig_update_rgb_matrix_default(void);
    eeconfig_update_rgb_matrix_default();
#endif

#ifdef LED_MATRIX_ENABLE
    extern void eeconfig_update_led_matrix_default(void);
    eeconfig_update_led_matrix_default();
#endif // LED_MATRIX_ENABLE

#ifdef HAPTIC_ENABLE
    haptic_config_t haptic_config = {0};
    eeconfig_update_haptic(&haptic_config);
    haptic_reset();
#endif // HAPTIC_ENABLE

#ifdef CONNECTION_ENABLE
    extern void eeconfig_update_connection_default(void);
    eeconfig_update_connection_default();
#endif // CONNECTION_ENABLE

#if (EECONFIG_KB_DATA_SIZE) > 0
    eeconfig_init_kb_datablock();
#endif // (EECONFIG_KB_DATA_SIZE) > 0

#if (EECONFIG_USER_DATA_SIZE) > 0
    eeconfig_init_user_datablock();
#endif // (EECONFIG_USER_DATA_SIZE) > 0

#if defined(VIA_ENABLE)
    // Invalidate VIA eeprom config, and then reset.
    // Just in case if power is lost mid init, this makes sure that it gets
    // properly re-initialized.
    eeconfig_init_via();
#elif defined(DYNAMIC_KEYMAP_ENABLE)
    dynamic_keymap_reset();
#endif

    eeconfig_init_kb();

#ifdef RGB_MATRIX_ENABLE
    extern void eeconfig_force_flush_rgb_matrix(void);
    eeconfig_force_flush_rgb_matrix();
#endif // RGB_MATRIX_ENABLE
#ifdef LED_MATRIX_ENABLE
    extern void eeconfig_force_flush_led_matrix(void);
    eeconfig_force_flush_led_matrix();
#endif // LED_MATRIX_ENABLE
}

void eeconfig_init(void) {
    eeconfig_init_quantum();
}

void eeconfig_enable(void) {
    nvm_eeconfig_enable();
}

void eeconfig_disable(void) {
    nvm_eeconfig_disable();
}

bool eeconfig_is_enabled(void) {
    bool is_eeprom_enabled = nvm_eeconfig_is_enabled();
#ifdef VIA_ENABLE
    if (is_eeprom_enabled) {
        is_eeprom_enabled = via_eeprom_is_valid();
    }
#endif // VIA_ENABLE
    return is_eeprom_enabled;
}

bool eeconfig_is_disabled(void) {
    bool is_eeprom_disabled = nvm_eeconfig_is_disabled();
#ifdef VIA_ENABLE
    if (!is_eeprom_disabled) {
        is_eeprom_disabled = !via_eeprom_is_valid();
    }
#endif // VIA_ENABLE
    return is_eeprom_disabled;
}

void eeconfig_read_debug(debug_config_t *debug_config) {
    nvm_eeconfig_read_debug(debug_config);
}
void eeconfig_update_debug(const debug_config_t *debug_config) {
    nvm_eeconfig_update_debug(debug_config);
}

layer_state_t eeconfig_read_default_layer(void) {
    return nvm_eeconfig_read_default_layer();
}
void eeconfig_update_default_layer(layer_state_t state) {
    nvm_eeconfig_update_default_layer(state);
}

void eeconfig_read_keymap(keymap_config_t *keymap_config) {
    nvm_eeconfig_read_keymap(keymap_config);
}
void eeconfig_update_keymap(const keymap_config_t *keymap_config) {
    nvm_eeconfig_update_keymap(keymap_config);
}

#ifdef AUDIO_ENABLE
void eeconfig_read_audio(audio_config_t *audio_config) {
    nvm_eeconfig_read_audio(audio_config);
}
void eeconfig_update_audio(const audio_config_t *audio_config) {
    nvm_eeconfig_update_audio(audio_config);
}
#endif // AUDIO_ENABLE

#ifdef UNICODE_COMMON_ENABLE
void eeconfig_read_unicode_mode(unicode_config_t *unicode_config) {
    return nvm_eeconfig_read_unicode_mode(unicode_config);
}
void eeconfig_update_unicode_mode(const unicode_config_t *unicode_config) {
    nvm_eeconfig_update_unicode_mode(unicode_config);
}
#endif // UNICODE_COMMON_ENABLE

#ifdef BACKLIGHT_ENABLE
void eeconfig_read_backlight(backlight_config_t *backlight_config) {
    nvm_eeconfig_read_backlight(backlight_config);
}
void eeconfig_update_backlight(const backlight_config_t *backlight_config) {
    nvm_eeconfig_update_backlight(backlight_config);
}
#endif // BACKLIGHT_ENABLE

#ifdef STENO_ENABLE
uint8_t eeconfig_read_steno_mode(void) {
    return nvm_eeconfig_read_steno_mode();
}
void eeconfig_update_steno_mode(uint8_t val) {
    nvm_eeconfig_update_steno_mode(val);
}
#endif // STENO_ENABLE

#ifdef RGB_MATRIX_ENABLE
void eeconfig_read_rgb_matrix(rgb_config_t *rgb_matrix_config) {
    nvm_eeconfig_read_rgb_matrix(rgb_matrix_config);
}
void eeconfig_update_rgb_matrix(const rgb_config_t *rgb_matrix_config) {
    nvm_eeconfig_update_rgb_matrix(rgb_matrix_config);
}
#endif // RGB_MATRIX_ENABLE

#ifdef LED_MATRIX_ENABLE
void eeconfig_read_led_matrix(led_eeconfig_t *led_matrix_config) {
    nvm_eeconfig_read_led_matrix(led_matrix_config);
}
void eeconfig_update_led_matrix(const led_eeconfig_t *led_matrix_config) {
    nvm_eeconfig_update_led_matrix(led_matrix_config);
}
#endif // LED_MATRIX_ENABLE

#ifdef RGBLIGHT_ENABLE
void eeconfig_read_rgblight(rgblight_config_t *rgblight_config) {
    nvm_eeconfig_read_rgblight(rgblight_config);
}
void eeconfig_update_rgblight(const rgblight_config_t *rgblight_config) {
    nvm_eeconfig_update_rgblight(rgblight_config);
}
#endif // RGBLIGHT_ENABLE

#if (EECONFIG_KB_DATA_SIZE) == 0
uint32_t eeconfig_read_kb(void) {
    return nvm_eeconfig_read_kb();
}
void eeconfig_update_kb(uint32_t val) {
    nvm_eeconfig_update_kb(val);
}
#endif // (EECONFIG_KB_DATA_SIZE) == 0

#if (EECONFIG_USER_DATA_SIZE) == 0
uint32_t eeconfig_read_user(void) {
    return nvm_eeconfig_read_user();
}
void eeconfig_update_user(uint32_t val) {
    nvm_eeconfig_update_user(val);
}
#endif // (EECONFIG_USER_DATA_SIZE) == 0

#ifdef HAPTIC_ENABLE
void eeconfig_read_haptic(haptic_config_t *haptic_config) {
    nvm_eeconfig_read_haptic(haptic_config);
}
void eeconfig_update_haptic(const haptic_config_t *haptic_config) {
    nvm_eeconfig_update_haptic(haptic_config);
}
#endif // HAPTIC_ENABLE

#ifdef CONNECTION_ENABLE
void eeconfig_read_connection(connection_config_t *config) {
    nvm_eeconfig_read_connection(config);
}
void eeconfig_update_connection(const connection_config_t *config) {
    nvm_eeconfig_update_connection(config);
}
#endif // CONNECTION_ENABLE

bool eeconfig_read_handedness(void) {
    return nvm_eeconfig_read_handedness();
}
void eeconfig_update_handedness(bool val) {
    nvm_eeconfig_update_handedness(val);
}

#if (EECONFIG_KB_DATA_SIZE) > 0
bool eeconfig_is_kb_datablock_valid(void) {
    return nvm_eeconfig_is_kb_datablock_valid();
}
uint32_t eeconfig_read_kb_datablock(void *data, uint32_t offset, uint32_t length) {
    return nvm_eeconfig_read_kb_datablock(data, offset, length);
}
uint32_t eeconfig_update_kb_datablock(const void *data, uint32_t offset, uint32_t length) {
    return nvm_eeconfig_update_kb_datablock(data, offset, length);
}
__attribute__((weak)) void eeconfig_init_kb_datablock(void) {
    nvm_eeconfig_init_kb_datablock();
}
#endif // (EECONFIG_KB_DATA_SIZE) > 0

#if (EECONFIG_USER_DATA_SIZE) > 0
bool eeconfig_is_user_datablock_valid(void) {
    return nvm_eeconfig_is_user_datablock_valid();
}
uint32_t eeconfig_read_user_datablock(void *data, uint32_t offset, uint32_t length) {
    return nvm_eeconfig_read_user_datablock(data, offset, length);
}
uint32_t eeconfig_update_user_datablock(const void *data, uint32_t offset, uint32_t length) {
    return nvm_eeconfig_update_user_datablock(data, offset, length);
}
__attribute__((weak)) void eeconfig_init_user_datablock(void) {
    nvm_eeconfig_init_user_datablock();
}
#endif // (EECONFIG_USER_DATA_SIZE) > 0