qmk_firmware

QMK firmware for my keyboards (Corne, Sweep Ferris) and trackball (Ploopy Adept)
Log | Files | Refs | Submodules | LICENSE

secure.c (2411B)

      1 // Copyright 2022 QMK
      2 // SPDX-License-Identifier: GPL-2.0-or-later
      3 
      4 #include "secure.h"
      5 #include "timer.h"
      6 #include "util.h"
      7 
      8 #ifndef SECURE_UNLOCK_TIMEOUT
      9 #    define SECURE_UNLOCK_TIMEOUT 5000
     10 #endif
     11 
     12 #ifndef SECURE_IDLE_TIMEOUT
     13 #    define SECURE_IDLE_TIMEOUT 60000
     14 #endif
     15 
     16 #ifndef SECURE_UNLOCK_SEQUENCE
     17 #    define SECURE_UNLOCK_SEQUENCE {{0, 0}}
     18 #endif
     19 
     20 static secure_status_t secure_status = SECURE_LOCKED;
     21 static uint32_t        unlock_time   = 0;
     22 static uint32_t        idle_time     = 0;
     23 
     24 static void secure_hook(secure_status_t secure_status) {
     25     secure_hook_quantum(secure_status);
     26     secure_hook_kb(secure_status);
     27 }
     28 
     29 secure_status_t secure_get_status(void) {
     30     return secure_status;
     31 }
     32 
     33 void secure_lock(void) {
     34     secure_status = SECURE_LOCKED;
     35     secure_hook(secure_status);
     36 }
     37 
     38 void secure_unlock(void) {
     39     secure_status = SECURE_UNLOCKED;
     40     idle_time     = timer_read32();
     41     secure_hook(secure_status);
     42 }
     43 
     44 void secure_request_unlock(void) {
     45     if (secure_status == SECURE_LOCKED) {
     46         secure_status = SECURE_PENDING;
     47         unlock_time   = timer_read32();
     48     }
     49     secure_hook(secure_status);
     50 }
     51 
     52 void secure_activity_event(void) {
     53     if (secure_status == SECURE_UNLOCKED) {
     54         idle_time = timer_read32();
     55     }
     56 }
     57 
     58 void secure_keypress_event(uint8_t row, uint8_t col) {
     59     static const uint8_t sequence[][2] = SECURE_UNLOCK_SEQUENCE;
     60     static const uint8_t sequence_len  = ARRAY_SIZE(sequence);
     61 
     62     static uint8_t offset = 0;
     63     if ((sequence[offset][0] == row) && (sequence[offset][1] == col)) {
     64         offset++;
     65         if (offset == sequence_len) {
     66             offset = 0;
     67             secure_unlock();
     68         }
     69     } else {
     70         offset = 0;
     71         secure_lock();
     72     }
     73 }
     74 
     75 void secure_task(void) {
     76 #if SECURE_UNLOCK_TIMEOUT != 0
     77     // handle unlock timeout
     78     if (secure_status == SECURE_PENDING) {
     79         if (timer_elapsed32(unlock_time) >= SECURE_UNLOCK_TIMEOUT) {
     80             secure_lock();
     81         }
     82     }
     83 #endif
     84 
     85 #if SECURE_IDLE_TIMEOUT != 0
     86     // handle idle timeout
     87     if (secure_status == SECURE_UNLOCKED) {
     88         if (timer_elapsed32(idle_time) >= SECURE_IDLE_TIMEOUT) {
     89             secure_lock();
     90         }
     91     }
     92 #endif
     93 }
     94 
     95 __attribute__((weak)) bool secure_hook_user(secure_status_t secure_status) {
     96     return true;
     97 }
     98 __attribute__((weak)) bool secure_hook_kb(secure_status_t secure_status) {
     99     return secure_hook_user(secure_status);
    100 }