hal_keyboard.h

#ifndef KEYBOARD_H
#define KEYBOARD_H
#include <stdint.h>
#include "./hal/hal_global.h"

#define KB_MAX_CURR_KEY 6

#define KB_INTR_SCAN_DONE 0x1
#define KB_INTR_UPDATE 0x2
#define KB_INTR_TOO_MANY_KEYS 0x4
#define KB_INTR_PAUSE 0x8

#define KB_MAX_ROW_NUM 14
#define KB_MAX_COL_NUM 14

enum kb_err_t{
    KB_ERR_OK = 0,
    KB_ERR_INVALID_PARAM = -1,
    KB_ERR_INIT = -2,
    KB_ERR_MUTEX = -3,
};




typedef enum
{
    KB_PRESS = 0,
    KB_RELEASE,   
    //KB_LONG_PRESS,    
 
} kb_event_t;
typedef struct {
    uint8_t row; 
    uint8_t col; 
    uint8_t col_output; 
    uint32_t col_mask; 
    uint32_t row_mask; 
    int prio; 
    void * arg; 
    void (*cb)(void* arg, uint8_t row, uint8_t col, int event); 
} kb_init_t;







static __inline void kb_intr_mask_clear(uint32_t val)
{
    WR_WORD(KEYBOARD_REG_INTR_MASK_CLEAR, val);
}
static __inline void kb_intr_clear(uint32_t val)
{
    WR_WORD(KEYBOARD_REG_INTR_CLEAR, val);
}
static __inline void kb_intr_set(uint32_t val)
{
    WR_WORD(KEYBOARD_REG_INTR_SET, val);
}
static __inline void kb_intr_mask_set(uint32_t val)
{
    WR_WORD(KEYBOARD_REG_INTR_MASK_SET, val);
}

static __inline void  kb_enable(void)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_MISC_CTRL);
    reg |= KEYBOARD_REG_MISC_CTRL_CTL_ENABLE;
    WR_WORD(KEYBOARD_REG_MISC_CTRL, reg);
}
static __inline void  kb_disable(void)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_MISC_CTRL);
    reg &= ~KEYBOARD_REG_MISC_CTRL_CTL_ENABLE;
    WR_WORD(KEYBOARD_REG_MISC_CTRL, reg);
}
static __inline void kb_wait_key(int wait)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_MISC_CTRL);
    
    if (wait) {
        reg |= KEYBOARD_REG_MISC_CTRL_CTL_WAIT_KEY_PRESS_BETWEEN_SCAN;
    } else {
        reg &= ~KEYBOARD_REG_MISC_CTRL_CTL_WAIT_KEY_PRESS_BETWEEN_SCAN;
    }
    WR_WORD(KEYBOARD_REG_MISC_CTRL, reg);
}
static __inline void kb_set_num_col(uint32_t val)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_MISC_CTRL);
    reg &= ~KEYBOARD_REG_MISC_CTRL_CTL_NUM_COL;
    reg |= (val&KEYBOARD_REG_MISC_CTRL_CTL_NUM_COL_MASK)<<KEYBOARD_REG_MISC_CTRL_CTL_NUM_COL_SHIFT;
    WR_WORD(KEYBOARD_REG_MISC_CTRL, reg);
}
static __inline void kb_set_num_row(uint32_t val)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_MISC_CTRL);
    reg &= ~KEYBOARD_REG_MISC_CTRL_CTL_NUM_ROW;
    reg |= (val&KEYBOARD_REG_MISC_CTRL_CTL_NUM_ROW_MASK)<<KEYBOARD_REG_MISC_CTRL_CTL_NUM_ROW_SHIFT;
    WR_WORD(KEYBOARD_REG_MISC_CTRL, reg);
}
static __inline void kb_set_max_num_key(uint32_t val)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_MISC_CTRL);
    reg &= ~KEYBOARD_REG_MISC_CTRL_CTL_MAX_NUM_KEY_PRESSED;
    reg |= (val&KEYBOARD_REG_MISC_CTRL_CTL_MAX_NUM_KEY_PRESSED_MASK)<<KEYBOARD_REG_MISC_CTRL_CTL_MAX_NUM_KEY_PRESSED_SHIFT;
    WR_WORD(KEYBOARD_REG_MISC_CTRL, reg);
}
static __inline void kb_col_output_inv(int val)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_MISC_CTRL);
    
    if (val) {
        reg |= KEYBOARD_REG_MISC_CTRL_CTL_COL_OUTPUT_INV;
    } else {
        reg &= ~KEYBOARD_REG_MISC_CTRL_CTL_COL_OUTPUT_INV;
    }
    WR_WORD(KEYBOARD_REG_MISC_CTRL, reg);
}


