/*
 * Copyright (c) CompanyNameMagicTag 2012-2019. All rights reserved.
 * Description: add data collect
 * Create: 2012-09-10
 */

#include "drv_dfx_cmn_inc.h"
#if defined PRODUCT_CFG_NDM_COLLECT_DATA
#include <drv_collectdata.h>
#include <soc_diag_async.h>
#include <dfx_diag_cmd_id.h>

#define EXT_DRV_DATA_COLLECT_MAX_SIZE (64 * 1024)
#define EXT_DRV_UPLOAD_DATA_ACK_SIZE 0X2800
#define EXT_DRV_UPLOAD_DATA_PACKET_SIZE 0X400
#define EXT_DRV_RECEIVE_DATA_PACKET_BLK_SIZE 300
#define EXT_DRV_RECEIVE_DATA_PACKET_TOTAL_SIZE 16384

dc_afe_backup g_afe_backup = { 0 };
typedef struct {
    ext_buf_s dc_info;
    td_pvoid dc_addr;
    td_pvoid malloc_addr;
} ext_dbk_dc_ctrl_s;
ext_dbk_dc_ctrl_s g_dbk_dc_ctrl;

typedef struct {
    td_u32 start_addr;
    td_u32 end_addr;
    td_u32 agc_gain; // 0xFFFFFFFF, NO fixed AGC
    td_u32 point_num;
    td_u32 time_out;
    td_u16 data_src;
    td_u16 triger_type;
} ext_diag_upload_start_req_s;

typedef struct {
    td_u32 return_ind;
    td_u32 total_len;
} ext_diag_upload_start_ind_s;

typedef struct {
    td_u32 receive_total_size;
    td_u16 receive_idx;
    td_u16 memget_flag;
    td_u16 receive_flag;
    td_u16 pad;
    td_void *data_addr;
} ext_diag_cache_mem_s;

ext_diag_cache_mem_s g_cache_mem = { 0 };
typedef struct {
    td_u32 file_total_size; // file total size
    td_u16 check_sum;       // Checksum
    td_u16 file_blk_size;   // Block size
    td_u16 index;           // Block index
    td_u16 pad;             // Block index
    td_u8 file_blk[0];      // data
} ext_send_transmit_blk_req_s;
typedef enum rceive_flag {
    E_RECEIVE_NULL = 0,
    E_RECEIVE_START,
    E_RECEIVE_ING,
    E_RECEIVE_DONE,
} ext_diag_rceive_flag_e;

EXT_PRV td_void dbk_dc_free_mem(td_void)
{
    if ((td_pvoid)g_dbk_dc_ctrl.malloc_addr != TD_NULL) {
        uapi_free(EXT_MOD_ID_DRV_DFX, g_dbk_dc_ctrl.malloc_addr);
        g_dbk_dc_ctrl.malloc_addr = TD_NULL;
    }
}
EXT_PRV td_pvoid dbk_dc_get_mem(td_u32 size)
{
    if (g_dbk_dc_ctrl.malloc_addr == TD_NULL) {
        if ((size != 0) && (size <= EXT_DRV_DATA_COLLECT_MAX_SIZE)) {
            g_dbk_dc_ctrl.malloc_addr = (td_pvoid)uapi_malloc(EXT_MOD_ID_DRV_DFX, size + ALIGNTYPE_64BYTE);
            if (g_dbk_dc_ctrl.malloc_addr != TD_NULL) {
                g_dbk_dc_ctrl.dc_addr =
                    (td_pvoid)((uintptr_t)align_length((uintptr_t)g_dbk_dc_ctrl.malloc_addr, ALIGNTYPE_64BYTE));
                memset_s(g_dbk_dc_ctrl.dc_addr, size, 0x77, size);
            }
        }
    }

    if (g_dbk_dc_ctrl.dc_addr == TD_NULL) {
        return TD_NULL;
    }

    return g_dbk_dc_ctrl.dc_addr;
}
td_u32 dbk_send_signal(EXT_IN td_pvoid cmd_param, td_u16 cmd_param_size)
{
    td_u32 ret = EXT_ERR_SUCCESS;
    ret = uapi_start_send_dc_signal((td_u8 *)cmd_param, cmd_param_size, &g_afe_backup);
    if (ret != EXT_ERR_SUCCESS) {
        return ret;
    }

    return ret;
}
td_void dbk_stop_send_signal(td_void)
{
    if (g_cache_mem.memget_flag == TD_TRUE) {
        dbk_dc_free_mem();
        g_cache_mem.memget_flag = TD_FALSE;
        g_cache_mem.data_addr = NULL;
        uapi_stop_send_dc_signal(&g_afe_backup);
    }
}
EXT_PRV td_u16 dc_calc_check_sum2(const td_pbyte ptr, td_u16 len)
{
    td_u16 check_sum = 0;

    if ((ptr != TD_NULL) && (len > 0)) {
        td_u16 i;
        for (i = 0; i < len; i++) {
            check_sum += ptr[i];
        }
    }
    return check_sum;
}

