doryan/BloomPatched
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved AVR8 TDF data extraction into AVR8 TDF class.

Browse Source
This commit is contained in:
Nav
2021-07-06 20:07:41 +01:00
parent 196a280142
commit d8f53e4f9f
6 changed files with 589 additions and 590 deletions
Download Patch File Download Diff File Expand all files Collapse all files

522
src/Targets/Microchip/AVR/AVR8/Avr8.cpp
View File

@@ -32,497 +32,13 @@ void Avr8::loadTargetDescriptionFile() {
}
void Avr8::initFromTargetDescriptionFile() {
assert(this->targetDescriptionFile.has_value());
this->name = this->targetDescriptionFile->getTargetName();
this->family = this->targetDescriptionFile->getFamily();
this->loadTargetParameters();
this->loadPadDescriptors();
this->loadTargetVariants();
}
void Avr8::loadTargetParameters() {
assert(this->targetDescriptionFile.has_value());
auto& peripheralModules = this->targetDescriptionFile->getPeripheralModulesMappedByName();
this->targetParameters = TargetParameters();
auto& propertyGroups = this->targetDescriptionFile->getPropertyGroupsMappedByName();
auto flashMemorySegment = this->targetDescriptionFile->getFlashMemorySegment();
if (flashMemorySegment.has_value()) {
this->targetParameters->flashSize = flashMemorySegment->size;
this->targetParameters->flashStartAddress = flashMemorySegment->startAddress;
if (flashMemorySegment->pageSize.has_value()) {
this->targetParameters->flashPageSize = flashMemorySegment->pageSize.value();
}
}
auto ramMemorySegment = this->targetDescriptionFile->getRamMemorySegment();
if (ramMemorySegment.has_value()) {
this->targetParameters->ramSize = ramMemorySegment->size;
this->targetParameters->ramStartAddress = ramMemorySegment->startAddress;
}
auto ioMemorySegment = this->targetDescriptionFile->getIoMemorySegment();
if (ioMemorySegment.has_value()) {
this->targetParameters->mappedIoStartAddress = ioMemorySegment->startAddress;
}
auto registerMemorySegment = this->targetDescriptionFile->getRegisterMemorySegment();
if (registerMemorySegment.has_value()) {
this->targetParameters->gpRegisterSize = registerMemorySegment->size;
this->targetParameters->gpRegisterStartAddress = registerMemorySegment->startAddress;
}
auto eepromMemorySegment = this->targetDescriptionFile->getEepromMemorySegment();
if (eepromMemorySegment.has_value()) {
this->targetParameters->eepromSize = eepromMemorySegment->size;
this->targetParameters->eepromStartAddress = eepromMemorySegment->startAddress;
if (eepromMemorySegment->pageSize.has_value()) {
this->targetParameters->eepromPageSize = eepromMemorySegment->pageSize.value();
}
}
auto firstBootSectionMemorySegment = this->targetDescriptionFile->getFirstBootSectionMemorySegment();
if (firstBootSectionMemorySegment.has_value()) {
this->targetParameters->bootSectionStartAddress = firstBootSectionMemorySegment->startAddress / 2;
this->targetParameters->bootSectionSize = firstBootSectionMemorySegment->size;
}
std::uint32_t cpuRegistersOffset = 0;
if (peripheralModules.contains("cpu")) {
auto cpuPeripheralModule = peripheralModules.at("cpu");
if (cpuPeripheralModule.instancesMappedByName.contains("cpu")) {
auto cpuInstance = cpuPeripheralModule.instancesMappedByName.at("cpu");
if (cpuInstance.registerGroupsMappedByName.contains("cpu")) {
cpuRegistersOffset = cpuInstance.registerGroupsMappedByName.at("cpu").offset.value_or(0);
}
}
}
auto statusRegister = this->targetDescriptionFile->getStatusRegister();
if (statusRegister.has_value()) {
this->targetParameters->statusRegisterStartAddress = cpuRegistersOffset + statusRegister->offset;
this->targetParameters->statusRegisterSize = statusRegister->size;
}
auto stackPointerRegister = this->targetDescriptionFile->getStackPointerRegister();
if (stackPointerRegister.has_value()) {
this->targetParameters->stackPointerRegisterLowAddress = cpuRegistersOffset + stackPointerRegister->offset;
this->targetParameters->stackPointerRegisterSize = stackPointerRegister->size;
} else {
// Sometimes the SP register is split into two register nodes, one for low, the other for high
auto stackPointerLowRegister = this->targetDescriptionFile->getStackPointerLowRegister();
auto stackPointerHighRegister = this->targetDescriptionFile->getStackPointerHighRegister();
if (stackPointerLowRegister.has_value()) {
this->targetParameters->stackPointerRegisterLowAddress = cpuRegistersOffset
+ stackPointerLowRegister->offset;
this->targetParameters->stackPointerRegisterSize = stackPointerLowRegister->size;
}
if (stackPointerHighRegister.has_value()) {
this->targetParameters->stackPointerRegisterSize =
this->targetParameters->stackPointerRegisterSize.has_value() ?
this->targetParameters->stackPointerRegisterSize.value() + stackPointerHighRegister->size :
stackPointerHighRegister->size;
}
}
auto supportedPhysicalInterfaces = this->targetDescriptionFile->getSupportedDebugPhysicalInterfaces();
if (supportedPhysicalInterfaces.contains(PhysicalInterface::DEBUG_WIRE)
|| supportedPhysicalInterfaces.contains(PhysicalInterface::JTAG)) {
this->loadDebugWireAndJtagTargetParameters();
}
if (supportedPhysicalInterfaces.contains(PhysicalInterface::PDI)) {
this->loadPdiTargetParameters();
}
if (supportedPhysicalInterfaces.contains(PhysicalInterface::UPDI)) {
this->loadUpdiTargetParameters();
}
}
void Avr8::loadDebugWireAndJtagTargetParameters() {
auto& peripheralModules = this->targetDescriptionFile->getPeripheralModulesMappedByName();
auto& propertyGroups = this->targetDescriptionFile->getPropertyGroupsMappedByName();
// OCD attributes can be found in property groups
if (propertyGroups.contains("ocd")) {
auto& ocdProperties = propertyGroups.at("ocd").propertiesMappedByName;
if (ocdProperties.find("ocd_revision") != ocdProperties.end()) {
this->targetParameters->ocdRevision = ocdProperties.find("ocd_revision")
->second.value.toUShort(nullptr, 10);
}
if (ocdProperties.find("ocd_datareg") != ocdProperties.end()) {
this->targetParameters->ocdDataRegister = ocdProperties.find("ocd_datareg")
->second.value.toUShort(nullptr, 16);
}
}
auto spmcsRegister = this->targetDescriptionFile->getSpmcsRegister();
if (spmcsRegister.has_value()) {
this->targetParameters->spmcRegisterStartAddress = spmcsRegister->offset;
} else {
auto spmcRegister = this->targetDescriptionFile->getSpmcRegister();
if (spmcRegister.has_value()) {
this->targetParameters->spmcRegisterStartAddress = spmcRegister->offset;
}
}
auto osccalRegister = this->targetDescriptionFile->getOscillatorCalibrationRegister();
if (osccalRegister.has_value()) {
this->targetParameters->osccalAddress = osccalRegister->offset;
}
auto eepromAddressRegister = this->targetDescriptionFile->getEepromAddressRegister();
if (eepromAddressRegister.has_value()) {
this->targetParameters->eepromAddressRegisterLow = eepromAddressRegister->offset;
this->targetParameters->eepromAddressRegisterHigh = (eepromAddressRegister->size == 2)
? eepromAddressRegister->offset + 1 : eepromAddressRegister->offset;
} else {
auto eepromAddressLowRegister = this->targetDescriptionFile->getEepromAddressLowRegister();
if (eepromAddressLowRegister.has_value()) {
this->targetParameters->eepromAddressRegisterLow = eepromAddressLowRegister->offset;
auto eepromAddressHighRegister = this->targetDescriptionFile->getEepromAddressHighRegister();
if (eepromAddressHighRegister.has_value()) {
this->targetParameters->eepromAddressRegisterHigh = eepromAddressHighRegister->offset;
} else {
this->targetParameters->eepromAddressRegisterHigh = eepromAddressLowRegister->offset;
}
}
}
auto eepromDataRegister = this->targetDescriptionFile->getEepromDataRegister();
if (eepromDataRegister.has_value()) {
this->targetParameters->eepromDataRegisterAddress = eepromDataRegister->offset;
}
auto eepromControlRegister = this->targetDescriptionFile->getEepromControlRegister();
if (eepromControlRegister.has_value()) {
this->targetParameters->eepromControlRegisterAddress = eepromControlRegister->offset;
}
}
void Avr8::loadPdiTargetParameters() {
auto& peripheralModules = this->targetDescriptionFile->getPeripheralModulesMappedByName();
auto& propertyGroups = this->targetDescriptionFile->getPropertyGroupsMappedByName();
if (propertyGroups.contains("pdi_interface")) {
auto& pdiInterfaceProperties = propertyGroups.at("pdi_interface").propertiesMappedByName;
if (pdiInterfaceProperties.contains("app_section_offset")) {
this->targetParameters->appSectionPdiOffset = pdiInterfaceProperties
.at("app_section_offset").value.toUInt(nullptr, 16);
}
if (pdiInterfaceProperties.contains("boot_section_offset")) {
this->targetParameters->bootSectionPdiOffset = pdiInterfaceProperties
.at("boot_section_offset").value.toUInt(nullptr, 16);
}
if (pdiInterfaceProperties.contains("datamem_offset")) {
this->targetParameters->ramPdiOffset = pdiInterfaceProperties
.at("datamem_offset").value.toUInt(nullptr, 16);
}
if (pdiInterfaceProperties.contains("eeprom_offset")) {
this->targetParameters->eepromPdiOffset = pdiInterfaceProperties
.at("eeprom_offset").value.toUInt(nullptr, 16);
}
if (pdiInterfaceProperties.contains("user_signatures_offset")) {
this->targetParameters->userSignaturesPdiOffset = pdiInterfaceProperties
.at("user_signatures_offset").value.toUInt(nullptr, 16);
}
if (pdiInterfaceProperties.contains("prod_signatures_offset")) {
this->targetParameters->productSignaturesPdiOffset = pdiInterfaceProperties
.at("prod_signatures_offset").value.toUInt(nullptr, 16);
}
if (pdiInterfaceProperties.contains("fuse_registers_offset")) {
this->targetParameters->fuseRegistersPdiOffset = pdiInterfaceProperties
.at("fuse_registers_offset").value.toUInt(nullptr, 16);
}
if (pdiInterfaceProperties.contains("lock_registers_offset")) {
this->targetParameters->lockRegistersPdiOffset = pdiInterfaceProperties
.at("lock_registers_offset").value.toUInt(nullptr, 16);
}
if (peripheralModules.contains("nvm")) {
auto& nvmModule = peripheralModules.at("nvm");
if (nvmModule.instancesMappedByName.contains("nvm")) {
auto& nvmInstance = nvmModule.instancesMappedByName.at("nvm");
if (nvmInstance.registerGroupsMappedByName.contains("nvm")) {
this->targetParameters->nvmBaseAddress = nvmInstance.registerGroupsMappedByName.at("nvm").offset;
}
}
}
}
}
void Avr8::loadUpdiTargetParameters() {
auto& propertyGroups = this->targetDescriptionFile->getPropertyGroupsMappedByName();
auto& peripheralModules = this->targetDescriptionFile->getPeripheralModulesMappedByName();
auto modulesByName = this->targetDescriptionFile->getModulesMappedByName();
if (peripheralModules.contains("nvmctrl")) {
auto& nvmCtrlModule = peripheralModules.at("nvmctrl");
if (nvmCtrlModule.instancesMappedByName.contains("nvmctrl")) {
auto& nvmCtrlInstance = nvmCtrlModule.instancesMappedByName.at("nvmctrl");
if (nvmCtrlInstance.registerGroupsMappedByName.contains("nvmctrl")) {
this->targetParameters->nvmBaseAddress = nvmCtrlInstance.registerGroupsMappedByName.at("nvmctrl").offset;
}
}
}
if (propertyGroups.contains("updi_interface")) {
auto& updiInterfaceProperties = propertyGroups.at("updi_interface").propertiesMappedByName;
if (updiInterfaceProperties.contains("ocd_base_addr")) {
this->targetParameters->ocdModuleAddress = updiInterfaceProperties
.at("ocd_base_addr").value.toUShort(nullptr, 16);
}
if (updiInterfaceProperties.contains("progmem_offset")) {
this->targetParameters->programMemoryUpdiStartAddress = updiInterfaceProperties
.at("progmem_offset").value.toUInt(nullptr, 16);
}
}
auto signatureMemorySegment = this->targetDescriptionFile->getSignatureMemorySegment();
if (signatureMemorySegment.has_value()) {
this->targetParameters->signatureSegmentStartAddress = signatureMemorySegment->startAddress;
this->targetParameters->signatureSegmentSize = signatureMemorySegment->size;
}
auto fuseMemorySegment = this->targetDescriptionFile->getFuseMemorySegment();
if (fuseMemorySegment.has_value()) {
this->targetParameters->fuseSegmentStartAddress = fuseMemorySegment->startAddress;
this->targetParameters->fuseSegmentSize = fuseMemorySegment->size;
}
auto lockbitsMemorySegment = this->targetDescriptionFile->getLockbitsMemorySegment();
if (lockbitsMemorySegment.has_value()) {
this->targetParameters->lockbitsSegmentStartAddress = lockbitsMemorySegment->startAddress;
}
}
void Avr8::loadPadDescriptors() {
/*
* Every port address we extract from the target description will be stored in portAddresses, so that
* we can extract the start (min) and end (max) for the target's IO port address
* range (TargetParameters::ioPortAddressRangeStart & TargetParameters::ioPortAddressRangeEnd)
*/
std::vector<std::uint32_t> portAddresses;
auto& modules = this->targetDescriptionFile->getModulesMappedByName();
auto portModule = (modules.contains("port")) ? std::optional(modules.find("port")->second) : std::nullopt;
auto& peripheralModules = this->targetDescriptionFile->getPeripheralModulesMappedByName();
if (peripheralModules.contains("port")) {
auto portPeripheralModule = peripheralModules.find("port")->second;
for (const auto& [instanceName, instance] : portPeripheralModule.instancesMappedByName) {
if (instanceName.find("port") == 0) {
auto portPeripheralRegisterGroup = (portPeripheralModule.registerGroupsMappedByName.contains(instanceName)) ?
std::optional(portPeripheralModule.registerGroupsMappedByName.find(instanceName)->second) :
std::nullopt;
for (const auto& signal : instance.instanceSignals) {
if (!signal.index.has_value()) {
continue;
}
auto padDescriptor = PadDescriptor();
padDescriptor.name = signal.padName;
padDescriptor.gpioPinNumber = signal.index.value();
if (portModule.has_value() && portModule->registerGroupsMappedByName.contains(instanceName)) {
// We have register information for this port
auto registerGroup = portModule->registerGroupsMappedByName.find(instanceName)->second;
for (const auto& [registerName, portRegister] : registerGroup.registersMappedByName) {
if (registerName.find("port") == 0) {
// This is the data register for the port
padDescriptor.gpioPortSetAddress = portRegister.offset;
padDescriptor.gpioPortClearAddress = portRegister.offset;
} else if (registerName.find("pin") == 0) {
// This is the input data register for the port
padDescriptor.gpioPortInputAddress = portRegister.offset;
} else if (registerName.find("ddr") == 0) {
// This is the data direction register for the port
padDescriptor.ddrSetAddress = portRegister.offset;
padDescriptor.ddrClearAddress = portRegister.offset;
}
}
} else if (portModule.has_value() && portModule->registerGroupsMappedByName.contains("port")) {
// We have generic register information for all ports on the target
auto registerGroup = portModule->registerGroupsMappedByName.find("port")->second;
for (const auto& [registerName, portRegister] : registerGroup.registersMappedByName) {
if (registerName.find("outset") == 0) {
// Include the port register offset
padDescriptor.gpioPortSetAddress = (portPeripheralRegisterGroup.has_value()
&& portPeripheralRegisterGroup->offset.has_value()) ?
portPeripheralRegisterGroup->offset.value_or(0) : 0;
padDescriptor.gpioPortSetAddress = padDescriptor.gpioPortSetAddress.value()
+ portRegister.offset;
} else if (registerName.find("outclr") == 0) {
padDescriptor.gpioPortClearAddress = (portPeripheralRegisterGroup.has_value()
&& portPeripheralRegisterGroup->offset.has_value()) ?
portPeripheralRegisterGroup->offset.value_or(0) : 0;
padDescriptor.gpioPortClearAddress = padDescriptor.gpioPortClearAddress.value()
+ portRegister.offset;
} else if (registerName.find("dirset") == 0) {
padDescriptor.ddrSetAddress = (portPeripheralRegisterGroup.has_value()
&& portPeripheralRegisterGroup->offset.has_value()) ?
portPeripheralRegisterGroup->offset.value_or(0) : 0;
padDescriptor.ddrSetAddress = padDescriptor.ddrSetAddress.value()
+ portRegister.offset;
} else if (registerName.find("dirclr") == 0) {
padDescriptor.ddrClearAddress = (portPeripheralRegisterGroup.has_value()
&& portPeripheralRegisterGroup->offset.has_value()) ?
portPeripheralRegisterGroup->offset.value_or(0) : 0;
padDescriptor.ddrClearAddress = padDescriptor.ddrClearAddress.value()
+ portRegister.offset;
} else if (registerName == "in") {
padDescriptor.gpioPortInputAddress = (portPeripheralRegisterGroup.has_value()
&& portPeripheralRegisterGroup->offset.has_value()) ?
portPeripheralRegisterGroup->offset.value_or(0) : 0;
padDescriptor.gpioPortInputAddress = padDescriptor.gpioPortInputAddress.value()
+ portRegister.offset;
}
}
}
if (padDescriptor.gpioPortSetAddress.has_value()) {
portAddresses.push_back(padDescriptor.gpioPortSetAddress.value());
}
if (padDescriptor.gpioPortClearAddress.has_value()) {
portAddresses.push_back(padDescriptor.gpioPortClearAddress.value());
}
if (padDescriptor.ddrSetAddress.has_value()) {
portAddresses.push_back(padDescriptor.ddrSetAddress.value());
}
if (padDescriptor.ddrClearAddress.has_value()) {
portAddresses.push_back(padDescriptor.ddrClearAddress.value());
}
this->padDescriptorsByName.insert(std::pair(padDescriptor.name, padDescriptor));
}
}
}
}
// TODO: Move this into getTargetParameters()
if (!portAddresses.empty()) {
this->targetParameters->ioPortAddressRangeStart = *std::min_element(portAddresses.begin(), portAddresses.end());
this->targetParameters->ioPortAddressRangeEnd = *std::max_element(portAddresses.begin(), portAddresses.end());
}
}
void Avr8::loadTargetVariants() {
auto tdVariants = this->targetDescriptionFile->getVariants();
auto tdPinoutsByName = this->targetDescriptionFile->getPinoutsMappedByName();
auto& modules = this->targetDescriptionFile->getModulesMappedByName();
for (const auto& tdVariant : tdVariants) {
if (tdVariant.disabled) {
continue;
}
auto targetVariant = TargetVariant();
targetVariant.id = static_cast<int>(this->targetVariantsById.size());
targetVariant.name = tdVariant.name;
targetVariant.packageName = tdVariant.package;
if (tdVariant.package.find("QFP") == 0 || tdVariant.package.find("TQFP") == 0) {
targetVariant.package = TargetPackage::QFP;
} else if (tdVariant.package.find("PDIP") == 0 || tdVariant.package.find("DIP") == 0) {
targetVariant.package = TargetPackage::DIP;
} else if (tdVariant.package.find("QFN") == 0 || tdVariant.package.find("VQFN") == 0) {
targetVariant.package = TargetPackage::QFN;
} else if (tdVariant.package.find("SOIC") == 0) {
targetVariant.package = TargetPackage::SOIC;
} else if (tdVariant.package.find("SSOP") == 0) {
targetVariant.package = TargetPackage::SSOP;
}
if (!tdPinoutsByName.contains(tdVariant.pinoutName)) {
// Missing pinouts in the target description file
continue;
}
auto tdPinout = tdPinoutsByName.find(tdVariant.pinoutName)->second;
for (const auto& tdPin : tdPinout.pins) {
auto targetPin = TargetPinDescriptor();
targetPin.name = tdPin.pad;
targetPin.padName = tdPin.pad;
targetPin.number = tdPin.position;
// TODO: REMOVE THIS:
if (tdPin.pad.find("vcc") == 0
|| tdPin.pad.find("avcc") == 0
|| tdPin.pad.find("aref") == 0
|| tdPin.pad.find("avdd") == 0
|| tdPin.pad.find("vdd") == 0
) {
targetPin.type = TargetPinType::VCC;
} else if (tdPin.pad.find("gnd") == 0) {
targetPin.type = TargetPinType::GND;
}
if (this->padDescriptorsByName.contains(targetPin.padName)) {
auto& pad = this->padDescriptorsByName.at(targetPin.padName);
if (pad.gpioPortSetAddress.has_value() && pad.ddrSetAddress.has_value()) {
targetPin.type = TargetPinType::GPIO;
}
}
targetVariant.pinDescriptorsByNumber.insert(std::pair(targetPin.number, targetPin));
}
this->targetVariantsById.insert(std::pair(targetVariant.id, targetVariant));
}
this->targetParameters = this->targetDescriptionFile->getTargetParameters();
this->padDescriptorsByName = this->targetDescriptionFile->getPadDescriptorsMappedByName();
this->targetVariantsById = this->targetDescriptionFile->getVariantsMappedById();
}
TargetSignature Avr8::getId() {
@@ -981,26 +497,20 @@ void Avr8::setPinState(int variantId, const TargetPinDescriptor& pinDescriptor,
}
}
bool Avr8::memoryAddressRangeClashesWithIoPortRegisters(TargetMemoryType memoryType, std::uint32_t startAddress, std::uint32_t endAddress) {
bool Avr8::memoryAddressRangeClashesWithIoPortRegisters(
TargetMemoryType memoryType,
std::uint32_t startAddress,
std::uint32_t endAddress
) {
auto& targetParameters = this->targetParameters.value();
if (targetParameters.mappedIoSegmentStartAddress.has_value() && targetParameters.mappedIoSegmentSize.has_value()) {
auto mappedIoSegmentStart = targetParameters.mappedIoSegmentStartAddress.value();
auto mappedIoSegmentEnd = mappedIoSegmentStart + targetParameters.mappedIoSegmentSize.value();
/*
* We're making an assumption here; that all IO port addresses for all AVR8 targets are aligned. I have no idea
* how well this will hold.
*
* If they're not aligned, this function may report false positives.
*/
if (targetParameters.ioPortAddressRangeStart.has_value() && targetParameters.ioPortAddressRangeEnd.has_value()) {
return (
startAddress >= targetParameters.ioPortAddressRangeStart
&& startAddress <= targetParameters.ioPortAddressRangeEnd
) || (
endAddress >= targetParameters.ioPortAddressRangeStart
&& endAddress <= targetParameters.ioPortAddressRangeEnd
) || (
startAddress <= targetParameters.ioPortAddressRangeStart
&& endAddress >= targetParameters.ioPortAddressRangeStart
);
return (startAddress >= mappedIoSegmentStart && startAddress <= mappedIoSegmentEnd)
|| (endAddress >= mappedIoSegmentStart && endAddress <= mappedIoSegmentEnd)
|| (startAddress <= mappedIoSegmentStart && endAddress >= mappedIoSegmentStart)
;
}
return false;