bool MainMemoryAccessBase::doRead(uint32_t address, uint32_t* buffer, size_t count)
{
MemoryArea* cpu = mm->getMemoryArea("CPU");
if (!cpu)
return false;
uint32_t pc = 0;
cpu->read(0, &pc, 1);
bool omitFirst = (address & 0x1);
if (omitFirst) {
--address;
++count;
}
bool omitLast = (count & 1);
if (omitLast) {
++count;
}
const hal_id readMacro = devHandle->supportsQuickMemRead() ?
ID_ReadMemQuick : ID_ReadMemWords;
HalExecElement* el = new HalExecElement(this->devHandle->checkHalId(readMacro));
el->appendInputData32(this->getStart() + address);
el->appendInputData32(static_cast<uint32_t>(count/2));
el->appendInputData32(pc);
el->setOutputSize(count);
ReadElement r(buffer, count, omitFirst, omitLast, 0);
this->readMap[this->elements.size()] = r;
this->elements.push_back(el);
return true;
}
bool RandomMemoryAccess::doWrite (uint32_t address, uint32_t* buffer, size_t count)
{
if (count > this->getSize())
return false;
uint32_t start_val = 0;
const uint32_t end_adr = address + count;
size_t paddedCount = count;
if(address & 1)
{
++paddedCount;
if( !doRead(address - 1, &start_val, 1) || !sync() )
return false;
}
uint32_t end_val = 0;
if(end_adr & 1)
{
++paddedCount;
if( !doRead(end_adr, &end_val, 1) || !sync() )
return false;
}
HalExecElement* el = new HalExecElement(this->devHandle->checkHalId(ID_WriteMemWords));
address += getStart();
el->appendInputData32(static_cast<uint32_t>(address & 0xfffffffe));
el->appendInputData32(static_cast<uint32_t>(paddedCount / 2));
if(address & 1)
{
el->appendInputData8(static_cast<uint8_t>(start_val));
}
for (size_t i = 0; i < count; ++i)
{
el->appendInputData8(static_cast<uint8_t>(buffer[i]));
}
if (end_adr & 1)
{
el->appendInputData16(static_cast<uint8_t>(end_val));
}
el->setInputMinSize(8); // at least address and size (4+4)
this->elements.push_back(el);
return true;
}
bool RandomMemoryAccess::writeBytes (uint32_t address, uint32_t* buffer, size_t count)
{
HalExecElement* el = new HalExecElement(ID_WriteMemBytes);
el->appendInputData32(this->getStart() + address);
el->appendInputData32(static_cast<uint32_t>(count));
for (size_t i = 0; i < count; ++i)
{
if (buffer[i] > 0xFF)
{
delete el;
return false;
}
el->appendInputData8(static_cast<uint8_t>(buffer[i]));
}
el->setInputMinSize(9);
this->elements.push_back(el);
return true;
}
/** each buffer element contains one _byte_ */
bool RandomMemoryAccess::writeWords (uint32_t address, uint32_t* buffer, size_t count)
{
if (address & 0x1)
return false;
HalExecElement* el = new HalExecElement(this->devHandle->checkHalId(ID_WriteMemWords));
el->appendInputData32(this->getStart() + address);
el->appendInputData32(static_cast<uint32_t>(count/2));
for (size_t i = 0; i+1 < count; i += 2)
{
if (buffer[i] > 0xFF || buffer[i+1] > 0xFF)
{
delete el;
return false;
}
el->appendInputData16(static_cast<uint16_t>(buffer[i] | (buffer[i+1] << 8)));
}
el->setInputMinSize(10);
this->elements.push_back(el);
return true;
}
bool BootcodeRomAccess::doRead (uint32_t address, uint32_t* buffer, size_t count)
{
bool omitFirst = (address & 0x1);
if (omitFirst)
{
--address;
++count;
}
bool omitLast = (count & 1);
if (omitLast)
{
++count;
}
HalExecElement* el = new HalExecElement(this->devHandle->checkHalId(ID_ReadMemQuick));
el->appendInputData32(this->getStart() + address);
el->appendInputData32(static_cast<uint32_t>(count/2));
el->setOutputSize(count);
ReadElement r(buffer, count, omitFirst, omitLast, 0);
this->readMap[this->elements.size()] = r;
this->elements.push_back(el);
return true;
}
bool FramMemoryAccessBaseFR57<MPU>::erase(uint32_t start, uint32_t end, uint32_t block_size, int type)
{
using boost::shared_ptr;
using boost::bind;
// check if valid erase type is used
if ((type != ERASE_SEGMENT) && (type != ERASE_MAIN))
{
return false;
}
if (block_size < 1)
{
return false;
}
// if the MPU is enabled, disable it to enable memory erase
if(!mpu.readMpuSettings() || !mpu.disableMpu())
{
return false;
}
// get Device RAM parameters for funclet upload
MemoryArea* ram = mm->getMemoryArea("system", 0);
if (!ram)
{
return false;
}
if ( !uploadFunclet(FuncletCode::ERASE) )
{
return false;
}
shared_ptr<void> restoreRamOnExit(static_cast<void*>(0),
bind(&FramMemoryAccessBaseFR57<MPU>::restoreRam, this));
//Note the erase on an FRAM device is just a dummy write with 0xFFFF to the device FRAm
int32_t erase_address = start;
const FuncletCode& funclet = devHandle->getFunclet(FuncletCode::ERASE);
const uint32_t eraseType = 0;
const uint32_t eraseLength = end - start + 1;
const uint16_t flags = 0x0;
const uint16_t programStartAddress = ram->getStart() + funclet.programStartOffset();
HalExecCommand cmd;
cmd.setTimeout(10000); // overwrite 3 sec default with 10 sec
HalExecElement* el = new HalExecElement(ID_SetDeviceChainInfo);
el->appendInputData16(static_cast<uint16_t>(this->devHandle->getDevChainInfo()->getBusId()));
cmd.elements.push_back(el);
el = new HalExecElement(this->devHandle->checkHalId(ID_ExecuteFunclet));
el->appendInputData16(static_cast<uint16_t>(ram->getStart() & 0xFFFF));
el->appendInputData16(static_cast<uint16_t>(ram->getSize() & 0xFFFF));
el->appendInputData16(programStartAddress);
el->appendInputData32(static_cast<uint32_t>(erase_address));
el->appendInputData32(eraseLength);
el->appendInputData16(eraseType);
el->appendInputData16(flags);
el->appendInputData16(devHandle->getClockCalibration()->getCal0());
el->appendInputData16(devHandle->getClockCalibration()->getCal1());
//Dummy data to trigger execution of erase funclet
el->appendInputData32(0xDEADBEEF);
// set value for return length
el->setOutputSize(2);
cmd.elements.push_back(el);
if (!this->devHandle->send(cmd))
{
return false;
}
return true;
}
bool FramMemoryAccessBaseFR57<MPU>::doWrite (uint32_t address, uint32_t* buffer, size_t count)
{
if (count > this->getSize())
{
return false;
}
address += this->getStart();
MemoryArea* ram = mm->getMemoryArea("system");
if (ram == NULL)
{
return false;
}
//32bit alignment
const uint32_t alignedAddress = address & 0xfffffffc;
const int frontPadding = address - alignedAddress;
const int stubble = (address + count) % 4;
const int backPadding = (4 - stubble) % 4;
HalExecElement* el = new HalExecElement(this->devHandle->checkHalId(ID_WriteFramQuickXv2));
el->appendInputData32(alignedAddress);
el->appendInputData32( (static_cast<uint32_t>(count) + frontPadding + backPadding)/2 );
vector<uint32_t> frontBuffer(frontPadding);
vector<uint32_t> backBuffer(backPadding);
if(frontPadding != 0)
{
mm->read(alignedAddress, &frontBuffer[0], frontPadding);
mm->sync();
}
if(backPadding != 0)
{
mm->read(address+count, &backBuffer[0], backPadding);
mm->sync();
}
for (int i = 0; i < frontPadding; ++i)
{
el->appendInputData8(frontBuffer[i]);
}
for (size_t i = 0; i < count; ++i)
{
if (buffer[i] > 0xFF)
{
delete el;
return false;
}
el->appendInputData8(static_cast<uint8_t>(buffer[i]));
}
for (int i = 0; i < backPadding; ++i)
{
el->appendInputData8(backBuffer[i]);
}
this->elements.push_back(el);
return true;
}
bool DebugManagerV3::run (uint16_t controlMask, DebugEventTarget * cb, bool releaseJtag)
{
MemoryManager* mm = this->parent->getMemoryManager();
MemoryArea* cpu = mm->getMemoryArea("CPU");
if (!cpu)
{
return false;
}
lpm5WakeupDetected = false;
if(cb!=0)
{
cbx=cb;
}
uint32_t pc, sr;
cpu->read(0, &pc, 1);
cpu->read(2, &sr, 1);
if(mm->flushAll()==false)
{
return false;
}
cycleCounter_.reset();
ConfigManager *cm = parent->getFetHandle()->getConfigManager();
const uint16_t mdb = parent->getEmulationManager()->getSoftwareBreakpoints()->getSwbpManager()->getInstructionAt(pc);
if (mdb != 0)
{
mdbPatchValue = mdb;
}
HalExecElement* el = new HalExecElement(this->parent->checkHalId(ID_RestoreContext_ReleaseJtag));
this->parent->getWatchdogControl()->addParamsTo(el);
el->appendInputData32(pc);
el->appendInputData16(sr);
el->appendInputData16(controlMask!=0? 0x0007: 0x0006); // eem control bits
el->appendInputData16(mdbPatchValue); // mdb
el->appendInputData16(releaseJtag ? 1 : 0);
el->appendInputData16(cm->ulpDebugEnabled() ? 1 : 0);
mdbPatchValue = 0;
HalExecCommand cmd;
cmd.elements.push_back(el);
if (!this->parent->send(cmd))
{
return false;
}
// handle lpmx5 polling
if (releaseJtag)
{
pausePolling();
}
else
{
this->resumePolling();
}
if (controlMask!=0 && !releaseJtag)
{
if (!activatePolling(controlMask))
{
return false;
}
}
resetCycleCounterBeforeNextStep = true;
return true;
}