EXT_PRV td_u32 receive_cache_packet(EXT_IN td_pvoid cmd_param, td_u16 cmd_param_size)
{
    int ret = EXT_ERR_SUCCESS;

    ext_send_transmit_blk_req_s *pst_blk = (ext_send_transmit_blk_req_s *)cmd_param;
    ext_unref_param(cmd_param_size);
    td_u16 check_sum = dc_calc_check_sum2((td_u8 *)pst_blk->file_blk, pst_blk->file_blk_size);
    if (check_sum != pst_blk->check_sum) {
        return EXT_ERR_FAILURE;
    }

    if (pst_blk->index != (g_cache_mem.receive_idx + 1)) {
        return EXT_ERR_FAILURE;
    }
    if (g_cache_mem.receive_total_size + pst_blk->file_blk_size > pst_blk->file_total_size) {
        return EXT_ERR_FAILURE;
    }

    td_u8 *p = g_cache_mem.data_addr;
    p += g_cache_mem.receive_total_size;
    g_cache_mem.receive_idx = pst_blk->index;
    g_cache_mem.receive_total_size += pst_blk->file_blk_size;
    ret = memcpy_s((td_void *)p, pst_blk->file_blk_size, pst_blk->file_blk, pst_blk->file_blk_size);
    if (ret != EOK) {
        return EXT_ERR_MEMCPY_FAIL;
    }
    if (g_cache_mem.receive_total_size == pst_blk->file_total_size) {
        g_cache_mem.receive_idx = 0;
        g_cache_mem.receive_flag = E_RECEIVE_DONE;
        g_cache_mem.receive_total_size = 0;
    } else if (g_cache_mem.receive_total_size < pst_blk->file_total_size) {
        g_cache_mem.receive_flag = E_RECEIVE_ING;
    }
    return EXT_ERR_SUCCESS;
}
EXT_PRV td_u32 receive_data_config_prv(td_u16 us_id, EXT_IN td_pvoid cmd_param, td_u16 cmd_param_size, td_u32 option)
{
    ext_unref_param(option);
    ext_send_transmit_blk_req_s *pstBlk = (ext_send_transmit_blk_req_s *)cmd_param;
    if (us_id == ID_DIAG_CMD_DRV_RECEIVE_DATA_STOP) {
        dbk_stop_send_signal();

        return EXT_ERR_SUCCESS;
    }
    if (pstBlk->file_total_size > EXT_DRV_RECEIVE_DATA_PACKET_TOTAL_SIZE) {
        return EXT_ERR_FAILURE;
    }
    ext_diag_upload_start_ind_s ret_len = { 0 };

    if (!g_cache_mem.memget_flag) {
        g_cache_mem.data_addr = dbk_dc_get_mem(pstBlk->file_total_size);
        if (g_cache_mem.data_addr == NULL) {
            return EXT_ERR_FAILURE;
        }
        g_cache_mem.memget_flag = TD_TRUE;
    }
    ret_len.return_ind = receive_cache_packet(cmd_param, cmd_param_size);
    ret_len.total_len = pstBlk->file_blk_size;
    if (ret_len.return_ind != EXT_ERR_SUCCESS) {
        ret_len.total_len = pstBlk->index;
    }

    if (g_cache_mem.receive_flag == (td_u16)E_RECEIVE_DONE) {
        dbk_send_signal(g_cache_mem.data_addr, (td_u16)pstBlk->file_total_size);
        g_cache_mem.receive_flag = E_RECEIVE_NULL;
    }
    if (uapi_diag_report_packet(us_id, (td_u8)EXT_DIAG_CMD_INSTANCE_LOCAL, (td_pbyte)&ret_len,
        (td_u16)sizeof(ext_diag_upload_start_ind_s), TD_TRUE) != EXT_ERR_SUCCESS) {
        return EXT_ERR_INVALID_PARAMETER;
    }
    return EXT_ERR_SUCCESS;
}
td_u32 receive_data_config(td_u16 us_id, EXT_IN td_pvoid cmd_param, td_u16 cmd_param_size, td_u8 option)
{
    return uapi_diag_async_cmd(us_id, cmd_param, cmd_param_size, option, receive_data_config_prv);
}

