// Copyright 2020-2021 Beken
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "os/os.h"
#include "components/bluetooth/bk_ble_types.h"
#include <components/log.h>
#include "bluetooth_internal.h"
#include "bt_os_adapter.h"
#include "driver/int.h"
#include "sys_driver.h"
#include "bk_uart.h"
#include "gpio_driver.h"
#include <driver/int_types.h>
#include <driver/hal/hal_int_types.h>
#include "bk_drv_model.h"
#include <modules/pm.h>
#include <driver/pwr_clk.h>
#include <components/system.h>
#include <driver/uart.h>
#include "arch_interrupt.h"
#include <driver/gpio.h>
#include <os/mem.h>
#include <os/str.h>
#include <string.h>
#include "aon_pmu_hal.h"
//#include "bk_cal_ex.h"
#include "bk_rf_internal.h"
#include "driver/ckmn.h"
#include "sdkconfig.h"

#if CONFIG_CACHE_ENABLE
#include "cache.h"
#endif

#define BT_OSI_VERSION              0x00010001

typedef struct
{
    uint8_t is_oneshot;
    uint32_t ms;
    void *cb;
    void *arg;
    uint32_t len;
    uint32_t data[0];
} bluetooth_timer_t;

int coex_init_wrapper(void)
{
#if CONFIG_WIFI_ENABLE
    // extern int coex_init(void);
    // return coex_init();
#endif
    return BK_OK;
}

static bk_err_t bluetooth_int_isr_register_wrapper(uint8_t type, void *isr, void *arg)
{
    icu_int_src_t src = INT_SRC_BTDM;

    if (type == BLUETOOTH_INT_SRC_BTDM)
    {
        src = INT_SRC_BTDM;
    }
    else if (type == BLUETOOTH_INT_SRC_BLE)
    {
        src = INT_SRC_BLE;
    }
    else if (type == BLUETOOTH_INT_SRC_BT)
    {
        src = INT_SRC_BT;
    }
    else
    {
        //error
        return -1;
    }

    return bk_int_isr_register(src, (int_group_isr_t)isr, arg);
}

static bk_err_t init_queue_wrapper(void **queue, const char *name, uint32_t message_size, uint32_t number_of_messages)
{
    return rtos_init_queue(queue, name, message_size, number_of_messages);
}

static bk_err_t deinit_queue_wrapper(void **queue)
{
    return rtos_deinit_queue(queue);
}

static bk_err_t pop_from_queue_wrapper(void **queue, void *message, uint32_t timeout_ms)
{
    return rtos_pop_from_queue(queue, message, timeout_ms);
}

static bk_err_t push_to_queue_wrapper(void **queue, void *message, uint32_t timeout_ms)
{
    return rtos_push_to_queue(queue, message, timeout_ms);
}

static bk_err_t create_thread_wrapper(void **thread, uint8_t priority, const char *name,
                                      void *function, uint32_t stack_size, void *arg)
{
    return rtos_create_thread(thread, priority, name, function, stack_size, arg);
}

static bk_err_t delete_thread_wrapper(void **thread)
{
    return rtos_delete_thread(thread);
}

static int thread_join(void **thread)
{
    return rtos_thread_join(thread);
}

static void controller_mem_init_wrapper(void)
{
#if CONFIG_BT_REUSE_MEDIA_MEMORY

    extern char _bt_data_start, _bt_data_end;
    unsigned int size = &_bt_data_end - &_bt_data_start;

    memset(&_bt_data_start, 0, size);
#endif
}

static bk_err_t bluetooth_deep_sleep_register_wrapper(void *enter_config_cb)
{
    pm_cb_conf_t enter_conf_bt = {NULL, NULL};

    enter_conf_bt.cb = enter_config_cb;

    return bk_pm_sleep_register_cb(PM_MODE_DEEP_SLEEP, PM_DEV_ID_BTDM, &enter_conf_bt, NULL);
}

static bk_err_t bluetooth_extern32k_register_wrapper(void *switch_cb)
{
    pm_cb_extern32k_cfg_t bt_pm_cb_extern32k_cfg =
    {
        .cb_module = PM_32K_MODULE_BT,
        .cb_func = NULL,
    };

    bt_pm_cb_extern32k_cfg.cb_func = switch_cb;

    return pm_extern32k_register_cb(&bt_pm_cb_extern32k_cfg);
}

static bk_err_t bluetooth_extern32k_unregister_wrapper(void)
{
    pm_cb_extern32k_cfg_t bt_pm_cb_extern32k_cfg =
    {
        .cb_module = PM_32K_MODULE_BT,
        .cb_func = NULL,
    };

    return pm_extern32k_unregister_cb(&bt_pm_cb_extern32k_cfg);
}

static uint8_t clk_32k_customer_config_get_wrapper(void)
{
    uint8_t lpo_src = 0;
    pm_lpo_src_e src = bk_clk_32k_customer_config_get();

    if (PM_LPO_SRC_DIVD == src)
    {
        lpo_src = BT_LPO_SRC_DIVD;
    }
    else if (PM_LPO_SRC_X32K == src)
    {
        lpo_src = BT_LPO_SRC_X32K;
    }
    else if (PM_LPO_SRC_ROSC == src)
    {
        lpo_src = BT_LPO_SRC_ROSC;
    }
    else
    {
        lpo_src = BT_LPO_SRC_DEFAULT;
    }

    return lpo_src;
}

