/* IBM_PROLOG_BEGIN_TAG */ /* This is an automatically generated prolog. */ /* */ /* $Source: src/usr/diag/prdf/framework/rule/prdfRuleChip.C $ */ /* */ /* IBM CONFIDENTIAL */ /* */ /* COPYRIGHT International Business Machines Corp. 2004,2012 */ /* */ /* p1 */ /* */ /* Object Code Only (OCO) source materials */ /* Licensed Internal Code Source Materials */ /* IBM HostBoot Licensed Internal Code */ /* */ /* The source code for this program is not published or otherwise */ /* divested of its trade secrets, irrespective of what has been */ /* deposited with the U.S. Copyright Office. */ /* */ /* Origin: 30 */ /* */ /* IBM_PROLOG_END_TAG */ #ifndef __HOSTBOOT_MODULE #include // for UtilReg #include #include //for SyncAnalysis #endif #include // for SystemPtr. #include #include #include #include #include #include #include // for enums. #include // for ScanFacility #include // for ResolutionFactory #include // for CaptureData #include // for ServiceDataCollector #include // for ErrorSignature #include // for Resolutions #include // for EregResolution #include // for DumpResolution #include // for TryResolution #include // for PrdfPluginCallResolution #include // for prdfAnalyzeConnected #include // for System #include #include // for errl user data flags. #include // for getConnected #include // for errl. #include // for UtilFile #include // for Util::hashString #include #include template struct ResetAndMaskTransformer : public std::unary_function { ResetAndMaskTransformer(ScanFacility & i_scanFactory, TARGETING::TargetHandle_t i_pchipHandle , size_t i_scomlen) : cv_scanFactory(i_scanFactory), cv_pchipHandle (i_pchipHandle ), cv_scomlen(i_scomlen) {}; virtual ~ResetAndMaskTransformer() {}; // zs01 virtual ResetAndMaskErrorRegister::ResetRegisterStruct operator()(const Prdr::PrdrRegister::ResetOrMaskStruct & i) { ResetAndMaskErrorRegister::ResetRegisterStruct o; o.read = &cv_scanFactory.GetScanCommRegister(cv_pchipHandle , i.addr_r, cv_scomlen); o.write = &cv_scanFactory.GetScanCommRegister(cv_pchipHandle , i.addr_w, cv_scomlen); switch (i.op) { case Prdr::OR: o.op = getStaticResetOperator >(); break; case Prdr::AND: o.op = getStaticResetOperator >(); break; case Prdr::XOR: o.op = getStaticResetOperator >(); break; case Prdr::NOT: o.op = getStaticResetOperator >(); break; default: o.op = NULL; // TODO: ERROR! Assert... break; } return o; }; private: ScanFacility & cv_scanFactory; TARGETING::TargetHandle_t cv_pchipHandle ; size_t cv_scomlen; }; void PrdfRuleChip::loadRuleFile(ScanFacility & i_scanFactory, ResolutionFactory & i_reslFactory) { using namespace PRDF; RegMap_t l_regMap; Reset_t l_resetMap; PrdfResetAndMaskPair l_currentResets; uint32_t l_regMax = 0; uint32_t l_vregMax = 0; GroupMap_t l_groupMap; uint32_t l_groupMax = 0; ActionMap_t l_actionMap; uint32_t l_actionMax = 0; uint32_t l_id = 1; SharedThreshold_t l_sharedThresholds; Prdr::PrdrChip * l_chip; /* Initialize local data struct to pass to sub-functions */ RuleFileData l_localData = { l_regMap, l_groupMap, l_actionMap, i_scanFactory, i_reslFactory, this->GetChipHandle(), l_chip, l_resetMap, l_currentResets, l_sharedThresholds }; // Parse chip file. cv_errl = Prdr::LoadChipCache::loadChip(cv_fileName, &l_chip); if (NULL == l_chip) { // TODO: Do we need to percAbend? We were unable to succesfully // load our chip objects. return; } // Get default dump type. cv_dumpType = l_chip->cv_dumpType; // Set signature offset for capture data output. iv_sigOff = l_chip->cv_signatureOffset; // create hardware regs. for (int i = 0; i < l_chip->cv_regCount; i++) { uint16_t hashId = l_chip->cv_registers[i].cv_name; l_regMap[l_id] = cv_hwRegs[hashId] = &i_scanFactory.GetScanCommRegister( this->GetChipHandle(), l_chip->cv_registers[i].cv_scomAddr, l_chip->cv_registers[i].cv_scomLen ); l_regMap[l_id]->SetId(hashId); // Copy reset registers. std::transform (l_chip->cv_registers[i].cv_resets.begin(), l_chip->cv_registers[i].cv_resets.end(), std::back_inserter(l_resetMap[l_id].first), ResetAndMaskTransformer( i_scanFactory, this->GetChipHandle(), l_chip->cv_registers[i].cv_scomLen) ); // Copy mask registers. std::transform (l_chip->cv_registers[i].cv_masks.begin(), l_chip->cv_registers[i].cv_masks.end(), std::back_inserter(l_resetMap[l_id].second), ResetAndMaskTransformer( i_scanFactory, this->GetChipHandle(), l_chip->cv_registers[i].cv_scomLen) ); //This flag signifies that a mapping IS or ISN'T created between a // uint32_t mapping and a vector of SCAN_COMM_REGISTER_CLASS pointers. //If there is no mapping outside of the for loop then it is because // there is a capture type or requirement without a group statement in the rule file. bool l_group_is_created = false; // Copy into capture groups. std::vector::const_iterator l_capturesEnd = l_chip->cv_registers[i].cv_captures.end(); //For each capture in this register save a Group Type or Requirement. for(std::vector::const_iterator j = l_chip->cv_registers[i].cv_captures.begin(); j != l_capturesEnd; ++j) { if ('G' == (*j).op) { cv_hwCaptureGroups[(*j).data[0]].push_back(l_regMap[l_id]); l_group_is_created = true; //@jl06 Added this to indicate group was created. } // @jl04 a Start. // This else if was added for a new capture "type" for registers primary/secondary. // Cannot put the "type" in with the G group otherwise it will show up as a // i_group of 2 which is not called. else if('T' == (*j).op) { //@jl06. d Deleted temporary declaration of PrdfCaptureType in // favor of an anonymous declaration. Calls ctor twice. cv_hwCaptureType[l_regMap[l_id]] = PrdfCaptureType((RegType)(*j).data[0]); //@jl06 c. } // @jl04 a Stop. else if ('f' == (*j).op) { PrdfCaptureRequirement req; req.cv_func = this->getExtensibleFunction(j->func); cv_hwCaptureReq[l_regMap[l_id]] = req; } else // 'C' { PrdfCaptureRequirement req; req.cv_TargetType = (*j).data[0]; req.cv_TargetIndex = (*j).data[1]; req.cv_func = NULL; cv_hwCaptureReq[l_regMap[l_id]] = req; } } if (!l_group_is_created) // @jl06 c Add to default group if none there. { // Add to default if no group specified. cv_hwCaptureGroups[1].push_back(l_regMap[l_id]); } l_regMax = l_id++; } for (int i = 0; i < l_chip->cv_ruleCount; i++) { if (l_regMap[l_id]) // check if it already exists. { l_vregMax = l_id++; continue; } l_currentResets = PrdfResetAndMaskPair(); SCAN_COMM_REGISTER_CLASS * l_tmp = this->createVirtualRegister(&l_chip->cv_rules[i], l_localData); l_regMap[l_id] = l_tmp; l_resetMap[l_id] = l_currentResets; l_vregMax = l_id++; }; // initialize all the pointers for the groups, but don't construct their // data yet. Resolution & l_defaultResolution = i_reslFactory.GetCalloutResolution( this->GetChipHandle(), MRU_MED ); for (int i = 0; i < l_chip->cv_groupCount; i++) { PrdfGroup * l_tmp = new PrdfGroup(l_defaultResolution); l_groupMap[l_id] = l_tmp; l_groupMax = l_id++; }; for (int i = 0; i < l_chip->cv_actionCount; i++) { if (l_actionMap[i]) { l_actionMax = l_id++; continue; } // createActionClass will add to the actionMap. this->createActionClass(i, l_localData); //l_actionMap[l_id] = l_tmp; l_actionMax = l_id++; } for (int i = 0; i < l_chip->cv_groupCount; i++) { this->createGroup((PrdfGroup *) l_groupMap[i+l_vregMax+1], i, l_localData); } for (int i = 0; i < NUM_GROUP_ATTN; i++) // @jl02 UNIT_CS Changes. JL cv_groupAttn[i] = l_groupMap[l_chip->cv_groupAttn[i]]; // Call initialize plugin. PrdfExtensibleChipFunction * l_init = getExtensibleFunction("Initialize", true); if (NULL != l_init) { (*l_init) (this, PrdfPluginDef::bindParm(NULL) ); } return; }; PrdfRuleChip::~PrdfRuleChip() { if (NULL != cv_dataBundle) { delete cv_dataBundle; } }; int32_t PrdfRuleChip::Analyze(STEP_CODE_DATA_STRUCT & i_serviceData, ATTENTION_TYPE i_attnType) { using namespace PRDF; ServiceDataCollector & i_sdc = *(i_serviceData.service_data); ErrorSignature & l_errSig = *(i_sdc.GetErrorSignature()); CaptureData & capture = i_serviceData.service_data->GetCaptureData(); // @jl04 a Add this for Drop call. // Set current ATTN type to input value. // If we don't do this, then the AttnRegisters don't work. i_sdc.SetCauseAttentionType(i_attnType); // @pw02 @pw04 int32_t l_rc = SUCCESS; // Set Signature Chip Id. l_errSig.setChipId( GetId() ); // Set default dump flags. //@ecdf //FIXME: take out hwTableContent for now for Hostboot #ifdef __HOSTBOOT_MODULE i_sdc.SetDump(/*(hwTableContent)cv_dumpType,*/ GetChipHandle()); #else i_sdc.SetDump((hwTableContent)cv_dumpType, GetChipHandle()); #endif // Get capture data for this chip. Allow override. PrdfExtensibleChipFunction * l_ignoreCapture = getExtensibleFunction("PreventDefaultCapture", true); bool l_shouldPreventDefaultCapture = false; (*l_ignoreCapture) (this, PrdfPluginDef::bindParm (i_serviceData, l_shouldPreventDefaultCapture)); if (!l_shouldPreventDefaultCapture) { // Drop secondary capture from earlier chips. capture.Drop(SECONDARY); // Read capture data. this->CaptureErrorData(i_sdc.GetCaptureData()); } // Analyze group. ErrorRegisterType * l_errReg = NULL; switch (i_attnType) { case CHECK_STOP: l_errReg = cv_groupAttn[0]; break; case RECOVERABLE: l_errReg = cv_groupAttn[1]; break; case SPECIAL: l_errReg = cv_groupAttn[2]; break; case UNIT_CS: // @jl02 JL Added this code to support the new Unit Check Stop. l_errReg = cv_groupAttn[3]; // @jl02 JL I don't know if this is the correct cv_groupAttn to add here or if it's needed. break; } if (NULL != l_errReg) { //mp02 a Start //Call any pre analysis functions PrdfExtensibleChipFunction * l_preAnalysis = getExtensibleFunction("PreAnalysis", true); bool analyzed = false; (*l_preAnalysis)(this, PrdfPluginDef::bindParm (i_serviceData,analyzed)); if ( !analyzed) l_rc = l_errReg->Analyze(i_serviceData); } //mp02 a Stop // mp02d l_rc = l_errReg->Analyze(i_serviceData); else //@jl07 l_rc = PRD_SCAN_COMM_REGISTER_ZERO; //@jl07 // Don't do reset or mask on CS. @pw03 if (CHECK_STOP != i_serviceData.service_data->GetAttentionType()) //@pw04 { #ifndef __HOSTBOOT_MODULE SyncAnalysis (i_sdc); //mp01 Add call to Sync SDC #endif // Call mask plugin. if (i_serviceData.service_data->IsAtThreshold()) { PrdfExtensibleChipFunction * l_mask = getExtensibleFunction("MaskError", true); (*l_mask)(this, PrdfPluginDef::bindParm(i_serviceData) ); //@pw01 } // Call reset plugin. PrdfExtensibleChipFunction * l_reset = getExtensibleFunction("ResetError", true); (*l_reset)(this, PrdfPluginDef::bindParm(i_serviceData) ); //@pw01 } // Call postanalysis plugin. // @jl02 JL Adding PostAnalysis plugin call. PrdfExtensibleChipFunction * l_postanalysis = getExtensibleFunction("PostAnalysis", true); // @jl02 the true above means that a plugin may not exist for this call. // @jl02 JL Adding call for post analysis. (*l_postanalysis)(this, PrdfPluginDef::bindParm(i_serviceData)); return l_rc; }; int32_t PrdfRuleChip::CaptureErrorData(CaptureData & i_cap, int i_group) { using namespace TARGETING; using namespace PRDF; std::vector::const_iterator l_hwCaptureEnd = cv_hwCaptureGroups[i_group].end(); for (std::vector::const_iterator i = cv_hwCaptureGroups[i_group].begin(); i != l_hwCaptureEnd; ++i) { // Check that requirements are satisfied. if (PrdfCaptureRequirement() != cv_hwCaptureReq[*i]) { PrdfCaptureRequirement req = cv_hwCaptureReq[*i]; if (NULL != req.cv_func) { bool l_cap = true; (*req.cv_func)(this, PrdfPluginDef::bindParm(l_cap)); if (!l_cap) continue; } else { bool l_indexValid =false; TargetHandleList l_ptargetHandleList = PlatServices::getConnected(this->GetChipHandle(), (TARGETING::TYPE) req.cv_TargetType); TargetHandleList ::iterator itrTarget =l_ptargetHandleList.begin(); for( ; itrTarget != l_ptargetHandleList.end();itrTarget++ ) { if (req.cv_TargetIndex == PlatServices::getTargetPosition(*itrTarget)) { l_indexValid = true; break; } } if(false == l_indexValid) { continue; } } } i_cap.Add(this->GetChipHandle(), (*i)->GetId() ^ this->getSignatureOffset(), *(*i), CaptureData::BACK, //@jl04 c change this because of proto. cv_hwCaptureType[*i].cv_regType); //@jl04 c Changed this function call to add a param. } // Call "PostCapture" plugin PrdfExtensibleChipFunction * l_postCapture = getExtensibleFunction("PostCapture", true); (*l_postCapture) (this, PrdfPluginDef::bindParm(i_cap, i_group) ); return SUCCESS; } SCAN_COMM_REGISTER_CLASS * PrdfRuleChip::createVirtualRegister( Prdr::PrdrExpr * i_vReg, RuleFileData & i_data ) { SCAN_COMM_REGISTER_CLASS * l_arg[4] = { NULL }; uint32_t l_tmp32 = 0; SCAN_COMM_REGISTER_CLASS * l_rc = NULL; switch(i_vReg->cv_op) { case Prdr::NOT: l_arg[0] = createVirtualRegister(i_vReg->cv_value[0].p, i_data); l_rc = &i_data.cv_scanFactory.GetNotRegister(*l_arg[0]); break; case Prdr::LSHIFT: case Prdr::RSHIFT: l_arg[0] = createVirtualRegister(i_vReg->cv_value[0].p, i_data); l_tmp32 = i_vReg->cv_value[1].p->cv_value[0].i; l_rc = (Prdr::LSHIFT == i_vReg->cv_op ? &i_data.cv_scanFactory.GetLeftShiftRegister(*l_arg[0], l_tmp32) : &i_data.cv_scanFactory.GetRightShiftRegister(*l_arg[0], l_tmp32) ); break; case Prdr::OR: case Prdr::AND: l_arg[0] = createVirtualRegister(i_vReg->cv_value[0].p, i_data); l_arg[1] = createVirtualRegister(i_vReg->cv_value[1].p, i_data); l_rc = (Prdr::OR == i_vReg->cv_op ? &i_data.cv_scanFactory.GetOrRegister(*l_arg[0], *l_arg[1]) : &i_data.cv_scanFactory.GetAndRegister(*l_arg[0], *l_arg[1]) ); break; case Prdr::REF_REG: std::copy(i_data.cv_resets[i_vReg->cv_value[0].i].first.begin(), i_data.cv_resets[i_vReg->cv_value[0].i].first.end(), std::back_inserter(i_data.cv_currentResets.first)); std::copy(i_data.cv_resets[i_vReg->cv_value[0].i].second.begin(), i_data.cv_resets[i_vReg->cv_value[0].i].second.end(), std::back_inserter(i_data.cv_currentResets.second)); l_rc = i_data.cv_regMap[i_vReg->cv_value[0].i]; break; case Prdr::REF_RULE: if (NULL == i_data.cv_regMap[i_vReg->cv_value[0].i]) i_data.cv_regMap[i_vReg->cv_value[0].i] = createVirtualRegister( &i_data.cv_loadChip-> cv_rules[i_vReg->cv_value[0].i], i_data); l_rc = i_data.cv_regMap[i_vReg->cv_value[0].i]; break; case Prdr::ATTNLINK: if (NULL != i_vReg->cv_value[0].p) l_arg[0] = createVirtualRegister(i_vReg->cv_value[0].p, i_data); if (NULL != i_vReg->cv_value[1].p) l_arg[1] = createVirtualRegister(i_vReg->cv_value[1].p, i_data); if (NULL != i_vReg->cv_value[2].p) l_arg[2] = createVirtualRegister(i_vReg->cv_value[2].p, i_data); if (NULL != i_vReg->cv_value[3].p) l_arg[3] = createVirtualRegister(i_vReg->cv_value[3].p, i_data); l_rc = &i_data.cv_scanFactory.GetAttnTypeRegister(*l_arg[0], /*passing null object*/ *l_arg[1], /*passing null object*/ *l_arg[2], /*passing null object*/ *l_arg[3]); /*passing null object*/ break; case Prdr::BIT_STR: { uint32_t l_size = i_vReg->cv_bitStrVect.size(); BIT_STRING_BUFFER_CLASS l_bs(l_size * 64); for (uint32_t i = 0; i < l_size; i++) { l_bs.SetFieldJustify(32*(2*i) , 32, (i_vReg->cv_bitStrVect[i] >> 32) & 0xFFFFFFFF); l_bs.SetFieldJustify(32*((2*i)+1), 32, (i_vReg->cv_bitStrVect[i] & 0xFFFFFFFF)); } l_rc = &i_data.cv_scanFactory.GetConstantRegister(l_bs); } break; } return l_rc; }; Resolution * PrdfRuleChip::createActionClass(uint32_t i_action, PrdfRuleChip::RuleFileData & i_data) { if (NULL != i_data.cv_actionMap[i_action]) return i_data.cv_actionMap[i_action]; Resolution * l_tmpRes = NULL, * l_retRes = NULL; for (int i = 0; i < i_data.cv_loadChip->cv_actionSize[i_action]; i++) { l_tmpRes = this->createResolution( &(i_data.cv_loadChip->cv_actions[i_action][i]), i_data); if (0 == i) { l_retRes = l_tmpRes; } else { l_retRes = &i_data.cv_reslFactory. LinkResolutions(*l_retRes, *l_tmpRes); } } if (NULL == l_retRes) // @pw05 { class NullResolution : public Resolution { public: int32_t Resolve(STEP_CODE_DATA_STRUCT & data) { return SUCCESS; }; }; static NullResolution l_nullRes; l_retRes = &l_nullRes; } i_data.cv_actionMap[i_action] = l_retRes; return l_retRes; }; Resolution * PrdfRuleChip::createResolution(Prdr::PrdrExpr * i_action, PrdfRuleChip::RuleFileData & i_data) { using namespace PRDF; Resolution * l_rc = NULL; switch (i_action->cv_op) { case Prdr::REF_ACT: l_rc = this->createActionClass(i_action->cv_value[0].i - (i_data.cv_loadChip->cv_regCount + i_data.cv_loadChip->cv_ruleCount + i_data.cv_loadChip->cv_groupCount + 1), i_data); break; case Prdr::REF_GRP: l_rc = &i_data.cv_reslFactory.GetEregResolution( *i_data.cv_groupMap[i_action->cv_value[0].i]); break; case Prdr::ACT_TRY: // TRY l_rc = &i_data.cv_reslFactory.GetTryResolution( *(this->createResolution(i_action->cv_value[0].p, i_data)), *(this->createResolution(i_action->cv_value[1].p, i_data)) ); break; case Prdr::ACT_FUNC: // FUNCCALL l_rc = &i_data.cv_reslFactory.GetPluginCallResolution( this, this->getExtensibleFunction(i_action->cv_actFunc) ); break; case Prdr::ACT_FLAG: // FLAG l_rc = &i_data.cv_reslFactory.GetFlagResolution( (ServiceDataCollector::Flag) i_action->cv_value[0].i); break; case Prdr::ACT_THRES: // Threshold // The values which different parameter will have // cv_value[0,1] error frequency and time in sec for field threshold //cv_value[4] true if mnfg threshols needs to be picked up from mnfg file, false otherwise // cv_value [2,3]: error frequency and time in sec for mnfg threshold if cv_value[4] is false // otheiwse cv_value[3] tells which threshold needs to pick up from mnfg file // cv_value[5] maski id if shared threshold if (0 == i_action->cv_value[5].i) { if ( !PlatServices::mfgMode() ) { l_rc = &i_data.cv_reslFactory.GetThresholdSigResolution( ThresholdResolution::ThresholdPolicy( (uint16_t)i_action->cv_value[0].i, i_action->cv_value[1].i)); } else if(i_action->cv_value[4].i) { // FIXME : need to uncomment PrdfMfgThresholdMgr after we figure it out #ifndef __HOSTBOOT_MODULE l_rc = &i_data.cv_reslFactory.GetThresholdSigResolution( *(PrdfMfgThresholdMgr::getInstance()-> getThresholdP(i_action->cv_value[3].i))); #endif } else { l_rc = &i_data.cv_reslFactory.GetThresholdSigResolution( ThresholdResolution::ThresholdPolicy( (uint16_t)i_action->cv_value[2].i, i_action->cv_value[3].i)); } } else if (NULL == i_data.cv_sharedThresholds[i_action->cv_value[5].i]) { if ( !PRDF::PlatServices::mfgMode() ) { l_rc = &i_data.cv_reslFactory. GetThresholdResolution(i_action->cv_value[5].i, ThresholdResolution::ThresholdPolicy((uint16_t)i_action->cv_value[0].i, i_action->cv_value[1].i)); } else if(i_action->cv_value[4].i) { // FIXME : need to uncomment PrdfMfgThresholdMgr after we figure it out #ifndef __HOSTBOOT_MODULE l_rc = &i_data.cv_reslFactory. GetThresholdResolution(i_action->cv_value[5].i, *(PrdfMfgThresholdMgr::getInstance()-> getThresholdP(i_action->cv_value[3].i))); #endif } else { l_rc = &i_data.cv_reslFactory. GetThresholdResolution(i_action->cv_value[5].i, ThresholdResolution::ThresholdPolicy((uint16_t)i_action->cv_value[2].i, i_action->cv_value[3].i)); } i_data.cv_sharedThresholds[i_action->cv_value[5].i] = l_rc; } else { l_rc = i_data.cv_sharedThresholds[i_action->cv_value[5].i]; } break; case Prdr::ACT_DUMP: // DUMP : TODO: Allow dump connected. #ifdef __HOSTBOOT_MODULE //FIXME: comment out hwtablecontent for hostboot l_rc = &i_data.cv_reslFactory.GetDumpResolution( /*(hwTableContent) i_action->cv_value[0].i,*/ GetChipHandle()); #else l_rc = &i_data.cv_reslFactory.GetDumpResolution( (hwTableContent) i_action->cv_value[0].i, GetChipHandle()); #endif break; case Prdr::ACT_GARD: // GARD l_rc = &i_data.cv_reslFactory.GetGardResolution( (GardResolution::ErrorType) i_action->cv_value[0].i); break; case Prdr::ACT_ANALY: // ANALYZE l_rc = &i_data.cv_reslFactory.GetAnalyzeConnectedResolution( this->GetChipHandle(), (TARGETING::TYPE) i_action->cv_value[0].i, i_action->cv_value[1].i); break; case Prdr::ACT_CALL: // CALLOUT switch ((char)i_action->cv_value[0].i) { case 'c': // connected chip. l_rc = &i_data.cv_reslFactory.GetConnectedCalloutResolution( this->GetChipHandle(), (TARGETING::TYPE) i_action->cv_value[2].i, i_action->cv_value[3].i, (CalloutPriorityEnum) i_action->cv_value[1].i, (NULL == i_action->cv_value[4].p ? NULL : (this->createResolution( i_action->cv_value[4].p, i_data))) ); break; case 'p': // Procedure. l_rc = &i_data.cv_reslFactory.GetCalloutResolution( (SymbolicFru) i_action->cv_value[2].i, (CalloutPriorityEnum) i_action->cv_value[1].i); break; case 's': // SELF default: l_rc = &i_data.cv_reslFactory.GetCalloutResolution( this->GetChipHandle(), (CalloutPriorityEnum) i_action->cv_value[1].i); break; }; break; case Prdr::ACT_CAPT: // Capture resolution. l_rc = &i_data.cv_reslFactory.GetCaptureResolution( this, i_action->cv_value[0].i); break; }; return l_rc; }; void PrdfRuleChip::createGroup(PrdfGroup * i_group, uint32_t i_groupId, PrdfRuleChip::RuleFileData & i_data) { // Internal class to collapse the bit string. class CreateBitString { public: static void execute(std::vector & i_bits, Prdr::PrdrExpr * i_expr) { if (NULL == i_expr) return; if (i_expr->cv_op == Prdr::INT_SHORT) { i_bits.push_back(i_expr->cv_value[0].i); } else // must be an | or & operator. { // Expand bit string from left side. CreateBitString::execute(i_bits, i_expr->cv_value[0].p); // Expand bit string from right side. CreateBitString::execute(i_bits, i_expr->cv_value[1].p); } }; }; for (int i = 0; i < i_data.cv_loadChip->cv_groupSize[i_groupId]; i++) { std::vector l_bits; // Vector to hold bit string. // TODO : handle & transformations. // Get expression for group's line. Prdr::PrdrExpr * l_expr = &i_data.cv_loadChip->cv_groups[i_groupId][i]; // Execute internal (recursive) class to generate bit string. CreateBitString::execute(l_bits, l_expr->cv_value[1].p); // Add expression to group. i_group->Add(i_data.cv_regMap[l_expr->cv_value[0].i], &(*l_bits.begin()), l_bits.size(), *(this->createResolution(l_expr->cv_value[2].p, i_data)), i_data.cv_resets[l_expr->cv_value[0].i], (i_data.cv_regMap[l_expr->cv_value[0].i]->GetId() + i_data.cv_loadChip->cv_signatureOffset) & 0xffff, Prdr::AND == l_expr->cv_value[1].p->cv_op ); } // end for. // Do flags. --- // Do Priority filter flag. if (i_data.cv_loadChip->cv_groupFlags[i_groupId] & Prdr::PRDR_GROUP_FILTER_PRIORITY) { std::vector l_bits; CreateBitString::execute(l_bits, i_data.cv_loadChip->cv_groupPriorityBits[i_groupId]); prdfFilter * l_filter = new PrioritySingleBitFilter(l_bits); i_group->AddFilter(l_filter); } // Do single bit filter flag. if (i_data.cv_loadChip->cv_groupFlags[i_groupId] & Prdr::PRDR_GROUP_FILTER_SINGLE_BIT) { prdfFilter * l_filter = new SingleBitFilter(); i_group->AddFilter(l_filter); } } PrdfExtensibleChipFunction * PrdfRuleChip::getExtensibleFunction(const char * i_func, bool i_expectNull) { PrdfExtensibleFunctionType * plugin = prdfGetPluginGlobalMap().getPlugins(cv_fileName)[i_func]; if (NULL == plugin) { static PrdfPlugin l_nullPlugin(NULL); plugin = &l_nullPlugin; if (!i_expectNull) { errlHndl_t l_errl = NULL; PRDF_CREATE_ERRL(l_errl, ERRL_SEV_UNRECOVERABLE, ERRL_ETYPE_NOT_APPLICABLE, SRCI_ERR_INFO, SRCI_NO_ATTR, PRDF_PRDFRULECHIP, LIC_REFCODE, PRDF_CODE_FAIL, __LINE__, 0, 0, 0); PRDF_ADD_FFDC(l_errl, cv_fileName, strlen(cv_fileName), prdfErrlVer1, prdfErrlString); PRDF_ADD_FFDC(l_errl, i_func, strlen(i_func), prdfErrlVer1, prdfErrlString); PRDF_COMMIT_ERRL(l_errl, ERRL_ACTION_REPORT); } } return (PrdfExtensibleChipFunction *) plugin; } SCAN_COMM_REGISTER_CLASS * PrdfRuleChip::getRegister(const char * i_reg, bool i_expectNull) { uint16_t hashId = Util::hashString( i_reg ); SCAN_COMM_REGISTER_CLASS * l_register = cv_hwRegs[hashId]; if (NULL == l_register) { static PrdfNullRegister l_nullRegister(1024); l_register = &l_nullRegister; if (!i_expectNull) { errlHndl_t l_errl = NULL; PRDF_CREATE_ERRL(l_errl, ERRL_SEV_UNRECOVERABLE, ERRL_ETYPE_NOT_APPLICABLE, SRCI_ERR_INFO, SRCI_NO_ATTR, PRDF_PRDFRULECHIP, LIC_REFCODE, PRDF_CODE_FAIL, __LINE__, 1, 0, 0); PRDF_ADD_FFDC(l_errl, cv_fileName, strlen(cv_fileName), prdfErrlVer1, prdfErrlString); PRDF_ADD_FFDC(l_errl, i_reg, strlen(i_reg), prdfErrlVer1, prdfErrlString); PRDF_COMMIT_ERRL(l_errl, ERRL_ACTION_REPORT); } } return l_register; }