/*
 * Copyright (c) 2019-2023 Beijing Hanwei Innovation Technology Ltd. Co. and
 * its subsidiaries and affiliates (collectly called MKSEMI).
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into an MKSEMI
 *    integrated circuit in a product or a software update for such product,
 *    must reproduce the above copyright notice, this list of conditions and
 *    the following disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * 3. Neither the name of MKSEMI nor the names of its contributors may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    MKSEMI integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be
 *    reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY MKSEMI "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL MKSEMI OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "board.h"
#include "mk_power.h"
#include "mk_clock.h"
#include "mk_calib.h"
#include "mk_misc.h"
#include "mk_uwb.h"
#ifdef WSF_EN
#include "wsf_nvm.h"
#endif
#if defined(UCI_INTF_PORT)
#include "uci_tl_task.h"
#endif

#if TRACE_EN
static enum TRACE_PORT_T user_trace_port;
#endif

#ifndef TRACE_BAUD_RATE
#define TRACE_BAUD_RATE (BAUD_115200)
#endif

struct BOARD_PARAM_T board_param = {0};
static GPIO_IRQ_HANDLER_T button_irq_handler = NULL;
static GPIO_IRQ_HANDLER_T accelerate_irq_handler=NULL;
 GPIO_IRQ_HANDLER_T _4Gusart_irq_handler=NULL;
 GPIO_IRQ_HANDLER_T pca_input_detect_irq_handler=NULL;
extern struct UART_CFG_T test_uart_cfg;
extern struct ADC_CFG_T usr_adc_cfg;
extern volatile int32_t m_EUART_DMA_RXPtr;	
void board_clock_run(void)
{
    // default load cap
    REG_WRITE(0x40000048, 76);

    clock_attach(CLOCK_48M_RO_TO_SYS_CLK);
    delay_us(50);

    // calibrate REFPLL
    calib_open();
    calib_start(CALIB_PO_REFPLL_EN);
    calib_check(CALIB_REFPLL_DONE);
    calib_close();

    /* SYSCLK comes from XTAL */
    clock_attach(SYS_CLK_SOURCE);

    /* Configure AHB clock, AHBCLK = SYSCLK/(div) */
    clock_set_divider(CLOCK_AHB_DIV, AHB_DIV);

    /* Configure APB clock, APBCLK = AHBCLK/(div) */
    clock_set_divider(CLOCK_APB_DIV, APB_DIV);

    /* Select 32k clock source: 32768Hz XTAL or 32000Hz RCO */
    clock_attach(CLK_32K_SOURCE);

    /* Select WDT clcok source: 32K or APBCLK */
    clock_attach(CLOCK_32K_TO_WDT_CLK);

#if SYS_TICK_EN
    /* Configure sys tick timer, 32768 / 100 = 10ms @ 32k */
    sys_tick_start(328);
#endif

    /* System timer */
    sys_timer_open();
}

void board_debug_console_open(enum TRACE_PORT_T port)
{
#if TRACE_EN
    trace_open(port, TRACE_BAUD_RATE);
    user_trace_port = port;
#endif
//    LOG_INFO(TRACE_MODULE_APP, "Hello from MKSEMI!\r\n");
//    LOG_INFO(TRACE_MODULE_APP, "Build information %s\r\n", mk_build_inf);
}