static bk_err_t lpo_src_set_wrapper(uint8_t lpo_src)
{
    pm_lpo_src_e src;

    if (BT_LPO_SRC_DIVD == lpo_src)
    {
        src = PM_LPO_SRC_DIVD;
    }
    else if (BT_LPO_SRC_X32K == lpo_src)
    {
        src = PM_LPO_SRC_X32K;
    }
    else if (BT_LPO_SRC_ROSC == lpo_src)
    {
        src = PM_LPO_SRC_ROSC;
    }
    else
    {
        src = PM_LPO_SRC_DEFAULT;
    }

    return bk_pm_lpo_src_set(src);
}

uint8_t lpo_src_get_wrapper(void)
{
    uint8_t lpo_src = 0;
    pm_lpo_src_e src = bk_pm_lpo_src_get();

    if (PM_LPO_SRC_DIVD == src)
    {
        lpo_src = BT_LPO_SRC_DIVD;
    }
    else if (PM_LPO_SRC_X32K == src)
    {
        lpo_src = BT_LPO_SRC_X32K;
    }
    else if (PM_LPO_SRC_ROSC == src)
    {
        lpo_src = BT_LPO_SRC_ROSC;
    }
    else
    {
        lpo_src = BT_LPO_SRC_DEFAULT;
    }

    return lpo_src;
}

static bk_err_t bluetooth_power_ctrl_wrapper(uint8_t power_state)
{
    pm_power_module_state_e state = (power_state ? PM_POWER_MODULE_STATE_ON : PM_POWER_MODULE_STATE_OFF);
    return bk_pm_module_vote_power_ctrl(PM_POWER_MODULE_NAME_BTSP, state);
}

static bk_err_t phy_power_ctrl_wrapper(uint8_t power_state)
{
    pm_power_module_state_e state = (power_state ? PM_POWER_MODULE_STATE_ON : PM_POWER_MODULE_STATE_OFF);
    return bk_pm_module_vote_power_ctrl(PM_POWER_SUB_MODULE_NAME_PHY_BT, state);
}

static bk_err_t bt_mac_clock_ctrl_wrapper(uint8_t clock_state)
{
    pm_dev_clk_pwr_e state = (clock_state ? PM_CLK_CTRL_PWR_UP : PM_CLK_CTRL_PWR_DOWN);
    return bk_pm_clock_ctrl(PM_CLK_ID_BTDM, state);
}

static bk_err_t bt_phy_clock_ctrl_wrapper(uint8_t clock_state)
{
    pm_dev_clk_pwr_e state = (clock_state ? PM_CLK_CTRL_PWR_UP : PM_CLK_CTRL_PWR_DOWN);
    return bk_pm_clock_ctrl(PM_CLK_ID_XVR, state);
}

static void btdm_interrupt_ctrl_wrapper(bool en)
{
    sys_drv_btdm_interrupt_ctrl(en);
}

static void ble_interrupt_ctrl_wrapper(bool en)
{
    sys_drv_ble_interrupt_ctrl(en);
}

static void bt_interrupt_ctrl_wrapper(bool en)
{
    sys_drv_bt_interrupt_ctrl(en);
}

static bool ate_is_enabled_wrapper(void)
{
    extern bool ate_is_enabled(void);
    return ate_is_enabled();
}

static bool cp_test_is_enabled_wrapper(void)
{
    extern bool cp_is_enabled(void);
    return cp_is_enabled();
}

static bk_err_t get_bluetooth_mac_wrapper(uint8_t *mac)
{
    return bk_get_mac(mac, MAC_TYPE_BLUETOOTH);
}

static bk_err_t uart_write_byte_wrapper(uint8_t id, uint8_t data)
{
    return uart_write_byte(id, data);
}

static void register_ble_dump_hook_wrapper(void *ble_func)
{
#if CONFIG_ARCH_RISCV
    rtos_regist_ble_dump_hook(ble_func);
#endif
}

static uint8_t get_ble_pwr_idx_wrapper(uint8_t channel)
{
    extern uint8_t manual_cal_get_ble_pwr_idx(uint8_t channel);
    return manual_cal_get_ble_pwr_idx(channel);
}

static void ble_cal_set_txpwr_wrapper(uint8_t idx)
{
    extern void ble_cal_set_txpwr(uint8_t idx);
    ble_cal_set_txpwr(idx);
}

static void ble_cal_recover_txpwr_wrapper(void)
{
    extern void ble_cal_recover_txpwr(void);
    ble_cal_recover_txpwr();
}

static void ble_cal_enter_txpwr_wrapper()
{
    extern void ble_cal_enter_txpwr(void);
    ble_cal_enter_txpwr();
}

static bk_err_t gpio_dev_unmap_wrapper(uint32_t gpio_id)
{
    return gpio_dev_unmap(gpio_id);
}

static bk_err_t gpio_dev_map_wrapper(uint32_t gpio_id, uint32_t func)
{
    return gpio_dev_map(gpio_id, func);
}


