#!/usr/bin/env python3 # -*- coding: utf-8 -*- # # Copyright (C) 2017-2020 The Project X-Ray Authors. # # Use of this source code is governed by a ISC-style # license that can be found in the LICENSE file or at # https://opensource.org/licenses/ISC # # SPDX-License-Identifier: ISC ''' Spartan 6 bitstream analyzer tool. This script reads a Spartan6 bitstream and prints out some useful information. It can also create a frames file with the configuration data words. The bitstream is analyzed word by word and interpreted according to the UG380 Configuration User Guide. The tool can be used to derive the initialization, startup and finalization sequence as well as the configuration data. The latter is written to a frames file which can be used by the bitstream tools such as frames2bit to generate a valid bitstream. ''' import argparse from io import StringIO from prjxray.util import OpenSafeFile conf_regs = { 0: "CRC", 1: "FAR_MAJ", 2: "FAR_MIN", 3: "FDRI", 4: "FDRO", 5: "CMD", 6: "CTL", 7: "MASK", 8: "STAT", 9: "LOUT", 10: "COR1", 11: "COR2", 12: "PWRDN_REG", 13: "FLR", 14: "IDCODE", 15: "CWDT", 16: "HC_OPT_REG", 18: "CSBO", 19: "GENERAL1", 20: "GENERAL2", 21: "GENERAL3", 22: "GENERAL4", 23: "GENERAL5", 24: "MODE_REG", 25: "PU_GWE", 26: "PU_GTS", 27: "MFWR", 28: "CCLK_FREQ", 29: "SEU_OPT", 30: "EXP_SIGN", 31: "RDBK_SIGN", 32: "BOOTSTS", 33: "EYE_MASK", 34: "CBC_REG" } cmd_reg_codes = { 0: "NULL", 1: "WCFG", 2: "MFW", 3: "LFRM", 4: "RCFG", 5: "START", 7: "RCRC", 8: "AGHIGH", 10: "GRESTORE", 11: "SHUTDOWN", 13: "DESYNC", 14: "IPROG" } opcodes = ("NOP", "READ", "WRITE", "UNKNOWN") def KnuthMorrisPratt(text, pattern): ''' Yields all starting positions of copies of the pattern in the text. Calling conventions are similar to string.find, but its arguments can be lists or iterators, not just strings, it returns all matches, not just the first one, and it does not need the whole text in memory at once. Whenever it yields, it will have read the text exactly up to and including the match that caused the yield. ''' # allow indexing into pattern and protect against change during yield pattern = list(pattern) # build table of shift amounts shifts = [1] * (len(pattern) + 1) shift = 1 for pos in range(len(pattern)): while shift <= pos and pattern[pos] != pattern[pos - shift]: shift += shifts[pos - shift] shifts[pos + 1] = shift # do the actual search startPos = 0 matchLen = 0 for c in text: while matchLen == len(pattern) or \ matchLen >= 0 and pattern[matchLen] != c: startPos += shifts[matchLen] matchLen -= shifts[matchLen] matchLen += 1 if matchLen == len(pattern): yield startPos class Bitstream: def __init__(self, file_name, verbose=False): self.frame_data = [] self.idcode = 0 self.exp_sign = 0 self.far_min = 0 self.far_maj = 0 self.curr_fdri_write_len = 0 self.curr_crc_check = 0 self.fdri_in_progress = False with OpenSafeFile(file_name, "rb") as f: self.bytes = f.read() pos, self.header = self.get_header() self.body = [ (i << 8) | j for i, j in zip(self.bytes[pos::2], self.bytes[pos + 1::2]) ] self.parse_bitstream(verbose) def get_header(self): pos = next(KnuthMorrisPratt(self.bytes, [0xaa, 0x99, 0x55, 0x66])) return pos + 4, self.bytes[:pos + 4] def parse_bitstream(self, verbose): payload_len = 0 for word in self.body: if payload_len > 0: if verbose: print("\tWord: ", hex(word)) payload_len = self.parse_reg( reg_addr, word, payload_len, verbose) continue else: packet_header = self.parse_packet_header(word) opcode = packet_header["opcode"] reg_addr = packet_header["reg_addr"] words = packet_header["word_count"] type = packet_header["type"] if verbose: print( "\tWord: ", hex(word), 'Type: {}, Op: {}, Addr: {}, Words: {}'.format( type, opcodes[opcode], reg_addr, words)) if opcode and reg_addr in conf_regs: payload_len = words continue def parse_packet_header(self, word): type = (word >> 13) & 0x7 opcode = (word >> 11) & 0x3 reg_addr = (word >> 5) & 0x3F if type == 1: word_count = word & 0x1F elif type == 2: word_count = 2 else: word_count = 0 return { "type": type, "opcode": opcode, "reg_addr": reg_addr, "word_count": word_count } def parse_command(self, word): return cmd_reg_codes[word] def parse_cor1(self, word): return word def parse_cor2(self, word): return word def parse_ctl(self, word): #decryption dec = (word >> 6) & 1 #security bits sb = (word >> 4) & 3 #persist p = (word >> 3) & 1 #use efuse efuse = (word >> 2) & 1 #crc extstat disable crc = (word >> 1) & 1 return { "decryption": dec, "security bits": sb, "pesist": p, "use efuse": efuse, "crc extstat disable": crc } def parse_cclk_freq(self, word): ext_mclk = (word >> 14) & 1 mclk_freq = word & 0x3FF return (ext_mclk, mclk_freq) def parse_pwrdn(self, word): en_eyes = (word >> 14) & 1 filter_b = (word >> 5) & 1 en_pgsr = (word >> 4) & 1 en_pwrdn = (word >> 2) & 1 keep_sclk = word & 1 return { "en_eyes": en_eyes, "filter_b": filter_b, "en_pgsr": en_pgsr, "en_pwrdn": en_pwrdn, "keep_sclk": keep_sclk } def parse_eye_mask(self, word): return word & 0xFF def parse_hc_opt(self, word): return (word >> 6) & 1 def parse_cwdt(self, word): return word def parse_pu_gwe(self, word): return word & 0x3FF def parse_pu_gts(self, word): return word & 0x3FF def parse_mode(self, word): new_mode = (word >> 13) & 0x1 buswidth = (word >> 11) & 0x3 bootmode = (word >> 8) & 0x7 bootvsel = word & 0xFF return { "new_mode": new_mode, "buswidth": buswidth, "bootmode": bootmode, "bootvsel": bootvsel } def parse_seu(self, word): seu_freq = (word >> 4) & 0x3FF seu_run_on_err = (word >> 3) & 0x1 glut_mask = (word >> 1) & 0x1 seu_enable = word & 0x1 return { "seu_freq": seu_freq, "seu_run_on_err": seu_run_on_err, "glut_mask": glut_mask, "seu_enable": seu_enable } def parse_reg(self, reg_addr, word, payload_len, verbose): reg = conf_regs[reg_addr] if reg == "CMD": command = self.parse_command(word) if verbose: print("Command: {}\n".format(command)) elif reg == "FLR": frame_length = word if verbose: print("Frame length: {}\n".format(frame_length)) elif reg == "COR1": conf_options = self.parse_cor1(word) if verbose: print("COR1 options: {}\n".format(conf_options)) elif reg == "COR2": conf_options = self.parse_cor2(word) if verbose: print("COR2 options: {}\n".format(conf_options)) elif reg == "IDCODE": assert payload_len < 3 if payload_len == 2: self.idcode = word << 16 elif payload_len == 1: self.idcode |= word if verbose: print("IDCODE: {}\n".format(hex(self.idcode))) elif reg == "MASK": mask = word if verbose: print("Mask value: {}\n".format(mask)) elif reg == "CTL": ctl_options = self.parse_ctl(word) if verbose: print("CTL options: {}\n".format(ctl_options)) elif reg == "CCLK_FREQ": cclk_freq_options = self.parse_cclk_freq(word) if verbose: print("CCLK_FREQ options: {}\n".format(cclk_freq_options)) elif reg == "PWRDN_REG": suspend_reg_options = self.parse_pwrdn(word) if verbose: print("{} options: {}\n".format(reg, suspend_reg_options)) elif reg == "EYE_MASK": eye_mask = self.parse_eye_mask(word) if verbose: print("{} options: {}\n".format(reg, eye_mask)) elif reg == "HC_OPT_REG": hc_options = self.parse_hc_opt(word) if verbose: print("{} options: {}\n".format(reg, hc_options)) elif reg == "CWDT": cwdt_options = self.parse_cwdt(word) if verbose: print("{} options: {}\n".format(reg, cwdt_options)) elif reg == "PU_GWE": pu_gwe_sequence = self.parse_pu_gwe(word) if verbose: print("{} options: {}\n".format(reg, pu_gwe_sequence)) elif reg == "PU_GTS": pu_gts_sequence = self.parse_pu_gts(word) if verbose: print("{} options: {}\n".format(reg, pu_gts_sequence)) elif reg == "MODE_REG": mode_options = self.parse_mode(word) if verbose: print("{} options: {}\n".format(reg, mode_options)) elif reg == "GENERAL1" or reg == "GENERAL2" \ or reg == "GENERAL3" or reg == "GENERAL4" \ or reg == "GENERAL5": general_options = word if verbose: print("{} options: {}\n".format(reg, general_options)) elif reg == "SEU_OPT": seu_options = self.parse_seu(word) if verbose: print("{} options: {}\n".format(reg, seu_options)) elif reg == "EXP_SIGN": if payload_len == 2: self.exp_sign = word << 16 elif payload_len == 1: self.exp_sign |= word if verbose: print("{}: {}\n".format(reg, self.exp_sign)) elif reg == "FAR_MAJ": if payload_len == 2: self.current_far_maj = word elif payload_len == 1: self.current_far_min = word if verbose: print( "{}: {} FAR_MIN: {}\n".format( reg, self.far_maj, self.far_min)) elif reg == "FDRI": if self.fdri_in_progress: self.frame_data.append(word) if payload_len == 1: self.fdri_in_progress = False return 0 elif payload_len == 2: self.curr_fdri_write_len = (word & 0xFFF) << 16 elif payload_len == 1: self.curr_fdri_write_len |= word self.fdri_in_progress = True # Check if 0 words actually means read something payload_len = self.curr_fdri_write_len + 2 if verbose: print("{}: {}\n".format(reg, self.curr_fdri_write_len)) return payload_len elif reg == "CRC": if payload_len == 2: self.curr_crc_check = (word & 0xFFF) << 16 elif payload_len == 1: self.curr_crc_check |= word if verbose: print("{}: {}\n".format(reg, self.curr_crc_check)) payload_len -= 1 return payload_len def write_frames_txt(self, file_name): '''Write frame data in a more readable format''' frame_stream = StringIO() for i in range(len(self.frame_data)): if i % 65 == 0: frame_stream.write("\nFrame {:4}\n".format(i // 65)) #IOB word if i % 65 == 32: frame_stream.write( "\n#{:3}:{:6}\n".format(i % 65, hex(self.frame_data[i]))) else: frame_stream.write( "#{:3}:{:6},".format(i % 65, hex(self.frame_data[i]))) with OpenSafeFile(file_name, "w") as f: print(frame_stream.getvalue(), file=f) def write_frames(self, file_name): '''Write configuration data to frames file''' frame_stream = StringIO() for i in range(len(self.frame_data)): if i % 65 == 0: frame_stream.write("0x{:08x} ".format(i // 65)) frame_stream.write("0x{:04x}".format(self.frame_data[i])) if i % 65 == 64: frame_stream.write("\n") elif i < len(self.frame_data) - 1: frame_stream.write(",") with OpenSafeFile(file_name, "w") as f: print(frame_stream.getvalue(), file=f) def main(args): verbose = not args.silent bitstream = Bitstream(args.bitstream, verbose) print("Frame data length: ", len(bitstream.frame_data)) if args.frames_out: bitstream.write_frames(args.frames_out) if verbose: bitstream.write_frames_txt(args.frames_out + ".txt") if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument('--bitstream', help='Input bitstream') parser.add_argument('--frames_out', help='Output frames file') parser.add_argument( '--silent', help="Don't print analysis details", action='store_true') args = parser.parse_args() main(args)