void board_calibration_params_default(void)
{
    board_param.load_cap = 76;
#ifdef UWB_EN
    board_param.tx_power_fcc[CALIB_CH9] = TX_POWER_LEVEL;
    board_param.tx_power_fcc[CALIB_CH5] = TX_POWER_LEVEL;
    board_param.tx_power_fcc[CALIB_CH2] = TX_POWER_LEVEL;

    board_param.ranging_session_id = 0;
    board_param.local_short_addr = 0;
    board_param.peer_short_addr = 0;

#if (ANT_PATTERN == ANT_PATTERN_SQUARE)
    int16_t ant_delays_ch9[4] = {0, 0, 0, 36};
    int16_t ant_delays_ch5[4] = {0, 0, 0, 36};
    int16_t ant_delays_ch2[4] = {0, 0, 36, 0};

    // 4-ANTs: 0, 1, 2, 3
    int16_t pdoa_delays_ch9[4] = {52, -21, -8, 0};
    int16_t pdoa_delays_ch5[4] = {52, -21, -8, 0};
    // int16_t pdoa_delays_ch5[4] = {70, -2, -0, 0};
    int16_t pdoa_delays_ch2[4] = {52, -21, -8, 0};

    int16_t pdoa_gains_ch9[4] = {94, 99, 89, 88};
    int16_t pdoa_gains_ch5[4] = {94, 99, 89, 88};
    // int16_t pdoa_gains_ch5[4] = {94, 93, 89, 98};
    int16_t pdoa_gains_ch2[4] = {94, 99, 89, 88};

    int16_t pdoa_offsets[2] = {0, 0};
    board_param.pdoa_ant_space = 180;

#elif (ANT_PATTERN == ANT_PATTERN_TRIANGLE_REGULAR)

    int16_t ant_delays_ch9[4] = {0, 0, 0, 36};
    int16_t ant_delays_ch5[4] = {0, 0, 0, 36};
    int16_t ant_delays_ch2[4] = {0, 0, 36, 0};

    // 3-ANTs: 3, 0, 1
    int16_t pdoa_delays_ch9[4] = {0, -21, 52};
    int16_t pdoa_delays_ch5[4] = {0, -21, 52};
    int16_t pdoa_delays_ch2[4] = {0, -21, 52};

    int16_t pdoa_gains_ch9[4] = {88, 94, 99};
    int16_t pdoa_gains_ch5[4] = {88, 94, 99};
    int16_t pdoa_gains_ch2[4] = {88, 94, 99};

    int16_t pdoa_offsets[2] = {0, 0};
    board_param.pdoa_ant_space = 180;

#else
    // linear antenna array

    int16_t ant_delays_ch9[4] = {0, 0, 0, 122};
    int16_t ant_delays_ch5[4] = {0, 0, 0, 122};
    int16_t ant_delays_ch2[4] = {0, 0, 122, 0};

#if RX_ANT_PORTS_NUM == 4
    // 4-ANTs: 0, 1, 2, 3
    int16_t pdoa_delays_ch9[4] = {36, 47, 57, 0};
    int16_t pdoa_delays_ch5[4] = {51, -73, -57, 0};
    int16_t pdoa_delays_ch2[4] = {36, 47, 57, 0};

    int16_t pdoa_gains_ch9[4] = {108, 99, 98, 100};
    int16_t pdoa_gains_ch5[4] = {94, 103, 87, 100};
    int16_t pdoa_gains_ch2[4] = {108, 99, 98, 100};

    int16_t pdoa_offsets[2] = {0, 0};
    board_param.pdoa_ant_space = 180;

#elif RX_ANT_PORTS_NUM == 3

#if 0
    // 3-ANTs: 3, 0, 1
    int16_t pdoa_delays_ch9[4] = {0, 36, 47};
    int16_t pdoa_delays_ch5[4] = {0, 51, -73};
    int16_t pdoa_delays_ch2[4] = {0, 36, 47};

    int16_t pdoa_gains_ch9[4] = {100, 108, 99};
    int16_t pdoa_gains_ch5[4] = {100, 94, 103};
    int16_t pdoa_gains_ch2[4] = {100, 108, 99};
#else
    // 3-ANTs: 1, 2, 3
    int16_t pdoa_delays_ch9[4] = {47, 57, 0};
    int16_t pdoa_delays_ch5[4] = {-73, -57, 0};
    int16_t pdoa_delays_ch2[4] = {47, 57, 0};

    int16_t pdoa_gains_ch9[4] = {99, 98, 100};
    int16_t pdoa_gains_ch5[4] = {103, 87, 100};
    int16_t pdoa_gains_ch2[4] = {99, 98, 100};
#endif
    int16_t pdoa_offsets[2] = {0, 0};
    board_param.pdoa_ant_space = 180;

#elif RX_ANT_PORTS_NUM == 2

#if 0
    // 2-ANTs: 2, 3
    int16_t pdoa_delays_ch9[4] = {57, 0};
    int16_t pdoa_delays_ch5[4] = {-57, 0};
    int16_t pdoa_delays_ch2[4] = {57, 0};

    int16_t pdoa_gains_ch9[4] = {98, 100};
    int16_t pdoa_gains_ch5[4] = {87, 100};
    int16_t pdoa_gains_ch2[4] = {98, 100};
#else
    // 2-ANTs: 3, 0
    int16_t pdoa_delays_ch9[4] = {0, 36};
    int16_t pdoa_delays_ch5[4] = {0, 51};
    int16_t pdoa_delays_ch2[4] = {0, 36};

    int16_t pdoa_gains_ch9[4] = {100, 108};
    int16_t pdoa_gains_ch5[4] = {100, 94};
    int16_t pdoa_gains_ch2[4] = {100, 108};
#endif
    int16_t pdoa_offsets[2] = {0, 0};
    board_param.pdoa_ant_space = 180;

#endif
#endif

    memcpy((uint8_t *)&board_param.ant_delays[CALIB_CH9], ant_delays_ch9, sizeof(ant_delays_ch9));
    memcpy((uint8_t *)&board_param.ant_delays[CALIB_CH5], ant_delays_ch5, sizeof(ant_delays_ch5));
    memcpy((uint8_t *)&board_param.ant_delays[CALIB_CH2], ant_delays_ch2, sizeof(ant_delays_ch2));

#if RX_ANT_PORTS_NUM > 1
    memcpy((uint8_t *)&board_param.pdoa_delays[CALIB_CH9], pdoa_delays_ch9, sizeof(pdoa_delays_ch9));
    memcpy((uint8_t *)&board_param.pdoa_delays[CALIB_CH5], pdoa_delays_ch5, sizeof(pdoa_delays_ch5));
    memcpy((uint8_t *)&board_param.pdoa_delays[CALIB_CH2], pdoa_delays_ch2, sizeof(pdoa_delays_ch2));

    memcpy((uint8_t *)&board_param.pdoa_gains[CALIB_CH9], pdoa_gains_ch9, sizeof(pdoa_gains_ch9));
    memcpy((uint8_t *)&board_param.pdoa_gains[CALIB_CH5], pdoa_gains_ch5, sizeof(pdoa_gains_ch5));
    memcpy((uint8_t *)&board_param.pdoa_gains[CALIB_CH2], pdoa_gains_ch2, sizeof(pdoa_gains_ch2));

    memcpy((uint8_t *)&board_param.pdoa_offsets[0], pdoa_offsets, sizeof(pdoa_offsets));
#endif

    board_param.dev_role = 0;
    board_param.dev_role_idx = 0;
#endif
}