static void set_printf_enable_wrapper(uint8_t enable)
{
    bk_set_printf_enable(enable);
}

static void evm_stop_bypass_mac_wrapper(void)
{
#if CONFIG_WIFI_ENABLE
    extern void evm_stop_bypass_mac(void);
    evm_stop_bypass_mac();
#endif
}

static void rs_deinit_wrapper(void)
{
#if CONFIG_WIFI_ENABLE
    extern void rs_deinit();
    rs_deinit();
#endif
}

static bk_err_t uart_enable_rx_interrupt_wrapper(uint8_t id)
{
    return bk_uart_enable_rx_interrupt(id);
}

static bk_err_t uart_take_rx_isr_wrapper(uint8_t id, void *isr, void *param)
{
    return bk_uart_take_rx_isr(id, isr, param);
}

static void ble_vote_rf_ctrl_wrapper(uint8_t cmd)
{
    rf_module_vote_ctrl(cmd, RF_BY_BLE_BIT);
}

static void ble_ate_vote_rf_ctrl_wrapper(uint8_t cmd)
{
    rf_module_vote_ctrl(cmd, RF_BY_ATE_BT_BIT);
}

static bk_err_t delay_milliseconds_wrapper(uint32_t num_ms)
{
    return rtos_delay_milliseconds(num_ms);
}

static uint32_t disable_int_wrapper(void)
{
    return rtos_enter_critical();
}

static void enable_int_wrapper(uint32_t int_level)
{
    rtos_exit_critical(int_level);
}

static bk_err_t gpio_disable_pull_wrapper(uint32_t gpio_id)
{
    return bk_gpio_disable_pull(gpio_id);
}

static bk_err_t gpio_enable_output_wrapper(uint32_t gpio_id)
{
    return bk_gpio_enable_output(gpio_id);
}

static bk_err_t gpio_set_output_high_wrapper(uint32_t gpio_id)
{
    return bk_gpio_set_output_high(gpio_id);
}

static bk_err_t gpio_set_output_low_wrapper(uint32_t gpio_id)
{
    return bk_gpio_set_output_low(gpio_id);
}

static bk_err_t gpio_pull_down_wrapper(uint32_t gpio_id)
{
    return bk_gpio_pull_down(gpio_id);
}

static bk_err_t gpio_pull_up_wrapper(uint32_t gpio_id)
{
    return bk_gpio_pull_up(gpio_id);
}

static int get_printf_port_wrapper(void)
{
    return bk_get_printf_port();
}

static void uart_enable_wrapper(uint8_t uart_id, uint8_t enable, uint32_t band)
{
    bk_err_t ret = 0;

    if (enable)
    {
        uart_config_t config =
        {
            //.baud_rate = UART_BAUDRATE_115200,
            .baud_rate = UART_BAUDRATE_2000000,
            .data_bits = UART_DATA_8_BITS,
            .parity = UART_PARITY_NONE,
            .stop_bits = UART_STOP_BITS_1,
            .flow_ctrl = UART_FLOWCTRL_DISABLE,
            .src_clk = UART_SCLK_XTAL_26M
        };

        switch (band)
        {
            case 115200:
                config.baud_rate = UART_BAUDRATE_115200;
                break;

            case 921600:
                config.baud_rate = UART_BAUDRATE_921600;
                break;

            case 1000000:
                config.baud_rate = 1000000;
                break;

            case 3250000:
                config.baud_rate = UART_BAUDRATE_3250000;
                break;

            case 2000000:
            default:
                config.baud_rate = UART_BAUDRATE_2000000;
                break;
        }

        switch (uart_id)
        {
            case UART_ID_0:
                gpio_dev_unmap(GPIO_10);
                gpio_dev_unmap(GPIO_11);
                break;

            case UART_ID_1:
                gpio_dev_unmap(GPIO_0);
                gpio_dev_unmap(GPIO_1);
                break;

            case UART_ID_2:
                gpio_dev_unmap(GPIO_40);
                gpio_dev_unmap(GPIO_41);
                break;

            default:
                bk_printf("%s uart_id err %d\n", __func__, uart_id);
                return;
                break;
        }

        ret = bk_uart_init(uart_id, &config);

        if (ret != 0)
        {
            bk_printf("%s bk_uart_init err, ret %d\n", __func__, ret);
            return;
        }

        os_printf("%s ble uart %d enable\n", __func__, uart_id);
    }
    else
    {
        bk_uart_deinit(uart_id);
        os_printf("%s ble uart %d disable\n", __func__, uart_id);
    }
}