td_u32 upload_data(td_u16 us_id, EXT_IN td_pvoid cmd_param, td_u16 cmd_param_size, td_u8 option)
{
    ext_unref_param(cmd_param);
    ext_unref_param(cmd_param_size);
    ext_unref_param(option);
    /* if less than 1K, data is flipped, and record length of the first part of ulTransmitedLen. No flipping is 0. */
    td_u32 transmited_len = 0;
    td_u32 send_len = 0;
    td_u32 total_left = 0;
    total_left = g_dbk_dc_ctrl.dc_info.buf_size[0] + g_dbk_dc_ctrl.dc_info.buf_size[1];
    while (total_left > 0) {
        send_len = (total_left >= EXT_DRV_UPLOAD_DATA_PACKET_SIZE - transmited_len) ?
            (EXT_DRV_UPLOAD_DATA_PACKET_SIZE - transmited_len) :
            total_left;
        transmited_len = 0;

        /* data flipping: record length of the first part of ulTransmitedLen */
        if (send_len > g_dbk_dc_ctrl.dc_info.buf_size[0]) {
            send_len = g_dbk_dc_ctrl.dc_info.buf_size[0];
            transmited_len = send_len;
        }
        if (uapi_diag_report_packet(us_id, (td_u8)EXT_DIAG_CMD_INSTANCE_LOCAL,
            (td_pbyte)g_dbk_dc_ctrl.dc_info.buf_addr[0], (td_u16)send_len, TD_TRUE) != EXT_ERR_SUCCESS) {
            dbk_dc_free_mem();
            return EXT_ERR_INVALID_PARAMETER;
        }
        total_left -= send_len;
        g_dbk_dc_ctrl.dc_info.buf_size[0] -= send_len;
        g_dbk_dc_ctrl.dc_info.buf_addr[0] += send_len;


        /* update the contents of buf */
        if (0 == g_dbk_dc_ctrl.dc_info.buf_size[0]) {
            g_dbk_dc_ctrl.dc_info.buf_size[0] = g_dbk_dc_ctrl.dc_info.buf_size[1];
            g_dbk_dc_ctrl.dc_info.buf_addr[0] = g_dbk_dc_ctrl.dc_info.buf_addr[1];
            g_dbk_dc_ctrl.dc_info.buf_size[1] = 0;
            g_dbk_dc_ctrl.dc_info.buf_addr[1] = 0;
        }
        break;
    }
    if (total_left == 0) {
        dbk_dc_free_mem();
    }

    return EXT_ERR_SUCCESS;
}

EXT_PRV td_u32 upload_data_config_prv_proc(dc_input_para_stru *str_dc_para, ext_diag_upload_start_ind_s *ret_len,
    ext_diag_upload_start_req_s *p_rx)
{
    if (str_dc_para == TD_NULL || p_rx == TD_NULL) {
        return EXT_ERR_INVALID_PARAMETER;
    }
    if ((p_rx->end_addr < p_rx->start_addr) || (p_rx->end_addr - p_rx->start_addr > EXT_DRV_DATA_COLLECT_MAX_SIZE)) {
        ret_len->return_ind = EXT_ERR_INVALID_PARAMETER;
        return EXT_ERR_INVALID_PARAMETER;
    }
    td_pvoid ul_addr = dbk_dc_get_mem(p_rx->end_addr - p_rx->start_addr);
    if (ul_addr == TD_NULL) {
        ret_len->return_ind = EXT_ERR_MALLOC_FAILUE;
        return EXT_ERR_MALLOC_FAILUE;
    }
    str_dc_para->data_src = (dc_trig_data_enum)p_rx->data_src;
    str_dc_para->triger_type = (dc_trig_type_enum)p_rx->triger_type;
    str_dc_para->agc_gain = (td_s32)p_rx->agc_gain;
    str_dc_para->after_point_len = p_rx->point_num;
    str_dc_para->end_addr = (uintptr_t)ul_addr + (p_rx->end_addr - p_rx->start_addr);
    str_dc_para->start_addr = (uintptr_t)ul_addr;
    str_dc_para->wait_result_timeout = p_rx->time_out;
    str_dc_para->wait_envok_time = 1000; /* 1000 */
    return EXT_ERR_SUCCESS;
}