void board_calibration_params_load(void)
{
    board_calibration_params_default();
#ifdef WSF_EN
    if (TRUE == WsfNvmReadData(BOARD_LOAD_CAP, &board_param.load_cap, sizeof(board_param.load_cap), 0))
    {
        board_param.flag |= (1 << BOARD_LOAD_CAP);
    }

    if (TRUE == WsfNvmReadData(BOARD_TX_POWER_FCC_LEVEL, &board_param.tx_power_fcc[0], sizeof(board_param.tx_power_fcc), 0))
    {
        board_param.flag |= (1 << BOARD_TX_POWER_FCC_LEVEL);
    }

    if (TRUE == WsfNvmReadData(BOARD_RANGING_SESSION_ID, (uint8_t *)&board_param.ranging_session_id, sizeof(board_param.ranging_session_id), 0))
    {
        board_param.flag |= (1 << BOARD_RANGING_SESSION_ID);
    }

    if (TRUE == WsfNvmReadData(BOARD_LOCAL_SHORT_ADDR, (uint8_t *)&board_param.local_short_addr, sizeof(board_param.local_short_addr), 0))
    {
        board_param.flag |= (1 << BOARD_LOCAL_SHORT_ADDR);
    }

    if (TRUE == WsfNvmReadData(BOARD_PEER_SHORT_ADDR, (uint8_t *)&board_param.peer_short_addr, sizeof(board_param.peer_short_addr), 0))
    {
        board_param.flag |= (1 << BOARD_PEER_SHORT_ADDR);
    }

    if (TRUE == WsfNvmReadData(BOARD_ANT_DELAYS, (uint8_t *)&board_param.ant_delays[0], sizeof(board_param.ant_delays), 0))
    {
        board_param.flag |= (1 << BOARD_ANT_DELAYS);
    }

    if (TRUE == WsfNvmReadData(BOARD_PDOA_DELAYS, (uint8_t *)&board_param.pdoa_delays[0], sizeof(board_param.pdoa_delays), 0))
    {
        board_param.flag |= (1 << BOARD_PDOA_DELAYS);
    }

    if (TRUE == WsfNvmReadData(BOARD_PDOA_GAINS, (uint8_t *)&board_param.pdoa_gains[0], sizeof(board_param.pdoa_gains), 0))
    {
        board_param.flag |= (1 << BOARD_PDOA_GAINS);
    }

    if (TRUE == WsfNvmReadData(BOARD_PDOA_ANT_SPACE, (uint8_t *)&board_param.pdoa_ant_space, sizeof(board_param.pdoa_ant_space), 0))
    {
        board_param.flag |= (1 << BOARD_PDOA_ANT_SPACE);
    }

    if (TRUE == WsfNvmReadData(BOARD_PDOA_OFFSETS, (uint8_t *)&board_param.pdoa_offsets[0], sizeof(board_param.pdoa_offsets), 0))
    {
        board_param.flag |= (1 << BOARD_PDOA_OFFSETS);
    }

    if (TRUE == WsfNvmReadData(BOARD_DEV_ROLE, (uint8_t *)&board_param.dev_role, sizeof(board_param.dev_role), 0))
    {
        board_param.flag |= (1 << BOARD_DEV_ROLE);
    }

    if (TRUE == WsfNvmReadData(BOARD_DEV_ROLE_IDX, (uint8_t *)&board_param.dev_role_idx, sizeof(board_param.dev_role_idx), 0))
    {
        board_param.flag |= (1 << BOARD_DEV_ROLE_IDX);
    }

    if (TRUE == WsfNvmReadData(BOARD_X32K_LOAD_CAP, &board_param.x32k_load_cap, sizeof(board_param.x32k_load_cap), 0))
    {
        board_param.flag |= (1 << BOARD_X32K_LOAD_CAP);
    }
#endif
}

