tools/dump_bitstream.cpp - prjuray-tools - Git at Google

 // Copyright 2020 Project U-Ray Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include <vector>
 #include <iostream>
 #include <map>
 #include <string>
 #include <fstream>
 #include <stdexcept>
 #include <iterator>
 #include <stdarg.h>
 #include <iomanip>
 #include "common.h"

 const uint32_t preamble = 0xAA995566;

 #define SKIP_CRC
 #define SKIP_CHECKSUM
 #define SKIP_COMMENT

 class dummy_ostream : public std::ostream {

 };

 dummy_ostream dummy_out;

 bool verbose_flag = false;

 #define COMMENT(x) (verbose_flag ? std::cout : dummy_out) << x << std::endl


 struct ByteStreamReader {
 	std::vector<uint8_t> data;
 	std::size_t ptr = 0;
 	void reset() {
 		ptr = 0;
 	}
 	bool done() {
 		return ptr >= (data.size() - 3);
 	}
 	uint32_t curr_crc = 0;
 	uint32_t curr_addr = 0;

 	uint32_t next_u32(bool skip_crc = false) {
 		if (done())
 			throw std::runtime_error("at end of bitstream");
 		uint32_t val = data[ptr] << 24UL | data[ptr+1] << 16UL | data[ptr+2] << 8UL | data[ptr+3];
 		ptr += 4;
 		if (!skip_crc)
 			curr_crc = icap_crc(curr_addr, val, curr_crc);
 		return val;
 	}

 	uint32_t peek_u32() {
 		if (done())
 			throw std::runtime_error("at end of bitstream");
 		uint32_t val = data[ptr] << 24UL | data[ptr+1] << 16UL | data[ptr+2] << 8UL | data[ptr+3];
 		return val;
 	}
 	void skip_till_preamble() {
 		while (peek_u32() != preamble)
 			++ptr;
 		COMMENT("# found preamble at offset " << ptr);
 		ptr += 4;
 	}
 };


 enum BitstreamRegister : uint16_t {
 	#define X(a, b) a = b,
 	#include "registers.inc"
 	#undef X
 };


 std::string get_register_name(uint16_t val) {
 	BitstreamRegister r = (BitstreamRegister)val;
 	#define X(a, b) if (val == a) return #a;
 	#include "registers.inc"
 	#undef X
 	return stringf("reg%04x", val);
 }

 std::map<uint32_t, uint32_t> next_frame;

 void parse_bitstream(ByteStreamReader &rd) {
 	rd.reset();
 	rd.skip_till_preamble();
 	uint32_t frame = 0;
 	uint16_t last_reg = 0;
 	uint64_t checksum = 0, exp_checksum = 0;
 	int word = 0;
 	auto is_checksum = [] (int w, int b) {
 		return ((w == 45 && b <= 31) || (w == 46 && b <= 15));
 	};

 	auto get_ecc_value = [](int word, int bit) {
 		int nib = bit / 4;
 		int nibbit = bit % 4;
 		// ECC offset is expanded to 1 bit per nibble,
 		// and then shifted based on the bit index in nibble
 		// e.g. word 3, bit 9
 		// offset: 0b10100110010 - concatenate (3 + (255 - 92)) [frame offset] and 9/4 [nibble offset]
 		// becomes: 0x10100110010
 		// shifted by bit in nibble (9%4): 0x20200220020
 		uint32_t offset =  (word + (255 - 92)) << 3  | nib;
 		uint64_t exp_offset = 0;
 		// Odd parity
 		offset ^= (1 << 11);
 		for (int i = 0; i < 11; i++)
 			if (offset & (1 << i)) offset ^= (1 << 11);
 		// Expansion
 		for (int i = 0; i < 12; i++)
 			if (offset & (1 << i)) exp_offset |= (1ULL << (4 * i));
 		return exp_offset << nibbit;
 	};

 	auto process_word = [&](uint32_t data) {


 		for (int i = 0; i < 32; i++)
 			if (data & (1 << i)) {
 				if (is_checksum(word, i)) {
 					checksum |= 1ULL << ((word - 45) * 32 + i);
 #ifdef SKIP_CHECKSUM
 					continue;
 #endif
 				} else {
 					exp_checksum ^= get_ecc_value(word, i);
 				}
 				std::cout <<  stringf("F0x%08xW%03dB%02d", frame, word, i) << std::endl;
 			}
 		++word;
 		if (word >= 93 && next_frame.count(frame)) {
 			// 4 parity bits for each bit in nibbles
 #if 0
 			for (int i = 0; i < 4; i++)
 				for (int j = 0; j < 11; j++)
 					if (exp_checksum & (1ULL << (4 * j + i)))
 						exp_checksum ^= (1ULL << (44 + i));
 #endif
 			COMMENT(stringf("# checksum: 0x%012llX calc: 0x%012llX %s", checksum, exp_checksum, (checksum == exp_checksum) ? "" : "~~~~~"));
 			checksum = 0;
 			exp_checksum = 0;
 			frame = next_frame.at(frame);
 		}
 	};

 	while (!rd.done()) {
 		uint32_t hdr = rd.next_u32(true);
 		if (hdr == 0xFFFFFFFF) {
 			COMMENT("# desync");
 			rd.skip_till_preamble();
 			continue;
 		}
 		uint8_t type = (hdr >> 29) & 0x07;
 		if (type == 0b001) {
 			// Type 1 (short) packet
 			uint8_t op = (hdr >> 27) & 0x03;
 			switch(op) {
 				case 0x00:
 					COMMENT("# NOP ");
 					// NOP
 					break;
 				case 0x01:
 				    // READ
 				    break;
 				case 0x02: {
 					// WRITE
 					uint16_t reg = (hdr >> 13) & 0x3FFF;
 					rd.curr_addr = reg;
 					last_reg = reg;
 					int count = hdr & 0x3FF;
 					COMMENT("# write " << get_register_name(reg));
 					if (reg == FAR) {
 						if (count != 1)
 							COMMENT("# bad FAR length " << count);
 						exp_checksum = 0;
 						checksum = 0;
 						frame = rd.next_u32();
 						word = 0;
 						COMMENT(stringf("# frame 0x%08x", frame));
 					} else if (reg == CRC) {
 						uint32_t crc = 0;
 						for(int i = 0; i < count; i++)
 							crc = rd.next_u32(true);
 						COMMENT(stringf("# CRC written=%08x calc=%08x %s", crc, rd.curr_crc, (crc == rd.curr_crc) ? "" : "*****"));
 						rd.curr_crc = 0;
 					} else if (reg == FDRI) {
 						for(int i = 0; i < count; i++)
 							process_word(rd.next_u32());
 					} else if (reg == CMD) {
 						uint32_t cmd = 0;
 						for(int i = 0; i < count; i++)
 							cmd = rd.next_u32();
 						COMMENT(stringf("#     CMD %08x", cmd));
 						if (cmd == 0x7)
 							rd.curr_crc = 0;
 					} else {
 						for(int i = 0; i < count; i++)
 							COMMENT(stringf("#     data %08x", rd.next_u32()));
 					}

 					if (reg == CRC && next_frame.count(frame)) {
 						exp_checksum = 0;
 						checksum = 0;
 						frame = next_frame.at(frame);
 					}

 				} break;
 			}
 		} else if (type == 0b010) {
 			// Type 2 (long) packet
 			int count = hdr & 0x3FFFFFF;
 			if (last_reg == FDRI) {
 				for(int i = 0; i < count; i++)
 					process_word(rd.next_u32());
 			} else {
 				for(int i = 0; i < count; i++)
 					COMMENT(stringf("#     data %08x", rd.next_u32()));
 			}
 		} else {
 			std::cout << stringf("# unknown packet type %01x (header: %08x)", type, hdr) << std::endl;
 			return;
 		}
 	}
 }

 int main(int argc, char *argv[]) {
 	if (argc < 2) {
 		std::cerr << "Usage: dump_bitstream file.bit [frames.txt] [verbose]" << std::endl;
 		return 2;
 	}

 	if (argc > 2) {
 		std::ifstream frame_db(argv[2]);
 		bool had_last = false;
 		uint32_t last;
 		uint32_t val;
 		frame_db.unsetf(std::ios::dec);
 		frame_db.unsetf(std::ios::hex);
 		frame_db.unsetf(std::ios::oct);
 		while (frame_db >> val) {
 			if (had_last)
 				next_frame[last] = val;
 			last = val;
 			had_last = true;
 		}
 	}

 	if (argc > 3) {
 		if (std::string(argv[3]) == "verbose")
 			verbose_flag = true;
 	}

 	ByteStreamReader rd;
 	std::ifstream file(argv[1], std::ios::binary);
 	file.unsetf(std::ios::skipws);
 	if (!file) {
 		std::cerr << "Failed to open input file" << std::endl;
 		return 2;
 	}
 	rd.data.insert(rd.data.begin(), std::istream_iterator<uint8_t>(file), std::istream_iterator<uint8_t>());
 	parse_bitstream(rd);
 }
	// Copyright 2020 Project U-Ray Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include <vector>
	#include <iostream>
	#include <map>
	#include <string>
	#include <fstream>
	#include <stdexcept>
	#include <iterator>
	#include <stdarg.h>
	#include <iomanip>
	#include "common.h"

	const uint32_t preamble = 0xAA995566;

	#define SKIP_CRC
	#define SKIP_CHECKSUM
	#define SKIP_COMMENT

	class dummy_ostream : public std::ostream {

	};

	dummy_ostream dummy_out;

	bool verbose_flag = false;

	#define COMMENT(x) (verbose_flag ? std::cout : dummy_out) << x << std::endl


	struct ByteStreamReader {
	std::vector<uint8_t> data;
	std::size_t ptr = 0;
	void reset() {
	ptr = 0;
	}
	bool done() {
	return ptr >= (data.size() - 3);
	}
	uint32_t curr_crc = 0;
	uint32_t curr_addr = 0;

	uint32_t next_u32(bool skip_crc = false) {
	if (done())
	throw std::runtime_error("at end of bitstream");
	uint32_t val = data[ptr] << 24UL \| data[ptr+1] << 16UL \| data[ptr+2] << 8UL \| data[ptr+3];
	ptr += 4;
	if (!skip_crc)
	curr_crc = icap_crc(curr_addr, val, curr_crc);
	return val;
	}

	uint32_t peek_u32() {
	if (done())
	throw std::runtime_error("at end of bitstream");
	uint32_t val = data[ptr] << 24UL \| data[ptr+1] << 16UL \| data[ptr+2] << 8UL \| data[ptr+3];
	return val;
	}
	void skip_till_preamble() {
	while (peek_u32() != preamble)
	++ptr;
	COMMENT("# found preamble at offset " << ptr);
	ptr += 4;
	}
	};



	enum BitstreamRegister : uint16_t {
	#define X(a, b) a = b,
	#include "registers.inc"
	#undef X
	};



	std::string get_register_name(uint16_t val) {
	BitstreamRegister r = (BitstreamRegister)val;
	#define X(a, b) if (val == a) return #a;
	#include "registers.inc"
	#undef X
	return stringf("reg%04x", val);
	}

	std::map<uint32_t, uint32_t> next_frame;

	void parse_bitstream(ByteStreamReader &rd) {
	rd.reset();
	rd.skip_till_preamble();
	uint32_t frame = 0;
	uint16_t last_reg = 0;
	uint64_t checksum = 0, exp_checksum = 0;
	int word = 0;
	auto is_checksum = [] (int w, int b) {
	return ((w == 45 && b <= 31) \|\| (w == 46 && b <= 15));
	};

	auto get_ecc_value = [](int word, int bit) {
	int nib = bit / 4;
	int nibbit = bit % 4;
	// ECC offset is expanded to 1 bit per nibble,
	// and then shifted based on the bit index in nibble
	// e.g. word 3, bit 9
	// offset: 0b10100110010 - concatenate (3 + (255 - 92)) [frame offset] and 9/4 [nibble offset]
	// becomes: 0x10100110010
	// shifted by bit in nibble (9%4): 0x20200220020
	uint32_t offset = (word + (255 - 92)) << 3 \| nib;
	uint64_t exp_offset = 0;
	// Odd parity
	offset ^= (1 << 11);
	for (int i = 0; i < 11; i++)
	if (offset & (1 << i)) offset ^= (1 << 11);
	// Expansion
	for (int i = 0; i < 12; i++)
	if (offset & (1 << i)) exp_offset \|= (1ULL << (4 * i));
	return exp_offset << nibbit;
	};

	auto process_word = [&](uint32_t data) {


	for (int i = 0; i < 32; i++)
	if (data & (1 << i)) {
	if (is_checksum(word, i)) {
	checksum \|= 1ULL << ((word - 45) * 32 + i);
	#ifdef SKIP_CHECKSUM
	continue;
	#endif
	} else {
	exp_checksum ^= get_ecc_value(word, i);
	}
	std::cout << stringf("F0x%08xW%03dB%02d", frame, word, i) << std::endl;
	}
	++word;
	if (word >= 93 && next_frame.count(frame)) {
	// 4 parity bits for each bit in nibbles
	#if 0
	for (int i = 0; i < 4; i++)
	for (int j = 0; j < 11; j++)
	if (exp_checksum & (1ULL << (4 * j + i)))
	exp_checksum ^= (1ULL << (44 + i));
	#endif
	COMMENT(stringf("# checksum: 0x%012llX calc: 0x%012llX %s", checksum, exp_checksum, (checksum == exp_checksum) ? "" : "~~~~~"));
	checksum = 0;
	exp_checksum = 0;
	frame = next_frame.at(frame);
	}
	};

	while (!rd.done()) {
	uint32_t hdr = rd.next_u32(true);
	if (hdr == 0xFFFFFFFF) {
	COMMENT("# desync");
	rd.skip_till_preamble();
	continue;
	}
	uint8_t type = (hdr >> 29) & 0x07;
	if (type == 0b001) {
	// Type 1 (short) packet
	uint8_t op = (hdr >> 27) & 0x03;
	switch(op) {
	case 0x00:
	COMMENT("# NOP ");
	// NOP
	break;
	case 0x01:
	// READ
	break;
	case 0x02: {
	// WRITE
	uint16_t reg = (hdr >> 13) & 0x3FFF;
	rd.curr_addr = reg;
	last_reg = reg;
	int count = hdr & 0x3FF;
	COMMENT("# write " << get_register_name(reg));
	if (reg == FAR) {
	if (count != 1)
	COMMENT("# bad FAR length " << count);
	exp_checksum = 0;
	checksum = 0;
	frame = rd.next_u32();
	word = 0;
	COMMENT(stringf("# frame 0x%08x", frame));
	} else if (reg == CRC) {
	uint32_t crc = 0;
	for(int i = 0; i < count; i++)
	crc = rd.next_u32(true);
	COMMENT(stringf("# CRC written=%08x calc=%08x %s", crc, rd.curr_crc, (crc == rd.curr_crc) ? "" : "*****"));
	rd.curr_crc = 0;
	} else if (reg == FDRI) {
	for(int i = 0; i < count; i++)
	process_word(rd.next_u32());
	} else if (reg == CMD) {
	uint32_t cmd = 0;
	for(int i = 0; i < count; i++)
	cmd = rd.next_u32();
	COMMENT(stringf("# CMD %08x", cmd));
	if (cmd == 0x7)
	rd.curr_crc = 0;
	} else {
	for(int i = 0; i < count; i++)
	COMMENT(stringf("# data %08x", rd.next_u32()));
	}

	if (reg == CRC && next_frame.count(frame)) {
	exp_checksum = 0;
	checksum = 0;
	frame = next_frame.at(frame);
	}

	} break;
	}
	} else if (type == 0b010) {
	// Type 2 (long) packet
	int count = hdr & 0x3FFFFFF;
	if (last_reg == FDRI) {
	for(int i = 0; i < count; i++)
	process_word(rd.next_u32());
	} else {
	for(int i = 0; i < count; i++)
	COMMENT(stringf("# data %08x", rd.next_u32()));
	}
	} else {
	std::cout << stringf("# unknown packet type %01x (header: %08x)", type, hdr) << std::endl;
	return;
	}
	}
	}

	int main(int argc, char *argv[]) {
	if (argc < 2) {
	std::cerr << "Usage: dump_bitstream file.bit [frames.txt] [verbose]" << std::endl;
	return 2;
	}

	if (argc > 2) {
	std::ifstream frame_db(argv[2]);
	bool had_last = false;
	uint32_t last;
	uint32_t val;
	frame_db.unsetf(std::ios::dec);
	frame_db.unsetf(std::ios::hex);
	frame_db.unsetf(std::ios::oct);
	while (frame_db >> val) {
	if (had_last)
	next_frame[last] = val;
	last = val;
	had_last = true;
	}
	}

	if (argc > 3) {
	if (std::string(argv[3]) == "verbose")
	verbose_flag = true;
	}

	ByteStreamReader rd;
	std::ifstream file(argv[1], std::ios::binary);
	file.unsetf(std::ios::skipws);
	if (!file) {
	std::cerr << "Failed to open input file" << std::endl;
	return 2;
	}
	rd.data.insert(rd.data.begin(), std::istream_iterator<uint8_t>(file), std::istream_iterator<uint8_t>());
	parse_bitstream(rd);
	}