bool Contest::setupPrizes(void) {
#ifdef DEBUG
stringstream debug;
#endif
PrizeNames.push_back("Nothing");
PrizeNames.push_back("Ringtones");
PrizeNames.push_back("Obsolete");
PrizeNames.push_back("Philips MP3 player");
PrizeNames.push_back("Philips Home Cinema");
PrizeNames.push_back("Peugeot 206 CC");
size_t ind = 0;
TimePeriod tp;
giftDetails p;
stringstream index;
while (ind < EOD.size() -1) {
tp = TimePeriod(EOD[ind], EOD[ind+1]);
index << EOD[ind].toString(true) << ":" << giftDetails::ID_MINUTEPRIZES;
p = giftDetails(giftDetails::ID_MINUTEPRIZES, PrizeNames[giftDetails::ID_MINUTEPRIZES], tp, MINUTEPRIZES, MINUTEPRIZES);
Prizes.insertObject(index.str(), p);
#ifdef EXTRADEBUG
debug << index.str() << ": ";
debug << p.insertString() << endl;
logMsg(debug.str());
debug.str("");
#endif
/* index.str("");
index << current.toString(true) << ":" << giftDetails::ID_HOURLYPRIZES;
p = giftDetails(giftDetails::ID_HOURLYPRIZES, PrizeNames[giftDetails::ID_HOURLYPRIZES], tp, HOURLYPRIZES, HOURLYPRIZES);
Prizes.insertObject(index.str(), p);
#ifdef EXTRADEBUG
debug << index.str() << ": ";
debug << p.insertString() << endl;
logMsg(debug.str());
debug.str("");
#endif*/
index.str("");
index << EOD[ind].toString(true) << ":" << giftDetails::ID_DAILYPRIZES;
p = giftDetails(giftDetails::ID_DAILYPRIZES, PrizeNames[giftDetails::ID_DAILYPRIZES], tp, DAILYPRIZES, DAILYPRIZES);
Prizes.insertObject(index.str(), p);
#ifdef EXTRADEBUG
debug << index.str() << ": ";
debug << p.insertString() << endl;
logMsg(debug.str());
debug.str("");
#endif
ind++;
index.str("");
}
ind = 0;
while (ind < EOW.size()-1) {
tp = TimePeriod(EOW[ind], EOW[ind+1]);
index << EOW[ind].toString(true) << ":" << giftDetails::ID_WEEKLYPRIZES;
p = giftDetails(giftDetails::ID_WEEKLYPRIZES, PrizeNames[giftDetails::ID_WEEKLYPRIZES], tp, WEEKLYPRIZES, WEEKLYPRIZES);
Prizes.insertObject(index.str(), p);
#ifdef EXTRADEBUG
debug << index.str() << ": ";
debug << p.insertString() << endl;
logMsg(debug.str());
debug.str("");
#endif
ind++;
index.str("");
}
tp = TimePeriod(EOW[ind], EOC);
index << EOW[ind].toString(true) << ":" << giftDetails::ID_WEEKLYPRIZES;
p = giftDetails(giftDetails::ID_WEEKLYPRIZES, PrizeNames[giftDetails::ID_WEEKLYPRIZES], tp, WEEKLYPRIZES, WEEKLYPRIZES);
Prizes.insertObject(index.str(), p);
#ifdef EXTRADEBUG
debug << index.str() << ": ";
debug << p.insertString() << endl;
logMsg(debug.str());
debug.str("");
#endif
ind++;
index.str("");
ind = 0;
while (ind < EOM.size() -1) {
tp = TimePeriod(EOM[ind], EOM[ind+1]);
index << EOM[ind].toString(true) << ":" << giftDetails::ID_MONTHLYPRIZES;
p = giftDetails(giftDetails::ID_MONTHLYPRIZES, PrizeNames[giftDetails::ID_MONTHLYPRIZES], tp, MONTHLYPRIZES, MONTHLYPRIZES);
Prizes.insertObject(index.str(), p);
#ifdef EXTRADEBUG
debug << index.str() << ": ";
debug << p.insertString() << endl;
logMsg(debug.str());
debug.str("");
#endif
ind++;
index.str("");
}
#ifdef DEBUG
debug.str("");
string colname = "qty_rem";
string iname = "gid";
stringstream val;
for (u_int i = giftDetails::ID_MINUTEPRIZES; i <= giftDetails::ID_MONTHLYPRIZES; i++) {
val.str("");
val << i;
debug << dec << "There are " << Prizes.sumColumn(val.str(), iname, colname)
<< " " << PrizeNames[i] << " available" << endl;
}
logMsg(debug.str());
#endif
return true;
}
static void
__download()
{
int i1, i2, i3;
char *ch, tmp[64];
#ifdef POLLING_MODE
rol->poll = 1;
#else
rol->poll = 0;
#endif
printf("\n>>>>>>>>>>>>>>> ROCID=%d, CLASSID=%d <<<<<<<<<<<<<<<<\n",rol->pid,rol->classid);
printf("CONFFILE >%s<\n\n",rol->confFile);
printf("LAST COMPILED: %s %s\n", __DATE__, __TIME__);
printf("USRSTRING >%s<\n\n",rol->usrString);
/* if slave, get fiber port number from user string */
#ifdef TI_SLAVE
ti_slave_fiber_port = 1; /* default */
ch = strstr(rol->usrString,"fp=");
if(ch != NULL)
{
strcpy(tmp,ch+strlen("fp="));
printf("tmp >>>>>>>>>>>>>>>>>>>>>%s<<<<<<<<<<<<<<<<<<<<<\n",tmp);
ti_slave_fiber_port = atoi(tmp);
printf("ti_slave_fiber_port =%d\n",ti_slave_fiber_port);
tiSetFiberIn_preInit(ti_slave_fiber_port);
}
#endif
/*
printf("rol1: downloading DDL table ...\n");
clonbanks_();
printf("rol1: ... done.\n");
*/
/**/
CTRIGINIT;
/* initialize OS windows and TI board */
#ifdef VXWORKS
CDOINIT(TIPRIMARY);
#else
CDOINIT(TIPRIMARY,TIR_SOURCE);
#endif
/************/
/* init daq */
daqInit();
DAQ_READ_CONF_FILE;
/*************************************/
/* redefine TI settings if neseccary */
#ifndef TI_SLAVE
/* TS 1-6 create physics trigger, no sync event pin, no trigger 2 */
vmeBusLock();
tiLoadTriggerTable(3);
tiSetTriggerWindow(14); // (7+1)*4ns trigger it coincidence time to form trigger type
/*
tiSetTriggerHoldoff(1,20,1);
tiSetTriggerHoldoff(2,0,1);
tiSetTriggerHoldoff(3,0,1);
tiSetTriggerHoldoff(4,0,1);
*/
// tiAddSlave(7);
// tiAddSlave(8);
vmeBusUnlock();
#endif
/*********************************************************/
/*********************************************************/
#ifdef USE_PRAD
/* (width + 3)*4 ns, 300 ns width */
vmeBusLock();
tiSetPromptTriggerWidth(60);
int ii;
for(ii = 1; ii <= 6; ++ii)
tiSetTSInputDelay(ii, 0);
vmeBusUnlock();
#endif
/* set wide pulse */
vmeBusLock();
/*sergey: WAS tiSetSyncDelayWidth(1,127,1);*/
/*worked for bit pattern latch tiSetSyncDelayWidth(0x54,127,1);*/
vmeBusUnlock();
usrVmeDmaSetConfig(2,5,1); /*A32,2eSST,267MB/s*/
/*usrVmeDmaSetConfig(2,5,0);*/ /*A32,2eSST,160MB/s*/
/*usrVmeDmaSetConfig(2,3,0);*/ /*A32,MBLT*/
/*
if(rol->pid==18)
{
usrVmeDmaSetConfig(2,3,0);
}
*/
/*
usrVmeDmaSetChannel(1);
printf("===== Use DMA Channel %d\n\n\n",usrVmeDmaGetChannel());
*/
tdcbuf = (unsigned int *)i2_from_rol1;
/******************/
/* USER code here */
#ifdef USE_PRAD
vmeBusLock();
dsc2Init(0x400000,0x80000,5,0/*1<<19*/);
ndsc2 = dsc2GetNdsc();
printf("!!!!!!!!!!! ndsc2=%d\n",ndsc2);
if(ndsc2>0)
{
DSC2_READ_CONF_FILE;
ndsc2_daq = dsc2GetNdsc_daq();
printf("!!!!!!!!!!! ndsc2_daq=%d\n",ndsc2_daq);
}
printf("Set Gate Source... \n");
dsc2SetGateSource(9, 1, 1);
//dsc2SetGateSource(9, 2, 3);
/*
dsc2Init(0x480000,0x80000,5,1<<19);
int dsc_ch, dsc_sl;
for(dsc_ch = 0; dsc_ch < 6; ++dsc_ch)
dsc2SetThreshold(0, dsc_ch, 100, TDCTRG);
for(dsc_sl = 1; dsc_sl < 5; ++dsc_sl) {
dsc2SetDelay(dsc_sl, 0, 3);
for(dsc_ch = 0; dsc_ch < 16; ++dsc_ch)
dsc2SetThreshold(dsc_sl, dsc_ch, 10, TDCTRG);
}
dsc2SetChannelMask(0,0xffff,TDCTRG);
dsc2SetChannelORMask(0,0xffff,TDCTRG);
dsc2Status(0,0);
*/
vmeBusUnlock();
#ifdef USE_V767
/*****************
* V767 SETUP
*****************/
/*vmeBusLock();*/
v767Init(V767_ADDR1,V767_OFF,1,0);
// turn off test mode
v767WriteMicro(0, 0x0200);
/* select stop trigger matching, substraction of trigger time,
all channels on, autoload on, and save configuration */
// v767SetAcqMode(0,0);
// v767SetDReadyMode(0,0);
/* v767BusErrEnable(0); */
/* v767SetBLKEndMode(0, 1); */
/* v767AutoloadDisable(itdc); */
/* v767AddrRotary(itdc); */
// v767SetEdgeDetectionMode(0,1);
/* v767OverlapTrigDisable(itdc); */
v767TriggerConfig(0,2000,1000,0);
/* v767ChannelMask(itdc,channelmask); */
v767Status(0, 0, 0);
// v767TriggerConfig(0,0,0,0); /* Print current trigger config */
printf("v767 8\n");fflush(stdout);
/*vmeBusUnlock();*/
/* v767SaveConfig(itdc); */
#endif
#ifdef USE_V1190
vmeBusLock();
tdc1190Init(V1190_ADDR1, V1190_OFF, 1, 0);
TDC_READ_CONF_FILE;
vmeBusUnlock();
#endif
#endif /* USE_PRAD */
sprintf(rcname,"RC%02d",rol->pid);
printf("rcname >%4.4s<\n",rcname);
#ifdef SSIPC
sprintf(ssname,"%s_%s",getenv("HOST"),rcname);
printf("Smartsockets unique name >%s<\n",ssname);
epics_msg_sender_init(getenv("EXPID"), ssname); /* SECOND ARG MUST BE UNIQUE !!! */
#endif
logMsg("INFO: User Download Executed\n",1,2,3,4,5,6);
}
t_uint32 PlatformInit(t_uint32 boot_indication, t_uint32 boot_status)
{
//volatile char toto; // for debug
char pwr_current_state;
volatile t_Header *p_header;
volatile t_ReqMb0 *p_ReqMB0;
volatile t_ShVar1 *p_MB_status;
volatile t_AckMb4 *p_ackMB4;
volatile t_DDRInit *p_ddr_mailbox;
volatile t_AVSData *p_AVSData;
char ddr_status;
unsigned i;
t_uint32 uPass = BOOT_OK;
logMsg("\r\nMEM_INIT start...\r\n");
p_header = (t_Header*)(TCDM_BASE+0xFE8);
p_ReqMB0 = (t_ReqMb0*)(TCDM_BASE+0xFDC);
p_MB_status = (t_ShVar1*)(TCDM_BASE+0xFFC);
p_ackMB4 = (t_AckMb4*)(TCDM_BASE+0xDF8);
p_AVSData = (t_AVSData *)(TCDM_BASE + 0x2E0);
p_ddr_mailbox = (t_DDRInit *)(TCDM_BASE+0x000);
if ( (boot_status & PWR_MNGT_STARTED) == PWR_MNGT_STARTED)
{
logMsg("MEM_INIT PWR_MNGT_STARTED\r\n");
//***********************
// All GPIOs reset
//***********************
IO(0x80157208) = 0x3FFFF;
// Clear AckMB interrupt
IO(0x8015748C)=0xFF;
// AB8500 update to config2 to be accessible in HWI2C
// => Bank 4 registers will be accessible with APE HWI2C
// => Sim Control registers will be accessible with Modem I2C
// => other registers will be accessible with APE HWI2C
HWI2C_Transfer_write(0x03,0x00,0x02); // write 0x2 in @0x300 (ReguSerialCtrl1 register)
// Enable body biasing (vbbn + vbbp)
HWI2C_Transfer_write(0x04, 0x01, 0x45);
// BUG VI28193
// Set VRF1Regu[1:0] to '10'
HWI2C_Transfer_write(0x04,0x0A,0x09);
//************************************************************
// Copy AVS structure in xp70 data mem and call FW AVS service
//************************************************************
p_AVSData->Voltage[AVS_VBB_RET ] = VBB_RET;
p_AVSData->Voltage[AVS_VBB_MAX_OPP ] = VBB_MAX_OPP;
p_AVSData->Voltage[AVS_VBB_100_OPP ] = VBB_100_OPP;
p_AVSData->Voltage[AVS_VBB_50_OPP ] = VBB_50_OPP;
p_AVSData->Voltage[AVS_VARM_MAX_OPP] = (1<<7)+COMP_VARM_MAX_OPP; // by default allow MAX opp. This is the aim of MASK_BIT7.
p_AVSData->Voltage[AVS_VARM_100_OPP] = COMP_VARM_100_OPP;
p_AVSData->Voltage[AVS_VARM_50_OPP ] = COMP_VARM_50_OPP;
p_AVSData->Voltage[AVS_VARM_RET ] = COMP_VARM_RET;
p_AVSData->Voltage[AVS_VAPE_100_OPP] = COMP_VAPE_100_OPP;
p_AVSData->Voltage[AVS_VAPE_50_OPP ] = COMP_VAPE_50_OPP;
p_AVSData->Voltage[AVS_VMOD_100_OPP] = COMP_VMOD_100_OPP;
p_AVSData->Voltage[AVS_VMOD_50_OPP ] = COMP_VMOD_50_OPP;
p_AVSData->Voltage[AVS_VSAFE ] = COMP_VSAFE;
// AVS service request
p_header->Req.un.Mb4 = AvsH;
// MailBox4 =>
// Send IT16 to XP70 to request AVS service
IO(0x80157100) |= 0x10;
while (p_ackMB4->field.AckMb4Status != (t_AckMb4Status)Avs_Ok);
logMsg("AVS_INIT OK\r\n");
// Clear AckMB4
p_ackMB4->field.AckMb4Status = AckMb4Init;
//*********************************
// Switch xP70 Fw in ApExecute
//*********************************
// power state transition request (header of MailBox0)
(p_header->Req).un.Mb0 = PwrStTrH;
(p_ReqMB0->PwrStTr).un.ApPwrStTr = ApBootToApExecute;
// Send IT (nb 10) to XP70
IO(0x80157100) |= 0x1;
logMsg("MEM_INIT IT sent to XP70\r\n");
pwr_current_state = p_MB_status->pwr_current_state_var;
// Check mailbox status
while (pwr_current_state != (t_ApPwrSt)ApExecute)
pwr_current_state = p_MB_status->pwr_current_state_var;
logMsg("MEM_INIT XP70 ApExecute\r\n");
//*********************************
// Fill DDR settings into XP70 data area
//*********************************
// Copy Mask for DDR controller registers
p_ddr_mailbox->MaskCfg0[0] = 0x6DFFFFFF; // no param into DENALI_CTL_25/28/31
p_ddr_mailbox->MaskCfg0[1] = 0x9800F1FF; // no param into DENALI_CTL_41/42/43/48to58 /61/62
p_ddr_mailbox->MaskCfg0[2] = 0xFFFFF309; // no param into DENALI_CTL_65/66/68to71/74/75
p_ddr_mailbox->MaskCfg0[3] = 0xFFFFFFFF;
p_ddr_mailbox->MaskCfg0[4] = 0x0001E01F; // no param into DENALI_CTL_133to140
// DDR settings
// REG_CONFIG_0 databahn registers
p_ddr_mailbox->Cfg0[0] = 0x00000101; // DENALI_CTL_0
p_ddr_mailbox->Cfg0[1] = 0x01010100; // DENALI_CTL_1
p_ddr_mailbox->Cfg0[2] = 0x00010001; // DENALI_CTL_2
p_ddr_mailbox->Cfg0[3] = 0x00010100; // DENALI_CTL_3
p_ddr_mailbox->Cfg0[4] = 0x01010100; // DENALI_CTL_4
p_ddr_mailbox->Cfg0[5] = 0x01000100; // DENALI_CTL_5
p_ddr_mailbox->Cfg0[6] = 0x00000000; // DENALI_CTL_6
p_ddr_mailbox->Cfg0[7] = 0x00000001; // DENALI_CTL_7
p_ddr_mailbox->Cfg0[8] = 0x00000101; // DENALI_CTL_8
p_ddr_mailbox->Cfg0[9] = 0x02020303; // DENALI_CTL_9
p_ddr_mailbox->Cfg0[10] = 0x03030303; // DENALI_CTL_10
p_ddr_mailbox->Cfg0[11] = 0x01030303; // DENALI_CTL_11
p_ddr_mailbox->Cfg0[12] = 0x00000301; // DENALI_CTL_12
p_ddr_mailbox->Cfg0[13] = 0x00000000; // DENALI_CTL_13
p_ddr_mailbox->Cfg0[14] = 0x00060207; // DENALI_CTL_14
p_ddr_mailbox->Cfg0[15] = 0x03000000; // DENALI_CTL_15
p_ddr_mailbox->Cfg0[16] = 0x04020202; // DENALI_CTL_16
p_ddr_mailbox->Cfg0[17] = 0x0c000f03; // DENALI_CTL_17
p_ddr_mailbox->Cfg0[18] = 0x00000f0d; // DENALI_CTL_18
p_ddr_mailbox->Cfg0[19] = 0x000e0000; // DENALI_CTL_19
p_ddr_mailbox->Cfg0[20] = 0x0002000a; // DENALI_CTL_20
p_ddr_mailbox->Cfg0[21] = 0x00060803; // DENALI_CTL_21
p_ddr_mailbox->Cfg0[22] = 0x05000909; // DENALI_CTL_22
p_ddr_mailbox->Cfg0[23] = 0x32002e1a; // DENALI_CTL_23
p_ddr_mailbox->Cfg0[24] = 0x23003200; // DENALI_CTL_24
p_ddr_mailbox->Cfg0[25] = 0x08110000; // DENALI_CTL_26
p_ddr_mailbox->Cfg0[26] = 0x00000034; // DENALI_CTL_27
p_ddr_mailbox->Cfg0[27] = 0x06100610; // DENALI_CTL_29
p_ddr_mailbox->Cfg0[28] = 0x06100610; // DENALI_CTL_30
p_ddr_mailbox->Cfg0[29] = 0xffff0000; // DENALI_CTL_32
p_ddr_mailbox->Cfg0[30] = 0xffffffff; // DENALI_CTL_33
p_ddr_mailbox->Cfg0[31] = 0x0000ffff; // DENALI_CTL_34
p_ddr_mailbox->Cfg0[32] = 0x00100100; // DENALI_CTL_35
p_ddr_mailbox->Cfg0[33] = 0x00000000; // DENALI_CTL_36
p_ddr_mailbox->Cfg0[34] = 0x00030000; // DENALI_CTL_37
p_ddr_mailbox->Cfg0[35] = 0x00391b4e; // DENALI_CTL_38
p_ddr_mailbox->Cfg0[36] = 0x0000003a; // DENALI_CTL_39
p_ddr_mailbox->Cfg0[37] = 0x00000028; // DENALI_CTL_40
p_ddr_mailbox->Cfg0[38] = 0x00000000; // DENALI_CTL_44
p_ddr_mailbox->Cfg0[39] = 0x00000000; // DENALI_CTL_45
p_ddr_mailbox->Cfg0[40] = 0x00000000; // DENALI_CTL_46
p_ddr_mailbox->Cfg0[41] = 0x00000000; // DENALI_CTL_47
p_ddr_mailbox->Cfg0[42] = 0x00000000; // DENALI_CTL_59
p_ddr_mailbox->Cfg0[43] = 0x00000000; // DENALI_CTL_60
p_ddr_mailbox->Cfg0[44] = 0x05000003; // DENALI_CTL_63
p_ddr_mailbox->Cfg0[45] = 0x00050006; // DENALI_CTL_64
p_ddr_mailbox->Cfg0[46] = 0x00000000; // DENALI_CTL_67
p_ddr_mailbox->Cfg0[47] = 0x00000000; // DENALI_CTL_72
p_ddr_mailbox->Cfg0[48] = 0x00007c00; // DENALI_CTL_73
p_ddr_mailbox->Cfg0[49] = 0x01000100; // DENALI_CTL_76
p_ddr_mailbox->Cfg0[50] = 0x01000103; // DENALI_CTL_77
p_ddr_mailbox->Cfg0[51] = 0x02020200; // DENALI_CTL_78
p_ddr_mailbox->Cfg0[52] = 0x02000103; // DENALI_CTL_79
p_ddr_mailbox->Cfg0[53] = 0x14000100; // DENALI_CTL_80
p_ddr_mailbox->Cfg0[54] = 0x0001b040; // DENALI_CTL_81
p_ddr_mailbox->Cfg0[55] = 0x00900000; // DENALI_CTL_82
p_ddr_mailbox->Cfg0[56] = 0x01900024; // DENALI_CTL_83
p_ddr_mailbox->Cfg0[57] = 0x00000014; // DENALI_CTL_84
p_ddr_mailbox->Cfg0[58] = 0x00000000; // DENALI_CTL_85
p_ddr_mailbox->Cfg0[59] = 0x00000000; // DENALI_CTL_86
p_ddr_mailbox->Cfg0[60] = 0x00820000; // DENALI_CTL_87
p_ddr_mailbox->Cfg0[61] = 0x00040082; // DENALI_CTL_88
p_ddr_mailbox->Cfg0[62] = 0x00010004; // DENALI_CTL_89
p_ddr_mailbox->Cfg0[63] = 0x00000001; // DENALI_CTL_90
p_ddr_mailbox->Cfg0[64] = 0x00000000; // DENALI_CTL_91
p_ddr_mailbox->Cfg0[65] = 0x00013880; // DENALI_CTL_92
p_ddr_mailbox->Cfg0[66] = 0x00000190; // DENALI_CTL_93
p_ddr_mailbox->Cfg0[67] = 0x00000fa0; // DENALI_CTL_94
p_ddr_mailbox->Cfg0[68] = 0x00010100; // DENALI_CTL_95
p_ddr_mailbox->Cfg0[69] = 0x01000001; // DENALI_CTL_96
p_ddr_mailbox->Cfg0[70] = 0x0a020201; // DENALI_CTL_97
p_ddr_mailbox->Cfg0[71] = 0x0009090a; // DENALI_CTL_98
p_ddr_mailbox->Cfg0[72] = 0x0fff0000; // DENALI_CTL_99
p_ddr_mailbox->Cfg0[73] = 0x00000fff; // DENALI_CTL_100
p_ddr_mailbox->Cfg0[74] = 0x03021000; // DENALI_CTL_101
p_ddr_mailbox->Cfg0[75] = 0x00050604; // DENALI_CTL_102
p_ddr_mailbox->Cfg0[76] = 0x06100610; // DENALI_CTL_103
p_ddr_mailbox->Cfg0[77] = 0x00000610; // DENALI_CTL_104
p_ddr_mailbox->Cfg0[78] = 0x00080403; // DENALI_CTL_105
p_ddr_mailbox->Cfg0[79] = 0x00110905; // DENALI_CTL_106
p_ddr_mailbox->Cfg0[80] = 0x39341a0d; // DENALI_CTL_107
p_ddr_mailbox->Cfg0[81] = 0x0304017e; // DENALI_CTL_108
p_ddr_mailbox->Cfg0[82] = 0x000f0610; // DENALI_CTL_109
p_ddr_mailbox->Cfg0[83] = 0x0039001d; // DENALI_CTL_110
p_ddr_mailbox->Cfg0[84] = 0x001e0010; // DENALI_CTL_111
p_ddr_mailbox->Cfg0[85] = 0x0089003a; // DENALI_CTL_112
p_ddr_mailbox->Cfg0[86] = 0x0030c6c9; // DENALI_CTL_113
p_ddr_mailbox->Cfg0[87] = 0x03494288; // DENALI_CTL_114
p_ddr_mailbox->Cfg0[88] = 0x00012009; // DENALI_CTL_115
p_ddr_mailbox->Cfg0[89] = 0x00048024; // DENALI_CTL_116
p_ddr_mailbox->Cfg0[90] = 0x00090024; // DENALI_CTL_117
p_ddr_mailbox->Cfg0[91] = 0x125224a4; // DENALI_CTL_118
p_ddr_mailbox->Cfg0[92] = 0x00110022; // DENALI_CTL_119
p_ddr_mailbox->Cfg0[93] = 0x00410082; // DENALI_CTL_120
p_ddr_mailbox->Cfg0[94] = 0x00110022; // DENALI_CTL_121
p_ddr_mailbox->Cfg0[95] = 0x00008001; // DENALI_CTL_122
p_ddr_mailbox->Cfg0[96] = 0x00020004; // DENALI_CTL_123
p_ddr_mailbox->Cfg0[97] = 0x00008001; // DENALI_CTL_124
p_ddr_mailbox->Cfg0[98] = 0x02491001; // DENALI_CTL_125
p_ddr_mailbox->Cfg0[99] = 0x02ca1001; // DENALI_CTL_126
p_ddr_mailbox->Cfg0[100] = 0x044b36c9; // DENALI_CTL_127
p_ddr_mailbox->Cfg0[101] = 0x019130c6; // DENALI_CTL_128
p_ddr_mailbox->Cfg0[102] = 0x1c7334c6; // DENALI_CTL_129
p_ddr_mailbox->Cfg0[103] = 0x0c31a906; // DENALI_CTL_130
p_ddr_mailbox->Cfg0[104] = 0x0c31a083; // DENALI_CTL_131
p_ddr_mailbox->Cfg0[105] = 0x0201a347; // DENALI_CTL_132
p_ddr_mailbox->Cfg0[106] = 0x03cb1001; // DENALI_CTL_141
p_ddr_mailbox->Cfg0[107] = 0x00010003; // DENALI_CTL_142
p_ddr_mailbox->Cfg0[108] = 0x00008001; // DENALI_CTL_143
p_ddr_mailbox->Cfg0[109] = 0x00010003; // DENALI_CTL_144
//Lpddr2 phy
p_ddr_mailbox->Cfg0[110] = 0x03cb1001; // DENALI_CTL_72
IO(0x80157438) = 0x00000000; // LpDDR2 start at 400Mhz
logMsg("MEM_INIT LpDDR2 at 400Mhz settings filled\r\n");
// DDR init request (header of MailBox4)
p_header->Req.un.Mb4 = ddrInitH;
// MailBox4 => no need to fill MB4 structure
// Send IT16 to XP70 to init DDR
IO(0x80157100) |= 0x10;
logMsg("MEM_INIT IT16 to XP70 to init DDR\r\n");
ddr_status = p_ackMB4->field.AckMb4Status;
while (ddr_status != (t_AckMb4Status)DDROn_Ok)
ddr_status = p_ackMB4->field.AckMb4Status;
logMsg("MEM_INIT DDR_ON OK\r\n");
// Clear AckMB4
p_ackMB4->field.AckMb4Status = AckMb4Init;
// Clear PRCM_ARM_IT1 IT for ackmb4
while((IO(0x80157494) & 0x10) != 0x10);
// Clear PRCM_ARM_IT1 ackmb4
IO(0x8015748C)=0x10;
}
//#######################################
//# Modem start-up
//#######################################
// Needed to send SYSCLK_OK to modem, but should be corrected in fw xP70
IO(0x80157318) = 0x0; //PRCM_SYSCLKOK_DELAY (val * 32K) 0 no delay
IO(0x801571FC) = 0x3; // Release Modem PURX and SWReset
IO(0x801574A4) = 0x1; // Ack SWReset from Modem in case of reboot due to this reason
IO(0x801574A4) = 0x0;
i = 0;
while( ((IO(0x801574A0) & 0x1) != 0x1) && (i<10000)) {
i++;
}
// Request Modem HOST_PORT interface
IO(0x80157334) = 0x00007; // PRCM_HOSTACCESS_REQ
// [16] Wake_req = 0
// [2:1] HOSTACCESS_ID = 11 (A9ss)
// [0] mod_host_port_req = 1
// Waiting for modem HOST_PORT available (other signal name HOST_PORT_OK)
i = 0;
while( ((IO(0x80157170) & 0x800) != 0x800) && (i<10000)) {
i++;
}
//####################################################################################
//####################################################################################
// Now, MSS is powered, and ready to execute SW.
// the HOST PORT interface is enabled, so A9SS can access to the MSS mapping
//####################################################################################
//####################################################################################
//#####
//Configure Modem STM trace
//#####
Modem_STM_config();
logMsg("MEM_INIT Modem_STM_config\r\n");
//#####
//Configure PRCMU STM trace
//#####
//PRCMU_STM_config();
//DDR test
if (boot_indication == SECOND_BOOT_INDICATION)
{
uPass = Test_Write_Read_DDR();
}
logMsg("MEM_INIT end\r\n");
return uPass;
}
/**finer logs the message at FINER level.
* The message is appended to the log file if the current level is in the range SEVERE to FINER
*
*@param toLog the message text to log
*/
void Logger::finer(string toLog) {
if (levelSet < FINER) return;
logMsg(FINER, toLog);
}
/**Destructs the Logger object after closing its log file.
*/
Logger::~Logger(void) {
logMsg (SEVERE, "logging END");
if (fileLog != stderr) fclose(fileLog);
}
/**severe logs a message at SEVERE level.
* All SEVERE messages are appended to the log file.
*
*@param toLog the message text to log
*/
void Logger::severe(string toLog) {
logMsg(SEVERE, toLog);
}
/** info logs message at INFO level.
* The message is appended to the log file if the current level is in the range SEVERE to INFO
*
*@param toLog the message text to log
*/
void Logger::info (string toLog) {
if (levelSet < INFO) return;
logMsg(INFO, toLog);
}
void offenseState::executeOffense() // executes box offense
{
gameState *gameS = gameState::Instance();
std::vector<teamState> teamInstance = gameS->getTeamInstance();
std::vector<playerState> playerInstance = teamInstance[gameS->getTeamWithBall()].getPlayerInstance();
int teamNumber = gameS->getTeamWithBall();
int playerWithBall = teamInstance[teamNumber].getPlayerWithBall();
playerSteer *pSteer;
if (!allStartPositionsReached) // checks if all players have reached their start positions for the offense being run
{
for (int x=0;x<5;++x)
{
if ( x != playerWithBall)
{
pSteer = playerInstance[x].getSteer();
std::vector<bool> positionReached = pSteer->getPositionReached();
if (positionReached.size() != 1)
{
positionReached.push_back(false);
pSteer->setPositionReached(positionReached);
}
if (!startPositionReached[x]) // checks if each player has reached the start position
{
std::vector<Ogre::Vector3> steerCoords = plays[0].getStartPositions();
OpenSteer::Vec3 coords = pSteer->convertToOpenSteerVec3(startPositions[x]);
pSteer->setSteerCoords(coords);
pSteer->setExecute(true);
}
else // increments the counter
{
// numStartPositionsReached += 1;
pSteer->setExecute(false);
}
if (numStartPositionsReached == 4) // FIXME: hard coded for a human player
{
// exit(0);
allStartPositionsReached = true;
}
if (!startPositionReached[x] && pSteer->getDistToPosition() < 3 && pSteer->getDistToPosition() != -1.0f)
{
startPositionReached[x] = true;
numStartPositionsReached += 1;
pSteer->setExecute(false);
}
logMsg("startPositionsReached = " +Ogre::StringConverter::toString(startPositionReached[x]));
}
}
}
else
{
// exit(0);
if (!allExecutePositionsReached)
{
// exit(0);
int allExecutionsReached = 0;
for (int ID=0;ID<5;++ID)
{
if (allExecutionsReached < 4)
{
if (ID != playerWithBall)
{
pSteer = playerInstance[ID].getSteer();
bool directiveComplete = checkForDirective(pSteer->getDesignation()); // checks if player must follow directive before executing
if (directiveComplete)
{
logMsg("Player " +Ogre::StringConverter::toString(ID) +" executePositionReached size = " +Ogre::StringConverter::toString(executePositionReached[ID].size()));
for (int x=0;x<executePositionReached[ID].size();++x)
{
if (executePositionReached[ID][x] == true)
{
logMsg("Player " +Ogre::StringConverter::toString(ID));
// exit(0);
}
else
{
int lastPos = executePositionReached[ID].size() - 1;
if (executePositionReached[ID][lastPos])
{
allExecutionsReached += 1;
}
// checks if previous position was reached
else if ( x > 0 && !executePositionReached[ID][x - 1])
{
// exit(0);
// break;
}
else //if (!executePositionReached[ID][x])
{
logMsg("Team " +Ogre::StringConverter::toString(teamNumber) +" Player " +Ogre::StringConverter::toString(ID) +" Seeking Offense Execute Position!");
OpenSteer::Vec3 executePosition = pSteer->convertToOpenSteerVec3(executePositions[ID][x]);
pSteer->setSteerCoords(executePosition);
float distToPosition = OpenSteer::Vec3::distance (pSteer->getSteerCoords(), pSteer->position());
pSteer->setDistToPosition(distToPosition);
if (pSteer->getDistToPosition() < 3 && pSteer->getDistToPosition() != -1.0f)
{
// exit(0);
executePositionReached[ID][x] = true;
pSteer->setExecute(false);
}
else
{
// exit(0);
pSteer->setExecute(true);
}
}
}
}
}
}
}
else
{
allExecutePositionsReached = true;
}
}
}
else
{
for (int x=0;x<5;++x)
{
pSteer = playerInstance[x].getSteer();
pSteer->setExecute(false);
playerInstance[x].setSteer(pSteer);
}
}
// exit(0);
}
}
/*!
* Writes an logfile message from type INFO
*/
void TTMessageLogger::infoMsg(QString caller, QString msgString)
{
logMsg(INFO, caller, msgString);
}
// updates the game state
bool gameState::updateState()
{
// logMsg("Updating gameState Logic");
boost::shared_ptr<AISystem> ai = AISystem::Instance();
boost::shared_ptr<conversion> convert = conversion::Instance();
boost::shared_ptr<gameEngine> gameE = gameEngine::Instance();
boost::shared_ptr<networkEngine> network = networkEngine::Instance();
boost::shared_ptr<physicsEngine> physEngine = physicsEngine::Instance();
timing timer = gameE->getTimer();
Ogre::Vector3 playerPos;
basketballInstance[activeBBallInstance].updateState();
basketballInstance[activeBBallInstance].setPlayer(5);
if (gameSetupComplete)
{
if (network->getPacketReceived()) // checks if a packet was received by network engine
{
processNetworkEvents(); // processes data received from the network
}
logMsg("network events processed");
if (!tipOffComplete) // calls tip off execution
{
if (executeTipOff())
{
tipOffComplete = true;
// exit(0);
}
}
if (teamWithBall != NOTEAM)
{
// logMsg("teamWithBall is " +convert->toString(teamWithBall));
// logMsg("playetWithBall is " +convert->toString(teamInstance[teamWithBall].getPlayerWithBall()));
// float currentTime = static_cast<float>(gameE->getLoopTime().getMilliseconds()/100);
long currentTime = timer.getLoopTimeMill().count();
float oldTime = ai->getOldTime();
float changeInTime = currentTime - oldTime;
// ai->update(currentTime, changeInTime);
logMsg("CHANGE == " +convert->toString(changeInTime));
if (changeInTime >= .5f)
{
logMsg("ELAPSED == " +convert->toString(changeInTime));
// exit(0);
// ai->update(aiTimer.getTotalSimulationTime (), aiTimer.getElapsedSimulationTime ());
ai->update(currentTime, changeInTime);
ai->setOldTime(currentTime);
}
}
logMsg("Physics");
physEngine->updateState(); // updates the state of the physics simulation
logMsg("stepWorld");
// exit(0);
physEngine->stepWorld(); // steps the physics simulation
/* logMsg("DirectionsAndMovement");
updateDirectionsAndMovements();
*/
// exit(0);
// updates the basketball(s) state
logMsg("Updated basketball state!");
// exit(0);
// renderBall();
// SceneNode *bball = basketballInstance[activeBBallInstance].getNode();
// bball->setPosition(basketballInstance[activeBBallInstance].calculatePositionChange());
// basketballInstance[activeBBallInstance].setNode(bball);
// Ogre::Vector3 change = basketballInstance[activeBBallInstance].calculatePositionChange();
// cout << "Calced Pos change = " << basketballInstance[activeBBallInstance].calculatePositionChange() << endl;
// basketballInstance[activeBBallInstance].nodeChangePosition(basketballInstance[activeBBallInstance].calculatePositionChange());
// std::vector<size_t> playerDirection = player->getPlayerDirection(); // stores contents of playerDirectdion from players class in local variable
// std::vector<size_t> oldPlayerDirection = player->getOldPlayerDirection(); // stores contents of oldPlayerDirection form players in local variable
// Initiates offense or defense for a team depending on value of teamWithBall
if (teamWithBall == 0) // if 0 puts team 0 on offense and team 1 on defense
{
teamInstance[0].setOffense(true);
teamInstance[0].setDefense(false);
teamInstance[1].setOffense(false);
teamInstance[1].setDefense(true);
}
else if (teamWithBall == 1) // if 1 puts team 1 on offense and team 0 on defense
{
teamInstance[0].setOffense(false);
teamInstance[0].setDefense(true);
teamInstance[1].setOffense(true);
teamInstance[1].setDefense(false);
}
else
{
}
// updates the state of each team
if (teamInstancesCreated)
{
//FIXME crash in updateState code
teamInstance[0].updateState();
teamInstance[1].updateState();
// exit(0);
}
else
{
}
}
// logMsg("gameState logic updated");
// exit(0);
return true;
}
void gameState::processNetworkPlayerEvents() // processes player events from network code
{
//conversion *convert = conversion::Instance();
boost::shared_ptr<conversion> convert = conversion::Instance();
//networkEngine *network = networkEngine::Instance();
boost::shared_ptr<networkEngine> network = networkEngine::Instance();
networkPlayerStateObject netPStateObj;
std::stringstream strStream;
std::vector<playerState> activePlayerInstance;
std::string receivedData = network->getReceivedData(); // stores receivedData value
size_t playerNumber = -1; // stores which player the data is for
size_t iterator; // iterator for match loop
logMsg("received Data === " +receivedData);
strStream << receivedData;
strStream >> netPStateObj;
logMsg("received teamID = " +convert->toString(netPStateObj.getTeamID()));
logMsg("received playerID = " +convert->toString(netPStateObj.getPlayerID()));
// sets which team's activePlayerInstance to use
if (network->getIsClient())
{
logMsg("is client");
activePlayerInstance = teamInstance[1].getActivePlayerInstance();
}
else if (network->getIsServer())
{
logMsg("is server");
activePlayerInstance = teamInstance[0].getActivePlayerInstance();
}
else
{
}
logMsg("activePlayerInstance size == " +convert->toString(activePlayerInstance.size()));
/* for (iterator = 0; iterator < 5; ++iterator)
{
std::string searchString; // stores search String
std::string searchIterator = convert->toString(iterator); // converts iterator to a string
searchString = "*" +searchIterator + "*"; // creates search string
if (Ogre::StringUtil::match(receivedData,searchString)) // checks for a match
{
playerNumber = iterator; // sets playerNumber to value of iterator
}
}
logMsg("alive????");
*/
playerNumber = netPStateObj.getPlayerID();
if (activePlayerInstance.size() > 0)
{
if (netPStateObj.getMovement())
{
switch (netPStateObj.getDirection())
{
case 0: // move player up
activePlayerInstance[playerNumber].setMovement(true);
activePlayerInstance[playerNumber].setDirection(UP);
break;
case 1: // move player down
activePlayerInstance[playerNumber].setMovement(true);
activePlayerInstance[playerNumber].setDirection(DOWN);
break;
case 2: // move player left
activePlayerInstance[playerNumber].setMovement(true);
activePlayerInstance[playerNumber].setDirection(LEFT);
break;
case 3: // move player right
activePlayerInstance[playerNumber].setMovement(true);
activePlayerInstance[playerNumber].setDirection(RIGHT);
break;
case 4: // move player up and left
activePlayerInstance[playerNumber].setMovement(true);
activePlayerInstance[playerNumber].setDirection(UPLEFT);
break;
case 5: // move player up aned right
activePlayerInstance[playerNumber].setMovement(true);
activePlayerInstance[playerNumber].setDirection(UPRIGHT);
break;
case 6: // move player down and left
activePlayerInstance[playerNumber].setMovement(true);
activePlayerInstance[playerNumber].setDirection(DOWNLEFT);
break;
case 7: // move player down and right
activePlayerInstance[playerNumber].setMovement(true);
activePlayerInstance[playerNumber].setDirection(DOWNRIGHT);
break;
default:
activePlayerInstance[playerNumber].setMovement(false);
break;
}
if (network->getIsClient())
{
teamInstance[1].setActivePlayerInstance(activePlayerInstance);
}
else if (network->getIsServer())
{
teamInstance[0].setActivePlayerInstance(activePlayerInstance);
}
}
else if (netPStateObj.getShootBlock())
{
}
else if (netPStateObj.getPassSteal())
{
}
else
{
}
}
logMsg("Survived!");
network->setReceivedData("");
}
// sets up the game condition
bool gameState::setupState()
{
//AISystem *ai = AISystem::Instance();
boost::shared_ptr<AISystem> ai = AISystem::Instance();
boost::shared_ptr<renderEngine> render = renderEngine::Instance();
boost::shared_ptr<loader> load = loader::Instance();
boost::shared_ptr<physicsEngine> physEngine = physicsEngine::Instance();
boost::shared_ptr<conversion> convert = conversion::Instance();
logMsg("Setting up state!");
if (!courtModelLoaded)
{
logMsg("creating court instances!");
if (createCourtInstances()) // creates the court instances
{
courtModelLoaded = true;
courtInstanceCreated = true;
}
}
if (!basketballInstancesCreated) // checks if court model has been loaded
{
logMsg("creating basketball instances!");
if (createBasketballInstances()) // creates the basketball instances
{
basketballInstancesCreated = true;
}
// FIXEME! this should not be hard coded
activeBBallInstance = 0; // sets the active basketball instance
}
if (!hoopModelLoaded)
{
logMsg("creating hoop instances!");
if (createHoopInstances()) // creates the hoop instances
{
hoopModelLoaded = true;
}
}
setBasketballStartPositions(); // sets starting positions for all basketballs that are instantiated
setCourtStartPositions(); // sets starting positions for all courts that are instantiated
setHoopStartPositions(); // sets starting positions for all hoops that are instantiated
logMsg("court y == " +convert->toString(courtInstance[0].getNode()->getPosition().y));
// exit(0);
if (!teamInstancesCreated) // checks if teamInstances have been created
{
if(createTeamInstances()) // creates the team instances
{
logMsg("TIC!");
teamInstancesCreated = true;
assignHoopToTeams(); // assigns proper hoop to the teams that were created.
}
}
// sets the quarter being played to the first one.
quarter = FIRST;
// basketballInstance[activeBBallInstance].getNode()->setPosition(1.4f,5.0f,366.0f);
physEngine->setupState(); // sets up the Physics Engine state
// exit(0);
ai->setup();
// Ogre::Entity *ent;
// ent = player->getModel(0);
// player->mAnimationState2 = ent->getAnimationState("Walk");
// std::vector<Ogre::Entity*> playerModels = player->getModel();
// std::vector<Ogre::SceneNode*> playerNodes = player->getNode();
// std::vector<playerState> pInstance = getPlayerInstance();
// player->setModel(playerModels);
// Ogre::Vector3 playerPos = playerNodes.at(0)->getPosition();
// Ogre::Vector3 offset;
// offset[0] = 2.0f;
// offset[1] = 2.0f;
// offset[2] = 2.0f;
// bball->setAutoTracking(true,playerNode[0],playerNode[0]->getPosition(),offset);
// bball->setPosition(playerPos[0] +2.0f, playerPos[1] + 4.0f, playerPos[2] - 1.0f);
// exit(0);
if (!setupEnvironmentCompleted) // checks if environment has been setup
{
if(setupEnvironment()) // sets up environment
{
setupEnvironmentCompleted = true;
}
}
// loads("../../data/players/players.xml");
if (!tipOffSetupComplete)
{
tipOffSetupComplete = setupTipOff(); // sets up tip off conditions
}
return true;
//#endif
}
//------------------------------------------------------------------------------
// Main entry point to this program
//------------------------------------------------------------------------------
int main(int argc, char** argv)
{
int c;
bool clearLockOnly = false;
bool rollbackOnly = false;
uint32_t tableOID = 0;
while ((c = getopt(argc, argv, "hlr:")) != EOF)
{
switch (c)
{
case 'l':
clearLockOnly = true;
break;
//Only allow '-r' option for development/debugging
#if 1
case 'r': // hidden option to rollback specified table w/o a lock
rollbackOnly = true;
tableOID = ::strtoull(optarg, 0, 10);
break;
#endif
case 'h':
case '?':
default:
usage();
return (c == 'h' ? 0 : 1);
break;
}
}
if ((argc - optind) != 1 )
{
usage();
return 1;
}
// Get the table lock ID specified by the user
uint64_t lockID = ::strtoull(argv[optind], 0, 10);
// If user specified both clearlock and rollback then we need to do both
if (clearLockOnly && rollbackOnly)
{
clearLockOnly = false;
rollbackOnly = false;
}
//--------------------------------------------------------------------------
// Verify that BRM is up and in a read/write state
//--------------------------------------------------------------------------
BRM::DBRM brm;
int brmRc = brm.isReadWrite();
if (brmRc != BRM::ERR_OK)
{
std::string brmErrMsg;
BRM::errString(brmRc, brmErrMsg);
std::cout << "BRM error: " << brmErrMsg << std::endl;
std::cout << "Table lock " << lockID << " is not cleared." << std::endl;
return 1;
}
if (brm.getSystemReady() < 1)
{
std::cout << "System is not ready. Verify that EryDB "
"is up and ready before running this program" << std::endl;
return 1;
}
//--------------------------------------------------------------------------
//@Bug 3711 Check whether the table is locked; does the table lock exist.
//--------------------------------------------------------------------------
execplan::erydbSystemCatalog::TableName tblName;
BRM::TableLockInfo tInfo;
std::string task;
std::vector<uint32_t> pmList;
int rc;
const std::string taskSysCat("getting system catalog information");
try {
if (rollbackOnly)
{
tInfo.id = lockID;
tInfo.tableOID = tableOID;
tInfo.ownerPID = 0;
tInfo.ownerSessionID = 1;
tInfo.state = BRM::LOADING;
// Construct PM list using all PMs, since we don't have a table
// lock with the list of applicable DBRoots.
task = "constructing total PM list";
rc = constructPMList( pmList );
if (rc != 0)
{
return 1;
}
}
else
{
task = "getting table lock";
bool lockExists = brm.getTableLockInfo( lockID, &tInfo );
if (!lockExists)
{
std::cout << "Table lock " << lockID << " does not exist." <<
std::endl;
return 1;
}
// Construct PM list based on list of affected DBRoots
task = "mapping DBRoots to PMs";
rc = constructPMList( tInfo.dbrootList, pmList );
if (rc != 0)
{
return 1;
}
}
uint32_t sessionID = 1;
task = taskSysCat;
boost::shared_ptr<execplan::erydbSystemCatalog> systemCatalogPtr =
execplan::erydbSystemCatalog::makeerydbSystemCatalog(
sessionID );
systemCatalogPtr->identity(execplan::erydbSystemCatalog::EC);
tblName = systemCatalogPtr->tableName( tInfo.tableOID );
}
catch (std::exception& ex)
{
std::cout << "Error " << task << ". " << ex.what() << std::endl;
if (clearLockOnly && (task == taskSysCat))
{
tblName.schema= "[unknown name]";
tblName.table.clear();
std::cout << "Will still try to clear table lock." << std::endl;
}
else
{
std::cout << "Table lock " << lockID << " is not cleared." <<
std::endl;
return 1;
}
}
catch (...)
{
std::cout << "Error " << task << ". " << std::endl;
if (clearLockOnly && (task == taskSysCat))
{
tblName.schema= "[unknown name]";
tblName.table.clear();
std::cout << "Will still try to clear table lock." << std::endl;
}
else
{
std::cout << "Table lock " << lockID << " is not cleared." <<
std::endl;
return 1;
}
}
logInitStatus( tblName.toString(), lockID );
if (rollbackOnly)
{
std::cout << "Rolling back table " << tblName.toString() <<
std::endl << std::endl;
}
else if (clearLockOnly)
{
std::cout << "Clearing table lock " << lockID <<
" for table " << tblName.toString() << std::endl << std::endl;
}
else
{
std::cout << "Rolling back and clearing table lock for table " <<
tblName.toString() << "; table lock " << lockID <<
std::endl << std::endl;
}
//--------------------------------------------------------------------------
// Perform bulk rollback
//--------------------------------------------------------------------------
std::string errMsg;
if (!clearLockOnly)
{
std::vector<boost::shared_ptr<messageqcpp::MessageQueueClient> >
msgQueClts;
rc = createMsgQueClts(pmList, msgQueClts, errMsg);
if (rc != 0)
{
logFinalStatus( tblName.toString(), lockID, errMsg );
std::cout << errMsg << std::endl;
std::cout << "Table lock " << lockID << " for table " <<
tblName.toString() << " is not cleared." << std::endl;
return rc;
}
rc = execBulkRollbackReq( msgQueClts, pmList,
&brm, tInfo, tblName.toString(), rollbackOnly, errMsg );
if (rc != 0)
{
logFinalStatus( tblName.toString(), lockID, errMsg );
std::cout << "Rollback error: " << errMsg << std::endl;
std::cout << "Table lock " << lockID << " for table " <<
tblName.toString() << " is not cleared." << std::endl;
return rc;
}
//----------------------------------------------------------------------
// Change the state of the table lock to cleanup state.
// We ignore the return stateChange flag.
//----------------------------------------------------------------------
if (!rollbackOnly)
{
try {
brm.changeState( tInfo.id, BRM::CLEANUP );
}
catch (std::exception& ex)
{
std::ostringstream oss;
oss << "Error changing state. " << ex.what();
logFinalStatus( tblName.toString(), lockID, oss.str() );
std::cout << oss.str() << std::endl;
std::cout << "Table lock " << lockID << " is not cleared." <<
std::endl;
return 1;
}
catch (...)
{
std::ostringstream oss;
oss << "Error changing state. " << std::endl;
logFinalStatus( tblName.toString(), lockID, oss.str() );
std::cout << oss.str() << std::endl;
std::cout << "Table lock " << lockID << " is not cleared." <<
std::endl;
return 1;
}
}
//----------------------------------------------------------------------
// Delete the meta data files
//----------------------------------------------------------------------
rc = execFileCleanupReq( msgQueClts, pmList,
&brm, tInfo, tblName.toString(), errMsg );
if (rc != 0)
{
//@Bug 4517. Release tablelock if remove meta files failed
const std::string APPLNAME("cleartablelock command");
const int SUBSYSTEM_ID = 19; // writeengine?
const int COMP_MSG_NUM = logging::M0089;
logging::Message::Args msgArgs;
logging::Message logMsg( COMP_MSG_NUM );
msgArgs.add( APPLNAME );
msgArgs.add( tblName.toString() );
msgArgs.add( lockID );
msgArgs.add( errMsg );
logMsg.format( msgArgs );
logging::LoggingID lid( SUBSYSTEM_ID );
logging::MessageLog ml( lid );
ml.logWarningMessage( logMsg );
std::cout << "File cleanup error: " << errMsg << std::endl;
}
} // end of: if (!clearLockOnly)
//--------------------------------------------------------------------------
// Finally, release the actual table lock
//--------------------------------------------------------------------------
std::cout << std::endl;
if (rollbackOnly)
{
logFinalStatus( tblName.toString(), lockID, std::string() );
std::cout << "Bulk Rollback Only for table " << tblName.toString() <<
" completed successfully." << std::endl;
}
else
{
try {
brm.releaseTableLock( lockID ); // ignore boolean return value
}
catch (std::exception& ex)
{
logFinalStatus( tblName.toString(), lockID, ex.what() );
std::cout << "Error releasing table lock " << lockID <<
" for table " << tblName.toString() << std::endl;
std::cout << ex.what() << std::endl;
return 1;
}
catch (...)
{
std::string unknownErr("Unknown exception");
logFinalStatus( tblName.toString(), lockID, unknownErr );
std::cout << "Error releasing table lock " << lockID <<
" for table " << tblName.toString() << std::endl;
std::cout << unknownErr << std::endl;
return 1;
}
logFinalStatus( tblName.toString(), lockID, std::string() );
std::cout << "Table lock " << lockID << " for table " <<
tblName.toString() << " is cleared." << std::endl;
}
return 0;
}
void EventLogControl::logAction(const wxString& action)
{
wxString now(wxDateTime::Now().Format("%H:%M:%S "));
addStyledText(now, logStyleImportant);
logMsg(action + "\n");
}
ROUTE_ENTRY * routeLookup
(
struct sockaddr * pDest, /* IP address reachable with matching route */
ULONG * pMask, /* netmask value, in network byte order */
int protoId /* route source from m2Lib.h, or 0 for any. */
)
{
struct radix_node_head * pHead = rt_tables[pDest->sa_family];
struct radix_node * pNode; /* radix tree entry for route */
struct rtentry * pRoute = NULL; /* candidate for matching route */
ROUTE_ENTRY * pMatch = NULL; /* matching route entry */
struct sockaddr_in netmask; /* netmask value, internal format */
char * pNetmask = NULL; /* target netmask value from tree */
struct rtentry * pNextRoute;
STATUS result = ERROR; /* OK indicates a successful search */
int s;
if (pHead == NULL)
{
/* No route table exists for the given address family. */
return (NULL);
}
bzero ( (char *)&netmask, sizeof (struct sockaddr_in));
s = splnet ();
/*
* If a specific netmask match is required, find the target value
* (a pointer to the stored netmask entry) which will determine
* whether the match exists. A mask value of zero indicates a
* host-specific route, which does not contain a netmask entry.
*/
if (pMask && *pMask)
{
/* Setup data structure to search mask's tree for given value. */
netmask.sin_family = AF_INET;
netmask.sin_len = sizeof (struct sockaddr_in);
netmask.sin_addr.s_addr = *pMask;
TOS_SET (&netmask, 0x1f);
in_socktrim (&netmask); /* Adjust length field for tree search. */
/* Search for netmask from corresponding tree. */
pNode = rn_addmask (&netmask, 1, pHead->rnh_treetop->rn_off);
if (pNode == 0)
{
/* No route currently uses the specified netmask. */
#ifdef DEBUG
logMsg ("routeLookup: requested mask does not exist.\n",
0, 0, 0, 0, 0, 0);
#endif
splx(s);
return (NULL);
}
pNetmask = pNode->rn_key;
}
pNode = pHead->rnh_matchaddr ((caddr_t)pDest, pHead);
if (pNode && ((pNode->rn_flags & RNF_ROOT) == 0))
{
/* Possible match found. Save for later use. */
pRoute = (struct rtentry *)pNode;
}
else
{
/* No route matches the given key. */
splx (s);
return (NULL);
}
#ifdef DEBUG
logMsg ("routeLookup: candidate for match at %p.\n", pNode,
0, 0, 0, 0, 0);
#endif
/*
* Compare the set of routes available with the initial key
* against the desired values. Each entry in the chain of
* routes with duplicate keys uses a different netmask value.
*
* NOTE: The pNode value is not necessarily the start of the
* chain. It is the first entry in the chain with a short
* enough netmask to produce a match against the destination.
*/
for ( ; pRoute != NULL; pRoute = pNextRoute)
{
/* Select the next route candidate in case a test fails. */
pNextRoute = (struct rtentry *)
((struct radix_node *)pRoute)->rn_dupedkey;
if (pMask)
{
/*
* Check mask of route against corresponding entry from
* the stored netmasks (derived from the given value).
*/
#ifdef DEBUG
logMsg ("routeLookup: checking against specific mask.\n",
0, 0, 0, 0, 0, 0);
#endif
if (*pMask)
{
if ( ((struct radix_node *)pRoute)->rn_mask != pNetmask)
continue; /* Mask values do not match. */
}
else if ( ( (struct sockaddr_in *)pDest)->sin_addr.s_addr)
{
/* Searching for a host-specific route (no netmask entry). */
if ( ((struct radix_node *)pRoute)->rn_mask != 0)
continue; /* Entry is not a host route. */
}
}
/*
* Candidate passed any mask requirements. Search for entries
* which match the specified route source.
*/
#ifdef DEBUG
logMsg ("routeLookup: Current mask is OK.\n", 0, 0, 0, 0, 0, 0);
#endif
if (protoId)
{
/* Check source of route against specified value. */
#ifdef DEBUG
logMsg ("routeLookup: testing protocol ID.\n",
0, 0, 0, 0, 0, 0);
#endif
for (pMatch = (ROUTE_ENTRY *)pRoute; pMatch != NULL;
pMatch = pMatch->diffNode.pFrwd)
{
if (RT_PROTO_GET(ROUTE_ENTRY_KEY(pMatch)) == protoId)
break;
}
if (pMatch == NULL) /* Route protocol values do not match. */
continue;
#ifdef DEBUG
logMsg ("routeLookup: Current protocol ID is OK.\n",
0, 0, 0, 0, 0, 0);
#endif
}
else
{
/*
* No route source is specified. Accept the entry
* which met any mask criteria.
*/
pMatch = (ROUTE_ENTRY *)pRoute;
}
/* The candidate route entry met all criteria. Stop the search. */
result = OK;
break;
}
if (result == OK)
{
/* Increase the reference count before returning the matching entry. */
pMatch->rtEntry.rt_refcnt++;
}
else
pMatch = NULL;
splx (s);
return (pMatch);
}
/*!
* Writes an logfile message from type WARNING
*/
void TTMessageLogger::warningMsg(QString caller, QString msgString)
{
logMsg(WARNING, caller, msgString);
}
bool StyleContext::parseStyleResult(StyleParamKey _key, StyleParam::Value& _val) const {
_val = none_type{};
if (duk_is_string(m_ctx, -1)) {
std::string value(duk_get_string(m_ctx, -1));
_val = StyleParam::parseString(_key, value);
} else if (duk_is_boolean(m_ctx, -1)) {
bool value = duk_get_boolean(m_ctx, -1);
switch (_key) {
case StyleParamKey::visible:
_val = value;
break;
case StyleParamKey::extrude:
_val = value ? glm::vec2(NAN, NAN) : glm::vec2(0.0f, 0.0f);
break;
default:
break;
}
} else if (duk_is_array(m_ctx, -1)) {
duk_get_prop_string(m_ctx, -1, "length");
int len = duk_get_int(m_ctx, -1);
duk_pop(m_ctx);
switch (_key) {
case StyleParamKey::extrude: {
if (len != 2) {
logMsg("Warning: Wrong array size for extrusion: '%d'.\n", len);
break;
}
duk_get_prop_index(m_ctx, -1, 0);
double v1 = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 1);
double v2 = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
_val = glm::vec2(v1, v2);
break;
}
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::font_fill:
case StyleParamKey::font_stroke:
case StyleParamKey::font_stroke_color: {
if (len < 3 || len > 4) {
logMsg("Warning: Wrong array size for color: '%d'.\n", len);
break;
}
duk_get_prop_index(m_ctx, -1, 0);
double r = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 1);
double g = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 2);
double b = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
double a = 1.0;
if (len == 4) {
duk_get_prop_index(m_ctx, -1, 3);
a = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
}
_val = (((uint32_t)(255.0 * a) & 0xff) << 24) |
(((uint32_t)(255.0 * r) & 0xff)<< 16) |
(((uint32_t)(255.0 * g) & 0xff)<< 8) |
(((uint32_t)(255.0 * b) & 0xff));
break;
}
default:
break;
}
} else if (duk_is_number(m_ctx, -1)) {
switch (_key) {
case StyleParamKey::width:
case StyleParamKey::outline_width:
case StyleParamKey::font_stroke_width: {
double v = duk_get_number(m_ctx, -1);
_val = static_cast<float>(v);
break;
}
case StyleParamKey::order:
case StyleParamKey::priority:
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::font_fill:
case StyleParamKey::font_stroke:
case StyleParamKey::font_stroke_color: {
_val = static_cast<uint32_t>(duk_get_uint(m_ctx, -1));
break;
}
default:
break;
}
} else {
logMsg("Warning: Unhandled return type from Javascript function.\n");
}
duk_pop(m_ctx);
DUMP("parseStyleResult\n");
return !_val.is<none_type>();
}
/*!
* Writes an logfile messages from type ERROR
*/
void TTMessageLogger::errorMsg(QString caller, QString msgString)
{
logMsg(ERROR, caller, msgString);
}
/**warning logs a message at WARNING level.
* The message is appended to the log file if the current level is in the range SEVERE to WARNING
*
*@param toLog the message text to log
*/
void Logger::warning(string toLog) {
if (levelSet < WARNING) return;
logMsg(WARNING, toLog);
}
/*!
* Writes an logfile messages from type DEBUG
*/
void TTMessageLogger::debugMsg(QString caller, QString msgString)
{
logMsg(DEBUG, caller, msgString);
}
/**config logs the message at CONFIG level.
* The message is appended to the log file if the current level is in the range SEVERE to CONFIG
*
*@param toLog the message text to log
*/
void Logger::config(string toLog) {
if (levelSet < CONFIG) return;
logMsg(CONFIG, toLog);
}
// Responsible to read the tileData from the service
// takes a vector of tileCoordinates to be read from the service.
bool MapzenVectorTileJson::LoadTile(std::vector<glm::ivec3> _tileCoords) {
std::vector<std::unique_ptr<std::string>> urls;
if(_tileCoords.size() == 0) {
logMsg("No tiles to fetch.");
}
//construct tileID and url for every tileCoord
for(auto& tileCoord : _tileCoords) {
urls.push_back(constructURL(tileCoord));
}
CURLM *multiHandle;
CURLMsg *handleMsg;
// file descriptors to be used with curl_multi_fdset and select()
fd_set fdRead;
fd_set fdWrite;
fd_set fdExcep;
int fdMax;
struct timeval timeout;
int rc; //return value for select() call
CURLMcode cres;
int queuedHandles, numHandles = urls.size();
int prevHandle;
int fetchTry = 0; //Counter to check for curl/select timeOuts.. maxed by static count MAX_FETCH_TRY
int fdsetTimeoutCount = 0;
// out will store the stringStream contents from libCurl
std::stringstream *out[urls.size()];
curl_global_init(CURL_GLOBAL_DEFAULT);
multiHandle = curl_multi_init();
int count = 0;
// initialize curl simple interface for every url
for(auto& url : urls) {
out[count] = new std::stringstream;
curlInit(multiHandle, *url.get(), out[count]);
count++;
}
//do curl stuff
if(multiHandle) {
//start fetching
cres = curl_multi_perform(multiHandle, &numHandles);
if(cres != CURLM_OK) {
logMsg("curl_multi_perform failed %d\n", cres);
for(auto i = 0; i < urls.size(); i++) {
delete out[i];
}
urls.clear();
return false;
}
//if numHandles is 0, then multi_perform has no easy handles to perform fetching
if(!numHandles) {
logMsg("Number of easy handles returned by curl_multi_perform is 0, should not be.");
for(auto i = 0; i < urls.size(); i++) {
delete out[i];
}
urls.clear();
return true;
}
//Start fetching info until no easy handle left to fetch data
do {
//set all file descriptors to 0
FD_ZERO(&fdRead);
FD_ZERO(&fdWrite);
FD_ZERO(&fdExcep);
//timeout specification for select() call
//select() will unblock either when a fd is ready or tileout is reached
timeout.tv_sec = 1; //enough time for fd to be ready reading data... could be optimized.
timeout.tv_usec = 0;
//get file descriptors from the transfer
cres = curl_multi_fdset(multiHandle, &fdRead, &fdWrite, &fdExcep, &fdMax);
if(cres != CURLM_OK) {
logMsg("curl_multi_fdset failed: %d\n", cres);
for(auto i = 0; i < urls.size(); i++) {
delete out[i];
}
urls.clear();
return false;
}
//wait and repeat until curl has something to report to the kernel wrt file descriptors
// TODO: if no internet, then this gets stuck... put a timeout here.
while(fdMax < 0 && fdsetTimeoutCount < 20) {
//TODO: Get a better heuristic on the sleep milliseconds
//sleeps for 100 msec and calls perform and fdset to see if multi perform has started its job
std::this_thread::sleep_for(std::chrono::milliseconds(100));
cres = curl_multi_perform(multiHandle, &numHandles);
prevHandle = numHandles;
curl_multi_fdset(multiHandle, &fdRead, &fdWrite, &fdExcep, &fdMax);
std::cout<<"Here\n"; //TODO: Remove this. Its here to test how many times this loop runs till
//multi_perform starts doing stuff
fdsetTimeoutCount++;
}
if(fdMax < 0) {
logMsg("fdMax set timeout: fdmax still not set by curl_multi_fdset. Internet connection??");
for(auto i = 0; i < urls.size(); i++) {
delete out[i];
}
urls.clear();
return false;
}
//select blocks the thread until the fd set by curl is ready with data.
rc = select(fdMax+1, &fdRead, &fdWrite, &fdExcep, &timeout);
// helper variables to convert extracted data to Json on the spot instead of waiting for all urls to be
// fetched and then converting the extracted data to json
char *url;
char *tmpOutData; //to read the CURLINFO_PRIVATE data which is type casted to char* from stringstream*
std::string tmpJsonData;
int length;
std::shared_ptr<Json::Value> jsonVal(new Json::Value);
Json::Reader jsonReader;
// see what select returned
switch(rc) {
case -1:
//select call ERRORed
break;
case 0:
std::cout<<"Here timeout\n"; //TODO: Remove this. Its here to test how many times select times out.
// So far never with 1 sec of timeout.
//select call Timed out. No fd ready to read anything.
fetchTry++;
if(fetchTry == MAX_FETCH_TRY) {
curl_multi_cleanup(multiHandle);
curl_global_cleanup();
for(auto i = 0; i < urls.size(); i++) {
delete out[i];
}
urls.clear();
return false;
}
break;
default:
// sleep for 5 msec to give enough time for curl to read data for any of the file descriptors.
std::this_thread::sleep_for(std::chrono::milliseconds(5));
std::cout<<"Possible Change\n"; //TODO: Remove this. Its here to test how many times fd is ready and
// will result in a complete data read
//Perform again to see what happened with individual easy handles
curl_multi_perform(multiHandle,&numHandles);
// if easy handle status changed some urls are done.
if(prevHandle != numHandles) {
std::cout<<"Change happened\n";//TODO: Remove this. Only here for testing
prevHandle = numHandles;
handleMsg = curl_multi_info_read(multiHandle, &queuedHandles);
// for every url done fill the jsonValue
for(auto qHandItr = 0; qHandItr <= queuedHandles; qHandItr++) {
if(handleMsg->msg == CURLMSG_DONE) {
//get the url from the easyHandle
curl_easy_getinfo(handleMsg->easy_handle, CURLINFO_EFFECTIVE_URL , &url);
//get the tmpOutData which is holding the extracted info from the url
curl_easy_getinfo(handleMsg->easy_handle, CURLINFO_PRIVATE , &tmpOutData);
// typecast back from char* to std::stringstream
tmpJsonData = ((std::stringstream *)tmpOutData)->str();
length = tmpJsonData.size();
jsonReader.parse(tmpJsonData.c_str(), tmpJsonData.c_str() + length, *(jsonVal.get()));
// no way to get what ID this url was for so have to extract ID from url
m_JsonRoots[extractIDFromUrl(std::string(url))] = jsonVal;
logMsg("R: %d - %s <%s>\n", handleMsg->data.result, curl_easy_strerror(handleMsg->data.result), url);
curl_multi_remove_handle(multiHandle, handleMsg->easy_handle);
curl_easy_cleanup(handleMsg->easy_handle);
}
}
}
break;
}
}while(numHandles);
curl_multi_cleanup(multiHandle);
curl_global_cleanup();
}
for(auto i = 0; i < urls.size(); i++) {
delete out[i];
}
urls.clear();
return true;
}
/**finest log the message at FINEST level.
* The message is appended to the log file if the current level is in the range SEVERE to FINEST
*
*@param toLog the message text to log
*/
void Logger::finest(string toLog) {
if (levelSet < FINEST) return;
logMsg(FINEST, toLog);
}
int main(int argc, char **argv)
{
char *szTpmPasswd = NULL;
int pswd_len;
TSS_HTPM hTpm;
TSS_HPOLICY hTpmPolicy;
int iRc = -1;
struct option opts[] = {
{"force", no_argument, NULL, 'f'},
{"well-known", no_argument, NULL, 'z'},
};
BYTE well_known[] = TSS_WELL_KNOWN_SECRET;
initIntlSys();
if (genericOptHandler
(argc, argv, "fz", opts, sizeof(opts) / sizeof(struct option),
parse, help) != 0)
goto out;
if (contextCreate(&hContext) != TSS_SUCCESS)
goto out;
if (contextConnect(hContext) != TSS_SUCCESS)
goto out_close;
if (contextGetTpm(hContext, &hTpm) != TSS_SUCCESS)
goto out_close;
if (!bValue) {
if (isWellKnown){
szTpmPasswd = (char *)well_known;
pswd_len = sizeof(well_known);
}else{
szTpmPasswd = GETPASSWD(_("Enter owner password: "******"Failed to get password\n"));
goto out_close;
}
}
if (policyGet(hTpm, &hTpmPolicy) != TSS_SUCCESS)
goto out_close;
if (policySetSecret(hTpmPolicy, pswd_len,
(BYTE *)szTpmPasswd) != TSS_SUCCESS)
goto out_close;
}
//Setup complete attempt command
if (tpmClearOwner(hTpm, bValue) != TSS_SUCCESS)
goto out_close;
//Command successful
iRc = 0;
logSuccess(argv[0]);
logMsg( _("TPM Successfuly Cleared. You need to reboot to complete this operation. After reboot the TPM will be in the default state: unowned, disabled and inactive.\n") );
//Cleanup
out_close:
if (szTpmPasswd && !isWellKnown)
shredPasswd(szTpmPasswd);
contextClose(hContext);
out:
return iRc;
}
void
fssrGainScan(int id, char *filename, \
int beg_chip, int end_chip, \
int beg_chan, int end_chan,
int start_thr, int chan_mult)
{
FILE *fd;
char fname[256], reg27[20];
int thr, ichip, ich;
int i, j;
int zero_count, amp, min_hits;
int base_thr = start_thr;
int temp_start_thr, zero_status, a;
uint32_t pulser_rate = vscmGetPulserRate(id);
uint32_t scaler[128];
/* Pulser Settings */
const int start_amp = 75;
const int end_amp = 125;
const int step_amp = 25;
int steps = ((end_amp - start_amp) / step_amp) + 1;
/* Get current time for file saving */
time_t now;
time(&now);
threshold_scan *data;
#ifdef VXWORKS
int ticks = 1;
#else
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 16666667; /* ~16.6 ms (similar to 1 tick on VxWorks) */
#endif
if (vscmIsNotInit(&id, __func__))
return;
/*
if ((end_chip - beg_chip) > 3) {
logMsg("ERROR: %s: Chip range must be 4 chips or less\n", __func__);
logMsg("ERROR: %s: Output files will be overwritten if >4\n", __func__);
return;
}
*/
if ((chan_mult < 1) || ((chan_mult & (chan_mult - 1)) != 0)) {
logMsg("ERROR: %s: Channel multiplier (%d) ", __func__, chan_mult);
logMsg("must be a power of 2\n");
return;
}
data = malloc(steps * chan_mult * sizeof(threshold_scan));
/* Temporarily disable both pulser outputs */
vscmPulser(id, 0, 0, 1);
#ifdef VXWORKS
min_hits = (int)(pulser_rate * (ticks / (float)sysClkRateGet()) * 0.99);
#else
min_hits = (int)(pulser_rate * (float)(ts.tv_nsec * 1.0e-9) * 0.99);
#endif
logMsg("INFO: %s: Min Hits = %d\n", __func__, min_hits);
for (ichip = beg_chip; ichip <= end_chip; ichip++) {
#ifdef DEBUG
fssrStatus(id, ichip);
#endif
if(filename)
{
logMsg("%s\n", filename);
logMsg("cd %d\n", chdir(filename));
logMsg("%s\n", getcwd());
char datetime[] = "YYYYMMDD_HHMM";
strftime(datetime, sizeof(datetime), "%Y%m%d_%H%M", localtime(&now));
struct stat sb;
if (stat(datetime, &sb) != 0)
mkdir(datetime, S_IRWXU | S_IRWXG | S_IROTH);
char host[255];
gethostname(host, 255);
sprintf(fname,"%s/%s_s%02d_c%1d_u%1d", datetime, host, id, ((ichip > 3) ? 2 : 1), ((ichip % 4) + 1));
if( (fd = fopen(fname, "w")) <= NULL )
{
logMsg("ERROR: %s: Opening file: %s\n", __func__, fname);
free(data);
return;
}
else
{
logMsg("INFO: %s: Output file: %s\n", __func__, fname);
}
}
else
{
logMsg("Chip %d\n", ichip);
}
fssrParseControl(id, ichip, reg27);
if (filename) {
fprintf(fd, "%s\n", reg27);
}
else
printf("%s\n", reg27);
/* Set all discriminators - start of loop*/
for (i = 0; i < 8; i++) {
fssrSetThreshold(id, ichip, i, base_thr + (i * 30));
}
for (i = 0; i < (128 / chan_mult); i++)
{
start_thr = base_thr;
thr = start_thr;
temp_start_thr = 1;
fssrKillMaskDisableAll(id, ichip);
fssrInjectMaskDisableAll(id, ichip);
/* printf("[%d] Chan: ",id);*/
for (j = 0; j < chan_mult; j++)
{
ich = i + (j * (128 / chan_mult));
/* printf("%d ", ich);*/
fssrKillMaskEnableSingle(id, ichip, ich);
fssrInjectMaskEnableSingle(id, ichip, ich);
}
/* printf("\n"); fflush(stdout);*/
for (a = 0; a < steps; a++)
{
amp = start_amp + (a * step_amp);
thr = start_thr;
zero_count = 0;
/* printf("[%d] Amp: %d Start: %d\n",id, amp, thr); fflush(stdout);*/
vscmPulser(id, ((ichip > 3) ? 2 : 1), amp, (int)(min_hits / 0.99));
while(thr < 256 && zero_count < 2)
{
zero_status = 0;
temp_start_thr = 0;
fssrSetThreshold(id, ichip, 0, thr);
vscmDisableChipScaler(id, ichip);
vscmClearStripScalers(id, ichip);
vscmEnableChipScaler(id, ichip);
vscmDisableChipScaler(id, ichip);
vscmEnableChipScaler(id, ichip);
vscmPulserStart(id);
/* Gather data by sleeping */
#ifdef VXWORKS
taskDelay(ticks);
#else
nanosleep(&ts, NULL);
#endif
vscmDisableChipScaler(id, ichip);
vscmReadStripScalers(id, ichip, scaler);
for (j = 0; j < chan_mult; j++)
{
ich = i + (j * (128 / chan_mult));
if (thr == start_thr)
{
data[(a * chan_mult) + j].amp = amp;
data[(a * chan_mult) + j].start = start_thr;
}
data[(a * chan_mult) + j].hits[thr] = scaler[ich];
if (scaler[ich] > min_hits)
temp_start_thr++;
if (scaler[ich] == 0)
zero_status++;
}
if (zero_status == chan_mult)
zero_count++;
else
zero_count = 0;
if (temp_start_thr == chan_mult)
start_thr = thr;
thr++;
}
}
/* Save the data struct to file */
if (filename)
{
for (j = 0; j < chan_mult; j++)
{
ich = i + (j * (128 / chan_mult));
fprintf(fd, "%d\n", ich);
for (a = 0; a < steps; a++)
{
fprintf(fd, "%d, ", data[(a * chan_mult) + j].amp);
fprintf(fd, "%d ", data[(a * chan_mult) + j].start);
zero_count = 0;
thr = data[(a *chan_mult) + j].start;
while(thr < 256 && zero_count < 2)
{
fprintf(fd, ",%d ", data[(a * chan_mult) + j].hits[thr]);
if (data[(a * chan_mult) + j].hits[thr] == 0)
zero_count++;
else
zero_count = 0;
thr++;
}
fprintf(fd, "\n");
}
fprintf(fd, "\n");
}
fflush(fd);
}
} /* End of Channel loop */
if (filename)
fclose(fd);
else
printf("\n");
/* Set all discriminators - end of loop*/
for (i = 0; i < 8; i++) {
fssrSetThreshold(id, ichip, i, base_thr + (i * 30));
}
} /* End of Chip loop */
free(data);
}
static retCode debugOption(char *option, logical enable, void *cl) {
char *c = option;
while (*c) {
switch (*c++) {
case 'd': /* single step instruction tracing */
#ifdef TRACEEXEC
insDebugging = True;
tracing = True;
interactive = True;
continue;
#else
logMsg(logFile, "Instruction-level debugging not enabled\n");
return Error;
#endif
case 'D': /* instruction tracing */
#ifdef TRACEEXEC
insDebugging = True;
tracing = True;
interactive = False;
continue;
#else
logMsg(logFile, "Instruction-level tracing not enabled\n");
return Error;
#endif
case 'u': /* debug the debugger */
#ifdef TRACE_DBG
debugDebugging = True;
continue;
#else
logMsg(logFile, "Debugging tracing not enabled\n");
return Error;
#endif
case 'v': /* turn on verify tracing */
#ifdef TRACEVERIFY
traceVerify = True;
continue;
#else
logMsg(logFile, "code verification not enabled\n");
return Error;
#endif
case 'm': /* trace memory allocations */
#ifdef TRACEMEM
traceMemory = True;
atexit(dumpGcStats);
continue;
#else
logMsg(logFile,"memory tracing not enabled");
return -1;
#endif
case 'H': /* validate heap after allocations */
#ifdef TRACEMEM
validateMemory = True;
continue;
#else
logMsg(logFile,"memory validation not enabled");
return -1;
#endif
case 'l': /* trace synch locks */
#ifdef LOCKTRACE
traceLock = True;
continue;
#else
logMsg(logFile, "sync tracing not enabled");
return Error;
#endif
case 'G': /* Internal symbolic tracing */
#ifdef TRACEEXEC
lineDebugging = True;
interactive = False;
tracing = True;
continue;
#else
logMsg(logFile, "tracing not enabled");
return Error;
#endif
case 'g': /* Internal symbolic debugging */
lineDebugging = True;
interactive = True;
tracing = True;
continue;
case 's':
#ifdef TRACESTATS
if (runStats) {
atexit(dumpInsStats);
} else {
atexit(dumpInsCount);
}
runStats = True;
break;
#else
logMsg(logFile, "instruction counting not enabled");
return Error;
#endif
case 'M': /* Trace manifest mgt */
#ifdef TRACEMANIFEST
traceManifest = True;
#else
logMsg(logFile, "Resource tracing not enabled\n");
return Error;
#endif
case 'P': /* trace package operations */
#ifdef TRACEPKG
tracePkg = True;
continue;
#else
logMsg(logFile,"package tracing not enabled");
return -1;
#endif
case 'F': // Show file name instead of package
showPkgFile = True;
continue;
case 'C': // Toggle showing colors
showColors = !showColors;
continue;
default:;
}
}
return Ok;
}
//+CAP_2353_001
///////////////////////////////////////
// Test_Write_Read_DDR
///////////////////////////////////////
t_uint32 Test_Write_Read_DDR()
{
t_uint32 address;
t_uint32 i;
t_uint32 data;
t_uint32 data_written[33];
t_uint8 byte1, byte2;
logMsg("LpDDR test...\r\n");
//write in RAM to test address wires [0:12] and data wires [0:27]
//adress (0x1) to (0x8000000) (=> some address wires will be tested twice, doesn't matter)
//data 0x1 to 0x8000000
address = 1;
data = 1;
for (i=0; i<2; i++ )
{
data_written[i] = data;
*((t_uint8*)(address)) = (t_uint8)(data);
address = 1<<(i+1);
data = data<<1;
}
/*write in RAM DDR 32bit data*/
/*adress 0x4 to 0x8000000*/
/*data 0x4 to 0x8000000*/
for (i=2; i<28; i++ )
{
data_written[i] = data;
*((t_uint32*)(address)) = (t_uint32)(data);
address = 1<<(i+1);
data = data<<1;
}
//write in RAM to test data wires [28:31]
//address 0x800 + 4*n*(1 word)
//data: 0x10000000 to 0x80000000 => all 32 data wires will be then tested!!!
address = 0x800;
for (i=1; i<=4; i++)
{
//write in address 0x804 data 0x10000000
//then write in address 0x808 data 0x20000000
//then write in address 0x80C data 0x40000000
//then write in address 0x810 data 0x80000000
data_written[i+27] = 1<<(i+27);
*((t_uint32*)(address+(4*i))) = 1<<(i+27);
}
/*write in RAM DDR - to check bit 0 and 1 of data bus*/
/*address 0x814*/
/*data 0x3*/
address = 0x814;
data = 0x3;
data_written[32] = data;
*((t_uint32*)(address)) = data;
//////////////////
//now check the written data by the way of a readback
//same loops as the both above...
/////////////////
/* test bit 0 and bit 1 of address bus */
address = 0;
byte1 = ((*(t_uint32*)(address)) & (0x00FF00)) >> 8;
if (byte1 != (t_uint8)(data_written[0]))
{
return BOOT_INTERNAL_ERROR;
}
byte2 = ((*(t_uint32*)(address)) & (0xFF0000)) >> 16;
if (byte2 != (t_uint8)(data_written[1]))
{
return BOOT_INTERNAL_ERROR;
}
/*set address for next reading back*/
address = 0x4;
for (i=2; i<28; i++ )
{
if (*((t_uint32*)(address)) != (t_uint32)(data_written[i]))
{
return BOOT_INTERNAL_ERROR;
}
address = 1<<(i+1);
}
address = 0x800;
for (i=1; i<=4; i++)
{
if (*((t_uint32*)(address+(4*i))) != data_written[i+27])
{
return BOOT_INTERNAL_ERROR;
}
}
/* test bit 0 and bit 1 of data bus */
address = 0x814;
if (*((t_uint32*)address) != data_written[32])
{
return BOOT_INTERNAL_ERROR;
}
logMsg("OK\r\n");
return BOOT_OK;
}
ROUTE_ENTRY * routeEntryFind
(
ROUTE_ENTRY * pRoute, /* primary route for destination/netmask */
short protoId, /* protocol identifer for route */
struct sockaddr * pGateway, /* next hop gateway for route */
ROUTE_ENTRY ** ppGroup, /* initial entry (head) of existing group */
ROUTE_ENTRY ** ppLastGroup, /* predecessor if head of group changes */
ROUTE_ENTRY ** ppNextGroup, /* successor if head of group changes */
ROUTE_ENTRY ** ppLast, /* previous entry in matching group */
ROUTE_ENTRY ** ppNext, /* next entry in matching group */
UCHAR weight /* weight value for route, 0 for delete */
)
{
ROUTE_ENTRY * pGroup; /* initial route entry with matching protocol */
ROUTE_ENTRY * pMatch = NULL; /* duplicate route entry, if any. */
ROUTE_ENTRY * pNextGroup = NULL; /* Group with higher minimum weight. */
ROUTE_ENTRY * pLastGroup = NULL; /* Previous group entry in list. */
ROUTE_ENTRY * pBack = NULL; /* Preceding route entry in group. */
ROUTE_ENTRY * pNext = NULL; /* Next route entry in group. */
ROUTE_ENTRY * pTemp; /* Loop index. */
BOOL gatewayFlag; /* Gateway value specified? */
UCHAR nextWeight; /* Weight for initial group entry after increase. */
if (pGateway == NULL || SOCKADDR_IN (pGateway) == 0)
gatewayFlag = FALSE;
else
gatewayFlag = TRUE;
/*
* Find the group which matches the protocol for the targeted route,
* if any. Use the first group if no value is specified. This search
* also finds an adjacent group if no match occurs or if the protocol
* does not match the first group and the provided weight value is less
* than the initial entry in the matching group.
*/
for (pGroup = pRoute; pGroup != NULL; pGroup = pGroup->diffNode.pFrwd)
{
if (protoId == 0) /* No protocol specified - use initial group. */
break;
if (RT_PROTO_GET(ROUTE_ENTRY_KEY(pGroup)) == protoId)
break;
/*
* If the weight value for the targeted route is less than
* the current minimum in an earlier group (which therefore
* uses a lower weight than the matching group), save the
* new successor for the matching group. Ignore this test
* for the delete operation, which selects a new adjacent
* group separately, if needed.
*/
if (weight && pNextGroup == NULL &&
weight < pGroup->rtEntry.rt_rmx.weight)
{
pNextGroup = pGroup;
#ifdef DEBUG
logMsg ("routeEntryFind: inserting ahead of group at %x.\n",
pNextGroup, 0, 0, 0, 0, 0);
#endif
}
/*
* Save the current group entry, which will eventually equal the
* tail of the list if no matching group exists. That final entry
* is required when creating a new group with a larger minimum
* weight than all existing groups.
*/
pLastGroup = pGroup;
}
/*
* Assign the preceding group if the weight value inserts a new group
* into the list or promotes an existing group to an earlier position.
*/
if (pNextGroup)
{
pLastGroup = pNextGroup->diffNode.pBack;
}
/*
* Find the specific route entry which matches the supplied gateway
* address within the selected group. Use the initial entry if no
* value is specified. The delete and change operations require a
* match, but the add operation fails in that case.
*
* This search also finds the neighboring routes within the matching
* group based on any specified weight value.
*/
for (pTemp = pGroup; pTemp != NULL; pTemp = pTemp->sameNode.pFrwd)
{
/*
* Save the first entry which matches the specified gateway.
* The second condition is not strictly necessary, since each
* gateway value is unique, but bypasses needless tests once
* a match is found.
*/
if (gatewayFlag && pMatch == NULL)
{
if (ROUTE_ENTRY_GATEWAY (pTemp)->sa_family == AF_LINK)
{
/*
* The gateway field contains an ARP template. The entry
* only matches for a search using the interface's assigned
* IP address as the gateway.
*/
if (SOCKADDR_IN (pTemp->rtEntry.rt_ifa->ifa_addr)
== SOCKADDR_IN (pGateway))
{
/* Specified route entry exists - save the match. */
pMatch = pTemp;
}
}
else if (SOCKADDR_IN (ROUTE_ENTRY_GATEWAY (pTemp))
== SOCKADDR_IN (pGateway))
{
/* Specified route entry exists - save the match. */
pMatch = pTemp;
}
}
if (gatewayFlag == FALSE && pMatch == NULL)
{
/* Use the initial entry if no gateway is specified. */
pMatch = pGroup;
}
/*
* The delete operation does not provide a weight value. Save
* the neighboring route for the add and change operations.
*/
if (weight && pNext == NULL &&
weight < pTemp->rtEntry.rt_rmx.weight)
{
pNext = pTemp;
}
/* Halt the search after finding the matching entry and location. */
if (pMatch && pNext)
break;
/*
* Save the current route, which eventually stores the last
* entry in the list. That value is only needed if the weight
* is larger than all existing entries in the group.
*/
pBack = pTemp;
}
/*
* Save the correct predecessor if the weight does not place the
* corresponding route at the end of the list. That value will
* equal NULL if the new position is the head of the list.
*
* Otherwise, the preceding entry already equals the last item in the
* list (which occurs when appending a new route with the maximum weight
* to an existing group) or remains NULL (if the group does not exist).
* No correction is needed in either case.
*/
if (pNext)
{
pBack = pNext->sameNode.pBack;
}
/*
* Update the chosen adjacent group, if needed. The results of the
* previous search are only valid if the weight value corresponds
* to the initial entry in a group, the selected route is not part
* of the first group, and the weight is reduced enough to alter
* the relative position of the selected group.
*/
if (pNext == pGroup)
{
/*
* The specified weight corresponds to the initial entry in
* a group, so either the weight of the group is reduced or it
* corresponds to the first entry in a new group. Update the
* neighboring groups selected with the earlier search if needed.
*/
if (pGroup && pNextGroup == NULL)
{
/*
* The group exists and no successor is assigned, so the
* earlier search found a matching group before detecting
* a different group with a higher weight than the specified
* value. This condition indicates that the reduced weight does
* not change the relative location of the matching group.
*/
pNextGroup = pGroup->diffNode.pFrwd;
pLastGroup = pGroup->diffNode.pBack;
}
}
/*
* Finish assigning the adjacent group, if needed. The earlier search
* only selects an adjacent group when the specified weight value is
* less than the weight of the initial entry in the matching group or
* is the first entry in a new group.
*/
if (pNext != pGroup && weight)
{
/*
* Find the correct adjacent group for an unchanged weight or an
* increase in the weight value of an entry in an existing group.
*/
if (pMatch == NULL || pMatch != pGroup)
{
/*
* If the selected route is not the initial entry, it is
* not connected to any adjacent groups.
*/
pLastGroup = pNextGroup = NULL;
}
else if (weight == pMatch->rtEntry.rt_rmx.weight)
{
/*
* The earlier search only finds an adjacent group when the
* weight of the group is reduced. Set the correct adjacent
* groups since the location in the group list is unchanged.
*/
pNextGroup = pGroup->diffNode.pFrwd;
pLastGroup = pGroup->diffNode.pBack;
}
else
{
/*
* The initial entry in the group list uses an increased
* weight. Set the correct weight value and find the new
* adjacent group.
*/
pTemp = pMatch->sameNode.pFrwd;
nextWeight = weight;
/*
* Use the weight value of the next initial group entry if
* the new weight will change the location of the current
* initial entry in the group.
*/
if (pTemp && weight > pTemp->rtEntry.rt_rmx.weight)
nextWeight = pTemp->rtEntry.rt_rmx.weight;
if (pMatch->rtEntry.rt_rmx.weight == nextWeight)
{
/*
* The next entry in the list used the same weight
* as the initial entry, so the position is unchanged.
*/
pNextGroup = pGroup->diffNode.pFrwd;
pLastGroup = pGroup->diffNode.pBack;
}
else
{
/*
* The minimum weight of the group increased. Find the
* new location.
*/
for (pTemp = pGroup; pTemp != NULL;
pTemp = pTemp->diffNode.pFrwd)
{
if (nextWeight < pTemp->rtEntry.rt_rmx.weight)
{
pNextGroup = pTemp;
break;
}
/*
* Save the current entry in case the next entry
* is the correct successor.
*/
pLastGroup = pTemp;
}
/*
* Set the preceding group to the correct value if the
* increased weight does not change the relative location
* of the group.
*/
if (pLastGroup == pGroup)
pLastGroup = pGroup->diffNode.pBack;
}
}
}
/*
* Correct the adjacent route within the matching group, if needed.
* That search places a route after any other entries with the same
* weight. This behavior is not correct when the weight of an existing
* entry does not change.
*/
if (pMatch && weight == pMatch->rtEntry.rt_rmx.weight)
{
pNext = pMatch->sameNode.pFrwd;
pBack = pMatch->sameNode.pBack;
}
/*
* Save the initial entry in the group and any adjacent entries in
* the supplied parameters. The delete operation does not retrieve
* any neighboring routes or specify the weight needed to assign
* those values.
*/
if (ppGroup)
*ppGroup = pGroup;
if (ppLastGroup)
*ppLastGroup = pLastGroup;
if (ppNextGroup)
*ppNextGroup = pNextGroup;
if (ppLast)
*ppLast = pBack;
if (ppNext)
*ppNext = pNext;
return (pMatch);
}
UnbufferedRsStmtTest::UnbufferedRsStmtTest( const String & name ) : StatementTest( name )
{
logMsg( "UnbufferedRsStmtTest ctor called" );
}
bool Contest::initTimers() {
int arg = ID_SOC;
SOC = TimeStamp(2003, 7, 1);
ACE_Reactor::instance()->schedule_timer(this,
(const void *) arg,
SOC.getTimeStamp() - time(0));
arg = ID_EOC;
EOC = TimeStamp(2004, 1, 1, 1);
ACE_Reactor::instance()->schedule_timer(this,
(const void *) arg,
EOC.getTimeStamp() - time(0));
TimeStamp start(SOC), end(EOC), current(start);
arg = ID_EOW;
EOW.push_back(current);
current.setTimeStamp(current.nextWeek());
while (current < end) {
EOW.push_back(current);
ACE_Reactor::instance()->schedule_timer(this,
(const void *) arg,
current.getTimeStamp() - time(0));
current.setTimeStamp(current.nextWeek());
}
vector<TimeStamp>::iterator i;
i = EOW.begin();
stringstream debug;
debug << "Weekly timers: (arg = " << arg << ")" << endl;
logMsg(debug.str());
while (i != EOW.end()) {
logMsg(i->toString());
i++;
}
arg = ID_EOM;
debug.str("");
debug << "Monthly timers: (arg = " << arg << ")" << endl;
logMsg(debug.str());
EOM.push_back(TimeStamp(2003, 7, 1));
EOM.push_back(TimeStamp(2003, 8, 1));
EOM.push_back(TimeStamp(2003, 9, 1));
EOM.push_back(TimeStamp(2003, 10, 1));
EOM.push_back(TimeStamp(2003, 11, 1));
EOM.push_back(TimeStamp(2003, 12, 1));
EOM.push_back(TimeStamp(2004, 1, 1));
i = EOM.begin();
i++;
while (i != EOM.end()) {
ACE_Reactor::instance()->schedule_timer(this,
(const void *) arg,
i->getTimeStamp() - time(0));
logMsg(i->toString());
i++;
}
arg = ID_EOD;
end = EOC;
current = SOC;
EOD.push_back(current);
current++;
while (current < end) {
EOD.push_back(current);
if ((find(EOW.begin(), EOW.end(), current) == EOW.end()) &&
find(EOM.begin(), EOM.end(), current) == EOM.end()) {
ACE_Reactor::instance()->schedule_timer(this,
(const void *) arg,
current.getTimeStamp() - time(0));
}
current++;
}
i = EOD.begin();
debug.str("");
debug << "Daily timers: (arg = " << arg << ")" << endl;
logMsg(debug.str());
while (i != EOD.end()) {
logMsg(i->toString());
i++;
}
logMsg("Start of Contest timer: ");
logMsg(SOC.toString());
logMsg("End of Contest timer: ");
logMsg(EOC.toString());
return true;
}