uint8_t board_calibration_param_write(uint8_t id, uint8_t *param, uint8_t param_len)
{
    uint8_t ret = 0;
#ifdef WSF_EN
    if (((id == BOARD_LOAD_CAP) && (param_len == sizeof(board_param.load_cap))) ||
        ((id == BOARD_TX_POWER_FCC_LEVEL) && (param_len == sizeof(board_param.tx_power_fcc))) ||
        ((id == BOARD_RANGING_SESSION_ID) && (param_len == sizeof(board_param.ranging_session_id))) ||
        ((id == BOARD_LOCAL_SHORT_ADDR) && (param_len == sizeof(board_param.local_short_addr))) ||
        ((id == BOARD_PEER_SHORT_ADDR) && (param_len == sizeof(board_param.peer_short_addr))) ||
        ((id == BOARD_ANT_DELAYS) && (param_len == sizeof(board_param.ant_delays))) ||
        ((id == BOARD_PDOA_DELAYS) && (param_len == sizeof(board_param.pdoa_delays))) ||
        ((id == BOARD_PDOA_GAINS) && (param_len == sizeof(board_param.pdoa_gains))) ||
        ((id == BOARD_PDOA_ANT_SPACE) && (param_len == sizeof(board_param.pdoa_ant_space))) ||
        ((id == BOARD_PDOA_OFFSETS) && (param_len == sizeof(board_param.pdoa_offsets))) ||
        ((id == BOARD_DEV_ROLE) && (param_len == sizeof(board_param.dev_role))) ||
        ((id == BOARD_DEV_ROLE_IDX) && (param_len == sizeof(board_param.dev_role_idx))) ||
        ((id == BOARD_X32K_LOAD_CAP) && (param_len == sizeof(board_param.x32k_load_cap))))
    {
        ret = WsfNvmWriteData(id, param, param_len, 0);
    }
#endif
    return ret;
}

