ms/dist_tester
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6af2ca712f6e95623eff27a373b41aac488f31c9
dist_tester/src/comm.c

791 lines
23 KiB
C
Raw Blame History

/*
* comm.c
*
* Created on: 01-08-2013
* Author: Krzysztof Jakubczyk
*/
#include <xdc/std.h>
#include <string.h>
#include <stdio.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>
#include <ti/sysbios/hal/Timer.h>
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
#include <ti/sysbios/knl/Clock.h>
#include <ti/sysbios/knl/Semaphore.h>
#include <ti/ipc/Ipc.h>
#include <ti/ipc/MultiProc.h>
#include <ti/ipc/MessageQ.h>
#include <ti/ipc/Notify.h>
#include "version.h"
#include "comm.h"
#include "misc.h"
#include "cfg_var.h"
#include "tdefs.h"
#include "logman.h"
#include "spi.h"
#include "logic_elements/elements.h"
#include "logic_elements/events_reg.h"
#include "logic_elements/dfr.h"
#include "logic_elements/ddr.h"
#include "logic_elements/measurand.h"
#include "logic_elements/leds_drv.h"
#include "logic_elements/virt_in_drv.h"
#include "logic_elements/dfr_drv.h"
#include "logic_elements/ddr_drv.h"
#include "logic_elements/rec_float.h"
#include "logic_elements/rec_an.h"
#include "logic_elements/rec_buf.h"
#include "logic_elements/analog_in.h"
#include "logic_elements/event.h"
#include "logic_elements/events_reg.h"
#include "logic_elements/dev_ctrl.h"
#include "logic_elements/an_gen.h"
#include "logic_elements/events_reg.h"
#include "logic_elements/mki7.h"
#include "logic_elements/mki7_2.h"
#include "config.h"
/// ethernet
#include "ethernet/ports/am1808/include/lwiplib.h"
#include "ethernet/emac.h"
#include "ports/am1808/include/netif/sitaraif.h"
#include <ti/sysbios/hal/Hwi.h>
///
Timer_Handle tick_timer_handle;
u32 tick_timer_period;
static MessageQ_Handle msgqueue_local;
struct notify_data notify;
struct broadcast_info bcast_nfo;
volatile struct ping_info ping_nfo;
struct eth_data eth = { .flags = 0 };
volatile u8 saved_bank = 0;
//u8 time_good=0;
Void commFxn(UArg a0, UArg a1)
{
struct timeval cur_time_old;
int status = 0;
UInt16 remoteProcId;
MessageQ_Params msgqParams;
struct msg_data *msg;
int ret;
u8 may_sync_hw;
u8 may_sync_sw;
MessageQ_QueueId msgqueue_id_remote;
int offset;
struct parsed_cfg_transport_line *line = (struct parsed_cfg_transport_line *)shared_buf;
int i;
float tmp;
int tmpstate;
u8 *off;
char firm_ver[40];
u8 first_tsync=1;
u16 kob_bin=0;
snprintf(firm_ver,sizeof(firm_ver),SW_VER" %u",(u32)ic->fpga_verl|((u32)ic->fpga_verh<<16));
tick_timer_handle = Clock_getTimerHandle();
tick_timer_period = Timer_getPeriod(tick_timer_handle);
dbg.tick_period = tick_timer_period;
dbg.logman_buf_capacity = sizeof(log_manager.buf);
do
{
Task_sleep(1);
status = Ipc_start();
}
while(status == Ipc_E_NOTREADY);
remoteProcId = MultiProc_getId("HOST");
do
{
Task_sleep(1);
status = Ipc_attach(remoteProcId);
} while(status == Ipc_E_NOTREADY);
MessageQ_Params_init(&msgqParams);
msgqueue_local = MessageQ_create("MsgQdsp", &msgqParams);
if(msgqueue_local == NULL)
System_printf("queue failed\n");
else
System_printf("queue succ\n");
// notify subsystem from dsp to arm
notify.lineId = 0;
notify.eventId = 7;
notify.remoteProcId = remoteProcId;
do
{
status = Notify_sendEvent(notify.remoteProcId,notify.lineId,notify.eventId, NOTIFY_INIT, TRUE);
if (status == Notify_E_EVTNOTREGISTERED)
Task_sleep(10);
} while (status == Notify_E_EVTNOTREGISTERED);
for(;;)
{
status = MessageQ_get(msgqueue_local, (MessageQ_Msg *)&msg, MessageQ_FOREVER);
if(status == 0)
{
msgqueue_id_remote = MessageQ_getReplyQueue(msg);
switch(msg->cmd)
{
case DSP_CMD_INIT_COMM:
msg->p1 = CMD_ACK;
if(msg->p2 == 0xAA55AA55) // neg pps
ic->sync_reg=0;
while(!spi_fram_restored)
Task_sleep(100); // wait for spi first read
msg->p3 = saved_bank;
break;
case DSP_CMD_GET_ANALOG_BUF:
analog_buf_card = msg->p1;
analog_buf_channel = msg->p2;
for(i=0;i<127;i++)
analog_buf[i]=(short)bus_an_samples_buf[analog_buf_card][analog_buf_channel][(bus_an_cur_sample_num+i)%(SAMPLES_PER_MS*MAIN_FREQ_PERIOD_MS*2)] - 32767;
memcpy((char*)shared_buf,(char*)analog_buf,sizeof(analog_buf));
msg->p1 = (Uint32)shared_buf;
msg->p2 = sizeof(analog_buf);
break;
case DSP_CMD_GET_MEASURANDS:
switch(msg->p1)
{
case 0:
for(i=0;i<measurands.count;i++)
{
*((char *)shared_buf+(i<<2)+i) = measurands.id[i];
/* if(i<=6)
tmp=debug_size[i];
else*/
tmp=*(measurands.value[i]);
memcpy((char *)shared_buf+(i<<2)+i+1,(char *)&tmp,sizeof(float));
}
break;
case 1:
for(i=0;i<measurands.count;i++)
{
*((char *)shared_buf+(i<<2)+i) = measurands.id[i];
tmp=*(measurands.value_pri[i]);
memcpy((char *)shared_buf+(i<<2)+i+1,(char *)&tmp,sizeof(float));
}
break;
case 2:
for(i=0;i<measurands.count;i++)
{
*((char *)shared_buf+(i<<2)+i) = measurands.id[i];
tmp=*(measurands.value_sec[i]);
memcpy((char *)shared_buf+(i<<2)+i+1,(char *)&tmp,sizeof(float));
}
break;
default:
for(i=0;i<measurands.count;i++)
{
*((char *)shared_buf+(i<<2)+i) = measurands.id[i];
tmp=*(measurands.value[i]);
memcpy((char *)shared_buf+(i<<2)+i+1,(char *)&tmp,sizeof(float));
}
break;
}
msg->p2 = sizeof(shared_buf);
msg->p3 = measurands.count;
break;
case DSP_CMD_GET_FWVER:
memcpy((char *)shared_buf,firm_ver,40);
msg->p1 = (Uint32)shared_buf;
msg->p2 = sizeof(shared_buf);
break;
case DSP_CMD_GET_NET_BUF:
offset=0;
// maybe use semaphore to avoid race condition
memcpy((char*)shared_buf,(char*)&log_manager.nets_data[msg->p1],256);
msg->p1 = (Uint32)shared_buf;
msg->p2 = offset;
break;
case DSP_CMD_GET_IO_BUF:
offset=0;
// maybe use semaphore to avoid race condition
//memcpy((char*)shared_buf,(char*)ic->bin_in,sizeof(ic->bin_in));
//offset=sizeof(ic->bin_in);
memcpy((char*)shared_buf,(char*)bus_bin_data,sizeof(bus_bin_data));
offset=sizeof(bus_bin_data);
memcpy((char*)shared_buf+offset,(char *)ic->out_set,sizeof(ic->out_set));
offset+=sizeof(ic->out_set);
memcpy((char*)shared_buf+offset,(char *)&ic->kob_an,12); // kobs and errs
offset+=2;
kob_bin=ic->kob_bin;
for(i=0;i<8;i++)
{
if(mwd32_mask & (1<<i))
{
if(kob_bin & (1<<i))
kob_bin|=(1<<(i+8));
else
kob_bin&=~(1<<(i+8));
}
}
memcpy((char*)shared_buf+offset,(char *)&kob_bin,2); // kobs and errs
offset+=2;
memcpy((char*)shared_buf+offset,(char *)&ic->kob_out,8); // kobs and errs
offset+=8;
memcpy((char*)shared_buf+offset,(char *)&samples_dropped,2);
offset+=2;
memcpy((char*)shared_buf+offset,(char*)bus_bin_data_ench,sizeof(bus_bin_data_ench));
offset+=sizeof(bus_bin_data_ench);
for(i=0;i<8;i++)
{
if(mwd32_mask & (1<<i))
{
if(ic->kob_bin & (1<<i))
kob_bin_ench|=(1<<i) | (1<<(i+8));
else
kob_bin_ench&=~((1<<i) | (1<<(i+8)));
}
else
kob_bin_ench&=~((1<<i) | (1<<(i+8)));
}
memcpy((char*)shared_buf+offset,(char*)&kob_bin_ench,sizeof(kob_bin_ench));
offset+=sizeof(kob_bin_ench);
msg->p1 = (Uint32)shared_buf;
msg->p2 = offset;
break;
case DSP_CMD_GET_LEDS_VIRT_IN:
msg->p1 = (Uint32)shared_buf;
msg->p2 = 16+MAX_BIN_CARDS+(MAX_OUT_CARDS*2)+8;//+MAX_BIN_CARDS;
memcpy((char*)shared_buf+0,(char *)&led_states,4);
memcpy((char*)shared_buf+4,(char *)&led_blink_states,4);
memcpy((char*)shared_buf+8,(char *)&virt_in_mask,4);
memcpy((char*)shared_buf+12,(char *)&virt_in_states,4);
memcpy((u8*)shared_buf+16,(u8*)force_bus_bin_data,MAX_BIN_CARDS);
memcpy((u8*)shared_buf+16+MAX_BIN_CARDS,(u8*)force_bus_out_data,MAX_OUT_CARDS*2);
memcpy((char*)shared_buf+16+MAX_BIN_CARDS+(MAX_OUT_CARDS*2),(char *)&virt_in2_mask,4);
memcpy((char*)shared_buf+16+MAX_BIN_CARDS+(MAX_OUT_CARDS*2)+4,(char *)&virt_in2_states,4);
// memcpy((char*)shared_buf+16+MAX_BIN_CARDS+(MAX_OUT_CARDS*2)+4+4,(char *)&force_bus_bin_data_ench,MAX_BIN_CARDS);
break;
case DSP_CMD_GET_GI:
msg->p1 = (Uint32)shared_buf;
msg->p2 = sizeof(shared_buf);
if(ev_reg_log==NULL)
{
msg->p3 = 0;
break;
}
else
msg->p3 = ev_reg_log->events_count;
if(msg->p3>1024)
msg->p3=1024;
for(i=0;i<msg->p3;i++)
{
struct event_args *ev_args;
struct event_logic *ev_log;
u32 data;
ev_args = (struct event_args *)log_manager.log_element[ev_reg_log->element_num[i]].fun_args_ptr;
ev_log = (struct event_logic *)log_manager.log_element[ev_reg_log->element_num[i]].fun_log_ptr;
data=((u32)ev_args->params.fun<<16)|((u32)ev_args->params.inf<<8)|ev_log->prev_state;
memcpy((char*)shared_buf+(i<<2),(char *)&data,4);
}
break;
case DSP_CMD_SET_VIRT_IN:
tmpstate=virt_in_states & ~msg->p1;
virt_in_states = tmpstate|(msg->p1 & msg->p2);
break;
case DSP_CMD_SET_VIRT_IN2:
tmpstate=virt_in2_states & ~msg->p1;
virt_in2_states = tmpstate|(msg->p1 & msg->p2);
break;
case DSP_CMD_FORCE_OUT_STATES:
msg->p1 = CMD_ACK;
msg->p2 = dev_ctrl_state;
memcpy((u8*)force_bus_out_data,(u8*)shared_buf,MAX_OUT_CARDS*2);
break;
case DSP_CMD_FORCE_BIN_STATES:
memcpy((u8*)force_bus_bin_data,(u8*)shared_buf,MAX_BIN_CARDS);
if(msg->p1==0xBEEF)
memcpy((u8*)force_bus_bin_data_ench,(u8*)shared_buf+MAX_BIN_CARDS,MAX_BIN_CARDS);
msg->p1 = CMD_ACK;
msg->p2 = dev_ctrl_state;
break;
case DSP_CMD_FORCE_AN_STATES:
msg->p1 = CMD_ACK;
msg->p2 = dev_ctrl_state;
memcpy((u8*)&genpar,(u8*)shared_buf,sizeof(genpar));
break;
case DSP_CMD_GET_AN_STATES:
msg->p1 = (Uint32)shared_buf;
msg->p2 = sizeof(genpar);
memcpy((u8*)shared_buf,(u8*)&genpar,sizeof(genpar));
break;
case DSP_CMD_GET_SHARED_BUF:
msg->p1 = (Uint32)shared_buf;
msg->p2 = sizeof(shared_buf);
break;
case DSP_CMD_UPDATE_CFG:
msg->p1 = CMD_ERR;
for(i=0;i<cfg_lut_elements;i++)
{
if(!strcmp(cfg_lut[i].name,line->name))
{
if(cfg_lut[i].type == line->type)
{
switch(line->type)
{
case ARG_TYPE_BOOL:
switch(cfg_lut[i].size)
{
case sizeof(unsigned char):
if(line->bool_val)
*((unsigned char*)cfg_lut[i].addr)|=cfg_lut[i].bit_mask;
else
*((unsigned char*)cfg_lut[i].addr)&=~cfg_lut[i].bit_mask;
msg->p1=CMD_ACK;
break;
case sizeof(unsigned short):
if(line->bool_val)
*((unsigned short*)cfg_lut[i].addr)|=cfg_lut[i].bit_mask;
else
*((unsigned short*)cfg_lut[i].addr)&=~cfg_lut[i].bit_mask;
msg->p1=CMD_ACK;
break;
case sizeof(unsigned int):
if(line->bool_val)
*((unsigned int*)cfg_lut[i].addr)|=cfg_lut[i].bit_mask;
else
*((unsigned int*)cfg_lut[i].addr)&=~cfg_lut[i].bit_mask;
msg->p1=CMD_ACK;
break;
default:
msg->p1=CMD_ERR;
break;
}
break;
case ARG_TYPE_DOUBLE:
msg->p1=CMD_ACK;
memcpy((char *)cfg_lut[i].addr,(char *)&line->double_val,cfg_lut[i].size);
break;
case ARG_TYPE_LONG:
msg->p1=CMD_ACK;
memcpy((char *)cfg_lut[i].addr,(char *)&line->long_val,cfg_lut[i].size);
break;
case ARG_TYPE_TEXT:
msg->p1=CMD_ACK;
memcpy((char *)cfg_lut[i].addr,(char *)line->text_val,cfg_lut[i].size);
break;
default:
msg->p1=CMD_ERR;
break;
}
if(msg->p1==CMD_ACK && (cfg_lut[i].flags & NEED_RELOAD_IC))
reload_ic_cfg();
break;
}
else
{
msg->p1=CMD_ERR;
break;
}
}
}
break;
case DSP_CMD_GET_REG_INF:
memcpy((u8*)shared_buf,(u8*)&regs,sizeof(regs));
msg->p1 = (Uint32)shared_buf;
msg->p2 = offset;
break;
case DSP_CMD_GET_DDR_REG_INF:
memcpy((u8*)shared_buf,(u8*)&ddr_regs,sizeof(ddr_regs));
msg->p1 = (Uint32)shared_buf;
msg->p2 = offset;
break;
case DSP_CMD_GET_REG_MULTIPLIERS:
if(dfr_drv_log_ptr == NULL) // dfr driver not initialized?
{
msg->p1 = CMD_ERR;
break;
}
msg->p1 = CMD_ACK;
off = (u8 *)shared_buf;
msg->p2 = dfr_drv_log_ptr->an_count;
for(i=0;i<dfr_drv_log_ptr->an_count;i++)
{
struct rec_an_logic *an_log;
struct rec_buf_logic *an_buf_log;
struct rec_float_args *float_args;
struct rec_float_logic *float_log;
struct dfr_an_comtrade_params an_comtrade_params;
if(dfr_drv_log_ptr->element_num[i] & ELEMENT_IS_REC_FLOAT)
{
float_args = (struct rec_float_args *)log_manager.log_element[dfr_drv_log_ptr->element_num[i] & 0x3FFF].fun_args_ptr;
float_log = (struct rec_float_logic *)log_manager.log_element[dfr_drv_log_ptr->element_num[i] & 0x3FFF].fun_log_ptr;
an_comtrade_params.multiplier=float_log->mul;
an_comtrade_params.primary=float_args->params.pierw;
an_comtrade_params.secondary=float_args->params.wtor;
an_comtrade_params.unit=float_args->params.jednostka | AN_IS_FLOAT;
}
else if(dfr_drv_log_ptr->element_num[i] & ELEMENT_IS_REC_BUF)
{
an_buf_log = (struct rec_buf_logic *)log_manager.log_element[dfr_drv_log_ptr->element_num[i] & 0x3FFF].fun_log_ptr;
an_comtrade_params.multiplier=an_buf_log->an_params->multiplier;
an_comtrade_params.primary=an_buf_log->an_params->znam_pierw;
an_comtrade_params.secondary=an_buf_log->an_params->znam_wtor;
an_comtrade_params.unit=an_buf_log->an_params->jednostka & 0x7FFFFFFF;
}
else
{
an_log = (struct rec_an_logic *)log_manager.log_element[dfr_drv_log_ptr->element_num[i] & 0x3FFF].fun_log_ptr;
an_comtrade_params.multiplier=an_log->an_params->multiplier;
an_comtrade_params.primary=an_log->an_params->znam_pierw;
an_comtrade_params.secondary=an_log->an_params->znam_wtor;
an_comtrade_params.unit=an_log->an_params->jednostka & 0x7FFFFFFF;
}
memcpy(off,(u8 *)&an_comtrade_params,sizeof(an_comtrade_params));
off+=sizeof(an_comtrade_params);
}
break;
case DSP_CMD_GET_REG_MULTIPLIERS_DDR:
if(ddr_drv_log_ptr == NULL) // ddr driver not initialized?
{
msg->p1 = CMD_ERR;
break;
}
msg->p1 = CMD_ACK;
off = (u8 *)shared_buf;
msg->p2 = ddr_drv_log_ptr->an_count;
for(i=0;i<ddr_drv_log_ptr->an_count;i++)
{
struct rec_float_args *float_args;
struct rec_float_logic *float_log;
struct dfr_an_comtrade_params an_comtrade_params;
if(ddr_drv_log_ptr->element_num[i] & ELEMENT_IS_REC_FLOAT)
{
float_args = (struct rec_float_args *)log_manager.log_element[ddr_drv_log_ptr->element_num[i] & 0x3FFF].fun_args_ptr;
float_log = (struct rec_float_logic *)log_manager.log_element[ddr_drv_log_ptr->element_num[i] & 0x3FFF].fun_log_ptr;
an_comtrade_params.multiplier=float_log->mul;
an_comtrade_params.primary=float_args->params.pierw;
an_comtrade_params.secondary=float_args->params.wtor;
an_comtrade_params.unit=float_args->params.jednostka | AN_IS_FLOAT;
}
memcpy(off,(u8 *)&an_comtrade_params,sizeof(an_comtrade_params));
off+=sizeof(an_comtrade_params);
}
break;
case DSP_CMD_ACK_REG:
if(msg->p1<MAX_REG_BANKS)
{
if(regs.bank[msg->p1].state == BANK_FILLED)
regs.bank[msg->p1].state = BANK_EMPTY;
}
break;
case DSP_CMD_ACK_DDR_REG:
if(msg->p1<DDR_MAX_REG_BANKS)
{
if(ddr_regs.bank[msg->p1].state == BANK_FILLED)
ddr_regs.bank[msg->p1].state = BANK_EMPTY;
}
break;
case DSP_CMD_CLEAR_RELAYS:
for(i=0;i<MAX_OUT_CARDS;i++)
ic->out_set[i]=0;
msg->p1 = CMD_ACK;
break;
case DSP_CMD_TIME_SYNC:
may_sync_hw = (first_tsync || (msg->p2<=950000 && msg->p2>=50000 && cur_time.tv_usec>=10 && cur_time.tv_usec<=990))?1:0;
may_sync_sw = (first_tsync || (msg->p2<=950000 && msg->p2>=50000 && cur_time_sw.tv_usec>=10 && cur_time_sw.tv_usec<=990))?1:0;
timesync_method=msg->p3 & 0xFF;
timesync_bits=(msg->p3>>8) & 0xFF;
if(timesync_bits & CFG_TSYNC_USE_SWCLK)
cur_time_old = cur_time_sw;
else
cur_time_old = cur_time;
if((timesync_method!=SYNC_METHOD_IRIG_B && timesync_method!=SYNC_METHOD_IRIG_B_ZPRAE && (timesync_method!=SYNC_METHOD_CUSTOM || !(timesync_bits & CFG_TSYNC_FROM_DSP)))||first_tsync)
{
if(may_sync_sw)
{
cur_time_sw.tv_sec = msg->p1;
if(!(timesync_bits & CFG_TSYNC_USE_SWPPS) || pps3_timeout_cnt>60000)
cur_time_sw.tv_usec = msg->p2 / 1000;
}
if(may_sync_hw)
{
cur_time.tv_sec=msg->p1;
first_tsync=0;
if(!ext_sync)
cur_time.tv_usec=msg->p2 / 1000;
}
}
msg->p1=cur_time_old.tv_sec;
msg->p2=cur_time_old.tv_usec;
msg->p3=(dev_ctrl_state&DEV_CTRL_STATE_IRIGB_FIX_OK)?1:0;
break;
case DSP_CMD_CFG_STATE:
if(msg->p1==SET_CFG_CHANGE)
dev_ctrl_state|=DEV_CTRL_STATE_CFG_CHANGE;
else if(msg->p1==SET_CFG_ERR)
dev_ctrl_state|=DEV_CTRL_STATE_CFG_ERR;
else if(msg->p1==SET_CFG_OK)
dev_ctrl_state&=~DEV_CTRL_STATE_CFG_ERR;
if(msg->p2 & 0x01)
dev_ctrl_state|=DEV_CTRL_STATE_PTP_OK;
else
dev_ctrl_state&=~DEV_CTRL_STATE_PTP_OK;
if(msg->p2 & 0x02)
dev_ctrl_state|=DEV_CTRL_STATE_NTP_OK;
else
dev_ctrl_state&=~DEV_CTRL_STATE_NTP_OK;
mki7_sfplinks=msg->p3;
mki7_2_sfplinks=msg->p3>>8;
break;
case DSP_CMD_SET_EVENT_FILTER:
events_reg_filter_act = msg->p1 ? 1 : 0;
events_reg_filter_period = msg->p2 > 65535 ? 65535 : msg->p2;
events_reg_filter_trans_limit = msg->p3 > 127 ? 127 : msg->p3;
break;
case DSP_CMD_LOGMAN_STOP:
logman_stop();
msg->p1 = CMD_ACK;
break;
case DSP_CMD_LOGMAN_RESET:
logman_reset();
msg->p1 = CMD_ACK;
break;
case DSP_CMD_LOGMAN_PUSHFUN:
if(!(ret=logman_pushfunc(msg->p2,(void*)shared_buf,msg->p3)))
msg->p1 = CMD_ACK;
else
{
msg->p1 = CMD_ERR;
msg->p2 = ret;
}
msg->p3 = (u32)log_manager.cur_buf_ptr;
break;
case DSP_CMD_LOGMAN_START:
saved_bank = msg->p1>5?0:msg->p1;
if(!(ret = logman_start()))
msg->p1 = CMD_ACK;
else
{
msg->p1 = CMD_ERR;
msg->p2 = ret;
}
break;
case DSP_CMD_DEBUGLOG:
if(msg->p1)
dev_ctrl_state|=DEV_CTRL_STATE_SD_ERR;
else if(dev_ctrl_state & DEV_CTRL_STATE_SD_ERR)
dev_ctrl_state&=~DEV_CTRL_STATE_SD_ERR;
dev_ctrl_state&=0x0000FFFF;
dev_ctrl_state|=(msg->p2&0xFFFF)<<16;
msg->p1 = CMD_ACK;
dbg.delta_period = ic->delta_period_50M;
dbg.phase_corr = ic->phase_corr;
dbg.sync_reg = ic->sync_reg;
dbg.max_elements = MAX_LOG_ELEMENTS;
dbg.nets_bufsize = LOGMAN_NETSDATA_SIZE;
memcpy((u8*)shared_buf,(u8*)&dbg,sizeof(dbg));
break;
case DSP_CMD_GET_EV_BUF:
msg->p1 = CMD_ACK;
memcpy((u8*)shared_buf,(u8*)&ev_db,sizeof(ev_db));
break;
case DSP_CMD_GET_PROFILE_BUF:
msg->p1 = (Uint32)shared_buf;
memcpy((u8*)shared_buf,(u8*)&log_profile,sizeof(log_profile));
break;
case DSP_CMD_GET_LOGIC_EL_PARAMS:
msg->p1 = (Uint32)shared_buf;
i=0;
while(log_elements[i].id!=EOF_ELEMENT && log_elements[i].id<1024 && i<2048)
{
shared_buf[i]=((u32)log_elements[i].log_size<<16) |(u32)log_elements[i].args_size;
i++;
}
msg->p2=i;
break;
case DSP_CMD_START_PROFILER:
memset(&log_profile,0,sizeof(log_profile));
dbg.logman_cycle_time_max=0;
log_manager.status|=LOGMAN_STATUS_PROFILING;
msg->p1 = CMD_ACK;
break;
case DSP_CMD_STOP_PROFILER:
log_manager.status&=~LOGMAN_STATUS_PROFILING;
msg->p1 = CMD_ACK;
break;
case DSP_CMD_ETH_ON:
memcpy(eth.hwaddr,(char*)shared_buf,sizeof(eth.hwaddr));
memcpy(eth.name,(char*)shared_buf+sizeof(eth.hwaddr),sizeof(eth.name));
memcpy((char *)&eth.dev_no,(char*)shared_buf+sizeof(eth.hwaddr)+sizeof(eth.name),sizeof(eth.dev_no));
memcpy((char *)&eth.unicast_ip,(char*)shared_buf+sizeof(eth.hwaddr)+sizeof(eth.name)+sizeof(eth.dev_no),sizeof(eth.unicast_ip));
eth.ip=msg->p1;
eth.netmask=msg->p2;
eth.gateway=msg->p3;
eth.flags|=ETH_GOT_SETTINGS;
lwIPInit(0, eth.hwaddr, eth.ip, eth.netmask, eth.gateway, IPADDR_USE_STATIC);
memcpy((u8 *)bcast_nfo.id,"ZP6",3);
memcpy((u8 *)bcast_nfo.dev_name,"DSP ",4);
memcpy((u8 *)bcast_nfo.dev_name+4,eth.name,16);
bcast_nfo.dev_name[20]=0;
bcast_nfo.mlb_type=ZPRAE_MLB12_TYPE;
bcast_nfo.dev_type=0;
bcast_nfo.dev_num=eth.dev_no;
memcpy((u8 *)bcast_nfo.mac,eth.hwaddr,6);
eth.flags|=ETH_INITIALIZED;
Hwi_enableInterrupt(10);
Hwi_enableInterrupt(11);
/*
EMACTxIntPulseDisable(EMAC_0_BASE, EMAC_CTRL_0_BASE, 0, 0);
EMACRxIntPulseDisable(EMAC_0_BASE, EMAC_CTRL_0_BASE, 0, 0);
Hwi_disableInterrupt(10);
Hwi_disableInterrupt(11);
sitaraif_save_descriptors();
*/
msg->p1 = CMD_ACK;
break;
case DSP_CMD_ETH_OFF:
msg->p1 = CMD_ACK;
//if(eth.flags & ETH_ACTIVE)
{
//EMACTxIntPulseDisable(EMAC_0_BASE, EMAC_CTRL_0_BASE, 1, 1);
//EMACRxIntPulseDisable(EMAC_0_BASE, EMAC_CTRL_0_BASE, 1, 1);
Hwi_disableInterrupt(10);
Hwi_disableInterrupt(11);
eth.flags&=~ETH_ACTIVE;
}
break;
case DSP_CMD_ETH_OFF_ACK:
msg->p1 = CMD_ACK;
eth.flags|=ETH_OFF_ACK;
break;
default:
msg->cmd = CMD_ERR;
msg->p1 = CMD_ERR;
break;
}
MessageQ_put(msgqueue_id_remote, (MessageQ_Msg)msg);
}
}
}
Reference in New Issue View Git Blame Copy Permalink