void enable_debug_gpio_wrapper(void)
{
    gpio_dev_unmap(GPIO_2);
    gpio_dev_map(GPIO_2, GPIO_DEV_DEBUG0);//CLK(H6)
    gpio_dev_unmap(GPIO_3);
    gpio_dev_map(GPIO_3, GPIO_DEV_DEBUG1);//CMD(H6)
    gpio_dev_unmap(GPIO_4);
    gpio_dev_map(GPIO_4, GPIO_DEV_DEBUG2);//D0(H6)
    gpio_dev_unmap(GPIO_5);
    gpio_dev_map(GPIO_5, GPIO_DEV_DEBUG3);//D1(H6)
    gpio_dev_unmap(GPIO_6);
    gpio_dev_map(GPIO_6, GPIO_DEV_DEBUG4);//CD(H6)
    gpio_dev_unmap(GPIO_7);
    gpio_dev_map(GPIO_7, GPIO_DEV_DEBUG5);//P7(H5)
    if (PM_LPO_SRC_X32K != bk_clk_32k_customer_config_get())
    {
        gpio_dev_unmap(GPIO_8);
        gpio_dev_map(GPIO_8, GPIO_DEV_DEBUG6);//P8(CON4)
        gpio_dev_unmap(GPIO_9);
        gpio_dev_map(GPIO_9, GPIO_DEV_DEBUG7);//P9(CON4)
    }
    else
    {
        bk_printf("%s, external 32k is in use, GPIO8 and GPIO9 can not be used to debug \r\n", __func__);
    }

    gpio_dev_unmap(GPIO_14);
    gpio_dev_map(GPIO_14, GPIO_DEV_DEBUG8);
    gpio_dev_unmap(GPIO_15);
    gpio_dev_map(GPIO_15, GPIO_DEV_DEBUG9);
    //gpio_dev_unmap(GPIO_16);
    //_gpio_dev_map_wrapper(GPIO_16, GPIO_DEV_DEBUG10);
    gpio_dev_unmap(GPIO_17);
    gpio_dev_map(GPIO_17, GPIO_DEV_DEBUG11);
    gpio_dev_unmap(GPIO_18);
    gpio_dev_map(GPIO_18, GPIO_DEV_DEBUG12);
    gpio_dev_unmap(GPIO_19);
    gpio_dev_map(GPIO_19, GPIO_DEV_DEBUG13);

    if (PM_LPO_SRC_X32K != bk_clk_32k_customer_config_get())
    {
        gpio_dev_unmap(GPIO_24);
        gpio_dev_map(GPIO_24, GPIO_DEV_DEBUG14);
    }
    else
    {
        bk_printf("%s, external 32k is in use, GPIO24 can not be used to debug \r\n", __func__);
    }

    gpio_dev_unmap(GPIO_25);
    gpio_dev_map(GPIO_25, GPIO_DEV_DEBUG15);

    gpio_dev_unmap(GPIO_26);
    gpio_dev_map(GPIO_26, GPIO_DEV_DEBUG16);
    gpio_dev_unmap(GPIO_27);
    gpio_dev_map(GPIO_27, GPIO_DEV_DEBUG17);
    gpio_dev_unmap(GPIO_28);
    gpio_dev_map(GPIO_28, GPIO_DEV_DEBUG18);
    gpio_dev_unmap(GPIO_29);
    gpio_dev_map(GPIO_29, GPIO_DEV_DEBUG19);
    gpio_dev_unmap(GPIO_30);
    gpio_dev_map(GPIO_30, GPIO_DEV_DEBUG20);
    gpio_dev_unmap(GPIO_31);
    gpio_dev_map(GPIO_31, GPIO_DEV_DEBUG21);
    gpio_dev_unmap(GPIO_32);
    gpio_dev_map(GPIO_32, GPIO_DEV_DEBUG22);
    gpio_dev_unmap(GPIO_33);
    gpio_dev_map(GPIO_33, GPIO_DEV_DEBUG23);

    gpio_dev_unmap(GPIO_34);
    gpio_dev_map(GPIO_34, GPIO_DEV_DEBUG24);
    gpio_dev_unmap(GPIO_35);
    gpio_dev_map(GPIO_35, GPIO_DEV_DEBUG25);
    gpio_dev_unmap(GPIO_36);
    gpio_dev_map(GPIO_36, GPIO_DEV_DEBUG26);
    gpio_dev_unmap(GPIO_37);
    gpio_dev_map(GPIO_37, GPIO_DEV_DEBUG27);
    gpio_dev_unmap(GPIO_38);
    gpio_dev_map(GPIO_38, GPIO_DEV_DEBUG28);
    gpio_dev_unmap(GPIO_39);
    gpio_dev_map(GPIO_39, GPIO_DEV_DEBUG29);
    gpio_dev_unmap(GPIO_42);
    gpio_dev_map(GPIO_42, GPIO_DEV_DEBUG30);
    gpio_dev_unmap(GPIO_43);
    gpio_dev_map(GPIO_43, GPIO_DEV_DEBUG31);
}


static uint32_t get_time_wrapper(void)
{
    return rtos_get_time();
}

static void *malloc_wrapper(size_t size)
{
    return os_malloc(size);
}

static void free_wrapper(void *ptr)
{
    os_free(ptr);
}


#define EVM_DEFUALT_BLE_RATE                   (158)
static void manual_cal_save_ble_txpwr_wrapper(uint32_t channel, uint32_t pwr_gain)
{
    extern void manual_cal_save_txpwr(UINT32 rate, UINT32 channel, UINT32 pwr_gain);
    manual_cal_save_txpwr(EVM_DEFUALT_BLE_RATE, channel, pwr_gain);
}