void board_ranging_result_correct(uint16_t *distance, int16_t *azimuth, int16_t *elevation)
{
    if ((distance == NULL) || (azimuth == NULL) || (elevation == NULL))
    {
        return;
    }

#if (ANT_PATTERN == ANT_PATTERN_SQUARE) // 3D

#elif (ANT_PATTERN == ANT_PATTERN_TRIANGLE_REGULAR) // 3D

#elif (ANT_PATTERN == ANT_PATTERN_LINEAR) // 2D -90 ~ 90
    // azimuth correction
    float post_azimuth = mk_q7_to_f32(*azimuth);
#if RX_ANT_PORTS_NUM == 4

    post_azimuth = (int16_t)(1.1221f * post_azimuth + 0.2729f);

#elif RX_ANT_PORTS_NUM == 3

    post_azimuth = (int16_t)(1.2287f * post_azimuth + 1.3633f);

#elif RX_ANT_PORTS_NUM == 2

    if (post_azimuth < -13.1)
    {
        post_azimuth = (int16_t)(0.8719f * post_azimuth - 28.282f);
    }
    else if (post_azimuth < -4.6)
    {
        post_azimuth = (int16_t)(3.7137f * post_azimuth + 10.307f);
    }
    else
    {
        post_azimuth = (int16_t)(1.0492f * post_azimuth - 3.1928f);
    }

#endif
    post_azimuth = ((post_azimuth > 90) ? 90 : ((post_azimuth < -90) ? -90 : post_azimuth));
    *azimuth = mk_f32_to_q7(post_azimuth);
#endif
}
void board_5V_input_init(GPIO_IRQ_HANDLER_T irq_handler)
{
		button_irq_handler = irq_handler;
    gpio_pin_set_dir(INPUT_5V_Pin , GPIO_DIR_IN, 0);
    io_pull_set(INPUT_5V_Pin , IO_PULL_DOWN, IO_PULL_UP_NONE);
    gpio_enable_irq(INPUT_5V_Pin, GPIO_IRQ_TYPE_RISING_EDGE, button_irq_handler);
    //power_wakeup_enable((enum POWER_WAKEUP_SOURCE_T)INPUT_5V_Pin, POWER_WAKEUP_LEVEL_LOW);
}
void board_acceleration_detection_init(GPIO_IRQ_HANDLER_T irq_handler)
{
		accelerate_irq_handler=irq_handler;
		gpio_pin_set_dir(ACCLERATE_DETECT_Pin , GPIO_DIR_IN, 0);
		io_pull_set(ACCLERATE_DETECT_Pin, IO_PULL_DOWN, IO_PULL_UP_LEVEL4);
    gpio_enable_irq(ACCLERATE_DETECT_Pin, GPIO_IRQ_TYPE_RISING_EDGE, accelerate_irq_handler);
	
}
void board_4GUsart_detection_init(GPIO_IRQ_HANDLER_T irq_handler)  //4G ´®¿ÚÊäÈë¼ì²âÖжϣ¬ÏÂÀ­´¥·¢
{
        _4Gusart_irq_handler=irq_handler;  
        io_pin_mux_set(_4G_USART_RX_Pin,IO_FUNC0);//°ÑÔ­ÏÈio ±äΪÆÕͨGPIO
		gpio_pin_set_dir(_4G_USART_RX_Pin , GPIO_DIR_IN, 0);
		io_pull_set(_4G_USART_RX_Pin, IO_PULL_UP, IO_PULL_UP_LEVEL2);
        gpio_enable_irq(_4G_USART_RX_Pin, GPIO_IRQ_TYPE_FALLING_EDGE, _4Gusart_irq_handler);
		power_wakeup_enable((enum POWER_WAKEUP_SOURCE_T)_4G_USART_RX_Pin, POWER_WAKEUP_LEVEL_LOW);
}
void pca_input_detection_init(GPIO_IRQ_HANDLER_T irq_handler)
{
		pca_input_detect_irq_handler=irq_handler;
		gpio_pin_set_dir(PCA_INPUT_DETECT , GPIO_DIR_IN, 0);
	io_pull_set(PCA_INPUT_DETECT, IO_PULL_UP, IO_PULL_UP_LEVEL2);
	gpio_enable_irq(PCA_INPUT_DETECT, GPIO_IRQ_TYPE_FALLING_EDGE, pca_input_detect_irq_handler);
	power_wakeup_enable((enum POWER_WAKEUP_SOURCE_T)PCA_INPUT_DETECT, POWER_WAKEUP_LEVEL_LOW);
}
void board_button_init(GPIO_IRQ_HANDLER_T irq_handler)
{
    button_irq_handler = irq_handler;
    gpio_pin_set_dir(BOARD_SW_1, GPIO_DIR_IN, 0);
    io_pull_set(BOARD_SW_1, IO_PULL_UP, IO_PULL_UP_LEVEL3);
    gpio_enable_irq(BOARD_SW_1, GPIO_IRQ_TYPE_FALLING_EDGE, button_irq_handler);

    power_wakeup_enable((enum POWER_WAKEUP_SOURCE_T)BOARD_SW_1, POWER_WAKEUP_LEVEL_LOW);
}

