def __init__( self, cx, lo, siz=None, hi=None, prefixed=False, compact=False, ): self.lo = lo self.name = self.__class__.__name__ if siz: assert hi == None or hi == lo + siz hi = lo + siz self.hi = hi self.prefixed = prefixed self.compact = compact if compact: if prefixed: self.y = data.Data(cx.m, self.lo - 5, self.hi) else: self.y = data.Data(cx.m, self.lo, self.hi) self.y.rendered = str(self) self.y.compact = True elif prefixed: self.pfx = data.Data(cx.m, self.lo - 5, self.lo) c = PFXS.get(cx.m.le(self.lo - 5, 5)) t = "$" + self.__class__.__name__.upper() if c: pc = '$' + c.__name__.upper() if pc != t: t = pc + " (" + t + ")" self.pfx.rendered = t if hi: self.set_hi(cx, hi)
def one_eprom(cx, start, eprom_size): # Calculate checksum j = 0 ^ cx.m.bu16(start) for jj in range(2, eprom_size): j += cx.m[start + jj] j &= 0xffff if j == 0xffff: j = "OK" else: print("NB: Bad Eprom checksum @%x" % start) j = "BAD" c = cx.m.add_range(start, start + eprom_size, txt="EPROM") c = data.Data(cx.m, start, start + 2, "u16") c.rendered = ".WORD 0x%04x" % cx.m.bu16(start) c.lcmt = "EPROM checksum (%s)" % j c = data.Data(cx.m, start + 2, start + 3, "byte") c.rendered = ".BYTE 0x%02x" % cx.m[start + 2] c.lcmt = "EPROM ID" # Jump table at front of EPROM for ax in range(start + 3, start + eprom_size, 3): if cx.m[ax] != 0x7e: break cx.disass(ax)
def __init__(self, cx, lo, **kwargs): # print("LIB 0x%05x" % lo) cx.m.set_block_comment(lo, "Library") super().__init__(cx, lo, **kwargs) self.links = self.names = self.msgs = self.config = None b = lo + 5 nl = Const(cx.m, b, 2, "Name Length") b = nl.hi if nl.val: y = data.Data(cx.m, b, b + nl.val * 2) y.rendered = "'" + text(cx.m, b, nl.val) + "'" y.compact = True b = y.hi nl = Const(cx.m, b, 2, "Name Length") b = nl.hi ln = Const(cx.m, b, 3, "Library Number") b = ln.hi self.libno = ln.val y = Relptr(cx.m, b, "Name Table") b = y.hi if y.dst: self.names = Obj(cx, y.dst, cls=NameTable) cx.m.set_label(self.names.lo, "LIB_%03x_NAMES" % self.libno) y = Relptr(cx.m, b, "Message Table") b = y.hi if y.dst: self.msgs = Obj(cx, y.dst) cx.m.set_label(self.msgs.lo, "LIB_%03x_MESSAGES" % self.libno) y = Relptr(cx.m, b, "Link Table") b = y.hi if y.dst: self.links = Obj(cx, y.dst, cls=LinkTable) cx.m.set_label(self.links.lo, "LIB_%03x_LINKS" % self.libno) y = Relptr(cx.m, b, "Config object") b = y.hi if y.dst: self.config = Obj(cx, y.dst) cx.m.set_label(self.config.lo, "LIB_%03x_CONFIG" % self.libno) if self.links: for n, i in enumerate(self.links.links): cx.libobj[(self.libno, n)] = i if self.names: t = self.names.names.get(n) else: t = None if t: cx.m.set_label(i, "LIB_%03x_%03x_%s" % (self.libno, n, t)) else: cx.m.set_label(i, "LIB_%03x_%03x" % (self.libno, n)) n1 = cx.m.le(i - 3, 3) n2 = cx.m.le(i - 6, 3) if n1 == n and n2 == self.libno: Const(cx.m, i - 6, 6) cx.m.set_line_comment(i - 6, "XYZZY") cx.m.q.queue(PRI_RPN, Obj, cx, i)
def __init__(self, cx, lo, lbl=None): self.cx = cx self.lo = lo self.lbl = lbl if self.lbl: self.cx.m.set_label(self.lo, self.lbl) else: self.cx.m.set_label(self.lo, "BITSPEC_%04x" % self.lo) adr = self.lo while self.cx.m[adr] != 0xff: item = data.Data(self.cx.m, adr, adr + 9) tbl = [] for _j in range(8): j = self.cx.m[adr] adr += 1 if j != 0x1f: tbl.append("+0x%02x.%d" % (j & 0x1f, 7 - (j >> 5))) else: tbl.append("NOP ") tbl.append("0x%02x" % self.cx.m[adr]) adr += 1 item.rendered = ".BITPOS\t" + ", ".join(tbl) item.compact = True data.Const(self.cx.m, adr, adr + 1)
def example(): m = mem.Stackup((FILENAME,), nextto=__file__) m2 = mem.WordMem(0, m.hi >> 1, bits=16) for a in range(m.lo, m.hi, 2): m2[a >> 1] = m.bu16(a) cx = hp_hybrid.hp_hybrid() cx.m.map(m2, 0x20, offset=0x20) cx.flow_check.append(fc_call) rom_checksum(cx.m) for a, b in SYMBOLS.items(): if b[0] == '_': cx.m.set_label(a, b[1:]) cx.disass(a) elif b[0] == '#': cx.m.set_label(a, b[1:]) y = data.Data(cx.m, a, a + 1) y.rendered = ".CONST\t0x%04x" % cx.m[a] else: cx.m.set_label(a, b) pat4244024.appendix_b_1(cx, 0x3a49) pat4244024.appendix_b_2(cx, 0x3ac2) pat4244024.appendix_b_3(cx, 0x3ca5) pat4244024.appendix_b_4(cx, 0x3d2c) pat4244024.appendix_b_5(cx, 0x3d4b) pat4244024.appendix_b_7(cx, 0x3df0) pat4244024.appendix_b_8(cx, 0x3e02) pat4244024.appendix_b_9(cx, 0x3e13) pat4244024.appendix_b_10(cx, 0x3e30) pat4244024.appendix_b_11(cx, 0x3e4a) pat4244024.appendix_b_12(cx, 0x3e6c) pat4244024.appendix_b_13(cx, 0x3e78) pat4244024.appendix_b_15(cx, 0x3e86) pat4244024.appendix_b_16(cx, 0x3ebc) pat4244024.appendix_b_17(cx, 0x3ebf) pat4244024.appendix_b_18(cx, 0x3ec2) pat4244024.appendix_b_21(cx, 0x3a35) pat4244024.appendix_b_28a(cx, 0x0020) pat4244024.appendix_b_28b(cx, 0x0200) if True: for a in range(0x3ef, 0x40a): data.Const(cx.m, a, a + 1) y = wgstring(cx.m, cx.m[a]) y.compact = True for a in range(0x1ebb, 0x1ec6): data.Const(cx.m, a, a + 1) y = wgstring(cx.m, cx.m[a]) y.compact = True cx.disass(0x20) code.lcmt_flows(cx.m) return NAME, (cx.m,)
def square_tbl(asp): for i in range(256): x = asp[0x6e00 + i] y = (i * i) & 0xff assert x == y x = asp[0x6f00 + i] y = (i * i) >> 8 assert x == y x = data.Data(asp, 0x6e00, 0x6f00, "TBL_6E00") x.rendered = "FOR I (0..255):\n .BYTE ((I * I) & 0xff)" x.compact = True asp.set_label(0x6e00, "SQUARE_TBL_LO") x = data.Data(asp, 0x6f00, 0x7000, "TBL_6F00") x.rendered = "FOR I (0..255):\n .BYTE ((I * I) >> 8)" x.compact = True asp.set_label(0x6f00, "SQUARE_TBL_HI")
def symb(cx, a, b): if b[0] == '_': cx.m.set_label(a, b[1:]) cx.disass(a) elif b[0] == '#': cx.m.set_label(a, b[1:]) y = data.Data(cx.m, a, a + 1) y.rendered = ".CONST\t0x%04x" % cx.m[a] else: cx.m.set_label(a, b)
def switch(cx, lo, hi): y = data.Data(cx.m, lo, hi) y.fmt = "" n = 0 for a in range(lo, hi, 2): o = cx.m.bs16(a) y.fmt += "[%d] -> 0x%x\n" % (n, lo + o) cx.disass(lo + o) cx.m.set_label(lo + o, "CASE_%x_%d" % (lo, n)) n += 1
def char_def(pj, a): for i in range(8): y = data.Data(pj, a + i, a + i + 1) x = pj.m[a + i] y.fmt = ".BITS\t" for j in range(8): if x & 0x80: y.fmt += "#" else: y.fmt += "-" x = x << 1
def wordtable(self): self.lang.m.set_label(self.hi, self.nm + '_TAB') hh = self.hi for j in range(self.low, self.high + 1): o = self.lang.m.bs16(hh) + self.hi self.dst(self.lang, j, o) y = data.Data(self.lang.m, hh, hh + 2, fmt=self.nm + '_TAB[%d] = 0x%x' % (j, o)) hh = y.hi
def tblx(a): c = data.Data(cx.m, a, a + 16, "tblx") s = "" for i in range(10): v = cx.m[a + i] s += " %02x" % v s += " " for i in range(10, 16): v = cx.m[a + i] s += " %02x" % v c.rendered = "TBLX " + s c.compact = True
def switchblock_16(adr, nswitch, lang): asp = lang.m nswitch += 1 tl = (nswitch * 2 + 3) & ~3 a = adr txt = '' for i in range(nswitch): o = asp.lu16(a) * 4 d = adr + 4 + o asp.set_label(d, "switch_0x%x_%d" % (adr, i)) lang.disass(d) txt += '[%d] .+0x%x (0x%x)\n' % (i, o, d) a += 2 y = data.Data(asp, adr, adr + tl, fmt=txt)
def __init__(self, cx, lo, **kwargs): super().__init__(cx, lo, **kwargs) b = lo + 5 for i in range(16): y = Relptr(cx.m, b, "NamLen=%d" % (i + 1)) b = y.hi y = Relptr(cx.m, b, "End") b = y.hi e = y.dst h = {} while b < e: x = cx.m.le(b, 2) c = b + 2 t = text(cx.m, c, x) h[b] = t c += 2 * x z = cx.m.le(c, 3) c += 3 y = data.Data(cx.m, b, c) y.rendered = ".NAME\t0x%03x, 0x%x, '%s'" % (z, x, t) y.compact = True b = c self.names = {} n = 0 y = data.Data(cx.m, b, self.hi) r = [] while b < self.hi: x = cx.m.le(b, 5) if x: nm = h[b - x] self.names[n] = nm r.append(".IDX\t0x%03x: '%s'" % (n, nm)) n += 1 b += 5 y.rendered = "\n".join(r) y.compact = True assert b == self.hi
def data_float(pj, a): y = data.Data(pj, a, a + 4) x = pj.m.bu32(a) e = x & 0xff if e & 0x80: e -= 0x100 m = x >> 8 s = m >> 23 m &= 0x7fffff y.val = m * (2.0 ** (e - 22.0)) if s: y.val *= -1 y.fmt = ".FLOAT\t%g" % y.val y.lcmt = "s=%d m=0x%06x e=%d" % (s,m,e) return y
def __init__(self, cx, lo, **kwargs): super().__init__(cx, lo, **kwargs) y = Const(cx.m, lo + 5, 5, "Rows") b = y.hi self.rows = y.val y = Const(cx.m, b, 5, "Cols") b = y.hi self.cols = y.val if self.rows and self.cols: b2, bm = do_bitmap(cx.m, b, self.cols, self.rows) y = data.Data(cx.m, b, b2) y.rendered = str(bm) y.compact = True
def arg_range(cx, cmds, start, end): x = cx.m.add_range(start, end, txt="ARG_RANGE") cx.m.set_label(start, "ARG_RANGE") l = list() n = 0 for a in range(start, end, 2): c = cmds[n] n += 1 lo = cx.m[a] hi = cx.m[a + 1] x = data.Data(cx.m, a, a + 2, "byte") x.rendered = ".BYTE\t0x%02x, 0x%02x" % (lo, hi) x.lcmt = c + "[%d" % lo + "-%d]" % hi for j in range(lo, hi + 1): l.append(c + "%d" % j) for j in cmds[n:]: l.append(j) return l
def data_float(asp, a): y = DATA.get(a) if not y: y = data.Data(asp, a, a + 4) x = asp.bu32(a) e = x & 0xff if e & 0x80: e -= 0x100 m = x >> 8 s = m >> 23 m &= 0x7fffff y.val = m * (2.0**(e - 22.0)) if s: y.val *= -1 y.fmt = ".FLOAT\t%g" % y.val y.lcmt = "s=%d m=0x%06x e=%d" % (s, m, e) DATA[a] = y return y
def from_asp(self, asp, lo, wfunc=None, render=True): ''' Read record from address-space ''' if not wfunc: wfunc = asp.lu16 while not asp[lo]: lo += 1 self.lo = lo for i in range(6): self.words.append(wfunc(lo)) lo += 2 for i in range(self.words[1], 65536): self.words.append(wfunc(lo)) lo += 2 if sum(self.words) & 0xffff: raise Exception("Checksum error") self.hi = lo if render: y = data.Data(asp, self.lo, self.hi) y.rendered = self.relrec() y.compact = True if self.words[0] == 7: y.lcmt = b40(self.words[6:8]) return self, lo
def assy_dst(self, cde=True): a = self['adr'] if a & 0x200: a -= 0x400 if self['c']: a += self.lo dd = (a + (1 << 16)) & 0x7fff if not self['d']: if cde: self.dstadr = dd return assy.Arg_dst(self.lang.m, dd) try: d = self.lang.m[dd] y = data.Data(self.lang.m, dd, dd + 1) y.rendered = ".REF\t0x%04x" % d if cde: self.dstadr = d return [assy.Arg_dst(self.lang.m, d), assy.Arg_verbatim("[Via 0x%04x]" % dd)] except mem.MemError: pass if cde: self.dstadr = dd return [assy.Arg_dst(self.lang.m, dd), assy.Arg_verbatim("I")]
def __init__(self, cx, lo, **kwargs): super().__init__(cx, lo, **kwargs) b = self.lo + 5 self.ny = cx.m.le(b, 2) b += 2 self.nx = cx.m.le(b, 2) b += 2 self.sx = self.nx // 4 fbuf = [] while b < self.hi: cmd = cx.m.le(b, 2) b += 2 if cmd & 0x80: fbuf += [cx.m[b]] * (cmd - 0x7f) b += 1 else: while cmd >= 0: fbuf.append(cx.m[b]) b += 1 cmd -= 1 bm = bitmap.BitMap(self.nx, self.ny) for i, n in enumerate(fbuf): i *= 4 y = i // self.nx x = i % self.nx for b in (1, 2, 4, 8): if n & b: bm.set(x ^ 4, y) x += 1 y = data.Data(cx.m, self.lo + 5, self.hi) y.rendered = ".RLLBITMAP\n" + str(bm) y.compact = True
def example(): m = mem.Stackup( FILENAMES, nextto=__file__, ) cx = mc6800.mc6800() cx.m.map(m, 0x6800) nmi = m.bu16(m.hi - 4) print("NMI %x" % nmi) cx.m.map(m, 0x8000 | nmi, 0x10000, offset=nmi - 0x6800) for a, l in SYMBOLS.items(): cx.m.set_label(a, l) def rom(lo, hi): cx.m.add_range(lo, hi, txt="ROM") s = 0 for a in range(lo, hi): s += cx.m[a] s &= 0xff if s == 0: print("ROM %04x-%04x sum good (%02x)" % (lo, hi, s)) else: print("ROM %04x-%04x sum BAD (%02x)" % (lo, hi, s)) rom(0x6800, 0x7000) rom(0x7000, 0x7800) rom(0x7800, 0x8000) for i in (0x6fff, 0x77ff, 0x7ff7): c = data.Data(cx.m, i, i + 1, "csum") c.rendered = c.tag cx.vectors() def jmptbl(lo, hi, x=None): c = cx.m.add_range(lo, hi, txt="jmptbl (%04x-%04x)" % (lo, hi)) # c.rendered = c.tag n = 0 for a in range(lo, hi, 2): y = cx.codeptr(a) if x != None and len(x) > n: cx.m.set_label(y.dst, "CMD_" + x[n]) n += 1 jmptbl(0x7768, 0x77b6, '9876543210.-@ABCDEFGHIJKLMNOPQRSTUVWXYZ') jmptbl(0x7860, 0x787c) jmptbl(0x78a0, 0x78bc) jmptbl(0x78c0, 0x78dc) ####################################################################### def tblx(a): c = data.Data(cx.m, a, a + 16, "tblx") s = "" for i in range(10): v = cx.m[a + i] s += " %02x" % v s += " " for i in range(10, 16): v = cx.m[a + i] s += " %02x" % v c.rendered = "TBLX " + s c.compact = True for a in range(0x7000, 0x70a0, 16): tblx(a) for a in range(0x7100, 0x71a0, 16): tblx(a) ####################################################################### seven_segment.table(cx.m, 0x7800, 0x7810, drive=(128, 64, 32, 16, 8, 4, 2, 1, 0), inv=True, verbose=False) return NAME, (cx.m, )
def example(): m = mem.Stackup((FILENAME,), nextto=__file__) cx = mcs51.I8032() cx.m.map(m, 0) cx.disass(0xb) cx.vectors(which=("RESET", "TF0")) cx.disass(0x600) for a, b in SYMBOLS.items(): cx.m.set_label(a, b) for a, b in BIT_SYMBOLS.items(): cx.as_bit.set_label(a, b) for a, b in DATA_SYMBOLS.items(): cx.as_data.set_label(a, b) cx.m.set_line_comment(0xa31, "Mask Left/Right Buttons") cx.m.set_line_comment(0xa47, "Mask Left/Right Buttons") cx.m.set_line_comment(0xa67, "Mask Dials") for i in range(0, 0x18, 8): data.Txt(cx.m, 0x0a2 + i, 0x0a2 + i + 0x08, label=False) for i in range(0, 0x18, 8): data.Txt(cx.m, 0x78a + i, 0x78a + i + 0x08, label=False) ####################################################################### def cmd_func(a1, a2, n): cx.m.set_label(a1, "DO_CMD%d" % n) a = a2 while True: if cx.m[a] != 0xb4: break c = cx.m[a + 1] d = cx.m[a + 2] cx.m.set_label(a, "CMD%d_%02x" % (n, c)) a += 3 + d cmd_func(0xbf3, 0xbf7, 1) cmd_func(0x823, 0x827, 2) cmd_func(0x84f, 0x851, 3) ####################################################################### ####################################################################### for a in range(0xba, 0x100, 2): x = data.Const(cx.m, a, a + 2) x.typ = ".WORD" x.val = cx.m.lu16(a) x.fmt = "0x%04x" % x.val ####################################################################### x = data.Data(cx.m, 0x100, 0x600, "chargen") x.rendered = "*CHARGEN*" x.compact = True cs = chargen.SVG_Charset( fn="/tmp/" + NAME + "_charset.svg", char_w = 5, char_h = 7, imargin = 1, ) for n in range(0x100): ll = [0] * 7 for i in range(7): for j in range(5): ll[6-i] |= ((cx.m[0x100 + j * 0x100 + n] >> i) & 1) << (4-j) cs.set_char(n // 16, n % 16, ll) cs.render() ####################################################################### return NAME, (cx.m,)
def task(pj, cx): cx.register_labels(pj) cx.vectors(pj) def cbyte(pj, a): c = data.Const(pj, a, a + 1) c.val = pj.m.rd(a) c.typ = ".BYTE" c.fmt = "0x%02x" % c.val return c def cword(pj, a): c = data.Const(pj, a, a + 2) c.val = pj.m.bu16(a) c.typ = ".WORD" c.fmt = "0x%04x" % c.val return c class d_chain(data.Data): def __init__(self, pj, a): super(d_chain, self).__init__(pj, a, a + 4) self.num = '%c%c%c' % ( pj.m.rd(self.lo), pj.m.rd(self.lo + 1), pj.m.rd(self.lo + 2), ) def render(self, pj): return ".STRUCT chain { '%c%c%c', %d }" % ( pj.m.rd(self.lo), pj.m.rd(self.lo + 1), pj.m.rd(self.lo + 2), pj.m.rd(self.lo + 3), ) class d_asf(data.Data): def __init__(self, pj, a): super(d_asf, self).__init__(pj, a, a + 16) def render(self, pj): s = ".STRUCT asf {" t = " " for i in range(0, 16, 2): s += t + "%6d" % pj.m.bu16(self.lo + i) t = ", " s += "}" return s class d_q(data.Data): """ Numbers are sign + 31 bit binary q-complement fractions: [Sign][31 bit fraction] """ def __init__(self, pj, a, lbl=True): if pj.find(a, ".D4") != None: return super(d_q, self).__init__(pj, a, a + 4, ".D4") self.val = pj.m.bu32(a) self.dec = self.val if self.dec & 0x80000000: self.dec &= 0x7fffffff self.dec *= -1 self.dec *= 2**-31 if lbl: pj.set_label(self.lo, "Q_%04x_%g" % (self.lo, self.dec)) def render(self, pj): if self.dec != 0.0: b = 1.0 / self.dec else: b = 0. return ".D4 %12g = 1/%g" % (self.dec, b) ####################################################################### led_map = [1, 2, 4, 128, 64, 16, 32, 8, 0] seven_segment.table(pj, 0xecb4, 0xecd4, map=led_map, verbose=False) pj.set_label(0xecb4, "7SEG_TBL") LED_lbl = { 0xf94d: "_PL-99___LORAN-C", 0xf95d: "__Progr____PL-15", 0xf96d: "_Please___Choose", 0xf97d: "Lat-Lon___or_Gri", 0xf98d: "__L-L=4____Gri=7", 0xf99d: "Enter____Gri____", 0xf9ad: "Enter____Lat-Lon", 0xf9bd: "________________", 0xf9cd: "_Enter___Fn_no__", 0xf9dd: "_______A_Gri___0", 0xf9ed: "Search_A_Gri___0", 0xf9fd: "SAVE_in_____no__", 0xfa0d: "___no_______Fn__", 0xfa1d: "_________CAL____", 0xfa2d: "Enter______deg__", 0xfa3d: "8888888888888888", 0xfa4d: "Oscil___________", 0xfa5d: "__AREA____CHANGE", 0xfa6d: "__Pri=1____Alt=4", 0xfa7d: "_reset___spd_fil", 0xfa8d: "__speed___filter", 0xfa9d: "__slo_____15_set", 0xfaad: "regular___15_set", 0xfabd: "___fast___15_set", 0xfacd: "__slo=1____reg=2", 0xfadd: "_fast=3__A5_15=C", 0xfaed: "display_____no__", 0xfafd: "_Go_to______no__", 0xfb0d: "no_ASF___Entered", 0xfb1d: "__ASF____Entered", 0xfb2d: "CHANGE_____by__0", 0xfb3d: "Enter____ASF____", 0xfb4d: "Enter_______no__", 0xfb5d: "1_For0___2_For00", 0xfb6d: "Start_______no__", 0xfb7d: "__L-L=4____tds=7", 0xfb8d: "________________", 0xfb9d: "_fast____Average", 0xfbad: "regular__Average", 0xfbbd: "__Light_____on__", 0xfbcd: "__Light_____off_", 0xfbdd: "_dest_______no__", 0xfbed: "Select______no__", 0xfbfd: "__________Cntr__", 0xfc0d: "_____00__set_CL_", 0xfc1d: "_____00_____CL0C", 0xfc2d: "_____00__set_ttG", 0xfc3d: "_____00______ttG", 0xfc4d: "ASF______Entr___", 0xfc5d: "Arr_0____dist___", 0xfc6d: "Anchor______no__", 0xfc7d: "Anchor____dist__", 0xfc8d: "set_0____d55____", 0xfc9d: "Clr_cyc___Error_", 0xfcad: "__Plan______Fn__", 0xfcbd: "_CHANGE____Gri__", 0xfccd: "_Cold_____Start_", 0xfcdd: "reStart_________", 0xfced: "__YE5=1_____no=4", 0xfcfd: "reset____hot_t__", 0xfd0d: "reset____cold_t_", 0xfd1d: "__route_____no__", 0xfd2d: "__route_____no-_", 0xfd3d: "__Use=1__displ=4", 0xfd4d: "Pt___15___done=4", 0xfd5d: "__End=1___Cont=4", 0xfd6d: "speed____display", 0xfd7d: "_Crse=1___Grnd=4", 0xfd8d: "set_brg___corr=0", 0xfd9d: "_Seed____Lat-Lon", 0xfdad: "_Output__data_on", 0xfdbd: "_Output__dataoff", 0xfdcd: "_Auto=1____not=4", 0xfddd: "_Clear_____ASF__", 0xfded: "Input____OSC____", 0xfdfd: "___SELF_____TRAC", } for a in range(0xf94d, 0xfdfe, 16): c = seven_segment.table(pj, a, a + 16, map=led_map, verbose=False) t = LED_lbl.get(a) assert t != None if t == None: # Try to construct a string ourselves... t = "" for i in c: if i == None: t += "?" elif len(i) == 1: t += i elif i == "blank": t += "_" else: t += "?" pj.set_label(a, "MSG_" + t) ####################################################################### def post_arg_func(pj, ins): post_arg_funcs = { 0xb80c: "WB", 0xb821: "WB", 0xb836: "W", 0xb846: "WWW", 0xb86c: "WWW", 0xb892: "WWW", 0xb989: "WWW", 0xbabc: "WW", 0xbb60: "WWW", 0xbca1: "WWW", 0xbdeb: "WW", } for f in ins.flow_out: i = post_arg_funcs.get(f.to) if i == None: continue ins.flow_out = [] ins.add_flow(pj, "C", True, f.to) a = ins.hi for j in i: if j == "W": d = pj.m.bu16(a) data.Dataptr(pj, a, a + 2, d) a += 2 if d >= 0x8000: d_q(pj, d) elif j == "B": cbyte(pj, a) # data.Data(pj, a, a + 1) a += 1 else: assert False ins.add_flow(pj, ">", True, a) return cx.flow_check.append(post_arg_func) ####################################################################### def bogo_flow(pj, ins): for f in ins.flow_out: if f.to == None: pass elif f.to < 0x8000 or f.to > 0xffff: print("BOGO", ins) cx.flow_check.append(bogo_flow) ####################################################################### chains = [] x = pj.add(0x9d20, 0x9d68, "chain-tbl") pj.set_label(x.lo, "CHAINS") for a in range(x.lo, x.hi, 4): chains.append("GRI_" + d_chain(pj, a).num + "0") """ This is probably ASF data (Based partially on number of records = 204) """ x = pj.add(0x9d68, 0xaa28, "asf-tbl") for a in range(x.lo, x.hi, 16): d_asf(pj, a) # ON_KEY table x = pj.add(0xe072, 0xe0e2, "on-key-tbl") pj.set_label(x.lo, "ON_KEY_TBL") n = 0x80 for a in range(x.lo, x.hi, 2): x = cx.codeptr(pj, a) pj.set_label(x.dst, "ON_KEY_0x%02x" % n) n += 1 # CMD table x = pj.add(0x9b81, 0x9bff, "cmd-tbl") pj.set_label(x.lo, "CMDTBL") for a in range(x.lo, x.hi, 3): y = data.Txt(pj, a, a + 1, label=False) z = cx.codeptr(pj, a + 1) if y.txt == " ": pj.set_label(z.dst, "CMD_SP") else: pj.set_label(z.dst, "CMD_%s" % y.txt) # FN table x = pj.add(0xf885, 0xf94d, "fn-tbl") pj.set_label(x.lo, "FN_TBL") d = dict() n = 0 for a in range(x.lo, x.hi, 2): y = cx.codeptr(pj, a) if not y.dst in d: d[y.dst] = [] d[y.dst].append(n) n += 1 for i in d: e = d[i] if len(e) == 1: pj.set_label(i, "FN_%02d" % e[0]) elif len(e) > 10: pj.set_label(i, "FN_UNDEF") else: pj.set_label(i, "FN_%02d_%02d" % (e[0], e[-1])) def longitude(pj, a): """ This gives values closely matching table values """ x = d_q(pj, a, lbl=False) s = "" v = x.dec * 180. if v < 0: v *= -1 s += "W" v = 180. - v else: s += "E" deg = v.__trunc__() v -= deg s += "%4d" % deg v *= 60 mi = v.__trunc__() v -= mi s += " %2d'" % mi v *= 60 s += ' %2.3f"' % v x.lcmt = s return x def lattitude(pj, a): """ This calculation is not quite right. """ x = d_q(pj, a, lbl=False) s = "" v = x.dec * 90. v = 108 - v if v < 0: v *= -1 s += "S" v = 180. - v else: s += "N" deg = v.__trunc__() v -= deg s += "%4d" % deg v *= 60 mi = v.__trunc__() v -= mi s += " %2d'" % mi v *= 60 s += ' %2.3f"' % v x.lcmt = s return x # # Chain data, idx'ed by 0x9d20 # x = pj.add(0xaa29, 0xb131, "tbl") n = 0 for a in range(x.lo, x.hi, 100): x = pj.add(a, a + 100, "chain-tbl") pj.set_label(a, "CHAIN_" + chains[n]) x = cword(pj, a) x.lcmt = "GRI %d * 5" % (x.val / 5) #data.Data(pj, a, a + 100) x = pj.add(a + 0x02, a + 0x02 + 5 * 4, "alpha-tbl") x = pj.add(a + 0x16, a + 0x16 + 5 * 4, "beta-tbl") x = pj.add(a + 0x2a, a + 0x2a + 5 * 4, "gamma-tbl") for c in range(5): d_q(pj, a + 0x02 + c * 4, lbl=False) lat = lattitude(pj, a + 0x16 + c * 4) lon = longitude(pj, a + 0x2a + c * 4) x = pj.add(a + 0x3e, a + 0x3e + 4 * 4, "rho-tbl") x = pj.add(a + 0x4e, a + 0x4e + 4 * 4, "sigma-tbl") for c in range(4): x = d_q(pj, a + 0x3e + c * 4, lbl=False) x.lcmt = "%.3f us / 2^23" % (x.dec * 2**23) d_q(pj, a + 0x4e + c * 4, lbl=False) x = pj.add(a + 0x5e, a + 0x5e + 5, "epsilon-tbl") for c in range(5): cbyte(pj, a + 0x5e + c) x = cbyte(pj, a + 99) x.lcmt = "# slaves" n += 1 for a in range(0xc2fe, 0xc38e, 4): d_q(pj, a) # idx into tbl at b156 # Chain data (18 pieces) # x = pj.add(0xb132, 0xb155, "tbl") n = 0 for a in range(x.lo, x.hi, 2): y = cword(pj, a) y.lcmt = chains[n] pj.set_label(0xb156 + y.val, "CHAIN_I_" + chains[n]) n += 1 x = pj.add(0xb156, 0xb43e, "tbl") for a in range(x.lo, x.hi, 4): #data.Data(pj, a, a + 4) d_q(pj, a, lbl=False) for a in range(0xc3a6, 0xc41e, 4): d_q(pj, a) for a in range(0x906f, 0x9087, 2): c = cword(pj, a) c.fmt = "%d" % c.val x = pj.add(0x9d00, 0x9d20, "tbl") x.lcmt += "accessed via 0x9cc2 pointer" for a in range(x.lo, x.hi, 2): c = cword(pj, a) pj.todo(0x9102, cx.disass) pj.todo(0x95da, cx.disass) pj.todo(0x9b29, cx.disass) pj.todo(0x9a96, cx.disass) pj.todo(0x9b44, cx.disass) pj.todo(0x9b57, cx.disass) pj.todo(0xdda1, cx.disass) pj.todo(0xdde0, cx.disass) pj.todo(0xde00, cx.disass) pj.todo(0xde20, cx.disass) pj.todo(0xf719, cx.disass) for a in range(0x9789, 0x97a5, 4): d_q(pj, a) for i in range(0xf220, 0xf226, 2): data.Dataptr(pj, i, i + 2, pj.m.bu16(i)) cword(pj, i + 6) #for i in range(0x89d8, 0x8a20, 2): # data.Dataptr(pj, i, i + 2, pj.m.bu16(i)) for i in range(0xe363, 0xe369, 2): x = cx.codeptr(pj, i) x = pj.add(0xb963, 0xb975, "tbl") for i in range(x.lo, x.hi): cbyte(pj, i) data.Data(pj, 0xca73, 0xca7c) data.Data(pj, 0xec7c, 0xec81) data.Data(pj, 0xec81, 0xec85) data.Data(pj, 0xec85, 0xec8b) data.Data(pj, 0xec8b, 0xec91) d_q(pj, 0xcb70) d_q(pj, 0xd4f5) d_q(pj, 0xd4f9) d_q(pj, 0xd4fd) d_q(pj, 0xd501) while pj.run(): pass pj.set_label(0x6489, "CHAIN_PTR") pj.set_label(0xb800, "MEMCPY(X, Y, B)") pj.set_label(0xb80c, "SHR_Q") pj.set_label(0xb821, "SHL_Q") pj.set_label(0xb836, "COM_Q") pj.set_label(0xb846, "ADD_Q") pj.set_label(0xb86c, "SUB_Q") pj.set_label(0xb892, "MUL_Q") pj.set_label(0xec91, "7SEG_XLAT(0x66a9)") pj.set_label(0xecaa, "7SEG_DIG(B)") pj.set_label(0xecd4, "DISPLAY(Y)") pj.set_label(0xf1a9, "DISPLAY_YES_NO(Y)") pj.set_label(0xf1b7, "IS_YES()") pj.set_label(0xf878, "PAUSE()") pj.set_label(0xfe5c, "Analog_Capture") pj.set_label(0xfe6e, "Capture_One_Analog") pj.set_label(0xf9, "ON_KEY")
def example(): m = [] for fn, csum in FILES: i = mem.Stackup(files=(fn,), nextto=__file__,) assert sum(i.bytearray(i.lo, i.hi)) & 0xffff == csum m.append(i) charrom(m[3], m[4]) cpu = z80.z80() cpu.m.map(m[0], 0x0000) cpu.m.map(m[1], 0x4000) cpu.m.map(m[2], 0xa000) cpu.flow_check.append(fc) for a, b in SYMBOLS.items(): cpu.m.set_label(a, b) for a, b in IO_SYMBOLS.items(): cpu.as_io.set_label(a, b) for a in range(0x3d, 0x60, 2): x = cpu.codeptr(a) cpu.m.set_line_comment(x.dst, "From tbl@0x003d") for a in range(0x0700, 0x0728, 2): x = cpu.codeptr(a) cpu.m.set_line_comment(x.dst, "From tbl@0x0700") for a in range(0x0800, 0x0810, 2): x = cpu.codeptr(a) cpu.m.set_line_comment(x.dst, "From tbl@0x0800") for a in range(0x0900, 0x0908, 2): x = cpu.codeptr(a) cpu.m.set_line_comment(x.dst, "From tbl@0x0900") for a in range(0xe00, 0xfa0, 2): x = cpu.codeptr(a) cpu.m.set_line_comment(x.dst, "From tbl@0x0e00") for a in range(0x0810, 0x0900, 2): x = cpu.dataptr(a) y = data.Txt(cpu.m, x.dst, term=(0x81,), label=False) x.lcmt = y.txt for a in range(0x0a45, 0x0be3, 2): x = cpu.dataptr(a) y = data.Txt(cpu.m, x.dst, term=(0x80,), label=False) x.lcmt = y.txt for a in range(0x3bb1, 0x3bd1, 2): x = cpu.dataptr(a) cpu.m.set_label(x.dst, "KBD_%x" % a) for i in range(29): try: y = data.Pstruct(cpu.m, x.dst + i * 5, "B" * 5, fmt=", ".join(["0x%02x"] * 5)) y.compact = True except: pass hack(cpu, 0x264b) a = 0xa51a b = 0xa539 while cpu.m[a] != 0xff: x = data.Pstruct(cpu.m, a, "BBB", fmt=", ".join(["0x%02x"] * 3)) a = x.hi y = data.Txt(cpu.m, b, b + 0x1e, label=False) b = y.hi data.Const(cpu.m, a, a + 1) x = data.Pstruct(cpu.m, 0x54a7, "B" * 12, fmt=", ".join(["0x%02x"] * 12)) x = data.Pstruct(cpu.m, 0xaddd, "B" * 12, fmt=", ".join(["0x%02x"] * 12)) x = data.Pstruct(cpu.m, 0xa392, "B" * 12, fmt=", ".join(["0x%02x"] * 12)) x = data.Pstruct(cpu.m, 0xa39e, "B" * 12, fmt=", ".join(["0x%02x"] * 12)) x = data.Pstruct(cpu.m, 0xacb0, "B" * 10, fmt=", ".join(["0x%02x"] * 10)) cpu.m.set_label(0xa2c4, "TestNames") for a in range(0xa2c4, 0xa384, 0x10): x = data.Txt(cpu.m, a, a + 0x10, label=False) for a in range(0xade9, 0xae21, 7): x = data.Txt(cpu.m, a, a + 0x7, label=True) menu_desc(cpu, 0x7103) menu_desc(cpu, 0x742b) menu_desc(cpu, 0x7689) for a, l in ( (0xa384, 0x7), (0xa38b, 0x7), (0xae21, 0xa), (0xae2c, 0xc), (0xae38, 0x7), (0xae40, 0x9), (0xae4a, 0xa), (0xae54, 0xb), (0xae5f, 0xf), (0xae6f, 0x7), (0xae76, 0xb), (0xae81, 0x7), ): x = data.Txt(cpu.m, a, a + l) cpu.vectors( ( "RESET", "RST08", "RST10", "RST18", "RST28", "IRQ", "NMI", ) ) # switch_tbl(cpu.m, 0x0dc0, cpu) switch_tbl(cpu.m, 0x32f8, cpu) switch_tbl(cpu.m, 0x334a, cpu) switch_tbl(cpu.m, 0x33c1, cpu) switch_tbl(cpu.m, 0x5328, cpu) switch_tbl(cpu.m, 0x5383, cpu) switch_tbl(cpu.m, 0x53b9, cpu) switch_tbl(cpu.m, 0x53a2, cpu) switch_tbl(cpu.m, 0x53af, cpu) for a in range(0x789b, 0x78bb, 2): y = cpu.dataptr(a) data.Txt(cpu.m, y.dst, term=(0x80,)) for a in ( 0x7926, 0x7cf7, 0x7d03, ): data.Txt(cpu.m, a, term=(0x80,)) if False: # See 0x43cc for a in range(0x3d, 0x58, 2): y = cpu.codeptr(a) cpu.m.set_line_comment(y.dst, "MANUAL from tbl@0x3c") if False: # See 0x493e for a in range(0x800, 0x900, 2): y = cpu.codeptr(a) cpu.m.set_line_comment(y.dst, "MANUAL from tbl@0x800") data.Pstruct(cpu.m, 0x89, "2B", fmt=", ".join(["0x%02x"] * 2)) for a in range(0x524, 0x56c, 4): data.Pstruct(cpu.m, a, "4B", fmt=", ".join(["0x%02x"] * 4)) for a, b in ( (0x008b, "via IY"), (0x04f6, "via IY"), (0x0506, "via IY"), (0x0518, "via IY"), (0x0fc7, "via xfa0"), (0x0fe5, "via xfa0"), (0x1006, "via xfa0"), (0x1397, None), (0x5c03, "via 0xc296"), (0x5df9, "via 0xc296"), (0x5e25, "via 0xc296"), (0x5ecb, "via 0xc296"), (0x5f7f, "via 0xc296"), (0x5fbc, "via 0xc296"), (0xac5a, None), (0xb800, None), (0xb874, "via 0xc1da ptr"), (0xb8db, "via 0xc1d8 ptr"), (0xb8e2, "via 0xc1d8 ptr"), (0xb8e9, "via 0xc1d8 ptr"), (0xb8f0, "via 0xc1d8 ptr"), (0xb8f7, "via 0xc1d8 ptr"), (0xb844, None), (0x3916, "via 0xcf58 ptr"), (0x3936, "via 0xcf58 ptr"), (0x3948, "via 0xcf58 ptr"), (0x39d8, "via 0xcf58 ptr"), ): cpu.disass(a) if not b: b = "MANUAL" cpu.m.set_line_comment(a, b) y = data.Data(cpu.m, 0x4707, 0x4707 + 0x15e) if False: discover.Discover(cpu) return NAME, (cpu.m,)
def misc_stuff(cx): for a in range(0xc2fe, 0xc38e, 4): d_q(cx.m, a) # idx into tbl at b156 # Chain data (18 pieces) # x = cx.m.add_range(0xb132, 0xb155, txt="tbl") n = 0 for a in range(x.lo, x.hi, 2): y = cword(cx.m, a) y.lcmt = CHAINS[n] cx.m.set_label(0xb156 + y.val, "CHAIN_I_" + CHAINS[n]) n += 1 x = cx.m.add_range(0xb156, 0xb43e, txt="tbl") for a in range(x.lo, x.hi, 4): #data.Data(cx.m, a, a + 4) d_q(cx.m, a, lbl=False) for a in range(0xc3a6, 0xc41e, 4): d_q(cx.m, a) for a in range(0x906f, 0x9087, 2): c = cword(cx.m, a) c.fmt = "%d" % c.val x = cx.m.add_range(0x9d00, 0x9d20, txt="tbl") cx.m.set_line_comment(x.lo, "accessed via 0x9cc2 pointer") for a in range(x.lo, x.hi, 2): c = cword(cx.m, a) cx.disass(0x9102) cx.disass(0x95da) cx.disass(0x9b29) cx.disass(0x9a96) cx.disass(0x9b44) cx.disass(0x9b57) cx.disass(0xdda1) cx.disass(0xdde0) cx.disass(0xde00) cx.disass(0xde20) cx.disass(0xf719) for a in range(0x9789, 0x97a5, 4): d_q(cx.m, a) for i in range(0xf220, 0xf226, 2): data.Dataptr(cx.m, i, i + 2, cx.m.bu16(i)) cword(cx.m, i + 6) #for i in range(0x89d8, 0x8a20, 2): # data.Dataptr(cx.m, i, i + 2, cx.m.bu16(i)) for i in range(0xe363, 0xe369, 2): x = cx.codeptr(i) x = cx.m.add_range(0xb963, 0xb975, txt="tbl") for i in range(x.lo, x.hi): cbyte(cx.m, i) data.Data(cx.m, 0xca73, 0xca7c) data.Data(cx.m, 0xec7c, 0xec81) data.Data(cx.m, 0xec81, 0xec85) data.Data(cx.m, 0xec85, 0xec8b) data.Data(cx.m, 0xec8b, 0xec91) d_q(cx.m, 0xcb70) d_q(cx.m, 0xd4f5) d_q(cx.m, 0xd4f9) d_q(cx.m, 0xd4fd) d_q(cx.m, 0xd501)
def task(pj, cpu): # Where ? # y = data.Const(pj, 0xfffe, 0x10000) # pj.set_label(y.lo, "eprom_lo_chksum") y = data.Const(pj, 0x19854, 0x19856) pj.set_label(y.lo, "eprom_hi_chksum") ############################################################### ############################################################### # Functions taking arguments after call instruction post_arg = { 0x1bc8: ("BCD_CMP", "brel", "D01"), 0x1bcc: ("BCD_CMP", "babs", "D01"), 0x1bd0: ("BCD_CMP", "bA6rel", "D01"), 0x1bdc: ("BCD_CMP", "D01", "babs"), 0x1be0: ("BCD_CMP", "D01", "bA6rel"), 0x1c52: ("BCD_ADD", "brel", "D01"), 0x1c56: ("BCD_ADD", "babs", "D01"), 0x1c5a: ("BCD_ADD", "bA6rel", "D01"), 0x1c5e: ("BCD_ADD", "stk", "D01"), 0x1c76: ("BCD_SUB", "brel", "D01"), 0x1c7a: ("BCD_SUB", "babs", "D01"), 0x1c7e: ("BCD_SUB", "bA6rel", "D01"), 0x1c88: ("BCD_SUB", "brel", "D01"), 0x1c8c: ("BCD_SUB", "babs", "D01"), 0x1c90: ("BCD_SUB", "bA6rel", "D01"), 0x1ccc: ("", "dabs", "FPXXX"), 0x2218: ("BCD_LD_D01", "bcd"), 0x223c: ("BCD_LD_D23", "bcd"), 0x238e: ("", "drel", "FPXXX"), 0x239a: ("", "dA6rel", "FPXXX"), 0x23f6: ("", "drel", "FPXXX"), 0x2402: ("", "D0+D1", "dA6rel"), 0x24ac: ("", "drel", "FPXXX"), 0x24b8: ("", "dA6rel", "FPXXX"), 0x24c4: ("", "drel", "FPXXX"), 0x25b0: ("", "drel", "FPXXX"), 0x25c8: ("", "drel", "FPXXX"), 0x25fa: ("", "dA6rel", "FPXXX"), 0x27ee: ("", "lrel", "FPXXX"), 0x2862: ("", "lrel", "LFXXX"), 0x28c2: ("", "lrel", "LFXXX"), 0x28ce: ("", "fabs", "LFXXX"), 0x297c: ("", "fA6rel", "LFXXX"), 0x2982: ("", "fabs", "LFXXX"), 0x2988: ("", "frel", "FFXXX"), 0x29ba: ("", "fA6rel", "LFXXX"), 0x29c6: ("", "frel", "FFXXX"), 0x29ea: ("", "fA6rel", "LFXXX"), 0x29f6: ("", "frel", "FFXXX"), 0x2a02: ("", "fA6rel", "LFXXX"), 0x2a0e: ("", "frel", "FFXXX"), 0x2a34: ("", "frel", "FFXXX"), 0x2a6e: ("", "frel", "FFXXX"), 0x2b08: ("", "fA6rel", "LFXXX"), 0x2b14: ("", "frel", "FFXXX"), 0x2b2c: ("", "frel", "FFXXX"), } for i in post_arg: j = post_arg[i] if len(j) > 0 and j[0] != "": pj.set_label(i, j[0]) def flow_post_arg(pj, ins): z = post_arg.get(ins.dstadr) if z == None: return ins.flow_out.pop(-1) if len(z) <= 1: a = data.Pstruct(pj, ins.hi, ">h", "%d", ".INFIX").hi ins.add_flow(pj, ">", True, a) return l = [] for i in z[1:]: if i[1:] == "A6rel": r = pj.m.bs16(ins.hi) ins.hi += 2 if r < 0: l.append("(A6-0x%x)" % -r) else: l.append("(A6+0x%x)" % r) elif i[1:] == "abs": r = pj.m.bu16(ins.hi) if r & 0x8000: r |= 0xffff0000 ins.hi += 2 l.append("0x%08x" % r) elif i == "drel": r = ins.hi + pj.m.bs16(ins.hi) ins.hi += 2 ins.lcmt += " @0x%x\n" % r y = data_double(pj, r) l.append("%g" % y.data[0]) elif i == "brel": r = ins.hi + pj.m.bs16(ins.hi) ins.hi += 2 ins.lcmt += " @0x%x\n" % r y = data_bcd(pj, r); l.append("%x" % y.data[0]) elif i == "lrel": r = ins.hi + pj.m.bs16(ins.hi) ins.hi += 2 ins.lcmt += " @0x%x\n" % r y = data.Pstruct(pj, r, ">L", "%d", ".LONG") l.append("%d" % y.data[0]) elif i == "frel": r = ins.hi + pj.m.bs16(ins.hi) ins.hi += 2 ins.lcmt += " @0x%x\n" % r y = data_float(pj, r) l.append("%g" % y.val) elif i == "bcd": r = pj.m.bu16(ins.hi) y = data.Pstruct(pj, ins.hi, ">H", "%x", ".BCD") l.append("%04x" % r) ins.hi += 2 else: l.append(i) ins.oper.append(assy.Arg_verbatim(pj, "(" + ",".join(l) + ")")) ins.add_flow(pj, True, True, ins.hi) cpu.flow_check.append(flow_post_arg) ############################################################### switches = { 0x13624: { 0: "ALL", 1: "ONEOS", 2: "ONSWP", 3: "TRMATH", }, } def flow_switch(pj, ins): if ins.dstadr != 0x2f38: return ins.flow_out.pop(0) ins.add_flow(pj, ">", "?", ins.hi) pj.set_label(ins.hi, "break_%04x" % ins.lo) y = data.Const(pj, ins.lo - 2, ins.lo) ncase = pj.m.bu16(ins.lo - 2) y.typ = ".NCASE" y.fmt = "%d" % ncase cs = switches.get(ins.lo) if cs == None: cs = {} a = ins.lo - 2 for i in range(ncase): a -= 2 ct = cs.get(i) if ct == None: ct = "_%d" % i w = data.Const(pj, a, a + 2) z = pj.m.bs16(a) w.typ = ".CASE" w.fmt = "0x%x, %d" % (i,z) w.fmt += ", 0x%04x" % (ins.hi + z) ins.add_flow(pj, ">", "0x%x" % i, ins.hi + z) if z < 0: pj.set_label(ins.hi + z, ".case_%04x_%s" % (ins.lo, ct)) cpu.flow_check.append(flow_switch) pj.todo(0x2f38, cpu.disass) ############################################################### keyboard = ( # Row, Column, Text ( 0, 0, "HZ_UV_USEC"), ( 0, 3, "MHZ_DBM_SEC"), ( 0, 5, "BACK_SPACE"), ( 0, 6, "KHZ_MV_MSEC"), ( 1, 0, "SAVE"), ( 1, 1, "RECALL"), ( 1, 2, "HOLD"), ( 1, 4, "0_1_5_GHZ"), ( 1, 6, "POINT"), ( 1, 7, "GHZ_DBM_DB"), ( 2, 0, "DIG_0"), ( 2, 1, "DIG_1"), ( 2, 2, "DIG_2"), ( 2, 3, "DIG_3"), ( 2, 4, "DIG_4"), ( 2, 5, "DIG_5"), ( 2, 6, "DIG_6"), ( 2, 7, "DIG_7"), ( 3, 0, "DIG_8"), ( 3, 1, "DIG_9"), ( 3, 4, "INPUT_1"), ( 3, 5, "FREQ_COUNT"), ( 3, 6, "INPUT_1"), ( 4, 1, "AUTO_RES_BW"), ( 4, 2, "AUTO_VIDEO_BW"), ( 4, 3, "AUTO_SWEEP_TIME"), ( 4, 4, "AUTO_ATTEN"), ( 4, 5, "AUTO_CF_STEP"), ( 4, 6, "RES_BW"), ( 4, 7, "VIDEO_BW"), ( 5, 0, "SWEEP_TIME"), ( 5, 1, "ATTEN"), ( 5, 2, "CF_STEP"), ( 5, 3, "PEAK_SEARCH"), ( 5, 4, "MARKER_OFF"), ( 5, 5, "MARKER_NORMAL"), ( 5, 6, "MARKER_CF"), ( 5, 7, "MARKER_DELTA"), ( 6, 0, "ZOOM"), ( 6, 1, "MKR_DELTA_STP_SIZE"), ( 6, 2, "MKR_REF_LVL"), ( 6, 3, "SIGNAL_TRACK"), ( 6, 4, "DOWN"), ( 6, 5, "UP"), ( 6, 6, "CENTER_FREQ"), ( 6, 7, "FREQ_SPAN"), ( 7, 0, "START_FREQ"), ( 7, 1, "STOP_FREQ"), ( 7, 2, "REF_LEVEL"), ( 8, 0, "NORMAL"), ( 8, 1, "CLEAR_A"), ( 8, 2, "MAX_A"), ( 8, 3, "OFF_A_B"), ( 8, 4, "VIEW_A"), ( 8, 5, "BLANK_A"), ( 8, 6, "A_B"), ( 8, 7, "CLEAR_B"), ( 9, 0, "MAX_B"), ( 9, 1, "A_EX_B"), ( 9, 2, "VIEW_B"), ( 9, 3, "BLANK_B"), ( 9, 4, "B-DL-B"), ( 9, 5, "LINE_OFF"), ( 9, 6, "LINE_ENTER"), ( 9, 7, "THRSH_OFF"), ( 10, 0, "THRSH_ENTER"), ( 10, 1, "ENTER_DB"), ( 10, 2, "LIN"), ( 10, 3, "SHIFT"), ( 10, 4, "CONT"), ( 10, 5, "SINGLE"), ( 10, 6, "TRIG_FREE_RUN"), ( 10, 7, "TRIG_LINE"), ( 11, 0, "TRIG_EXT"), ( 11, 1, "TRIG_VIDEO"), ( 11, 2, "LOWER_LEFT"), ( 11, 4, "LOWER_RIGHT"), ) keynos = {} for r,c,t in keyboard: n = 0x20 + r * 8 + c keynos[n] = t ############################################################### class params(data.Data): def __init__(self, pj, nm, i, j): self.nm = nm self.b = 0x195c4 self.i = i self.j = j self.fi = pj.m.rd(self.b + i) self.args = [] for a in range(j): self.args.append(pj.m.rd(self.b + i + 1 + a)) super(params, self).__init__(pj, self.b + i, self.b + i + 1 + j) self.fp = 0x196b6 + self.fi * 4 self.fa = pj.m.bu32(self.fp) pj.todo(self.fa, cpu.disass) data.Codeptr(pj, self.fp, self.fp + 4, self.fa) pj.set_label(self.fa, "F_" + nm + "(" + self.summ() + ")") def render(self, pj): t = ".PARAM\t" t += "func=%d" % self.fi t += " call=%s" % self.nm t += "(" + self.summ() + ")" return t def summ(self): t = [] for i in self.args: if i == 0x03: t.append("STR") elif i == 0x16: t.append("int") elif i == 0x18: t.append("INT") elif i == 0x19: t.append("REAL") else: t.append("0x%02x" % i) return ",".join(t) def funcidx(self): return self.fi class mnem(data.Data): def __init__(self, pj, hi): lo = hi lo -= 2 self.c = pj.m.bu16(lo) lo -= 2 self.b = pj.m.bu16(lo) lo -= 2 self.a = pj.m.bu16(lo) self.len = self.c & 0xfff self.type = self.c >> 12 lo -= (self.len + 1) & 0xffe super(mnem, self).__init__(pj, lo, hi) self.compact = True a,b,c = data.stringify(pj, self.lo, self.len) self.string = b self.hash = 0 for i in bytearray(self.string, 'ascii'): self.hash += i self.hash %= 13 self.pp = None self.args = None if self.type == 3: self.pp = params(pj, self.string, self.b, self.a >> 8) if self.type == 1: if self.b not in keynos: keynos[self.b] = "CMD_" + self.string def render(self, pj): t = ".MNEM\t" t += "0x%04x" % self.a t += ", 0x%04x" % self.b t += ", 0x%x" % self.type t += ", len=0x%03x" % self.len t += ", hash=%2d" % self.hash t += ", '" + self.string + "'" return t if True: pj.set_label(0x18c3a, "MNETABLE") a = 0x193a0 while a > 0x18c3a: y = mnem(pj, a) x = pj.m.bu16(y.lo - 2) a = y.lo ############################################################### class oldcmd(data.Data): def __init__(self, pj, lo, n): super(oldcmd, self).__init__(pj, lo, lo + 2) x,self.name,y = data.stringify(pj, self.lo, 2) self.key = pj.m.rd(0x194b2 + n) self.imm = (pj.m.rd(0x1951e + (n >> 3)) >> (n & 7)) & 1 if not self.imm: self.svf1 = pj.m.bu16(0x1952c + self.key * 4) self.svf2 = pj.m.bu16(0x1952c + self.key * 4 + 2) if not self.svf2 in keynos: keynos[self.svf2] = "CMD_" + self.name def render(self, pj): t = ".OLDCMD\t" t += "'" + self.name + "'" t += " imm=%x" % self.imm t += " key=%02x" % self.key if self.imm and self.key in keynos: t += " ('" + keynos[self.key] + "')" if not self.imm: t += " svf=0x%04x,0x%04x" % (self.svf1, self.svf2) t += " xxx=%02x" % (self.svf1 & 0x1e) return t if True: pj.set_label(0x193da, "OLDCMDS") n = 0 for a in range(0x193da, 0x194b2, 2): y = oldcmd(pj, a, n) n += 1 # print("OLDCMDS %d" % ((0x194b2-0x193da)/2)) pj.set_label(0x194b2, "KEYTAB") for a in range(0x194b2, 0x1951e, 8): y = data.Const(pj, a, min(a + 8, 0x1951e), fmt="0x%02x") # print("KEYTAB %d" % ((0x1951e-0x194b2)/1)) pj.set_label(0x1951e, "IMEDBITS") for a in range(0x1951e, 0x1952c, 8): y = data.Const(pj, a, min(a + 8, 0x1952c), fmt="0x%02x") # print("IMEDBITS %d" % ((0x1952c-0x1951e)/1)) pj.set_label(0x1952c, "SFLGVAL") for a in range(0x1952c, 0x195c4, 16): y = data.Const(pj, a, min(a + 16, 0x195c4), "0x%08x", pj.m.bu32, 4) # print("SFLGVAL %d" % ((0x195c4-0x1952c)/2)) ############################################################### switches[0x09ae8] = {} switches[0x09d78] = {} switches[0x0a5de] = {} switches[0x0af5c] = {} switches[0x0b5ec] = {} switches[0x0bb4e] = {} switches[0x0bd5a] = {} switches[0x0bd6e] = { 0: "KEYS_00_1f", 1: "KEYS_20_3f", 2: "KEYS_40_5f", 3: "KEYS_60_7f", 4: "KEYS_80_9f", 5: "KEYS_a0_bf", } for n in keynos: t = keynos[n] # print("KEY_%02x" % n, t) sk = "KS%c" % n ksk = hp856x_cmds.cmds.get(sk) if ksk != None and type(ksk) != str: ksk = ksk[1] if ksk == None: ksk = "==" + t if n < 0x20: switches[0x9ae8][n] = "KEY_%02x_" % n + t if n >= 0x20 and n < 0x30: switches[0x9d78][n - 0x20] = "KEY_%02x_" % n + t if n >= 0x40 and n < 0x60: switches[0xa5de][n - 0x41] = "KEY_%02x_" % n + t switches[0xaf5c][n - 0x41] = "KEY_S%02x_KS%c_" % (n, n) + ksk if n >= 0x60 and n < 0x80: switches[0xb5ec][n - 0x61] = "KEY_%02x_" % n + t switches[0xbb4e][n - 0x60] = "KEY_S%02x_KS%c_" % (n, n) + ksk if n >= 0xa0 and n <= 0xbf: switches[0xbd5a][n - 0xa0] = "KEY_%02x_" % n + t if True: for b,e in ( ( 0x0e750, 0x0e778), ( 0x15ca4, 0x15cb4), ): for a in range(b, e, 8): data_double(pj, a) ############################################################### if True: cpu.vectors(pj, hi = 0xc0) ####################################################### for b,e in ( (0x06936, 0x0693a), (0x06a2c, 0x06b84), (0x070ca, 0x070d6), (0x081ae, 0x081ba), (0x1357a, 0x1358a), (0x13e58, 0x13e70), (0x14960, 0x1497c), (0x14c94, 0x14cb4), (0x14f98, 0x14fa8), (0x15094, 0x150a4), (0x15140, 0x15150), (0x15e0e, 0x15e32), (0x172b8, 0x172c4), (0x17dbe, 0x17dce), ): for a in range(b, e, 4): x = pj.m.bu32(a) data.Dataptr(pj, a, a + 4, x) data.Txt(pj, x, pfx=1, align=2) data.Txt(pj, 0x15dfc, pfx=1, align=2) ####################################################### for a in ( 0x0e2fa, 0x0e308, 0x0e318, 0x12986, 0x12988, 0x1298c, 0x12990, 0x1694e, 0x16954, ): y = data.Txt(pj, a, pfx=1, align=2) ####################################################### data.Dataptr(pj, 0xe39a, 0xe39a + 4, pj.m.bu32(0xe39a)) data.Const(pj, 0x2140, 0x2148, "%d", pj.m.bu64, 8) data.Const(pj, 0x2148, 0x214c, "%d", pj.m.bu32, 4) for a in ( 0x0645e, 0x06476, 0x0647e, 0x0648a, 0x06492, 0x0649a, 0x064a6, 0x064be, 0x0e2c4, 0x0e2d4, 0x0e2cc, 0x0e32a, 0x0e332, 0x0e37c, 0x0e384, 0x128ca, 0x15da0, ): y = data_bcd(pj, a) pj.set_label(a, "BCD_%x" % y.data[0]) ####################################################### pj.set_label(0x0693c, "MSG_ADR_X_Y") for a in range(0x693c, 0x6a2c, 6): data.Const(pj, a, a+6, "0x%04x", pj.m.bu16, 2) ####################################################### pj.set_label(0x6b84, "G_CTRL") pj.set_label(0x6ba8, "G_CENTER") pj.set_label(0x6bcc, "G_MARKER") pj.set_label(0x6be2, "G_DSP_LINE") pj.set_label(0x6bf8, "G_GRATICULE") pj.set_label(0x6c4c, "G_HP_LOGO") pj.set_label(0x6c5e, "G_ACT_FUNC") a = 0x6b84 dsp = hp85662a.hp85662a() while a < 0x6c98: x = pj.m.bs16(a) if x < 0: y = data.Data(pj, a, a + 2) y.fmt = ".DSPLOC\t0x%04x" % -x y.lcmt = "adr=%d" % -x dsp = hp85662a.hp85662a() else: y = dsp.disass(pj, a) a = y.hi ####################################################### pj.set_label(0x0e3be, "UNITS") for a in range(0x0e3be, 0x0e3d4, 2): data.Txt(pj, a, a + 2, label=False) ####################################################### # 0ee98 00 01 93 be # 0eeaa 00 01 93 da | | # 0ee8e 00 01 da ee | | ####################################################### # Orphans ? if False: pj.todo(0x01b88, cpu.disass) pj.todo(0x01b8e, cpu.disass) pj.todo(0x01b94, cpu.disass) pj.todo(0x01b9a, cpu.disass) pj.todo(0x01b9e, cpu.disass) pj.todo(0x01ba2, cpu.disass) pj.todo(0x01ba8, cpu.disass) pj.todo(0x01c76, cpu.disass) pj.todo(0x01c82, cpu.disass) pj.todo(0x01c90, cpu.disass) pj.todo(0x01cd2, cpu.disass) pj.todo(0x01d14, cpu.disass) pj.todo(0x01578, cpu.disass) pj.todo(0x01594, cpu.disass) pj.todo(0x0171a, cpu.disass) pj.todo(0x01906, cpu.disass) pj.todo(0x02dee, cpu.disass) pj.todo(0x02df4, cpu.disass) pj.todo(0x03412, cpu.disass) pj.todo(0x11e74, cpu.disass) # from 0x2272 pj.todo(0x2282, cpu.disass) # filled in 0xffffabd2 pj.todo(0x0ed98, cpu.disass) pj.todo(0x0df5e, cpu.disass) # Arg to 0x802 pj.todo(0x3292, cpu.disass) # 0x3284 ####################################################### # pat 4,244,024 pg 262 lin 3700 pj.set_label(0x4fac, "SCANTAB") for a in range(0x4fac, 0x4fec, 2): y = data.Const(pj, a, a+2, "0x%04x", pj.m.bu16, 2) ####################################################### y = data.Const(pj, 0x193a2, 0x193be, "%d", pj.m.bu16, 2) pj.set_label(y.lo, "HASHPTR2") y = data.Const(pj, 0x193be, 0x193da, "%d", pj.m.bu16, 2) pj.set_label(y.lo, "HASHPTR") ####################################################### pj.set_label(0x19826, "PFXSCALE") for a in range(0x19826, 0x19853, 1): y = data.Const(pj, a, a + 1, fmt="0x%02x") # print("PFXSCALE %d" % ((0x19853-0x19826)/1)) else: y = cpu.disass(pj, 0xda1e) for i in y.__dict__: print("\t", i, y.__dict__[i]) while pj.run(): pass for i in pj.t: if i.tag != "m68000": continue if i.dstadr in (0x940c, 0xed54): y = pj.t.find_hi(i.lo) if len(y) != 1: continue y = y[0] if pj.m.rd(y.lo) == 0x70: k = pj.m.rd(y.lo + 1) elif pj.m.bu16(y.lo) == 0x103c: k = pj.m.bu16(y.lo + 2) else: continue if not k in keynos: continue y.oper[0].txt = "#KEY_" + keynos[k] if i.dstadr in (0xe4e8,): y = pj.t.find_hi(i.lo) if len(y) != 1: continue y = y[0] if y.mne != "PEA.L": continue z = data.Txt(pj, y.dstadr, pfx=1, align=2) y.lcmt = "'" + z.txt + "'" if i.dstadr in (0xe718, 0x3456, 0x6ce0): y = pj.t.find_hi(i.lo) if len(y) != 1: continue y = y[0] if pj.m.bu16(y.lo) != 0x203c: continue a = pj.m.bu32(y.lo + 2) z = data.Txt(pj, a, pfx=1, align=2) y.lcmt = "'" + z.txt + "'" if i.dstadr == 0xe718: w = pj.t.find_hi(y.lo) if len(w) != 1: continue w = w[0] if w.mne != "PEA.L": continue z = data.Txt(pj, w.dstadr, pfx=1, align=2) w.lcmt = "'" + z.txt + "'" y = data.Const(pj, 0x693a, 0x693c, "%d", pj.m.bu16, 2) pj.set_label(0x009b8, "RESET") pj.set_label(0x00c2e, "SELFTEST") pj.set_label(0x00d7a, "CPUTEST_FAIL") pj.set_label(0x00e9a, "epromsize") y = data.Const(pj, 0x00e9a, 0x00e9e, "%d", pj.m.bu32, 4) pj.set_label(0x00ef2, "ramaddress") y = data.Const(pj, 0x00ef2, 0x00efe, "0x%08x", pj.m.bu32, 4) pj.set_label(0x00e9e, "ROMSUM") pj.set_label(0x00ec0, "ROMTEST") pj.set_label(0x01ae2, "BCD_FMT(BCD, PTR)") pj.set_label(0x01b34, "BCD_ABS(BCD)") pj.set_label(0x01b38, "BCD_NEG(BCD)") pj.set_label(0x01be6, "BCD_CMP(R01,R23)") pj.set_label(0x01bea, "BCD_CMP(R23,R01)") pj.set_label(0x01c00, "stk_64") pj.set_label(0x01c14, "rel_64") pj.set_label(0x01c28, "abs_64") pj.set_label(0x01c3c, "loc_64") pj.set_label(0x01b48, "BCD_NEG8(&A0)") pj.set_label(0x01b62, "BCD_NEG(D23)") pj.set_label(0x01b72, "BCD_ADD8(&A0,&A1)") pj.set_label(0x01c60, "BCD_ADD(D01, D23)") pj.set_label(0x01c98, "BCD_SUBR(D23, D01(order?)") pj.set_label(0x01c9c, "BCD_SUB(D01, D23(order?)") pj.set_label(0x01cb0, "BCD_SUB8(&A0,&A1)") pj.set_label(0x0214c, "BCD_MUL5(D01)") pj.set_label(0x0217e, "BCD_MUL3(D01)") pj.set_label(0x0218c, "BCD_MUL6(D01)") pj.set_label(0x021be, "BCD_MUL8(D01)") pj.set_label(0x021c0, "BCD_MUL4(D01)") pj.set_label(0x021c4, "BCD_MUL2(D01)") pj.set_label(0x021f6, "BCD_DIV2(D01)") pj.set_label(0x02224, "BCD_LD(D0.W)") pj.set_label(0x0222c, "BCD_LD(D0.L)") pj.set_label(0x023ec, "FD_ABS(R2+R3)") pj.set_label(0x0287e, "rel_32") pj.set_label(0x02892, "abs_32") pj.set_label(0x028a4, "loc_32") pj.set_label(0x02f38, "SWITCH") pj.set_label(0x0320e, "BZERO(PTR,INT)") pj.set_label(0x033fc, "SHOW_CHAR") pj.set_label(0x03412, "SHOW_SEMI") pj.set_label(0x0341a, "SHOW_COMMA") pj.set_label(0x03422, "SHOW_CRNL") pj.set_label(0x03428, "SHOW_NL") pj.set_label(0x03430, "SHOW_MINUS") pj.set_label(0x03438, "SHOW_2CHAR") pj.set_label(0x03498, "SHOW_INT") pj.set_label(0x03932, "DISP_RD(INT ADR)") pj.set_label(0x03958, "SHOW_TXT_AT(ADR,STR)") pj.set_label(0x03906, "DISP_WR(INT ADR, INT DATA)") pj.set_label(0x039b0, "SHOW_WORD(INT)") pj.set_label(0x03c0a, "FREQ_CNT_SET_PERIOD(INT)") pj.set_label(0x03c26, "FREQ_CNT_WAIT()") pj.set_label(0x03c3a, "FREQ_CNT_10MHZ(INT)") pj.set_label(0x06936, "REVISION") pj.set_label(0x0693a, "MODEL") pj.set_label(0x06a2c, "MSG_TXT") pj.set_label(0x06ce0, "SHOW_TXT(STR)") pj.set_label(0x06cf2, "SHOW_CRNL") pj.set_label(0x06cfc, "SET_IF_LEDS(INT)") pj.set_label(0x06d20, "SHOW_MSG") pj.set_label(0x070be, "UPD_DETECTOR") pj.set_label(0x07b4e, "FILL_DISPLAY") pj.set_label(0x08164, "SHOW_CR[NL]") pj.set_label(0x0940c, "EXEC(INT KEY)") pj.set_label(0x0e39a, "VAR_HEAD") pj.set_label(0x0ed54, "EXEC2(INT KEY)") pj.set_label(0x0eddc, "SEARCH(NAMLEN.W, CHAIN.L, HASH.L, NAME.L)") pj.set_label(0x0ee6a, "FIND_OLDCMD(INT)") pj.set_label(0x0f72c, "NAME2TRACE") pj.set_label(0x0a986, "CALIBRATING") pj.set_label(0x0aa7a, "AUTOCAL") pj.set_label(0x13092, "WHICH(PTR TABLE, STR KEY, INT N)") pj.set_label(0x14158, "TRACE_MATH(LONG, INT, STR, STR, STR)") pj.set_label(0x17dce, "SHOW_COMMA") pj.set_label(0x17e9e, "PL_MOVE") pj.set_label(0x17eac, "PL_LINE") #pj.set_label(0x18d24, "MNEM") #pj.set_label(0x195c4, "PARMTYPE") #pj.set_label(0x196b6, "PRCADRS") # 0xffff0005 # 0xffff0007 # 0xffff0009 # 0xffff0013 # 0xffff0019 # 0xffff0021 # 0xffff0027 # 0xffff0035 #pj.set_label(0xffff4000, "PIT_PGCR") #pj.set_label(0xffff4002, "PIT_PSRR") #pj.set_label(0xffff4004, "PIT_PADDR") #pj.set_label(0xffff4006, "PIT_PBDDR") #pj.set_label(0xffff4008, "PIT_PCDDR") #pj.set_label(0xffff4010, "PIT_PADR") #pj.set_label(0xffff4012, "PIT_PBDR") # 0xffff8000 # 0xffffa6ae = stack # 0xffffa6ae # 0xffffa6b2 # 0xffffa6b6 # 0xffffa6ba # 0xffffa6bc # 0xffffa6be # 0xffffa6c2 # 0xffffa6c6 # 0xffffa6ca # 0xffffa6ce pj.set_label(0xffffa6d2, "ram_var_hash") # 0xffffa6ec # 0xffffa6f0 # 0xffffa6f2 # 0xffffa6f8 # 0xffffa6fe # 0xffffa704 # 0xffffa707 # 0xffffa708 # 0xffffa70a # 0xffffa70c # 0xffffa70e # 0xffffa710 # 0xffffa712 # 0xffffa714 # 0xffffa716 # 0xffffa71a # 0xffffa71c # 0xffffa890 # 0xffffa89e # 0xffffa8a0 # 0xffffa8a4 # 0xffffa8a6 # 0xffffa8a8 # 0xffffa972 # 0xffffa973 # 0xffffa974 # 0xffffa975 # 0xffffa976 # 0xffffa9af # 0xffffa9b0 # 0xffffa9b2 # 0xffffa9b4 # 0xffffa9b6 # 0xffffa9ba # 0xffffa9bb # 0xffffa9bc # 0xffffa9be # 0xffffa9c0 # 0xffffa9f4 # 0xffffa9f6 # 0xffffa9f8 # 0xffffa9fa # 0xffffa9fc # 0xffffaa1e # 0xffffaa20 # 0xffffaa24 # 0xffffaa26 # 0xffffaa28 # 0xffffaa29 # 0xffffaa2a pj.set_label(0xffffaa2c, "ram_center_freq") # 0xffffaa2d pj.set_label(0xffffaa34, "ram_freq_span") # 0xffffaa38 pj.set_label(0xffffaa3c, "ram_rf_fp_leds") pj.set_label(0xffffaa3e, "ram_if_fp_leds") # 0xffffaa3f # 0xffffaa40 if_scale_gain copy # 0xffffaa41 # 0xffffaa42 # 0xffffaa44 # 0xffffaa46 # 0xffffaa47 # 0xffffaa48 # 0xffffaa4a # 0xffffaa4c # 0xffffaa4e # 0xffffaa50 # 0xffffaa51 # 0xffffaa58 # 0xffffaa59 # 0xffffaa60 # 0xffffaa62 # 0xffffaa64 # 0xffffaa66 # 0xffffaa68 # 0xffffaa69 # 0xffffaa6a # 0xffffaa6b # 0xffffaa72 # 0xffffaa73 # 0xffffaa74 # 0xffffaa76 # 0xffffaa78 # 0xffffaa79 # 0xffffaa82 # 0xffffaa84 # 0xffffaa8a # 0xffffaa8e # 0xffffaa92 # 0xffffaa9a # 0xffffaaa2 # 0xffffaaa6 # 0xffffaaaa # 0xffffaaae # 0xffffaab2 # 0xffffaaba # 0xffffaabc # 0xffffaabe # 0xffffaac0 # 0xffffaac2 # 0xffffaaca # 0xffffaad2 # 0xffffaad4 # 0xffffaad6 # 0xffffaad8 # 0xffffaad9 # 0xffffaada # 0xffffaadc # 0xffffaade # 0xffffaae0 # 0xffffaae2 # 0xffffaae4 # 0xffffaae6 # 0xffffaae8 # 0xffffaaea # 0xffffaaeb # 0xffffaaec # 0xffffaaed # 0xffffaaee # 0xffffaaef # 0xffffaaf0 # 0xffffaaf1 # 0xffffaaf2 # 0xffffaaf4 # 0xffffaaf6 pj.set_label(0xffffaaf8, "ram_kbd_row") # 0xffffaafa # 0xffffaafc # 0xffffaafe # 0xffffaaff # 0xffffab00 # 0xffffab02 # 0xffffab04 # 0xffffab06 # 0xffffab07 # 0xffffab08 # 0xffffab0a # 0xffffab0c # 0xffffab0e # 0xffffab10 # 0xffffab11 # 0xffffab12 # 0xffffab13 # 0xffffab14 # 0xffffab16 # 0xffffab18 # 0xffffab1a # 0xffffab9a # 0xffffaba8 # 0xffffabb0 # 0xffffabba # 0xffffabbc # 0xffffabbe # 0xffffabc8 # 0xffffabce # 0xffffabd0 pj.set_label(0xffffabd2, "func_ptr+a6+a7") # 0xffffabd6 # 0xffffabda # 0xffffabde # 0xffffabe2 # 0xffffabe4 # 0xffffabe6 # 0xffffabe8 # 0xffffabea # 0xffffabec # 0xffffabee # 0xffffabf0 # 0xffffabf2 # 0xffffabfa # 0xffffae24 # 0xffffb628 # 0xffffb62a # 0xffffb630 # 0xffffbe2c # 0xffffbe2e # 0xffffbe30 # 0xffffbe32 # 0xffffbe34 # 0xffffbe38 # 0xffffbe3c # 0xffffbe40 # 0xffffbe42 # 0xffffbe44 # 0xffffbe46 # 0xffffbe48 # 0xffffbe50 # 0xffffbe54 # 0xffffbe5c # 0xffffbe5e # 0xffffbe60 # 0xffffbe62 # 0xffffbe64 # 0xffffbe68 # 0xffffbe6a # 0xffffbe78 # 0xffffbe86 # 0xffffbe88 # 0xffffbe8c # 0xffffbe8e # 0xffffbe9c # 0xffffbeaa # 0xffffbeac # 0xffffbeb0 # 0xffffbeb2 # 0xffffbec0 # 0xffffbf1f # 0xffffbf7e # 0xffffbfde # 0xffffbfdf # 0xffffbfe0 # 0xffffbfe1 pj.set_label(0xffffbfe2, "ram_hpib_address") pj.set_label(0xffffbfe3, "ram_not_hpib_address") # 0xffffbfe4 # 0xffffbfe5 # 0xffffbfe6 # 0xffffbfe7 # 0xffffbfe8 # 0xffffbfe9 # 0xffffbfea # 0xffffbfec # 0xffffbff0 # 0xffffbff4 # 0xffffbff8 # 0xffffbffc # 0xffffbffd # 0xffffbffe # I/O Decoding on A15 ##################### # 0x...00 BIO - BOTTOM/RF # 0x...20 DBCLK #2 # 0x...40 TIO - TOP/IF # 0x...64 LDBTEST #7 # 0x...80 LHPIB # 0x...a4 LDBTEST #7 # 0x...c0 LBUS # 0x...e0 HPIBSW #1 # 0x...e4 LATR #5 # BIO/BOTTOM/RF ############### pj.set_label(0xffffc000, "rf_50vto_lo_dac") pj.set_label(0xffffc002, "rf_50vto_hi_dac") pj.set_label(0xffffc006, "rf_yig_dac") pj.set_label(0xffffc008, "rf_scan_atten_vto") pj.set_label(0xffffc00a, "rf_scantime") pj.set_label(0xffffc00c, "rf_yig_lock_scan") pj.set_label(0xffffc00e, "rf_scan_mode") # A12 pj.set_label(0xffffc010, "rf_fp_leds") pj.set_label(0xffffc012, "rf_kbd_row") pj.set_label(0xffffc014, "rf_kbd_col") pj.set_label(0xffffc016, "rf_rpg") pj.set_label(0xffffc018, "rf_srq_resets") pj.set_label(0xffffc01a, "rf_phase_lock") pj.set_label(0xffffc01c, "rf_245_lock") pj.set_label(0xffffc01e, "rf_attn") # A15 pj.set_label(0xffffc020, "dbus_test_0") pj.set_label(0xffffc022, "dbus_test_2") pj.set_label(0xffffc025, "dbus_test_5") # A17 pj.set_label(0xffffc028, "rf_freqcnt_ctrl") pj.set_label(0xffffc02a, "rf_freqcnt_msb") pj.set_label(0xffffc02c, "rf_freqcnt_lsb") # pj.set_label(0xffffc030, "rf_inputs_atten_20") pj.set_label(0xffffc032, "rf_vunit_atten_30") pj.set_label(0xffffc034, "rf_atten_40") pj.set_label(0xffffc034, "rf_atten_50") pj.set_label(0xffffc034, "rf_atten_60") pj.set_label(0xffffc034, "rf_atten_70") # TIO/TOP/IF ############ pj.set_label(0xffffc040, "display_address") pj.set_label(0xffffc042, "display_rd_store") pj.set_label(0xffffc044, "display_wr_store") pj.set_label(0xffffc046, "display_wr_offset") pj.set_label(0xffffc048, "display_control") pj.set_label(0xffffc04a, "display_rd_scan") pj.set_label(0xffffc04c, "display_wr_marker") pj.set_label(0xffffc04e, "display_wr_scan") # SWEEP pj.set_label(0xffffc064, "if_sweep_src_trig") pj.set_label(0xffffc066, "if_sweep_time") pj.set_label(0xffffc068, "if_scale_gain") pj.set_label(0xffffc06a, "if_bw_fine") pj.set_label(0xffffc06c, "if_fp_leds") # HPIB ###### # 0xffffc081 # 0xffffc083 # 0xffffc085 # 0xffffc087 # 0xffffc089 # 0xffffc08b # 0xffffc08d # 0xffffc08f # LBUS ###### # 0xffffc0e0 ? # HPIBSW pj.set_label(0xffffc0e1, "adrsw_srq_display_ready") pj.set_label(0xffffc0e5, "latr_test") ############################################################### if False: for a in ( 0x01298, 0x013a8, 0x013d8, 0x013de, 0x013e4, 0x01e12, 0x01e94, 0x0217e, 0x0218c, 0x02194, 0x021a8, 0x02268, ): # print("ORPHAN %x" % a) y = cpu.disass(pj, a) y.lcmt = "ORPHAN - " nondisc = { 0x14ce: 0, } while True: l = [] for b,e in pj.gaps(): if b in nondisc: continue if e - b < 2: continue if pj.m.bu16(b) in (0x4eb8, 0x4e56): l.append(b) elif pj.m.rd(b) in (0x61,): l.append(b) # print(l) for i in l: y = cpu.disass(pj, i) y.lcmt = "DISCOVER - " while pj.run(): pass if len(l) == 0: break
def example(): l = [] for fw, vf in ( (FIRMWARE_K, version_k), (FIRMWARE_R, version_r), ): cy = common(fw) l.append(cy.m) vf(cy) a = 0x15b4c while True: y = Dataptr(cy.m, a) if not y.dst: break a += 5 y = Dataptr(cy.m, a) cy.m.q.queue(PRI_RPN, Obj, cy, y.dst) a += 5 y = Dataptr(cy.m, a) cy.m.q.queue(PRI_RPN, Obj, cy, y.dst) a += 5 for a in ( 0x21de7, 0x3858e, 0x385e8, 0x648bd, 0x72e87, ): Obj(cy, a) cy.m.set_line_comment(a, "Manual") for a in ( 0x0be2d, 0x0c114, 0x0c1d4, 0x0c1e9, 0x80000, 0x8011c, 0x80126, 0x80133, 0x80167, 0x801a5, 0x80215, 0x80804, 0x80821, 0x80832, 0x80965, 0x80974, 0x809d5, 0x80a54, 0x80a73, 0x80b2d, 0x80b43, 0x80c20, 0x80ec3, 0x80f79, 0x8107d, 0x81374, 0x818cb, 0x81944, # see GOSUB 0x26ca 0x81cad, 0x81cbc, 0x81ce2, 0x81cfc, 0x81d24, ): cy.m.q.queue(PRI_ASSY, cy.disass, a) for a in range(0x70601, 0x706a1, 5): y = Dataptr(cy.m, a) cy.disass(y.dst) # Table of week-days for a in range(0x0cf31, 0x0cf5b, 6): y = data.Data(cy.m, a, a + 6) t = text(cy.m, a, 3) y.rendered = ".TXT\t「" + t + "」" while True: cy.m.q.run() if hunt_objects(cy): break if True: edb = entrydatabase.RPN_EDB() edb.decorate(cy.m, "48G") return "HP48GX", l
def example(): m = mem.Stackup(( ("85680-80115.BIN", "85680-80116.BIN"), ("85680-80113.BIN", "85680-80114.BIN"), ), nextto=__file__) # Checum EPROMS # See 00e9e/ROMSUM s = [0xff, 0xff, 0xff, 0xff] for a in range(32768): s[0] += m[a * 2] s[1] += m[a * 2 + 1] s[2] += m[a * 2 + 65536] s[3] += m[a * 2 + 65536 + 1] for i in s: assert i & 0xff == 0 cx = mycpu() cx.m.map(m, 0) cx.macro("DISPLAY_READY()", "0838 0007 c0e1 66f8") cx.flow_check.append(flow_post_arg) for a, b in SYMBOLS.items(): cx.m.set_label(a, b) # Where ? # y = data.Const(cx.m, 0xfffe, 0x10000) # cx.m.set_label(y.lo, "eprom_lo_chksum") y = data.Const(cx.m, 0x19854, 0x19856) cx.m.set_label(y.lo, "eprom_hi_chksum") for i in post_arg: j = post_arg[i] if j and j[0] != "": cx.m.set_label(i, j[0]) if True: for b, e in ( (0x06936, 0x0693a), (0x06a2c, 0x06b84), (0x070ca, 0x070d6), (0x081ae, 0x081ba), (0x1357a, 0x1358a), (0x13e58, 0x13e70), (0x14960, 0x1497c), (0x14c94, 0x14cb4), (0x14f98, 0x14fa8), (0x15094, 0x150a4), (0x15140, 0x15150), (0x15e0e, 0x15e32), (0x172b8, 0x172c4), (0x17dbe, 0x17dce), ): for a in range(b, e, 4): x = cx.m.bu32(a) data.Dataptr(cx.m, a, a + 4, x) if not cx.m.occupied(x): data.Txt(cx.m, x, pfx=1, align=2) data.Txt(cx.m, 0x15dfc, pfx=1, align=2) cx.flow_check.append(flow_switch) cx.vectors(hi=0xc0) if True: n = 0 for a in range(0x193da, 0x194b2, 2): y = oldcmd(cx.m, a, n) n += 1 # print("OLDCMDS %d" % ((0x194b2-0x193da)/2)) for a in range(0x194b2, 0x1951e, 8): y = data.Const(cx.m, a, min(a + 8, 0x1951e), fmt="0x%02x") # print("KEYTAB %d" % ((0x1951e-0x194b2)/1)) for a in range(0x1951e, 0x1952c, 8): y = data.Const(cx.m, a, min(a + 8, 0x1952c), fmt="0x%02x") # print("IMEDBITS %d" % ((0x1952c-0x1951e)/1)) for a in range(0x1952c, 0x195c4, 16): y = data.Const(cx.m, a, min(a + 16, 0x195c4), "0x%08x", cx.m.bu32, 4) # print("SFLGVAL %d" % ((0x195c4-0x1952c)/2)) if True: a = 0x193a0 while a > 0x18c3a: y = mnem(cx, a) x = cx.m.bu16(y.lo - 2) a = y.lo ############################################################### switches[0x09ae8] = {} switches[0x09d78] = {} switches[0x0a5de] = {} switches[0x0af5c] = {} switches[0x0b5ec] = {} switches[0x0bb4e] = {} switches[0x0bd5a] = {} switches[0x0bd6e] = { 0: "KEYS_00_1f", 1: "KEYS_20_3f", 2: "KEYS_40_5f", 3: "KEYS_60_7f", 4: "KEYS_80_9f", 5: "KEYS_a0_bf", } for n in KEYNOS: t = KEYNOS[n] # print("KEY_%02x" % n, t) sk = "KS%c" % n ksk = hp856x_cmds.cmds.get(sk) if ksk is not None and type(ksk) != str: ksk = ksk[1] if ksk is None: ksk = "==" + t if n < 0x20: switches[0x9ae8][n] = "KEY_%02x_" % n + t if n >= 0x20 and n < 0x30: switches[0x9d78][n - 0x20] = "KEY_%02x_" % n + t if n >= 0x40 and n < 0x60: switches[0xa5de][n - 0x41] = "KEY_%02x_" % n + t switches[0xaf5c][n - 0x41] = "KEY_S%02x_KS%c_" % (n, n) + ksk if n >= 0x60 and n < 0x80: switches[0xb5ec][n - 0x61] = "KEY_%02x_" % n + t switches[0xbb4e][n - 0x60] = "KEY_S%02x_KS%c_" % (n, n) + ksk if n >= 0xa0 and n <= 0xbf: switches[0xbd5a][n - 0xa0] = "KEY_%02x_" % n + t if True: for b, e in ( (0x0e750, 0x0e778), (0x15ca4, 0x15cb4), ): for a in range(b, e, 8): data_double(cx.m, a) ############################################################### if True: cx.disass(0x2f38) ####################################################### ####################################################### for a in ( 0x0e2fa, 0x0e308, 0x0e318, 0x12986, 0x12988, 0x1298c, 0x12990, 0x1694e, 0x16954, ): y = data.Txt(cx.m, a, pfx=1, align=2) ####################################################### data.Dataptr(cx.m, 0xe39a, 0xe39a + 4, cx.m.bu32(0xe39a)) data.Const(cx.m, 0x2140, 0x2148, "%d", cx.m.bu64, 8) data.Const(cx.m, 0x2148, 0x214c, "%d", cx.m.bu32, 4) for a in ( 0x0645e, 0x06476, 0x0647e, 0x0648a, 0x06492, 0x0649a, 0x064a6, 0x064be, 0x0e2c4, 0x0e2d4, 0x0e2cc, 0x0e32a, 0x0e332, 0x0e37c, 0x0e384, 0x128ca, 0x15da0, ): if not cx.m.occupied(a): y = data_bcd(cx.m, a) cx.m.set_label(a, "BCD_%x" % y.data[0]) ####################################################### for a in range(0x693c, 0x6a2c, 6): data.Const(cx.m, a, a + 6, "0x%04x", cx.m.bu16, 2) ####################################################### a = 0x6b84 dsp = hp85662a.hp85662a() while a < 0x6c98: x = cx.m.bs16(a) if x < 0: y = data.Data(cx.m, a, a + 2) y.fmt = ".DSPLOC\t0x%04x" % -x y.lcmt = "adr=%d" % -x dsp = hp85662a.hp85662a() else: y = dsp.disass(a, cx.m) a = y.hi ####################################################### for a in range(0x0e3be, 0x0e3d4, 2): data.Txt(cx.m, a, a + 2, label=False) ####################################################### # 0ee98 00 01 93 be # 0eeaa 00 01 93 da | | # 0ee8e 00 01 da ee | | ####################################################### # Orphans ? if False: cx.disass(0x01b88) cx.disass(0x01b8e) cx.disass(0x01b94) cx.disass(0x01b9a) cx.disass(0x01b9e) cx.disass(0x01ba2) cx.disass(0x01ba8) cx.disass(0x01c76) cx.disass(0x01c82) cx.disass(0x01c90) cx.disass(0x01cd2) cx.disass(0x01d14) cx.disass(0x01578) cx.disass(0x01594) cx.disass(0x0171a) cx.disass(0x01906) cx.disass(0x02dee) cx.disass(0x02df4) cx.disass(0x03412) cx.disass(0x11e74) # from 0x2272 cx.disass(0x2282) # filled in 0xffffabd2 cx.disass(0x0ed98) cx.disass(0x0df5e) # Arg to 0x802 cx.disass(0x3292) # 0x3284 ####################################################### # pat 4,244,024 pg 262 lin 3700 for a in range(0x4fac, 0x4fec, 2): y = data.Const(cx.m, a, a + 2, "0x%04x", cx.m.bu16, 2) ####################################################### y = data.Const(cx.m, 0x193a2, 0x193be, "%d", cx.m.bu16, 2) cx.m.set_label(y.lo, "HASHPTR2") y = data.Const(cx.m, 0x193be, 0x193da, "%d", cx.m.bu16, 2) cx.m.set_label(y.lo, "HASHPTR") ####################################################### for a in range(0x19826, 0x19853, 1): y = data.Const(cx.m, a, a + 1, fmt="0x%02x") else: y = cx.disass(0xda1e) for i in y.__dict__: print("\t", i, y.__dict__[i]) for i in cx.m: if i.tag != "m68000": continue if i.dstadr in (0x940c, 0xed54): y = list(cx.m.find(hi=i.lo)) if len(y) != 1: continue y = y[0] if cx.m[y.lo] == 0x70: k = cx.m[y.lo + 1] elif cx.m.bu16(y.lo) == 0x103c: k = cx.m.bu16(y.lo + 2) else: continue if not k in KEYNOS: continue y.oper[0].txt = "#KEY_" + KEYNOS[k] if i.dstadr in (0xe4e8, ): y = list(cx.m.find(hi=i.lo)) if len(y) != 1: continue y = y[0] if y.mne != "PEA.L": continue z = data.Txt(cx.m, y.dstadr, pfx=1, align=2) y.lcmt = "'" + z.txt + "'" if i.dstadr in (0xe718, 0x3456, 0x6ce0): y = list(cx.m.find(hi=i.lo)) if len(y) != 1: continue y = y[0] if cx.m.bu16(y.lo) != 0x203c: continue a = cx.m.bu32(y.lo + 2) z = data.Txt(cx.m, a, pfx=1, align=2) y.lcmt = "'" + z.txt + "'" if i.dstadr == 0xe718: w = list(cx.m.find(hi=y.lo)) if len(w) != 1: continue w = w[0] if w.mne != "PEA.L": continue z = list(cx.m.find(w.dstadr)) if not z: z = [data.Txt(cx.m, w.dstadr, pfx=1, align=2)] w.lcmt = "'" + z[0].txt + "'" y = data.Const(cx.m, 0x693a, 0x693c, "%d", cx.m.bu16, 2) y = data.Const(cx.m, 0x00e9a, 0x00e9e, "%d", cx.m.bu32, 4) y = data.Const(cx.m, 0x00ef2, 0x00efe, "0x%08x", cx.m.bu32, 4) #cx.m.set_label(0x18d24, "MNEM") #cx.m.set_label(0x195c4, "PARMTYPE") #cx.m.set_label(0x196b6, "PRCADRS") # 0xffff0005 # 0xffff0007 # 0xffff0009 # 0xffff0013 # 0xffff0019 # 0xffff0021 # 0xffff0027 # 0xffff0035 #cx.m.set_label(0xffff4000, "PIT_PGCR") #cx.m.set_label(0xffff4002, "PIT_PSRR") #cx.m.set_label(0xffff4004, "PIT_PADDR") #cx.m.set_label(0xffff4006, "PIT_PBDDR") #cx.m.set_label(0xffff4008, "PIT_PCDDR") #cx.m.set_label(0xffff4010, "PIT_PADR") #cx.m.set_label(0xffff4012, "PIT_PBDR") # 0xffff8000 # 0xffffa6ae = stack # I/O Decoding on A15 ##################### # 0x...00 BIO - BOTTOM/RF # 0x...20 DBCLK #2 # 0x...40 TIO - TOP/IF # 0x...64 LDBTEST #7 # 0x...80 LHPIB # 0x...a4 LDBTEST #7 # 0x...c0 LBUS # 0x...e0 HPIBSW #1 # 0x...e4 LATR #5 # HPIB ###### # 0xffffc081 # 0xffffc083 # 0xffffc085 # 0xffffc087 # 0xffffc089 # 0xffffc08b # 0xffffc08d # 0xffffc08f # LBUS ###### # 0xffffc0e0 ? ############################################################### if False: for a in ( 0x01298, 0x013a8, 0x013d8, 0x013de, 0x013e4, 0x01e12, 0x01e94, 0x0217e, 0x0218c, 0x02194, 0x021a8, 0x02268, ): # print("ORPHAN %x" % a) y = cx.disass(a) y.lcmt = "ORPHAN - " nondisc = { 0x14ce: 0, } while True: l = [] for b, e in cx.m.gaps(): if b in nondisc: continue if e - b < 2: continue if cx.m.bu16(b) in (0x4eb8, 0x4e56): l.append(b) elif cx.m[b] in (0x61, ): l.append(b) # print(l) for i in l: y = cx.disass(i) y.lcmt = "DISCOVER - " if l: break ############################################################### return NAME, (cx.m, )