Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
// SPDX-License-Identifier: Apache-2.0
/*
* Copyright (C) 2022 Gwenhael Goavec-Merou <gwenhael.goavec-merou@trabucayre.com>
*/
#include "pofParser.hpp"
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#include <string>
#include <map>
#include <regex>
#include <stdexcept>
#include <utility>
#include <vector>
#include "display.hpp"
POFParser::POFParser(const std::string &filename, bool verbose):
ConfigBitstreamParser(filename, ConfigBitstreamParser::BIN_MODE,
verbose)
{}
POFParser::~POFParser()
{}
uint8_t *POFParser::getData(const std::string §ion_name)
{
if (section_name == "")
return (uint8_t*)_bit_data.data();
auto section = mem_section.find(section_name);
if (section == mem_section.end())
return NULL;
return (*section).second.data;
}
int POFParser::getLength(const std::string §ion_name)
{
if (section_name == "")
return _bit_length;
auto section = mem_section.find(section_name);
if (section == mem_section.end())
return -1;
return (*section).second.len;
}
void POFParser::displayHeader()
{
ConfigBitstreamParser::displayHeader();
char mess[1024];
snprintf(mess, 1024, "Flag section offset len end");
printInfo(mess);
for (auto it = mem_section.begin(); it != mem_section.end(); it++) {
memory_section_t v = (*it).second;
snprintf(mess, 1024, "%02x %4s: ", v.flag, v.section.c_str());
printInfo(mess, false);
// start address + len (in bits) + end addr
snprintf(mess, 1024, " %08x %08x %08x", v.offset, v.len, v.offset + ((v.len/8)-1));
/* Note: for CFM0 end address is displayed with another value in () */
printSuccess(mess);
}
}
int POFParser::parse()
{
const uint32_t file_size = static_cast<uint32_t>(_file_size);
uint8_t *ptr = (uint8_t *)_raw_data.data();
uint32_t pos = 0;
if (_verbose)
printf("[%08x:%08x] %s\n", 0, 3, ptr);
/* [0:3]: POF\0 */
ptr += 4;
pos += 4;
/* unknown */
if (_verbose) {
if ((pos + 4) > file_size) {
printError("POFParser: Can't read first section");
return -1;
}
uint32_t first_section = ARRAY2INT32(ptr);
printf("first section: %08x %4u\n", first_section, first_section);
}
ptr += 4;
pos += 4;
/* number of packets */
if (_verbose) {
if ((pos + 4) > file_size) {
printError("POFParser: Can't read first section");
return -1;
}
uint32_t num_packets = ARRAY2INT32(ptr);
printf("number of packets: %08x %4u\n", num_packets, num_packets);
}
pos += 4;
/* 16bit code + 32bits size + content */
while (pos < file_size) {
if ((pos + 2) > file_size) {
printError("POFParser: Bound check failure: can't read flag");
return -1;
}
uint16_t flag = ARRAY2INT16((&_raw_data.data()[pos]));
pos += 2;
if ((pos + 4) > file_size) {
printError("POFParser: Bound check failure: can't read size");
return -1;
}
uint32_t size = ARRAY2INT32((&_raw_data.data()[pos]));
pos += 4;
if ((pos >= file_size) || ((pos + size) > file_size)) {
printError("POFParser: Bound check: can't parse section");
return -1;
}
uint32_t ret = parseSection(flag, pos, size);
if (ret != size) {
printError("POFParser: parseSection Failed");
return -1;
}
pos += ret;
}
/* update pointers to memory area */
ptr = (uint8_t *)_bit_data.data();
mem_section["CFM0"].data = &ptr[mem_section["CFM0"].offset + 0x0C];
if (mem_section.find("CFM1") != mem_section.end())
mem_section["CFM1"].data = &ptr[mem_section["CFM1"].offset + 0x0C];
if (mem_section.find("CFM2") != mem_section.end())
mem_section["CFM2"].data = &ptr[mem_section["CFM2"].offset + 0x0C];
mem_section["UFM"].data = &ptr[mem_section["UFM"].offset + 0x0C];
mem_section["ICB"].data = &ptr[mem_section["ICB"].offset + 0x0C];
return EXIT_SUCCESS;
}
uint32_t POFParser::parseSection(uint16_t flag, uint32_t pos, uint32_t size)
{
std::string content;
std::string t;
char mess[1024];
if (_verbose) {
snprintf(mess, 1024, "Flag: %02x (%d) Size: %u", flag, flag, size);
printInfo(mess);
}
/* 0x01: software name/version */
/* 0x02: full FPGAs model */
/* 0x03: bitstream name ? */
/* 0x3b: ? */
/* 0x12: ? */
/* 0x13: contains usercode / checksum */
/* 0x24: ? */
/* 0x11: ? */
/* 0x18: ? */
/* 0x15: ? */
/* 0x34: ? */
/* 0x35: ? */
/* 0x38: ? */
/* 0x08: ? CRC ? */
switch (flag) {
case 0x01: // software name/version
_hdr["tool"] = _raw_data.substr(pos, size);
break;
case 0x02: // full FPGA part name
_hdr["part_name"] = _raw_data.substr(pos, size-1); // -1 because '\0'
break;
case 0x03: // bitstream/design/xxx name
_hdr["design_name"] = _raw_data.substr(pos, size);
break;
case 0x08: // last packet: CRC ?
if (size < 2) {
printError("POFParser: flag 0x08 failed size too small");
return 0;
}
_hdr["maybeCRC"] = std::to_string(ARRAY2INT16((&_raw_data.data()[pos])));
break;
case 0x11: // cfg data
// 12 Bytes unknown
// followed by UFM/CFM/DSM data
if (_verbose) {
content = _raw_data.substr(pos, size);
if ((3 * 4) > size) {
printError("POFParser: can't display 0x11 area");
return -1;
}
uint32_t val0 = ARRAY2INT32((&content.c_str()[0]));
uint32_t val1 = ARRAY2INT32((&content.c_str()[4]));
uint32_t val2 = ARRAY2INT32((&content.c_str()[8]));
printf("Flag 0x11: Unknown %08x %08x %08x\n", val0, val1, val2);
}
_bit_data.resize(size);
std::copy(_raw_data.begin() + pos, _raw_data.begin() + pos + size,
_bit_data.begin());
_bit_length = size * 8;
if (_verbose)
printf("size %u %zu\n", size, _bit_data.size());
break;
case 0x13: // contains usercode / checksum
_hdr["usercode"] = std::to_string(ARRAY2INT32((&_raw_data.data()[pos+size-4])));
if (_verbose) {
if (size < 12) {
printf("POFParser: Can't display flag 0x13 area");
return -1;
}
t = _raw_data.substr(pos, size);
for (size_t i = 0; i < t.size(); i++)
printf("%02x ", static_cast<uint8_t>(t[i]));
printf("\n");
printf("%s\n", t.c_str());
/* 4 x 32bits */
uint32_t sec0, sec1, sec2, sec3;
sec0 = (t[0] << 24) | (t[1] << 16) | (t[2] << 8) | (t[3] << 0);
sec1 = (t[4] << 24) | (t[5] << 16) | (t[6] << 8) | (t[7] << 0);
sec2 = (t[8] << 24) | (t[9] << 16) | (t[10] << 8) | (t[11] << 0);
sec3 = ((unsigned char)t[size-4] << 24) |
((unsigned char)t[size-3] << 16) |
((unsigned char)t[size-2] << 8) |
((unsigned char)t[size-1] << 0);
printf("sec0: %08x\n", sec0);
printf("sec1: %08x\n", sec1);
printf("sec2: %08x\n", sec2);
printf("sec3: %08x\n", sec3);
}
break;
case 0x1a: // flash sections
// 12Bytes ?
// followed by flash sections separates by ';'
// 1B + name + ' ' + cfg data offset (bits) + size (bits)
content = _raw_data.substr(pos, size);
parseFlag26(flag, pos, size, content);
break;
default:
snprintf(mess, 1024, "unknown flag 0x%02x: offset %u length %u",
flag, pos - 6, size);
printWarn(mess);
break;
}
return size;
}
/* section with flag 0x11A */
/* 3 x 32bits -> unknown
* followed by flash sections separates by ';'
* 1B + name + ' ' + cfg data offset (bits) + size (bits)
*/
void POFParser::parseFlag26(uint16_t flag, uint32_t pos,
uint32_t size, const std::string &payload)
{
if (_verbose)
printf("%04x %08x %08x\n", flag, pos, size);
if (size != payload.size())
printf("mismatch size\n");
if (_verbose) {
uint32_t val0 = ARRAY2INT32((&payload.c_str()[0]));
uint32_t val1 = ARRAY2INT32((&payload.c_str()[4]));
uint32_t val2 = ARRAY2INT32((&payload.c_str()[8]));
printf("%08x %08x %08x\n", val0, val1, val2);
}
std::regex regex{R"([;]+)"}; // split on space
std::sregex_token_iterator it{payload.begin() + 12, payload.end(),
regex, -1};
std::vector<std::string> words{it, {}};
std::regex sp_reg{R"([\s]+)"}; // split on space
for (size_t i = 0; i < words.size(); i++) {
std::sregex_token_iterator it{words[i].begin(), words[i].end(),
sp_reg, -1};
std::vector<std::string> sect{it, {}};
uint32_t start = stoul(sect[1], nullptr, 16);
uint32_t length = stoul(sect[2], nullptr, 16);
uint8_t id = static_cast<uint8_t>(sect[0][0]);
std::string name = sect[0].substr(1);
mem_section.insert(std::pair<std::string, memory_section_t>(
name, {id, name, start, NULL, length}));
}
}
e4cd4bf3dThis file is pinned to the selected release. Download the original to open it in your design tool.