void initTriggerEmulator(Engine *engine) { engine_configuration_s *engineConfiguration = engine->engineConfiguration; board_configuration_s *boardConfiguration = &engineConfiguration->bc; #if EFI_EMULATE_POSITION_SENSORS || defined(__DOXYGEN__) print("Emulating %s\r\n", getConfigurationName(engineConfiguration->engineType)); triggerSignal.outputPins[0] = TRIGGER_EMULATOR_PRIMARY; triggerSignal.outputPins[1] = TRIGGER_EMULATOR_SECONDARY; triggerSignal.outputPins[2] = TRIGGER_EMULATOR_3RD; #if EFI_PROD_CODE // todo: refactor, make this a loop outputPinRegisterExt2("distributor ch1", triggerSignal.outputPins[0], boardConfiguration->triggerSimulatorPins[0], &boardConfiguration->triggerSimulatorPinModes[0]); outputPinRegisterExt2("distributor ch2", triggerSignal.outputPins[1], boardConfiguration->triggerSimulatorPins[1], &boardConfiguration->triggerSimulatorPinModes[1]); outputPinRegisterExt2("distributor ch3", triggerSignal.outputPins[2], boardConfiguration->triggerSimulatorPins[2], &boardConfiguration->triggerSimulatorPinModes[2]); #endif /* EFI_PROD_CODE */ initTriggerEmulatorLogic(engine); #else print("No position sensor(s) emulation\r\n"); #endif /* EFI_EMULATE_POSITION_SENSORS */ }
static void printInfo(systime_t nowSeconds) { /** * we report the version every 4 seconds - this way the console does not need to * request it and we will display it pretty soon */ if (overflowDiff(nowSeconds, timeOfPreviousPrintVersion) < 4) { return; } timeOfPreviousPrintVersion = nowSeconds; appendPrintf(&logger, "%s%s%d@%s %s %d%s", RUS_EFI_VERSION_TAG, DELIMETER, getRusEfiVersion(), VCS_VERSION, getConfigurationName(engineConfiguration->engineType), getTimeNowSeconds(), DELIMETER); #if EFI_PROD_CODE || defined(__DOXYGEN__) printOutPin(CRANK1, boardConfiguration->triggerInputPins[0]); printOutPin(CRANK2, boardConfiguration->triggerInputPins[1]); #if EFI_WAVE_ANALYZER || defined(__DOXYGEN__) printOutPin(WA_CHANNEL_1, boardConfiguration->logicAnalyzerPins[0]); printOutPin(WA_CHANNEL_2, boardConfiguration->logicAnalyzerPins[1]); #endif for (int i = 0; i < engineConfiguration->specs.cylindersCount; i++) { printOutPin(enginePins.coils[i].name, boardConfiguration->ignitionPins[i]); printOutPin(enginePins.injectors[i].name, boardConfiguration->injectionPins[i]); } #endif }
static void triggerInfo(Engine *engine) { #if (EFI_PROD_CODE || EFI_SIMULATOR) || defined(__DOXYGEN__) trigger_shape_s *ts = &engine->triggerShape; scheduleMsg(&logger, "Template %s/%d trigger %d", getConfigurationName(engineConfiguration->engineType), engineConfiguration->engineType, engineConfiguration->triggerConfig.triggerType); scheduleMsg(&logger, "trigger event counters %d/%d/%d/%d", triggerCentral.getHwEventCounter(0), triggerCentral.getHwEventCounter(1), triggerCentral.getHwEventCounter(2), triggerCentral.getHwEventCounter(3)); scheduleMsg(&logger, "expected cycle events %d/%d/%d", ts->expectedEventCount[0], engine->triggerShape.expectedEventCount[1], ts->expectedEventCount[2]); scheduleMsg(&logger, "trigger type=%d/need2ndChannel=%s", engineConfiguration->triggerConfig.triggerType, boolToString(engineConfiguration->needSecondTriggerInput)); scheduleMsg(&logger, "expected duty #0=%f/#1=%f", ts->dutyCycle[0], ts->dutyCycle[1]); scheduleMsg(&logger, "isError %s/total errors=%d ord_err=%d/total revolutions=%d/self=%s", boolToString(isTriggerDecoderError()), triggerCentral.triggerState.totalTriggerErrorCounter, triggerCentral.triggerState.orderingErrorCounter, triggerCentral.triggerState.getTotalRevolutionCounter(), boolToString(engineConfiguration->directSelfStimulation)); #endif #if EFI_PROD_CODE scheduleMsg(&logger, "sn=%s ignitionMathTime=%d schTime=%d triggerMaxDuration=%d", boolToString(ts->isSynchronizationNeeded), engine->ignitionMathTime, engine->ignitionSchTime, triggerMaxDuration); triggerMaxDuration = 0; scheduleMsg(&logger, "maxLockTime=%d / maxTriggerReentraint=%d", maxLockTime, maxTriggerReentraint); scheduleMsg(&logger, "maxEventQueueTime=%d", maxEventQueueTime); scheduleMsg(&logger, "primary trigger simulator: %s %s freq=%d", hwPortname(boardConfiguration->triggerSimulatorPins[0]), pinModeToString(boardConfiguration->triggerSimulatorPinModes[0]), boardConfiguration->triggerSimulatorFrequency); scheduleMsg(&logger, "secondary trigger simulator: %s %s phase=%d", hwPortname(boardConfiguration->triggerSimulatorPins[1]), pinModeToString(boardConfiguration->triggerSimulatorPinModes[1]), triggerSignal.safe.phaseIndex); scheduleMsg(&logger, "3rd trigger simulator: %s %s", hwPortname(boardConfiguration->triggerSimulatorPins[2]), pinModeToString(boardConfiguration->triggerSimulatorPinModes[2])); scheduleMsg(&logger, "trigger error extra LED: %s %s", hwPortname(boardConfiguration->triggerErrorPin), pinModeToString(boardConfiguration->triggerErrorPinMode)); scheduleMsg(&logger, "primary trigger input: %s", hwPortname(boardConfiguration->triggerInputPins[0])); scheduleMsg(&logger, "secondary trigger input: %s", hwPortname(boardConfiguration->triggerInputPins[1])); scheduleMsg(&logger, "primary logic input: %s", hwPortname(boardConfiguration->logicAnalyzerPins[0])); scheduleMsg(&logger, "secondary logic input: %s", hwPortname(boardConfiguration->logicAnalyzerPins[1])); #endif /* EFI_PROD_CODE */ }
void initTriggerEmulator(void) { #if EFI_EMULATE_POSITION_SENSORS print("Emulating %s\r\n", getConfigurationName(engineConfiguration)); configuration.outputPins[0] = TRIGGER_EMILATOR_PRIMARY; configuration.outputPins[1] = TRIGGER_EMILATOR_SECONDARY; outputPinRegisterExt2("distributor ch1", configuration.outputPins[0], boardConfiguration->triggerSimulatorPins[0], &boardConfiguration->triggerSimulatorPinModes[0]); outputPinRegisterExt2("distributor ch2", configuration.outputPins[1], boardConfiguration->triggerSimulatorPins[1], &boardConfiguration->triggerSimulatorPinModes[1]); initTriggerEmulatorLogic(applyPinState); #else print("No position sensor(s) emulation\r\n"); #endif /* EFI_EMULATE_POSITION_SENSORS */ }
/** * @brief Prints current engine configuration to human-readable console. */ void printConfiguration(engine_configuration_s *engineConfiguration, engine_configuration2_s *engineConfiguration2) { scheduleMsg(&logger, getConfigurationName(engineConfiguration)); scheduleMsg(&logger, "configurationVersion=%d", getGlobalConfigurationVersion()); for (int k = 0; k < FUEL_LOAD_COUNT; k++) { // print("line %d (%f): ", k, engineConfiguration->fuelKeyBins[k]); // for (int r = 0; r < FUEL_RPM_COUNT; r++) { // print("%f ", engineConfiguration->fuelTable[k][r]); // } // print("\r\n"); } printFloatArray("RPM bin: ", engineConfiguration->fuelRpmBins, FUEL_RPM_COUNT); printFloatArray("Y bin: ", engineConfiguration->fuelLoadBins, FUEL_LOAD_COUNT); printFloatArray("CLT: ", engineConfiguration->cltFuelCorr, CLT_CURVE_SIZE); printFloatArray("CLT bins: ", engineConfiguration->cltFuelCorrBins, CLT_CURVE_SIZE); printFloatArray("IAT: ", engineConfiguration->iatFuelCorr, IAT_CURVE_SIZE); printFloatArray("IAT bins: ", engineConfiguration->iatFuelCorrBins, IAT_CURVE_SIZE); printFloatArray("vBatt: ", engineConfiguration->battInjectorLagCorr, VBAT_INJECTOR_CURVE_SIZE); printFloatArray("vBatt bins: ", engineConfiguration->battInjectorLagCorrBins, VBAT_INJECTOR_CURVE_SIZE); // appendMsgPrefix(&logger); scheduleMsg(&logger, "rpmHardLimit: %d", engineConfiguration->rpmHardLimit); scheduleMsg(&logger, "rpmMultiplier=%f", engineConfiguration->rpmMultiplier); scheduleMsg(&logger, "tpsMin: %d", engineConfiguration->tpsMin); scheduleMsg(&logger, "tpsMax: %d", engineConfiguration->tpsMax); scheduleMsg(&logger, "timingMode: %d", engineConfiguration->timingMode); scheduleMsg(&logger, "fixedModeTiming: %d", (int) engineConfiguration->fixedModeTiming); scheduleMsg(&logger, "ignitionOffset=%f", engineConfiguration->ignitionOffset); scheduleMsg(&logger, "injectionOffset=%f", engineConfiguration->injectionOffset); scheduleMsg(&logger, "crankingChargeAngle=%f", engineConfiguration->crankingChargeAngle); scheduleMsg(&logger, "crankingTimingAngle=%f", engineConfiguration->crankingTimingAngle); scheduleMsg(&logger, "globalTriggerAngleOffset=%f", engineConfiguration->globalTriggerAngleOffset); // scheduleMsg(&logger, "analogChartMode: %d", engineConfiguration->analogChartMode); // scheduleMsg(&logger, "crankingRpm: %d", engineConfiguration->crankingSettings.crankingRpm); scheduleMsg(&logger, "idlePinMode: %d", boardConfiguration->idleValvePinMode); scheduleMsg(&logger, "malfunctionIndicatorPinMode: %d", boardConfiguration->malfunctionIndicatorPinMode); scheduleMsg(&logger, "analogInputDividerCoefficient: %f", engineConfiguration->analogInputDividerCoefficient); scheduleMsg(&logger, "needSecondTriggerInput: %d", engineConfiguration->needSecondTriggerInput); #if EFI_PROD_CODE scheduleMsg(&logger, "idleValvePin: %s", hwPortname(boardConfiguration->idleValvePin)); scheduleMsg(&logger, "fuelPumpPin: mode %d @ %s", boardConfiguration->fuelPumpPinMode, hwPortname(boardConfiguration->fuelPumpPin)); scheduleMsg(&logger, "injectionPins: mode %d", boardConfiguration->injectionPinMode); for (int i = 0; i < engineConfiguration->cylindersCount; i++) { brain_pin_e brainPin = boardConfiguration->injectionPins[i]; scheduleMsg(&logger, "injection %d @ %s", i, hwPortname(brainPin)); } scheduleMsg(&logger, "ignitionPins: mode %d", boardConfiguration->ignitionPinMode); // todo: calculate coils count based on ignition mode for (int i = 0; i < 4; i++) { brain_pin_e brainPin = boardConfiguration->ignitionPins[i]; scheduleMsg(&logger, "ignition %d @ %s", i, hwPortname(brainPin)); } scheduleMsg(&logger, "primary trigger simulator: %s %d", hwPortname(boardConfiguration->triggerSimulatorPins[0]), boardConfiguration->triggerSimulatorPinModes[0]); scheduleMsg(&logger, "secondary trigger simulator: %s %d", hwPortname(boardConfiguration->triggerSimulatorPins[1]), boardConfiguration->triggerSimulatorPinModes[1]); #endif /* EFI_PROD_CODE */ scheduleMsg(&logger, "isInjectionEnabledFlag %d", engineConfiguration2->isInjectionEnabledFlag); // appendPrintf(&logger, DELIMETER); // scheduleLogging(&logger); }
/** * @brief Prints current engine configuration to human-readable console. */ void printConfiguration(engine_configuration_s *engineConfiguration) { scheduleMsg(&logger, "Template %s/%d trigger %s/%s/%d", getConfigurationName(engineConfiguration->engineType), engineConfiguration->engineType, getTrigger_type_e(engineConfiguration->trigger.type), getEngine_load_mode_e(engineConfiguration->algorithm), engineConfiguration->algorithm); scheduleMsg(&logger, "configurationVersion=%d", getGlobalConfigurationVersion()); for (int k = 0; k < FUEL_LOAD_COUNT; k++) { // print("line %d (%f): ", k, engineConfiguration->fuelKeyBins[k]); // for (int r = 0; r < FUEL_RPM_COUNT; r++) { // print("%f ", engineConfiguration->fuelTable[k][r]); // } // print("\r\n"); } // printFloatArray("RPM bin: ", config->fuelRpmBins, FUEL_RPM_COUNT); // // printFloatArray("Y bin: ", config->fuelLoadBins, FUEL_LOAD_COUNT); // // printFloatArray("CLT: ", config->cltFuelCorr, CLT_CURVE_SIZE); // printFloatArray("CLT bins: ", config->cltFuelCorrBins, CLT_CURVE_SIZE); // // printFloatArray("IAT: ", config->iatFuelCorr, IAT_CURVE_SIZE); // printFloatArray("IAT bins: ", config->iatFuelCorrBins, IAT_CURVE_SIZE); // // printFloatArray("vBatt: ", engineConfiguration->injector.battLagCorr, VBAT_INJECTOR_CURVE_SIZE); // printFloatArray("vBatt bins: ", engineConfiguration->injector.battLagCorrBins, VBAT_INJECTOR_CURVE_SIZE); scheduleMsg(&logger, "rpmHardLimit: %d/operationMode=%d", engineConfiguration->rpmHardLimit, engineConfiguration->operationMode); scheduleMsg(&logger, "globalTriggerAngleOffset=%f", engineConfiguration->globalTriggerAngleOffset); scheduleMsg(&logger, "=== cranking ==="); scheduleMsg(&logger, "crankingRpm: %d", engineConfiguration->cranking.rpm); scheduleMsg(&logger, "cranking injection %s", getInjection_mode_e(engineConfiguration->crankingInjectionMode)); if (engineConfiguration->useConstantDwellDuringCranking) { scheduleMsg(&logger, "ignitionDwellForCrankingMs=%f", engineConfiguration->ignitionDwellForCrankingMs); } else { scheduleMsg(&logger, "cranking charge charge angle=%f fire at %f", engineConfiguration->crankingChargeAngle, engineConfiguration->crankingTimingAngle); } scheduleMsg(&logger, "=== ignition ==="); scheduleMsg(&logger, "ignitionMode: %s/enabled=%s", getIgnition_mode_e(engineConfiguration->ignitionMode), boolToString(engineConfiguration->isIgnitionEnabled)); scheduleMsg(&logger, "timingMode: %s", getTiming_mode_e(engineConfiguration->timingMode)); if (engineConfiguration->timingMode == TM_FIXED) { scheduleMsg(&logger, "fixedModeTiming: %d", (int) engineConfiguration->fixedModeTiming); } scheduleMsg(&logger, "ignitionOffset=%f", engineConfiguration->ignitionOffset); scheduleMsg(&logger, "=== injection ==="); scheduleMsg(&logger, "injection %s offset=%f/enabled=%s", getInjection_mode_e(engineConfiguration->injectionMode), (double) engineConfiguration->injectionOffset, boolToString(engineConfiguration->isInjectionEnabled)); printOutputs(engineConfiguration); scheduleMsg(&logger, "map_avg=%s/mil=%s/fp=%s/ts=%s/wa=%s/it=%s/fastAdc=%s", boolToString(engineConfiguration->isMapAveragingEnabled), boolToString(engineConfiguration->isMilEnabled), boolToString(engineConfiguration->isFuelPumpEnabled), boolToString(engineConfiguration->isTunerStudioEnabled), boolToString(engineConfiguration->isWaveAnalyzerEnabled), boolToString(engineConfiguration->isIdleThreadEnabled), boolToString(boardConfiguration->isFastAdcEnabled)); scheduleMsg(&logger, "isManualSpinningMode=%s/isCylinderCleanupEnabled=%s", boolToString(engineConfiguration->isManualSpinningMode), boolToString(engineConfiguration->isCylinderCleanupEnabled)); scheduleMsg(&logger, "clutchUp@%s: %s", hwPortname(boardConfiguration->clutchUpPin), boolToString(engine->clutchUpState)); scheduleMsg(&logger, "clutchDown@%s: %s", hwPortname(boardConfiguration->clutchDownPin), boolToString(engine->clutchDownState)); scheduleMsg(&logger, "boardTestModeJumperPin: %s/nesting=%d", hwPortname(boardConfiguration->boardTestModeJumperPin), maxNesting); scheduleMsg(&logger, "digitalPotentiometerSpiDevice %d", boardConfiguration->digitalPotentiometerSpiDevice); for (int i = 0; i < DIGIPOT_COUNT; i++) { scheduleMsg(&logger, "digitalPotentiometer CS%d %s", i, hwPortname(boardConfiguration->digitalPotentiometerChipSelect[i])); } #if EFI_PROD_CODE printSpiState(&logger, boardConfiguration); #endif /* EFI_PROD_CODE */ }
static void showLine(lcd_line_e line, int screenY) { static char buffer[10]; switch (line) { case LL_VERSION: lcdPrintf("version %s", VCS_VERSION); return; case LL_CONFIG: lcdPrintf("config %s", getConfigurationName(engineConfiguration->engineType)); return; case LL_RPM: lcdPrintf("RPM %d", getRpmE(engine)); { char sdState; if (boardConfiguration->isSdCardEnabled) { sdState = isSdCardAlive() ? 'L' : 'n'; } else { sdState = 'D'; } int seconds = getTimeNowSeconds(); if (seconds < 10000) { lcdPrintf(" %d%c", seconds, sdState); } } return; case LL_CLT_TEMPERATURE: lcdPrintf("Coolant %f", getCoolantTemperature(PASS_ENGINE_PARAMETER_F)); return; case LL_IAT_TEMPERATURE: lcdPrintf("Intake Air %f", getIntakeAirTemperature(PASS_ENGINE_PARAMETER_F)); return; case LL_ALGORITHM: lcdPrintf(getEngine_load_mode_e(engineConfiguration->algorithm)); return; case LL_INJECTION: lcdPrintf(getInjection_mode_e(engineConfiguration->injectionMode)); return; case LL_ING_FLOW: lcdPrintf("Inj %fcc", engineConfiguration->injector.flow); return; case LL_IGNITION: lcdPrintf(getIgnition_mode_e(engineConfiguration->ignitionMode)); return; case LL_TPS: getPinNameByAdcChannel(engineConfiguration->tpsAdcChannel, buffer); lcdPrintf("Throttle %s %f%%", buffer, getTPS()); return; case LL_VBATT: lcdPrintf("Battery %fv", getVBatt(PASS_ENGINE_PARAMETER_F)); return; case LL_KNOCK: getPinNameByAdcChannel(engineConfiguration->hipOutputChannel, buffer); lcdPrintf("Knock %s %fv", buffer, engine->knockVolts); return; #if EFI_ANALOG_SENSORS || defined(__DOXYGEN__) case LL_BARO: if (hasBaroSensor()) { lcdPrintf("Baro: %f", getBaroPressure()); } else { lcdPrintf("Baro: none"); } return; #endif case LL_AFR: if (engineConfiguration->hasAfrSensor) { lcdPrintf("AFR: %f", getAfr()); } else { lcdPrintf("AFR: none"); } return; case LL_MAP: if (engineConfiguration->hasMapSensor) { lcdPrintf("MAP %f", getMap()); } else { lcdPrintf("MAP: none"); } return; case LL_MAF_V: if (hasMafSensor()) { lcdPrintf("MAF: %fv", getMaf()); } else { lcdPrintf("MAF: none"); } return; case LL_MAF_KG_HR: if (hasMafSensor()) { lcdPrintf("MAF: %f kg/hr", getRealMaf()); } else { lcdPrintf("MAF: none"); } return; case LL_TRIGGER_ERRORS: lcdPrintf("Errors"); return; case LL_TRIGGER_DUTY: lcdPrintf("Duty"); return; default: lcdPrintf("()"); } }
void triggerInfo(Engine *engine) { #if (EFI_PROD_CODE || EFI_SIMULATOR) || defined(__DOXYGEN__) TriggerShape *ts = &engine->triggerShape; scheduleMsg(logger, "Template %s (%d) trigger %s (%d) useRiseEdge=%s onlyFront=%s", getConfigurationName(engineConfiguration->engineType), engineConfiguration->engineType, getTrigger_type_e(engineConfiguration->trigger.type), engineConfiguration->trigger.type, boolToString(TRIGGER_SHAPE(useRiseEdge)), boolToString(engineConfiguration->useOnlyFrontForTrigger)); scheduleMsg(logger, "trigger#1 event counters up=%d/down=%d", triggerCentral.getHwEventCounter(0), triggerCentral.getHwEventCounter(1)); if (engine->triggerShape.needSecondTriggerInput) { scheduleMsg(logger, "trigger#2 event counters up=%d/down=%d", triggerCentral.getHwEventCounter(2), triggerCentral.getHwEventCounter(3)); } scheduleMsg(logger, "expected cycle events %d/%d/%d", ts->expectedEventCount[0], engine->triggerShape.expectedEventCount[1], ts->expectedEventCount[2]); scheduleMsg(logger, "trigger type=%d/need2ndChannel=%s", engineConfiguration->trigger.type, boolToString(engine->triggerShape.needSecondTriggerInput)); scheduleMsg(logger, "expected duty #0=%f/#1=%f", ts->dutyCycle[0], ts->dutyCycle[1]); scheduleMsg(logger, "isError %s/total errors=%d ord_err=%d/total revolutions=%d/self=%s", boolToString(isTriggerDecoderError()), triggerCentral.triggerState.totalTriggerErrorCounter, triggerCentral.triggerState.orderingErrorCounter, triggerCentral.triggerState.getTotalRevolutionCounter(), boolToString(engineConfiguration->directSelfStimulation)); if (ts->isSynchronizationNeeded) { scheduleMsg(logger, "gap from %f to %f", ts->syncRatioFrom, ts->syncRatioTo); } #endif #if EFI_PROD_CODE scheduleMsg(logger, "sn=%s ignitionMathTime=%d schTime=%d injectonSchTime=%d zeroTestTime=%d advanceTime=%d triggerMaxDuration=%d", boolToString(ts->isSynchronizationNeeded), engine->m.ignitionMathTime, engine->m.ignitionSchTime, engine->m.injectonSchTime, engine->m.zeroTestTime, engine->m.advanceTime, triggerMaxDuration); triggerMaxDuration = 0; scheduleMsg(logger, "maxLockTime=%d / maxTriggerReentraint=%d", maxLockTime, maxTriggerReentraint); scheduleMsg(logger, "maxEventQueueTime=%d", maxEventQueueTime); scheduleMsg(logger, "primary trigger input: %s", hwPortname(boardConfiguration->triggerInputPins[0])); scheduleMsg(logger, "primary trigger simulator: %s %s freq=%d", hwPortname(boardConfiguration->triggerSimulatorPins[0]), getPin_output_mode_e(boardConfiguration->triggerSimulatorPinModes[0]), boardConfiguration->triggerSimulatorFrequency); if (engine->triggerShape.needSecondTriggerInput) { scheduleMsg(logger, "secondary trigger input: %s", hwPortname(boardConfiguration->triggerInputPins[1])); #if EFI_EMULATE_POSITION_SENSORS || defined(__DOXYGEN__) scheduleMsg(logger, "secondary trigger simulator: %s %s phase=%d", hwPortname(boardConfiguration->triggerSimulatorPins[1]), getPin_output_mode_e(boardConfiguration->triggerSimulatorPinModes[1]), triggerSignal.safe.phaseIndex); #endif /* EFI_EMULATE_POSITION_SENSORS */ } // scheduleMsg(logger, "3rd trigger simulator: %s %s", hwPortname(boardConfiguration->triggerSimulatorPins[2]), // getPin_output_mode_e(boardConfiguration->triggerSimulatorPinModes[2])); scheduleMsg(logger, "trigger error extra LED: %s %s", hwPortname(boardConfiguration->triggerErrorPin), getPin_output_mode_e(boardConfiguration->triggerErrorPinMode)); scheduleMsg(logger, "primary logic input: %s", hwPortname(boardConfiguration->logicAnalyzerPins[0])); scheduleMsg(logger, "secondary logic input: %s", hwPortname(boardConfiguration->logicAnalyzerPins[1])); #endif /* EFI_PROD_CODE */ }
Boolean UNIX_BootConfigSetting::getConfigurationName(CIMProperty &p) const { p = CIMProperty(PROPERTY_CONFIGURATION_NAME, getConfigurationName()); return true; }