static void bluetooth_timer2_handler_cb(void *arg1, void *arg2)
{
    timer_handler_t func = (typeof(func))arg1;
    func(arg2);
}

static bool is_timer_init_wrapper(void *timer)
{
    bluetooth_timer_t *tmp = (typeof(tmp))timer;

    if (!tmp)
    {
        return 0;
    }

    if (tmp->is_oneshot)
    {
        return rtos_is_oneshot_timer_init((beken2_timer_t *)tmp->data);
    }
    else
    {
        return rtos_is_timer_init((beken_timer_t *)tmp->data);
    }
}

static int32_t init_timer_ext_wrapper(void **timer, uint32_t time_ms, void *function, void *arg, bool oneshot)
{
    int ret = 0;
    bluetooth_timer_t *tmp = NULL;
    uint32_t size = 0;

    if (oneshot)
    {
        size = sizeof(*tmp) + sizeof(beken2_timer_t);
        tmp = (typeof(tmp))os_malloc(size);
    }
    else
    {
        size = sizeof(*tmp) + sizeof(beken_timer_t);
        tmp = (typeof(tmp))os_malloc(size);
    }

    if (!tmp)
    {
        os_printf("%s, malloc failed\r\n", __func__);
        return -1;
    }

    os_memset(tmp, 0, size);
    tmp->len = size;
    tmp->is_oneshot = oneshot;
    tmp->cb = function;
    tmp->arg = arg;
    tmp->ms = time_ms;

    if (oneshot)
    {
        ret = rtos_init_oneshot_timer((beken2_timer_t *)tmp->data, time_ms, bluetooth_timer2_handler_cb, function, arg);
    }
    else
    {
        ret = rtos_init_timer((beken_timer_t *)tmp->data, time_ms, function, arg);
    }

    if (ret)
    {
        os_free(tmp);
    }
    else
    {
        *timer = (typeof(*timer))tmp;
    }

    return ret;
}

static int32_t init_timer_wrapper(void **timer, uint32_t time_ms, void *function, void *arg)
{
    return init_timer_ext_wrapper(timer, time_ms, function, arg, 0);
}

static int32_t start_timer_wrapper(void *timer)
{
    bluetooth_timer_t *tmp = (typeof(tmp))timer;

    if (!tmp)
    {
        return -1;
    }

    if (tmp->is_oneshot)
    {
        return rtos_start_oneshot_timer((beken2_timer_t *)tmp->data);
    }
    else
    {
        return rtos_start_timer((beken_timer_t *)tmp->data);
    }
}

static bool is_timer_running_wrapper(void *timer)
{
    bluetooth_timer_t *tmp = (typeof(tmp))timer;

    if (!tmp)
    {
        return 0;
    }

    if (tmp->is_oneshot)
    {
        return rtos_is_oneshot_timer_running((beken2_timer_t *)tmp->data);
    }
    else
    {
        return rtos_is_timer_running((beken_timer_t *)tmp->data);
    }
}

static int32_t stop_timer_wrapper(void *timer)
{
    bluetooth_timer_t *tmp = (typeof(tmp))timer;

    if (!tmp)
    {
        return -1;
    }

    if (tmp->is_oneshot)
    {
        return rtos_stop_oneshot_timer((beken2_timer_t *)tmp->data);
    }
    else
    {
        return rtos_stop_timer((beken_timer_t *)tmp->data);
    }
}

static int32_t deinit_timer_wrapper(void *timer)
{
    bk_err_t ret = 0;
    bluetooth_timer_t *tmp = (typeof(tmp))timer;

    if (!tmp)
    {
        return -1;
    }

    if (tmp->is_oneshot)
    {
        ret = rtos_deinit_oneshot_timer((beken2_timer_t *)tmp->data);
    }
    else
    {
        ret = rtos_deinit_timer((beken_timer_t *)tmp->data);
    }

    os_free(tmp);

    return ret;
}

static int32_t timer_change_period(void *timer, uint32_t time_ms)
{
    bluetooth_timer_t *tmp = (typeof(tmp))timer;

    if (!tmp)
    {
        return -1;
    }

    if (tmp->is_oneshot)
    {
        tmp->ms = time_ms;
        return rtos_oneshot_reload_timer_ex((beken2_timer_t *)tmp->data, tmp->ms, bluetooth_timer2_handler_cb, tmp->cb, tmp->arg);
    }
    else
    {
        return rtos_change_period((beken_timer_t *)tmp->data, time_ms);
    }
}

#if 0
#define RF_WIFIPLL_HOLD_BY_BLE_BIT                   (1 << 1)
#define RF_WIFIPLL_HOLD_BY_WIFI_BIT                  (1 << 0)

enum
{
    CMD_RF_WIFIPLL_HOLD_BIT_SET,
    CMD_RF_WIFIPLL_HOLD_BIT_CLR,
};

//extern UINT32 rf_pll_ctrl(UINT32 cmd, UINT32 param);
__attribute__((weak)) uint32_t rf_pll_ctrl(uint32_t cmd, uint32_t param)
{
    BK_ASSERT_EX(0, "%s this func shout not call !!!!!\n");
    return 0;
}
#endif

