qieyuan/yb_arm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
yb_arm/test/case24/src/testcase24.c
lishuang.xie fe2787d53f update New Feature#1737 from dev_ck_v2.1_featuer#1737# to dev_ck_v2.1 
1. modified the function: int32_t osp_read_spe_cfg_file(char* path, uint8_t cellid), add the cellid
2. modified the function: int32_t osp_get_cfg_file(char* name, uint8_t cellid, uint64_t *paddr, uint32_t *psize);, add the cellid
3. modified the interface file
4. modified the testcase which used the functions
5. Test:
   5.1 spu_case0_arm_case0_cpri:  Pass
   5.2 spu_case14_arm_caes20_cpri:Pass
   5.3 spu_case20_arm_case20_cpri:Pass
   5.4 spu_case24_arm_case24_cpri:Pass
   5.5 spu_case34_arm_case5:      Pass
   5.6 spu_case44_arm_case5:      Pass
2024-03-30 16:23:55 +08:00

653 lines
21 KiB
C
Raw Blame History

// +FHDR------------------------------------------------------------
// Copyright (c) 2022 SmartLogic.
// ALL RIGHTS RESERVED
// -----------------------------------------------------------------
// Filename : test.c
// Author : xianfeng.du
// Created On : 2022-11-25
// Last Modified :
// -----------------------------------------------------------------
// Description:
//
//
// -FHDR------------------------------------------------------------
#include <stddef.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>
#include "typedef.h"
#include "ucp_printf.h"
#include "msg_transfer_mem.h"
#include "pet_sm_mgt.h"
#include "ucp_handshake.h"
#include "ospShell.h"
#include "ospLog.h"
#include "ospCfgToBin.h"
#include "drv_init.h"
#include "stc_drv_api.h"
uint32_t slot_ind_flag = 0;
uint32_t slot_ind_time_flag = 0;
uint32_t g_slot_time = 0;
uint32_t gu32_value = 0;
uint32_t gu32_tick_receive_ctrl = 0;
uint32_t gu32_tick_from_tx_ctrl = 0;
uint32_t gu32_rx_callback_data_cnt = 0;
uint32_t gu32_switch = 1;
void osp_switch(uint32_t u32_switch)
{
gu32_switch = u32_switch;
}
uint32_t rx_callback_data(const char* buf,uint32_t payloadSize)
{
uint32_t stc_cnt = read_stc_local_timer();
uint32_t value = *(uint32_t *)buf;
uint16_t sfn = value >> 16;
uint16_t slot = value & 0xffff;
uint32_t tick_from_tx_ctrl = *(uint32_t *)(buf+4);
++gu32_rx_callback_data_cnt;
slot_ind_flag = 1;
gu32_value = value;
gu32_tick_receive_ctrl = stc_cnt;
gu32_tick_from_tx_ctrl = tick_from_tx_ctrl;
uint32_t diff = stc_cnt - tick_from_tx_ctrl;
if(0 == slot_ind_time_flag)
{
slot_ind_time_flag = 1;
diff = 1000000;
}
else
{
diff = stc_cnt - g_slot_time;
}
g_slot_time = stc_cnt;
if ((diff > 1020000) || (diff < 980000))
{
if((gu32_switch & 0x01) == 1)
{
UCP_PRINT_ERROR("[0],qNO[%d],sfn[%d],slot[%d],diff[%d]",UCP4008_TRAFFIC_NR_eMBB_DATA,sfn,slot,diff);
}
}
return payloadSize;
}
uint32_t gu32_rx1_slot_ind_flag = 0;
uint32_t gu32_rx1_slot_ind_time_flag = 0;
uint32_t gu32_rx1_slot_time = 0;
uint32_t rx1_callback_data(const char* buf,uint32_t payloadSize)
{
uint32_t stc_cnt = read_stc_local_timer();
uint32_t value = *(uint32_t *)buf;
uint16_t sfn = value >> 16;
uint16_t slot = value & 0xffff;
uint32_t diff = 0;
gu32_rx1_slot_ind_flag = 1;
if(0 == gu32_rx1_slot_ind_time_flag)
{
gu32_rx1_slot_ind_time_flag = 1;
diff = 1000000;
}
else
{
diff = stc_cnt - gu32_rx1_slot_time;
}
gu32_rx1_slot_time = stc_cnt;
if ((diff > 1020000) || (diff < 980000))
{
if((gu32_switch & 0x10) == 0x10)
{
UCP_PRINT_ERROR("[1],qNO[%d],sfn[%d],slot[%d],diff[%d]",UCP4008_TRAFFIC_NR_eMBB_DATA,sfn,slot,diff);
}
}
return payloadSize;
}
uint32_t gu32_rx2_slot_ind_flag = 0;
uint32_t gu32_rx2_slot_ind_time_flag = 0;
uint32_t gu32_rx2_slot_time = 0;
uint32_t rx2_callback_data(const char* buf,uint32_t payloadSize)
{
uint32_t stc_cnt = read_stc_local_timer();
uint32_t value = *(uint32_t *)buf;
uint16_t sfn = value >> 16;
uint16_t slot = value & 0xffff;
uint32_t diff = 0;
gu32_rx2_slot_ind_flag = 1;
if(0 == gu32_rx2_slot_ind_time_flag)
{
gu32_rx2_slot_ind_time_flag = 1;
diff = 1000000;
}
else
{
diff = stc_cnt - gu32_rx2_slot_time;
}
gu32_rx2_slot_time = stc_cnt;
if ((diff > 1020000) || (diff < 980000))
{
if((gu32_switch & 0x100) == 0x100)
{
UCP_PRINT_ERROR("[2],qNO[%d],sfn[%d],slot[%d],diff[%d]",UCP4008_TRAFFIC_NR_eMBB_DATA,sfn,slot,diff);
}
}
return payloadSize;
}
uint32_t gu32_rx3_slot_ind_flag = 0;
uint32_t gu32_rx3_slot_ind_time_flag = 0;
uint32_t gu32_rx3_slot_time = 0;
uint32_t rx3_callback_data(const char* buf,uint32_t payloadSize)
{
uint32_t stc_cnt = read_stc_local_timer();
uint32_t value = *(uint32_t *)buf;
uint16_t sfn = value >> 16;
uint16_t slot = value & 0xffff;
uint32_t diff = 0;
gu32_rx3_slot_ind_flag = 1;
if(0 == gu32_rx3_slot_ind_time_flag)
{
gu32_rx3_slot_ind_time_flag = 1;
diff = 1000000;
}
else
{
diff = stc_cnt - gu32_rx3_slot_time;
}
gu32_rx3_slot_time = stc_cnt;
if ((diff > 1020000) || (diff < 980000))
{
if((gu32_switch & 0x1000) == 0x1000)
{
UCP_PRINT_ERROR("[3],qNO[%d],sfn[%d],slot[%d],diff[%d]",UCP4008_TRAFFIC_NR_eMBB_DATA,sfn,slot,diff);
}
}
return payloadSize;
}
uint32_t rx_callback_ctrl(const char* buf,uint32_t payloadSize)
{
return payloadSize;
}
static inline void get_msg_transfer_info(uint16_t port_index, uint16_t inst_id, uint16_t transfer_type, transfer_type_info_s* transfer_type_info_ptr)
{
queue_info_s c_plane,u_plane;
switch (transfer_type) {
case CU_SPLIT:
c_plane.rx_block_size = 0x25800;
c_plane.rx_block_num = 32;
c_plane.rx_callback = rx_callback_ctrl;
c_plane.tx_block_size = 0x8000;
c_plane.tx_block_num = 8;
c_plane.tx_callback = NULL;
u_plane.rx_block_size = 0x28000;
u_plane.rx_block_num = 8;
//u_plane.rx_callback = rx_callback_data;
if (0 == inst_id)
{
u_plane.rx_callback = rx_callback_data;
}
else if (1 == inst_id)
{
u_plane.rx_callback = rx1_callback_data;
}
else if (2 == inst_id)
{
u_plane.rx_callback = rx2_callback_data;
}
else
{
u_plane.rx_callback = rx3_callback_data;
}
u_plane.tx_block_size = 0x28000;
u_plane.tx_block_num = 8;
u_plane.tx_callback = NULL;
transfer_type_info_ptr->queue_cplane_info = c_plane;
transfer_type_info_ptr->queue_uplane_info = u_plane;
break;
case OAM:
c_plane.rx_block_size = 0x100000;
c_plane.rx_block_num = 16;
c_plane.rx_callback = rx_callback_oam;
c_plane.tx_block_size = 0x8000;
c_plane.tx_block_num = 4;
c_plane.tx_callback = NULL;
transfer_type_info_ptr->queue_cplane_info = c_plane;
break;
default:
UCP_PRINT_ERROR("get_msg_queue_cfg doesn't support transfer_type[%d] .",transfer_type);
break;
}
return;
}
static inline void msg_transfer_cfg(void)
{
uint8_t port_id = 0;
uint16_t inst_id = 0;
uint16_t transfer_type = 0;
int32_t handle_id = 0;
transfer_type_info_s transfer_type_info;
for (inst_id=0; inst_id<MAX_INSTANCE_NUM; inst_id++) {
//for (inst_id=0; inst_id<4; inst_id++) { // 4 cell
/*********************************transfer_type = CU_SPLIT**********************************/
transfer_type = CU_SPLIT;
get_msg_transfer_info(port_id,inst_id,transfer_type, &transfer_type_info);
handle_id = msg_transfer_init(port_id, transfer_type, inst_id, &transfer_type_info);
if (handle_id < 0) {
UCP_PRINT_ERROR("phy_cfg_init transfer_type:CU_SPLIT, handle_id[0x%08x] error.",handle_id);
}
/*********************************transfer_type = OAM**********************************/
transfer_type = OAM;
get_msg_transfer_info(port_id,inst_id,transfer_type, &transfer_type_info);
handle_id = msg_transfer_init(port_id, transfer_type, inst_id, &transfer_type_info);
if (handle_id < 0) {
UCP_PRINT_ERROR("phy_cfg_init transfer_type:OAM, handle_id[0x%08x] error.",handle_id);
}
}
PetSmLocalMgt_t* pPetSmLocalMgt = get_pet_sm_local_mgt();
MsgQueueLocalMgt_t* pMsgQueueLocalMgt = get_msg_queue_local_mgt();
pPetSmLocalMgt->pSyncInfo->queueCfgFlag = ++pMsgQueueLocalMgt->localSyncInfo.queueCfgFlag;
return;
}
static inline void msg_transfer_queue_polling(void)
{
uint8_t port_id = 0;
HandleId_t handler;
uint16_t cu_flag;
uint32_t offset = 0;
uint32_t len = 0;
uint8_t* msg_ptr;
for (uint32_t i = 0; i < MAX_INSTANCE_NUM; i++) {
//for (uint32_t i = 0; i < 4; i++) {
handler.port_id = port_id;
handler.inst_id = i;
handler.type_id = CU_SPLIT;
cu_flag = C_PLANE;
msg_transfer_receive(handler.value, cu_flag, offset, len, &msg_ptr);
cu_flag = U_PLANE;
msg_transfer_receive(handler.value, cu_flag, offset, len, &msg_ptr);
handler.type_id = OAM;
msg_transfer_receive(handler.value, cu_flag, offset, len, &msg_ptr);
}
return;
}
#define CELL_SETUP_TYPE_SIMULATION (0x5a6b7c8d)
void cell_setup_simulation(uint8_t scs_id, uint8_t cell_id, uint32_t run_core, uint8_t frame_type)
{
uint32_t size = 32;
char* buf;
uint32_t availableSize,offset;
uint16_t cu_flag = C_PLANE;
HandleId_t handler;
handler.port_id = 0;
handler.inst_id = 0;
handler.type_id = CU_SPLIT;
int32_t ret = msg_transfer_send_start(handler.value,cu_flag);
/************C_PLANE***************/
ret = msg_transfer_alloc_msg(handler.value, cu_flag, size, &buf, &availableSize, &offset);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("cell_setup_simulation call msg_transfer_alloc_msg err.");
return ;
//continue;
}
UCP_PRINT_DEBUG("availableSize = 0x%x.", availableSize);
UCP_PRINT_DEBUG("offset = 0x%x.", offset);
*(uint32_t*)(buf + 0) = CELL_SETUP_TYPE_SIMULATION;
*(uint32_t*)(buf + 4) = read_stc_local_timer();
*(uint32_t*)(buf + 12) = 0; // build cell
*(uint32_t*)(buf + 16) = scs_id;
*(uint32_t*)(buf + 20) = cell_id;
*(uint32_t*)(buf + 24) = run_core;
*(uint32_t*)(buf + 28) = frame_type;
ret = msg_transfer_send_msg(handler.value, cu_flag, (uint8_t *)buf, offset, size);
ret = msg_transfer_send_end(handler.value,cu_flag);
return;
}
int32_t test_case(uint32_t argc, int32_t* argvp)
{
UCP_PRINT_DEBUG("start running testcase 24 (8 ape 15K case, 4 cells).");
uint64_t addr = 0;
uint32_t fsize = 0;
osp_read_spe_cfg_file("/ramfs/cfgDat", 0);
osp_read_spe_cfg_file("/ramfs/cfgDat", 1);
osp_read_spe_cfg_file("/ramfs/cfgDat", 2);
osp_read_spe_cfg_file("/ramfs/cfgDat", 3);
osp_get_cfg_file("nr_csirs_cfg.dat", 0, &addr, &fsize);
osp_get_cfg_file("nr_csirs_lut.dat", 1, &addr, &fsize);
osp_get_cfg_file("nr_csirs_lut.dat", 2, &addr, &fsize);
osp_get_cfg_file("nr_csirs_cfg.dat", 3, &addr, &fsize);
msg_transfer_mem_init();
msg_transfer_cfg();
ucp_handshake();
UCP_PRINT_DEBUG("start transfering message.");
uint32_t size = 100;
char* buf;
uint32_t availableSize,offset;
uint8_t* ptr;
uint8_t u8_cell_flag = 0;
uint16_t cu_flag = C_PLANE;
HandleId_t handler;
handler.port_id = 0;
handler.inst_id = 0;
handler.type_id = CU_SPLIT;
int32_t ret;
uint8_t scs_id = 0; // LTE
uint8_t cell_id = 0;
uint32_t run_ape = 0x3;
uint8_t frame_type = 1; // tdd
cell_setup_simulation(scs_id, cell_id, run_ape, frame_type); /* the first cell */
UCP_PRINT_DEBUG("call cell setup(1)");
osp_insert_cmd("sw", (OSP_FUNCPTR)osp_switch, "osp_switch", 1);
while(1)
{
if ((100000 == gu32_rx_callback_data_cnt) && (0 == u8_cell_flag))
{
/* 1st cell build ok after 10s */
scs_id = 0; // LTE
cell_id = 1;
run_ape = 0xC;
frame_type = 1; // tdd
cell_setup_simulation(scs_id, cell_id, run_ape, frame_type); /* the second cell */
u8_cell_flag = 1;
UCP_PRINT_DEBUG("call cell setup(2)");
}
if ((200000 == gu32_rx_callback_data_cnt) && (1 == u8_cell_flag))
{
/* 1st cell build ok after 10s */
scs_id = 0; // LTE
cell_id = 2;
run_ape = 0x30;
frame_type = 1; // tdd
cell_setup_simulation(scs_id, cell_id, run_ape, frame_type); /* the second cell */
u8_cell_flag = 2;
UCP_PRINT_DEBUG("call cell setup(3)");
}
if ((300000 == gu32_rx_callback_data_cnt) && (2 == u8_cell_flag))
{
/* 1st cell build ok after 10s */
scs_id = 0; // LTE
cell_id = 3;
run_ape = 0xC0;
frame_type = 1; // tdd
cell_setup_simulation(scs_id, cell_id, run_ape, frame_type); /* the second cell */
u8_cell_flag = 3;
UCP_PRINT_DEBUG("call cell setup(4)");
}
msg_transfer_queue_polling();
if ((1 == slot_ind_flag) || (1 == gu32_rx1_slot_ind_flag) || (1 == gu32_rx2_slot_ind_flag) || (1 == gu32_rx3_slot_ind_flag))
{
if(1 == slot_ind_flag)
{
slot_ind_flag = 0;
handler.inst_id = 0;
/************C_PLANE***************/
cu_flag = C_PLANE;
ret = msg_transfer_send_start(handler.value,cu_flag);
ret = msg_transfer_alloc_msg(handler.value, cu_flag, size, &buf, &availableSize, &offset);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,c_plane alloc error\r\n");
continue;
}
ptr = (uint8_t *)buf;
*(uint32_t*)(ptr + 0) = gu32_value;
*(uint32_t*)(ptr + 4) = gu32_tick_from_tx_ctrl;
*(uint32_t*)(ptr + 8) = gu32_tick_receive_ctrl;
*(uint32_t*)(ptr + 12) = read_stc_local_timer();
ret = msg_transfer_send_msg(handler.value, cu_flag, (uint8_t *)buf, offset, size);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,c_plane send error\r\n");
}
ret = msg_transfer_send_end(handler.value,cu_flag);
/************U_PLANE***************/
cu_flag = U_PLANE;
ret = msg_transfer_send_start(handler.value,cu_flag);
ret = msg_transfer_alloc_msg(handler.value, cu_flag, size, &buf, &availableSize, &offset);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,u_plane alloc error\r\n");
continue;
}
ptr = (uint8_t *)buf;
*(uint32_t*)(ptr + 0) = gu32_value;
*(uint32_t*)(ptr + 4) = gu32_tick_from_tx_ctrl;
*(uint32_t*)(ptr + 8) = gu32_tick_receive_ctrl;
*(uint32_t*)(ptr + 12) = read_stc_local_timer();
ret = msg_transfer_send_msg(handler.value, cu_flag, (uint8_t *)buf, offset, size);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,u_plane send error\r\n");
}
ret = msg_transfer_send_end(handler.value,cu_flag);
}
if (1 == gu32_rx1_slot_ind_flag)
{
gu32_rx1_slot_ind_flag = 0;
handler.inst_id = 1;
/************C_PLANE***************/
cu_flag = C_PLANE;
ret = msg_transfer_send_start(handler.value,cu_flag);
ret = msg_transfer_alloc_msg(handler.value, cu_flag, size, &buf, &availableSize, &offset);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,c_plane alloc error\r\n");
continue;
}
ptr = (uint8_t *)buf;
*(uint32_t*)(ptr + 0) = gu32_value;
*(uint32_t*)(ptr + 4) = gu32_tick_from_tx_ctrl;
*(uint32_t*)(ptr + 8) = gu32_tick_receive_ctrl;
*(uint32_t*)(ptr + 12) = read_stc_local_timer();
ret = msg_transfer_send_msg(handler.value, cu_flag, (uint8_t *)buf, offset, size);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,c_plane send error\r\n");
}
ret = msg_transfer_send_end(handler.value,cu_flag);
/************U_PLANE***************/
cu_flag = U_PLANE;
ret = msg_transfer_send_start(handler.value,cu_flag);
ret = msg_transfer_alloc_msg(handler.value, cu_flag, size, &buf, &availableSize, &offset);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,u_plane alloc error\r\n");
continue;
}
ptr = (uint8_t *)buf;
*(uint32_t*)(ptr + 0) = gu32_value;
*(uint32_t*)(ptr + 4) = gu32_tick_from_tx_ctrl;
*(uint32_t*)(ptr + 8) = gu32_tick_receive_ctrl;
*(uint32_t*)(ptr + 12) = read_stc_local_timer();
ret = msg_transfer_send_msg(handler.value, cu_flag, (uint8_t *)buf, offset, size);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,u_plane send error\r\n");
}
ret = msg_transfer_send_end(handler.value,cu_flag);
}
if (1 == gu32_rx2_slot_ind_flag)
{
gu32_rx2_slot_ind_flag = 0;
handler.inst_id = 2;
/************C_PLANE***************/
cu_flag = C_PLANE;
ret = msg_transfer_send_start(handler.value,cu_flag);
ret = msg_transfer_alloc_msg(handler.value, cu_flag, size, &buf, &availableSize, &offset);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,c_plane alloc error\r\n");
continue;
}
ptr = (uint8_t *)buf;
*(uint32_t*)(ptr + 0) = gu32_value;
*(uint32_t*)(ptr + 4) = gu32_tick_from_tx_ctrl;
*(uint32_t*)(ptr + 8) = gu32_tick_receive_ctrl;
*(uint32_t*)(ptr + 12) = read_stc_local_timer();
ret = msg_transfer_send_msg(handler.value, cu_flag, (uint8_t *)buf, offset, size);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,c_plane send error\r\n");
}
ret = msg_transfer_send_end(handler.value,cu_flag);
/************U_PLANE***************/
cu_flag = U_PLANE;
ret = msg_transfer_send_start(handler.value,cu_flag);
ret = msg_transfer_alloc_msg(handler.value, cu_flag, size, &buf, &availableSize, &offset);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,u_plane alloc error\r\n");
continue;
}
ptr = (uint8_t *)buf;
*(uint32_t*)(ptr + 0) = gu32_value;
*(uint32_t*)(ptr + 4) = gu32_tick_from_tx_ctrl;
*(uint32_t*)(ptr + 8) = gu32_tick_receive_ctrl;
*(uint32_t*)(ptr + 12) = read_stc_local_timer();
ret = msg_transfer_send_msg(handler.value, cu_flag, (uint8_t *)buf, offset, size);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,u_plane send error\r\n");
}
ret = msg_transfer_send_end(handler.value,cu_flag);
}
if (1 == gu32_rx3_slot_ind_flag)
{
gu32_rx3_slot_ind_flag = 0;
handler.inst_id = 3;
/************C_PLANE***************/
cu_flag = C_PLANE;
ret = msg_transfer_send_start(handler.value,cu_flag);
ret = msg_transfer_alloc_msg(handler.value, cu_flag, size, &buf, &availableSize, &offset);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,c_plane alloc error\r\n");
continue;
}
ptr = (uint8_t *)buf;
*(uint32_t*)(ptr + 0) = gu32_value;
*(uint32_t*)(ptr + 4) = gu32_tick_from_tx_ctrl;
*(uint32_t*)(ptr + 8) = gu32_tick_receive_ctrl;
*(uint32_t*)(ptr + 12) = read_stc_local_timer();
ret = msg_transfer_send_msg(handler.value, cu_flag, (uint8_t *)buf, offset, size);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,c_plane send error\r\n");
}
ret = msg_transfer_send_end(handler.value,cu_flag);
/************U_PLANE***************/
cu_flag = U_PLANE;
ret = msg_transfer_send_start(handler.value,cu_flag);
ret = msg_transfer_alloc_msg(handler.value, cu_flag, size, &buf, &availableSize, &offset);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,u_plane alloc error\r\n");
continue;
}
ptr = (uint8_t *)buf;
*(uint32_t*)(ptr + 0) = gu32_value;
*(uint32_t*)(ptr + 4) = gu32_tick_from_tx_ctrl;
*(uint32_t*)(ptr + 8) = gu32_tick_receive_ctrl;
*(uint32_t*)(ptr + 12) = read_stc_local_timer();
ret = msg_transfer_send_msg(handler.value, cu_flag, (uint8_t *)buf, offset, size);
if ( SUCCESS != ret) {
UCP_PRINT_ERROR("1,u_plane send error\r\n");
}
ret = msg_transfer_send_end(handler.value,cu_flag);
}
}
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink