
//******************************************** Включаемые файлы *********************************************

#include "bsp.h"
#include "fpga_main_tst.h"
#include <string.h>



//******************************************* Проверка параметров *******************************************


//******************************************** Определения типов ********************************************


//******************************************* Локальные константы *******************************************


//************************************ Глобальные (публичные) переменные ************************************


//************************************* Локальные (приватные) переменные ************************************



//***********************************************************************************************************
//******************************** Определения локальных (приватных) функций ********************************
//***********************************************************************************************************

// --------------------------------------
static void gpio_test_toogle(void)
{
    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL0, true);
    lmcal_ptim_delay(500);
    // for(u32 delay = 0; delay < 1000000; delay++){}
    
    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL0, false);
    // for(u32 delay = 0; delay < 1000000; delay++){}
    lmcal_ptim_delay(500);
} 

// --------------------------------------
static void f_periodic_blink(void)
{
    static bool state = false;

    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL0, state);
    state = !state;
}

static void ptim_test_callback(void)
{
    lmcal_ptim_set_callback(f_periodic_blink);
} 


// --------------------------------------
static char uart_test_buf[40];
static u16 uart_test_read_word = 0;
// static char uart_test_rx_buf[40];

#define TST_UART_WRITE_SIZE  (12)  // Hello_World\n

static void uart_test_init(void)
{
    lmcal_uart_enable(LMCAL_UART_CHANNEL1, true);

    strcpy(uart_test_buf, "Hello_World\r\0");
}


static void uart_test_write(void)
{
    for(u32 delay = 0; delay < 1000000; delay++){}

    for (u32 cnt = 0; cnt < TST_UART_WRITE_SIZE; cnt++)
    {
        lmcal_uart_write(LMCAL_UART_CHANNEL1, uart_test_buf[cnt]);
    }
}


static void uart_test_read(void)
{
    // Чтение с блокированием
    uart_test_read_word = lmcal_uart_read(LMCAL_UART_CHANNEL1);
}


//-------------------------------------------------------

static void sdio_wr_done_cb(void)
{
    //! test - irq (установить в прерывании)
    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL9, true);
}



static void sdio_rd_done_cb(void)
{
    //! test - irq (установить в прерывании)
    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL9, true);
}



static u32 sdio_tx_data[128];
static u32 sdio_rx_data[128];

static void sdio_test_init(void)
{
    for (int i = 0; i < 128; i++)
    {
        sdio_tx_data[i] = 0;
        sdio_rx_data[i] = 0;
    }

    sdio_tx_data[0] = 0x11223344;
    sdio_tx_data[1] = 0x55667788;
    sdio_tx_data[2] = 0x99aabbcc;
    sdio_tx_data[3] = 0xddeeff00;
    sdio_tx_data[4] = 0x00000000;

    sdio_tx_data[5] = 0x11223344;
    sdio_tx_data[6] = 0x55667788;
    sdio_tx_data[7] = 0x99aabbcc;
    sdio_tx_data[8] = 0xddeeff00;
    sdio_tx_data[9] = 0x00000000;

    sdio_tx_data[10] = 0x11223344;
    sdio_tx_data[11] = 0x55667788;
    sdio_tx_data[12] = 0x99aabbcc;
    sdio_tx_data[13] = 0xddeeff00;
    sdio_tx_data[14] = 0x00000000;

    sdio_tx_data[15] = 0xAABBCCDD;

    lmcal_sdio_set_callback(LMCAL_SDIO_CHANNEL0, CB_MEM_WR_DONE_CALLBACK, sdio_wr_done_cb);
    lmcal_sdio_set_callback(LMCAL_SDIO_CHANNEL1, CB_MEM_RD_DONE_CALLBACK, sdio_rd_done_cb);
}



// SDIO - Тест чтения
static void sdio_read_test(void)
{
    // Используется лог. анализатор в ПЛИС, ножки нужно дергать для
    // срабатывания триггера
    fun_res_t err = ERR_OK;

    lmcal_ptim_delay(100);

    //! test - irq (установить в прерывании)
    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL9, false);
    //! trig
    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL8, true);

    sdio_rx_data[0] = 0x11;
    sdio_rx_data[1] = 0x11;
    sdio_rx_data[2] = 0x11;
    sdio_rx_data[3] = 0x11;
    sdio_rx_data[4] = 0x11;
    sdio_rx_data[5] = 0x11;
    sdio_rx_data[6] = 0x11;
    sdio_rx_data[7] = 0x11;

    err = lmcal_sdio_read_buf(LMCAL_SDIO_CHANNEL1, (u32)0x11112222, sdio_rx_data, 1, NULL);
    
    //! trig
    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL8, false);
}



