Enot/LPCClocklessAnalyzer
1
0
Fork 0
mirror of https://github.com/stacksmashing/LPCClocklessAnalyzer.git synced 2026-01-30 19:08:38 +03:00
Code Issues Packages Projects Releases Wiki Activity

Working

Browse Source
This commit is contained in:
Thomas Roth
2023-10-12 19:20:33 +02:00
parent f911d69f4b
commit 291814dde4
4 changed files with 165 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
src/LPCClocklessAnalyzer.cpp
View File

@@ -48,9 +48,44 @@ void LPCClocklessAnalyzer::addFrameLabel(uint64_t start, uint64_t end, uint64_t
ReportProgress(end);
}
uint32_t LPCClocklessAnalyzer::readAddress() {
uint32_t address = 0;
for(int i=0; i < 4; i++) {
mFrame->Advance( mSamplesPerBit );
advanceAllToFrame();
address |= getBits() << 4 * (3-i);
mResults->AddMarker( mFrame->GetSampleNumber(), AnalyzerResults::Dot, mSettings->mFrameChannel );
}
return address;
}
void LPCClocklessAnalyzer::skipTar() {
mFrame->Advance( mSamplesPerBit );
mFrame->Advance( mSamplesPerBit );
}
uint8_t LPCClocklessAnalyzer::readData() {
uint8_t data = 0;
mFrame->Advance( mSamplesPerBit );
advanceAllToFrame();
data = getBits();
mFrame->Advance( mSamplesPerBit );
advanceAllToFrame();
data |= getBits() << 4;
return data;
}
uint8_t LPCClocklessAnalyzer::readSync() {
mFrame->Advance( mSamplesPerBit );
advanceAllToFrame();
return getBits();
}
void LPCClocklessAnalyzer::WorkerThread()
{
mSampleRateHz = GetSampleRate();
mSamplesPerBit = mSampleRateHz / (mSettings->mBitRate * 1000);
mFrame = GetAnalyzerChannelData( mSettings->mFrameChannel );
for(int i=0; i < 4; i++) {
mLadd[i] = GetAnalyzerChannelData( mSettings->mLaddChannel[i] );
@@ -60,14 +95,19 @@ void LPCClocklessAnalyzer::WorkerThread()
// - U32 samples_per_bit = mSampleRateHz / mSettings->mBitRate;
// - U32 mSamplesPerBit = mSampleRateHz / mSettings->mBitRate;
U32 samples_per_bit = mSampleRateHz / (mSettings->mBitRate * 1000);
std::cout << "Samples per bit: " << samples_per_bit << std::endl;
// mSamplesPerBit = mSampleRateHz / (mSettings->mBitRate * 1000);
std::cout << "Samples per bit: " << mSamplesPerBit << std::endl;
// U32 samples_to_first_center_of_first_data_bit = U32( 1.5 * double( mSampleRateHz ) / double( mSettings->mBitRate ) );
for( ; ; )
{
// Frame f;
// f.mType = 0x99;
bool is_write = false;
U8 data = 0;
@@ -77,7 +117,11 @@ void LPCClocklessAnalyzer::WorkerThread()
if( mFrame->GetBitState() == BIT_HIGH )
mFrame->AdvanceToNextEdge();
mFrame->Advance(samples_per_bit/2);
uint64_t total_starting_sample = mFrame->GetSampleNumber();
mFrame->Advance(mSamplesPerBit/2);
advanceAllToFrame();
// Check pattern
uint8_t bits = getBits();
@@ -92,96 +136,78 @@ void LPCClocklessAnalyzer::WorkerThread()
continue;
}
// mLadd[0]->AdvanceToAbsPosition(mFrame->GetSampleNumber());
// // Often the ladd lines are delayed to the actual clock transition in my testing.
// if( mLadd[0]->GetBitState() == BIT_HIGH ) {
// mLadd[0]->AdvanceToNextEdge();
// }
// mFrame->AdvanceToAbsPosition(mLadd[0]->GetSampleNumber());
// for(int i=1; i < 4; i++) {
// mLadd[i]->AdvanceToAbsPosition(mLadd[0]->GetSampleNumber());
// }
// std::cout << "Advancing..." << mFrame->GetSampleNumber() << std::endl;
// mFrame->Advance(samples_per_bit/2);
// mSerial->AdvanceToNextEdge(); //falling edge -- beginning of the start bit
U64 starting_sample = mFrame->GetSampleNumber();
// Go to CYCTYPE + DIR
// 0000 = read
// 0010 = write
mFrame->Advance( samples_per_bit );
mFrame->Advance( mSamplesPerBit );
advanceAllToFrame();
uint8_t cyctype_dir = getBits();
if(cyctype_dir == 0x02) {
printf("Is write\n");
// printf("Is write\n");
is_write = true;
// f.is_write = true;
} else {
// f.is_write = false;
}
addFrameLabel(starting_sample, mFrame->GetSampleNumber(), cyctype_dir);
// Frame frame;
// frame.mData1 = cyctype_dir;
// frame.mFlags = 0;
// frame.mStartingSampleInclusive = starting_sample;
// frame.mEndingSampleInclusive = mFrame->GetSampleNumber();
// mResults->AddFrame( frame );
// mResults->CommitResults();
// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), cyctype_dir);
//let's put a dot exactly where we sample this bit:
mResults->AddMarker( mFrame->GetSampleNumber(), AnalyzerResults::Dot, mSettings->mFrameChannel );
starting_sample = mFrame->GetSampleNumber();
// Iterate over address fields
uint32_t address = 0;
for(int i=0; i < 4; i++) {
mFrame->Advance( samples_per_bit );
advanceAllToFrame();
uint32_t address = readAddress();
// f.address = address;
// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), address);
// Read data/TAR
if(is_write) {
starting_sample = mFrame->GetSampleNumber();
data = readData();
// f.data = data;
// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), data);
skipTar();
starting_sample = mFrame->GetSampleNumber();
uint8_t sync = readSync();
// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), sync);
skipTar();
} else {
skipTar();
// sync field
starting_sample = mFrame->GetSampleNumber();
while(readSync() != 0) {
address |= getBits() << 4 * (3-i);
mResults->AddMarker( mFrame->GetSampleNumber(), AnalyzerResults::Dot, mSettings->mFrameChannel );
}
addFrameLabel(starting_sample, mFrame->GetSampleNumber(), address);
// frame.mData1 = address;
// frame.mFlags = 0;
// frame.mStartingSampleInclusive = starting_sample;
// frame.mEndingSampleInclusive = mFrame->GetSampleNumber();
// uint8_t sync = readSync();
// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), sync);
// mResults->AddFrame( frame );
// mResults->CommitResults();
// data field
starting_sample = mFrame->GetSampleNumber();
data = readData();
// f.data = data;
// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), data);
skipTar();
}
// Next bits depend on whether read or write
uint64_t transfer =
((uint64_t)cyctype_dir << 40) |
((uint64_t)address << 8) |
(data);
addFrameLabel(total_starting_sample, mFrame->GetSampleNumber(), transfer);
// f.mFlags = 0;
// f.mStartingSampleInclusive = total_starting_sample;
// f.mEndingSampleInclusive = mFrame->GetSampleNumber();
// mResults->AddFrame( f );
// if( mSerial->GetBitState() == BIT_HIGH )
// data |= mask;
// mFrame->Advance( samples_per_bit );
// mask = mask >> 1;
// }
//we have a byte to save.
// Frame frame;
// // frame.mData1 = data;
// frame.mFlags = 0;
// frame.mStartingSampleInclusive = starting_sample;
// frame.mEndingSampleInclusive = mFrame->GetSampleNumber();
// mResults->AddFrame( frame );
// mResults->CommitResults();
// ReportProgress( frame.mEndingSampleInclusive );
mResults->CommitResults();
ReportProgress(mFrame->GetSampleNumber());
mFrame->AdvanceToNextEdge();
}
}

5
src/LPCClocklessAnalyzer.h
View File

@@ -33,6 +33,7 @@ protected: //vars
//Serial analysis vars:
U32 mSampleRateHz;
U32 mSamplesPerBit;
U32 mStartOfStopBitOffset;
U32 mEndOfStopBitOffset;
@@ -40,6 +41,10 @@ private:
uint8_t getBits();
void advanceAllToFrame();
void addFrameLabel(uint64_t start, uint64_t end, uint64_t label);
uint32_t readAddress();
void skipTar();
uint8_t readData();
uint8_t readSync();
};
extern "C" ANALYZER_EXPORT const char* __cdecl GetAnalyzerName();

