From 13d20ddb2a48e53eccee7717aa593581ee08e09d Mon Sep 17 00:00:00 2001 From: Marcus10110 Date: Wed, 30 Sep 2020 19:56:44 -0700 Subject: [PATCH] clang-format update of System Management Bus (SMBus) Analyzer --- src/SMBusAnalyzer.cpp | 571 ++++++------- src/SMBusAnalyzer.h | 50 +- src/SMBusAnalyzerResults.cpp | 950 ++++++++++----------- src/SMBusAnalyzerResults.h | 35 +- src/SMBusAnalyzerSettings.cpp | 152 ++-- src/SMBusAnalyzerSettings.h | 41 +- src/SMBusCommands.cpp | 616 +++++++------- src/SMBusCommands.h | 482 +++++------ src/SMBusSimulationDataGenerator.cpp | 590 ++++++------- src/SMBusSimulationDataGenerator.h | 91 +-- src/SMBusTypes.cpp | 1136 +++++++++++++------------- src/SMBusTypes.h | 328 ++++---- 12 files changed, 2532 insertions(+), 2510 deletions(-) diff --git a/src/SMBusAnalyzer.cpp b/src/SMBusAnalyzer.cpp index 8d913ed..77bd5e4 100644 --- a/src/SMBusAnalyzer.cpp +++ b/src/SMBusAnalyzer.cpp @@ -8,342 +8,351 @@ #include "SMBusAnalyzer.h" #include "SMBusAnalyzerSettings.h" -SMBusAnalyzer::SMBusAnalyzer() - : mSimulationInitilized(false) +SMBusAnalyzer::SMBusAnalyzer() : mSimulationInitilized( false ) { - SetAnalyzerSettings(&mSettings); + SetAnalyzerSettings( &mSettings ); } SMBusAnalyzer::~SMBusAnalyzer() { - KillThread(); + KillThread(); } void SMBusAnalyzer::SetupResults() { - // reset the results - mResults.reset(new SMBusAnalyzerResults(this, &mSettings)); - SetAnalyzerResults(mResults.get()); + // reset the results + mResults.reset( new SMBusAnalyzerResults( this, &mSettings ) ); + SetAnalyzerResults( mResults.get() ); - // set which channels will carry bubbles - mResults->AddChannelBubblesWillAppearOn(mSettings.mSMBDAT); - mResults->AddChannelBubblesWillAppearOn(mSettings.mSMBCLK); + // set which channels will carry bubbles + mResults->AddChannelBubblesWillAppearOn( mSettings.mSMBDAT ); + mResults->AddChannelBubblesWillAppearOn( mSettings.mSMBCLK ); } -AnalyzerChannelData* SMBusAnalyzer::AdvanceAllTo(U64 toSample) +AnalyzerChannelData* SMBusAnalyzer::AdvanceAllTo( U64 toSample ) { - assert(mSMBCLK->GetSampleNumber() <= toSample); - assert(mSMBDAT->GetSampleNumber() <= toSample); - - mSMBCLK->AdvanceToAbsPosition(toSample); - mSMBDAT->AdvanceToAbsPosition(toSample); + assert( mSMBCLK->GetSampleNumber() <= toSample ); + assert( mSMBDAT->GetSampleNumber() <= toSample ); - return GetNearestTransitionChannel(); + mSMBCLK->AdvanceToAbsPosition( toSample ); + mSMBDAT->AdvanceToAbsPosition( toSample ); + + return GetNearestTransitionChannel(); } AnalyzerChannelData* SMBusAnalyzer::GetNearestTransitionChannel() { - if (!mSMBDAT->DoMoreTransitionsExistInCurrentData()) - return mSMBCLK; + if( !mSMBDAT->DoMoreTransitionsExistInCurrentData() ) + return mSMBCLK; - if (!mSMBCLK->DoMoreTransitionsExistInCurrentData()) - return mSMBDAT; + if( !mSMBCLK->DoMoreTransitionsExistInCurrentData() ) + return mSMBDAT; - if (mSMBDAT->GetSampleOfNextEdge() < mSMBCLK->GetSampleOfNextEdge()) - return mSMBDAT; + if( mSMBDAT->GetSampleOfNextEdge() < mSMBCLK->GetSampleOfNextEdge() ) + return mSMBDAT; - return mSMBCLK; + return mSMBCLK; } -bool SMBusAnalyzer::GetSignal(SMBusSignalState& state) +bool SMBusAnalyzer::GetSignal( SMBusSignalState& state ) { - func_begin: - bool ret_val = true; - - state.Clear(); - - AnalyzerChannelData* nearestEdgeChannel = GetNearestTransitionChannel(); - - // first check for a start or stop - if (mSMBCLK->GetBitState() == BIT_HIGH) - { - U64 start_sample = mSMBCLK->GetSampleNumber(); - if (nearestEdgeChannel == mSMBDAT) - { - ret_val = false; - - // remember where we began in case this is the last packet - U64 frame_begin = mSMBDAT->GetSampleNumber(); - - state.sample_marker = mSMBDAT->GetSampleOfNextEdge(); - - if (mSMBDAT->GetBitState() == BIT_HIGH) - state.bus_signal = SMB_Start; - else - state.bus_signal = SMB_Stop; - - // move all to the SMBDAT transition - nearestEdgeChannel = AdvanceAllTo(state.sample_marker); - - // set the begin and ending samples for the frame - U64 frame_offset = 0; - if (nearestEdgeChannel->DoMoreTransitionsExistInCurrentData()) - { - U64 end_sample = nearestEdgeChannel->GetSampleOfNextEdge(); - if (end_sample - state.sample_marker < state.sample_marker - start_sample) - frame_offset = (end_sample - state.sample_marker) / 2; - else - frame_offset = (state.sample_marker - start_sample) / 2; - } else { - frame_offset = state.sample_marker - frame_begin; - } - - state.sample_begin = state.sample_marker - frame_offset; - state.sample_end = state.sample_marker + frame_offset; - - // skip the falling SMBCLK if we have a start - // this prepares us for the first bit - if (state.bus_signal == SMB_Start && nearestEdgeChannel == mSMBCLK) - AdvanceAllTo(mSMBCLK->GetSampleOfNextEdge()); - } else { - // SMBCLK falls - skip to it - nearestEdgeChannel = AdvanceAllTo(nearestEdgeChannel->GetSampleOfNextEdge()); - } - } - - // if we didn't find a start or stop above try parsing a bit - if (ret_val) - { - // we must have a low SMBCLK at this point - assert(mSMBCLK->GetBitState() == BIT_LOW); - - // skip the preparing of SMBDAT for the rising SMBCLK egde - if (nearestEdgeChannel == mSMBDAT) - { - state.sample_begin = mSMBDAT->GetSampleOfNextEdge(); - nearestEdgeChannel = AdvanceAllTo(state.sample_begin); - } else { - state.sample_begin = (mSMBCLK->GetSampleNumber() + mSMBCLK->GetSampleOfNextEdge()) / 2; - } - - // do we have a rising SMBCLK at this point? - if (nearestEdgeChannel == mSMBCLK) - { - nearestEdgeChannel = AdvanceAllTo(mSMBCLK->GetSampleOfNextEdge()); - - state.sample_rising_clk = mSMBCLK->GetSampleNumber(); - - // do we have a falling SMBCLK edge next? - if (nearestEdgeChannel == mSMBCLK) - { - // sample the state of SMBDAT - state.sample_marker = (mSMBCLK->GetSampleOfNextEdge() + state.sample_rising_clk) / 2; - - if (state.sample_marker > state.sample_rising_clk && state.sample_marker < mSMBCLK->GetSampleOfNextEdge()) - nearestEdgeChannel = AdvanceAllTo(state.sample_marker); - - state.bus_signal = mSMBDAT->GetBitState() == BIT_HIGH ? SMB_One : SMB_Zero; - - // advance to SMBCLK falling edge - nearestEdgeChannel = AdvanceAllTo(mSMBCLK->GetSampleOfNextEdge()); - - // where to put the end of state depends on where the next transition happens - if (nearestEdgeChannel == mSMBCLK) - state.sample_end = (mSMBCLK->GetSampleNumber() + mSMBCLK->GetSampleOfNextEdge()) / 2; - else - state.sample_end = mSMBDAT->GetSampleOfNextEdge(); - - } else { - // go back to parsing start/stop - goto func_begin; - } - - } else { - // go back to parsing start/stop - goto func_begin; - } - } - - return ret_val; + bool ret_val = true; + + state.Clear(); + + AnalyzerChannelData* nearestEdgeChannel = GetNearestTransitionChannel(); + + // first check for a start or stop + if( mSMBCLK->GetBitState() == BIT_HIGH ) + { + U64 start_sample = mSMBCLK->GetSampleNumber(); + if( nearestEdgeChannel == mSMBDAT ) + { + ret_val = false; + + // remember where we began in case this is the last packet + U64 frame_begin = mSMBDAT->GetSampleNumber(); + + state.sample_marker = mSMBDAT->GetSampleOfNextEdge(); + + if( mSMBDAT->GetBitState() == BIT_HIGH ) + state.bus_signal = SMB_Start; + else + state.bus_signal = SMB_Stop; + + // move all to the SMBDAT transition + nearestEdgeChannel = AdvanceAllTo( state.sample_marker ); + + // set the begin and ending samples for the frame + U64 frame_offset = 0; + if( nearestEdgeChannel->DoMoreTransitionsExistInCurrentData() ) + { + U64 end_sample = nearestEdgeChannel->GetSampleOfNextEdge(); + if( end_sample - state.sample_marker < state.sample_marker - start_sample ) + frame_offset = ( end_sample - state.sample_marker ) / 2; + else + frame_offset = ( state.sample_marker - start_sample ) / 2; + } + else + { + frame_offset = state.sample_marker - frame_begin; + } + + state.sample_begin = state.sample_marker - frame_offset; + state.sample_end = state.sample_marker + frame_offset; + + // skip the falling SMBCLK if we have a start + // this prepares us for the first bit + if( state.bus_signal == SMB_Start && nearestEdgeChannel == mSMBCLK ) + AdvanceAllTo( mSMBCLK->GetSampleOfNextEdge() ); + } + else + { + // SMBCLK falls - skip to it + nearestEdgeChannel = AdvanceAllTo( nearestEdgeChannel->GetSampleOfNextEdge() ); + } + } + + // if we didn't find a start or stop above try parsing a bit + if( ret_val ) + { + // we must have a low SMBCLK at this point + assert( mSMBCLK->GetBitState() == BIT_LOW ); + + // skip the preparing of SMBDAT for the rising SMBCLK egde + if( nearestEdgeChannel == mSMBDAT ) + { + state.sample_begin = mSMBDAT->GetSampleOfNextEdge(); + nearestEdgeChannel = AdvanceAllTo( state.sample_begin ); + } + else + { + state.sample_begin = ( mSMBCLK->GetSampleNumber() + mSMBCLK->GetSampleOfNextEdge() ) / 2; + } + + // do we have a rising SMBCLK at this point? + if( nearestEdgeChannel == mSMBCLK ) + { + nearestEdgeChannel = AdvanceAllTo( mSMBCLK->GetSampleOfNextEdge() ); + + state.sample_rising_clk = mSMBCLK->GetSampleNumber(); + + // do we have a falling SMBCLK edge next? + if( nearestEdgeChannel == mSMBCLK ) + { + // sample the state of SMBDAT + state.sample_marker = ( mSMBCLK->GetSampleOfNextEdge() + state.sample_rising_clk ) / 2; + + if( state.sample_marker > state.sample_rising_clk && state.sample_marker < mSMBCLK->GetSampleOfNextEdge() ) + nearestEdgeChannel = AdvanceAllTo( state.sample_marker ); + + state.bus_signal = mSMBDAT->GetBitState() == BIT_HIGH ? SMB_One : SMB_Zero; + + // advance to SMBCLK falling edge + nearestEdgeChannel = AdvanceAllTo( mSMBCLK->GetSampleOfNextEdge() ); + + // where to put the end of state depends on where the next transition happens + if( nearestEdgeChannel == mSMBCLK ) + state.sample_end = ( mSMBCLK->GetSampleNumber() + mSMBCLK->GetSampleOfNextEdge() ) / 2; + else + state.sample_end = mSMBDAT->GetSampleOfNextEdge(); + } + else + { + // go back to parsing start/stop + goto func_begin; + } + } + else + { + // go back to parsing start/stop + goto func_begin; + } + } + + return ret_val; } void SMBusAnalyzer::WorkerThread() { - // get the channel pointers - mSMBDAT = GetAnalyzerChannelData(mSettings.mSMBDAT); - mSMBCLK = GetAnalyzerChannelData(mSettings.mSMBCLK); - - const bool calcPEC = mSettings.CalcPEC(); - bool is_bit; - SMBusByte byte; - SMBusPacket packet; - SMBusSignalState s; - for (;;) - { - is_bit = GetSignal(s); - - if (is_bit) - { - // is this a data bit? - if (byte.signals.size() < 8) - { - byte.value <<= 1; - if (s.bus_signal == SMB_One) - byte.value |= 1; - - byte.signals.push_back(s); - } else { - // translate zero/one to ack/nack - if (s.bus_signal == SMB_Zero) - { - byte.is_acked = true; - s.bus_signal = SMB_ACK; - } else { - byte.is_acked = false; - s.bus_signal = SMB_NACK; - } - - // remember the ACK/NACK signal - byte.signals.push_back(s); - - // add byte to command/packet - if (!packet.chunks.empty()) - packet.chunks.back().push_back(byte); - } - - } else { - - // on a Start signal begin a new chunk - if (s.bus_signal == SMB_Start) - { - if (packet.chunks.empty()) - packet.first_start = s; - - packet.chunks.push_back(std::vector()); - } - } - - // create the markers - s.AddMarkers(mResults.get(), mSettings.mSMBCLK, mSettings.mSMBDAT); - - // branch on decode level - if (mSettings.mDecodeLevel == DL_Signals) - { - mResults->AddFrame(s.ToFrame()); - - } else if (mSettings.mDecodeLevel == DL_Bytes) { - - if (byte.IsComplete()) - { - if (packet.chunks.back().size() == 1) // if this is the first byte of the packet - mResults->AddFrame(byte.ToAddrFrame(NULL)); - else - mResults->AddFrame(byte.ToFrame()); - } - - } else if (mSettings.mDecodeLevel == DL_SMBus - || mSettings.mDecodeLevel == DL_PMBus - || mSettings.mDecodeLevel == DL_SmartBattery) { - - if (s.bus_signal == SMB_Stop) - { - // make frames for the transaction - - packet.stop = s; - - // first try the SMBus protocols - bool found_match = false; - int pcnt; - for (pcnt = 0; pcnt < NUM_SMBUS_PROTOCOLS && !found_match; ++pcnt) - { - if (packet.MatchesProtocol(SMBusProtocols + pcnt, calcPEC)) - { - //packet.CreateDescFrames(mResults.get(), SMBusProtocols + pcnt, 0); - packet.CreateFrames(mResults.get(), SMBusProtocols + pcnt, calcPEC, mSettings.mDecodeLevel); - found_match = true; - } - } - - // do the PMBus specific protocols - if (!found_match && mSettings.mDecodeLevel == DL_PMBus) - { - for (pcnt = 0; pcnt < NUM_PMBUS_PROTOCOLS && !found_match; ++pcnt) - { - if (packet.MatchesProtocol(PMBusProtocols + pcnt, calcPEC)) - { - //packet.CreateDescFrames(mResults.get(), PMBusProtocols + pcnt, 0); - packet.CreateFrames(mResults.get(), PMBusProtocols + pcnt, calcPEC, mSettings.mDecodeLevel); - found_match = true; - } - } - - if (!found_match && packet.MatchesGroupCommand(calcPEC)) - { - //packet.CreateDescFrames(mResults.get(), NULL, 1); - packet.CreateFramesForGroupCommand(mResults.get(), calcPEC); - found_match = true; - } - } - - // if we have not recognized this packet, just add raw data frames - if (!found_match) - { - //packet.CreateDescFrames(mResults.get(), NULL, 2); - packet.CreateFramesForRawData(mResults.get(), calcPEC); - } - - packet.Clear(); - } - } - - if (byte.signals.size() == 9 || !is_bit) - byte.Clear(); - - mResults->CommitResults(); - - ReportProgress(mSMBDAT->GetSampleNumber()); - } + // get the channel pointers + mSMBDAT = GetAnalyzerChannelData( mSettings.mSMBDAT ); + mSMBCLK = GetAnalyzerChannelData( mSettings.mSMBCLK ); + + const bool calcPEC = mSettings.CalcPEC(); + bool is_bit; + SMBusByte byte; + SMBusPacket packet; + SMBusSignalState s; + for( ;; ) + { + is_bit = GetSignal( s ); + + if( is_bit ) + { + // is this a data bit? + if( byte.signals.size() < 8 ) + { + byte.value <<= 1; + if( s.bus_signal == SMB_One ) + byte.value |= 1; + + byte.signals.push_back( s ); + } + else + { + // translate zero/one to ack/nack + if( s.bus_signal == SMB_Zero ) + { + byte.is_acked = true; + s.bus_signal = SMB_ACK; + } + else + { + byte.is_acked = false; + s.bus_signal = SMB_NACK; + } + + // remember the ACK/NACK signal + byte.signals.push_back( s ); + + // add byte to command/packet + if( !packet.chunks.empty() ) + packet.chunks.back().push_back( byte ); + } + } + else + { + // on a Start signal begin a new chunk + if( s.bus_signal == SMB_Start ) + { + if( packet.chunks.empty() ) + packet.first_start = s; + + packet.chunks.push_back( std::vector() ); + } + } + + // create the markers + s.AddMarkers( mResults.get(), mSettings.mSMBCLK, mSettings.mSMBDAT ); + + // branch on decode level + if( mSettings.mDecodeLevel == DL_Signals ) + { + mResults->AddFrame( s.ToFrame() ); + } + else if( mSettings.mDecodeLevel == DL_Bytes ) + { + if( byte.IsComplete() ) + { + if( packet.chunks.back().size() == 1 ) // if this is the first byte of the packet + mResults->AddFrame( byte.ToAddrFrame( NULL ) ); + else + mResults->AddFrame( byte.ToFrame() ); + } + } + else if( mSettings.mDecodeLevel == DL_SMBus || mSettings.mDecodeLevel == DL_PMBus || mSettings.mDecodeLevel == DL_SmartBattery ) + { + if( s.bus_signal == SMB_Stop ) + { + // make frames for the transaction + + packet.stop = s; + + // first try the SMBus protocols + bool found_match = false; + int pcnt; + for( pcnt = 0; pcnt < NUM_SMBUS_PROTOCOLS && !found_match; ++pcnt ) + { + if( packet.MatchesProtocol( SMBusProtocols + pcnt, calcPEC ) ) + { + // packet.CreateDescFrames(mResults.get(), SMBusProtocols + pcnt, 0); + packet.CreateFrames( mResults.get(), SMBusProtocols + pcnt, calcPEC, mSettings.mDecodeLevel ); + found_match = true; + } + } + + // do the PMBus specific protocols + if( !found_match && mSettings.mDecodeLevel == DL_PMBus ) + { + for( pcnt = 0; pcnt < NUM_PMBUS_PROTOCOLS && !found_match; ++pcnt ) + { + if( packet.MatchesProtocol( PMBusProtocols + pcnt, calcPEC ) ) + { + // packet.CreateDescFrames(mResults.get(), PMBusProtocols + pcnt, 0); + packet.CreateFrames( mResults.get(), PMBusProtocols + pcnt, calcPEC, mSettings.mDecodeLevel ); + found_match = true; + } + } + + if( !found_match && packet.MatchesGroupCommand( calcPEC ) ) + { + // packet.CreateDescFrames(mResults.get(), NULL, 1); + packet.CreateFramesForGroupCommand( mResults.get(), calcPEC ); + found_match = true; + } + } + + // if we have not recognized this packet, just add raw data frames + if( !found_match ) + { + // packet.CreateDescFrames(mResults.get(), NULL, 2); + packet.CreateFramesForRawData( mResults.get(), calcPEC ); + } + + packet.Clear(); + } + } + + if( byte.signals.size() == 9 || !is_bit ) + byte.Clear(); + + mResults->CommitResults(); + + ReportProgress( mSMBDAT->GetSampleNumber() ); + } } bool SMBusAnalyzer::NeedsRerun() { - return false; + return false; } -U32 SMBusAnalyzer::GenerateSimulationData(U64 minimum_sample_index, U32 device_sample_rate, SimulationChannelDescriptor** simulation_channels) +U32 SMBusAnalyzer::GenerateSimulationData( U64 minimum_sample_index, U32 device_sample_rate, + SimulationChannelDescriptor** simulation_channels ) { - if (!mSimulationInitilized) - { - mSimulationDataGenerator.Initialize(GetSimulationSampleRate(), &mSettings); - mSimulationInitilized = true; - } + if( !mSimulationInitilized ) + { + mSimulationDataGenerator.Initialize( GetSimulationSampleRate(), &mSettings ); + mSimulationInitilized = true; + } - return mSimulationDataGenerator.GenerateSimulationData(minimum_sample_index, device_sample_rate, simulation_channels); + return mSimulationDataGenerator.GenerateSimulationData( minimum_sample_index, device_sample_rate, simulation_channels ); } U32 SMBusAnalyzer::GetMinimumSampleRateHz() { - return 1000000; + return 1000000; } const char* SMBusAnalyzer::GetAnalyzerName() const { - return ::GetAnalyzerName(); + return ::GetAnalyzerName(); } const char* GetAnalyzerName() { - return "SMBus"; + return "SMBus"; } Analyzer* CreateAnalyzer() { - return new SMBusAnalyzer(); + return new SMBusAnalyzer(); } -void DestroyAnalyzer(Analyzer* analyzer) +void DestroyAnalyzer( Analyzer* analyzer ) { - delete analyzer; + delete analyzer; } diff --git a/src/SMBusAnalyzer.h b/src/SMBusAnalyzer.h index b9d948d..af9bc2c 100644 --- a/src/SMBusAnalyzer.h +++ b/src/SMBusAnalyzer.h @@ -11,43 +11,41 @@ class SMBusAnalyzer : public Analyzer2 { -public: - SMBusAnalyzer(); - virtual ~SMBusAnalyzer(); - virtual void WorkerThread(); + public: + SMBusAnalyzer(); + virtual ~SMBusAnalyzer(); + virtual void WorkerThread(); - virtual U32 GenerateSimulationData(U64 newest_sample_requested, U32 sample_rate, SimulationChannelDescriptor** simulation_channels); - virtual U32 GetMinimumSampleRateHz(); + virtual U32 GenerateSimulationData( U64 newest_sample_requested, U32 sample_rate, SimulationChannelDescriptor** simulation_channels ); + virtual U32 GetMinimumSampleRateHz(); - virtual const char* GetAnalyzerName() const; - virtual bool NeedsRerun(); + virtual const char* GetAnalyzerName() const; + virtual bool NeedsRerun(); - // helpers - AnalyzerChannelData* GetNearestTransitionChannel(); - AnalyzerChannelData* AdvanceAllTo(U64 toSample); + // helpers + AnalyzerChannelData* GetNearestTransitionChannel(); + AnalyzerChannelData* AdvanceAllTo( U64 toSample ); - // returns true if it state is a Zero or a One, false for Start or stop - bool GetSignal(SMBusSignalState& state); + // returns true if it state is a Zero or a One, false for Start or stop + bool GetSignal( SMBusSignalState& state ); - virtual void SetupResults(); + virtual void SetupResults(); -protected: // functions + protected: // functions + protected: // vars + SMBusAnalyzerSettings mSettings; + std::auto_ptr mResults; -protected: // vars + AnalyzerChannelData* mSMBDAT; + AnalyzerChannelData* mSMBCLK; - SMBusAnalyzerSettings mSettings; - std::auto_ptr mResults; + SMBusSimulationDataGenerator mSimulationDataGenerator; - AnalyzerChannelData* mSMBDAT; - AnalyzerChannelData* mSMBCLK; - - SMBusSimulationDataGenerator mSimulationDataGenerator; - - bool mSimulationInitilized; + bool mSimulationInitilized; }; extern "C" ANALYZER_EXPORT const char* __cdecl GetAnalyzerName(); extern "C" ANALYZER_EXPORT Analyzer* __cdecl CreateAnalyzer(); -extern "C" ANALYZER_EXPORT void __cdecl DestroyAnalyzer(Analyzer* analyzer); +extern "C" ANALYZER_EXPORT void __cdecl DestroyAnalyzer( Analyzer* analyzer ); -#endif // SMBUS_ANALYZER_H \ No newline at end of file +#endif // SMBUS_ANALYZER_H \ No newline at end of file diff --git a/src/SMBusAnalyzerResults.cpp b/src/SMBusAnalyzerResults.cpp index 47494b8..7111acd 100644 --- a/src/SMBusAnalyzerResults.cpp +++ b/src/SMBusAnalyzerResults.cpp @@ -11,505 +11,529 @@ #include "SMBusAnalyzerSettings.h" #include "SMBusCommands.h" -SMBusAnalyzerResults::SMBusAnalyzerResults(SMBusAnalyzer* analyzer, SMBusAnalyzerSettings* settings) -: mSettings(settings), - mAnalyzer(analyzer) -{} - -SMBusAnalyzerResults::~SMBusAnalyzerResults() -{} - -struct BitFieldDesc +SMBusAnalyzerResults::SMBusAnalyzerResults( SMBusAnalyzer* analyzer, SMBusAnalyzerSettings* settings ) + : mSettings( settings ), mAnalyzer( analyzer ) { - int bit_number; - const char* bit_name; -}; +} -const BitFieldDesc BatteryModeBits[] = +SMBusAnalyzerResults::~SMBusAnalyzerResults() { - { 0, "INTERNAL_CHARGE_CONTROLLER"}, - { 1, "PRIMARY_BATTERY_SUPPORT"}, - { 7, "CONDITION_FLAG"}, - { 8, "CHARGE_CONTROLLER_ENABLED"}, - { 9, "PRIMARY_BATTERY"}, - {13, "ALARM_MODE"}, - {14, "CHARGER_MODE"}, - {15, "CAPACITY_MODE"}, - - {0, 0} -}; +} -const BitFieldDesc BatteryStatusBits[] = +struct BitFieldDesc { - {15, "OVER CHARGED ALARM"}, - {14, "TERMINATE CHARGE ALARM"}, - {12, "OVER TEMP ALARM"}, - {11, "TERMINATE DISCHARGE ALARM"}, - {9, "REMAINING CAPACITY ALARM"}, - {8, "REMAINING TIME ALARM"}, - {7, "INITIALIZED"}, - {6, "DISCHARGING"}, - {5, "FULLY CHARGED"}, - {4, "FULLY DISCHARGED"}, - - {0, 0} + int bit_number; + const char* bit_name; }; -const char* ErrorCodesDesc[] = -{ - "OK", - "Busy", - "ReservedCommand", - "UnsupportedCommand", - "AccessDenied", - "Overflow/Underflow", - "BadSize", - "UnknownError", +const BitFieldDesc BatteryModeBits[] = { { 0, "INTERNAL_CHARGE_CONTROLLER" }, + { 1, "PRIMARY_BATTERY_SUPPORT" }, + { 7, "CONDITION_FLAG" }, + { 8, "CHARGE_CONTROLLER_ENABLED" }, + { 9, "PRIMARY_BATTERY" }, + { 13, "ALARM_MODE" }, + { 14, "CHARGER_MODE" }, + { 15, "CAPACITY_MODE" }, + + { 0, 0 } }; + +const BitFieldDesc BatteryStatusBits[] = { { 15, "OVER CHARGED ALARM" }, + { 14, "TERMINATE CHARGE ALARM" }, + { 12, "OVER TEMP ALARM" }, + { 11, "TERMINATE DISCHARGE ALARM" }, + { 9, "REMAINING CAPACITY ALARM" }, + { 8, "REMAINING TIME ALARM" }, + { 7, "INITIALIZED" }, + { 6, "DISCHARGING" }, + { 5, "FULLY CHARGED" }, + { 4, "FULLY DISCHARGED" }, + + { 0, 0 } }; + +const char* ErrorCodesDesc[] = { + "OK", "Busy", "ReservedCommand", "UnsupportedCommand", "AccessDenied", "Overflow/Underflow", "BadSize", "UnknownError", }; -void BitFieldToDescAll(const BitFieldDesc* bfld, U64 val, std::vector& desc) +void BitFieldToDescAll( const BitFieldDesc* bfld, U64 val, std::vector& desc ) { - desc.clear(); + desc.clear(); - while (bfld->bit_name) - { - desc.push_back(bfld->bit_name); - desc.back() += "="; + while( bfld->bit_name ) + { + desc.push_back( bfld->bit_name ); + desc.back() += "="; - if (val & U16(1 << bfld->bit_number)) - desc.back() += "1"; - else - desc.back() += "0"; + if( val & U16( 1 << bfld->bit_number ) ) + desc.back() += "1"; + else + desc.back() += "0"; - ++bfld; - } + ++bfld; + } } -void SMBusAnalyzerResults::AddResultStringsFromVector(const std::string& prefix, const std::vector& v, const std::string& postfix, std::vector& results) +void SMBusAnalyzerResults::AddResultStringsFromVector( const std::string& prefix, const std::vector& v, + const std::string& postfix, std::vector& results ) { - results.clear(); - - results.push_back(prefix + "..."); - - std::string str; - for (std::vector::const_iterator vi(v.begin()); - vi != v.end(); ++vi) - { - str += *vi; - - if (vi + 1 < v.end() || !postfix.empty()) - { - str += ", "; - results.push_back(prefix + str + "..."); - } else { - results.push_back(prefix + str); - } - } - - if (!postfix.empty()) - results.push_back(prefix + str + postfix); + results.clear(); + + results.push_back( prefix + "..." ); + + std::string str; + for( std::vector::const_iterator vi( v.begin() ); vi != v.end(); ++vi ) + { + str += *vi; + + if( vi + 1 < v.end() || !postfix.empty() ) + { + str += ", "; + results.push_back( prefix + str + "..." ); + } + else + { + results.push_back( prefix + str ); + } + } + + if( !postfix.empty() ) + results.push_back( prefix + str + postfix ); } -void SMBusAnalyzerResults::GetBubbleText(const Frame& f, DisplayBase display_base, std::vector& results) +void SMBusAnalyzerResults::GetBubbleText( const Frame& f, DisplayBase display_base, std::vector& results ) { - results.clear(); - - if (f.mType == SMB_Start) - { - if (mSettings->mDecodeLevel == DL_Signals) - results.push_back("Start"); - } else if (f.mType == SMB_Stop) { - if (mSettings->mDecodeLevel == DL_Signals) - results.push_back("Stop"); - } else if (f.mType == SMB_Zero) - results.push_back("0"); - else if (f.mType == SMB_One) - results.push_back("1"); - else if (f.mType == SMB_ACK) - results.push_back("ACK"); - else if (f.mType == SMB_NACK) - results.push_back("NACK"); - else if (f.mType == FT_Byte) { - - std::string num(int2str_sal(f.mData1, display_base, 8)); - results.push_back("Byte " + num + ((f.mFlags & F_IsAcked) ? " ACK" : " NACK")); - results.push_back("Byte " + num + ((f.mFlags & F_IsAcked) ? " A" : " N")); - results.push_back(num + ((f.mFlags & F_IsAcked) ? " A" : " N")); - results.push_back(num); - - } else if (f.mType == FT_Word) { - - std::string num(int2str_sal(f.mData1, display_base, 16)); - - results.push_back("Word " + num + ((f.mFlags & F_IsAcked) ? " ACK" : " NACK")); - results.push_back("Word " + num + ((f.mFlags & F_IsAcked) ? " A" : " N")); - results.push_back(num + ((f.mFlags & F_IsAcked) ? " A" : " N")); - results.push_back(num); - - } else if (f.mType == FT_PEC) { - - std::string readPEC(int2str_sal(f.mData1, display_base, 8)); - std::string calcedPEC(int2str_sal(f.mData2, display_base, 8)); - - if (f.mData1 == f.mData2) - { - results.push_back("PEC " + readPEC + " OK"); - results.push_back(readPEC + " OK"); - results.push_back("PEC OK"); - } else { - results.push_back("Bad PEC " + readPEC + " should be " + calcedPEC); - results.push_back(readPEC + " bad PEC!"); - results.push_back("Bad PEC!"); - } - - results.push_back(readPEC); - - } else if (f.mType == FT_Address) { - - std::string addr(int2str_sal(f.mData1, display_base, 7)); - std::string rw = (f.mFlags & F_IsRead) ? "Read " : "Write "; - std::string rw_s = (f.mFlags & F_IsRead) ? "R " : "W "; - const bool is_acked = f.mFlags & F_IsAcked; - - results.push_back(rw + "address " + addr + (is_acked ? " ACK" : " NACK")); - results.push_back(addr); - results.push_back(addr + (is_acked ? " A" : " N")); - results.push_back(rw + addr + (is_acked ? " A" : " N")); - results.push_back(rw + addr + (is_acked ? " ACK" : " NACK")); - results.push_back(rw_s + addr + (is_acked ? " A" : " N")); - results.push_back(rw_s + addr + (is_acked ? " ACK" : " NACK")); - results.push_back(rw_s + "addr " + addr + (is_acked ? " A" : " N")); - results.push_back(rw_s + "address " + addr + (is_acked ? " ACK" : " NACK")); - results.push_back(rw + "addr " + addr + (is_acked ? " A" : " N")); - - } else if (f.mType == FT_ByteCount) { - - std::string bc_str(int2str_sal(f.mData1, display_base, 7)); - - results.push_back("Byte count " + bc_str); - results.push_back("ByteCount " + bc_str); - results.push_back("Cnt " + bc_str); - results.push_back(bc_str); - - } else if (f.mType == FT_CmdPMBus || f.mType == FT_CmdSmartBattery) { - - CommandDesc cmd; - if (f.mType == FT_CmdPMBus) - cmd = GetPMBusCommandDesc(f.mData1); - else - cmd = GetSmartBatteryCommandDesc(f.mData1); - - std::string id(int2str_sal(f.mData1, display_base, 8)); - - results.push_back("Command " + std::string(cmd.name) + " " + id); - results.push_back(id); - results.push_back(cmd.name); - results.push_back("Cmd " + std::string(cmd.name)); - results.push_back("Cmd " + id); - results.push_back("Cmd " + std::string(cmd.name) + " " + id); - results.push_back("Command " + std::string(cmd.name)); - results.push_back("Command " + id); - - } else if (f.mType == FT_CmdSMBus) { - - std::string id(int2str_sal(f.mData1, display_base, 8)); - - results.push_back("Command " + id); - results.push_back(id); - results.push_back("Cmd " + id); - - } else if (f.mType == FT_PMBusCapability) { - - U8 bm = (U8) f.mData1; - const char* pec_desc = (f.mData1 & 0x80 ? "PEC unsupported, " : "PEC supported, "); - - const char* max_bus_speed; - switch (f.mData1 & 0x60) - { - case 0x00: max_bus_speed = "Max bus speed 100KHz, "; break; - case 0x20: max_bus_speed = "Max bus speed 400KHz, "; break; - default: max_bus_speed = "Reserved, "; break; - } - - const char* smbalert_desc = ((f.mData1 & 0x10) ? "SMBALERT supported " : "SMBALERT unsupported "); - - std::string val_str(int2str_sal(f.mData1, display_base, 8)); - - results.push_back("Capability data byte " + val_str + " " + pec_desc + max_bus_speed + smbalert_desc); - results.push_back(val_str); - results.push_back("Capability " + val_str + " ..."); - results.push_back("Capability " + val_str + " " + pec_desc + "..."); - results.push_back("Capability " + val_str + " " + pec_desc + max_bus_speed + "..."); - - } else if (f.mType == FT_PMBusQuery) { - - U8 bm = (U8) f.mData1; - - // command supported? - if (bm & 0x80) - { - std::string for_write = (bm & 0x40) ? "for write" : ""; - const char* for_read = (bm & 0x20) ? "for read" : ""; - const char* format; - switch (bm & 0x1C) - { - case 0x00: format = "Linear data format"; break; - case 0x0C: format = "Direct mode format"; break; - case 0x14: format = "VID mode format"; break; - case 0x18: format = "Manufacturer specific format"; break; - default: format = "error format"; break; - } - - results.push_back("Command supported " + for_write + for_read + format); - results.push_back("Command supported " + for_write + for_read + "..."); - results.push_back("Command supported " + for_write + "..."); - results.push_back("Command supported..."); - results.push_back("Supported..."); - } else { - results.push_back("Command unsupported"); - results.push_back("unsupported"); - } - - } else if (f.mType == FT_PMBusWriteProtect) { - - switch (f.mData1) - { - case 0x80: - results.push_back("Disable all writes except to the WRITE_PROTECT command"); - results.push_back("Disable..."); - results.push_back("Disable all except WRITE_PROTECT..."); - break; - case 0x40: - results.push_back("Disable all writes except to the WRITE_PROTECT, OPERATION and PAGE commands"); - results.push_back("Disable..."); - results.push_back("Disable all except WRITE_PROTECT, OPERATION and PAGE..."); - break; - case 0x20: - results.push_back("Disable all writes except to the WRITE_PROTECT, OPERATION, PAGE, ON_OFF_CONFIG and VOUT_COMMAND commands"); - results.push_back("Disable..."); - results.push_back("Disable all except WRITE_PROTECT, OPERATION, PAGE, ON_OFF_CONFIG and VOUT_COMMAND..."); - break; - case 0x00: - results.push_back("Enable writes to all commands"); - results.push_back("Enable..."); - results.push_back("Enable all writes..."); - break; - default: - results.push_back("Invalid Data!"); - results.push_back("Invalid"); - break; - } - - } else if (f.mType == FT_PMBusOperation) { - - std::string unit_on_off = ""; - const char* margin_state = ""; - switch (f.mData1 & 0xC0) - { - case 0x00: - unit_on_off = "Immediate off (no sequencing)"; - margin_state = "N/A"; - break; - case 0x40: - unit_on_off = "Soft off (with sequencing)"; - margin_state = "N/A"; - break; - case 0x80: - unit_on_off = "Unit on"; - switch (f.mData1 & 0x3C) - { - case 0x14: margin_state = "Margin low (ignore fault)"; break; - case 0x18: margin_state = "Margin low (act on fault)"; break; - case 0x24: margin_state = "Margin high (ignore fault)"; break; - case 0x28: margin_state = "Margin high (act on fault)"; break; - } - break; - } - - std::string val(int2str_sal(f.mData1, display_base, 8)); - - results.push_back("Operation params " + val + " Unit on/off=" + unit_on_off + ", Margin state=" + margin_state); - results.push_back(val); - results.push_back("Operation params..."); - results.push_back(unit_on_off + ", " + margin_state); - - } else if (f.mType == FT_PMBusOnOffConfig) { - - std::string val(int2str_sal(f.mData1, display_base, 8)); - - const char* power_up = (f.mData1 & 0x10) ? "CONTROL pin and OPERATION command" : "Any time"; - const char* commands = (f.mData1 & 0x08) ? "Acknowledge on/off portion of OPERATION command" : "Ignore on/off portion of OPERATION command"; - const char* control = (f.mData1 & 0x04) ? "CONTROL pin required to operate" : "Ignore CONTROL pin"; - const char* polarity = (f.mData1 & 0x02) ? "CONTROL is active high" : "CONTROL is active low"; - const char* action = (f.mData1 & 0x01) ? "Turn off the output as fast as possible" : "Use programmed turn off delay"; - - results.push_back("Params " + val + ": " + power_up + ", " + commands + ", " + polarity + ", " + action); - results.push_back(val); - results.push_back("Params " + val + ": " + power_up); - results.push_back("Params " + val + ": " + power_up + "..."); - results.push_back("Params " + val + ": " + power_up + ", " + commands + "..."); - results.push_back("Params " + val + ": " + power_up + ", " + commands + ", " + polarity + "..."); - - } else if (f.mType == FT_PMBusVoutMode) { - - std::string val(int2str_sal(f.mData1, display_base, 8)); - - U8 mode = U8(f.mData1 >> 5); - U8 param = U8(f.mData1 & 0x1F); - - results.push_back(val + " Mode: "+ int2str_sal(mode, display_base, 3) + " Param: " + int2str_sal(param, display_base, 5)); - results.push_back(val); - - } else if (f.mType == FT_SmartBattBatteryMode) { - - std::string val(int2str_sal(f.mData1, display_base, 16)); - std::string prefix("BatteryMode " + val + " "); - - std::vector v; - BitFieldToDescAll(BatteryModeBits, f.mData1, v); - - AddResultStringsFromVector(prefix, v, "", results); - - // make sure the longest description is the first in the vector - std::swap(results.front(), results.back()); - - results.push_back(val); - - } else if (f.mType == FT_SmartBattBatteryStatus) { - - std::string val(int2str_sal(f.mData1, display_base, 16)); - std::string prefix("BatteryStatus " + val + " "); - - std::vector v; - BitFieldToDescAll(BatteryStatusBits, f.mData1, v); - - AddResultStringsFromVector(prefix, v, "ErrorCode=" + std::string(ErrorCodesDesc[f.mData1 & 0x07]), results); - - // make sure the longest description is the first in the vector - std::swap(results.front(), results.back()); - - results.push_back(val); - - } else if (f.mType == FT_SmartBattSpecificationInfo) { - - std::string val(int2str_sal(f.mData1, display_base, 16)); - - U8 revision = f.mData1 & 0x0f; - U8 version = (f.mData1 >> 4) & 0x0f; - U8 vscale = (f.mData1 >> 8) & 0x0f; - U8 ipscale = U8(f.mData1 >> 12); - - results.push_back("SpecificationInfo " + val + " Revision=" + int2str_sal(revision, display_base, 4) - + " Version=" + int2str_sal(version, display_base, 4) - + " VScale=" + int2str_sal(vscale, display_base, 4) - + " IPScale=" + int2str_sal(ipscale, display_base, 4)); - - results.push_back("SpecificationInfo " + val + " Revision=" + int2str_sal(revision, display_base, 4) + ", ..."); - - results.push_back("SpecificationInfo " + val + " Revision=" + int2str_sal(revision, display_base, 4) - + " Version=" + int2str_sal(version, display_base, 4) + ", ..."); - - results.push_back("SpecificationInfo " + val + " Revision=" + int2str_sal(revision, display_base, 4) - + " Version=" + int2str_sal(version, display_base, 4) - + " VScale=" + int2str_sal(vscale, display_base, 4) + ", ..."); - - results.push_back(val); - results.push_back("SpecificationInfo " + val + " ..."); - - } else if (f.mType == FT_SmartBattManufactureDate) { - - std::string val(int2str_sal(f.mData1, display_base, 16)); - - U8 day = f.mData1 & 0x1f; // 5 bits - U8 month = (f.mData1 >> 5) & 0x0f; // 4 bits - U16 year = (f.mData1 >> 9) & 0x9f; // 7 bits - year += 1980; - - std::string date(int2str(month) + "/" + int2str(day) + "/" + int2str(year)); - - results.push_back("ManufactureDate " + val + " " + date); - results.push_back("ManufactureDate " + val + " ..."); - results.push_back(val); - - } else { - results.push_back("."); - } - - // add the protocol name - if (f.mData2 != 0 && f.mType != FT_PEC) - { - const SMBusProtocol* pProt = (const SMBusProtocol*) f.mData2; - results.front() += " Protocol=" + std::string(pProt->name); - } + results.clear(); + + if( f.mType == SMB_Start ) + { + if( mSettings->mDecodeLevel == DL_Signals ) + results.push_back( "Start" ); + } + else if( f.mType == SMB_Stop ) + { + if( mSettings->mDecodeLevel == DL_Signals ) + results.push_back( "Stop" ); + } + else if( f.mType == SMB_Zero ) + results.push_back( "0" ); + else if( f.mType == SMB_One ) + results.push_back( "1" ); + else if( f.mType == SMB_ACK ) + results.push_back( "ACK" ); + else if( f.mType == SMB_NACK ) + results.push_back( "NACK" ); + else if( f.mType == FT_Byte ) + { + std::string num( int2str_sal( f.mData1, display_base, 8 ) ); + results.push_back( "Byte " + num + ( ( f.mFlags & F_IsAcked ) ? " ACK" : " NACK" ) ); + results.push_back( "Byte " + num + ( ( f.mFlags & F_IsAcked ) ? " A" : " N" ) ); + results.push_back( num + ( ( f.mFlags & F_IsAcked ) ? " A" : " N" ) ); + results.push_back( num ); + } + else if( f.mType == FT_Word ) + { + std::string num( int2str_sal( f.mData1, display_base, 16 ) ); + + results.push_back( "Word " + num + ( ( f.mFlags & F_IsAcked ) ? " ACK" : " NACK" ) ); + results.push_back( "Word " + num + ( ( f.mFlags & F_IsAcked ) ? " A" : " N" ) ); + results.push_back( num + ( ( f.mFlags & F_IsAcked ) ? " A" : " N" ) ); + results.push_back( num ); + } + else if( f.mType == FT_PEC ) + { + std::string readPEC( int2str_sal( f.mData1, display_base, 8 ) ); + std::string calcedPEC( int2str_sal( f.mData2, display_base, 8 ) ); + + if( f.mData1 == f.mData2 ) + { + results.push_back( "PEC " + readPEC + " OK" ); + results.push_back( readPEC + " OK" ); + results.push_back( "PEC OK" ); + } + else + { + results.push_back( "Bad PEC " + readPEC + " should be " + calcedPEC ); + results.push_back( readPEC + " bad PEC!" ); + results.push_back( "Bad PEC!" ); + } + + results.push_back( readPEC ); + } + else if( f.mType == FT_Address ) + { + std::string addr( int2str_sal( f.mData1, display_base, 7 ) ); + std::string rw = ( f.mFlags & F_IsRead ) ? "Read " : "Write "; + std::string rw_s = ( f.mFlags & F_IsRead ) ? "R " : "W "; + const bool is_acked = f.mFlags & F_IsAcked; + + results.push_back( rw + "address " + addr + ( is_acked ? " ACK" : " NACK" ) ); + results.push_back( addr ); + results.push_back( addr + ( is_acked ? " A" : " N" ) ); + results.push_back( rw + addr + ( is_acked ? " A" : " N" ) ); + results.push_back( rw + addr + ( is_acked ? " ACK" : " NACK" ) ); + results.push_back( rw_s + addr + ( is_acked ? " A" : " N" ) ); + results.push_back( rw_s + addr + ( is_acked ? " ACK" : " NACK" ) ); + results.push_back( rw_s + "addr " + addr + ( is_acked ? " A" : " N" ) ); + results.push_back( rw_s + "address " + addr + ( is_acked ? " ACK" : " NACK" ) ); + results.push_back( rw + "addr " + addr + ( is_acked ? " A" : " N" ) ); + } + else if( f.mType == FT_ByteCount ) + { + std::string bc_str( int2str_sal( f.mData1, display_base, 7 ) ); + + results.push_back( "Byte count " + bc_str ); + results.push_back( "ByteCount " + bc_str ); + results.push_back( "Cnt " + bc_str ); + results.push_back( bc_str ); + } + else if( f.mType == FT_CmdPMBus || f.mType == FT_CmdSmartBattery ) + { + CommandDesc cmd; + if( f.mType == FT_CmdPMBus ) + cmd = GetPMBusCommandDesc( f.mData1 ); + else + cmd = GetSmartBatteryCommandDesc( f.mData1 ); + + std::string id( int2str_sal( f.mData1, display_base, 8 ) ); + + results.push_back( "Command " + std::string( cmd.name ) + " " + id ); + results.push_back( id ); + results.push_back( cmd.name ); + results.push_back( "Cmd " + std::string( cmd.name ) ); + results.push_back( "Cmd " + id ); + results.push_back( "Cmd " + std::string( cmd.name ) + " " + id ); + results.push_back( "Command " + std::string( cmd.name ) ); + results.push_back( "Command " + id ); + } + else if( f.mType == FT_CmdSMBus ) + { + std::string id( int2str_sal( f.mData1, display_base, 8 ) ); + + results.push_back( "Command " + id ); + results.push_back( id ); + results.push_back( "Cmd " + id ); + } + else if( f.mType == FT_PMBusCapability ) + { + U8 bm = ( U8 )f.mData1; + const char* pec_desc = ( f.mData1 & 0x80 ? "PEC unsupported, " : "PEC supported, " ); + + const char* max_bus_speed; + switch( f.mData1 & 0x60 ) + { + case 0x00: + max_bus_speed = "Max bus speed 100KHz, "; + break; + case 0x20: + max_bus_speed = "Max bus speed 400KHz, "; + break; + default: + max_bus_speed = "Reserved, "; + break; + } + + const char* smbalert_desc = ( ( f.mData1 & 0x10 ) ? "SMBALERT supported " : "SMBALERT unsupported " ); + + std::string val_str( int2str_sal( f.mData1, display_base, 8 ) ); + + results.push_back( "Capability data byte " + val_str + " " + pec_desc + max_bus_speed + smbalert_desc ); + results.push_back( val_str ); + results.push_back( "Capability " + val_str + " ..." ); + results.push_back( "Capability " + val_str + " " + pec_desc + "..." ); + results.push_back( "Capability " + val_str + " " + pec_desc + max_bus_speed + "..." ); + } + else if( f.mType == FT_PMBusQuery ) + { + U8 bm = ( U8 )f.mData1; + + // command supported? + if( bm & 0x80 ) + { + std::string for_write = ( bm & 0x40 ) ? "for write" : ""; + const char* for_read = ( bm & 0x20 ) ? "for read" : ""; + const char* format; + switch( bm & 0x1C ) + { + case 0x00: + format = "Linear data format"; + break; + case 0x0C: + format = "Direct mode format"; + break; + case 0x14: + format = "VID mode format"; + break; + case 0x18: + format = "Manufacturer specific format"; + break; + default: + format = "error format"; + break; + } + + results.push_back( "Command supported " + for_write + for_read + format ); + results.push_back( "Command supported " + for_write + for_read + "..." ); + results.push_back( "Command supported " + for_write + "..." ); + results.push_back( "Command supported..." ); + results.push_back( "Supported..." ); + } + else + { + results.push_back( "Command unsupported" ); + results.push_back( "unsupported" ); + } + } + else if( f.mType == FT_PMBusWriteProtect ) + { + switch( f.mData1 ) + { + case 0x80: + results.push_back( "Disable all writes except to the WRITE_PROTECT command" ); + results.push_back( "Disable..." ); + results.push_back( "Disable all except WRITE_PROTECT..." ); + break; + case 0x40: + results.push_back( "Disable all writes except to the WRITE_PROTECT, OPERATION and PAGE commands" ); + results.push_back( "Disable..." ); + results.push_back( "Disable all except WRITE_PROTECT, OPERATION and PAGE..." ); + break; + case 0x20: + results.push_back( "Disable all writes except to the WRITE_PROTECT, OPERATION, PAGE, ON_OFF_CONFIG and VOUT_COMMAND commands" ); + results.push_back( "Disable..." ); + results.push_back( "Disable all except WRITE_PROTECT, OPERATION, PAGE, ON_OFF_CONFIG and VOUT_COMMAND..." ); + break; + case 0x00: + results.push_back( "Enable writes to all commands" ); + results.push_back( "Enable..." ); + results.push_back( "Enable all writes..." ); + break; + default: + results.push_back( "Invalid Data!" ); + results.push_back( "Invalid" ); + break; + } + } + else if( f.mType == FT_PMBusOperation ) + { + std::string unit_on_off = ""; + const char* margin_state = ""; + switch( f.mData1 & 0xC0 ) + { + case 0x00: + unit_on_off = "Immediate off (no sequencing)"; + margin_state = "N/A"; + break; + case 0x40: + unit_on_off = "Soft off (with sequencing)"; + margin_state = "N/A"; + break; + case 0x80: + unit_on_off = "Unit on"; + switch( f.mData1 & 0x3C ) + { + case 0x14: + margin_state = "Margin low (ignore fault)"; + break; + case 0x18: + margin_state = "Margin low (act on fault)"; + break; + case 0x24: + margin_state = "Margin high (ignore fault)"; + break; + case 0x28: + margin_state = "Margin high (act on fault)"; + break; + } + break; + } + + std::string val( int2str_sal( f.mData1, display_base, 8 ) ); + + results.push_back( "Operation params " + val + " Unit on/off=" + unit_on_off + ", Margin state=" + margin_state ); + results.push_back( val ); + results.push_back( "Operation params..." ); + results.push_back( unit_on_off + ", " + margin_state ); + } + else if( f.mType == FT_PMBusOnOffConfig ) + { + std::string val( int2str_sal( f.mData1, display_base, 8 ) ); + + const char* power_up = ( f.mData1 & 0x10 ) ? "CONTROL pin and OPERATION command" : "Any time"; + const char* commands = + ( f.mData1 & 0x08 ) ? "Acknowledge on/off portion of OPERATION command" : "Ignore on/off portion of OPERATION command"; + const char* control = ( f.mData1 & 0x04 ) ? "CONTROL pin required to operate" : "Ignore CONTROL pin"; + const char* polarity = ( f.mData1 & 0x02 ) ? "CONTROL is active high" : "CONTROL is active low"; + const char* action = ( f.mData1 & 0x01 ) ? "Turn off the output as fast as possible" : "Use programmed turn off delay"; + + results.push_back( "Params " + val + ": " + power_up + ", " + commands + ", " + polarity + ", " + action ); + results.push_back( val ); + results.push_back( "Params " + val + ": " + power_up ); + results.push_back( "Params " + val + ": " + power_up + "..." ); + results.push_back( "Params " + val + ": " + power_up + ", " + commands + "..." ); + results.push_back( "Params " + val + ": " + power_up + ", " + commands + ", " + polarity + "..." ); + } + else if( f.mType == FT_PMBusVoutMode ) + { + std::string val( int2str_sal( f.mData1, display_base, 8 ) ); + + U8 mode = U8( f.mData1 >> 5 ); + U8 param = U8( f.mData1 & 0x1F ); + + results.push_back( val + " Mode: " + int2str_sal( mode, display_base, 3 ) + " Param: " + int2str_sal( param, display_base, 5 ) ); + results.push_back( val ); + } + else if( f.mType == FT_SmartBattBatteryMode ) + { + std::string val( int2str_sal( f.mData1, display_base, 16 ) ); + std::string prefix( "BatteryMode " + val + " " ); + + std::vector v; + BitFieldToDescAll( BatteryModeBits, f.mData1, v ); + + AddResultStringsFromVector( prefix, v, "", results ); + + // make sure the longest description is the first in the vector + std::swap( results.front(), results.back() ); + + results.push_back( val ); + } + else if( f.mType == FT_SmartBattBatteryStatus ) + { + std::string val( int2str_sal( f.mData1, display_base, 16 ) ); + std::string prefix( "BatteryStatus " + val + " " ); + + std::vector v; + BitFieldToDescAll( BatteryStatusBits, f.mData1, v ); + + AddResultStringsFromVector( prefix, v, "ErrorCode=" + std::string( ErrorCodesDesc[ f.mData1 & 0x07 ] ), results ); + + // make sure the longest description is the first in the vector + std::swap( results.front(), results.back() ); + + results.push_back( val ); + } + else if( f.mType == FT_SmartBattSpecificationInfo ) + { + std::string val( int2str_sal( f.mData1, display_base, 16 ) ); + + U8 revision = f.mData1 & 0x0f; + U8 version = ( f.mData1 >> 4 ) & 0x0f; + U8 vscale = ( f.mData1 >> 8 ) & 0x0f; + U8 ipscale = U8( f.mData1 >> 12 ); + + results.push_back( "SpecificationInfo " + val + " Revision=" + int2str_sal( revision, display_base, 4 ) + + " Version=" + int2str_sal( version, display_base, 4 ) + " VScale=" + int2str_sal( vscale, display_base, 4 ) + + " IPScale=" + int2str_sal( ipscale, display_base, 4 ) ); + + results.push_back( "SpecificationInfo " + val + " Revision=" + int2str_sal( revision, display_base, 4 ) + ", ..." ); + + results.push_back( "SpecificationInfo " + val + " Revision=" + int2str_sal( revision, display_base, 4 ) + + " Version=" + int2str_sal( version, display_base, 4 ) + ", ..." ); + + results.push_back( "SpecificationInfo " + val + " Revision=" + int2str_sal( revision, display_base, 4 ) + " Version=" + + int2str_sal( version, display_base, 4 ) + " VScale=" + int2str_sal( vscale, display_base, 4 ) + ", ..." ); + + results.push_back( val ); + results.push_back( "SpecificationInfo " + val + " ..." ); + } + else if( f.mType == FT_SmartBattManufactureDate ) + { + std::string val( int2str_sal( f.mData1, display_base, 16 ) ); + + U8 day = f.mData1 & 0x1f; // 5 bits + U8 month = ( f.mData1 >> 5 ) & 0x0f; // 4 bits + U16 year = ( f.mData1 >> 9 ) & 0x9f; // 7 bits + year += 1980; + + std::string date( int2str( month ) + "/" + int2str( day ) + "/" + int2str( year ) ); + + results.push_back( "ManufactureDate " + val + " " + date ); + results.push_back( "ManufactureDate " + val + " ..." ); + results.push_back( val ); + } + else + { + results.push_back( "." ); + } + + // add the protocol name + if( f.mData2 != 0 && f.mType != FT_PEC ) + { + const SMBusProtocol* pProt = ( const SMBusProtocol* )f.mData2; + results.front() += " Protocol=" + std::string( pProt->name ); + } } -void SMBusAnalyzerResults::GenerateBubbleText(U64 frame_index, Channel& channel, DisplayBase display_base) +void SMBusAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base ) { - ClearResultStrings(); - Frame f = GetFrame(frame_index); + ClearResultStrings(); + Frame f = GetFrame( frame_index ); - std::vector results; - GetBubbleText(f, display_base, results); + std::vector results; + GetBubbleText( f, display_base, results ); - for (std::vector::iterator ri(results.begin()); ri != results.end(); ++ri) - AddResultString(ri->c_str()); + for( std::vector::iterator ri( results.begin() ); ri != results.end(); ++ri ) + AddResultString( ri->c_str() ); } -void SMBusAnalyzerResults::GenerateExportFile(const char* file, DisplayBase display_base, U32 export_type_user_id) +void SMBusAnalyzerResults::GenerateExportFile( const char* file, DisplayBase display_base, U32 export_type_user_id ) { - std::ofstream file_stream(file, std::ios::out); - - U64 trigger_sample = mAnalyzer->GetTriggerSample(); - U32 sample_rate = mAnalyzer->GetSampleRate(); - - Frame f; - char time_str[128]; - const U64 num_frames = GetNumFrames(); - std::vector results; - for (U64 fcnt = 0; fcnt < num_frames; fcnt++) - { - f = GetFrame(fcnt); // get the frame - - if (f.mType == FT_Start) - { - // make the time string - AnalyzerHelpers::GetTimeString(f.mStartingSampleInclusive, trigger_sample, sample_rate, time_str, sizeof(time_str)); - file_stream << "Start: " << time_str << std::endl; - } else if (f.mType == FT_Stop) { - file_stream << std::endl; - } else { - GetBubbleText(f, display_base, results); - file_stream << results.front() << std::endl; - } - - if (UpdateExportProgressAndCheckForCancel(fcnt, num_frames)) - return; - } - - // end - UpdateExportProgressAndCheckForCancel(num_frames, num_frames); + std::ofstream file_stream( file, std::ios::out ); + + U64 trigger_sample = mAnalyzer->GetTriggerSample(); + U32 sample_rate = mAnalyzer->GetSampleRate(); + + Frame f; + char time_str[ 128 ]; + const U64 num_frames = GetNumFrames(); + std::vector results; + for( U64 fcnt = 0; fcnt < num_frames; fcnt++ ) + { + f = GetFrame( fcnt ); // get the frame + + if( f.mType == FT_Start ) + { + // make the time string + AnalyzerHelpers::GetTimeString( f.mStartingSampleInclusive, trigger_sample, sample_rate, time_str, sizeof( time_str ) ); + file_stream << "Start: " << time_str << std::endl; + } + else if( f.mType == FT_Stop ) + { + file_stream << std::endl; + } + else + { + GetBubbleText( f, display_base, results ); + file_stream << results.front() << std::endl; + } + + if( UpdateExportProgressAndCheckForCancel( fcnt, num_frames ) ) + return; + } + + // end + UpdateExportProgressAndCheckForCancel( num_frames, num_frames ); } -void SMBusAnalyzerResults::GenerateFrameTabularText(U64 frame_index, DisplayBase display_base) +void SMBusAnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base ) { - ClearTabularText(); + ClearTabularText(); - std::vector results; - Frame frame = GetFrame(frame_index); - GetBubbleText(frame, display_base, results); + std::vector results; + Frame frame = GetFrame( frame_index ); + GetBubbleText( frame, display_base, results ); - if (!results.empty()) - AddTabularText(results.front().c_str()); + if( !results.empty() ) + AddTabularText( results.front().c_str() ); } -void SMBusAnalyzerResults::GeneratePacketTabularText(U64 packet_id, DisplayBase display_base) +void SMBusAnalyzerResults::GeneratePacketTabularText( U64 packet_id, DisplayBase display_base ) { - ClearResultStrings(); - AddResultString("not supported"); + ClearResultStrings(); + AddResultString( "not supported" ); } -void SMBusAnalyzerResults::GenerateTransactionTabularText(U64 transaction_id, DisplayBase display_base) +void SMBusAnalyzerResults::GenerateTransactionTabularText( U64 transaction_id, DisplayBase display_base ) { - ClearResultStrings(); - AddResultString("not supported"); + ClearResultStrings(); + AddResultString( "not supported" ); } diff --git a/src/SMBusAnalyzerResults.h b/src/SMBusAnalyzerResults.h index a9deabb..7f1b69f 100644 --- a/src/SMBusAnalyzerResults.h +++ b/src/SMBusAnalyzerResults.h @@ -8,28 +8,27 @@ class SMBusAnalyzer; class SMBusAnalyzerSettings; -class SMBusAnalyzerResults: public AnalyzerResults +class SMBusAnalyzerResults : public AnalyzerResults { -public: - SMBusAnalyzerResults(SMBusAnalyzer* analyzer, SMBusAnalyzerSettings* settings); - virtual ~SMBusAnalyzerResults(); + public: + SMBusAnalyzerResults( SMBusAnalyzer* analyzer, SMBusAnalyzerSettings* settings ); + virtual ~SMBusAnalyzerResults(); - virtual void GenerateBubbleText(U64 frame_index, Channel& channel, DisplayBase display_base); - virtual void GenerateExportFile(const char* file, DisplayBase display_base, U32 export_type_user_id); + virtual void GenerateBubbleText( U64 frame_index, Channel& channel, DisplayBase display_base ); + virtual void GenerateExportFile( const char* file, DisplayBase display_base, U32 export_type_user_id ); - virtual void GenerateFrameTabularText(U64 frame_index, DisplayBase display_base); - virtual void GeneratePacketTabularText(U64 packet_id, DisplayBase display_base); - virtual void GenerateTransactionTabularText(U64 transaction_id, DisplayBase display_base); + virtual void GenerateFrameTabularText( U64 frame_index, DisplayBase display_base ); + virtual void GeneratePacketTabularText( U64 packet_id, DisplayBase display_base ); + virtual void GenerateTransactionTabularText( U64 transaction_id, DisplayBase display_base ); -protected: // functions + protected: // functions + protected: // vars + SMBusAnalyzerSettings* mSettings; + SMBusAnalyzer* mAnalyzer; -protected: // vars - - SMBusAnalyzerSettings* mSettings; - SMBusAnalyzer* mAnalyzer; - - void AddResultStringsFromVector(const std::string& prefix, const std::vector& v, const std::string& postfix, std::vector& results); - void GetBubbleText(const Frame& f, DisplayBase display_base, std::vector& results); + void AddResultStringsFromVector( const std::string& prefix, const std::vector& v, const std::string& postfix, + std::vector& results ); + void GetBubbleText( const Frame& f, DisplayBase display_base, std::vector& results ); }; -#endif // SMBUS_ANALYZER_RESULTS_H \ No newline at end of file +#endif // SMBUS_ANALYZER_RESULTS_H \ No newline at end of file diff --git a/src/SMBusAnalyzerSettings.cpp b/src/SMBusAnalyzerSettings.cpp index 3054d8d..4b0c30d 100644 --- a/src/SMBusAnalyzerSettings.cpp +++ b/src/SMBusAnalyzerSettings.cpp @@ -4,124 +4,122 @@ #include "SMBusAnalyzerResults.h" #include "SMBusTypes.h" -SMBusAnalyzerSettings::SMBusAnalyzerSettings() -: mSMBDAT(UNDEFINED_CHANNEL), - mSMBCLK(UNDEFINED_CHANNEL), - mDecodeLevel(DL_Signals) +SMBusAnalyzerSettings::SMBusAnalyzerSettings() : mSMBDAT( UNDEFINED_CHANNEL ), mSMBCLK( UNDEFINED_CHANNEL ), mDecodeLevel( DL_Signals ) { - // init the interface - mSMBDATInterface.SetTitleAndTooltip("SMBDAT", "SMBus data line"); - mSMBDATInterface.SetChannel(mSMBDAT); + // init the interface + mSMBDATInterface.SetTitleAndTooltip( "SMBDAT", "SMBus data line" ); + mSMBDATInterface.SetChannel( mSMBDAT ); - mSMBCLKInterface.SetTitleAndTooltip("SMBCLK", "SMBus clock line"); - mSMBCLKInterface.SetChannel(mSMBCLK); + mSMBCLKInterface.SetTitleAndTooltip( "SMBCLK", "SMBus clock line" ); + mSMBCLKInterface.SetChannel( mSMBCLK ); - mDecodeLevelInterface.SetTitleAndTooltip("SMBus decode level", "Type of decoded SMBus data"); - mDecodeLevelInterface.AddNumber(DL_Signals, "Signals", "Decode the signal states"); - mDecodeLevelInterface.AddNumber(DL_Bytes, "Bytes", "Decode the data as raw bytes"); - mDecodeLevelInterface.AddNumber(DL_SMBus, "SMBus", "Decode SMBus basic protocol"); - mDecodeLevelInterface.AddNumber(DL_PMBus, "PMBus", "Decode PMBus commands"); - mDecodeLevelInterface.AddNumber(DL_SmartBattery, "Smart Battery", "Decode Smart Battery commands"); + mDecodeLevelInterface.SetTitleAndTooltip( "SMBus decode level", "Type of decoded SMBus data" ); + mDecodeLevelInterface.AddNumber( DL_Signals, "Signals", "Decode the signal states" ); + mDecodeLevelInterface.AddNumber( DL_Bytes, "Bytes", "Decode the data as raw bytes" ); + mDecodeLevelInterface.AddNumber( DL_SMBus, "SMBus", "Decode SMBus basic protocol" ); + mDecodeLevelInterface.AddNumber( DL_PMBus, "PMBus", "Decode PMBus commands" ); + mDecodeLevelInterface.AddNumber( DL_SmartBattery, "Smart Battery", "Decode Smart Battery commands" ); - mDecodeLevelInterface.SetNumber(DL_Signals); + mDecodeLevelInterface.SetNumber( DL_Signals ); - mCalculatePECInterface.SetValue(true); - mCalculatePECInterface.SetTitleAndTooltip("Calculate PEC on packets", "true - calculate PEC, false - no PEC on packets"); + mCalculatePECInterface.SetValue( true ); + mCalculatePECInterface.SetTitleAndTooltip( "Calculate PEC on packets", "true - calculate PEC, false - no PEC on packets" ); - // add the interfaces - AddInterface(&mSMBDATInterface); - AddInterface(&mSMBCLKInterface); - AddInterface(&mDecodeLevelInterface); - AddInterface(&mCalculatePECInterface); + // add the interfaces + AddInterface( &mSMBDATInterface ); + AddInterface( &mSMBCLKInterface ); + AddInterface( &mDecodeLevelInterface ); + AddInterface( &mCalculatePECInterface ); - // describe export - AddExportOption(0, "Export as text file"); - AddExportExtension(0, "text", "txt"); + // describe export + AddExportOption( 0, "Export as text file" ); + AddExportExtension( 0, "text", "txt" ); - ClearChannels(); + ClearChannels(); - AddChannel(mSMBDAT, "SMBDAT", false); - AddChannel(mSMBCLK, "SMBCLK", false); + AddChannel( mSMBDAT, "SMBDAT", false ); + AddChannel( mSMBCLK, "SMBCLK", false ); } SMBusAnalyzerSettings::~SMBusAnalyzerSettings() -{} +{ +} bool SMBusAnalyzerSettings::SetSettingsFromInterfaces() { - if (mSMBDATInterface.GetChannel() == UNDEFINED_CHANNEL) - { - SetErrorText("Please select an input for the SMBDAT."); - return false; - } + if( mSMBDATInterface.GetChannel() == UNDEFINED_CHANNEL ) + { + SetErrorText( "Please select an input for the SMBDAT." ); + return false; + } - if (mSMBCLKInterface.GetChannel() == UNDEFINED_CHANNEL) - { - SetErrorText("Please select an input for the SMBCLK."); - return false; - } + if( mSMBCLKInterface.GetChannel() == UNDEFINED_CHANNEL ) + { + SetErrorText( "Please select an input for the SMBCLK." ); + return false; + } - std::vector all_channels{mSMBDATInterface.GetChannel(), mSMBCLKInterface.GetChannel()}; + std::vector all_channels{ mSMBDATInterface.GetChannel(), mSMBCLKInterface.GetChannel() }; - if (AnalyzerHelpers::DoChannelsOverlap(all_channels.data(), all_channels.size())) - { - SetErrorText("Please select different inputs for the channels."); - return false; - } + if( AnalyzerHelpers::DoChannelsOverlap( all_channels.data(), all_channels.size() ) ) + { + SetErrorText( "Please select different inputs for the channels." ); + return false; + } - mSMBDAT = mSMBDATInterface.GetChannel(); - mSMBCLK = mSMBCLKInterface.GetChannel(); + mSMBDAT = mSMBDATInterface.GetChannel(); + mSMBCLK = mSMBCLKInterface.GetChannel(); - ClearChannels(); + ClearChannels(); - AddChannel(mSMBDAT, "SMBDAT", true); - AddChannel(mSMBCLK, "SMBCLK", true); + AddChannel( mSMBDAT, "SMBDAT", true ); + AddChannel( mSMBCLK, "SMBCLK", true ); - mDecodeLevel = SMBusDecodeLevel(int(mDecodeLevelInterface.GetNumber())); + mDecodeLevel = SMBusDecodeLevel( int( mDecodeLevelInterface.GetNumber() ) ); - return true; + return true; } void SMBusAnalyzerSettings::UpdateInterfacesFromSettings() { - mSMBDATInterface.SetChannel(mSMBDAT); - mSMBCLKInterface.SetChannel(mSMBCLK); + mSMBDATInterface.SetChannel( mSMBDAT ); + mSMBCLKInterface.SetChannel( mSMBCLK ); - mDecodeLevelInterface.SetNumber(mDecodeLevel); + mDecodeLevelInterface.SetNumber( mDecodeLevel ); } -void SMBusAnalyzerSettings::LoadSettings(const char* settings) +void SMBusAnalyzerSettings::LoadSettings( const char* settings ) { - SimpleArchive text_archive; - text_archive.SetString(settings); + SimpleArchive text_archive; + text_archive.SetString( settings ); - text_archive >> mSMBDAT; - text_archive >> mSMBCLK; + text_archive >> mSMBDAT; + text_archive >> mSMBCLK; - int s; - text_archive >> s; - mDecodeLevel = SMBusDecodeLevel(s); + int s; + text_archive >> s; + mDecodeLevel = SMBusDecodeLevel( s ); - ClearChannels(); + ClearChannels(); - AddChannel(mSMBDAT, "SMBDAT", true); - AddChannel(mSMBCLK, "SMBCLK", true); + AddChannel( mSMBDAT, "SMBDAT", true ); + AddChannel( mSMBCLK, "SMBCLK", true ); - bool calc_pec; - text_archive >> calc_pec; - mCalculatePECInterface.SetValue(calc_pec); + bool calc_pec; + text_archive >> calc_pec; + mCalculatePECInterface.SetValue( calc_pec ); - UpdateInterfacesFromSettings(); + UpdateInterfacesFromSettings(); } const char* SMBusAnalyzerSettings::SaveSettings() { - SimpleArchive text_archive; + SimpleArchive text_archive; - text_archive << mSMBDAT; - text_archive << mSMBCLK; - text_archive << mDecodeLevel; - text_archive << mCalculatePECInterface.GetValue(); + text_archive << mSMBDAT; + text_archive << mSMBCLK; + text_archive << mDecodeLevel; + text_archive << mCalculatePECInterface.GetValue(); - return SetReturnString(text_archive.GetString()); + return SetReturnString( text_archive.GetString() ); } diff --git a/src/SMBusAnalyzerSettings.h b/src/SMBusAnalyzerSettings.h index 6c4850e..eb45705 100644 --- a/src/SMBusAnalyzerSettings.h +++ b/src/SMBusAnalyzerSettings.h @@ -8,33 +8,32 @@ class SMBusAnalyzerSettings : public AnalyzerSettings { -public: - SMBusAnalyzerSettings(); - virtual ~SMBusAnalyzerSettings(); + public: + SMBusAnalyzerSettings(); + virtual ~SMBusAnalyzerSettings(); - virtual bool SetSettingsFromInterfaces(); - virtual void LoadSettings(const char* settings); - virtual const char* SaveSettings(); + virtual bool SetSettingsFromInterfaces(); + virtual void LoadSettings( const char* settings ); + virtual const char* SaveSettings(); - void UpdateInterfacesFromSettings(); + void UpdateInterfacesFromSettings(); - Channel mSMBDAT; - Channel mSMBCLK; + Channel mSMBDAT; + Channel mSMBCLK; - SMBusDecodeLevel mDecodeLevel; + SMBusDecodeLevel mDecodeLevel; - bool CalcPEC() - { - return mCalculatePECInterface.GetValue(); - } + bool CalcPEC() + { + return mCalculatePECInterface.GetValue(); + } -protected: - AnalyzerSettingInterfaceChannel mSMBDATInterface; - AnalyzerSettingInterfaceChannel mSMBCLKInterface; - - AnalyzerSettingInterfaceNumberList mDecodeLevelInterface; - AnalyzerSettingInterfaceBool mCalculatePECInterface; + protected: + AnalyzerSettingInterfaceChannel mSMBDATInterface; + AnalyzerSettingInterfaceChannel mSMBCLKInterface; + AnalyzerSettingInterfaceNumberList mDecodeLevelInterface; + AnalyzerSettingInterfaceBool mCalculatePECInterface; }; -#endif // SMBUS_ANALYZER_SETTINGS_H +#endif // SMBUS_ANALYZER_SETTINGS_H diff --git a/src/SMBusCommands.cpp b/src/SMBusCommands.cpp index 836504e..3830db0 100644 --- a/src/SMBusCommands.cpp +++ b/src/SMBusCommands.cpp @@ -7,327 +7,327 @@ // appendix 1 PMBus specs const CommandDesc pmbus_cmds[] = { -{0x00, "PAGE", 1, ReadWrite, FT_Undefined}, -{0x01, "OPERATION", 1, ReadWrite, FT_PMBusOperation}, -{0x02, "ON_OFF_CONFIG", 1, ReadWrite, FT_PMBusOnOffConfig}, -{0x03, "CLEAR_FAULTS", 0, Send, FT_Undefined}, -{0x04, "PHASE", 1, ReadWrite, FT_Undefined}, -{0x05, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x06, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x07, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x08, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x09, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x0A, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x0B, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x0C, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x0D, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x0E, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x0F, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x10, "WRITE_PROTECT", 1, ReadWrite, FT_PMBusWriteProtect}, -{0x11, "STORE_DEFAULT_ALL", 0, Send, FT_Undefined}, -{0x12, "RESTORE_DEFAULT_ALL", 0, Send, FT_Undefined}, -{0x13, "STORE_DEFAULT_CODE", 1, Write, FT_Undefined}, -{0x14, "RESTORE_DEFAULT_CODE", 1, Write, FT_Undefined}, -{0x15, "STORE_USER_ALL", 0, Send, FT_Undefined}, -{0x16, "RESTORE_USER_ALL", 0, Send, FT_Undefined}, -{0x17, "STORE_USER_CODE", 1, Write, FT_Undefined}, -{0x18, "RESTORE_USER_CODE", 1, Write, FT_Undefined}, -{0x19, "CAPABILITY", 1, Read, FT_PMBusCapability}, -// Block Write-Block Read-Process call See Section 11.13 -{0x1A, "QUERY", Undefined, Undefined, FT_Undefined}, -{0x1B, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x1C, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x1D, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x1E, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x1F, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x20, "VOUT_MODE", 1, ReadWrite, FT_PMBusVoutMode}, -{0x21, "VOUT_COMMAND", 2, ReadWrite, FT_Undefined}, -{0x22, "VOUT_TRIM", 2, ReadWrite, FT_Undefined}, -{0x23, "VOUT_CAL_OFFSET", 2, ReadWrite, FT_Undefined}, -{0x24, "VOUT_MAX", 2, ReadWrite, FT_Undefined}, -{0x25, "VOUT_MARGIN_HIGH", 2, ReadWrite, FT_Undefined}, -{0x26, "VOUT_MARGIN_LOW", 2, ReadWrite, FT_Undefined}, -{0x27, "VOUT_TRANSITION_RATE", 2, ReadWrite, FT_Undefined}, -{0x28, "VOUT_DROOP", 2, ReadWrite, FT_Undefined}, -{0x29, "VOUT_SCALE_LOOP", 2, ReadWrite, FT_Undefined}, -{0x2A, "VOUT_SCALE_MONITOR", 2, ReadWrite, FT_Undefined}, -{0x2B, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x2C, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x2D, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x2E, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x2F, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x30, "COEFFICIENTS", Undefined, Undefined, FT_Undefined}, -{0x31, "POUT_MAX", 2, ReadWrite, FT_Undefined}, -{0x32, "MAX_DUTY", 2, ReadWrite, FT_Undefined}, -{0x33, "FREQUENCY_SWITCH", 2, ReadWrite, FT_Undefined}, -{0x34, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x35, "VIN_ON", 2, ReadWrite, FT_Undefined}, -{0x36, "VIN_OFF", 2, ReadWrite, FT_Undefined}, -{0x37, "INTERLEAVE", 2, ReadWrite, FT_Undefined}, -{0x38, "IOUT_CAL_GAIN", 2, ReadWrite, FT_Undefined}, -{0x39, "IOUT_CAL_OFFSET", 2, ReadWrite, FT_Undefined}, -{0x3A, "FAN_CONFIG_1_2", 1, ReadWrite, FT_Undefined}, -{0x3B, "FAN_COMMAND_1", 2, ReadWrite, FT_Undefined}, -{0x3C, "FAN_COMMAND_2", 2, ReadWrite, FT_Undefined}, -{0x3D, "FAN_CONFIG_3_4", 1, ReadWrite, FT_Undefined}, -{0x3E, "FAN_COMMAND_3", 2, ReadWrite, FT_Undefined}, -{0x3F, "FAN_COMMAND_4", 2, ReadWrite, FT_Undefined}, -{0x40, "VOUT_OV_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x41, "VOUT_OV_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x42, "VOUT_OV_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x43, "VOUT_UV_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x44, "VOUT_UV_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x45, "VOUT_UV_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x46, "IOUT_OC_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x47, "IOUT_OC_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x48, "IOUT_OC_LV_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x49, "IOUT_OC_LV_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x4A, "IOUT_OC_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x4B, "IOUT_UC_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x4C, "IOUT_UC_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x4D, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x4E, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x4F, "OT_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x50, "OT_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x51, "OT_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x52, "UT_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x53, "UT_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x54, "UT_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x55, "VIN_OV_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x56, "VIN_OV_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x57, "VIN_OV_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x58, "VIN_UV_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x59, "VIN_UV_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x5A, "VIN_UV_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x5B, "IIN_OC_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x5C, "IIN_OC_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x5D, "IIN_OC_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x5E, "POWER_GOOD_ON", 2, ReadWrite, FT_Undefined}, -{0x5F, "POWER_GOOD_OFF", 2, ReadWrite, FT_Undefined}, -{0x60, "TON_DELAY", 2, ReadWrite, FT_Undefined}, -{0x61, "TON_RISE", 2, ReadWrite, FT_Undefined}, -{0x62, "TON_MAX_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x63, "TON_MAX_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x64, "TOFF_DELAY", 2, ReadWrite, FT_Undefined}, -{0x65, "TOFF_FALL", 2, ReadWrite, FT_Undefined}, -{0x66, "TOFF_MAX_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x67, "Reserved", Undefined, Undefined, FT_Undefined}, // (Was Used In Revision 1.0) -{0x68, "POUT_OP_FAULT_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x69, "POUT_OP_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined}, -{0x6A, "POUT_OP_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x6B, "PIN_OP_WARN_LIMIT", 2, ReadWrite, FT_Undefined}, -{0x6C, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x6D, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x6E, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x6F, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x70, "Reserved (Test Input Fuse A)", Undefined, Undefined, FT_Undefined}, -{0x71, "Reserved (Test Input Fuse B)", Undefined, Undefined, FT_Undefined}, -{0x72, "Reserved (Test Input OR-ing A)", Undefined, Undefined, FT_Undefined}, -{0x73, "Reserved (Test Input OR-ing B)", Undefined, Undefined, FT_Undefined}, -{0x74, "Reserved (Test Output OR-ing)", Undefined, Undefined, FT_Undefined}, -{0x75, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x76, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x77, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x78, "STATUS_BYTE", 1, Read, FT_Undefined}, -{0x79, "STATUS_WORD", 2, Read, FT_Undefined}, -{0x7A, "STATUS_VOUT", 1, Read, FT_Undefined}, -{0x7B, "STATUS_IOUT", 1, Read, FT_Undefined}, -{0x7C, "STATUS_INPUT", 1, Read, FT_Undefined}, -{0x7D, "STATUS_TEMPERATURE", 1, Read, FT_Undefined}, -{0x7E, "STATUS_CML", 1, Read, FT_Undefined}, -{0x7F, "STATUS_OTHER", 1, Read, FT_Undefined}, -{0x80, "STATUS_MFR_SPECIFIC", 1, Read, FT_Undefined}, -{0x81, "STATUS_FANS_1_2", 1, Read, FT_Undefined}, -{0x82, "STATUS_FANS_3_4", 1, Read, FT_Undefined}, -{0x83, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x84, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x85, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x86, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x87, "Reserved", Undefined, Undefined, FT_Undefined}, -{0x88, "READ_VIN", 2, Read, FT_Undefined}, -{0x89, "READ_IIN", 2, Read, FT_Undefined}, -{0x8A, "READ_VCAP", 2, Read, FT_Undefined}, -{0x8B, "READ_VOUT", 2, Read, FT_Undefined}, -{0x8C, "READ_IOUT", 2, Read, FT_Undefined}, -{0x8D, "READ_TEMPERATURE_1", 2, Read, FT_Undefined}, -{0x8E, "READ_TEMPERATURE_2", 2, Read, FT_Undefined}, -{0x8F, "READ_TEMPERATURE_3", 2, Read, FT_Undefined}, -{0x90, "READ_FAN_SPEED_1", 2, Read, FT_Undefined}, -{0x91, "READ_FAN_SPEED_2", 2, Read, FT_Undefined}, -{0x92, "READ_FAN_SPEED_3", 2, Read, FT_Undefined}, -{0x93, "READ_FAN_SPEED_4", 2, Read, FT_Undefined}, -{0x94, "READ_DUTY_CYCLE", 2, Read, FT_Undefined}, -{0x95, "READ_FREQUENCY", 2, Read, FT_Undefined}, -{0x96, "READ_POUT", 2, Read, FT_Undefined}, -{0x97, "READ_PIN", 2, Read, FT_Undefined}, -{0x98, "PMBUS_REVISION", 1, Read, FT_Undefined}, -{0x99, "MFR_ID", LengthVariable, ReadWrite, FT_Undefined}, -{0x9A, "MFR_MODEL", LengthVariable, ReadWrite, FT_Undefined}, -{0x9B, "MFR_REVISION", LengthVariable, ReadWrite, FT_Undefined}, -{0x9C, "MFR_LOCATION", LengthVariable, ReadWrite, FT_Undefined}, -{0x9D, "MFR_DATE", LengthVariable, ReadWrite, FT_Undefined}, -{0x9E, "MFR_SERIAL", LengthVariable, ReadWrite, FT_Undefined}, -{0x9F, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xA0, "MFR_VIN_MIN", 2, Read, FT_Undefined}, -{0xA1, "MFR_VIN_MAX", 2, Read, FT_Undefined}, -{0xA2, "MFR_IIN_MAX", 2, Read, FT_Undefined}, -{0xA3, "MFR_PIN_MAX", 2, Read, FT_Undefined}, -{0xA4, "MFR_VOUT_MIN", 2, Read, FT_Undefined}, -{0xA5, "MFR_VOUT_MAX", 2, Read, FT_Undefined}, -{0xA6, "MFR_IOUT_MAX", 2, Read, FT_Undefined}, -{0xA7, "MFR_POUT_MAX", 2, Read, FT_Undefined}, -{0xA8, "MFR_TAMBIENT_MAX", 2, Read, FT_Undefined}, -{0xA9, "MFR_TAMBIENT_MIN", 2, Read, FT_Undefined}, -{0xAA, "MFR_EFFICIENCY_LL", 14, ReadWrite, FT_Undefined}, -{0xAB, "MFR_EFFICIENCY_HL", 14, ReadWrite, FT_Undefined}, -{0xAC, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xAD, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xAE, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xAF, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xB0, "USER_DATA_00", LengthVariable, ReadWrite, FT_Undefined}, -{0xB1, "USER_DATA_01", LengthVariable, ReadWrite, FT_Undefined}, -{0xB2, "USER_DATA_02", LengthVariable, ReadWrite, FT_Undefined}, -{0xB3, "USER_DATA_03", LengthVariable, ReadWrite, FT_Undefined}, -{0xB4, "USER_DATA_04", LengthVariable, ReadWrite, FT_Undefined}, -{0xB5, "USER_DATA_05", LengthVariable, ReadWrite, FT_Undefined}, -{0xB6, "USER_DATA_06", LengthVariable, ReadWrite, FT_Undefined}, -{0xB7, "USER_DATA_07", LengthVariable, ReadWrite, FT_Undefined}, -{0xB8, "USER_DATA_08", LengthVariable, ReadWrite, FT_Undefined}, -{0xB9, "USER_DATA_09", LengthVariable, ReadWrite, FT_Undefined}, -{0xBA, "USER_DATA_10", LengthVariable, ReadWrite, FT_Undefined}, -{0xBB, "USER_DATA_11", LengthVariable, ReadWrite, FT_Undefined}, -{0xBC, "USER_DATA_12", LengthVariable, ReadWrite, FT_Undefined}, -{0xBD, "USER_DATA_13", LengthVariable, ReadWrite, FT_Undefined}, -{0xBE, "USER_DATA_14", LengthVariable, ReadWrite, FT_Undefined}, -{0xBF, "USER_DATA_15", LengthVariable, ReadWrite, FT_Undefined}, -{0xC0, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xC1, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xC2, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xC3, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xC4, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xC5, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xC6, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xC7, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xC8, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xC9, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xCA, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xCB, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xCC, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xCD, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xCE, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xCF, "Reserved", Undefined, Undefined, FT_Undefined}, -{0xD0, "MFR_SPECIFIC_00", Undefined, Undefined, FT_Undefined}, -{0xD1, "MFR_SPECIFIC_01", Undefined, Undefined, FT_Undefined}, -{0xD2, "MFR_SPECIFIC_02", Undefined, Undefined, FT_Undefined}, -{0xD3, "MFR_SPECIFIC_03", Undefined, Undefined, FT_Undefined}, -{0xD4, "MFR_SPECIFIC_04", Undefined, Undefined, FT_Undefined}, -{0xD5, "MFR_SPECIFIC_05", Undefined, Undefined, FT_Undefined}, -{0xD6, "MFR_SPECIFIC_06", Undefined, Undefined, FT_Undefined}, -{0xD7, "MFR_SPECIFIC_07", Undefined, Undefined, FT_Undefined}, -{0xD8, "MFR_SPECIFIC_08", Undefined, Undefined, FT_Undefined}, -{0xD9, "MFR_SPECIFIC_09", Undefined, Undefined, FT_Undefined}, -{0xDA, "MFR_SPECIFIC_10", Undefined, Undefined, FT_Undefined}, -{0xDB, "MFR_SPECIFIC_11", Undefined, Undefined, FT_Undefined}, -{0xDD, "MFR_SPECIFIC_13", Undefined, Undefined, FT_Undefined}, -{0xDE, "MFR_SPECIFIC_14", Undefined, Undefined, FT_Undefined}, -{0xDF, "MFR_SPECIFIC_15", Undefined, Undefined, FT_Undefined}, -{0xE0, "MFR_SPECIFIC_16", Undefined, Undefined, FT_Undefined}, -{0xE1, "MFR_SPECIFIC_17", Undefined, Undefined, FT_Undefined}, -{0xE2, "MFR_SPECIFIC_18", Undefined, Undefined, FT_Undefined}, -{0xE3, "MFR_SPECIFIC_19", Undefined, Undefined, FT_Undefined}, -{0xE4, "MFR_SPECIFIC_20", Undefined, Undefined, FT_Undefined}, -{0xE5, "MFR_SPECIFIC_21", Undefined, Undefined, FT_Undefined}, -{0xE6, "MFR_SPECIFIC_22", Undefined, Undefined, FT_Undefined}, -{0xE7, "MFR_SPECIFIC_23", Undefined, Undefined, FT_Undefined}, -{0xE8, "MFR_SPECIFIC_24", Undefined, Undefined, FT_Undefined}, -{0xE9, "MFR_SPECIFIC_25", Undefined, Undefined, FT_Undefined}, -{0xEA, "MFR_SPECIFIC_26", Undefined, Undefined, FT_Undefined}, -{0xEB, "MFR_SPECIFIC_27", Undefined, Undefined, FT_Undefined}, -{0xEC, "MFR_SPECIFIC_28", Undefined, Undefined, FT_Undefined}, -{0xED, "MFR_SPECIFIC_29", Undefined, Undefined, FT_Undefined}, -{0xEE, "MFR_SPECIFIC_30", Undefined, Undefined, FT_Undefined}, -{0xEF, "MFR_SPECIFIC_31", Undefined, Undefined, FT_Undefined}, -{0xF0, "MFR_SPECIFIC_32", Undefined, Undefined, FT_Undefined}, -{0xF1, "MFR_SPECIFIC_33", Undefined, Undefined, FT_Undefined}, -{0xF2, "MFR_SPECIFIC_34", Undefined, Undefined, FT_Undefined}, -{0xF3, "MFR_SPECIFIC_35", Undefined, Undefined, FT_Undefined}, -{0xF4, "MFR_SPECIFIC_36", Undefined, Undefined, FT_Undefined}, -{0xF5, "MFR_SPECIFIC_37", Undefined, Undefined, FT_Undefined}, -{0xF6, "MFR_SPECIFIC_38", Undefined, Undefined, FT_Undefined}, -{0xF7, "MFR_SPECIFIC_39", Undefined, Undefined, FT_Undefined}, -{0xF8, "MFR_SPECIFIC_40", Undefined, Undefined, FT_Undefined}, -{0xF9, "MFR_SPECIFIC_41", Undefined, Undefined, FT_Undefined}, -{0xFA, "MFR_SPECIFIC_42", Undefined, Undefined, FT_Undefined}, -{0xFB, "MFR_SPECIFIC_43", Undefined, Undefined, FT_Undefined}, -{0xFC, "MFR_SPECIFIC_44", Undefined, Undefined, FT_Undefined}, -{0xFD, "MFR_SPECIFIC_45", Undefined, Undefined, FT_Undefined}, -{0xFE, "MFR_SPECIFIC_COMMAND_EXT", Undefined, Undefined, FT_Undefined}, -{0xFF, "PMBUS_COMMAND_EXT", Undefined, Undefined, FT_Undefined}, + { 0x00, "PAGE", 1, ReadWrite, FT_Undefined }, + { 0x01, "OPERATION", 1, ReadWrite, FT_PMBusOperation }, + { 0x02, "ON_OFF_CONFIG", 1, ReadWrite, FT_PMBusOnOffConfig }, + { 0x03, "CLEAR_FAULTS", 0, Send, FT_Undefined }, + { 0x04, "PHASE", 1, ReadWrite, FT_Undefined }, + { 0x05, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x06, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x07, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x08, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x09, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x0A, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x0B, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x0C, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x0D, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x0E, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x0F, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x10, "WRITE_PROTECT", 1, ReadWrite, FT_PMBusWriteProtect }, + { 0x11, "STORE_DEFAULT_ALL", 0, Send, FT_Undefined }, + { 0x12, "RESTORE_DEFAULT_ALL", 0, Send, FT_Undefined }, + { 0x13, "STORE_DEFAULT_CODE", 1, Write, FT_Undefined }, + { 0x14, "RESTORE_DEFAULT_CODE", 1, Write, FT_Undefined }, + { 0x15, "STORE_USER_ALL", 0, Send, FT_Undefined }, + { 0x16, "RESTORE_USER_ALL", 0, Send, FT_Undefined }, + { 0x17, "STORE_USER_CODE", 1, Write, FT_Undefined }, + { 0x18, "RESTORE_USER_CODE", 1, Write, FT_Undefined }, + { 0x19, "CAPABILITY", 1, Read, FT_PMBusCapability }, + // Block Write-Block Read-Process call See Section 11.13 + { 0x1A, "QUERY", Undefined, Undefined, FT_Undefined }, + { 0x1B, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x1C, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x1D, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x1E, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x1F, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x20, "VOUT_MODE", 1, ReadWrite, FT_PMBusVoutMode }, + { 0x21, "VOUT_COMMAND", 2, ReadWrite, FT_Undefined }, + { 0x22, "VOUT_TRIM", 2, ReadWrite, FT_Undefined }, + { 0x23, "VOUT_CAL_OFFSET", 2, ReadWrite, FT_Undefined }, + { 0x24, "VOUT_MAX", 2, ReadWrite, FT_Undefined }, + { 0x25, "VOUT_MARGIN_HIGH", 2, ReadWrite, FT_Undefined }, + { 0x26, "VOUT_MARGIN_LOW", 2, ReadWrite, FT_Undefined }, + { 0x27, "VOUT_TRANSITION_RATE", 2, ReadWrite, FT_Undefined }, + { 0x28, "VOUT_DROOP", 2, ReadWrite, FT_Undefined }, + { 0x29, "VOUT_SCALE_LOOP", 2, ReadWrite, FT_Undefined }, + { 0x2A, "VOUT_SCALE_MONITOR", 2, ReadWrite, FT_Undefined }, + { 0x2B, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x2C, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x2D, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x2E, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x2F, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x30, "COEFFICIENTS", Undefined, Undefined, FT_Undefined }, + { 0x31, "POUT_MAX", 2, ReadWrite, FT_Undefined }, + { 0x32, "MAX_DUTY", 2, ReadWrite, FT_Undefined }, + { 0x33, "FREQUENCY_SWITCH", 2, ReadWrite, FT_Undefined }, + { 0x34, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x35, "VIN_ON", 2, ReadWrite, FT_Undefined }, + { 0x36, "VIN_OFF", 2, ReadWrite, FT_Undefined }, + { 0x37, "INTERLEAVE", 2, ReadWrite, FT_Undefined }, + { 0x38, "IOUT_CAL_GAIN", 2, ReadWrite, FT_Undefined }, + { 0x39, "IOUT_CAL_OFFSET", 2, ReadWrite, FT_Undefined }, + { 0x3A, "FAN_CONFIG_1_2", 1, ReadWrite, FT_Undefined }, + { 0x3B, "FAN_COMMAND_1", 2, ReadWrite, FT_Undefined }, + { 0x3C, "FAN_COMMAND_2", 2, ReadWrite, FT_Undefined }, + { 0x3D, "FAN_CONFIG_3_4", 1, ReadWrite, FT_Undefined }, + { 0x3E, "FAN_COMMAND_3", 2, ReadWrite, FT_Undefined }, + { 0x3F, "FAN_COMMAND_4", 2, ReadWrite, FT_Undefined }, + { 0x40, "VOUT_OV_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x41, "VOUT_OV_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x42, "VOUT_OV_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x43, "VOUT_UV_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x44, "VOUT_UV_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x45, "VOUT_UV_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x46, "IOUT_OC_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x47, "IOUT_OC_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x48, "IOUT_OC_LV_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x49, "IOUT_OC_LV_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x4A, "IOUT_OC_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x4B, "IOUT_UC_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x4C, "IOUT_UC_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x4D, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x4E, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x4F, "OT_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x50, "OT_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x51, "OT_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x52, "UT_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x53, "UT_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x54, "UT_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x55, "VIN_OV_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x56, "VIN_OV_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x57, "VIN_OV_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x58, "VIN_UV_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x59, "VIN_UV_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x5A, "VIN_UV_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x5B, "IIN_OC_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x5C, "IIN_OC_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x5D, "IIN_OC_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x5E, "POWER_GOOD_ON", 2, ReadWrite, FT_Undefined }, + { 0x5F, "POWER_GOOD_OFF", 2, ReadWrite, FT_Undefined }, + { 0x60, "TON_DELAY", 2, ReadWrite, FT_Undefined }, + { 0x61, "TON_RISE", 2, ReadWrite, FT_Undefined }, + { 0x62, "TON_MAX_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x63, "TON_MAX_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x64, "TOFF_DELAY", 2, ReadWrite, FT_Undefined }, + { 0x65, "TOFF_FALL", 2, ReadWrite, FT_Undefined }, + { 0x66, "TOFF_MAX_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x67, "Reserved", Undefined, Undefined, FT_Undefined }, // (Was Used In Revision 1.0) + { 0x68, "POUT_OP_FAULT_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x69, "POUT_OP_FAULT_RESPONSE", 1, ReadWrite, FT_Undefined }, + { 0x6A, "POUT_OP_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x6B, "PIN_OP_WARN_LIMIT", 2, ReadWrite, FT_Undefined }, + { 0x6C, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x6D, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x6E, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x6F, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x70, "Reserved (Test Input Fuse A)", Undefined, Undefined, FT_Undefined }, + { 0x71, "Reserved (Test Input Fuse B)", Undefined, Undefined, FT_Undefined }, + { 0x72, "Reserved (Test Input OR-ing A)", Undefined, Undefined, FT_Undefined }, + { 0x73, "Reserved (Test Input OR-ing B)", Undefined, Undefined, FT_Undefined }, + { 0x74, "Reserved (Test Output OR-ing)", Undefined, Undefined, FT_Undefined }, + { 0x75, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x76, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x77, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x78, "STATUS_BYTE", 1, Read, FT_Undefined }, + { 0x79, "STATUS_WORD", 2, Read, FT_Undefined }, + { 0x7A, "STATUS_VOUT", 1, Read, FT_Undefined }, + { 0x7B, "STATUS_IOUT", 1, Read, FT_Undefined }, + { 0x7C, "STATUS_INPUT", 1, Read, FT_Undefined }, + { 0x7D, "STATUS_TEMPERATURE", 1, Read, FT_Undefined }, + { 0x7E, "STATUS_CML", 1, Read, FT_Undefined }, + { 0x7F, "STATUS_OTHER", 1, Read, FT_Undefined }, + { 0x80, "STATUS_MFR_SPECIFIC", 1, Read, FT_Undefined }, + { 0x81, "STATUS_FANS_1_2", 1, Read, FT_Undefined }, + { 0x82, "STATUS_FANS_3_4", 1, Read, FT_Undefined }, + { 0x83, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x84, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x85, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x86, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x87, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0x88, "READ_VIN", 2, Read, FT_Undefined }, + { 0x89, "READ_IIN", 2, Read, FT_Undefined }, + { 0x8A, "READ_VCAP", 2, Read, FT_Undefined }, + { 0x8B, "READ_VOUT", 2, Read, FT_Undefined }, + { 0x8C, "READ_IOUT", 2, Read, FT_Undefined }, + { 0x8D, "READ_TEMPERATURE_1", 2, Read, FT_Undefined }, + { 0x8E, "READ_TEMPERATURE_2", 2, Read, FT_Undefined }, + { 0x8F, "READ_TEMPERATURE_3", 2, Read, FT_Undefined }, + { 0x90, "READ_FAN_SPEED_1", 2, Read, FT_Undefined }, + { 0x91, "READ_FAN_SPEED_2", 2, Read, FT_Undefined }, + { 0x92, "READ_FAN_SPEED_3", 2, Read, FT_Undefined }, + { 0x93, "READ_FAN_SPEED_4", 2, Read, FT_Undefined }, + { 0x94, "READ_DUTY_CYCLE", 2, Read, FT_Undefined }, + { 0x95, "READ_FREQUENCY", 2, Read, FT_Undefined }, + { 0x96, "READ_POUT", 2, Read, FT_Undefined }, + { 0x97, "READ_PIN", 2, Read, FT_Undefined }, + { 0x98, "PMBUS_REVISION", 1, Read, FT_Undefined }, + { 0x99, "MFR_ID", LengthVariable, ReadWrite, FT_Undefined }, + { 0x9A, "MFR_MODEL", LengthVariable, ReadWrite, FT_Undefined }, + { 0x9B, "MFR_REVISION", LengthVariable, ReadWrite, FT_Undefined }, + { 0x9C, "MFR_LOCATION", LengthVariable, ReadWrite, FT_Undefined }, + { 0x9D, "MFR_DATE", LengthVariable, ReadWrite, FT_Undefined }, + { 0x9E, "MFR_SERIAL", LengthVariable, ReadWrite, FT_Undefined }, + { 0x9F, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xA0, "MFR_VIN_MIN", 2, Read, FT_Undefined }, + { 0xA1, "MFR_VIN_MAX", 2, Read, FT_Undefined }, + { 0xA2, "MFR_IIN_MAX", 2, Read, FT_Undefined }, + { 0xA3, "MFR_PIN_MAX", 2, Read, FT_Undefined }, + { 0xA4, "MFR_VOUT_MIN", 2, Read, FT_Undefined }, + { 0xA5, "MFR_VOUT_MAX", 2, Read, FT_Undefined }, + { 0xA6, "MFR_IOUT_MAX", 2, Read, FT_Undefined }, + { 0xA7, "MFR_POUT_MAX", 2, Read, FT_Undefined }, + { 0xA8, "MFR_TAMBIENT_MAX", 2, Read, FT_Undefined }, + { 0xA9, "MFR_TAMBIENT_MIN", 2, Read, FT_Undefined }, + { 0xAA, "MFR_EFFICIENCY_LL", 14, ReadWrite, FT_Undefined }, + { 0xAB, "MFR_EFFICIENCY_HL", 14, ReadWrite, FT_Undefined }, + { 0xAC, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xAD, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xAE, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xAF, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xB0, "USER_DATA_00", LengthVariable, ReadWrite, FT_Undefined }, + { 0xB1, "USER_DATA_01", LengthVariable, ReadWrite, FT_Undefined }, + { 0xB2, "USER_DATA_02", LengthVariable, ReadWrite, FT_Undefined }, + { 0xB3, "USER_DATA_03", LengthVariable, ReadWrite, FT_Undefined }, + { 0xB4, "USER_DATA_04", LengthVariable, ReadWrite, FT_Undefined }, + { 0xB5, "USER_DATA_05", LengthVariable, ReadWrite, FT_Undefined }, + { 0xB6, "USER_DATA_06", LengthVariable, ReadWrite, FT_Undefined }, + { 0xB7, "USER_DATA_07", LengthVariable, ReadWrite, FT_Undefined }, + { 0xB8, "USER_DATA_08", LengthVariable, ReadWrite, FT_Undefined }, + { 0xB9, "USER_DATA_09", LengthVariable, ReadWrite, FT_Undefined }, + { 0xBA, "USER_DATA_10", LengthVariable, ReadWrite, FT_Undefined }, + { 0xBB, "USER_DATA_11", LengthVariable, ReadWrite, FT_Undefined }, + { 0xBC, "USER_DATA_12", LengthVariable, ReadWrite, FT_Undefined }, + { 0xBD, "USER_DATA_13", LengthVariable, ReadWrite, FT_Undefined }, + { 0xBE, "USER_DATA_14", LengthVariable, ReadWrite, FT_Undefined }, + { 0xBF, "USER_DATA_15", LengthVariable, ReadWrite, FT_Undefined }, + { 0xC0, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xC1, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xC2, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xC3, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xC4, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xC5, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xC6, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xC7, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xC8, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xC9, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xCA, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xCB, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xCC, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xCD, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xCE, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xCF, "Reserved", Undefined, Undefined, FT_Undefined }, + { 0xD0, "MFR_SPECIFIC_00", Undefined, Undefined, FT_Undefined }, + { 0xD1, "MFR_SPECIFIC_01", Undefined, Undefined, FT_Undefined }, + { 0xD2, "MFR_SPECIFIC_02", Undefined, Undefined, FT_Undefined }, + { 0xD3, "MFR_SPECIFIC_03", Undefined, Undefined, FT_Undefined }, + { 0xD4, "MFR_SPECIFIC_04", Undefined, Undefined, FT_Undefined }, + { 0xD5, "MFR_SPECIFIC_05", Undefined, Undefined, FT_Undefined }, + { 0xD6, "MFR_SPECIFIC_06", Undefined, Undefined, FT_Undefined }, + { 0xD7, "MFR_SPECIFIC_07", Undefined, Undefined, FT_Undefined }, + { 0xD8, "MFR_SPECIFIC_08", Undefined, Undefined, FT_Undefined }, + { 0xD9, "MFR_SPECIFIC_09", Undefined, Undefined, FT_Undefined }, + { 0xDA, "MFR_SPECIFIC_10", Undefined, Undefined, FT_Undefined }, + { 0xDB, "MFR_SPECIFIC_11", Undefined, Undefined, FT_Undefined }, + { 0xDD, "MFR_SPECIFIC_13", Undefined, Undefined, FT_Undefined }, + { 0xDE, "MFR_SPECIFIC_14", Undefined, Undefined, FT_Undefined }, + { 0xDF, "MFR_SPECIFIC_15", Undefined, Undefined, FT_Undefined }, + { 0xE0, "MFR_SPECIFIC_16", Undefined, Undefined, FT_Undefined }, + { 0xE1, "MFR_SPECIFIC_17", Undefined, Undefined, FT_Undefined }, + { 0xE2, "MFR_SPECIFIC_18", Undefined, Undefined, FT_Undefined }, + { 0xE3, "MFR_SPECIFIC_19", Undefined, Undefined, FT_Undefined }, + { 0xE4, "MFR_SPECIFIC_20", Undefined, Undefined, FT_Undefined }, + { 0xE5, "MFR_SPECIFIC_21", Undefined, Undefined, FT_Undefined }, + { 0xE6, "MFR_SPECIFIC_22", Undefined, Undefined, FT_Undefined }, + { 0xE7, "MFR_SPECIFIC_23", Undefined, Undefined, FT_Undefined }, + { 0xE8, "MFR_SPECIFIC_24", Undefined, Undefined, FT_Undefined }, + { 0xE9, "MFR_SPECIFIC_25", Undefined, Undefined, FT_Undefined }, + { 0xEA, "MFR_SPECIFIC_26", Undefined, Undefined, FT_Undefined }, + { 0xEB, "MFR_SPECIFIC_27", Undefined, Undefined, FT_Undefined }, + { 0xEC, "MFR_SPECIFIC_28", Undefined, Undefined, FT_Undefined }, + { 0xED, "MFR_SPECIFIC_29", Undefined, Undefined, FT_Undefined }, + { 0xEE, "MFR_SPECIFIC_30", Undefined, Undefined, FT_Undefined }, + { 0xEF, "MFR_SPECIFIC_31", Undefined, Undefined, FT_Undefined }, + { 0xF0, "MFR_SPECIFIC_32", Undefined, Undefined, FT_Undefined }, + { 0xF1, "MFR_SPECIFIC_33", Undefined, Undefined, FT_Undefined }, + { 0xF2, "MFR_SPECIFIC_34", Undefined, Undefined, FT_Undefined }, + { 0xF3, "MFR_SPECIFIC_35", Undefined, Undefined, FT_Undefined }, + { 0xF4, "MFR_SPECIFIC_36", Undefined, Undefined, FT_Undefined }, + { 0xF5, "MFR_SPECIFIC_37", Undefined, Undefined, FT_Undefined }, + { 0xF6, "MFR_SPECIFIC_38", Undefined, Undefined, FT_Undefined }, + { 0xF7, "MFR_SPECIFIC_39", Undefined, Undefined, FT_Undefined }, + { 0xF8, "MFR_SPECIFIC_40", Undefined, Undefined, FT_Undefined }, + { 0xF9, "MFR_SPECIFIC_41", Undefined, Undefined, FT_Undefined }, + { 0xFA, "MFR_SPECIFIC_42", Undefined, Undefined, FT_Undefined }, + { 0xFB, "MFR_SPECIFIC_43", Undefined, Undefined, FT_Undefined }, + { 0xFC, "MFR_SPECIFIC_44", Undefined, Undefined, FT_Undefined }, + { 0xFD, "MFR_SPECIFIC_45", Undefined, Undefined, FT_Undefined }, + { 0xFE, "MFR_SPECIFIC_COMMAND_EXT", Undefined, Undefined, FT_Undefined }, + { 0xFF, "PMBUS_COMMAND_EXT", Undefined, Undefined, FT_Undefined }, -{ -1, "", Undefined, Undefined, FT_Undefined}, + { -1, "", Undefined, Undefined, FT_Undefined }, }; -const CommandDesc& GetPMBusCommandDesc(U64 id) +const CommandDesc& GetPMBusCommandDesc( U64 id ) { - if (id < 0 || id > 0xff) - return pmbus_cmds[0x100]; + if( id < 0 || id > 0xff ) + return pmbus_cmds[ 0x100 ]; - return pmbus_cmds[id]; + return pmbus_cmds[ id ]; } // from Smart Battery specs rev 1.1 const CommandDesc smart_batt_cmds[] = { -{SBC_ManufacturerAccess, "ManufacturerAccess", 2, ReadWrite, FT_Undefined}, -{SBC_RemainingCapacityAlarm, "RemainingCapacityAlarm", 2, ReadWrite, FT_Undefined}, -{SBC_RemainingTimeAlarm, "RemainingTimeAlarm", 2, ReadWrite, FT_Undefined}, -{SBC_BatteryMode, "BatteryMode", 2, ReadWrite, FT_SmartBattBatteryMode}, -{SBC_AtRate, "AtRate", 2, ReadWrite, FT_Undefined}, -{SBC_AtRateTimeToFull, "AtRateTimeToFull", 2, Read, FT_Undefined}, -{SBC_AtRateTimeToEmpty, "AtRateTimeToEmpty", 2, Read, FT_Undefined}, -{SBC_AtRateOK, "AtRateOK", 2, Read, FT_Undefined}, -{SBC_Temperature, "Temperature", 2, Read, FT_Undefined}, -{SBC_Voltage, "Voltage", 2, Read, FT_Undefined}, -{SBC_Current, "Current", 2, Read, FT_Undefined}, -{SBC_AverageCurrent, "AverageCurrent", 2, Read, FT_Undefined}, -{SBC_MaxError, "MaxError", 2, Read, FT_Undefined}, -{SBC_RelativeStateOfCharge, "RelativeStateOfCharge", 2, Read, FT_Undefined}, -{SBC_AbsoluteStateOfCharge, "AbsoluteStateOfCharge", 2, Read, FT_Undefined}, -{SBC_RemainingCapacity, "RemainingCapacity", 2, Read, FT_Undefined}, -{SBC_FullChargeCapacity, "FullChargeCapacity", 2, Read, FT_Undefined}, -{SBC_RunTimeToEmpty, "RunTimeToEmpty", 2, Read, FT_Undefined}, -{SBC_AverageTimeToEmpty, "AverageTimeToEmpty", 2, Read, FT_Undefined}, -{SBC_AverageTimeToFull, "AverageTimeToFull", 2, Read, FT_Undefined}, -{SBC_ChargingCurrent, "ChargingCurrent", Undefined, Read, FT_Undefined}, -{SBC_ChargingVoltage, "ChargingVoltage", Undefined, Read, FT_Undefined}, -{SBC_BatteryStatus, "BatteryStatus", 2, Read, FT_SmartBattBatteryStatus}, -{SBC_CycleCount, "CycleCount", 2, Read, FT_Undefined}, -{SBC_DesignCapacity, "DesignCapacity", 2, Read, FT_Undefined}, -{SBC_DesignVoltage, "DesignVoltage", 2, Read, FT_Undefined}, -{SBC_SpecificationInfo, "SpecificationInfo", 2, Read, FT_SmartBattSpecificationInfo}, -{SBC_ManufactureDate, "ManufactureDate", 2, Read, FT_SmartBattManufactureDate}, -{SBC_SerialNumber, "SerialNumber", 2, Read, FT_Undefined}, -{SBC_ManufacturerName, "ManufacturerName", LengthVariable, Read, FT_Undefined}, -{SBC_DeviceName, "DeviceName", LengthVariable, Read, FT_Undefined}, -{SBC_DeviceChemistry, "DeviceChemistry", LengthVariable, Read, FT_Undefined}, -{SBC_ManufacturerData, "ManufacturerData", LengthVariable, Read, FT_Undefined}, -{SBC_OptionalMfgFunction5, "OptionalMfgFunction5", Undefined, ReadWrite, FT_Undefined}, -{SBC_OptionalMfgFunction4, "OptionalMfgFunction4", Undefined, ReadWrite, FT_Undefined}, -{SBC_OptionalMfgFunction3, "OptionalMfgFunction3", Undefined, ReadWrite, FT_Undefined}, -{SBC_OptionalMfgFunction2, "OptionalMfgFunction2", Undefined, ReadWrite, FT_Undefined}, -{SBC_OptionalMfgFunction1, "OptionalMfgFunction1", Undefined, ReadWrite, FT_Undefined}, + { SBC_ManufacturerAccess, "ManufacturerAccess", 2, ReadWrite, FT_Undefined }, + { SBC_RemainingCapacityAlarm, "RemainingCapacityAlarm", 2, ReadWrite, FT_Undefined }, + { SBC_RemainingTimeAlarm, "RemainingTimeAlarm", 2, ReadWrite, FT_Undefined }, + { SBC_BatteryMode, "BatteryMode", 2, ReadWrite, FT_SmartBattBatteryMode }, + { SBC_AtRate, "AtRate", 2, ReadWrite, FT_Undefined }, + { SBC_AtRateTimeToFull, "AtRateTimeToFull", 2, Read, FT_Undefined }, + { SBC_AtRateTimeToEmpty, "AtRateTimeToEmpty", 2, Read, FT_Undefined }, + { SBC_AtRateOK, "AtRateOK", 2, Read, FT_Undefined }, + { SBC_Temperature, "Temperature", 2, Read, FT_Undefined }, + { SBC_Voltage, "Voltage", 2, Read, FT_Undefined }, + { SBC_Current, "Current", 2, Read, FT_Undefined }, + { SBC_AverageCurrent, "AverageCurrent", 2, Read, FT_Undefined }, + { SBC_MaxError, "MaxError", 2, Read, FT_Undefined }, + { SBC_RelativeStateOfCharge, "RelativeStateOfCharge", 2, Read, FT_Undefined }, + { SBC_AbsoluteStateOfCharge, "AbsoluteStateOfCharge", 2, Read, FT_Undefined }, + { SBC_RemainingCapacity, "RemainingCapacity", 2, Read, FT_Undefined }, + { SBC_FullChargeCapacity, "FullChargeCapacity", 2, Read, FT_Undefined }, + { SBC_RunTimeToEmpty, "RunTimeToEmpty", 2, Read, FT_Undefined }, + { SBC_AverageTimeToEmpty, "AverageTimeToEmpty", 2, Read, FT_Undefined }, + { SBC_AverageTimeToFull, "AverageTimeToFull", 2, Read, FT_Undefined }, + { SBC_ChargingCurrent, "ChargingCurrent", Undefined, Read, FT_Undefined }, + { SBC_ChargingVoltage, "ChargingVoltage", Undefined, Read, FT_Undefined }, + { SBC_BatteryStatus, "BatteryStatus", 2, Read, FT_SmartBattBatteryStatus }, + { SBC_CycleCount, "CycleCount", 2, Read, FT_Undefined }, + { SBC_DesignCapacity, "DesignCapacity", 2, Read, FT_Undefined }, + { SBC_DesignVoltage, "DesignVoltage", 2, Read, FT_Undefined }, + { SBC_SpecificationInfo, "SpecificationInfo", 2, Read, FT_SmartBattSpecificationInfo }, + { SBC_ManufactureDate, "ManufactureDate", 2, Read, FT_SmartBattManufactureDate }, + { SBC_SerialNumber, "SerialNumber", 2, Read, FT_Undefined }, + { SBC_ManufacturerName, "ManufacturerName", LengthVariable, Read, FT_Undefined }, + { SBC_DeviceName, "DeviceName", LengthVariable, Read, FT_Undefined }, + { SBC_DeviceChemistry, "DeviceChemistry", LengthVariable, Read, FT_Undefined }, + { SBC_ManufacturerData, "ManufacturerData", LengthVariable, Read, FT_Undefined }, + { SBC_OptionalMfgFunction5, "OptionalMfgFunction5", Undefined, ReadWrite, FT_Undefined }, + { SBC_OptionalMfgFunction4, "OptionalMfgFunction4", Undefined, ReadWrite, FT_Undefined }, + { SBC_OptionalMfgFunction3, "OptionalMfgFunction3", Undefined, ReadWrite, FT_Undefined }, + { SBC_OptionalMfgFunction2, "OptionalMfgFunction2", Undefined, ReadWrite, FT_Undefined }, + { SBC_OptionalMfgFunction1, "OptionalMfgFunction1", Undefined, ReadWrite, FT_Undefined }, -{-1, "", Undefined, Undefined, FT_Undefined}, + { -1, "", Undefined, Undefined, FT_Undefined }, }; -const CommandDesc& GetSmartBatteryCommandDesc(U64 id) +const CommandDesc& GetSmartBatteryCommandDesc( U64 id ) { - int c = 0; - for (c = 0; smart_batt_cmds[c].id != -1; ++c) - { - if (smart_batt_cmds[c].id == id) - return smart_batt_cmds[c]; - } + int c = 0; + for( c = 0; smart_batt_cmds[ c ].id != -1; ++c ) + { + if( smart_batt_cmds[ c ].id == id ) + return smart_batt_cmds[ c ]; + } - return smart_batt_cmds[(sizeof(smart_batt_cmds)/sizeof(CommandDesc)) - 1]; + return smart_batt_cmds[ ( sizeof( smart_batt_cmds ) / sizeof( CommandDesc ) ) - 1 ]; } diff --git a/src/SMBusCommands.h b/src/SMBusCommands.h index 4b4b530..a45437d 100644 --- a/src/SMBusCommands.h +++ b/src/SMBusCommands.h @@ -3,251 +3,253 @@ struct CommandDesc { - int id; - const char* name; - int data_length; // -1 for variable - ParamDirection direction; + int id; + const char* name; + int data_length; // -1 for variable + ParamDirection direction; - SMBusFrameType databyte_param_type; // in case of single byte params + SMBusFrameType databyte_param_type; // in case of single byte params }; -const CommandDesc& GetPMBusCommandDesc(U64 id); -const CommandDesc& GetSmartBatteryCommandDesc(U64 id); +const CommandDesc& GetPMBusCommandDesc( U64 id ); +const CommandDesc& GetSmartBatteryCommandDesc( U64 id ); -enum PMBusCommandID { -PAGE = 0x00, -OPERATION = 0x01, -ON_OFF_CONFIG = 0x02, -CLEAR_FAULTS = 0x03, -PHASE = 0x04, -WRITE_PROTECT = 0x10, -STORE_DEFAULT_ALL = 0x11, -RESTORE_DEFAULT_ALL = 0x12, -STORE_DEFAULT_CODE = 0x13, -RESTORE_DEFAULT_CODE = 0x14, -STORE_USER_ALL = 0x15, -RESTORE_USER_ALL = 0x16, -STORE_USER_CODE = 0x17, -RESTORE_USER_CODE = 0x18, -CAPABILITY = 0x19, -QUERY = 0x1A, -VOUT_MODE = 0x20, -VOUT_COMMAND = 0x21, -VOUT_TRIM = 0x22, -VOUT_CAL_OFFSET = 0x23, -VOUT_MAX = 0x24, -VOUT_MARGIN_HIGH = 0x25, -VOUT_MARGIN_LOW = 0x26, -VOUT_TRANSITION_RATE = 0x27, -VOUT_DROOP = 0x28, -VOUT_SCALE_LOOP = 0x29, -VOUT_SCALE_MONITOR = 0x2A, -COEFFICIENTS = 0x30, -POUT_MAX = 0x31, -MAX_DUTY = 0x32, -FREQUENCY_SWITCH = 0x33, -VIN_ON = 0x35, -VIN_OFF = 0x36, -INTERLEAVE = 0x37, -IOUT_CAL_GAIN = 0x38, -IOUT_CAL_OFFSET = 0x39, -FAN_CONFIG_1_2 = 0x3A, -FAN_COMMAND_1 = 0x3B, -FAN_COMMAND_2 = 0x3C, -FAN_CONFIG_3_4 = 0x3D, -FAN_COMMAND_3 = 0x3E, -FAN_COMMAND_4 = 0x3F, -VOUT_OV_FAULT_LIMIT = 0x40, -VOUT_OV_FAULT_RESPONSE = 0x41, -VOUT_OV_WARN_LIMIT = 0x42, -VOUT_UV_WARN_LIMIT = 0x43, -VOUT_UV_FAULT_LIMIT = 0x44, -VOUT_UV_FAULT_RESPONSE = 0x45, -IOUT_OC_FAULT_LIMIT = 0x46, -IOUT_OC_FAULT_RESPONSE = 0x47, -IOUT_OC_LV_FAULT_LIMIT = 0x48, -IOUT_OC_LV_FAULT_RESPONSE = 0x49, -IOUT_OC_WARN_LIMIT = 0x4A, -IOUT_UC_FAULT_LIMIT = 0x4B, -IOUT_UC_FAULT_RESPONSE = 0x4C, -OT_FAULT_LIMIT = 0x4F, -OT_FAULT_RESPONSE = 0x50, -OT_WARN_LIMIT = 0x51, -UT_WARN_LIMIT = 0x52, -UT_FAULT_LIMIT = 0x53, -UT_FAULT_RESPONSE = 0x54, -VIN_OV_FAULT_LIMIT = 0x55, -VIN_OV_FAULT_RESPONSE = 0x56, -VIN_OV_WARN_LIMIT = 0x57, -VIN_UV_WARN_LIMIT = 0x58, -VIN_UV_FAULT_LIMIT = 0x59, -VIN_UV_FAULT_RESPONSE = 0x5A, -IIN_OC_FAULT_LIMIT = 0x5B, -IIN_OC_FAULT_RESPONSE = 0x5C, -IIN_OC_WARN_LIMIT = 0x5D, -POWER_GOOD_ON = 0x5E, -POWER_GOOD_OFF = 0x5F, -TON_DELAY = 0x60, -TON_RISE = 0x61, -TON_MAX_FAULT_LIMIT = 0x62, -TON_MAX_FAULT_RESPONSE = 0x63, -TOFF_DELAY = 0x64, -TOFF_FALL = 0x65, -TOFF_MAX_WARN_LIMIT = 0x66, -POUT_OP_FAULT_LIMIT = 0x68, -POUT_OP_FAULT_RESPONSE = 0x69, -POUT_OP_WARN_LIMIT = 0x6A, -PIN_OP_WARN_LIMIT = 0x6B, -STATUS_BYTE = 0x78, -STATUS_WORD = 0x79, -STATUS_VOUT = 0x7A, -STATUS_IOUT = 0x7B, -STATUS_INPUT = 0x7C, -STATUS_TEMPERATURE = 0x7D, -STATUS_CML = 0x7E, -STATUS_OTHER = 0x7F, -STATUS_MFR_SPECIFIC = 0x80, -STATUS_FANS_1_2 = 0x81, -STATUS_FANS_3_4 = 0x82, -READ_VIN = 0x88, -READ_IIN = 0x89, -READ_VCAP = 0x8A, -READ_VOUT = 0x8B, -READ_IOUT = 0x8C, -READ_TEMPERATURE_1 = 0x8D, -READ_TEMPERATURE_2 = 0x8E, -READ_TEMPERATURE_3 = 0x8F, -READ_FAN_SPEED_1 = 0x90, -READ_FAN_SPEED_2 = 0x91, -READ_FAN_SPEED_3 = 0x92, -READ_FAN_SPEED_4 = 0x93, -READ_DUTY_CYCLE = 0x94, -READ_FREQUENCY = 0x95, -READ_POUT = 0x96, -READ_PIN = 0x97, -PMBUS_REVISION = 0x98, -MFR_ID = 0x99, -MFR_MODEL = 0x9A, -MFR_REVISION = 0x9B, -MFR_LOCATION = 0x9C, -MFR_DATE = 0x9D, -MFR_SERIAL = 0x9E, -MFR_VIN_MIN = 0xA0, -MFR_VIN_MAX = 0xA1, -MFR_IIN_MAX = 0xA2, -MFR_PIN_MAX = 0xA3, -MFR_VOUT_MIN = 0xA4, -MFR_VOUT_MAX = 0xA5, -MFR_IOUT_MAX = 0xA6, -MFR_POUT_MAX = 0xA7, -MFR_TAMBIENT_MAX = 0xA8, -MFR_TAMBIENT_MIN = 0xA9, -MFR_EFFICIENCY_LL = 0xAA, -MFR_EFFICIENCY_HL = 0xAB, -USER_DATA_00 = 0xB0, -USER_DATA_01 = 0xB1, -USER_DATA_02 = 0xB2, -USER_DATA_03 = 0xB3, -USER_DATA_04 = 0xB4, -USER_DATA_05 = 0xB5, -USER_DATA_06 = 0xB6, -USER_DATA_07 = 0xB7, -USER_DATA_08 = 0xB8, -USER_DATA_09 = 0xB9, -USER_DATA_10 = 0xBA, -USER_DATA_11 = 0xBB, -USER_DATA_12 = 0xBC, -USER_DATA_13 = 0xBD, -USER_DATA_14 = 0xBE, -USER_DATA_15 = 0xBF, -MFR_SPECIFIC_00 = 0xD0, -MFR_SPECIFIC_01 = 0xD1, -MFR_SPECIFIC_02 = 0xD2, -MFR_SPECIFIC_03 = 0xD3, -MFR_SPECIFIC_04 = 0xD4, -MFR_SPECIFIC_05 = 0xD5, -MFR_SPECIFIC_06 = 0xD6, -MFR_SPECIFIC_07 = 0xD7, -MFR_SPECIFIC_08 = 0xD8, -MFR_SPECIFIC_09 = 0xD9, -MFR_SPECIFIC_10 = 0xDA, -MFR_SPECIFIC_11 = 0xDB, -MFR_SPECIFIC_13 = 0xDD, -MFR_SPECIFIC_14 = 0xDE, -MFR_SPECIFIC_15 = 0xDF, -MFR_SPECIFIC_16 = 0xE0, -MFR_SPECIFIC_17 = 0xE1, -MFR_SPECIFIC_18 = 0xE2, -MFR_SPECIFIC_19 = 0xE3, -MFR_SPECIFIC_20 = 0xE4, -MFR_SPECIFIC_21 = 0xE5, -MFR_SPECIFIC_22 = 0xE6, -MFR_SPECIFIC_23 = 0xE7, -MFR_SPECIFIC_24 = 0xE8, -MFR_SPECIFIC_25 = 0xE9, -MFR_SPECIFIC_26 = 0xEA, -MFR_SPECIFIC_27 = 0xEB, -MFR_SPECIFIC_28 = 0xEC, -MFR_SPECIFIC_29 = 0xED, -MFR_SPECIFIC_30 = 0xEE, -MFR_SPECIFIC_31 = 0xEF, -MFR_SPECIFIC_32 = 0xF0, -MFR_SPECIFIC_33 = 0xF1, -MFR_SPECIFIC_34 = 0xF2, -MFR_SPECIFIC_35 = 0xF3, -MFR_SPECIFIC_36 = 0xF4, -MFR_SPECIFIC_37 = 0xF5, -MFR_SPECIFIC_38 = 0xF6, -MFR_SPECIFIC_39 = 0xF7, -MFR_SPECIFIC_40 = 0xF8, -MFR_SPECIFIC_41 = 0xF9, -MFR_SPECIFIC_42 = 0xFA, -MFR_SPECIFIC_43 = 0xFB, -MFR_SPECIFIC_44 = 0xFC, -MFR_SPECIFIC_45 = 0xFD, -MFR_SPECIFIC_COMMAND_EXT = 0xFE, -PMBUS_COMMAND_EXT = 0xFF, +enum PMBusCommandID +{ + PAGE = 0x00, + OPERATION = 0x01, + ON_OFF_CONFIG = 0x02, + CLEAR_FAULTS = 0x03, + PHASE = 0x04, + WRITE_PROTECT = 0x10, + STORE_DEFAULT_ALL = 0x11, + RESTORE_DEFAULT_ALL = 0x12, + STORE_DEFAULT_CODE = 0x13, + RESTORE_DEFAULT_CODE = 0x14, + STORE_USER_ALL = 0x15, + RESTORE_USER_ALL = 0x16, + STORE_USER_CODE = 0x17, + RESTORE_USER_CODE = 0x18, + CAPABILITY = 0x19, + QUERY = 0x1A, + VOUT_MODE = 0x20, + VOUT_COMMAND = 0x21, + VOUT_TRIM = 0x22, + VOUT_CAL_OFFSET = 0x23, + VOUT_MAX = 0x24, + VOUT_MARGIN_HIGH = 0x25, + VOUT_MARGIN_LOW = 0x26, + VOUT_TRANSITION_RATE = 0x27, + VOUT_DROOP = 0x28, + VOUT_SCALE_LOOP = 0x29, + VOUT_SCALE_MONITOR = 0x2A, + COEFFICIENTS = 0x30, + POUT_MAX = 0x31, + MAX_DUTY = 0x32, + FREQUENCY_SWITCH = 0x33, + VIN_ON = 0x35, + VIN_OFF = 0x36, + INTERLEAVE = 0x37, + IOUT_CAL_GAIN = 0x38, + IOUT_CAL_OFFSET = 0x39, + FAN_CONFIG_1_2 = 0x3A, + FAN_COMMAND_1 = 0x3B, + FAN_COMMAND_2 = 0x3C, + FAN_CONFIG_3_4 = 0x3D, + FAN_COMMAND_3 = 0x3E, + FAN_COMMAND_4 = 0x3F, + VOUT_OV_FAULT_LIMIT = 0x40, + VOUT_OV_FAULT_RESPONSE = 0x41, + VOUT_OV_WARN_LIMIT = 0x42, + VOUT_UV_WARN_LIMIT = 0x43, + VOUT_UV_FAULT_LIMIT = 0x44, + VOUT_UV_FAULT_RESPONSE = 0x45, + IOUT_OC_FAULT_LIMIT = 0x46, + IOUT_OC_FAULT_RESPONSE = 0x47, + IOUT_OC_LV_FAULT_LIMIT = 0x48, + IOUT_OC_LV_FAULT_RESPONSE = 0x49, + IOUT_OC_WARN_LIMIT = 0x4A, + IOUT_UC_FAULT_LIMIT = 0x4B, + IOUT_UC_FAULT_RESPONSE = 0x4C, + OT_FAULT_LIMIT = 0x4F, + OT_FAULT_RESPONSE = 0x50, + OT_WARN_LIMIT = 0x51, + UT_WARN_LIMIT = 0x52, + UT_FAULT_LIMIT = 0x53, + UT_FAULT_RESPONSE = 0x54, + VIN_OV_FAULT_LIMIT = 0x55, + VIN_OV_FAULT_RESPONSE = 0x56, + VIN_OV_WARN_LIMIT = 0x57, + VIN_UV_WARN_LIMIT = 0x58, + VIN_UV_FAULT_LIMIT = 0x59, + VIN_UV_FAULT_RESPONSE = 0x5A, + IIN_OC_FAULT_LIMIT = 0x5B, + IIN_OC_FAULT_RESPONSE = 0x5C, + IIN_OC_WARN_LIMIT = 0x5D, + POWER_GOOD_ON = 0x5E, + POWER_GOOD_OFF = 0x5F, + TON_DELAY = 0x60, + TON_RISE = 0x61, + TON_MAX_FAULT_LIMIT = 0x62, + TON_MAX_FAULT_RESPONSE = 0x63, + TOFF_DELAY = 0x64, + TOFF_FALL = 0x65, + TOFF_MAX_WARN_LIMIT = 0x66, + POUT_OP_FAULT_LIMIT = 0x68, + POUT_OP_FAULT_RESPONSE = 0x69, + POUT_OP_WARN_LIMIT = 0x6A, + PIN_OP_WARN_LIMIT = 0x6B, + STATUS_BYTE = 0x78, + STATUS_WORD = 0x79, + STATUS_VOUT = 0x7A, + STATUS_IOUT = 0x7B, + STATUS_INPUT = 0x7C, + STATUS_TEMPERATURE = 0x7D, + STATUS_CML = 0x7E, + STATUS_OTHER = 0x7F, + STATUS_MFR_SPECIFIC = 0x80, + STATUS_FANS_1_2 = 0x81, + STATUS_FANS_3_4 = 0x82, + READ_VIN = 0x88, + READ_IIN = 0x89, + READ_VCAP = 0x8A, + READ_VOUT = 0x8B, + READ_IOUT = 0x8C, + READ_TEMPERATURE_1 = 0x8D, + READ_TEMPERATURE_2 = 0x8E, + READ_TEMPERATURE_3 = 0x8F, + READ_FAN_SPEED_1 = 0x90, + READ_FAN_SPEED_2 = 0x91, + READ_FAN_SPEED_3 = 0x92, + READ_FAN_SPEED_4 = 0x93, + READ_DUTY_CYCLE = 0x94, + READ_FREQUENCY = 0x95, + READ_POUT = 0x96, + READ_PIN = 0x97, + PMBUS_REVISION = 0x98, + MFR_ID = 0x99, + MFR_MODEL = 0x9A, + MFR_REVISION = 0x9B, + MFR_LOCATION = 0x9C, + MFR_DATE = 0x9D, + MFR_SERIAL = 0x9E, + MFR_VIN_MIN = 0xA0, + MFR_VIN_MAX = 0xA1, + MFR_IIN_MAX = 0xA2, + MFR_PIN_MAX = 0xA3, + MFR_VOUT_MIN = 0xA4, + MFR_VOUT_MAX = 0xA5, + MFR_IOUT_MAX = 0xA6, + MFR_POUT_MAX = 0xA7, + MFR_TAMBIENT_MAX = 0xA8, + MFR_TAMBIENT_MIN = 0xA9, + MFR_EFFICIENCY_LL = 0xAA, + MFR_EFFICIENCY_HL = 0xAB, + USER_DATA_00 = 0xB0, + USER_DATA_01 = 0xB1, + USER_DATA_02 = 0xB2, + USER_DATA_03 = 0xB3, + USER_DATA_04 = 0xB4, + USER_DATA_05 = 0xB5, + USER_DATA_06 = 0xB6, + USER_DATA_07 = 0xB7, + USER_DATA_08 = 0xB8, + USER_DATA_09 = 0xB9, + USER_DATA_10 = 0xBA, + USER_DATA_11 = 0xBB, + USER_DATA_12 = 0xBC, + USER_DATA_13 = 0xBD, + USER_DATA_14 = 0xBE, + USER_DATA_15 = 0xBF, + MFR_SPECIFIC_00 = 0xD0, + MFR_SPECIFIC_01 = 0xD1, + MFR_SPECIFIC_02 = 0xD2, + MFR_SPECIFIC_03 = 0xD3, + MFR_SPECIFIC_04 = 0xD4, + MFR_SPECIFIC_05 = 0xD5, + MFR_SPECIFIC_06 = 0xD6, + MFR_SPECIFIC_07 = 0xD7, + MFR_SPECIFIC_08 = 0xD8, + MFR_SPECIFIC_09 = 0xD9, + MFR_SPECIFIC_10 = 0xDA, + MFR_SPECIFIC_11 = 0xDB, + MFR_SPECIFIC_13 = 0xDD, + MFR_SPECIFIC_14 = 0xDE, + MFR_SPECIFIC_15 = 0xDF, + MFR_SPECIFIC_16 = 0xE0, + MFR_SPECIFIC_17 = 0xE1, + MFR_SPECIFIC_18 = 0xE2, + MFR_SPECIFIC_19 = 0xE3, + MFR_SPECIFIC_20 = 0xE4, + MFR_SPECIFIC_21 = 0xE5, + MFR_SPECIFIC_22 = 0xE6, + MFR_SPECIFIC_23 = 0xE7, + MFR_SPECIFIC_24 = 0xE8, + MFR_SPECIFIC_25 = 0xE9, + MFR_SPECIFIC_26 = 0xEA, + MFR_SPECIFIC_27 = 0xEB, + MFR_SPECIFIC_28 = 0xEC, + MFR_SPECIFIC_29 = 0xED, + MFR_SPECIFIC_30 = 0xEE, + MFR_SPECIFIC_31 = 0xEF, + MFR_SPECIFIC_32 = 0xF0, + MFR_SPECIFIC_33 = 0xF1, + MFR_SPECIFIC_34 = 0xF2, + MFR_SPECIFIC_35 = 0xF3, + MFR_SPECIFIC_36 = 0xF4, + MFR_SPECIFIC_37 = 0xF5, + MFR_SPECIFIC_38 = 0xF6, + MFR_SPECIFIC_39 = 0xF7, + MFR_SPECIFIC_40 = 0xF8, + MFR_SPECIFIC_41 = 0xF9, + MFR_SPECIFIC_42 = 0xFA, + MFR_SPECIFIC_43 = 0xFB, + MFR_SPECIFIC_44 = 0xFC, + MFR_SPECIFIC_45 = 0xFD, + MFR_SPECIFIC_COMMAND_EXT = 0xFE, + PMBUS_COMMAND_EXT = 0xFF, }; -enum SmartBatteryCommandID { -SBC_ManufacturerAccess = 0x00, -SBC_RemainingCapacityAlarm = 0x01, -SBC_RemainingTimeAlarm = 0x02, -SBC_BatteryMode = 0x03, -SBC_AtRate = 0x04, -SBC_AtRateTimeToFull = 0x05, -SBC_AtRateTimeToEmpty = 0x06, -SBC_AtRateOK = 0x07, -SBC_Temperature = 0x08, -SBC_Voltage = 0x09, -SBC_Current = 0x0a, -SBC_AverageCurrent = 0x0b, -SBC_MaxError = 0x0c, -SBC_RelativeStateOfCharge = 0x0d, -SBC_AbsoluteStateOfCharge = 0x0e, -SBC_RemainingCapacity = 0x0f, -SBC_FullChargeCapacity = 0x10, -SBC_RunTimeToEmpty = 0x11, -SBC_AverageTimeToEmpty = 0x12, -SBC_AverageTimeToFull = 0x13, -SBC_ChargingCurrent = 0x14, -SBC_ChargingVoltage = 0x15, -SBC_BatteryStatus = 0x16, -SBC_CycleCount = 0x17, -SBC_DesignCapacity = 0x18, -SBC_DesignVoltage = 0x19, -SBC_SpecificationInfo = 0x1a, -SBC_ManufactureDate = 0x1b, -SBC_SerialNumber = 0x1c, -SBC_ManufacturerName = 0x20, -SBC_DeviceName = 0x21, -SBC_DeviceChemistry = 0x22, -SBC_ManufacturerData = 0x23, -SBC_OptionalMfgFunction5 = 0x2f, -SBC_OptionalMfgFunction4 = 0x3c, -SBC_OptionalMfgFunction3 = 0x3d, -SBC_OptionalMfgFunction2 = 0x3e, -SBC_OptionalMfgFunction1 = 0x3f, +enum SmartBatteryCommandID +{ + SBC_ManufacturerAccess = 0x00, + SBC_RemainingCapacityAlarm = 0x01, + SBC_RemainingTimeAlarm = 0x02, + SBC_BatteryMode = 0x03, + SBC_AtRate = 0x04, + SBC_AtRateTimeToFull = 0x05, + SBC_AtRateTimeToEmpty = 0x06, + SBC_AtRateOK = 0x07, + SBC_Temperature = 0x08, + SBC_Voltage = 0x09, + SBC_Current = 0x0a, + SBC_AverageCurrent = 0x0b, + SBC_MaxError = 0x0c, + SBC_RelativeStateOfCharge = 0x0d, + SBC_AbsoluteStateOfCharge = 0x0e, + SBC_RemainingCapacity = 0x0f, + SBC_FullChargeCapacity = 0x10, + SBC_RunTimeToEmpty = 0x11, + SBC_AverageTimeToEmpty = 0x12, + SBC_AverageTimeToFull = 0x13, + SBC_ChargingCurrent = 0x14, + SBC_ChargingVoltage = 0x15, + SBC_BatteryStatus = 0x16, + SBC_CycleCount = 0x17, + SBC_DesignCapacity = 0x18, + SBC_DesignVoltage = 0x19, + SBC_SpecificationInfo = 0x1a, + SBC_ManufactureDate = 0x1b, + SBC_SerialNumber = 0x1c, + SBC_ManufacturerName = 0x20, + SBC_DeviceName = 0x21, + SBC_DeviceChemistry = 0x22, + SBC_ManufacturerData = 0x23, + SBC_OptionalMfgFunction5 = 0x2f, + SBC_OptionalMfgFunction4 = 0x3c, + SBC_OptionalMfgFunction3 = 0x3d, + SBC_OptionalMfgFunction2 = 0x3e, + SBC_OptionalMfgFunction1 = 0x3f, }; -#endif // COMMANDS_DESC_H +#endif // COMMANDS_DESC_H diff --git a/src/SMBusSimulationDataGenerator.cpp b/src/SMBusSimulationDataGenerator.cpp index 6156210..c7316fb 100644 --- a/src/SMBusSimulationDataGenerator.cpp +++ b/src/SMBusSimulationDataGenerator.cpp @@ -6,384 +6,388 @@ #include "SMBusCommands.h" SMBusSimulationDataGenerator::SMBusSimulationDataGenerator() -{} +{ +} SMBusSimulationDataGenerator::~SMBusSimulationDataGenerator() -{} +{ +} -void SMBusSimulationDataGenerator::Initialize(U32 simulation_sample_rate, SMBusAnalyzerSettings* settings) +void SMBusSimulationDataGenerator::Initialize( U32 simulation_sample_rate, SMBusAnalyzerSettings* settings ) { - mSimulationSampleRateHz = simulation_sample_rate; - mSettings = settings; + mSimulationSampleRateHz = simulation_sample_rate; + mSettings = settings; - // 50KHz, but it's not really used for AdvanceByHalfPeriod - mClockGenerator.Init(50000, simulation_sample_rate); + // 50KHz, but it's not really used for AdvanceByHalfPeriod + mClockGenerator.Init( 50000, simulation_sample_rate ); - mSMBDAT = mSMBSimulationChannels.Add(settings->mSMBDAT, mSimulationSampleRateHz, BIT_HIGH); - mSMBCLK = mSMBSimulationChannels.Add(settings->mSMBCLK, mSimulationSampleRateHz, BIT_HIGH); + mSMBDAT = mSMBSimulationChannels.Add( settings->mSMBDAT, mSimulationSampleRateHz, BIT_HIGH ); + mSMBCLK = mSMBSimulationChannels.Add( settings->mSMBCLK, mSimulationSampleRateHz, BIT_HIGH ); - AdvanceAllBySec(ONE_MS * 0.5); // insert a pause before we start + AdvanceAllBySec( ONE_MS * 0.5 ); // insert a pause before we start } -U32 SMBusSimulationDataGenerator::GenerateSimulationData(U64 largest_sample_requested, U32 sample_rate, SimulationChannelDescriptor** simulation_channels) +U32 SMBusSimulationDataGenerator::GenerateSimulationData( U64 largest_sample_requested, U32 sample_rate, + SimulationChannelDescriptor** simulation_channels ) { - U64 adjusted_largest_sample_requested = AnalyzerHelpers::AdjustSimulationTargetSample( largest_sample_requested, sample_rate, mSimulationSampleRateHz ); + U64 adjusted_largest_sample_requested = + AnalyzerHelpers::AdjustSimulationTargetSample( largest_sample_requested, sample_rate, mSimulationSampleRateHz ); - while (mSMBCLK->GetCurrentSampleNumber() < adjusted_largest_sample_requested) - { - CreateSMBusTransaction(); - AdvanceAllBySec(ONE_MS * 2); - } + while( mSMBCLK->GetCurrentSampleNumber() < adjusted_largest_sample_requested ) + { + CreateSMBusTransaction(); + AdvanceAllBySec( ONE_MS * 2 ); + } - *simulation_channels = mSMBSimulationChannels.GetArray(); + *simulation_channels = mSMBSimulationChannels.GetArray(); - return mSMBSimulationChannels.GetCount(); + return mSMBSimulationChannels.GetCount(); } void SMBusSimulationDataGenerator::CreateSMBusTransaction() { - OutputQuickCommand(); - OutputSendByte(0x01); - OutputRecvByte(0x02); - - if (mSettings->mDecodeLevel == DL_PMBus) - { - OutputProcessCallPMBusCoefficients(); - OutputReadByte(CAPABILITY, 0xB0); - OutputBlockProcessCallPMBusQuery(); - - OutputWriteByte(WRITE_PROTECT, 0x20); - OutputReadByte(WRITE_PROTECT, 0x00); - - OutputWriteByte(OPERATION, 0x20); - OutputReadByte(OPERATION, 0x00); - - OutputWriteByte(ON_OFF_CONFIG, 0xff); - OutputReadByte(ON_OFF_CONFIG, 0xff); - - OutputWriteByte(VOUT_MODE, 0xff); - OutputReadByte(VOUT_MODE, 0xff); - - OutputPMBusGroupCommand(); - - } else if (mSettings->mDecodeLevel == DL_SmartBattery) { - - OutputWriteWord(SBC_ManufacturerAccess, 0x1234); - OutputReadWord(SBC_ManufacturerAccess, 0x5678); - - OutputWriteWord(SBC_BatteryMode, 0xabcd); - OutputReadWord(SBC_BatteryStatus, 0xabcd); - - OutputReadWord(SBC_SpecificationInfo, 0xabcd); - OutputReadWord(SBC_ManufactureDate, 0x1234); - - } else { - - OutputQuickCommand(); - OutputSendByte(0xae); - OutputRecvByte(0x66); - OutputWriteByte(0x83, 0x73); - OutputReadByte(0x84, 0x91); - OutputWriteWord(0x12, 0x92); - OutputReadWord(0x05, 0x62); - } + OutputQuickCommand(); + OutputSendByte( 0x01 ); + OutputRecvByte( 0x02 ); + + if( mSettings->mDecodeLevel == DL_PMBus ) + { + OutputProcessCallPMBusCoefficients(); + OutputReadByte( CAPABILITY, 0xB0 ); + OutputBlockProcessCallPMBusQuery(); + + OutputWriteByte( WRITE_PROTECT, 0x20 ); + OutputReadByte( WRITE_PROTECT, 0x00 ); + + OutputWriteByte( OPERATION, 0x20 ); + OutputReadByte( OPERATION, 0x00 ); + + OutputWriteByte( ON_OFF_CONFIG, 0xff ); + OutputReadByte( ON_OFF_CONFIG, 0xff ); + + OutputWriteByte( VOUT_MODE, 0xff ); + OutputReadByte( VOUT_MODE, 0xff ); + + OutputPMBusGroupCommand(); + } + else if( mSettings->mDecodeLevel == DL_SmartBattery ) + { + OutputWriteWord( SBC_ManufacturerAccess, 0x1234 ); + OutputReadWord( SBC_ManufacturerAccess, 0x5678 ); + + OutputWriteWord( SBC_BatteryMode, 0xabcd ); + OutputReadWord( SBC_BatteryStatus, 0xabcd ); + + OutputReadWord( SBC_SpecificationInfo, 0xabcd ); + OutputReadWord( SBC_ManufactureDate, 0x1234 ); + } + else + { + OutputQuickCommand(); + OutputSendByte( 0xae ); + OutputRecvByte( 0x66 ); + OutputWriteByte( 0x83, 0x73 ); + OutputReadByte( 0x84, 0x91 ); + OutputWriteWord( 0x12, 0x92 ); + OutputReadWord( 0x05, 0x62 ); + } } void SMBusSimulationDataGenerator::OutputStart() { - // get SMBDAT high - if (mSMBDAT->GetCurrentBitState() == BIT_LOW) - { - AdvanceAllBySec(ONE_US * 5); - mSMBDAT->Transition(); - } - - // get SMBCLK high - if (mSMBCLK->GetCurrentBitState() == BIT_LOW) - { - AdvanceAllBySec(TSU_STA_MIN); - mSMBCLK->Transition(); - } - - // SMBDAT goes low - AdvanceAllBySec(ONE_US * 10); - mSMBDAT->Transition(); - - // SMBCLK goes low - AdvanceAllBySec(ONE_US * 10); - mSMBCLK->Transition(); - - // pause a little - AdvanceAllBySec(TBUF_MIN * 2); + // get SMBDAT high + if( mSMBDAT->GetCurrentBitState() == BIT_LOW ) + { + AdvanceAllBySec( ONE_US * 5 ); + mSMBDAT->Transition(); + } + + // get SMBCLK high + if( mSMBCLK->GetCurrentBitState() == BIT_LOW ) + { + AdvanceAllBySec( TSU_STA_MIN ); + mSMBCLK->Transition(); + } + + // SMBDAT goes low + AdvanceAllBySec( ONE_US * 10 ); + mSMBDAT->Transition(); + + // SMBCLK goes low + AdvanceAllBySec( ONE_US * 10 ); + mSMBCLK->Transition(); + + // pause a little + AdvanceAllBySec( TBUF_MIN * 2 ); } void SMBusSimulationDataGenerator::OutputStop() { - // SMBCLK must be low - assert(mSMBCLK->GetCurrentBitState() == BIT_LOW); - - // get SMBDAT low - if (mSMBDAT->GetCurrentBitState() == BIT_HIGH) - { - AdvanceAllBySec(ONE_US * 8); // insert a pause before we start - mSMBDAT->Transition(); - } - - // SMBCLK goes high - AdvanceAllBySec(ONE_US * 8); - mSMBCLK->Transition(); - - // SMBDAT goes high - AdvanceAllBySec(ONE_US * 8); - mSMBDAT->Transition(); + // SMBCLK must be low + assert( mSMBCLK->GetCurrentBitState() == BIT_LOW ); + + // get SMBDAT low + if( mSMBDAT->GetCurrentBitState() == BIT_HIGH ) + { + AdvanceAllBySec( ONE_US * 8 ); // insert a pause before we start + mSMBDAT->Transition(); + } + + // SMBCLK goes high + AdvanceAllBySec( ONE_US * 8 ); + mSMBCLK->Transition(); + + // SMBDAT goes high + AdvanceAllBySec( ONE_US * 8 ); + mSMBDAT->Transition(); } -void SMBusSimulationDataGenerator::OutputBit(BitState state) +void SMBusSimulationDataGenerator::OutputBit( BitState state ) { - if (state == BIT_HIGH) - mSMBDAT->TransitionIfNeeded(BIT_HIGH); - else - mSMBDAT->TransitionIfNeeded(BIT_LOW); + if( state == BIT_HIGH ) + mSMBDAT->TransitionIfNeeded( BIT_HIGH ); + else + mSMBDAT->TransitionIfNeeded( BIT_LOW ); - AdvanceAllBySec(ONE_US * 5); + AdvanceAllBySec( ONE_US * 5 ); - mSMBCLK->Transition(); // go high - AdvanceAllBySec(ONE_US * 10); - mSMBCLK->Transition(); // go low + mSMBCLK->Transition(); // go high + AdvanceAllBySec( ONE_US * 10 ); + mSMBCLK->Transition(); // go low - AdvanceAllBySec(ONE_US * 5); + AdvanceAllBySec( ONE_US * 5 ); } -U8 SMBusSimulationDataGenerator::OutputByte(const U8 byte, bool is_ack) +U8 SMBusSimulationDataGenerator::OutputByte( const U8 byte, bool is_ack ) { - // SMBCLK must be low - assert(mSMBCLK->GetCurrentBitState() == BIT_LOW); + // SMBCLK must be low + assert( mSMBCLK->GetCurrentBitState() == BIT_LOW ); - for (int mask = 0x80; mask; mask >>= 1) - OutputBit((byte & mask) ? BIT_HIGH : BIT_LOW); + for( int mask = 0x80; mask; mask >>= 1 ) + OutputBit( ( byte & mask ) ? BIT_HIGH : BIT_LOW ); - OutputBit(is_ack ? BIT_LOW : BIT_HIGH); + OutputBit( is_ack ? BIT_LOW : BIT_HIGH ); - // add a small pause - AdvanceAllBySec(ONE_US * 15); + // add a small pause + AdvanceAllBySec( ONE_US * 15 ); - return byte; + return byte; } -U8 SMBusSimulationDataGenerator::OutputAddr(U8 addr, bool is_read, bool is_ack) +U8 SMBusSimulationDataGenerator::OutputAddr( U8 addr, bool is_read, bool is_ack ) { - U8 byte = (addr << 1) | (is_read ? 1 : 0); - OutputByte(byte, is_ack); - return byte; + U8 byte = ( addr << 1 ) | ( is_read ? 1 : 0 ); + OutputByte( byte, is_ack ); + return byte; } void SMBusSimulationDataGenerator::OutputQuickCommand() { - // quick command has no PEC + // quick command has no PEC - OutputStart(); - OutputAddr(0x41, true); - OutputStop(); + OutputStart(); + OutputAddr( 0x41, true ); + OutputStop(); - AdvanceAllBySec(ONE_MS * 0.5); + AdvanceAllBySec( ONE_MS * 0.5 ); } -void SMBusSimulationDataGenerator::OutputSendByte(U8 byte) +void SMBusSimulationDataGenerator::OutputSendByte( U8 byte ) { - U8 pec = 0; + U8 pec = 0; - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x42, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(byte, mSettings->CalcPEC())]; - if (mSettings->CalcPEC()) - OutputByte(pec, false); - OutputStop(); + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x42, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( byte, mSettings->CalcPEC() ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec, false ); + OutputStop(); - AdvanceAllBySec(ONE_MS * 0.5); + AdvanceAllBySec( ONE_MS * 0.5 ); } -void SMBusSimulationDataGenerator::OutputRecvByte(U8 byte) +void SMBusSimulationDataGenerator::OutputRecvByte( U8 byte ) { - U8 pec = 0; + U8 pec = 0; - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, true)]; - pec = SMBusCRCLookup[pec ^ OutputByte(byte, mSettings->CalcPEC())]; - if (mSettings->CalcPEC()) - OutputByte(pec, false); - OutputStop(); + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, true ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( byte, mSettings->CalcPEC() ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec, false ); + OutputStop(); - AdvanceAllBySec(ONE_MS * 0.5); + AdvanceAllBySec( ONE_MS * 0.5 ); } -void SMBusSimulationDataGenerator::OutputWriteByte(U8 command, U8 data_byte) +void SMBusSimulationDataGenerator::OutputWriteByte( U8 command, U8 data_byte ) { - U8 pec = 0; + U8 pec = 0; - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(command)]; - pec = SMBusCRCLookup[pec ^ OutputByte(data_byte, mSettings->CalcPEC())]; - if (mSettings->CalcPEC()) - OutputByte(pec, false); - OutputStop(); + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( command ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( data_byte, mSettings->CalcPEC() ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec, false ); + OutputStop(); - AdvanceAllBySec(ONE_MS * 0.5); + AdvanceAllBySec( ONE_MS * 0.5 ); } -void SMBusSimulationDataGenerator::OutputReadByte(U8 command, U8 data_byte) +void SMBusSimulationDataGenerator::OutputReadByte( U8 command, U8 data_byte ) { - U8 pec = 0; - - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(command)]; - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, true)]; - pec = SMBusCRCLookup[pec ^ OutputByte(data_byte, mSettings->CalcPEC())]; - if (mSettings->CalcPEC()) - OutputByte(pec, false); - OutputStop(); - - AdvanceAllBySec(ONE_MS * 0.5); + U8 pec = 0; + + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( command ) ]; + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, true ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( data_byte, mSettings->CalcPEC() ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec, false ); + OutputStop(); + + AdvanceAllBySec( ONE_MS * 0.5 ); } -void SMBusSimulationDataGenerator::OutputWriteWord(U8 command, U16 data_word) +void SMBusSimulationDataGenerator::OutputWriteWord( U8 command, U16 data_word ) { - U8 pec = 0; - - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(command)]; - pec = SMBusCRCLookup[pec ^ OutputByte(U8(data_word >> 8))]; - pec = SMBusCRCLookup[pec ^ OutputByte(U8(data_word & 0xff), mSettings->CalcPEC())]; - if (mSettings->CalcPEC()) - OutputByte(pec, false); - OutputStop(); - - AdvanceAllBySec(ONE_MS * 0.5); + U8 pec = 0; + + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( command ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( U8( data_word >> 8 ) ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( U8( data_word & 0xff ), mSettings->CalcPEC() ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec, false ); + OutputStop(); + + AdvanceAllBySec( ONE_MS * 0.5 ); } -void SMBusSimulationDataGenerator::OutputReadWord(U8 command, U16 data_word) +void SMBusSimulationDataGenerator::OutputReadWord( U8 command, U16 data_word ) { - U8 pec = 0; - - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(command)]; - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, true)]; - pec = SMBusCRCLookup[pec ^ OutputByte(U8(data_word >> 8))]; - pec = SMBusCRCLookup[pec ^ OutputByte(U8(data_word & 0xff), mSettings->CalcPEC())]; - if (mSettings->CalcPEC()) - OutputByte(pec, false); - OutputStop(); - - AdvanceAllBySec(ONE_MS * 0.5); + U8 pec = 0; + + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( command ) ]; + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, true ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( U8( data_word >> 8 ) ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( U8( data_word & 0xff ), mSettings->CalcPEC() ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec, false ); + OutputStop(); + + AdvanceAllBySec( ONE_MS * 0.5 ); } void SMBusSimulationDataGenerator::OutputProcessCallPMBusRevision() { - U8 pec = 0; - - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(PMBUS_REVISION)]; - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, true)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x11, mSettings->CalcPEC())]; - if (mSettings->CalcPEC()) - OutputByte(pec, false); - OutputStop(); - - AdvanceAllBySec(ONE_MS * 0.5); + U8 pec = 0; + + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( PMBUS_REVISION ) ]; + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, true ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x11, mSettings->CalcPEC() ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec, false ); + OutputStop(); + + AdvanceAllBySec( ONE_MS * 0.5 ); } void SMBusSimulationDataGenerator::OutputBlockProcessCallPMBusQuery() { - U8 pec = 0; - - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(QUERY)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x01)]; // block command byte count - pec = SMBusCRCLookup[pec ^ OutputByte(CLEAR_FAULTS)]; // 1 data byte is the command to query - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, true)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x01)]; // block command byte count - pec = SMBusCRCLookup[pec ^ OutputByte(0x98, mSettings->CalcPEC())]; // the result - if (mSettings->CalcPEC()) - OutputByte(pec, false); - OutputStop(); - - AdvanceAllBySec(ONE_MS * 0.5); + U8 pec = 0; + + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( QUERY ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x01 ) ]; // block command byte count + pec = SMBusCRCLookup[ pec ^ OutputByte( CLEAR_FAULTS ) ]; // 1 data byte is the command to query + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, true ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x01 ) ]; // block command byte count + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x98, mSettings->CalcPEC() ) ]; // the result + if( mSettings->CalcPEC() ) + OutputByte( pec, false ); + OutputStop(); + + AdvanceAllBySec( ONE_MS * 0.5 ); } void SMBusSimulationDataGenerator::OutputPMBusGroupCommand() { - U8 pec; - - OutputStart(); - pec = 0; - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(VOUT_MARGIN_HIGH)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x01)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x24)]; - if (mSettings->CalcPEC()) - OutputByte(pec); - - OutputStart(); - pec = 0; - pec = SMBusCRCLookup[pec ^ OutputAddr(0x44, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(VOUT_MARGIN_HIGH)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x73)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x28)]; - if (mSettings->CalcPEC()) - OutputByte(pec); - - OutputStart(); - pec = 0; - pec = SMBusCRCLookup[pec ^ OutputAddr(0x45, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(VOUT_MARGIN_HIGH)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x24)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x88)]; - if (mSettings->CalcPEC()) - OutputByte(pec); - - OutputStart(); - pec = 0; - pec = SMBusCRCLookup[pec ^ OutputAddr(0x46, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(VOUT_MODE)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x11)]; - if (mSettings->CalcPEC()) - OutputByte(pec); - - OutputStop(); - - AdvanceAllBySec(ONE_MS * 0.5); + U8 pec; + + OutputStart(); + pec = 0; + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( VOUT_MARGIN_HIGH ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x01 ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x24 ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec ); + + OutputStart(); + pec = 0; + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x44, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( VOUT_MARGIN_HIGH ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x73 ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x28 ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec ); + + OutputStart(); + pec = 0; + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x45, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( VOUT_MARGIN_HIGH ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x24 ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x88 ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec ); + + OutputStart(); + pec = 0; + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x46, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( VOUT_MODE ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x11 ) ]; + if( mSettings->CalcPEC() ) + OutputByte( pec ); + + OutputStop(); + + AdvanceAllBySec( ONE_MS * 0.5 ); } void SMBusSimulationDataGenerator::OutputProcessCallPMBusCoefficients() { - U8 pec = 0; - - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, false)]; - pec = SMBusCRCLookup[pec ^ OutputByte(COEFFICIENTS)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x02)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x03)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x24)]; - OutputStart(); - pec = SMBusCRCLookup[pec ^ OutputAddr(0x43, true)]; - pec = SMBusCRCLookup[pec ^ OutputByte(0x05)]; // byte count - pec = SMBusCRCLookup[pec ^ OutputByte(0x12)]; // m: low - pec = SMBusCRCLookup[pec ^ OutputByte(0x23)]; // m: high - pec = SMBusCRCLookup[pec ^ OutputByte(0x34)]; // b: low - pec = SMBusCRCLookup[pec ^ OutputByte(0x45)]; // b: high - pec = SMBusCRCLookup[pec ^ OutputByte(0x56)]; // R - if (mSettings->CalcPEC()) - OutputByte(pec, false); - OutputStop(); - - AdvanceAllBySec(ONE_MS * 0.5); + U8 pec = 0; + + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, false ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( COEFFICIENTS ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x02 ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x03 ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x24 ) ]; + OutputStart(); + pec = SMBusCRCLookup[ pec ^ OutputAddr( 0x43, true ) ]; + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x05 ) ]; // byte count + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x12 ) ]; // m: low + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x23 ) ]; // m: high + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x34 ) ]; // b: low + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x45 ) ]; // b: high + pec = SMBusCRCLookup[ pec ^ OutputByte( 0x56 ) ]; // R + if( mSettings->CalcPEC() ) + OutputByte( pec, false ); + OutputStop(); + + AdvanceAllBySec( ONE_MS * 0.5 ); } diff --git a/src/SMBusSimulationDataGenerator.h b/src/SMBusSimulationDataGenerator.h index e9942ff..91fd642 100644 --- a/src/SMBusSimulationDataGenerator.h +++ b/src/SMBusSimulationDataGenerator.h @@ -9,51 +9,50 @@ class SMBusAnalyzerSettings; class SMBusSimulationDataGenerator { -public: - SMBusSimulationDataGenerator(); - ~SMBusSimulationDataGenerator(); - - void Initialize(U32 simulation_sample_rate, SMBusAnalyzerSettings* settings); - U32 GenerateSimulationData( U64 newest_sample_requested, U32 sample_rate, SimulationChannelDescriptor** simulation_channels ); - -protected: - SMBusAnalyzerSettings* mSettings; - U32 mSimulationSampleRateHz; - - void AdvanceAllBySec(double sec) - { - mSMBSimulationChannels.AdvanceAll(mClockGenerator.AdvanceByTimeS(sec)); - } - - void CreateSMBusTransaction(); - - void OutputStart(); - void OutputStop(); - void OutputBit(BitState state); - U8 OutputByte(const U8 byte, bool is_ack = true); - U8 OutputAddr(const U8 byte, bool is_read, bool is_ack = true); - - void OutputQuickCommand(); - void OutputSendByte(U8 byte); - void OutputRecvByte(U8 byte); - void OutputWriteByte(U8 command, U8 data_byte); - void OutputReadByte(U8 command, U8 data_byte); - void OutputWriteWord(U8 command, U16 data_word); - void OutputReadWord(U8 command, U16 data_word); - - // PMBus specific - void OutputProcessCallPMBusCoefficients(); - void OutputProcessCallPMBusRevision(); - void OutputBlockProcessCallPMBusQuery(); - void OutputPMBusGroupCommand(); - -protected: - - ClockGenerator mClockGenerator; - - SimulationChannelDescriptorGroup mSMBSimulationChannels; - SimulationChannelDescriptor* mSMBDAT; - SimulationChannelDescriptor* mSMBCLK; + public: + SMBusSimulationDataGenerator(); + ~SMBusSimulationDataGenerator(); + + void Initialize( U32 simulation_sample_rate, SMBusAnalyzerSettings* settings ); + U32 GenerateSimulationData( U64 newest_sample_requested, U32 sample_rate, SimulationChannelDescriptor** simulation_channels ); + + protected: + SMBusAnalyzerSettings* mSettings; + U32 mSimulationSampleRateHz; + + void AdvanceAllBySec( double sec ) + { + mSMBSimulationChannels.AdvanceAll( mClockGenerator.AdvanceByTimeS( sec ) ); + } + + void CreateSMBusTransaction(); + + void OutputStart(); + void OutputStop(); + void OutputBit( BitState state ); + U8 OutputByte( const U8 byte, bool is_ack = true ); + U8 OutputAddr( const U8 byte, bool is_read, bool is_ack = true ); + + void OutputQuickCommand(); + void OutputSendByte( U8 byte ); + void OutputRecvByte( U8 byte ); + void OutputWriteByte( U8 command, U8 data_byte ); + void OutputReadByte( U8 command, U8 data_byte ); + void OutputWriteWord( U8 command, U16 data_word ); + void OutputReadWord( U8 command, U16 data_word ); + + // PMBus specific + void OutputProcessCallPMBusCoefficients(); + void OutputProcessCallPMBusRevision(); + void OutputBlockProcessCallPMBusQuery(); + void OutputPMBusGroupCommand(); + + protected: + ClockGenerator mClockGenerator; + + SimulationChannelDescriptorGroup mSMBSimulationChannels; + SimulationChannelDescriptor* mSMBDAT; + SimulationChannelDescriptor* mSMBCLK; }; -#endif // SMBUS_SIMULATION_DATA_GENERATOR_H +#endif // SMBUS_SIMULATION_DATA_GENERATOR_H diff --git a/src/SMBusTypes.cpp b/src/SMBusTypes.cpp index 628863e..f143a4d 100644 --- a/src/SMBusTypes.cpp +++ b/src/SMBusTypes.cpp @@ -10,704 +10,690 @@ #include "SMBusCommands.h" // protocols as defined by SMBus spec v2.0 chapter 5.5 -const SMBusProtocol SMBusProtocols[NUM_SMBUS_PROTOCOLS] = -{ - {"Quick Command", {SMBP_Start, SMBP_AddrAny, SMBP_Stop} }, - {"Send byte", {SMBP_Start, SMBP_AddrWrite, SMBP_DataByte, SMBP_Stop} }, - {"Recv byte", {SMBP_Start, SMBP_AddrRead, SMBP_DataByte, SMBP_Stop} }, - {"Write byte", {SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_DataByte, SMBP_Stop} }, - {"Write word", {SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_DataWord, SMBP_Stop} }, - {"Read byte", {SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_Start, SMBP_AddrRead, SMBP_DataByte, SMBP_Stop} }, - {"Read word", {SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_Start, SMBP_AddrRead, SMBP_DataWord, SMBP_Stop} }, - {"Block process call", {SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_DataWord, SMBP_Start, SMBP_AddrRead, SMBP_DataWord, SMBP_Stop} }, - {"Process call", {SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_ByteCount, SMBP_DataBlock, SMBP_Stop} }, - {"Block write", {SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_Start, SMBP_AddrRead, SMBP_ByteCount, SMBP_DataBlock, SMBP_Stop} }, - {"Block read", {SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_ByteCount, SMBP_DataBlock, SMBP_Start, SMBP_AddrRead, SMBP_ByteCount, SMBP_DataBlock, SMBP_Stop} }, - {"Host notify", {SMBP_Start, SMBP_AddrHostWrite, SMBP_DataByte, SMBP_DataByte, SMBP_Stop} }, +const SMBusProtocol SMBusProtocols[ NUM_SMBUS_PROTOCOLS ] = { + { "Quick Command", { SMBP_Start, SMBP_AddrAny, SMBP_Stop } }, + { "Send byte", { SMBP_Start, SMBP_AddrWrite, SMBP_DataByte, SMBP_Stop } }, + { "Recv byte", { SMBP_Start, SMBP_AddrRead, SMBP_DataByte, SMBP_Stop } }, + { "Write byte", { SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_DataByte, SMBP_Stop } }, + { "Write word", { SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_DataWord, SMBP_Stop } }, + { "Read byte", { SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_Start, SMBP_AddrRead, SMBP_DataByte, SMBP_Stop } }, + { "Read word", { SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_Start, SMBP_AddrRead, SMBP_DataWord, SMBP_Stop } }, + { "Block process call", + { SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_DataWord, SMBP_Start, SMBP_AddrRead, SMBP_DataWord, SMBP_Stop } }, + { "Process call", { SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_ByteCount, SMBP_DataBlock, SMBP_Stop } }, + { "Block write", { SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_Start, SMBP_AddrRead, SMBP_ByteCount, SMBP_DataBlock, SMBP_Stop } }, + { "Block read", + { SMBP_Start, SMBP_AddrWrite, SMBP_Command, SMBP_ByteCount, SMBP_DataBlock, SMBP_Start, SMBP_AddrRead, SMBP_ByteCount, SMBP_DataBlock, + SMBP_Stop } }, + { "Host notify", { SMBP_Start, SMBP_AddrHostWrite, SMBP_DataByte, SMBP_DataByte, SMBP_Stop } }, }; -#define SMBus_QuickCommand (SMBusProtocols) -#define SMBus_SendByte (SMBusProtocols + 1) -#define SMBus_RecvByte (SMBusProtocols + 2) -#define SMBus_WriteByte (SMBusProtocols + 3) -#define SMBus_WriteWord (SMBusProtocols + 4) -#define SMBus_ReadByte (SMBusProtocols + 5) -#define SMBus_ReadWord (SMBusProtocols + 6) -#define SMBus_BlockProcessCall (SMBusProtocols + 7) -#define SMBus_ProcessCall (SMBusProtocols + 8) -#define SMBus_BlockWrite (SMBusProtocols + 9) -#define SMBus_BlockRead (SMBusProtocols + 10) -#define SMBus_HostNotify (SMBusProtocols + 11) +#define SMBus_QuickCommand ( SMBusProtocols ) +#define SMBus_SendByte ( SMBusProtocols + 1 ) +#define SMBus_RecvByte ( SMBusProtocols + 2 ) +#define SMBus_WriteByte ( SMBusProtocols + 3 ) +#define SMBus_WriteWord ( SMBusProtocols + 4 ) +#define SMBus_ReadByte ( SMBusProtocols + 5 ) +#define SMBus_ReadWord ( SMBusProtocols + 6 ) +#define SMBus_BlockProcessCall ( SMBusProtocols + 7 ) +#define SMBus_ProcessCall ( SMBusProtocols + 8 ) +#define SMBus_BlockWrite ( SMBusProtocols + 9 ) +#define SMBus_BlockRead ( SMBusProtocols + 10 ) +#define SMBus_HostNotify ( SMBusProtocols + 11 ) // PMBus specific protocols as defined by PMBus spec v1.1 chapter 5.2 // PMBus Group command is handled separately -const SMBusProtocol PMBusProtocols[NUM_PMBUS_PROTOCOLS] = -{ - {"Ext command read byte", {SMBP_Start, SMBP_AddrWrite, SMBP_CommandExt, SMBP_Start, SMBP_AddrRead, SMBP_DataByte, SMBP_Stop} }, - {"Ext command write byte", {SMBP_Start, SMBP_AddrWrite, SMBP_CommandExt, SMBP_DataByte, SMBP_Stop} }, - {"Ext command read word", {SMBP_Start, SMBP_AddrWrite, SMBP_CommandExt, SMBP_Start, SMBP_AddrRead, SMBP_DataByte, SMBP_DataByte, SMBP_Stop} }, - {"Ext command write word", {SMBP_Start, SMBP_AddrWrite, SMBP_CommandExt, SMBP_DataByte, SMBP_DataByte, SMBP_Stop} }, +const SMBusProtocol PMBusProtocols[ NUM_PMBUS_PROTOCOLS ] = { + { "Ext command read byte", { SMBP_Start, SMBP_AddrWrite, SMBP_CommandExt, SMBP_Start, SMBP_AddrRead, SMBP_DataByte, SMBP_Stop } }, + { "Ext command write byte", { SMBP_Start, SMBP_AddrWrite, SMBP_CommandExt, SMBP_DataByte, SMBP_Stop } }, + { "Ext command read word", + { SMBP_Start, SMBP_AddrWrite, SMBP_CommandExt, SMBP_Start, SMBP_AddrRead, SMBP_DataByte, SMBP_DataByte, SMBP_Stop } }, + { "Ext command write word", { SMBP_Start, SMBP_AddrWrite, SMBP_CommandExt, SMBP_DataByte, SMBP_DataByte, SMBP_Stop } }, }; // ************************************************************************************ Frame SMBusSignalState::ToFrame() const { - Frame f; + Frame f; - f.mType = bus_signal; - f.mStartingSampleInclusive = sample_begin; - f.mEndingSampleInclusive = sample_end; - f.mData1 = f.mData2 = 0; - f.mFlags = 0; + f.mType = bus_signal; + f.mStartingSampleInclusive = sample_begin; + f.mEndingSampleInclusive = sample_end; + f.mData1 = f.mData2 = 0; + f.mFlags = 0; - return f; + return f; } -void SMBusSignalState::AddMarkers(AnalyzerResults* pResults, Channel& chnlSMBCLK, Channel& chnlSMBDAT) +void SMBusSignalState::AddMarkers( AnalyzerResults* pResults, Channel& chnlSMBCLK, Channel& chnlSMBDAT ) { - if (bus_signal == SMB_Zero || bus_signal == SMB_One - || bus_signal == SMB_ACK || bus_signal == SMB_NACK) - { - pResults->AddMarker(sample_rising_clk, AnalyzerResults::UpArrow, chnlSMBCLK); - - if (bus_signal == SMB_Zero) - pResults->AddMarker(sample_marker, AnalyzerResults::Zero, chnlSMBDAT); - else if (bus_signal == SMB_One) - pResults->AddMarker(sample_marker, AnalyzerResults::One, chnlSMBDAT); - else if (bus_signal == SMB_ACK) - pResults->AddMarker(sample_marker, AnalyzerResults::Dot, chnlSMBDAT); - else if (bus_signal == SMB_NACK) - pResults->AddMarker(sample_marker, AnalyzerResults::ErrorDot, chnlSMBDAT); - - } else if (bus_signal == SMB_Start || bus_signal == SMB_Stop) { - pResults->AddMarker(sample_marker, bus_signal == SMB_Stop ? AnalyzerResults::Stop : AnalyzerResults::Start, chnlSMBDAT); - } + if( bus_signal == SMB_Zero || bus_signal == SMB_One || bus_signal == SMB_ACK || bus_signal == SMB_NACK ) + { + pResults->AddMarker( sample_rising_clk, AnalyzerResults::UpArrow, chnlSMBCLK ); + + if( bus_signal == SMB_Zero ) + pResults->AddMarker( sample_marker, AnalyzerResults::Zero, chnlSMBDAT ); + else if( bus_signal == SMB_One ) + pResults->AddMarker( sample_marker, AnalyzerResults::One, chnlSMBDAT ); + else if( bus_signal == SMB_ACK ) + pResults->AddMarker( sample_marker, AnalyzerResults::Dot, chnlSMBDAT ); + else if( bus_signal == SMB_NACK ) + pResults->AddMarker( sample_marker, AnalyzerResults::ErrorDot, chnlSMBDAT ); + } + else if( bus_signal == SMB_Start || bus_signal == SMB_Stop ) + { + pResults->AddMarker( sample_marker, bus_signal == SMB_Stop ? AnalyzerResults::Stop : AnalyzerResults::Start, chnlSMBDAT ); + } } // ************************************************************************************ SMBusByte::SMBusByte() { - Clear(); + Clear(); } void SMBusByte::Clear() { - value = 0; - is_acked = false; - signals.clear(); + value = 0; + is_acked = false; + signals.clear(); } Frame SMBusByte::ToFrame() const { - Frame f; + Frame f; - f.mType = FT_Byte; - f.mStartingSampleInclusive = signals.front().sample_begin; - f.mEndingSampleInclusive = signals.back().sample_end; - f.mData1 = value; - f.mData2 = 0; - f.mFlags = is_acked ? F_IsAcked : 0; + f.mType = FT_Byte; + f.mStartingSampleInclusive = signals.front().sample_begin; + f.mEndingSampleInclusive = signals.back().sample_end; + f.mData1 = value; + f.mData2 = 0; + f.mFlags = is_acked ? F_IsAcked : 0; - return f; + return f; } -Frame SMBusByte::ToAddrFrame(const SMBusProtocol* pProt) const +Frame SMBusByte::ToAddrFrame( const SMBusProtocol* pProt ) const { - Frame f; + Frame f; - f.mType = FT_Address; - f.mStartingSampleInclusive = signals.front().sample_begin; - f.mEndingSampleInclusive = signals.back().sample_end; - f.mData1 = value >> 1; - f.mData2 = U64(pProt); - f.mFlags = 0; - if (is_acked) - f.mFlags |= F_IsAcked; + f.mType = FT_Address; + f.mStartingSampleInclusive = signals.front().sample_begin; + f.mEndingSampleInclusive = signals.back().sample_end; + f.mData1 = value >> 1; + f.mData2 = U64( pProt ); + f.mFlags = 0; + if( is_acked ) + f.mFlags |= F_IsAcked; - if (value & 1) - f.mFlags |= F_IsRead; + if( value & 1 ) + f.mFlags |= F_IsRead; - return f; + return f; } Frame SMBusByte::ToPMBusCommandFrame() const { - Frame f; - - f.mType = FT_CmdPMBus; - f.mStartingSampleInclusive = signals.front().sample_begin; - f.mEndingSampleInclusive = signals.back().sample_end; - f.mData1 = value; - f.mData2 = 0; - f.mFlags = 0; - if (is_acked) - f.mFlags |= F_IsAcked; - - return f; + Frame f; + + f.mType = FT_CmdPMBus; + f.mStartingSampleInclusive = signals.front().sample_begin; + f.mEndingSampleInclusive = signals.back().sample_end; + f.mData1 = value; + f.mData2 = 0; + f.mFlags = 0; + if( is_acked ) + f.mFlags |= F_IsAcked; + + return f; } Frame SMBusByte::ToSMBusCommandFrame() const { - Frame f; - - f.mType = FT_CmdSMBus; - f.mStartingSampleInclusive = signals.front().sample_begin; - f.mEndingSampleInclusive = signals.back().sample_end; - f.mData1 = value; - f.mData2 = 0; - f.mFlags = 0; - if (is_acked) - f.mFlags |= F_IsAcked; - - return f; + Frame f; + + f.mType = FT_CmdSMBus; + f.mStartingSampleInclusive = signals.front().sample_begin; + f.mEndingSampleInclusive = signals.back().sample_end; + f.mData1 = value; + f.mData2 = 0; + f.mFlags = 0; + if( is_acked ) + f.mFlags |= F_IsAcked; + + return f; } Frame SMBusByte::ToSmartBatteryCommandFrame() const { - Frame f; - - f.mType = FT_CmdSmartBattery; - f.mStartingSampleInclusive = signals.front().sample_begin; - f.mEndingSampleInclusive = signals.back().sample_end; - f.mData1 = value; - f.mData2 = 0; - f.mFlags = 0; - if (is_acked) f.mFlags |= F_IsAcked; - - return f; + Frame f; + + f.mType = FT_CmdSmartBattery; + f.mStartingSampleInclusive = signals.front().sample_begin; + f.mEndingSampleInclusive = signals.back().sample_end; + f.mData1 = value; + f.mData2 = 0; + f.mFlags = 0; + if( is_acked ) + f.mFlags |= F_IsAcked; + + return f; } -Frame SMBusByte::ToPMBusCommandExtFrame(const SMBusByte& sec) const +Frame SMBusByte::ToPMBusCommandExtFrame( const SMBusByte& sec ) const { - Frame f; - - f.mType = FT_CmdPMBus; - f.mStartingSampleInclusive = signals.front().sample_begin; - f.mEndingSampleInclusive = sec.signals.back().sample_end; - f.mData1 = value; - f.mData1 <<= 8; - f.mData1 |= sec.value; - f.mData2 = 0; - f.mFlags = 0; - if (is_acked) - f.mFlags |= F_IsAcked; - - return f; + Frame f; + + f.mType = FT_CmdPMBus; + f.mStartingSampleInclusive = signals.front().sample_begin; + f.mEndingSampleInclusive = sec.signals.back().sample_end; + f.mData1 = value; + f.mData1 <<= 8; + f.mData1 |= sec.value; + f.mData2 = 0; + f.mFlags = 0; + if( is_acked ) + f.mFlags |= F_IsAcked; + + return f; } -Frame SMBusByte::ToDataWord(const SMBusByte& sec, SMBusFrameType frame_type) const +Frame SMBusByte::ToDataWord( const SMBusByte& sec, SMBusFrameType frame_type ) const { - Frame f; - - f.mType = frame_type; - f.mStartingSampleInclusive = signals.front().sample_begin; - f.mEndingSampleInclusive = sec.signals.back().sample_end; - f.mData1 = value; - f.mData1 <<= 8; - f.mData1 |= sec.value; - f.mData2 = 0; - f.mFlags = 0; - if (is_acked) - f.mFlags |= F_IsAcked; - - return f; + Frame f; + + f.mType = frame_type; + f.mStartingSampleInclusive = signals.front().sample_begin; + f.mEndingSampleInclusive = sec.signals.back().sample_end; + f.mData1 = value; + f.mData1 <<= 8; + f.mData1 |= sec.value; + f.mData2 = 0; + f.mFlags = 0; + if( is_acked ) + f.mFlags |= F_IsAcked; + + return f; } Frame SMBusByte::ToByteCount() const { - Frame f; - - f.mType = FT_ByteCount; - f.mStartingSampleInclusive = signals.front().sample_begin; - f.mEndingSampleInclusive = signals.back().sample_end; - f.mData1 = value; - f.mData2 = 0; - f.mFlags = 0; - if (is_acked) - f.mFlags |= F_IsAcked; - - return f; + Frame f; + + f.mType = FT_ByteCount; + f.mStartingSampleInclusive = signals.front().sample_begin; + f.mEndingSampleInclusive = signals.back().sample_end; + f.mData1 = value; + f.mData2 = 0; + f.mFlags = 0; + if( is_acked ) + f.mFlags |= F_IsAcked; + + return f; } -Frame SMBusByte::ToDataByte(SMBusFrameType frame_type) const +Frame SMBusByte::ToDataByte( SMBusFrameType frame_type ) const { - Frame f; - - f.mType = frame_type; - f.mStartingSampleInclusive = signals.front().sample_begin; - f.mEndingSampleInclusive = signals.back().sample_end; - f.mData1 = value; - f.mData2 = 0; - f.mFlags = 0; - if (is_acked) - f.mFlags |= F_IsAcked; - - return f; + Frame f; + + f.mType = frame_type; + f.mStartingSampleInclusive = signals.front().sample_begin; + f.mEndingSampleInclusive = signals.back().sample_end; + f.mData1 = value; + f.mData2 = 0; + f.mFlags = 0; + if( is_acked ) + f.mFlags |= F_IsAcked; + + return f; } -Frame SMBusByte::ToPECFrame(const U8 calcedPEC) const +Frame SMBusByte::ToPECFrame( const U8 calcedPEC ) const { - Frame f; - - f.mType = FT_PEC; - f.mStartingSampleInclusive = signals.front().sample_begin; - f.mEndingSampleInclusive = signals.back().sample_end; - f.mData1 = value; - f.mData2 = calcedPEC; - f.mFlags = 0; - if (is_acked) - f.mFlags |= F_IsAcked; - - return f; + Frame f; + + f.mType = FT_PEC; + f.mStartingSampleInclusive = signals.front().sample_begin; + f.mEndingSampleInclusive = signals.back().sample_end; + f.mData1 = value; + f.mData2 = calcedPEC; + f.mFlags = 0; + if( is_acked ) + f.mFlags |= F_IsAcked; + + return f; } // ************************************************************************************ SMBusPacket::SMBusPacket() { - Clear(); + Clear(); } void SMBusPacket::Clear() { - chunks.clear(); - first_start.Clear(); - stop.Clear(); + chunks.clear(); + first_start.Clear(); + stop.Clear(); } /* void SMBusPacket::CreateDescFrames(SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, int desc_code) const { - // create the protocol description frames - Frame clkf; + // create the protocol description frames + Frame clkf; - clkf.mData1 = U64(pProt); - clkf.mData2 = desc_code; - clkf.mStartingSampleInclusive = chunks.front().front().signals.front().sample_begin; - clkf.mEndingSampleInclusive = chunks.back().back().signals.back().sample_end; - clkf.mType = FT_Desc; + clkf.mData1 = U64(pProt); + clkf.mData2 = desc_code; + clkf.mStartingSampleInclusive = chunks.front().front().signals.front().sample_begin; + clkf.mEndingSampleInclusive = chunks.back().back().signals.back().sample_end; + clkf.mType = FT_Desc; - pResults->AddFrame(clkf); + pResults->AddFrame(clkf); } */ -void SMBusPacket::CreateFrames(SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, bool has_pec, SMBusDecodeLevel dec_level) const +void SMBusPacket::CreateFrames( SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, bool has_pec, SMBusDecodeLevel dec_level ) const { - const SMBP_ProtElem* pProtElems = pProt->prot_elems; - - pResults->AddFrame(first_start.ToFrame()); - - // first try if we have a PMBus command with non-trivial parameters - if (dec_level == DL_PMBus && pProt != SMBus_QuickCommand) - { - // first check the command code against the PMBus table - const CommandDesc& cmd = GetPMBusCommandDesc(chunks.front()[1].value); - - // commands in Send byte SMBus protocol - if (pProt == SMBus_SendByte - && (cmd.id == CLEAR_FAULTS || cmd.id == STORE_DEFAULT_ALL || cmd.id == RESTORE_DEFAULT_ALL - || cmd.id == STORE_USER_ALL || cmd.id == RESTORE_USER_ALL)) - { - pResults->AddFrame(chunks.front()[0].ToAddrFrame(pProt)); - pResults->AddFrame(chunks.front()[1].ToPMBusCommandFrame()); - if (chunks.front().size() > 2) - pResults->AddFrame(chunks.back().back().ToPECFrame(CalcPEC(has_pec))); - - } else if (pProt == SMBus_WriteByte - && (cmd.direction == Write || cmd.direction == ReadWrite) - && cmd.databyte_param_type != FT_Undefined) { - - pResults->AddFrame(chunks.front()[0].ToAddrFrame(pProt)); - pResults->AddFrame(chunks.front()[1].ToPMBusCommandFrame()); - pResults->AddFrame(chunks.front()[2].ToDataByte(cmd.databyte_param_type)); - if (chunks.front().size() > 3) - pResults->AddFrame(chunks.back().back().ToPECFrame(CalcPEC(has_pec))); - - } else if (pProt == SMBus_ReadByte - && (cmd.direction == Read || cmd.direction == ReadWrite) - && cmd.databyte_param_type != FT_Undefined) { - - pResults->AddFrame(chunks.front()[0].ToAddrFrame(pProt)); - pResults->AddFrame(chunks.front()[1].ToPMBusCommandFrame()); - - pResults->AddFrame(chunks[1][0].ToAddrFrame(pProt)); - pResults->AddFrame(chunks[1][1].ToDataByte(cmd.databyte_param_type)); - if (chunks[1].size() > 2) - pResults->AddFrame(chunks[1][2].ToPECFrame(CalcPEC(has_pec))); - - } else if (pProt == SMBus_BlockProcessCall && chunks.front()[1].value == QUERY - && chunks.front().size() == 4 - && ((has_pec && chunks[1].size() == 4) || (!has_pec && chunks[1].size() == 3))) { - - // NOTE: - // it is not possible (as far as I know) to distinguish between a ProcessCall - // and a BlockProcessCall with byte counts of 1 - both have the same number of bytes - - pResults->AddFrame(chunks.front()[0].ToAddrFrame(pProt)); - pResults->AddFrame(chunks.front()[1].ToPMBusCommandFrame()); - pResults->AddFrame(chunks.front()[2].ToByteCount()); - pResults->AddFrame(chunks.front()[3].ToPMBusCommandFrame()); - - pResults->AddFrame(chunks[1][0].ToAddrFrame(pProt)); - pResults->AddFrame(chunks[1][1].ToByteCount()); - pResults->AddFrame(chunks[1][2].ToDataByte(FT_PMBusQuery)); - if (chunks[1].size() > 3) - pResults->AddFrame(chunks.back().back().ToPECFrame(CalcPEC(has_pec))); - - } else { - CreateDefaultFrames(pResults, pProt, has_pec, dec_level); - } - - } else if (dec_level == DL_SmartBattery && pProt != SMBus_QuickCommand) { - - // get the command code - const CommandDesc& cmd = GetSmartBatteryCommandDesc(chunks.front()[1].value); - - if (pProt == SMBus_WriteWord - && (cmd.direction == Write || cmd.direction == ReadWrite) - && cmd.databyte_param_type != FT_Undefined) - { - pResults->AddFrame(chunks.front()[0].ToAddrFrame(pProt)); - pResults->AddFrame(chunks.front()[1].ToSmartBatteryCommandFrame()); - pResults->AddFrame(chunks.front()[2].ToDataWord(chunks.front()[3], cmd.databyte_param_type)); - if (chunks.front().size() > 4) - pResults->AddFrame(chunks.back().back().ToPECFrame(CalcPEC(has_pec))); - - } else if (pProt == SMBus_ReadWord - && (cmd.direction == Read || cmd.direction == ReadWrite) - && cmd.databyte_param_type != FT_Undefined) { - - pResults->AddFrame(chunks.front()[0].ToAddrFrame(pProt)); - pResults->AddFrame(chunks.front()[1].ToSmartBatteryCommandFrame()); - - pResults->AddFrame(chunks[1][0].ToAddrFrame(pProt)); - pResults->AddFrame(chunks[1][1].ToDataWord(chunks[1][2], cmd.databyte_param_type)); - if (chunks[1].size() > 3) - pResults->AddFrame(chunks.back().back().ToPECFrame(CalcPEC(has_pec))); - } else { - CreateDefaultFrames(pResults, pProt, has_pec, dec_level); - } - - } else { - CreateDefaultFrames(pResults, pProt, has_pec, dec_level); - } - - pResults->AddFrame(stop.ToFrame()); + const SMBP_ProtElem* pProtElems = pProt->prot_elems; + + pResults->AddFrame( first_start.ToFrame() ); + + // first try if we have a PMBus command with non-trivial parameters + if( dec_level == DL_PMBus && pProt != SMBus_QuickCommand ) + { + // first check the command code against the PMBus table + const CommandDesc& cmd = GetPMBusCommandDesc( chunks.front()[ 1 ].value ); + + // commands in Send byte SMBus protocol + if( pProt == SMBus_SendByte && ( cmd.id == CLEAR_FAULTS || cmd.id == STORE_DEFAULT_ALL || cmd.id == RESTORE_DEFAULT_ALL || + cmd.id == STORE_USER_ALL || cmd.id == RESTORE_USER_ALL ) ) + { + pResults->AddFrame( chunks.front()[ 0 ].ToAddrFrame( pProt ) ); + pResults->AddFrame( chunks.front()[ 1 ].ToPMBusCommandFrame() ); + if( chunks.front().size() > 2 ) + pResults->AddFrame( chunks.back().back().ToPECFrame( CalcPEC( has_pec ) ) ); + } + else if( pProt == SMBus_WriteByte && ( cmd.direction == Write || cmd.direction == ReadWrite ) && + cmd.databyte_param_type != FT_Undefined ) + { + pResults->AddFrame( chunks.front()[ 0 ].ToAddrFrame( pProt ) ); + pResults->AddFrame( chunks.front()[ 1 ].ToPMBusCommandFrame() ); + pResults->AddFrame( chunks.front()[ 2 ].ToDataByte( cmd.databyte_param_type ) ); + if( chunks.front().size() > 3 ) + pResults->AddFrame( chunks.back().back().ToPECFrame( CalcPEC( has_pec ) ) ); + } + else if( pProt == SMBus_ReadByte && ( cmd.direction == Read || cmd.direction == ReadWrite ) && + cmd.databyte_param_type != FT_Undefined ) + { + pResults->AddFrame( chunks.front()[ 0 ].ToAddrFrame( pProt ) ); + pResults->AddFrame( chunks.front()[ 1 ].ToPMBusCommandFrame() ); + + pResults->AddFrame( chunks[ 1 ][ 0 ].ToAddrFrame( pProt ) ); + pResults->AddFrame( chunks[ 1 ][ 1 ].ToDataByte( cmd.databyte_param_type ) ); + if( chunks[ 1 ].size() > 2 ) + pResults->AddFrame( chunks[ 1 ][ 2 ].ToPECFrame( CalcPEC( has_pec ) ) ); + } + else if( pProt == SMBus_BlockProcessCall && chunks.front()[ 1 ].value == QUERY && chunks.front().size() == 4 && + ( ( has_pec && chunks[ 1 ].size() == 4 ) || ( !has_pec && chunks[ 1 ].size() == 3 ) ) ) + { + // NOTE: + // it is not possible (as far as I know) to distinguish between a ProcessCall + // and a BlockProcessCall with byte counts of 1 - both have the same number of bytes + + pResults->AddFrame( chunks.front()[ 0 ].ToAddrFrame( pProt ) ); + pResults->AddFrame( chunks.front()[ 1 ].ToPMBusCommandFrame() ); + pResults->AddFrame( chunks.front()[ 2 ].ToByteCount() ); + pResults->AddFrame( chunks.front()[ 3 ].ToPMBusCommandFrame() ); + + pResults->AddFrame( chunks[ 1 ][ 0 ].ToAddrFrame( pProt ) ); + pResults->AddFrame( chunks[ 1 ][ 1 ].ToByteCount() ); + pResults->AddFrame( chunks[ 1 ][ 2 ].ToDataByte( FT_PMBusQuery ) ); + if( chunks[ 1 ].size() > 3 ) + pResults->AddFrame( chunks.back().back().ToPECFrame( CalcPEC( has_pec ) ) ); + } + else + { + CreateDefaultFrames( pResults, pProt, has_pec, dec_level ); + } + } + else if( dec_level == DL_SmartBattery && pProt != SMBus_QuickCommand ) + { + // get the command code + const CommandDesc& cmd = GetSmartBatteryCommandDesc( chunks.front()[ 1 ].value ); + + if( pProt == SMBus_WriteWord && ( cmd.direction == Write || cmd.direction == ReadWrite ) && + cmd.databyte_param_type != FT_Undefined ) + { + pResults->AddFrame( chunks.front()[ 0 ].ToAddrFrame( pProt ) ); + pResults->AddFrame( chunks.front()[ 1 ].ToSmartBatteryCommandFrame() ); + pResults->AddFrame( chunks.front()[ 2 ].ToDataWord( chunks.front()[ 3 ], cmd.databyte_param_type ) ); + if( chunks.front().size() > 4 ) + pResults->AddFrame( chunks.back().back().ToPECFrame( CalcPEC( has_pec ) ) ); + } + else if( pProt == SMBus_ReadWord && ( cmd.direction == Read || cmd.direction == ReadWrite ) && + cmd.databyte_param_type != FT_Undefined ) + { + pResults->AddFrame( chunks.front()[ 0 ].ToAddrFrame( pProt ) ); + pResults->AddFrame( chunks.front()[ 1 ].ToSmartBatteryCommandFrame() ); + + pResults->AddFrame( chunks[ 1 ][ 0 ].ToAddrFrame( pProt ) ); + pResults->AddFrame( chunks[ 1 ][ 1 ].ToDataWord( chunks[ 1 ][ 2 ], cmd.databyte_param_type ) ); + if( chunks[ 1 ].size() > 3 ) + pResults->AddFrame( chunks.back().back().ToPECFrame( CalcPEC( has_pec ) ) ); + } + else + { + CreateDefaultFrames( pResults, pProt, has_pec, dec_level ); + } + } + else + { + CreateDefaultFrames( pResults, pProt, has_pec, dec_level ); + } + + pResults->AddFrame( stop.ToFrame() ); } -void SMBusPacket::CreateDefaultFrames(SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, bool has_pec, SMBusDecodeLevel dec_level) const +void SMBusPacket::CreateDefaultFrames( SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, bool has_pec, + SMBusDecodeLevel dec_level ) const { - const SMBP_ProtElem* pProtElems = pProt->prot_elems; - - U8 prot_elem_ndx = 1; // skip the initial Start - - size_t bcnt = 0, chnkcnt = 0; - bool should_end_on_nack = false; - int byte_count = -1; - while (pProtElems[prot_elem_ndx] != SMBP_Stop) - { - const std::vector& chunk(chunks[chnkcnt]); - - switch (pProtElems[prot_elem_ndx]) - { - case SMBP_Start: - bcnt = 0; - ++chnkcnt; - break; - case SMBP_AddrAny: - case SMBP_AddrWrite: - case SMBP_AddrHostWrite: - pResults->AddFrame(chunk[bcnt].ToAddrFrame(pProt)); - ++bcnt; - should_end_on_nack = false; - break; - case SMBP_AddrRead: - pResults->AddFrame(chunk[bcnt].ToAddrFrame(pProt)); - ++bcnt; - should_end_on_nack = true; - break; - case SMBP_Command: - if (dec_level == DL_PMBus) - pResults->AddFrame(chunk[bcnt].ToPMBusCommandFrame()); - else if (dec_level == DL_SmartBattery) - pResults->AddFrame(chunk[bcnt].ToSmartBatteryCommandFrame()); - else - pResults->AddFrame(chunk[bcnt].ToSMBusCommandFrame()); - - ++bcnt; - break; - case SMBP_CommandExt: - pResults->AddFrame(chunk[bcnt].ToPMBusCommandExtFrame(chunk[bcnt + 1])); - bcnt += 2; - break; - case SMBP_DataByte: - pResults->AddFrame(chunk[bcnt].ToDataByte()); - ++bcnt; - break; - case SMBP_DataWord: - pResults->AddFrame(chunk[bcnt].ToDataWord(chunk[bcnt + 1])); - bcnt += 2; - break; - case SMBP_ByteCount: - pResults->AddFrame(chunk[bcnt].ToByteCount()); - byte_count = chunk[bcnt].value; - ++bcnt; - break; - case SMBP_DataBlock: - - // create byte blocks - int c; - for (c = 0; c < byte_count; ++c) - pResults->AddFrame(chunk[bcnt + c].ToDataByte()); - - bcnt += byte_count; - - byte_count = -1; - - break; - } - - ++prot_elem_ndx; - } - - int bytes_remaining = chunks.back().size() - bcnt; - - if (has_pec && bytes_remaining == 1) - pResults->AddFrame(chunks.back().back().ToPECFrame(CalcPEC(has_pec))); + const SMBP_ProtElem* pProtElems = pProt->prot_elems; + + U8 prot_elem_ndx = 1; // skip the initial Start + + size_t bcnt = 0, chnkcnt = 0; + bool should_end_on_nack = false; + int byte_count = -1; + while( pProtElems[ prot_elem_ndx ] != SMBP_Stop ) + { + const std::vector& chunk( chunks[ chnkcnt ] ); + + switch( pProtElems[ prot_elem_ndx ] ) + { + case SMBP_Start: + bcnt = 0; + ++chnkcnt; + break; + case SMBP_AddrAny: + case SMBP_AddrWrite: + case SMBP_AddrHostWrite: + pResults->AddFrame( chunk[ bcnt ].ToAddrFrame( pProt ) ); + ++bcnt; + should_end_on_nack = false; + break; + case SMBP_AddrRead: + pResults->AddFrame( chunk[ bcnt ].ToAddrFrame( pProt ) ); + ++bcnt; + should_end_on_nack = true; + break; + case SMBP_Command: + if( dec_level == DL_PMBus ) + pResults->AddFrame( chunk[ bcnt ].ToPMBusCommandFrame() ); + else if( dec_level == DL_SmartBattery ) + pResults->AddFrame( chunk[ bcnt ].ToSmartBatteryCommandFrame() ); + else + pResults->AddFrame( chunk[ bcnt ].ToSMBusCommandFrame() ); + + ++bcnt; + break; + case SMBP_CommandExt: + pResults->AddFrame( chunk[ bcnt ].ToPMBusCommandExtFrame( chunk[ bcnt + 1 ] ) ); + bcnt += 2; + break; + case SMBP_DataByte: + pResults->AddFrame( chunk[ bcnt ].ToDataByte() ); + ++bcnt; + break; + case SMBP_DataWord: + pResults->AddFrame( chunk[ bcnt ].ToDataWord( chunk[ bcnt + 1 ] ) ); + bcnt += 2; + break; + case SMBP_ByteCount: + pResults->AddFrame( chunk[ bcnt ].ToByteCount() ); + byte_count = chunk[ bcnt ].value; + ++bcnt; + break; + case SMBP_DataBlock: + + // create byte blocks + int c; + for( c = 0; c < byte_count; ++c ) + pResults->AddFrame( chunk[ bcnt + c ].ToDataByte() ); + + bcnt += byte_count; + + byte_count = -1; + + break; + } + + ++prot_elem_ndx; + } + + int bytes_remaining = chunks.back().size() - bcnt; + + if( has_pec && bytes_remaining == 1 ) + pResults->AddFrame( chunks.back().back().ToPECFrame( CalcPEC( has_pec ) ) ); } -void SMBusPacket::CreateFramesForGroupCommand(SMBusAnalyzerResults* pResults, bool has_pec) const +void SMBusPacket::CreateFramesForGroupCommand( SMBusAnalyzerResults* pResults, bool has_pec ) const { - for (std::vector >::const_iterator ci(chunks.begin()); - ci != chunks.end(); - ++ci) - { - const std::vector& chunk(*ci); - - U8 pec = 0; - - pResults->AddFrame(chunk.front().ToAddrFrame(NULL)); // addr - pec = SMBusCRCLookup[pec ^ chunk.front().value]; - pResults->AddFrame(chunk[1].ToPMBusCommandFrame()); // command - pec = SMBusCRCLookup[pec ^ chunk[1].value]; - - for (size_t bcnt = 2; bcnt < chunk.size() - (has_pec ? 1 : 0); ++bcnt) - { - pResults->AddFrame(chunk[bcnt].ToDataByte()); - pec = SMBusCRCLookup[pec ^ chunk[bcnt].value]; - } - - if (has_pec) - pResults->AddFrame(chunk.back().ToPECFrame(pec)); - } + for( std::vector>::const_iterator ci( chunks.begin() ); ci != chunks.end(); ++ci ) + { + const std::vector& chunk( *ci ); + + U8 pec = 0; + + pResults->AddFrame( chunk.front().ToAddrFrame( NULL ) ); // addr + pec = SMBusCRCLookup[ pec ^ chunk.front().value ]; + pResults->AddFrame( chunk[ 1 ].ToPMBusCommandFrame() ); // command + pec = SMBusCRCLookup[ pec ^ chunk[ 1 ].value ]; + + for( size_t bcnt = 2; bcnt < chunk.size() - ( has_pec ? 1 : 0 ); ++bcnt ) + { + pResults->AddFrame( chunk[ bcnt ].ToDataByte() ); + pec = SMBusCRCLookup[ pec ^ chunk[ bcnt ].value ]; + } + + if( has_pec ) + pResults->AddFrame( chunk.back().ToPECFrame( pec ) ); + } } -void SMBusPacket::CreateFramesForRawData(SMBusAnalyzerResults* pResults, bool has_pec) const +void SMBusPacket::CreateFramesForRawData( SMBusAnalyzerResults* pResults, bool has_pec ) const { - for (std::vector >::const_iterator ci(chunks.begin()); - ci != chunks.end(); - ++ci) - { - const std::vector& chunk(*ci); + for( std::vector>::const_iterator ci( chunks.begin() ); ci != chunks.end(); ++ci ) + { + const std::vector& chunk( *ci ); - if( chunk.size() == 0 ) - continue; + if( chunk.size() == 0 ) + continue; - U8 pec = 0; + U8 pec = 0; - pResults->AddFrame(chunk.front().ToAddrFrame(0)); // addr - pec = SMBusCRCLookup[pec ^ chunk.front().value]; + pResults->AddFrame( chunk.front().ToAddrFrame( 0 ) ); // addr + pec = SMBusCRCLookup[ pec ^ chunk.front().value ]; - for (size_t bcnt = 1; bcnt < chunk.size() - (has_pec ? 1 : 0); ++bcnt) - { - pResults->AddFrame(chunk[bcnt].ToDataByte()); - pec = SMBusCRCLookup[pec ^ chunk[bcnt].value]; - } + for( size_t bcnt = 1; bcnt < chunk.size() - ( has_pec ? 1 : 0 ); ++bcnt ) + { + pResults->AddFrame( chunk[ bcnt ].ToDataByte() ); + pec = SMBusCRCLookup[ pec ^ chunk[ bcnt ].value ]; + } - if (has_pec) - pResults->AddFrame(chunk.back().ToPECFrame(pec)); - } + if( has_pec ) + pResults->AddFrame( chunk.back().ToPECFrame( pec ) ); + } } // CRC-8 lookup table for SMBus PEC calculation -const U8 SMBusCRCLookup[] = -{ -0x00,0x07,0x0E,0x09,0x1C,0x1B,0x12,0x15,0x38,0x3F,0x36,0x31,0x24,0x23,0x2A,0x2D, -0x70,0x77,0x7E,0x79,0x6C,0x6B,0x62,0x65,0x48,0x4F,0x46,0x41,0x54,0x53,0x5A,0x5D, -0xE0,0xE7,0xEE,0xE9,0xFC,0xFB,0xF2,0xF5,0xD8,0xDF,0xD6,0xD1,0xC4,0xC3,0xCA,0xCD, -0x90,0x97,0x9E,0x99,0x8C,0x8B,0x82,0x85,0xA8,0xAF,0xA6,0xA1,0xB4,0xB3,0xBA,0xBD, -0xC7,0xC0,0xC9,0xCE,0xDB,0xDC,0xD5,0xD2,0xFF,0xF8,0xF1,0xF6,0xE3,0xE4,0xED,0xEA, -0xB7,0xB0,0xB9,0xBE,0xAB,0xAC,0xA5,0xA2,0x8F,0x88,0x81,0x86,0x93,0x94,0x9D,0x9A, -0x27,0x20,0x29,0x2E,0x3B,0x3C,0x35,0x32,0x1F,0x18,0x11,0x16,0x03,0x04,0x0D,0x0A, -0x57,0x50,0x59,0x5E,0x4B,0x4C,0x45,0x42,0x6F,0x68,0x61,0x66,0x73,0x74,0x7D,0x7A, -0x89,0x8E,0x87,0x80,0x95,0x92,0x9B,0x9C,0xB1,0xB6,0xBF,0xB8,0xAD,0xAA,0xA3,0xA4, -0xF9,0xFE,0xF7,0xF0,0xE5,0xE2,0xEB,0xEC,0xC1,0xC6,0xCF,0xC8,0xDD,0xDA,0xD3,0xD4, -0x69,0x6E,0x67,0x60,0x75,0x72,0x7B,0x7C,0x51,0x56,0x5F,0x58,0x4D,0x4A,0x43,0x44, -0x19,0x1E,0x17,0x10,0x05,0x02,0x0B,0x0C,0x21,0x26,0x2F,0x28,0x3D,0x3A,0x33,0x34, -0x4E,0x49,0x40,0x47,0x52,0x55,0x5C,0x5B,0x76,0x71,0x78,0x7F,0x6A,0x6D,0x64,0x63, -0x3E,0x39,0x30,0x37,0x22,0x25,0x2C,0x2B,0x06,0x01,0x08,0x0F,0x1A,0x1D,0x14,0x13, -0xAE,0xA9,0xA0,0xA7,0xB2,0xB5,0xBC,0xBB,0x96,0x91,0x98,0x9F,0x8A,0x8D,0x84,0x83, -0xDE,0xD9,0xD0,0xD7,0xC2,0xC5,0xCC,0xCB,0xE6,0xE1,0xE8,0xEF,0xFA,0xFD,0xF4,0xF3 +const U8 SMBusCRCLookup[] = { + 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D, 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, + 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D, 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, + 0xC4, 0xC3, 0xCA, 0xCD, 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD, 0xC7, 0xC0, + 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2, 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA, 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2, + 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A, 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32, 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, + 0x0D, 0x0A, 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42, 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A, 0x89, 0x8E, 0x87, 0x80, + 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4, 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC, 0xC1, 0xC6, + 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4, 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C, 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44, + 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34, 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, + 0x5C, 0x5B, 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63, 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B, 0x06, 0x01, 0x08, 0x0F, + 0x1A, 0x1D, 0x14, 0x13, 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83, 0xDE, 0xD9, + 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3 }; -U8 SMBusPacket::CalcPEC(bool has_pec) const +U8 SMBusPacket::CalcPEC( bool has_pec ) const { - U8 ret_val = 0; - - for (std::vector >::const_iterator ci(chunks.begin()); - ci != chunks.end(); - ++ci) - { - for (std::vector::const_iterator bi(ci->begin()); - bi != ci->end(); - ++bi) - { - if (!has_pec || ci != chunks.end() - 1 || bi != ci->end() - 1) - ret_val = SMBusCRCLookup[ret_val ^ bi->value]; - } - } - - return ret_val; + U8 ret_val = 0; + + for( std::vector>::const_iterator ci( chunks.begin() ); ci != chunks.end(); ++ci ) + { + for( std::vector::const_iterator bi( ci->begin() ); bi != ci->end(); ++bi ) + { + if( !has_pec || ci != chunks.end() - 1 || bi != ci->end() - 1 ) + ret_val = SMBusCRCLookup[ ret_val ^ bi->value ]; + } + } + + return ret_val; } -bool SMBusPacket::MatchesProtocol(const SMBusProtocol* pProt, bool has_pec) const +bool SMBusPacket::MatchesProtocol( const SMBusProtocol* pProt, bool has_pec ) const { - U8 prot_elem_ndx = 1; // skip the initial Start - - if (chunks.empty()) - return false; - - const SMBP_ProtElem* pProtElems = pProt->prot_elems; - - size_t bcnt = 0, chnkcnt = 0; - int byte_count = -1; - while (pProtElems[prot_elem_ndx] != SMBP_Stop) - { - if (chunks.size() <= chnkcnt) - return false; - - const std::vector& chunk(chunks[chnkcnt]); - - if (chunk.empty()) - return false; - - if (pProtElems[prot_elem_ndx] != SMBP_Start && pProtElems[prot_elem_ndx] != SMBP_Stop - && chunk.size() <= bcnt) - return false; - - switch (pProtElems[prot_elem_ndx]) - { - case SMBP_Start: - - // check if we've consumed the previous chunks - if (chunk.size() != bcnt) - return false; - - bcnt = 0; - ++chnkcnt; - break; - case SMBP_AddrAny: - ++bcnt; - break; - case SMBP_AddrRead: - if (!chunk[bcnt].IsRead()) - return false; - - ++bcnt; - break; - case SMBP_AddrWrite: - if (chunk[bcnt].IsRead()) - return false; - - ++bcnt; - break; - case SMBP_AddrHostWrite: - if (chunk[bcnt].GetAddr() != 0x04 // Host addr - || chunk[bcnt].IsRead()) - return false; - - ++bcnt; - break; - case SMBP_Command: - ++bcnt; - break; - case SMBP_CommandExt: - if (chunk[bcnt].value != PMBUS_COMMAND_EXT) - return false; - - bcnt += 2; - break; - case SMBP_DataByte: - ++bcnt; - break; - case SMBP_DataWord: - bcnt += 2; - break; - case SMBP_ByteCount: - byte_count = chunk[bcnt].value; - ++bcnt; - break; - case SMBP_DataBlock: - bcnt += byte_count; - byte_count = -1; - break; - } - - ++prot_elem_ndx; - } - - if (chnkcnt != chunks.size() - 1) - return false; - - int bytes_remaining = chunks.back().size() - bcnt; - - // if we have a quick command, it's OK for have 1 single byte packet without PEC - if (chunks.size() == 1 && chunks.front().size() == 1 && bytes_remaining == 0) - return true; - - if (has_pec) - return bytes_remaining == 1; - - return bytes_remaining == 0; + U8 prot_elem_ndx = 1; // skip the initial Start + + if( chunks.empty() ) + return false; + + const SMBP_ProtElem* pProtElems = pProt->prot_elems; + + size_t bcnt = 0, chnkcnt = 0; + int byte_count = -1; + while( pProtElems[ prot_elem_ndx ] != SMBP_Stop ) + { + if( chunks.size() <= chnkcnt ) + return false; + + const std::vector& chunk( chunks[ chnkcnt ] ); + + if( chunk.empty() ) + return false; + + if( pProtElems[ prot_elem_ndx ] != SMBP_Start && pProtElems[ prot_elem_ndx ] != SMBP_Stop && chunk.size() <= bcnt ) + return false; + + switch( pProtElems[ prot_elem_ndx ] ) + { + case SMBP_Start: + + // check if we've consumed the previous chunks + if( chunk.size() != bcnt ) + return false; + + bcnt = 0; + ++chnkcnt; + break; + case SMBP_AddrAny: + ++bcnt; + break; + case SMBP_AddrRead: + if( !chunk[ bcnt ].IsRead() ) + return false; + + ++bcnt; + break; + case SMBP_AddrWrite: + if( chunk[ bcnt ].IsRead() ) + return false; + + ++bcnt; + break; + case SMBP_AddrHostWrite: + if( chunk[ bcnt ].GetAddr() != 0x04 // Host addr + || chunk[ bcnt ].IsRead() ) + return false; + + ++bcnt; + break; + case SMBP_Command: + ++bcnt; + break; + case SMBP_CommandExt: + if( chunk[ bcnt ].value != PMBUS_COMMAND_EXT ) + return false; + + bcnt += 2; + break; + case SMBP_DataByte: + ++bcnt; + break; + case SMBP_DataWord: + bcnt += 2; + break; + case SMBP_ByteCount: + byte_count = chunk[ bcnt ].value; + ++bcnt; + break; + case SMBP_DataBlock: + bcnt += byte_count; + byte_count = -1; + break; + } + + ++prot_elem_ndx; + } + + if( chnkcnt != chunks.size() - 1 ) + return false; + + int bytes_remaining = chunks.back().size() - bcnt; + + // if we have a quick command, it's OK for have 1 single byte packet without PEC + if( chunks.size() == 1 && chunks.front().size() == 1 && bytes_remaining == 0 ) + return true; + + if( has_pec ) + return bytes_remaining == 1; + + return bytes_remaining == 0; } -bool SMBusPacket::MatchesGroupCommand(bool has_pec) const +bool SMBusPacket::MatchesGroupCommand( bool has_pec ) const { - for (std::vector >::const_iterator ci(chunks.begin()); - ci != chunks.end(); - ++ci) - { - const std::vector& chunk(*ci); + for( std::vector>::const_iterator ci( chunks.begin() ); ci != chunks.end(); ++ci ) + { + const std::vector& chunk( *ci ); - if (chunk.empty()) - return false; + if( chunk.empty() ) + return false; - // we must have an addr write first - if (chunk.front().value & 1) - return false; + // we must have an addr write first + if( chunk.front().value & 1 ) + return false; - // we must have at least one data byte + PEC (if present) - if (chunk.size() < size_t(3 + (has_pec ? 1 : 0))) - return false; - } + // we must have at least one data byte + PEC (if present) + if( chunk.size() < size_t( 3 + ( has_pec ? 1 : 0 ) ) ) + return false; + } - return true; + return true; } -std::string int2str(const U8 i) +std::string int2str( const U8 i ) { - char number_str[8]; - AnalyzerHelpers::GetNumberString(i, Decimal, 8, number_str, sizeof(number_str)); - return number_str; + char number_str[ 8 ]; + AnalyzerHelpers::GetNumberString( i, Decimal, 8, number_str, sizeof( number_str ) ); + return number_str; } -std::string int2str_sal(const U64 i, DisplayBase base, const int max_bits) +std::string int2str_sal( const U64 i, DisplayBase base, const int max_bits ) { - char number_str[256]; - AnalyzerHelpers::GetNumberString(i, base, max_bits, number_str, sizeof(number_str)); - return number_str; + char number_str[ 256 ]; + AnalyzerHelpers::GetNumberString( i, base, max_bits, number_str, sizeof( number_str ) ); + return number_str; } diff --git a/src/SMBusTypes.h b/src/SMBusTypes.h index 90e4a53..75466b4 100644 --- a/src/SMBusTypes.h +++ b/src/SMBusTypes.h @@ -7,246 +7,250 @@ // the decoding level of the analyzer enum SMBusDecodeLevel { - DL_Signals, - DL_Bytes, - DL_SMBus, - DL_PMBus, - DL_SmartBattery, + DL_Signals, + DL_Bytes, + DL_SMBus, + DL_PMBus, + DL_SmartBattery, }; -// SMBus states +// SMBus states enum SMBusSignal { - SMB_Start, - SMB_Stop, - SMB_Zero, - SMB_One, + SMB_Start, + SMB_Stop, + SMB_Zero, + SMB_One, - SMB_ACK, - SMB_NACK, + SMB_ACK, + SMB_NACK, - SMB_Undefined, + SMB_Undefined, }; enum SMBusFrameType { - FT_Start, // signals - FT_Stop, - FT_Zero, - FT_One, - FT_ACK, - FT_NACK, + FT_Start, // signals + FT_Stop, + FT_Zero, + FT_One, + FT_ACK, + FT_NACK, - FT_Byte, // raw byte - FT_Word, // raw word + FT_Byte, // raw byte + FT_Word, // raw word - FT_Address, // address byte - FT_PEC, + FT_Address, // address byte + FT_PEC, - FT_CmdSMBus, // unknown SMBus command + FT_CmdSMBus, // unknown SMBus command - FT_CmdPMBus, // commands - FT_CmdSmartBattery, + FT_CmdPMBus, // commands + FT_CmdSmartBattery, - FT_ByteCount, // the block count. it's followed by raw bytes + FT_ByteCount, // the block count. it's followed by raw bytes - // PMBus command params - FT_PMBusCapability, - FT_PMBusQuery, - FT_PMBusWriteProtect, - FT_PMBusOperation, - FT_PMBusOnOffConfig, - FT_PMBusVoutMode, + // PMBus command params + FT_PMBusCapability, + FT_PMBusQuery, + FT_PMBusWriteProtect, + FT_PMBusOperation, + FT_PMBusOnOffConfig, + FT_PMBusVoutMode, - // SmartBattery - FT_SmartBattBatteryMode, - FT_SmartBattBatteryStatus, - FT_SmartBattSpecificationInfo, - FT_SmartBattManufactureDate, + // SmartBattery + FT_SmartBattBatteryMode, + FT_SmartBattBatteryStatus, + FT_SmartBattSpecificationInfo, + FT_SmartBattManufactureDate, - FT_Undefined, + FT_Undefined, }; enum SMBusFlags { - F_IsAcked = 0x01, - F_IsRead = 0x02, + F_IsAcked = 0x01, + F_IsRead = 0x02, }; struct SMBusSignalState { - U64 sample_begin; - U64 sample_end; + U64 sample_begin; + U64 sample_end; - U64 sample_marker; + U64 sample_marker; - U64 sample_rising_clk; // for data bits + U64 sample_rising_clk; // for data bits - SMBusSignal bus_signal; + SMBusSignal bus_signal; - SMBusSignalState() - { - Clear(); - } + SMBusSignalState() + { + Clear(); + } - void Clear() - { - sample_begin = sample_end = sample_marker = sample_rising_clk = 0; + void Clear() + { + sample_begin = sample_end = sample_marker = sample_rising_clk = 0; - bus_signal = SMB_Undefined; - } + bus_signal = SMB_Undefined; + } - Frame ToFrame() const; - void AddMarkers(AnalyzerResults* pResults, Channel& chnlSMBCLK, Channel& chnlSMBDAT); + Frame ToFrame() const; + void AddMarkers( AnalyzerResults* pResults, Channel& chnlSMBCLK, Channel& chnlSMBDAT ); - bool IsEmpty() const - { - return sample_begin == sample_end && sample_begin == 0; - } + bool IsEmpty() const + { + return sample_begin == sample_end && sample_begin == 0; + } }; // SMBus protocolelements that are parsable by small chunks of code enum SMBP_ProtElem { - SMBP_Start, - SMBP_Stop, - SMBP_AddrAny, - SMBP_AddrRead, - SMBP_AddrWrite, - SMBP_AddrHostWrite, - SMBP_Command, - SMBP_CommandExt, - SMBP_DataByte, - SMBP_DataWord, - SMBP_ByteCount, - SMBP_DataBlock, + SMBP_Start, + SMBP_Stop, + SMBP_AddrAny, + SMBP_AddrRead, + SMBP_AddrWrite, + SMBP_AddrHostWrite, + SMBP_Command, + SMBP_CommandExt, + SMBP_DataByte, + SMBP_DataWord, + SMBP_ByteCount, + SMBP_DataBlock, }; struct SMBusProtocol { - const char* name; // the name of the protocol - const SMBP_ProtElem prot_elems[10]; // the protocol elements + const char* name; // the name of the protocol + const SMBP_ProtElem prot_elems[ 10 ]; // the protocol elements }; -#define NUM_SMBUS_PROTOCOLS 12 -#define NUM_PMBUS_PROTOCOLS 4 +#define NUM_SMBUS_PROTOCOLS 12 +#define NUM_PMBUS_PROTOCOLS 4 -extern const SMBusProtocol SMBusProtocols[NUM_SMBUS_PROTOCOLS]; -extern const SMBusProtocol PMBusProtocols[NUM_PMBUS_PROTOCOLS]; +extern const SMBusProtocol SMBusProtocols[ NUM_SMBUS_PROTOCOLS ]; +extern const SMBusProtocol PMBusProtocols[ NUM_PMBUS_PROTOCOLS ]; struct SMBusByte { - U8 value; - bool is_acked; - std::vector signals; - - SMBusByte(); - void Clear(); - - bool IsComplete() const - { - return signals.size() == 9; // 8 data + ack/nack - } - - bool IsRead() const - { - return value & 1; - } - - U8 GetAddr() const - { - return value >> 1; - } - - Frame ToFrame() const; - Frame ToAddrFrame(const SMBusProtocol* pProt) const; - Frame ToSmartBatteryCommandFrame() const; - Frame ToSMBusCommandFrame() const; - Frame ToPMBusCommandFrame() const; - Frame ToPMBusCommandExtFrame(const SMBusByte& sec) const; - Frame ToDataByte(SMBusFrameType frame_type = FT_Byte) const; - Frame ToDataWord(const SMBusByte& sec, SMBusFrameType frame_type = FT_Word) const; - Frame ToPECFrame(const U8 calcedPEC) const; - Frame ToByteCount() const; + U8 value; + bool is_acked; + std::vector signals; + + SMBusByte(); + void Clear(); + + bool IsComplete() const + { + return signals.size() == 9; // 8 data + ack/nack + } + + bool IsRead() const + { + return value & 1; + } + + U8 GetAddr() const + { + return value >> 1; + } + + Frame ToFrame() const; + Frame ToAddrFrame( const SMBusProtocol* pProt ) const; + Frame ToSmartBatteryCommandFrame() const; + Frame ToSMBusCommandFrame() const; + Frame ToPMBusCommandFrame() const; + Frame ToPMBusCommandExtFrame( const SMBusByte& sec ) const; + Frame ToDataByte( SMBusFrameType frame_type = FT_Byte ) const; + Frame ToDataWord( const SMBusByte& sec, SMBusFrameType frame_type = FT_Word ) const; + Frame ToPECFrame( const U8 calcedPEC ) const; + Frame ToByteCount() const; }; class SMBusAnalyzerResults; struct SMBusPacket { - SMBusSignalState first_start; - SMBusSignalState stop; + SMBusSignalState first_start; + SMBusSignalState stop; - std::vector > chunks; + std::vector> chunks; - SMBusPacket(); - void Clear(); + SMBusPacket(); + void Clear(); - bool IsEmpty() const { return chunks.empty(); } + bool IsEmpty() const + { + return chunks.empty(); + } - // does not work for group command - U8 CalcPEC(bool has_pec) const; + // does not work for group command + U8 CalcPEC( bool has_pec ) const; - // these return true if the packet matches the specified protocol - bool MatchesProtocol(const SMBusProtocol* pProt, bool has_pec) const; - bool MatchesGroupCommand(bool has_pec) const; + // these return true if the packet matches the specified protocol + bool MatchesProtocol( const SMBusProtocol* pProt, bool has_pec ) const; + bool MatchesGroupCommand( bool has_pec ) const; - void CreateFrames(SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, bool has_pec, SMBusDecodeLevel dec_level) const; - void CreateDefaultFrames(SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, bool has_pec, SMBusDecodeLevel dec_level) const; - //void CreateDescFrames(SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, int desc_code) const; + void CreateFrames( SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, bool has_pec, SMBusDecodeLevel dec_level ) const; + void CreateDefaultFrames( SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, bool has_pec, SMBusDecodeLevel dec_level ) const; + // void CreateDescFrames(SMBusAnalyzerResults* pResults, const SMBusProtocol* pProt, int desc_code) const; - void CreateFramesForGroupCommand(SMBusAnalyzerResults* pResults, bool has_pec) const; - void CreateFramesForRawData(SMBusAnalyzerResults* pResults, bool has_pec) const; + void CreateFramesForGroupCommand( SMBusAnalyzerResults* pResults, bool has_pec ) const; + void CreateFramesForRawData( SMBusAnalyzerResults* pResults, bool has_pec ) const; }; extern const U8 SMBusCRCLookup[]; enum ParamDirection { - ReadWrite, - Read, - Write, - Send, - Undefined = -2, // const also used for length + ReadWrite, + Read, + Write, + Send, + Undefined = -2, // const also used for length }; -#define LengthVariable -1 +#define LengthVariable -1 // PEC calculation - CRC-8 with for a C(x) = x^8 + x^2 + x + 1 polynomial -U8 CalcPEC(const U8* pBytes, int numBytes); +U8 CalcPEC( const U8* pBytes, int numBytes ); // timings - not really used -#define ONE_MS 0.001 -#define ONE_US 0.000001 -#define ONE_NS 0.000000001 - -#define TBUF_MIN (4.7 * ONE_US) // Bus free time between Stop and Start Condition -#define THD_STA_MIN (4 * ONE_US) // Hold time after (Repeated) Start Condition. - // After this period, the first clock is generated. -#define TSU_STA_MIN (4.7 * ONE_US) // Repeated Start Condition setup time -#define TSU_STO_MIN (4 * ONE_US) // Stop Condition setup time -#define THD_DAT_MIN (300 * ONE_NS) // Data hold time -#define TSU_DAT_MIN (250 * ONE_NS) // Data setup time -#define TTIMEOUT_MIN (25 * ONE_MS) // Detect clock low timeout -#define TTIMEOUT_MAX (35 * ONE_MS) -#define TLOW_MIN (4.7 * ONE_US) // Clock low period -#define THIGH_MIN (4 * ONE_US) // Clock high period -#define THIGH_MAX (50 * ONE_US) -#define TLOW_SEXT_MAX (25 * ONE_MS) // Cumulative clock low extend time (slave device) -#define TLOW_MEXT_MAX (10 * ONE_MS) // Cumulative clock low extend time (master device) -#define TF_MAX (300 * ONE_NS) // Clock/Data Fall Time -#define TR_MAX (1000 * ONE_NS) // Clock/Data Rise Time -#define TPOR_MAX (500 * ONE_MS) // Time in which a device must be operational after power-on reset +#define ONE_MS 0.001 +#define ONE_US 0.000001 +#define ONE_NS 0.000000001 + +#define TBUF_MIN ( 4.7 * ONE_US ) // Bus free time between Stop and Start Condition +#define THD_STA_MIN \ + ( 4 * ONE_US ) // Hold time after (Repeated) Start Condition. + // After this period, the first clock is generated. +#define TSU_STA_MIN ( 4.7 * ONE_US ) // Repeated Start Condition setup time +#define TSU_STO_MIN ( 4 * ONE_US ) // Stop Condition setup time +#define THD_DAT_MIN ( 300 * ONE_NS ) // Data hold time +#define TSU_DAT_MIN ( 250 * ONE_NS ) // Data setup time +#define TTIMEOUT_MIN ( 25 * ONE_MS ) // Detect clock low timeout +#define TTIMEOUT_MAX ( 35 * ONE_MS ) +#define TLOW_MIN ( 4.7 * ONE_US ) // Clock low period +#define THIGH_MIN ( 4 * ONE_US ) // Clock high period +#define THIGH_MAX ( 50 * ONE_US ) +#define TLOW_SEXT_MAX ( 25 * ONE_MS ) // Cumulative clock low extend time (slave device) +#define TLOW_MEXT_MAX ( 10 * ONE_MS ) // Cumulative clock low extend time (master device) +#define TF_MAX ( 300 * ONE_NS ) // Clock/Data Fall Time +#define TR_MAX ( 1000 * ONE_NS ) // Clock/Data Rise Time +#define TPOR_MAX ( 500 * ONE_MS ) // Time in which a device must be operational after power-on reset // helpers & debug -std::string int2str_sal(const U64 i, DisplayBase base, const int max_bits = 8); -inline std::string int2str(const U64 i) +std::string int2str_sal( const U64 i, DisplayBase base, const int max_bits = 8 ); +inline std::string int2str( const U64 i ) { - return int2str_sal(i, Decimal, 64); + return int2str_sal( i, Decimal, 64 ); } /* @@ -254,16 +258,16 @@ inline std::string int2str(const U64 i) inline void debug(const std::string& str) { #if !defined(NDEBUG) && defined(_WINDOWS) - ::OutputDebugStringA(("----- " + str + "\n").c_str()); + ::OutputDebugStringA(("----- " + str + "\n").c_str()); #endif } inline void debug(const char* str) { #if !defined(NDEBUG) && defined(_WINDOWS) - debug(std::string(str)); + debug(std::string(str)); #endif } */ -#endif // SMBUS_TYPES_H +#endif // SMBUS_TYPES_H