EXT_PRV td_u32 upload_data_config_prv(td_u16 us_id, EXT_IN td_pvoid cmd_param, td_u16 cmd_param_size, td_u32 option)
{
    td_u32 ulRet = EXT_ERR_SUCCESS;
    ext_diag_upload_start_ind_s ret_len = { 0 };
    dc_input_para_stru strDcPara = { 0 };
    (td_void)memset_s((td_void *)&g_dbk_dc_ctrl.dc_info, sizeof(g_dbk_dc_ctrl.dc_info), 0, sizeof(ext_buf_s));
    if (us_id == ID_DIAG_CMD_DRV_UPLOAD_DATA_STOP) {
        dbk_dc_free_mem();
        return EXT_ERR_SUCCESS;
    }
    ext_unref_param(option);
    ext_diag_upload_start_req_s *pRx = (ext_diag_upload_start_req_s *)cmd_param;
    td_u32 procRet = upload_data_config_prv_proc(&strDcPara, &ret_len, pRx);
    if (procRet != EXT_ERR_SUCCESS) {
        goto fail;
    }
    if (EXT_ERR_SUCCESS != (ulRet = uapi_dc_start_normal_data_collect(&strDcPara, &g_dbk_dc_ctrl.dc_info))) {
        ret_len.return_ind = ulRet;
        goto fail;
    }
    ret_len.return_ind = EXT_ERR_SUCCESS;
    ret_len.total_len = g_dbk_dc_ctrl.dc_info.buf_size[0] + g_dbk_dc_ctrl.dc_info.buf_size[1];
    if (uapi_diag_report_packet(us_id, (td_u8)EXT_DIAG_CMD_INSTANCE_LOCAL, (td_pbyte)&ret_len,
        (td_u16)sizeof(ext_diag_upload_start_ind_s), TD_TRUE) != EXT_ERR_SUCCESS) {
        (td_void)memset_s((td_void *)&g_dbk_dc_ctrl.dc_info, sizeof(g_dbk_dc_ctrl.dc_info), 0, sizeof(ext_buf_s));
        dbk_dc_free_mem();
        return EXT_ERR_INVALID_PARAMETER;
    }
    uapi_sleep(10);
    if (EXT_ERR_SUCCESS == upload_data(ID_DIAG_CMD_DRV_UPLOAD_DATA, cmd_param, cmd_param_size, (td_u8)option)) {
        return EXT_ERR_SUCCESS;
    } else {
        ret_len.return_ind = EXT_ERR_INVALID_RAM_ADDR;
    }
fail:
    dbk_dc_free_mem();
    (td_void)memset_s((td_void *)&g_dbk_dc_ctrl.dc_info, sizeof(g_dbk_dc_ctrl.dc_info), 0, sizeof(ext_buf_s));
    if (uapi_diag_report_packet(us_id, (td_u8)EXT_DIAG_CMD_INSTANCE_LOCAL, (td_pbyte)&ret_len,
        (td_u16)sizeof(ext_diag_upload_start_ind_s), TD_TRUE) != EXT_ERR_SUCCESS) {
        return EXT_ERR_INVALID_PARAMETER;
    }
    return ret_len.return_ind;
}

td_u32 upload_data_config(td_u16 us_id, EXT_IN td_pvoid cmd_param, td_u16 cmd_param_size, td_u8 option)
{
    return uapi_diag_async_cmd(us_id, cmd_param, cmd_param_size, option, upload_data_config_prv);
}

#endif