| # Copyright lowRISC contributors. |
| # Licensed under the Apache License, Version 2.0, see LICENSE for details. |
| # SPDX-License-Identifier: Apache-2.0 |
| # |
| # Convert I2C host format to SVG |
| |
| import logging as log |
| from collections import namedtuple |
| |
| import i2csvg.i2csvg_data as sdata |
| |
| |
| # validating version of int(x, 0) |
| # returns int value, error flag |
| # if error flag is True value will be zero |
| def check_int(x, err_prefix): |
| if isinstance(x, int): |
| return x, False |
| if len(x) == 0: |
| log.error(err_prefix + " Zero length string") |
| return 0, True |
| if x[0] == '0' and len(x) > 2: |
| if x[1] in 'bB': |
| validch = '01' |
| elif x[1] in 'oO': |
| validch = '01234567' |
| elif x[1] in 'xX': |
| validch = '0123456789abcdefABCDEF' |
| else: |
| log.error(err_prefix + |
| ": int must start digit, 0b, 0B, 0o, 0O, 0x or 0X") |
| return 0, True |
| for c in x[2:]: |
| if not c in validch: |
| log.error(err_prefix + ": Bad character " + c + " in " + x) |
| return 0, True |
| else: |
| if not x.isdecimal(): |
| log.error(err_prefix + ": Number not valid int " + x) |
| return 0, 1 |
| return int(x, 0), False |
| |
| |
| def check_single(line, char, fullline, err): |
| ''' Check for character char in input line |
| Return True if there is one (or more) |
| Propagate err or force to err True if more than one char |
| ''' |
| res = False |
| if char in line: |
| res = True |
| if line.count(char) > 1: |
| log.warning('Multiple ' + char + ' in line ' + fullline) |
| err = True |
| return res, err |
| |
| |
| I2cOp = namedtuple('I2cOp', |
| 'read rcont start stop nackok mvalue adr size fbyte tag') |
| |
| |
| def check_and_size(iic, line): |
| ''' Check I2C Op for validity and return size in bits |
| ''' |
| err = False |
| if iic.start and iic.read: |
| log.error('Start and Read found in ' + line) |
| err = True |
| if iic.rcont and not iic.read: |
| log.error('RCont without Read found in ' + line) |
| err = True |
| |
| # documentation says R+C and P is not permitted, but I think it |
| # is needed for protocols where the last read data is ACKed? |
| # (these don't match I2C or SMBus spec but exist in the wild) |
| |
| size = 0 |
| if iic.start: |
| size += 1 |
| if iic.stop: |
| size += 1 |
| if iic.read: |
| # multi is D0, D1, ..., Dn-1 so 3 byte/acks and a 1 bit squiggle |
| # regular read is one byte/ack per |
| size += 9 * 3 + 1 if iic.mvalue else 9 * iic.fbyte |
| else: |
| # write data is one byte/ack |
| size += 9 |
| # rcont, nackok just affect the polarity of the final ack bit |
| # adr just affects how the write data is drawn |
| return size, err |
| |
| |
| def parse_i2c_fifodata(line): |
| ''' Parse input line of I2C FDATA fifo and convert to internal type |
| Line is usually 0x + the hex value written to the register |
| But could be binary (0b), octal (0o) or decimal |
| ''' |
| fifodata, err = check_int(line, 'FIFO value') |
| # bit values here must match the register definition! |
| ress = (fifodata & 0x0100) != 0 |
| resp = (fifodata & 0x0200) != 0 |
| resr = (fifodata & 0x0400) != 0 |
| resc = (fifodata & 0x0800) != 0 |
| resn = (fifodata & 0x1000) != 0 |
| resb = fifodata & 0xff |
| resm = False # only used in descriptive case |
| resa = False # only used in descriptive case |
| |
| tmpr = I2cOp(resr, resc, ress, resp, resn, resm, resa, 0, resb, None) |
| size, serr = check_and_size(tmpr, line) |
| if serr: |
| err = True |
| return I2cOp(resr, resc, ress, resp, resn, resm, resa, size, resb, |
| None), err |
| |
| |
| def parse_i2c_code(line): |
| ''' Parse input line of I2C FDATA fifo and convert to internal type |
| Line is coded with flags and an 8-bit data value |
| S - Start flag, P - stop flag, |
| R - read flag, C - continue read flag, N - NackOk flag |
| followed by the data byte |
| Special cases: |
| M - indicates multiple bytes instead of data byte |
| A - followed by 0 or 1 address/direction or 2 address/data |
| Data value in quotes is a tag |
| ''' |
| resr, resc, ress, resp, resn = False, False, False, False, False |
| resm, resa, resb = False, False, 0 |
| |
| err = False |
| firstval = 0 |
| for i in line: |
| if i.isdigit() or i == "'": |
| break |
| firstval += 1 |
| # Will only check the flags section, so no concern about hex digits |
| ress, err = check_single(line[:firstval], 'S', line, err) |
| resp, err = check_single(line[:firstval], 'P', line, err) |
| resr, err = check_single(line[:firstval], 'R', line, err) |
| resc, err = check_single(line[:firstval], 'C', line, err) |
| resn, err = check_single(line[:firstval], 'N', line, err) |
| # these two are formally part of the value but parse like flags |
| resm, err = check_single(line[:firstval], 'M', line, err) |
| resa, err = check_single(line[:firstval], 'A', line, err) |
| |
| if firstval == len(line): |
| if not resm: |
| err = True |
| log.error('No value found in ' + line) |
| rest = None |
| else: |
| if resm: |
| err = True |
| log.error('Found M and value in ' + line) |
| rest = None |
| resb = 0 |
| elif line[firstval] == "'": |
| rest = line[firstval + 1:-1] |
| resb = 0 |
| else: |
| rest = None |
| resb, verr = check_int(line[firstval:], |
| 'Value in ' + line + ' ' + str(firstval)) |
| if verr: |
| err = True |
| if resb < 0 or resb > 255 or (resa and resb > 2): |
| log.error('Value out of range in ' + line) |
| resb = 0 |
| err = True |
| |
| tmpr = I2cOp(resr, resc, ress, resp, resn, resm, resa, 0, resb, rest) |
| size, serr = check_and_size(tmpr, line) |
| if serr: |
| err = True |
| return I2cOp(resr, resc, ress, resp, resn, resm, resa, size, resb, |
| rest), err |
| |
| |
| def parse_file(infile, fifodata=False, prefix=None): |
| ''' Parse a file of I2C data |
| fifodata indicates if the data is a dump from writes to FDATA fifo |
| prefix is a prefix on valid lines and will be stripped |
| lines without the prefix are ignored |
| Returns list of I2cOps or str (for titles) |
| ''' |
| transaction = [] |
| errors = 0 |
| firstline = True |
| |
| for line in infile: |
| if prefix: |
| if not line.startswith(prefix): |
| continue |
| line = line[len(prefix):] |
| |
| if len(line) == 0 or line.isspace() or line[0] == '#': |
| continue |
| line = line.lstrip().rstrip() |
| if line[0] == 'T': |
| transaction.append(line[1:].lstrip()) |
| continue |
| schar = ',' |
| if fifodata and not ',' in line: |
| # fifodata could also be whitespace spearated |
| schar = None |
| |
| for sline in line.split(sep=schar): |
| if fifodata: |
| t, err = parse_i2c_fifodata(sline) |
| else: |
| t, err = parse_i2c_code(sline) |
| if err: |
| errors += 1 |
| else: |
| transaction.append(t) |
| if errors > 0: |
| log.error('Found ' + str(errors) + ' errors in input') |
| return transaction |
| |
| |
| def output_debug(outfile, t, term): |
| for tr in t: |
| outfile.write(str(tr) + term) |
| |
| |
| def text_element(tr, term, titles): |
| if isinstance(tr, str): |
| if titles: |
| return 'T ' + tr + term |
| return '' |
| flags = 'S' if tr.start else '.' |
| flags += 'P' if tr.stop else '.' |
| flags += 'R' if tr.read else '.' |
| flags += 'C' if tr.rcont else '.' |
| flags += 'N' if tr.nackok else '.' |
| |
| # mvalue and adr are only for drawing, but can propagate in value |
| if tr.adr: |
| val = 'A' + str(tr.fbyte) |
| else: |
| if tr.tag: |
| val = "'" + tr.tag + "'" |
| else: |
| val = 'M' if tr.mvalue else hex(tr.fbyte) |
| return flags + ' ' + val + term |
| |
| |
| def output_text(outfile, transactions, term, titles=True): |
| for tr in transactions: |
| text = text_element(tr, term, titles) |
| if text: |
| outfile.write(text) |
| |
| |
| # use will place a defined group at the given x,y |
| def svg_use(item, x, y): |
| return ' <use href="#' + item + '" x="' + str(x) + \ |
| '" y="' + str(y) + '" />\n' |
| |
| |
| # a byte write is a byte of data from the host and an ack from the device |
| def svg_wrbyte(xpos, ypos, nok, label): |
| rtext = svg_use('hbyte', xpos, ypos) |
| rtext += ' <text x="' + str(xpos + (sdata.bytew / 2)) |
| rtext += '" y="' + str(ypos + sdata.txty) + '">\n' |
| rtext += label |
| rtext += '</text>\n' |
| xpos += sdata.bytew |
| if nok: |
| rtext += svg_use('norackd', xpos, ypos) |
| else: |
| rtext += svg_use('ackd', xpos, ypos) |
| xpos += sdata.bitw |
| return rtext, xpos |
| |
| |
| # a byte read is a byte of data from the device and an ack/nack from the host |
| def svg_rdbyte(xpos, ypos, ack, label): |
| rtext = svg_use('dbyte', xpos, ypos) |
| rtext += ' <text x="' + str(xpos + (sdata.bytew / 2)) |
| rtext += '" y="' + str(ypos + sdata.txty) + '">\n' |
| rtext += label |
| rtext += '</text>\n' |
| xpos += sdata.bytew |
| rtext += svg_use(ack, xpos, ypos) |
| xpos += sdata.bitw |
| return rtext, xpos |
| |
| |
| def svg_element(tr, xpos, ypos): |
| etext = '' |
| if tr.start: |
| etext += svg_use('start', xpos, ypos) |
| xpos += sdata.bitw |
| |
| if tr.read and not tr.mvalue: |
| for n in range(0, 1 if tr.tag else tr.fbyte): |
| acktype = 'ackh' if (n < tr.fbyte - 1) or tr.rcont else 'nackh' |
| t, xpos = svg_rdbyte(xpos, ypos, acktype, |
| tr.tag if tr.tag else 'D' + str(n + 1)) |
| etext += t |
| if xpos > sdata.wrap and (n < tr.fbyte - 1): |
| xpos = sdata.cindent |
| ypos += sdata.linesep |
| elif tr.read and tr.mvalue: |
| # need space to draw three byte+ack and a break squiggle |
| if (xpos + (sdata.bytew + sdata.bitw) * 3 + sdata.bitw) > sdata.wrap: |
| xpos = sdata.cindent |
| ypos += sdata.linesep |
| t, xpos = svg_rdbyte(xpos, ypos, 'ackh', 'Data1') |
| etext += t |
| t, xpos = svg_rdbyte(xpos, ypos, 'ackh', 'Data2') |
| etext += t |
| etext += svg_use('skip', xpos, ypos) |
| xpos += sdata.bitw |
| t, xpos = svg_rdbyte(xpos, ypos, 'nackh', 'DataN') |
| etext += t |
| |
| elif tr.adr: |
| etext += svg_use('adr' + str(tr.fbyte), xpos, ypos) |
| xpos += sdata.bytew |
| etext += svg_use('ackd', xpos, ypos) |
| xpos += sdata.bitw |
| elif tr.mvalue: |
| # need space to draw three byte+ack and a break squiggle |
| if (xpos + (sdata.bytew + sdata.bitw) * 3 + sdata.bitw) > sdata.wrap: |
| xpos = sdata.cindent |
| ypos += sdata.linesep |
| t, xpos = svg_wrbyte(xpos, ypos, tr.nackok, 'Data1') |
| etext += t |
| t, xpos = svg_wrbyte(xpos, ypos, tr.nackok, 'Data2') |
| etext += t |
| etext += svg_use('skip', xpos, ypos) |
| xpos += sdata.bitw |
| t, xpos = svg_wrbyte(xpos, ypos, tr.nackok, 'DataN') |
| etext += t |
| |
| elif tr.start: # and not tr.adr by position in elif |
| etext += svg_use('adr' + str(tr.fbyte & 1), xpos, ypos) |
| etext += ' <text x="' + str(xpos + 115) |
| etext += '" y="' + str(ypos + sdata.txty) + '">' + hex(tr.fbyte >> 1) |
| etext += '</text>\n' |
| xpos += sdata.bytew |
| etext += svg_use('ackd', xpos, ypos) |
| xpos += sdata.bitw |
| |
| else: |
| t, xpos = svg_wrbyte(xpos, ypos, tr.nackok, |
| tr.tag if tr.tag else hex(tr.fbyte)) |
| etext += t |
| |
| if tr.stop: |
| etext += svg_use('pstop', xpos, ypos) |
| xpos += sdata.bitw |
| |
| return etext, xpos, ypos |
| |
| |
| # since they are referenced by href name the style and defs only |
| # go in the first svg in a file |
| first_svg = True |
| |
| |
| def out_svg(outfile, svg, ypos, svgtext): |
| global first_svg |
| outfile.write('<svg\n' + sdata.svgtag_consts) |
| outfile.write('viewBox="0 0 ' + str(sdata.svgw) + ' ' + |
| str(ypos + sdata.linesep + 8) + '">\n') |
| if (first_svg): |
| outfile.write(sdata.svgstyle + sdata.svg_defs) |
| first_svg = False |
| outfile.write(svg) |
| if svgtext: |
| outfile.write('<text x="10" y="' + str(ypos + sdata.linesep + 3)) |
| outfile.write('" class="tt">' + svgtext[:-2] + '</text>\n') |
| outfile.write('</svg>\n') |
| |
| |
| def output_svg(outfile, transactions, title): |
| xpos = 0 |
| ypos = 0 |
| svg = '' |
| svgtext = '' |
| for tr in transactions: |
| if isinstance(tr, str): |
| if svg: |
| out_svg(outfile, svg, ypos, svgtext) |
| if title: |
| outfile.write('<h2>' + tr + '</h2>\n') |
| xpos = 0 |
| ypos = 0 |
| svg = '' |
| svgtext = '' |
| continue |
| if xpos > sdata.wrap: |
| xpos = sdata.cindent |
| ypos += sdata.linesep |
| trsvg, xpos, ypos = svg_element(tr, xpos, ypos) |
| svgtext += text_element(tr, ', ', False) |
| svg += trsvg |
| |
| out_svg(outfile, svg, ypos, svgtext) |