static uint32_t bt_rf_pll_ctrl_wrapper(uint32_t set)
{
#if CONFIG_WIFI_ENABLE
    uint32_t cmd = (set ? CMD_RF_WIFIPLL_HOLD_BIT_SET : CMD_RF_WIFIPLL_HOLD_BIT_CLR);

    return rf_pll_ctrl(cmd, RF_WIFIPLL_HOLD_BY_BLE_BIT);
#else
    return 0;
#endif
}

static void reboot_wrapper(void)
{
    bk_reboot();
}

static int uart_read_byte_ex_wrapper(uint8_t id, uint8_t *ch)
{
    return uart_read_byte_ex(id, ch);
}

static int bt_vote_sleep_ctrl_wrapper(uint32_t sleep_state, uint32_t sleep_time)
{
    return bk_pm_module_vote_sleep_ctrl(PM_SLEEP_MODULE_NAME_BTSP, sleep_state, sleep_time);
}


static void bt_ext_wakeup_ctrl_wrapper(uint8_t enable)
{
    sys_drv_bt_sleep_exit_ctrl(enable);
}

static void send_uart2(uint8_t uart_id, const char *fmt, ...)
{
    char string[CONFIG_PRINTF_BUF_SIZE];
    UINT32 i = 0;
    va_list args;
    va_start(args, fmt);
    //exception_mode_printf(fmt, args);

    vsnprintf(string, sizeof(string) - 1, fmt, args);
    string[CONFIG_PRINTF_BUF_SIZE - 1] = 0;

    while (*(string + i))
    {
        uart_write_byte(uart_id, *(string + i));
        i++;
    }

    va_end(args);
}

static void dump_bytes(uint8_t *buffer, uint16_t length)
{
    char hex_stream[49U] = {0};
    uint32_t i;
    uint16_t offset;
    uint8_t c;

    offset = 0U;

    for (i = 0U; i < length; i ++)
    {
        c = buffer[i];

        sprintf((char *)&hex_stream[offset], "%02X ", c);
        //        hex_stream[offset] = c;
        //        hex_stream[offset + 1] = c + 1;
        //        hex_stream[offset + 2] = ' ';

        offset += 3U;

        if (offset == 48)
        {
            hex_stream[offset] = '\0';
            send_uart2(UART_ID_1, hex_stream);
            os_memset(hex_stream, 0, 49U);
            offset = 0;
            continue;
        }
    }

    hex_stream[offset] = '\0';

    send_uart2(UART_ID_1, hex_stream);
}

static void btsnoop_wrapper(uint8_t uart_id, uint8_t pkt_type, uint8_t is_rxed, uint8_t *pkt, uint16_t pkt_len, uint8_t method)
{
    switch(method)
    {
    case 0:
    default:
        if (is_rxed)
        {
            send_uart2(uart_id, "\r\n<- %02x ", pkt_type);
            dump_bytes(pkt, pkt_len);
            send_uart2(uart_id, "\r\n");
        }
        else
        {
            send_uart2(uart_id, "\r\n-> %02x ", pkt_type);
            dump_bytes(pkt, pkt_len);
            send_uart2(uart_id, "\r\n");
        }
        break;

    case 1:
        if(is_rxed)
        {
            pkt_type |= 0b10000000;
        }

        uart_write_byte(uart_id, pkt_type);

        for (uint32_t i = 0; i < pkt_len; ++i)
        {
            uart_write_byte(uart_id, pkt[i]);
        }
        break;
    }
}

static uint32_t get_chipid_mask(void)
{
    return PM_CHIP_ID_MASK;
}

static size_t get_sys_debug_config_addr(uint32_t index)
{
    switch (index)
    {
        case 0:
            return SYS_SYS_DEBUG_CONFIG0_ADDR;
            break;

        default:
        case 1:
            return SYS_SYS_DEBUG_CONFIG1_ADDR;
            break;
    }
}

static uint32_t get_chipid(uint32_t ver)
{
    switch (ver)
    {

        default:
        case 4:
            return PM_CHIP_ID_MPW_V4;
            break;
    }

    return 0;
}


static uint32_t get_current_chipid(void)
{
    return aon_pmu_hal_get_chipid();
}

static uint32_t get_test_rfconfig(void)
{
    extern uint32_t test_rfconfig;
    return test_rfconfig;
}

static uint8_t get_rf_mode(void)
{
    extern uint32_t rwnx_rfconfig;

    if ((rwnx_rfconfig & BLUETOOTH_RF_PLL_MASK) == BLUETOOTH_RF_PLL_WIFI)
    {
        return BT_RF_MODE_WIFI;
    }
    else if ((rwnx_rfconfig & BLUETOOTH_RF_MODE_MASK) == BLUETOOTH_RF_MODE_POLAR)
    {
        return BT_RF_MODE_POLAR;
    }

    return 0;
}

static int32_t init_mutex(void **mutex)
{
    return rtos_init_mutex((beken_mutex_t *)mutex);
}

static int32_t lock_mutex(void **mutex)
{
    return rtos_lock_mutex((beken_mutex_t *)mutex);
}

static int32_t unlock_mutex(void **mutex)
{
    return rtos_unlock_mutex((beken_mutex_t *)mutex);
}