static __inline void kb_reset(void)
{
    uint32_t val = RD_WORD(GLOBAL_REG_RESET_CTRL_1);
    
    WR_WORD(GLOBAL_REG_RESET_CTRL_1, val & (~0x2)); //GLOBAL_REG_RESET_CTRL_1_CTL_RESET_1_D0_CPU_KEYBOARD_RSTN_REG
    delay_us(10);
    WR_WORD(GLOBAL_REG_RESET_CTRL_1, val | 0x2);
}

static __inline void kb_set_col_mask(uint32_t val)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_COL_ROW_MASK);
    reg &= ~KEYBOARD_REG_COL_ROW_MASK_CTL_KEYBOARD_COL_MASK;
    reg |= (val&KEYBOARD_REG_COL_ROW_MASK_CTL_KEYBOARD_COL_MASK_MASK)<<KEYBOARD_REG_COL_ROW_MASK_CTL_KEYBOARD_COL_MASK_SHIFT;
    WR_WORD(KEYBOARD_REG_COL_ROW_MASK, reg);
}
static __inline void kb_set_row_mask(uint32_t val)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_COL_ROW_MASK);
    reg &= ~KEYBOARD_REG_COL_ROW_MASK_CTL_KEYBOARD_ROW_MASK;
    reg |= (val&KEYBOARD_REG_COL_ROW_MASK_CTL_KEYBOARD_ROW_MASK_MASK)<<KEYBOARD_REG_COL_ROW_MASK_CTL_KEYBOARD_ROW_MASK_SHIFT;
    WR_WORD(KEYBOARD_REG_COL_ROW_MASK, reg);
}
static __inline void kb_set_scan_interval(uint32_t val)
{
    WR_WORD(KEYBOARD_REG_SCAN_INTERVAL, val&KEYBOARD_REG_SCAN_INTERVAL_CTL_SCAN_INTERVAL_MASK);
}
static __inline void kb_set_us_cnt_lmt(uint32_t val)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_SCAN_TIMING_CONTROL);
    reg &= ~KEYBOARD_REG_SCAN_TIMING_CONTROL_CTL_US_CNT_LMT;
    reg |= (val&KEYBOARD_REG_SCAN_TIMING_CONTROL_CTL_US_CNT_LMT_MASK)<<KEYBOARD_REG_SCAN_TIMING_CONTROL_CTL_US_CNT_LMT_SHIFT;
    WR_WORD(KEYBOARD_REG_SCAN_TIMING_CONTROL, reg);
}

static __inline void kb_set_deglitch(uint32_t val)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_SCAN_TIMING_CONTROL);
    reg &= ~KEYBOARD_REG_SCAN_TIMING_CONTROL_CTL_DEGLITCH_CNT_LMT;
    reg |= (val&KEYBOARD_REG_SCAN_TIMING_CONTROL_CTL_DEGLITCH_CNT_LMT_MASK)<<KEYBOARD_REG_SCAN_TIMING_CONTROL_CTL_DEGLITCH_CNT_LMT_SHIFT;
    WR_WORD(KEYBOARD_REG_SCAN_TIMING_CONTROL, reg);
}

