| #include <stdint.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include <iostream> |
| #include <set> |
| #include <string> |
| #include <vector> |
| |
| #include <absl/strings/numbers.h> |
| #include <absl/strings/str_cat.h> |
| #include <absl/strings/str_split.h> |
| #include <absl/types/optional.h> |
| #include <gflags/gflags.h> |
| #include <prjxray/memory_mapped_file.h> |
| #include <prjxray/xilinx/xc7series/bitstream_reader.h> |
| #include <prjxray/xilinx/xc7series/configuration.h> |
| #include <prjxray/xilinx/xc7series/part.h> |
| |
| DEFINE_bool(c, false, "output '*' for repeating patterns"); |
| DEFINE_bool(C, false, "do not ignore the checksum in each frame"); |
| DEFINE_int32(f, |
| -1, |
| "only dump the specified frame (might be used more than once)"); |
| DEFINE_string(F, |
| "", |
| "<first_frame_address>:<last_frame_address> only dump frame in " |
| "the specified range"); |
| DEFINE_string(o, "", "write machine-readable output file with config frames"); |
| DEFINE_bool(p, false, "output a binary netpgm image"); |
| DEFINE_bool(x, |
| false, |
| "use format 'bit_%%08x_%%03d_%%02d_t%%d_h%%d_r%%d_c%%d_m%%d'\n" |
| "The fields have the following meaning:\n" |
| " - complete 32 bit hex frame id\n" |
| " - word index with that frame (decimal)\n" |
| " - bit index with that word (decimal)\n" |
| " - decoded frame type from frame id\n" |
| " - decoded top/botttom from frame id (top=0)\n" |
| " - decoded row address from frame id\n" |
| " - decoded column address from frame id\n" |
| " - decoded minor address from frame id\n"); |
| DEFINE_bool(y, false, "use format 'bit_%%08x_%%03d_%%02d'"); |
| DEFINE_bool(z, false, "skip zero frames (frames with all bits cleared) in o"); |
| DEFINE_string(part_file, "", "YAML file describing a Xilinx 7-Series part"); |
| |
| namespace xc7series = prjxray::xilinx::xc7series; |
| |
| std::set<uint32_t> frames; |
| uint32_t frame_range_begin = 0, frame_range_end = 0; |
| |
| std::vector<uint32_t> zero_frame(101); |
| |
| int main(int argc, char** argv) { |
| gflags::SetUsageMessage( |
| absl::StrCat("Usage: ", argv[0], " [options] [bitfile]")); |
| gflags::ParseCommandLineFlags(&argc, &argv, true); |
| |
| auto part = xc7series::Part::FromFile(FLAGS_part_file); |
| if (!part) { |
| std::cerr << "Part file not found or invalid" << std::endl; |
| return 1; |
| } |
| |
| if (FLAGS_f >= 0) { |
| frames.insert(FLAGS_f); |
| } |
| |
| if (!FLAGS_F.empty()) { |
| std::pair<std::string, std::string> p = |
| absl::StrSplit(FLAGS_F, ":"); |
| frame_range_begin = strtol(p.first.c_str(), nullptr, 0); |
| frame_range_end = strtol(p.second.c_str(), nullptr, 0) + 1; |
| } |
| |
| absl::optional<xc7series::BitstreamReader> reader; |
| if (argc == 2) { |
| auto in_file_name = argv[1]; |
| auto in_file = |
| prjxray::MemoryMappedFile::InitWithFile(in_file_name); |
| if (!in_file) { |
| std::cerr << "Can't open input file '" << in_file_name |
| << "' for reading!" << std::endl; |
| return 1; |
| } |
| |
| std::cout << "Bitstream size: " << in_file->size() << " bytes" |
| << std::endl; |
| |
| reader = xc7series::BitstreamReader::InitWithBytes( |
| in_file->as_bytes()); |
| } else { |
| std::vector<uint8_t> bitdata; |
| while (1) { |
| int c = getchar(); |
| if (c == EOF) |
| break; |
| bitdata.push_back(c); |
| } |
| |
| std::cout << "Bitstream size: " << bitdata.size() << " bytes" |
| << std::endl; |
| |
| reader = xc7series::BitstreamReader::InitWithBytes(bitdata); |
| } |
| |
| if (!reader) { |
| std::cerr << "Bitstream does not appear to be a Xilinx " |
| << "7-series bitstream!" << std::endl; |
| return 1; |
| } |
| |
| std::cout << "Config size: " << reader->words().size() << " words" |
| << std::endl; |
| |
| auto config = xc7series::Configuration::InitWithPackets(*part, *reader); |
| if (!config) { |
| std::cerr << "Bitstream does not appear to be for this part" |
| << std::endl; |
| return 1; |
| } |
| |
| std::cout << "Number of configuration frames: " |
| << config->frames().size() << std::endl; |
| |
| FILE* f = stdout; |
| |
| if (!FLAGS_o.empty()) { |
| f = fopen(FLAGS_o.c_str(), "w"); |
| |
| if (f == nullptr) { |
| printf("Can't open output file '%s' for writing!\n", |
| FLAGS_o.c_str()); |
| return 1; |
| } |
| } else { |
| fprintf(f, "\n"); |
| } |
| |
| std::vector<std::vector<bool>> pgmdata; |
| std::vector<int> pgmsep; |
| |
| for (auto& it : config->frames()) { |
| if (FLAGS_z && it.second == zero_frame) |
| continue; |
| |
| if (!frames.empty() && !frames.count(it.first)) |
| continue; |
| |
| if (frame_range_begin != frame_range_end && |
| (it.first < frame_range_begin || |
| frame_range_end <= it.first)) |
| continue; |
| |
| if (FLAGS_o.empty()) |
| printf( |
| "Frame 0x%08x (Type=%d Top=%d Row=%d Column=%d " |
| "Minor=%d):\n", |
| static_cast<uint32_t>(it.first), |
| static_cast<unsigned int>(it.first.block_type()), |
| it.first.is_bottom_half_rows() ? 1 : 0, |
| it.first.row(), it.first.column(), |
| it.first.minor()); |
| |
| if (FLAGS_p) { |
| if (it.first.minor() == 0 && !pgmdata.empty()) |
| pgmsep.push_back(pgmdata.size()); |
| |
| pgmdata.push_back(std::vector<bool>()); |
| |
| for (int i = 0; i < 101; i++) |
| for (int k = 0; k < 32; k++) |
| pgmdata.back().push_back( |
| (it.second.at(i) & (1 << k)) != 0); |
| } else if (FLAGS_x || FLAGS_y) { |
| for (int i = 0; i < 101; i++) |
| for (int k = 0; k < 32; k++) |
| if ((i != 50 || k > 12 || FLAGS_C) && |
| ((it.second.at(i) & (1 << k)) != |
| 0)) { |
| if (FLAGS_x) |
| fprintf( |
| f, |
| "bit_%08x_%03d_%" |
| "02d_t%d_h%d_r%d_c%" |
| "d_m%d\n", |
| static_cast< |
| uint32_t>( |
| it.first), |
| i, k, |
| static_cast< |
| unsigned int>( |
| it.first |
| .block_type()), |
| it.first.is_bottom_half_rows() |
| ? 1 |
| : 0, |
| it.first.row(), |
| it.first.column(), |
| it.first.minor()); |
| else |
| fprintf(f, |
| "bit_%08x_%03d_" |
| "%02d\n", |
| static_cast< |
| uint32_t>( |
| it.first), |
| i, k); |
| } |
| if (FLAGS_o.empty()) |
| fprintf(f, "\n"); |
| } else { |
| if (!FLAGS_o.empty()) |
| fprintf(f, ".frame 0x%08x\n", |
| static_cast<uint32_t>(it.first)); |
| |
| for (int i = 0; i < 101; i++) |
| fprintf(f, "%08x%s", |
| it.second.at(i) & |
| ((i != 50 || FLAGS_C) ? 0xffffffff |
| : 0xffffe000), |
| (i % 6) == 5 ? "\n" : " "); |
| fprintf(f, "\n\n"); |
| } |
| } |
| |
| if (FLAGS_p) { |
| int width = pgmdata.size() + pgmsep.size(); |
| int height = 101 * 32 + 100; |
| fprintf(f, "P5 %d %d 15\n", width, height); |
| |
| for (int y = 0, bit = 101 * 32 - 1; y < height; y++, bit--) { |
| for (int x = 0, frame = 0, sep = 0; x < width; |
| x++, frame++) { |
| if (sep < int(pgmsep.size()) && |
| frame == pgmsep.at(sep)) { |
| fputc(8, f); |
| x++, sep++; |
| } |
| |
| fputc(pgmdata.at(frame).at(bit) ? 15 : 0, f); |
| } |
| |
| if (bit % 32 == 0 && y) { |
| for (int x = 0; x < width; x++) |
| fputc(8, f); |
| y++; |
| } |
| } |
| } |
| |
| if (!FLAGS_o.empty()) |
| fclose(f); |
| |
| printf("DONE\n"); |
| return 0; |
| } |