static int32_t deinit_mutex(void **mutex)
{
    return rtos_deinit_mutex((beken_mutex_t *)mutex);
}

static int32_t init_semaphore(void **semaphore, int32_t max_count)
{
    return rtos_init_semaphore((beken_semaphore_t *)semaphore, 1);
}

static int32_t set_semaphore(void **semaphore)
{
    return rtos_set_semaphore((beken_semaphore_t *)semaphore);
}

static int32_t get_semaphore(void **semaphore, uint32_t timeout_ms)
{
    return rtos_get_semaphore((beken_semaphore_t *)semaphore, timeout_ms);
}

static int32_t deinit_semaphore(void **semaphore)
{
    return rtos_deinit_semaphore((beken_semaphore_t *)semaphore);
}

static int reg_run_cmd(const char *content, int cnt)
{
#if CONFIG_CLI && CONFIG_BKREG
    extern int bkreg_run_command(const char *cmd, int cnt);
    return bkreg_run_command(content, cnt);
#else
    return 0;
#endif
}

static uint32_t manual_calibration_txpwr_table_ready_in_flash()
{
    extern UINT32 manual_cal_txpwr_tab_ready_in_flash(void);
    return manual_cal_txpwr_tab_ready_in_flash();
}

static uint32_t manual_calibration_is_in_cali_mode()
{
    extern UINT32 manual_cal_is_in_rftest_mode(void);
    return manual_cal_is_in_rftest_mode();
}

static double bk_driver_get_rc32k_freq()
{
    if (BT_LPO_SRC_X32K == clk_32k_customer_config_get_wrapper() && BT_LPO_SRC_X32K == lpo_src_get_wrapper())
    {
        return BLUETOOTH_CLK_32768;
    }
    else
    {
        if (BT_LPO_SRC_DIVD == lpo_src_get_wrapper())
        {
            return BLUETOOTH_CLK_32K;
        }
        else
        {
#if CONFIG_CKMN
            return bk_ckmn_driver_get_rc32k_freq();
#else
            return BLUETOOTH_CLK_32K;
#endif
        }
    }
}

static void flush_dcache_wrapper()
{
#if CONFIG_CACHE_ENABLE
    flush_all_dcache();
#endif
}

static void ble_enter_dut()
{
    extern void ble_cal_enter_dut();
    ble_cal_enter_dut();
}


static void ble_exit_dut()
{
    extern void ble_cal_exit_dut();
    ble_cal_exit_dut();
}

static uint8_t set_bluetooth_power_level(float pwr_gain)
{
    extern bk_err_t bk_ble_set_tx_power(float powerdBm);
    extern uint8_t manual_cal_get_ble_pwr_idx(uint8_t channel);
    extern uint8_t get_ble_txpwr_table_size(void);
    extern void ble_cal_set_txpwr(uint8_t idx);

    bk_ble_set_tx_power(pwr_gain);
    uint8_t pwr_index = manual_cal_get_ble_pwr_idx(19);
    uint8_t max_pwr_index = get_ble_txpwr_table_size() - 1;
    uint8_t new_pwr_index = pwr_index > max_pwr_index ? max_pwr_index : pwr_index;
    ble_cal_set_txpwr(pwr_index);
    return new_pwr_index;
}

//warning: bt_osi_funcs must be data section, otherwise a2dp_source_pcm and a2dp_source_decode will trig watchdog !!!!!!!!
static struct bt_osi_funcs_t bt_osi_funcs =
{
    ._version = BT_OSI_VERSION,
    .size = sizeof(struct bt_osi_funcs_t),
    ._coex_init = coex_init_wrapper,
    ._bluetooth_int_isr_register = bluetooth_int_isr_register_wrapper,
    ._init_queue = init_queue_wrapper,
    ._deinit_queue = deinit_queue_wrapper,
    ._pop_from_queue = pop_from_queue_wrapper,
    ._push_to_queue = push_to_queue_wrapper,
    ._create_thread = create_thread_wrapper,
    ._delete_thread = delete_thread_wrapper,
    ._thread_join = thread_join,