static __inline void kb_manual_start(int en)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_MANUAL_START);
    if (en) {
        reg |= KEYBOARD_REG_MANUAL_START_CTL_MANUAL_START;
    } else {
        reg &= ~KEYBOARD_REG_MANUAL_START_CTL_MANUAL_START;
    }
    WR_WORD(KEYBOARD_REG_MANUAL_START, reg);
}
static __inline void kb_manual_set_pre_key(int en)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_MANUAL_START);
    if (en) {
        reg |= KEYBOARD_REG_MANUAL_START_CTL_MANUAL_SET_PREV_KEY;
    } else {
        reg &= ~KEYBOARD_REG_MANUAL_START_CTL_MANUAL_SET_PREV_KEY;
    }
    WR_WORD(KEYBOARD_REG_MANUAL_START, reg);
}
static __inline void kb_manual_pre_num_key(uint8_t num)
{
    uint32_t reg = RD_WORD(KEYBOARD_REG_MANUAL_START);
    reg &= ~KEYBOARD_REG_MANUAL_START_CTL_MANUAL_PREV_NUM_KEY;
    reg |= (num&KEYBOARD_REG_MANUAL_START_CTL_MANUAL_PREV_NUM_KEY_MASK)<<KEYBOARD_REG_MANUAL_START_CTL_MANUAL_PREV_NUM_KEY_SHIFT;
    WR_WORD(KEYBOARD_REG_MANUAL_START, reg);
}
static __inline void kb_manual_key_press03(uint32_t val)
{
    WR_WORD(KEYBOARD_REG_MANUAL_KEY_PRESS_0TO3, val);
}
static __inline void kb_manual_key_press45(uint32_t val)
{
    WR_WORD(KEYBOARD_REG_MANUAL_KEY_PRESS_45, val);
}
static __inline uint32_t kb_get_curr_num(void)
{
    return RD_WORD(KEYBOARD_REG_NUM_KEY_PRESS)&KEYBOARD_REG_NUM_KEY_PRESS_STS_CURR_NUM_KEY;
}
static __inline uint32_t kb_get_pre_num(void)
{
    return (RD_WORD(KEYBOARD_REG_NUM_KEY_PRESS)&KEYBOARD_REG_NUM_KEY_PRESS_STS_PREV_NUM_KEY)>>KEYBOARD_REG_NUM_KEY_PRESS_STS_PREV_NUM_KEY_SHIFT;
}
static __inline void kb_pin_mux_0(int id, uint32_t mux)
{
    uint32_t reg = RD_WORD(GLOBAL_REG_KEYBOARD_MUX_0);
    reg &= ~(0x3<<(id*2));
    reg |= (mux&0x3)<<(id*2);
    WR_WORD(GLOBAL_REG_KEYBOARD_MUX_0, reg);
}
static __inline void kb_pin_mux_1(int id, uint32_t mux)
{
    uint32_t reg = RD_WORD(GLOBAL_REG_KEYBOARD_MUX_1);
    reg &= ~(0x3<<(id*2));
    reg |= (mux&0x3)<<(id*2);
    WR_WORD(GLOBAL_REG_KEYBOARD_MUX_1, reg);
}


/***********************************************************************************
 * @brief Enable keyboad module
 * @return KB_ERR_OK if successful, otherwise failed
 * ************************************************************************************/  
int hal_kb_enable(void);


/***********************************************************************************
 * @brief Disable keyboad module
 * @return KB_ERR_OK if successful, otherwise failed
 * ************************************************************************************/  
int hal_kb_disable(void);


/************************************************************************************
 * @brief Open keyboard device
 * @param[in] init   init paramter, @see kb_init_t
 * @return @see enum kb_err_t
 * ***********************************************************************************/
int hal_kb_open(kb_init_t *init);

/************************************************************************************
 * @brief Close keyboard device
 * @return None
 * ***********************************************************************************/
void hal_kb_close(void);

/************************************************************************************
 * @brief Set scan interval
 * @param[in] interval   Scan interval after successful key detection, unit is us.
 * @return @see enum kb_err_t
 * ***********************************************************************************/
int hal_kb_set_scan_interval(uint32_t interval);

/************************************************************************************
 * @brief Set deglich count
 * @param[in] cnt   Number of scans with same result to claim a successful key detection. 
 * @return @see enum kb_err_t
 * ***********************************************************************************/
int hal_kb_set_deglitch(uint32_t cnt);

#endif