51
src/LPCClocklessAnalyzerResults.cpp
View File

@@ -5,6 +5,8 @@
#include <iostream>
#include <fstream>
LPCClocklessAnalyzerResults::LPCClocklessAnalyzerResults( LPCClocklessAnalyzer* analyzer, LPCClocklessAnalyzerSettings* settings )
: AnalyzerResults(),
mSettings( settings ),
@@ -22,8 +24,26 @@ void LPCClocklessAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel&
Frame frame = GetFrame( frame_index );
char number_str[128];
AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
AddResultString( number_str );
AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 48, number_str, 128 );
AddResultString( stringForFrame(display_base, &frame).c_str() );
}
std::string LPCClocklessAnalyzerResults::stringForFrame(DisplayBase display_base, Frame *f) {
uint64_t data = f->mData1;
std::string ret = "";
if((data & 0xff0000000000) == 0x020000000000) {
ret += "WRITE ";
} else {
ret += "READ ";
}
char address[128];
AnalyzerHelpers::GetNumberString((f->mData1 >> 8) & 0xFFFFFFFF, display_base, 32, address, 128);
ret += address;
ret += " DATA ";
char data_str[8];
AnalyzerHelpers::GetNumberString(f->mData1 & 0xFF, display_base, 8, data_str, 8);
ret += data_str;
return ret;
}
void LPCClocklessAnalyzerResults::GenerateExportFile( const char* file, DisplayBase display_base, U32 export_type_user_id )
@@ -61,12 +81,37 @@ void LPCClocklessAnalyzerResults::GenerateExportFile( const char* file, DisplayB
void LPCClocklessAnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base )
{
#ifdef SUPPORTS_PROTOCOL_SEARCH
Frame frame = GetFrame( frame_index );
// if(frame.mType == 0x99) {
// LPCFrame& req( ( LPCFrame& )frame);
// if(req.is_write) {
// AddTabularText("WRTE");
// } else {
// AddTabularText("READ");
// }
// char number_str[128];
// AnalyzerHelpers::GetNumberString( req.address, display_base, 8, number_str, 128 );
// AddTabularText( number_str );
// char number_str2[128];
// AnalyzerHelpers::GetNumberString( req.data, display_base, 8, number_str2, 128 );
// AddTabularText( number_str2 );
// } else {
ClearTabularText();
char number_str[128];
AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
// AnalyzerHelpers::GetNumberString()
AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 48, number_str, 128 );
AddTabularText( number_str );
AddResultString( stringForFrame(display_base, &frame).c_str() );
// AddTabularText("TEST");
// }
#endif
}

9
src/LPCClocklessAnalyzerResults.h
View File

@@ -6,6 +6,14 @@
class LPCClocklessAnalyzer;
class LPCClocklessAnalyzerSettings;
// struct LPCFrame : public Frame
// {
// bool is_write;
// uint32_t address;
// uint8_t sync;
// uint8_t data;
// };
class LPCClocklessAnalyzerResults : public AnalyzerResults
{
public:
@@ -18,6 +26,7 @@ public:
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 );
std::string stringForFrame(DisplayBase display_base, Frame *f);
protected: //functions