void board_led_init(void)
{
    gpio_pin_set_dir(BOARD_LED_1, GPIO_DIR_OUT, 0);
    gpio_pin_set_dir(BOARD_LED_2, GPIO_DIR_OUT, 0);
}

void board_led_on(enum IO_PIN_T idx)
{
    gpio_pin_set(idx);
}

void board_led_off(enum IO_PIN_T idx)
{
    gpio_pin_clr(idx);
}

void board_led_toggle(enum IO_PIN_T idx)
{
    gpio_pin_toggle(idx);
}
void board_output_init(void)
{
		//adc²É¼¯gndĬÈÏÀ­¸ß
		io_pin_mux_set(ADC_GND_ENABLE, IO_FUNC0);
    gpio_pin_set_dir(ADC_GND_ENABLE , GPIO_DIR_OUT, 1);
//		io_open_drain_set(ADC_GND_ENABLE, 1);
    io_pull_set(ADC_GND_ENABLE,IO_HIGH_Z,IO_PULL_UP_NONE);//3

}
void board_configure(void)
{
}

void board_prepare_for_power_down(void)
{
#if !defined(CELL_PHONE_EN)
    board_led_off(BOARD_LED_1);
#endif
}

void board_restore_from_power_down(void)
{
	uart_open(UART_ID1, &test_uart_cfg);
	AIR780EUartInit();
	adc_open(&usr_adc_cfg);
	
	m_EUART_DMA_RXPtr = 0;//Çå¿ÕÉϴλº´æÆ÷±ÜÃâÖظ´·¢
#if defined(UCI_INTF_PORT)
    uci_tl_resume();
#else
    // button - restore interrupt type
	gpio_enable_irq(_4G_USART_RX_Pin, GPIO_IRQ_TYPE_FALLING_EDGE, _4Gusart_irq_handler);
	gpio_enable_irq(ACCLERATE_DETECT_Pin, GPIO_IRQ_TYPE_RISING_EDGE, accelerate_irq_handler);
//    if (button_irq_handler)
//    {
//        gpio_enable_irq(BOARD_SW_1, GPIO_IRQ_TYPE_FALLING_EDGE, button_irq_handler);
//    }
#endif

#if !defined(CELL_PHONE_EN)
    board_led_on(BOARD_LED_1);
#endif

    // system timer
    sys_timer_open();

#if TRACE_EN
    trace_open(user_trace_port, TRACE_BAUD_RATE);
#endif
}