// SDIO - Тест записи
static void sdio_write_test(void)
{
    // Используется лог. анализатор в ПЛИС, ножки нужно дергать для
    // срабатывания триггера
    fun_res_t err = ERR_OK;

    lmcal_ptim_delay(100);

    //! test - irq
    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL9, false);
    //! trig
    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL8, true);
    
    err = lmcal_sdio_write_buf(LMCAL_SDIO_CHANNEL0, (u32)0x99887766, sdio_tx_data, 32, NULL);

    //! trig
    lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL8, false);
}



// static void f_sdio_cmd_test(u32 cmd, u32 arg)
// {
//     //! trig
//     lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL8, true);

//     // lmcal_send_cmd(LMCAL_SDIO_CHANNEL0, cmd, arg, NULL);

//     lmcal_send_cmd(LMCAL_SDIO_CHANNEL0, 24, 0x01000020, NULL);
//     lmcal_send_cmd(LMCAL_SDIO_CHANNEL0, 17, 0x01000020, NULL);

//     //! trig
//     lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL8, false);
// }



//! Проверка SDIO
// static void f_task_1ms(void)
// {    
//         // static bool test_res;

//     // --------------------------------------------
//     // for (int j = 0; j < 10; j++)
//     // {
//     //     // 128
//     //     sdio_write_test();
//     // }

//     // for (int j = 0; j < 10; j++)
//     // {
//     //     // 128
//     //     sdio_read_test();
//     // }
    

//     // Проверка
//     // test_res = true;
//     // for (int j = 0; j < 128; j++)
//     // {
//     //     if (sdio_tx_data[j] != sdio_rx_data[j])
//     //     {
//     //         test_res = false;
//     //     }
//     // }

// }



//***********************************************************************************************************
//******************************* Определения глобальных (публичных) функций ********************************
//***********************************************************************************************************

// Функции-тесты, выполняемые после инициализации lmcal
void test_init(void)
{
    // ptim_test_callback();

    // uart_test_init();

    // sdio_test_init();
    // FPGA_TST_Init();
}


// Функции-тесты, выполняемые в while(1)
void test_loop(void)
{
    // sdio_read_test();
    // sdio_write_test();

    // gpio_test_toogle();

    // uart_test_write();
    // uart_test_read();

    // lmcal_ptim_delay(500);
    // FPGA_TST_CycleReadWriteReg();
}





//*********************************************** КОНЕЦ ФАЙЛА ***********************************************



// static u32 sdio_tx_data[128];
// static u32 sdio_rx_data[128];

// static void sdio_test_init(void)
// {
//     for (int i = 0; i < 128; i++)
//     {
//         sdio_tx_data[i] = 0;
//         sdio_rx_data[i] = 0;
//     }

//     u16* buf_addr = (u16*)sdio_tx_data;

//     for (int i = 0; i < 128; i++)
//     {    
//         *buf_addr++ = i+1;
//     }



//     lmcal_sdio_set_callback(LMCAL_SDIO_CHANNEL0, CB_MEM_WR_DONE_CALLBACK, sdio_wr_done_cb);
//     lmcal_sdio_set_callback(LMCAL_SDIO_CHANNEL1, CB_MEM_RD_DONE_CALLBACK, sdio_rd_done_cb);
// }



// // SDIO - Тест чтения
// static void sdio_read_test(void)
// {
//     lmcal_ch_sts_t sts = CH_STS_BUSY;

//     // Используется лог. анализатор в ПЛИС, ножки нужно дергать для
//     // срабатывания триггера
//     fun_res_t err = ERR_OK;

//     // lmcal_ptim_delay(1);

//     for (int i = 0; i < 128; i++)
//     {
//         sdio_rx_data[i] = 0;
//     }


//     //! trig
//     lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL8, true);

//     //! test - irq (установить в прерывании)
//     lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL9, false);
    
//     err = lmcal_sdio_read_buf(LMCAL_SDIO_CHANNEL1, (u32)0x01000020, sdio_rx_data, 32, NULL);
    
//     //! trig
//     lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL8, false);

//     // wait
//     while(sts == CH_STS_BUSY)
//     {
//         sts = lmcal_sdio_get_status(LMCAL_SDIO_CHANNEL1);
//     }
// }



// // SDIO - Тест записи
// static void sdio_write_test(void)
// {
//     lmcal_ch_sts_t sts = CH_STS_BUSY;

//     // Используется лог. анализатор в ПЛИС, ножки нужно дергать для
//     // срабатывания триггера
//     fun_res_t err = ERR_OK;

//     // lmcal_ptim_delay(1);


//     //! trig
//     lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL8, true);
    
//     //! test - irq
//     lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL9, false);

//     err = lmcal_sdio_write_buf(LMCAL_SDIO_CHANNEL0, (u32)0x01000020, sdio_tx_data, 32, NULL);

//     //! trig
//     lmcal_gpio_write_pin(LMCAL_GPIO_CHANNEL8, false);

//     // wait
//     while(sts == CH_STS_BUSY)
//     {
//         sts = lmcal_sdio_get_status(LMCAL_SDIO_CHANNEL0);
//     }
// }