    ._controller_mem_init = controller_mem_init_wrapper,
    ._bluetooth_deep_sleep_register = bluetooth_deep_sleep_register_wrapper,
    ._bluetooth_extern32k_register = bluetooth_extern32k_register_wrapper,
    ._bluetooth_extern32k_unregister = bluetooth_extern32k_unregister_wrapper,
    ._clk_32k_customer_config_get = clk_32k_customer_config_get_wrapper,
    ._lpo_src_set = lpo_src_set_wrapper,
    ._lpo_src_get = lpo_src_get_wrapper,
    ._bluetooth_power_ctrl = bluetooth_power_ctrl_wrapper,
    ._phy_power_ctrl = phy_power_ctrl_wrapper,
    ._bt_mac_clock_ctrl = bt_mac_clock_ctrl_wrapper,
    ._bt_phy_clock_ctrl = bt_phy_clock_ctrl_wrapper,
    ._btdm_interrupt_ctrl = btdm_interrupt_ctrl_wrapper,
    ._ble_interrupt_ctrl = ble_interrupt_ctrl_wrapper,
    ._bt_interrupt_ctrl = bt_interrupt_ctrl_wrapper,
    ._ate_is_enabled = ate_is_enabled_wrapper,
    ._cp_test_is_enabled = cp_test_is_enabled_wrapper,
    ._get_bluetooth_mac = get_bluetooth_mac_wrapper,
    ._uart_write_byte = uart_write_byte_wrapper,
    ._register_ble_dump_hook = register_ble_dump_hook_wrapper,
    ._get_ble_pwr_idx = get_ble_pwr_idx_wrapper,
    ._ble_cal_set_txpwr = ble_cal_set_txpwr_wrapper,
    ._ble_cal_recover_txpwr = ble_cal_recover_txpwr_wrapper,
    ._ble_cal_enter_txpwr = ble_cal_enter_txpwr_wrapper,
    ._gpio_dev_unmap = gpio_dev_unmap_wrapper,
    ._gpio_dev_map = gpio_dev_map_wrapper,
    ._set_printf_enable = set_printf_enable_wrapper,
    ._evm_stop_bypass_mac = evm_stop_bypass_mac_wrapper,
    ._rs_deinit = rs_deinit_wrapper,
    ._phy_enable_rx_switch = NULL,
    ._uart_enable_rx_interrupt = uart_enable_rx_interrupt_wrapper,
    ._uart_take_rx_isr = uart_take_rx_isr_wrapper,
    ._ble_vote_rf_ctrl = ble_vote_rf_ctrl_wrapper,
    ._ble_ate_vote_rf_ctrl = ble_ate_vote_rf_ctrl_wrapper,
    ._delay_milliseconds = delay_milliseconds_wrapper,
    ._disable_int = disable_int_wrapper,
    ._enable_int = enable_int_wrapper,
    ._gpio_disable_pull = gpio_disable_pull_wrapper,
    ._gpio_enable_output = gpio_enable_output_wrapper,
    ._gpio_set_output_high = gpio_set_output_high_wrapper,
    ._gpio_set_output_low = gpio_set_output_low_wrapper,
    ._gpio_pull_down = gpio_pull_down_wrapper,
    ._gpio_pull_up = gpio_pull_up_wrapper,
    ._get_printf_port = get_printf_port_wrapper,
    ._uart_enable = uart_enable_wrapper,
    ._enable_debug_gpio = enable_debug_gpio_wrapper,
    ._log = bk_printf_ext,
    ._get_time = get_time_wrapper,
    ._malloc = malloc_wrapper,
    ._free = free_wrapper,

    ._manual_cal_save_ble_txpwr = manual_cal_save_ble_txpwr_wrapper,

    ._is_timer_init = is_timer_init_wrapper,
    ._init_timer = init_timer_wrapper,
    ._init_timer_ext = init_timer_ext_wrapper,
    ._start_timer = start_timer_wrapper,
    ._is_timer_running = is_timer_running_wrapper,
    ._stop_timer = stop_timer_wrapper,
    ._deinit_timer = deinit_timer_wrapper,
    ._timer_change_period = timer_change_period,

    ._bt_rf_pll_ctrl = bt_rf_pll_ctrl_wrapper,
    ._reboot = reboot_wrapper,
    ._uart_read_byte_ex = uart_read_byte_ex_wrapper,

    ._bt_vote_sleep_ctrl = bt_vote_sleep_ctrl_wrapper,
    ._coexist_check_large_signal = NULL,
    ._bt_ext_wakeup_ctrl = bt_ext_wakeup_ctrl_wrapper,
    ._btsnoop = btsnoop_wrapper,

    ._get_sys_debug_config_addr = get_sys_debug_config_addr,
    ._get_chipid_mask = get_chipid_mask,
    ._get_chipid = get_chipid,
    ._get_current_chipid = get_current_chipid,
    ._get_test_rfconfig = get_test_rfconfig,

    ._init_mutex = init_mutex,
    ._lock_mutex = lock_mutex,
    ._unlock_mutex = unlock_mutex,
    ._deinit_mutex = deinit_mutex,
    ._init_semaphore = init_semaphore,
    ._set_semaphore = set_semaphore,
    ._get_semaphore = get_semaphore,
    ._deinit_semaphore = deinit_semaphore,

    ._get_rf_mode = get_rf_mode,
    ._bkreg_run_command = reg_run_cmd,
    ._manual_cal_txpwr_tab_ready_in_flash = manual_calibration_txpwr_table_ready_in_flash,
    ._manual_cal_is_in_cali_mode = manual_calibration_is_in_cali_mode,
    ._bk_driver_get_rc32k_freq = bk_driver_get_rc32k_freq,
    ._flush_dcache = flush_dcache_wrapper,
    ._ble_enter_dut = ble_enter_dut,
    ._ble_exit_dut = ble_exit_dut,
    ._set_bluetooth_power_level = set_bluetooth_power_level,
};

int bk_bt_os_adapter_init(void)
{
    ble_err_t ret = BK_OK;

    if (bt_os_adapter_init((void *)&bt_osi_funcs) != 0)
    {
        return BK_FAIL;
    }

    return ret;
}