def post_arg_func(asp, 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 is None:
continue
ins.flow_out = []
ins += code.Call(to=f.to)
a = ins.hi
for j in i:
if j == "W":
d = asp.bu16(a)
data.Dataptr(asp, a, a + 2, d)
a += 2
if d >= 0x8000:
d_q(asp, d)
elif j == "B":
cbyte(asp, a)
# data.Data(asp, a, a + 1)
a += 1
else:
assert False
ins += code.Jump(to=a)
def lexer(pj): assert pj.pg == 4 class lex(data.Data): def __init__(self, pj, lo, pfx): hi = lo + 4 self.f = pj.m[lo + 1] self.t = pj.m.bu16(lo + 2) self.pfx = pfx + "%c" % pj.m[lo] if self.f > 0: hi += 1 super().__init__(pj, lo, hi, "lex") if self.f > 0 and self.pfx in hpib: self.lcmt += hpib[self.pfx] + "\n" self.compact = True if self.f > 0: pj.m.set_label(self.t, "J_" + self.pfx) cpu.disass(self.t) h = hpib.get(self.pfx) if h == None: h = "UNDOC!" y=pj.m.find_lo(self.t) assert len(y) == 1 y[0].lcmt += "HPIB: " + h + "\n" def render(self, pj): s = ".LEX\t\"%s\", " % self.pfx s += "%d, " % pj.m[self.lo + 1] s += pj.render_adr(pj.m.bu16(self.lo + 2)) if self.f: s += ", 0x%02x" % pj.m[self.lo + 4] return s def tx(a, pfx): t0 = a while pj.m[a] != 0: y = lex(pj, a, pfx) a = y.hi if y.f == 0: b = pj.m.bu16(y.lo + 2) p = pfx + "%c" % pj.m[y.lo] pj.m.set_label(b, "LEX_" + p) tx(b, p) data.Const(pj, a, a + 1) pj.m.set_label(0x9780, "LEXTAB_ALPHABET") n = 65 for i in range(0x9780, 0x97b4, 2): data.Dataptr(pj.m, i, i + 2, pj.m.bu16(i)) a = pj.m.bu16(i) if n != 0x5a: pj.m.set_label(a, "LEX_%c" % n) else: pj.m.set_label(a, "LEX_NULL") tx(a, "%c" % n) n += 1 pj.m.set_label(0x9a22, "LEXTAB_OTHER") tx(0x9a22, "")
def inline_args(asp, ins):
for f in ins.flow_out:
i = i_args.get(f.to)
if i is None:
continue
ins.flow_out = []
ins += code.Call(to=f.to)
a = ins.hi
for j in i:
if j == "i":
d = asp.bu16(a)
data.Dataptr(asp, a, a + 2, d)
a += 2
else:
print("IARG:", j)
assert False
ins += code.Jump(to=a)
def inline_args(pj, ins):
for f in ins.flow_out:
i = i_args.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 == "i":
d = pj.m.bu16(a)
data.Dataptr(pj, a, a + 2, d)
a += 2
else:
print("IARG:", j)
assert False
ins.add_flow(pj, ">", True, a)
return
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
def dptr(pj, a):
v = pj.m.bu16(a)
data.Dataptr(pj, a, a + 2, v)
return v
def example():
cx = mc6809.mc6809()
cx.m.map(
mem.Stackup((FILENAMES[0], ), nextto=__file__),
0x0000,
)
cx.m.map(
mem.Stackup((FILENAMES[1], ), nextto=__file__),
0xe000,
)
s = 0
for a in range(0x0000, 0x2000, 2):
s += cx.m.bu16(a)
print("SUM 0x0000-0x1fff = 0x%x" % s)
s = 0
for a in range(0xe000, 0x10000, 2):
s += cx.m.bu16(a)
print("SUM 0xe000-0xffff = 0x%x" % s)
cx.add_ins(our_desc, our_ins)
for a, b in SYMBOLS.items():
cx.m.set_label(a, b)
gpu = hp1345a.hp1345a()
cx.vectors(which=("RST", "NMI", "SWI", "IRQ", "FIRQ", "SWI2"))
if True:
# screen texts
a = 0xd95
while a < 0xf4d:
z = Scrtxt(cx.m, a)
a = z.hi
Scrtxt(cx.m, 0x01db)
Scrtxt(cx.m, 0xea56)
Scrtxt(cx.m, 0xea6a)
Scrtxt(cx.m, 0xea7d)
Scrtxt(cx.m, 0xee37)
Scrtxt(cx.m, 0xee51)
Scrtxt(cx.m, 0xfa6d)
if True:
n = 0
c = {}
while cx.m.bu16(0xfd0 + n):
y = data.Txt(cx.m, 0xfd0 + n, 0xfd0 + n + 2, align=1)
ta = 0x1062 + n
t = cx.m.bu16(ta)
z = data.Codeptr(cx.m, ta, ta + 2, t)
z.lcmt += y.txt
cx.disass(t)
if t not in c:
c[t] = []
if y.txt not in CMDS:
print("Undoc command", y.txt)
CMDS[y.txt] = [t, "???"]
else:
CMDS[y.txt][0] = t
c[t].append(y.txt)
n += 2
for i in c:
c[i].sort()
cx.m.set_label(i, "CMD_" + "_".join(c[i]))
for i in CMDS:
c = CMDS[i]
if c[0] == 0:
print(i, "CMD not implemented (" + c[1] + ")")
continue
if c[1][0] == "?":
print(i, "CMD not documented (%s)" % c[1][1:])
cx.m.set_block_comment(c[0], " COMMAND " + i + " - " + c[1])
if True:
for a in (0x129d, 0x17e3, 0x181e, 0xe0e3, 0xee7e):
w = cx.m[a + 1] + 1
t = cx.m.bu16(a + 4)
for i in range(w):
d = cx.m.bu16(t)
data.Codeptr(cx.m, t, t + 2, d)
cx.disass(d)
t += 2
if True:
# Random strings
ttab(cx.m, 0xf019, 0xf03b)
ttab(cx.m, 0xf1d1, 0xf25c)
ttab(cx.m, 0xf412, 0xf44c)
ttab(cx.m, 0xefd7, 0xeff7)
if True:
a = 0xf56e
while cx.m[a]:
y = data.Txt(cx.m, a, a + 6, label=False, align=1)
a = y.hi
if True:
for a in range(0xf811, 0xf825, 2):
#d = cx.m.bu16(a)
cx.codeptr(a)
#cx.disass(d)
if True:
# HP1345 testpatterns
cx.m.set_label(0xfbed, "IMG_PIKES_PEAK")
cx.m.set_label(0xfd41, "IMG_FOCUS")
for a0 in (0xfbed, 0xfd41):
a = a0
data.Const(cx.m, a, a + 2, func=cx.m.bu16, fmt="0x%x", size=2)
l = cx.m.bu16(a)
a += 2
hp1345_render.svg(cx.m, a, a + l * 2)
while l > 0:
gpu.disass(a, cx.m)
a += 2
l -= 1
if True:
# No idea, possibly length error in IMG_FOCUS ?
data.Const(cx.m, 0xff17, 0xff19, fmt="0x%04x", func=cx.m.bu16, size=2)
if True:
# Special character handling
b = 0xf75b
c = 0xf778
cx.m.set_label(b, "CHR_TBL_KEY")
cx.m.set_label(c, "CHR_TBL_PTR")
data.Const(cx.m, b, c, fmt="0x%x")
a = c
while b < c:
p = cx.m.bu16(a)
y = data.Dataptr(cx.m, a, a + 2, p)
cx.m.set_label(p, "CHR_TBL_%02x" % cx.m[b])
while True:
z = data.Const(cx.m,
p,
p + 2,
func=cx.m.bu16,
fmt="0x%x",
size=2)
if cx.m[p + 1] & 0x80:
break
p += 2
b += 1
a += 2
# Stuff not accessed from anywhere
cx.disass(0xe5a1)
cx.m.set_block_comment(0xe5a1, "Unused ROM checksum code")
cx.m.set_block_comment(0xe5a1, "NB: Expects low rom at 0xc000")
cx.disass(0x1acf)
cx.disass(0xebf0)
cx.m.set_block_comment(0x003b9, "Outputs $0x0c - Term (not comma)")
cx.m.set_block_comment(0x003b9, "Outputs $0x12 - Error")
cx.m.set_block_comment(0x003b9, "Outputs $0x1a = 0")
cx.m.set_block_comment(0x003b9, "Outputs $0x1b - Digits")
cx.m.set_block_comment(0x003b9, "Outputs $0x1f - Decimals")
cx.m.set_block_comment(0x003b9, "Outputs $0x27 - Negative")
cx.m.set_block_comment(0x003b9, "Outputs $0x31+32 - Number")
cx.m.set_block_comment(0xf895, "Set reset, clear interrupt, Clr reset")
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 hints(pj, cpu):
if pj.pg == 0:
Menu(pj, cpu, 0x433e, "CHANMENU")
# @0x8948
data.Const(pj, 0x4003, 0x4004)
# @0x8954
for a,n in [
[ 0x4008, "START_TONE_APP" ],
[ 0x400a, "START_DTMF_APP" ],
[ 0x400c, "START_DSEQ_APP" ],
[ 0x4022, "START_DIAG_APP" ],
[ 0x4024, "START_XX5_APP" ],
[ 0x404f, "START_ERR_APP" ],
]:
cpu.codeptr(a)
u = pj.m.bu16(a)
pj.m.set_label(u, n.lower())
pj.m.set_label(a, n)
cpu.codeptr(0x4004)
cpu.codeptr(0x4006)
for a in range(0x400e, 0x4018, 2):
cpu.codeptr(a)
for a in range(0x4018, 0x4022, 2):
y = data.Dataptr(pj.m, a, a + 2, pj.m.bu16(a))
u = pj.m.bu16(a)
y = data.Txt(pj, u, u + 40, label=False)
y.compact = True
# @0xc4a5, @0xc318
for a in range(0x404f,0x4053,2):
cpu.codeptr(a)
for a,b in (
(0x4027, 0x28),
(0x411b, 0x28),
(0x4143, 0x28),
(0x416b, 0x28),
(0x4193, 0x28),
(0x4391, 0x04),
(0x4395, 0x0f),
(0x43a4, 0x0c),
(0x43b0, 0x0d),
(0x5cce, 0x1),
(0x5cd0, 0x1),
(0x5cd2, 0x1),
(0x5cd4, 0x1),
):
y = data.Txt(pj, a, a + b, label=False)
y.compact = True
y = data.Txt(pj, 0x41bb, 0x41bb + 12, label=False)
y.compact = True
if pj.pg == 1:
Menu(pj, cpu, 0x416b, "TONEMENU")
Menu(pj, cpu, 0x4234, "DTMFMENU")
for a,n in (
(0x5609, 7),
(0x69a6, 0x28),
(0x69d1, 5),
):
y = data.Txt(pj, a, a + n, label=False)
y.compact = True
for a in (0x4142,0x4156):
y = data.Txt(pj, a, a + 0x14, label=False)
y.compact = True
for a in range(0x43bc, 0x43f2, 3):
data.Const(pj, a, a + 3)
Num(pj, 0x4262)
Num(pj, 0x4265)
if pj.pg == 2:
Menu(pj, cpu, 0x416b, "DSEQMENU")
for a in range(0x4245, 0x4255, 2):
cpu.codeptr(a)
for a in range(0x4330, 0x4340, 2):
cpu.codeptr(a)
for a,b in (
(0x5144,20),
(0x5159,20),
(0x516f,3),
(0x5173,3),
(0x5177,3),
(0x517b,5),
):
y = data.Txt(pj, a, a + b, label=False)
y.compact = True
if pj.pg == 3:
Menu(pj, cpu, 0x4178, "DIAGMENU")
MenuPage(pj, cpu, 0x4196)
for i in range(0x3f):
a = 0x7349 + 4 * i
y = data.Const(pj, a, a + 2)
y.typ = ".BYTE"
y.fmt = "%d, %d" % (pj.m[a], pj.m.[a + 1])
u = pj.m.bu16(a + 2)
l = pj.m[a + 1]
data.Dataptr(pj.m, a + 2, a + 4, pj.m.bu16(a + 2))
y = data.Txt(pj, u, u + l, label=False)
y.compact = True
for a,b in (
(0x4002,53),
(0x4466,6),
(0x7339,3),
(0x733d,3),
(0x550f,2),
):
y = data.Txt(pj, a, a + b, label=False)
y.compact = True
for a in range(0x63da, 0x665a, 40):
y = data.Txt(pj, a, a + 40, label=False)
y.compact = True
a = 0x4c64
while a < 0x4dcb:
y = data.Txt(pj, a)
y.compact = True
a = y.hi
a = 0x54cf
while a < 0x550d:
y = data.Txt(pj, a)
y.compact = True
a = y.hi
a = 0x624d
while a < 0x63a4:
y = data.Txt(pj, a)
y.compact = True
a = y.hi
for a in range(0x4a3f, 0x4aad, 2):
y = pj.m.bu16(a)
assert pj.m[y] == 0xcc
x = pj.m.bu16(y + 1)
z = pj.m.find_lo(x)
if len(z) > 0:
t = z[0].txt[:-4].strip().replace(" ","_")
pj.m.set_label(y, "test_key_" + t)
Num(pj, 0x684a)
if pj.pg == 4:
data.Const(pj, 0xfd6e, 0xfd70)
for a in range(0xee62, 0xee88, 2):
u = pj.m.bu16(a)
y = data.Dataptr(pj.m, a, a + 2, u)
y = data.Const(pj, u, u + 1)
y = data.Txt(pj, u + 1, u + 1 + pj.m[u], label=False)
y.compact = True
for a in range(0xeeee, 0x0ef0e, 2):
u = pj.m.bu16(a)
y = data.Dataptr(pj.m, a, a + 2, u)
y = data.Const(pj, u, u + 1)
y = data.Txt(pj, u + 1, u + 1 + pj.m[u], label=False)
y.compact = True
for a in range(0xef94, 0xf014, 8):
y = data.Const(pj, a, a + 8, fmt="0x%02x")
for a,b in (
(0x8f7c,35),
(0x977b, 5),
(0xed11,40),
(0xea99,0x23),
(0xeb41,40),
(0xeb69,40),
(0xec5b,14),
(0xec69,14),
(0xec77,14),
(0xec85,0x36),
(0xecbb,6),
(0xecc1,40),
(0xece9,40),
):
y = data.Txt(pj, a, a + b, label=False)
y.compact = True
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
l = [ "LCD_CHR_f", "LCD_CHR_1", "LCD_CHR_2", "LCD_CHR_3",
"LCD_CHR_4", "LCD_CHR_phi", "LCD_CHR_mu", "LCD_CHR_is", ]
for a in range(0xea15, 0xea4e, 8):
pj.m.set_label(a, l.pop(0))
char_def(pj, a)
data.Const(pj, 0x929d, 0x929d + 8)
data.Const(pj, 0x9777, 0x9777 + 4)
data.Const(pj, 0xdd73, 0xdd9d)
# 2 x 35 bytes, no idea...
for a in range(0xed89, 0xedcf, 5):
data.Const(pj, a, a + 5, "0x%02x")
n = 1
for a in range(0xae3d, 0xaea5, 2):
print("%x -> " % a + keys[n])
u = pj.m.bu16(a)
if u != 0xae22:
pj.m.set_label(u, "key_" + keys[n])
n += 1
Num(pj, 0xea55)
Num(pj, 0xea6e)
Num(pj, 0xea65)
Num(pj, 0xea6b)
Num(pj, 0xea62)
Num(pj, 0xea68)
for a in range(0xee4a,0xee62, 3):
Num(pj,a)
for a in range(0xef4a, 0xef94, 2):
y = data.Const(pj, a, a + 2, fmt="0x%02x")
i = keys.get(pj.m[a])
j = keys.get(pj.m[a + 1])
y.lcmt += "%8s | %-8s\n" % (i, j)
def __init__(self, pj, adr, cx):
super(vector, self).__init__(pj, adr, adr + 4)
self.ws = data.Dataptr(pj, adr + 0x00, adr + 0x02, pj.m.bu16(adr))
self.ip = cx.codeptr(pj, adr + 0x02)
self.dstadr = self.ip.dst
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 ptr(pj, a):
return data.Dataptr(pj, a, a + 2, pj.m.bu16(a))
def dataptr(self, adr):
return data.Dataptr(self.m, adr, adr + 4, self.m.bu32(adr))
def example():
m0 = mem.Stackup(FILENAMES, nextto=__file__)
cx = my68k20()
cx.flow_check.append(inline_text)
cx.trap_returns[0] = True
cx.m.map(m0, 0x0, 0x8)
cx.m.map(m0, 0x80000000, 0x80002000, 0x0000)
cx.m.map(m0, 0x80004000, 0x80006000, 0x2000)
cx.m.map(m0, 0x80002000, 0x80004000, 0x4000)
cx.m.map(m0, 0x80006000, 0x80008000, 0x6000)
cx.m.map(m0, 0x00070000, 0x00072000, 0x8000)
cx.m.map(m0, 0x00072000, 0x00074000, 0xa000)
cx.m.map(m0, 0x00074000, 0x00076000, 0xc000)
cx.m.map(m0, 0x00076000, 0x00078000, 0xe000)
for a, b in SYMBOLS.items():
cx.m.set_label(a, b)
resha_section(
cx.m, 0x70000, {
0: (None, cx.disass),
1: (None, cx.disass),
2: (None, cx.disass),
3: (None, cx.disass),
4: (None, cx.disass),
5: (None, cx.disass),
})
resha_section(cx.m, 0x72000, {
0: (None, cx.disass),
2: (None, cx.disass),
3: (None, cx.disass),
})
resha_section(cx.m, 0x74000, {
0: (None, cx.disass),
1: (None, cx.disass),
})
resha_section(cx.m, 0x76000, {
0: (None, cx.disass),
})
cx.disass(0x80000024)
for a in (
0x80000072,
0x80000156,
0x800001c4,
0x80000314,
0x80000374,
0x80000552,
0x80002a24,
0x80002a2c,
0x800033ce,
0x80003690,
0x80004afe,
0x80004b42,
0x80004b68,
0x80007e0b,
):
data.Txt(cx.m, a, label=False, align=2)
def txts(a, b, align=2, label=False):
while a < b:
y = data.Txt(cx.m, a, label=label, align=align, splitnl=True)
a = y.hi
txts(0x7063e, 0x70708, align=1)
txts(0x712a6, 0x71308, align=1)
txts(0x719f2, 0x71ab8, align=1)
txts(0x74006, 0x7412c, align=1, label=True)
txts(0x76248, 0x763b0, align=1)
for a in range(0x76084, 0x760c8, 4):
y = cx.dataptr(a)
data.Txt(cx.m, y.dst)
for a in range(0x76a4c, 0x76a54, 4):
y = cx.dataptr(a)
data.Txt(cx.m, y.dst)
a = 0x765e4
while a < 0x76656:
w = data.Pstruct(cx.m, a, "<H", fmt="0x%x")
y = cx.dataptr(w.hi)
if y.dst:
data.Txt(cx.m, y.dst)
a = y.hi
a = 0x7351e
while True:
w = data.Pstruct(cx.m, a, "<H", fmt="0x%x")
if not w.data[0]:
break
y = cx.codeptr(w.hi)
a = y.hi
for a in range(0x7352e, 0x7353c, 4):
y = cx.codeptr(a)
cx.m.set_line_comment(y.dst, "VIA 0x%x" % a)
for a in range(0x734ea, 0x7351e, 4):
y = cx.codeptr(a)
cx.m.set_line_comment(y.dst, "VIA 0x%x" % a)
for a in range(0x76040, 0x76080, 4):
y = cx.codeptr(a)
cx.m.set_line_comment(y.dst, "VIA 0x%x" % a)
for a in (
0x7051c,
0x70554,
0x705d4,
0x705df,
0x705e8,
0x705f5,
0x70628,
0x70746,
0x709ea,
0x71010,
0x71025,
0x71039,
0x7104c,
0x71b10,
0x7200a,
0x76128,
0x762b0,
0x76a0a,
0x76a28,
0x76a46,
0x76990,
0x76a46,
0x76220,
# 0x77666,
):
data.Txt(cx.m, a)
txts(0x800010cc, 0x80001122, align=1, label=True)
txts(0x80001bb0, 0x80001bc2)
txts(0x80002c14, 0x80002e04, align=1)
txts(0x80004ece, 0x80004fbf, align=1)
txts(0x800027ee, 0x800028ca, align=1)
##########
data.Txt(cx.m, 0x8000221c, align=1)
data.Txt(cx.m, 0x80002232, align=1, splitnl=True)
data.Txt(cx.m, 0x8000223d, align=1, splitnl=True)
l = []
for a in range(0x8000228f, 0x800024a8):
x = cx.m[a]
if not x:
l.append(a)
break
if x & 0x80:
l.append(a)
for i in range(len(l) - 1):
data.Txt(cx.m, l[i], l[i + 1], align=1, label=not i)
data.Txt(cx.m, l[-1] + 1, align=1, label=False)
# 0x8000298e
y = data.Txt(cx.m, 0x8000240c, splitnl=True, align=1)
y = data.Txt(cx.m, 0x80002481, splitnl=True, align=1)
y = data.Txt(cx.m, 0x8000254e, splitnl=True, align=1)
y = data.Txt(cx.m, 0x8000256e, splitnl=True, align=1)
y = data.Txt(cx.m, 0x8000257d, splitnl=True, align=1)
y = data.Txt(cx.m, 0x8000258c, splitnl=True, align=1)
y = data.Txt(cx.m, 0x8000259b, splitnl=True, align=1)
for a, b in (
(0x704e8, None),
(0x70708, None),
(0x72c5e, None),
(0x730a8, None), # via 0x734f2
(0x73134, None), # via 0x734ee
(0x73258, None), # via 0x731b2
(0x7338a, None),
(0x73396, None), # via 0x731b2
(0x734ca, None),
(0x733a2, None),
(0x731b6, None),
(0x7412e, None),
(0x7665a, None),
(0x74208, None),
(0x74212, None),
(0x77662, None),
(
0x8000000c,
None,
),
(
0x80000010,
None,
),
(
0x80000014,
None,
),
(
0x80000018,
None,
),
(
0x8000001c,
None,
),
(
0x80000020,
None,
),
(
0x800001f6,
None,
),
(
0x80000208,
None,
),
(
0x8000021a,
None,
),
(
0x80001524,
None,
),
(
0x80001566,
None,
),
(
0x800015a8,
None,
),
(
0x80001628,
None,
),
(
0x800016c2,
None,
),
(
0x80002796,
None,
),
(
0x800027ca,
None,
),
(
0x80002bbe,
None,
),
(
0x80002bc4,
None,
),
(
0x800040a0,
None,
),
):
cx.disass(a)
if not b:
b = "MANUAL"
cx.m.set_line_comment(a, b)
for a in range(0x80002000, 0x80002074, 4):
cx.disass(a)
for a in range(0x8000310e, 0x80003122, 4):
cx.codeptr(a)
for a in range(0x800038ce, 0x800038ee, 4):
cx.codeptr(a)
for a in range(0x80004000, 0x80004008, 4):
cx.disass(a)
for a in range(0x800043aa, 0x80004492, 6):
y = data.Const(cx.m, a, a + 4, func=cx.m.bu32, size=4)
z = data.Const(cx.m, y.hi, y.hi + 2, func=cx.m.bu16, size=2)
w = cx.m.bu16(a + 4)
w >>= 4
w &= 0xffe
d = 0x800043aa + w
cx.disass(d)
for a in range(0x80004a7a, 0x80004a98, 4):
d = cx.m.bu32(a)
data.Dataptr(cx.m, a, a + 4, d)
data.Txt(cx.m, d, align=1)
for a in range(0x800036e8, 0x800036fc, 4):
d = cx.m.bu32(a)
data.Dataptr(cx.m, a, a + 4, d)
data.Txt(cx.m, d)
data.Const(cx.m, 0x80001ffa, 0x80002000)
data.Const(cx.m, 0x80003ffa, 0x80004000)
data.Const(cx.m, 0x80005ffa, 0x80006000)
data.Const(cx.m, 0x80007dfa, 0x80007e00)
# See 0x800039e0
data.Const(cx.m, 0x80003a2a, 0x80003a2a + 0x16)
y = data.Pstruct(cx.m, 0x80007e84, ">L")
y.lcmt = "Machine Number"
d = discover.Discover(cx)
return NAME, (cx.m, )
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, )
def dataptr(self, a):
return data.Dataptr(self.m, a, a + 2, self.m.bu16(a))
def example():
m = mem.ByteMem(0x8000, 0x10000)
for i in open(fwd + "06626-80005-REV-A-00-04.hex"):
j = i.split()
m[int(j[0],16)] = int(j[1],16)
cx = mc6809.mc6809()
cx.m.map(m, 0x8000, offset=0x8000)
for i, j in SYMBOLS.items():
cx.m.set_label(i, j)
cx.vectors(which=("RST", "NMI", "SWI", "IRQ", "FIRQ"))
token = {
1: '?',
2: 'end',
3: 'sep',
4: 'number',
6: 'string',
}
err = {
}
# 6624 6626
kbd_tbl = {
0x01: [ '9', '9' ],
0x02: [ '.', '.' ],
0x03: [ 'enter', 'enter' ],
0x04: [ '6', '6' ],
0x05: [ 'meter', 'range' ],
0x06: [ 'rcl', 'rcl' ],
0x07: [ 'unmask', 'ocp' ],
0x08: [ 'addr', 'addr' ],
0x09: [ '7', '7' ],
0x0a: [ '0', '0' ],
0x0b: [ '2', '2' ],
0x0c: [ '4', '4' ],
0x0d: [ 'output>', 'output>' ],
0x0e: [ 'on_off', 'on_off' ],
0x0f: [ '1', '1' ],
0x10: [ 'vset', 'vset' ],
0x11: [ None, None ],
0x12: [ 'sto', 'sto' ],
0x13: [ 'err', 'err' ],
0x14: [ 'lcl', 'lcl' ],
0x15: [ 'ovset', 'V_up' ],
0x16: [ 'fault', 'reset' ],
0x17: [ 'ocp', 'I_up' ],
0x18: [ 'dly', 'ovset' ],
0x19: [ '<output', '<output' ],
0x1a: [ 'ocrst', 'I_dn' ],
0x1b: [ 'iset', 'iset' ],
0x1c: [ 'ovrst', 'V_dn' ],
0x1d: [ '8', '8' ],
0x1e: [ 'backsp', 'backsp' ],
0x1f: [ '3', '3' ],
0x20: [ '5', '5' ],
}
for i in range(1,33):
s = "%02x" % i
a = cx.m[0x87f0+i-1]
b = cx.m[0x87d0+i-1]
s += " "
s += " %x" % a
s += " %04x" % cx.m.bu16(0x87b2 + a * 2)
s += " %-10s" % kbd_tbl[i][0]
s += " "
s += " %x" % b
s += " %04x" % cx.m.bu16(0x87b2 + b * 2)
s += " %-10s" % kbd_tbl[i][1]
print(s)
def softlbl(a, n):
cx.m.set_label(a, n)
data.Const(cx.m, 0x8000, 0x8002)
cx.m.set_label(0xd472, "chan_ptr")
for a in range(0xd472, 0xd47a, 2):
data.Dataptr(cx.m, a, a + 2, cx.m.bu16(a))
for a,b in (
(0x8002, 0x802a),
):
y = data.Txt(cx.m, a, b, align=1)
for a in (
0x827b,
0x849b,
0x84a7,
0x84b3,
0x84bf,
0x84cb,
0x84d7,
0xbcb1,
0xbcbd,
0xbcc9,
0xc255,
0xcf01,
0xd262,
):
y = data.Txt(cx.m, a, a + 12, align=1)
for a in (
0xa183,
0xa186,
0xa18f,
0xa198,
0xaffe,
):
y = data.Txt(cx.m, a, pfx=1, align=1)
cx.m.set_label(0x8ec2, "ERROR_TEXTS")
n = 0
for a in range(0x8ec2, 0x9036, 12):
y = data.Txt(cx.m, a, a + 12, align=1, label=False)
err[n] = y.txt
n += 1
a = 0xa225
nn = 7
while a < 0xa370:
b = cx.m[a]
if b == 0:
break
y = data.Txt(cx.m, a, pfx=1, align=1, label=False)
token[nn] = y.txt
a = y.hi
nn += 1
print("NN", nn)
for a in range(0x87d0, 0x8810, 8):
data.Const(cx.m, a, a + 8)
def t1(a, l):
cx.m.set_label(a, l)
while True:
data.Const(cx.m, a, a + 1)
if cx.m[a] == 0:
return;
a += 1
y = data.Txt(cx.m, a, align=1, label=False)
a = y.hi
cx.codeptr(a)
z = cx.m.bu16(a)
if False:
# XXX: doesn't work for ERROR
print("XXX %04x" % (z-3), y.txt)
cx.disass(z - 3)
cx.m.set_label(z, "func_" + y.txt)
a += 2
t1(0x8824, "HP6626_func_01_key")
t1(0x8860, "HP6624_func_01_key")
n = 1
for a in range(0x87b4, 0x87d0, 2):
x = cx.m.bu16(a)
softlbl(x, "key_%02x_%04x" % (n, x))
n += 1
cx.codeptr(a)
n = 1
for a in range(0xa5d3, 0xa687, 2):
x = cx.m.bu16(a)
softlbl(x, "cmd_%02x_%04x" % (n,x))
n += 1
cx.codeptr(a)
class tt_5(data.Data):
def __init__(self, asp, lo):
hi = lo + 4
super().__init__(asp, lo, hi, "tt_5")
def render(self):
s = ".TT5\t"
t = self.aspace[self.lo]
if t in token:
s += (token[t] + ", ").ljust(8)
else:
s += "T%02x, " % t
s += "0x%02x, " % self.aspace[self.lo + 1]
w = self.aspace.bu16(self.lo + 2)
s += self.aspace.adr(w)
return s
tt5s = {}
def tt5(a, f, l = None, ex = 0):
if l == None:
l = []
cx.m.set_label(a, "tt5_%04x" % a)
while True:
ll = list(l)
if cx.m[a] == 0:
if not cx.m.occupied(a):
data.Const(cx.m, a, a + 1)
break
t = cx.m[a]
if t in token:
ll.append(token[t])
else:
ll.append("T%02x" % t)
e = cx.m[a + 1]
if e != 0:
ex = f + e * 2
z = cx.m.bu16(ex)
# print("%04x" % a, "%04x" % z, "A %02x" % e, ll)
cx.m.set_label(z, "cmd_" + "_".join(ll))
if a not in tt5s:
tt5s[a] = tt_5(cx.m, a)
x = cx.m.bu16(a + 2)
if x != 0:
tt5(x, f, ll, ex)
else:
#print("%04x" % a, ll, "%04x" % ex)
for y in cx.m.find(ex):
y.lcmt += " ".join(ll) + "\n"
#print(y)
a += 4
tt5(0xa3a2, 0xa5d1)
for a in range(0xb7ac, 0xb7c4, 2):
data.Const(cx.m, a, a + 2)
# Task or coroutine table
for a in range(0xce62, 0xce80, 6):
data.Dataptr(cx.m, a, a + 2, cx.m.bu16(a))
z = cx.m.bu16(a + 2)
softlbl(z, "task_%04x" % z)
cx.codeptr(a + 2)
data.Dataptr(cx.m, a + 4, a + 6, cx.m.bu16(a + 4))
if True:
cx.disass(0x8631)
cx.disass(0x8b64)
cx.disass(0x8d6d)
cx.disass(0x8d76)
cx.disass(0x8e84)
cx.disass(0x8e87)
cx.disass(0xab5c)
cx.disass(0xc7a2)
cx.disass(0xc7ad)
cx.disass(0xc7b8)
cx.disass(0xc7c5)
cx.disass(0xc7d9)
cx.disass(0xc7e6)
cx.disass(0xc7fc)
cx.disass(0xc809)
cx.disass(0xc814)
cx.disass(0xc821)
cx.disass(0xc835)
cx.disass(0xc842)
cx.disass(0xc84b)
cx.disass(0xcf0d)
cx.disass(0xc855)
cx.disass(0xd3b8)
cx.disass(0xd3f8)
if True:
# See above in t1
cx.disass(0x8b03)
cx.disass(0x8b14)
cx.disass(0x8b25)
cx.disass(0x8b36)
cx.disass(0x8b44)
cx.disass(0x8b65)
cx.disass(0x8b78)
cx.disass(0x8b86)
cx.disass(0x8b91)
##############
def fp_val(cx, lo, hi):
e = cx.m.s8(hi - 1)
m = 0
i = 0
a = hi - 2
while a >= lo:
m |= cx.m[a] << i
i += 8
a -= 1
m *= 10 ** e
return m
class fp(data.Data):
def __init__(self, cx, lo, hi):
super().__init__(cx.m, lo, hi, "fp")
self.val = fp_val(cx, lo, hi)
def render(self):
return ".FP\t%g" % self.val
class tt_2(data.Data):
def __init__(self, cx, lo):
hi = lo + 5 + cx.m[lo + 4] * 4
super().__init__(cx.m, lo, hi, "tt_2")
def render(self):
s = ".TT2\t{\n"
w = self.aspace.bu16(self.lo + 0)
s += "\t.next = " + self.aspace.adr(w) + "\n"
s += "\t.model = %4d\n" % self.aspace.bu16(self.lo + 2)
n = self.aspace[self.lo + 4]
s += "\t.outputs = %d\n" % n
a = self.lo + 5
for i in range(n):
w = self.aspace.bu16(a)
s += "\t.out1[%d] = " % i + self.aspace.adr(w) + "\n"
a += 2
w = self.aspace.bu16(a)
s += "\t.out2[%d] = " % i + self.aspace.adr(w) + "\n"
a += 2
return s + "\t}"
class tt_output1(data.Data):
def __init__(self, cx, lo):
hi = lo + 39
super().__init__(cx.m, lo, hi, "tt_output1")
self.compact = True
def render(self):
s = ".OUTPUT1\t"
a = self.lo
f = [ "%4.1f", "%4.1f", "%6.3f", "%6.3f", "%4.1f"]
for i in range(5):
s += "0x%04x, " % self.aspace.bu16(a)
a += 2
s += (f[i] + ", ") % fp_val(cx, a, a + 4)
a += 4
for i in range(3):
s += "%5.2f, " % fp_val(cx, a, a + 3)
a += 3
return s[:-2]
class tt_output2(data.Data):
def __init__(self, cx, lo):
hi = lo + 44
super().__init__(cx.m, lo, hi, "tt_output2")
self.compact = True
def render(self):
s = ".OUTPUT2\t"
a = self.lo
f = [ "%4.1f", "%4.1f", "%6.3f", "%6.3f", "%4.1f",
"%5.3f", "%4.1f"]
for i in range(7):
s += "0x%04x, " % self.aspace.bu16(a)
a += 2
s += (f[i] + ", ") % fp_val(cx, a, a + 4)
a += 4
s += "0x%04x" % self.aspace.bu16(a)
return s
tt = {}
def tt3_1(a):
if a in tt:
return
tt[a] = True
tt_output1(cx, a)
def tt3_2(a):
if a in tt:
return
tt[a] = True
tt_output2(cx, a)
return
softlbl(a, "tt3_2_%04x" % a)
while True:
if cx.m[a + 2] > 2:
break
data.Const(cx.m, a, a+2, fmt="0x%02x")
fp(cx, a + 2, a + 6)
a += 6
data.Const(cx.m, a, a+2, fmt="0x%02x")
a = 0xb39c
while a:
cx.m.set_label(a, "tt2_%04x" % a)
x = cx.m.bu16(a)
if x == 0:
data.Dataptr(cx.m, a, a + 2, x)
break
y = tt_2(cx, a);
a = x
continue
data.Const(cx.m, a + 2, a + 4, fmt="%d")
data.Const(cx.m, a + 4, a + 5)
y = cx.m[a + 4]
a += 5
for i in range(y * 2):
z = cx.m.bu16(a)
tt3_1(z)
data.Dataptr(cx.m, a, a + 2, z)
a += 2
z = cx.m.bu16(a)
tt3_2(z)
data.Dataptr(cx.m, a, a + 2, z)
a += 2
a = x
##############
for a in range(0xb437, 0xb46e, 5):
cx.m.set_label(a, "tt1_%04x" % a)
data.Const(cx.m, a, a+1)
z = cx.m.bu16(a + 1)
data.Dataptr(cx.m, a + 1, a + 3, z)
tt3_1(z)
z = cx.m.bu16(a + 3)
data.Dataptr(cx.m, a + 3, a + 5, z)
tt3_2(z)
#############
# Add comment with error message
for i in cx.m:
if i.tag != "mc6809":
continue
if i.dstadr != 0x91d7:
continue
j = list(cx.m.find(hi=i.lo))
if len(j) != 1:
continue
j=j[0]
x = cx.m[j.lo]
if x != 0x86:
continue
y = cx.m[j.lo + 1]
j.lcmt += "Error: " + err[y] + "\n"
#############
# discover.Discover(cx)
return NAME, (cx.m,)
def task(pj, cpu):
gpu = hp1345a.hp1345a()
cpu.vectors(pj)
if True:
# screen texts
a = 0xd95
while a < 0xf4d:
z = Scrtxt(pj, a)
a = z.hi
continue
y = data.Pstruct(pj, a, ">HH")
y = data.Pstruct(pj, a + 4, ">bbb")
l = pj.m.bu16(a)
y = data.Txt(pj, a + 7, a + 7 + l, align=1)
a += 7 + l
Scrtxt(pj, 0x01db)
Scrtxt(pj, 0xea56)
Scrtxt(pj, 0xea6a)
Scrtxt(pj, 0xea7d)
Scrtxt(pj, 0xee37)
Scrtxt(pj, 0xee51)
Scrtxt(pj, 0xfa6d)
if True:
n = 0
c = {}
while pj.m.bu16(0xfd0 + n):
y = data.Txt(pj, 0xfd0 + n, 0xfd0 + n + 2, align=1)
ta = 0x1062 + n
t = pj.m.bu16(ta)
z = data.Codeptr(pj, ta, ta + 2, t)
z.lcmt += y.txt
pj.todo(t, cpu.disass)
if t not in c:
c[t] = []
if y.txt not in CMDS:
print("Undoc command", y.txt)
CMDS[y.txt] = [t, "???"]
else:
CMDS[y.txt][0] = t
c[t].append(y.txt)
n += 2
for i in c:
c[i].sort()
pj.set_label(i, "CMD_" + "_".join(c[i]))
for i in CMDS:
c = CMDS[i]
if c[0] == 0:
print(i, "CMD not implemented (" + c[1] + ")")
continue
if c[1][0] == "?":
print(i, "CMD not documented (%s)" % c[1][1:])
pj.set_block_comment(c[0],
" COMMAND " + i + " - " + c[1])
if True:
for a in (0x129d, 0x17e3, 0x181e, 0xe0e3, 0xee7e):
w = pj.m.rd(a + 1) + 1
t = pj.m.bu16(a + 4)
for i in range(w):
d = pj.m.bu16(t)
data.Codeptr(pj, t, t + 2, d)
pj.todo(d, cpu.disass)
t += 2
if True:
# Random strings
ttab(pj, 0xf019, 0xf03b)
ttab(pj, 0xf1d1, 0xf25c)
ttab(pj, 0xf412, 0xf44c)
ttab(pj, 0xefd7, 0xeff7)
if True:
a = 0xf56e
while pj.m.rd(a):
y = data.Txt(pj, a, a + 6, label=False, align=1)
a = y.hi
if True:
for a in range(0xf811, 0xf825, 2):
d = pj.m.bu16(a)
data.Codeptr(pj, a, a + 2, d)
pj.todo(d, cpu.disass)
if True:
# HP1345 testpatterns
pj.set_label(0xfbed, "IMG_PIKES_PEAK")
pj.set_label(0xfd41, "IMG_FOCUS")
for a0 in (0xfbed, 0xfd41):
a = a0
data.Const(pj, a, a + 2,
func=pj.m.bu16, fmt="0x%x", size=2)
l = pj.m.bu16(a)
a += 2
hp1345_render.svg(pj, a, a + l*2)
while l > 0:
gpu.disass(pj, a)
a += 2
l -= 1
if True:
# No idea, possibly length error in IMG_FOCUS ?
data.Const(pj, 0xff17, 0xff19, fmt="0x%04x", func=pj.m.bu16, size=2)
if True:
# Special character handling
b = 0xf75b
c = 0xf778
pj.set_label(b, "CHR_TBL_KEY")
pj.set_label(c, "CHR_TBL_PTR")
data.Const(pj, b, c, fmt="0x%x")
a = c
while b < c:
p = pj.m.bu16(a)
y = data.Dataptr(pj, a, a + 2, p)
pj.set_label(p, "CHR_TBL_%02x" % pj.m.rd(b))
while True:
z = data.Const(pj, p, p + 2,
func=pj.m.bu16, fmt="0x%x", size=2)
if pj.m.rd(p + 1) & 0x80:
break
p += 2
b += 1
a += 2
# Stuff not accessed from anywhere
pj.todo(0xe5a1, cpu.disass)
pj.set_label(0xe5a1, "BOGO_TEST_ROM")
pj.set_block_comment(0xe5a1, "Unused ROM checksum code")
pj.set_block_comment(0xe5a1, "NB: Expects low rom at 0xc000")
pj.set_label(0xe5ed, "TEST_IMGRAM")
pj.todo(0xebf0, cpu.disass)
while pj.run():
pass
pj.set_label(0x0291, "A=GETCHAR()")
pj.set_label(0x02d0, "PUTCHAR(A)")
pj.set_label(0x0312, "Y=FIND_CMD()")
pj.set_label(0x0338, "CLEAR_SCREEN()")
pj.set_label(0x0395, "PUTSTR(',')")
pj.set_label(0x039a, "PUTSTR(CRNL)")
pj.set_label(0x03a9, "memcpy(Y,X+2,@X)")
pj.set_label(0x03b9, "GETNBR()")
pj.set_block_comment(0x003b9, "Outputs $0x0c - Term (not comma)")
pj.set_block_comment(0x003b9, "Outputs $0x12 - Error")
pj.set_block_comment(0x003b9, "Outputs $0x1a = 0")
pj.set_block_comment(0x003b9, "Outputs $0x1b - Digits")
pj.set_block_comment(0x003b9, "Outputs $0x1f - Decimals")
pj.set_block_comment(0x003b9, "Outputs $0x27 - Negative")
pj.set_block_comment(0x003b9, "Outputs $0x31+32 - Number")
pj.set_label(0x04a2, "PUTNBR(D)")
pj.set_label(0x0bcb, "ERR_1_UNKNOWN_INSN()")
pj.set_label(0x0bdc, "ERR_2_WRONG_NO_PARAMS()")
pj.set_label(0x0bed, "ERR_3_XXX_OUT_OF_RANGE()")
pj.set_label(0x0c2e, "ERR_4_ILLEGAL_CHAR()")
pj.set_label(0x0c41, "ERR_11_NO_PLOTTER_HANDSHAKE()")
pj.set_label(0x0c5d, "ERR_12_UNRECOG_PLOTTER()")
pj.set_label(0x0c79, "ERR_22_FILE_NOT_OPEN_ON()")
pj.set_label(0x0c8c, "ERR_24_NOT_IN_SCROLL_MODE()")
pj.set_label(0x0c9f, "ERR_25_MEMORY_NOT_INIT()")
pj.set_label(0x0cb2, "ERR_32_ALL_FILES_NOT_CONFIG()")
pj.set_label(0x0cc5, "ERR_33_NO_DATA_TO_SCROLL()")
pj.set_label(0x0cd8, "ERR_34_MEMORY_OVERFLOW_ON()")
pj.set_label(0x0ceb, "ERR_35_FILE_ALREADY_OPEN_ON()")
pj.set_label(0x0f4e, "SCR_MSG(X)")
pj.set_label(0x0f77, "X = PREP_SCREEN()")
pj.set_label(0x0f8e, "D = ADR2JMP(D)")
pj.set_label(0x0fac, "DELAY(@U)")
pj.set_label(0x2800, "dip_switch")
pj.set_label(0xe77e, "CMD_nop")
pj.set_label(0xef76, "PLOT_pu_sp_lt()")
pj.set_label(0xef90, "PLOT_SELECT_PEN(A)")
pj.set_label(0xefb9, "PLOT_LINE_TYPE(A)")
pj.set_label(0xf004, "PUTSTR(X+1,@X)")
pj.set_label(0xf0c0, "SPEC_CHAR()")
pj.set_label(0xf56e, "plotter_table")
pj.set_label(0xf7fd, "DIAG_MODE()")
pj.set_label(0xf825, "DIAG_HPIB_BACK2BACK()")
pj.set_label(0xf895, "HPIB_RESET_CHIPS()")
pj.set_label(0xf8ae, "HPIB_IFC()")
pj.set_block_comment(0xf895, "Set reset, clear interrupt, Clr reset")
pj.set_label(0xfa9f, "DIAG_SIGNATURE_EPROM1()")
pj.set_label(0xfaaf, "DIAG_SIGNATURE_EPROM2()")
pj.set_label(0xfac2, "DIAG_SIGNATURE_3000()")
pj.set_label(0xfade, "DIAG_SIGNATURE_RAM()")
pj.set_label(0xfaee, "DIAG_RAM()")
pj.set_label(0xfb03, "DIAG_IMGRAM()")
pj.set_label(0xfbcb, "DIAG_PIKES_PEAK()")
pj.set_label(0xfbdc, "DIAG_FOCUS()")
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):
cpu.vectors(pj)
token = {
1: '?',
2: 'end',
3: 'sep',
4: 'number',
6: 'string',
}
err = {}
# 6624 6626
kbd_tbl = {
0x01: ['9', '9'],
0x02: ['.', '.'],
0x03: ['enter', 'enter'],
0x04: ['6', '6'],
0x05: ['meter', 'range'],
0x06: ['rcl', 'rcl'],
0x07: ['unmask', 'ocp'],
0x08: ['addr', 'addr'],
0x09: ['7', '7'],
0x0a: ['0', '0'],
0x0b: ['2', '2'],
0x0c: ['4', '4'],
0x0d: ['output>', 'output>'],
0x0e: ['on_off', 'on_off'],
0x0f: ['1', '1'],
0x10: ['vset', 'vset'],
0x11: [None, None],
0x12: ['sto', 'sto'],
0x13: ['err', 'err'],
0x14: ['lcl', 'lcl'],
0x15: ['ovset', 'V_up'],
0x16: ['fault', 'reset'],
0x17: ['ocp', 'I_up'],
0x18: ['dly', 'ovset'],
0x19: ['<output', '<output'],
0x1a: ['ocrst', 'I_dn'],
0x1b: ['iset', 'iset'],
0x1c: ['ovrst', 'V_dn'],
0x1d: ['8', '8'],
0x1e: ['backsp', 'backsp'],
0x1f: ['3', '3'],
0x20: ['5', '5'],
}
for i in range(1, 33):
s = "%02x" % i
a = pj.m.rd(0x87f0 + i - 1)
b = pj.m.rd(0x87d0 + i - 1)
s += " "
s += " %x" % a
s += " %04x" % pj.m.bu16(0x87b2 + a * 2)
s += " %-10s" % kbd_tbl[i][0]
s += " "
s += " %x" % b
s += " %04x" % pj.m.bu16(0x87b2 + b * 2)
s += " %-10s" % kbd_tbl[i][1]
print(s)
def softlbl(a, n):
if a not in pj.labels:
pj.set_label(a, n)
for a, n in (
(0x002b, "display_chan"),
(0x0085, "n_chan"),
(0x0086, "model_desc_ptr"),
(0x038f, "B_flag1"),
(0x0390, "B_flag2"),
(0x01bc, "cal_lock_flag"),
(0x1000, "i8291_data"),
(0x1001, "i8291_intrrupt1"),
(0x1002, "i8291_intrrupt2"),
(0x1003, "i8291_spoll"),
(0x1004, "i8291_addressed"),
(0x1005, "i8291_cmd_aux"),
(0x1006, "i8291_addr1"),
(0x1007, "i8291_addr2_eos"),
(0x2000, "slv_force"),
(0x3000, "slv_sense"),
(0x4000, "dip_kbd_sense"),
(0x5000, "kbd_dsply_scan"),
(0x8100, "B=dsply_needs_update()"),
(0x819b, "p4_p5()"),
(0x81ac, "p4_p5(B)"),
(0x81c0, "dsply_shift_bits(B,Y)"),
(0x8236, "task__display"),
(0x84e3, "i8291_init"),
(0x8465, "MSG(X)"),
(0x8775, "task__keyboard"),
(0x87d0, "HP6626_keytbl"),
(0x87f0, "HP6624_keytbl"),
(0x88b6, "GETKEY"),
(0x897f, "key_08_METER"),
(0x89d5, "key_01_func"),
(0x8992, "key_06_ENTER"),
(0x89c0, "key_05_BS"),
(0x8bb0, "key_09_output_control"),
(0x8c1a, "key_04_LCL"),
(0x8a2b, "key_03_OUTPUT_SELECT"),
(0x8a81, "key_02_digit"),
(0x8acd, "key_07_PERIOD"),
(0x8bfa, "key_09_output_ONOFF"),
(0x8c05, "key_09_output_OCP_UNMASK"),
(0x8c40, "key_0e_RANGE"),
(0x8cb3, "key_0a_V_UP"),
(0x8d05, "key_0b_V_DOWN"),
(0x8dce, "key_0c_I_UP"),
(0x8e32, "key_0d_I_DOWN"),
(0x91d7, "ERR=A"),
(0x93f7, "err_NUMBER_RANGE"),
(0x9463, "Get_Chan"),
(0x9468, "Chan_Nr_Check"),
(0x99d5, "cmd_A"),
(0x99d9, "cmd_B"),
(0x99dd, "cmd_S"),
(0x9acb, "func_09_output_OCRST"),
(0x9b4a, "func_09_output_OVRST"),
(0x9b21, "get_chan"),
(0x9ea6, "put_char"),
(0x9ead, "put_CRNL"),
(0x9ebc, "reset_outbuf"),
(0x9ec4, "put_string"),
(0x9ed2, "put_digits"),
(0xa14b, "cmd_ID"),
(0xaaf9, "Get_Nbr"),
(0xb00b, "Output_40W20V_1"),
(0xb032, "Output_40W50V_1"),
(0xb059, "Output_80W20V_1"),
(0xb080, "Output_80W50V_1"),
(0xb0a7, "Output_25W_1"),
(0xb0ce, "Output_50W_1"),
(0xb0f5, "Output_100W20V_1"),
(0xb11c, "Output_100W50V_1"),
(0xb143, "Output_200W20V_1"),
(0xb16a, "Output_200W50V_1"),
(0xb191, "Output_10W10V_1"),
(0xb1b8, "Output_40W20V_2"),
(0xb1e4, "Output_40W50V_2"),
(0xb210, "Output_80W20V_2"),
(0xb23c, "Output_80W50V_2"),
(0xb268, "Output_25W_2"),
(0xb294, "Output_50W_2"),
(0xb2c0, "Output_100W20V_2"),
(0xb2ec, "Output_100W50V_2"),
(0xb318, "Output_200W20V_2"),
(0xb344, "Output_200W50V_2"),
(0xb370, "Output_10W10V_2"),
(0xb476, "Config_Model"),
(0xb4c5, "ERR_NO_MODEL"),
(0xb5ca, "special_model"),
(0xb7c4, "tx_slave"),
(0xb873, "rx_slave_byte"),
(0xbacc, "yield"),
(0xbade, "EE_Write_Word"),
(0xbae9, "EE_Write_Byte"),
(0xbb1e, "I2C_Ready"),
(0xbb37, "EE_Read_Word"),
(0xbb7f, "EE_Read_Byte"),
(0xbbbf, "I2C_Error"),
(0xbbcb, "I2C_Start_Byte"),
(0xbbd2, "I2C_Poll_Ack"),
(0xbbf5, "EE_SCL_LH"),
(0xbc00, "EE_SCL_L"),
(0xbc06, "I2C_Read_Byte"),
(0xbc23, "I2C_Write_Byte"),
(0xbc45, "I2C_Start"),
(0xbc70, "I2C_Stop"),
(0xbc8d, "I2C_Get_Ack"),
(0xbc9f, "EE_Ack"),
(0xbcd5, "cmd_OVCAL"),
(0xc36a, "err_CAL_ERROR"),
(0xc5cf, "cmd_CMODE"),
(0xc62f, "err_CAL_LOCKED"),
(0xc637, "err_STORE_LIMIT"),
(0xcb22, "ROMSUM"),
(0xce80, "task_setup"),
(0xcea5, "task_switch"),
(0xceb7, "task__vimes"),
(0xd448, "init_slavetbl"),
):
pj.set_label(a, n)
data.Const(pj, 0x8000, 0x8002)
pj.set_label(0xd472, "chan_ptr")
for a in range(0xd472, 0xd47a, 2):
data.Dataptr(pj, a, a + 2, pj.m.bu16(a))
for a, b in ((0x8002, 0x802a), ):
y = data.Txt(pj, a, b, align=1)
for a in (
0x827b,
0x849b,
0x84a7,
0x84b3,
0x84bf,
0x84cb,
0x84d7,
0xbcb1,
0xbcbd,
0xbcc9,
0xc255,
0xcf01,
0xd262,
):
y = data.Txt(pj, a, a + 12, align=1)
for a in (
0xa183,
0xa186,
0xa18f,
0xa198,
0xaffe,
):
y = data.Txt(pj, a, pfx=1, align=1)
pj.set_label(0x8ec2, "ERROR_TEXTS")
n = 0
for a in range(0x8ec2, 0x9036, 12):
y = data.Txt(pj, a, a + 12, align=1, label=False)
err[n] = y.txt
n += 1
a = 0xa225
nn = 7
while a < 0xa370:
b = pj.m.rd(a)
if b == 0:
break
y = data.Txt(pj, a, pfx=1, align=1, label=False)
token[nn] = y.txt
a = y.hi
nn += 1
print("NN", nn)
for a in range(0x87d0, 0x8810, 8):
data.Const(pj, a, a + 8)
def t1(a, l):
pj.set_label(a, l)
while True:
data.Const(pj, a, a + 1)
if pj.m.rd(a) == 0:
return
a += 1
y = data.Txt(pj, a, align=1, label=False)
a = y.hi
cpu.codeptr(pj, a)
z = pj.m.bu16(a)
if False:
# XXX: doesn't work for ERROR
print("XXX %04x" % (z - 3), y.txt)
pj.todo(z - 3, cpu.disass)
pj.set_label(z, "func_" + y.txt)
a += 2
t1(0x8824, "HP6626_func_01_key")
t1(0x8860, "HP6624_func_01_key")
n = 1
for a in range(0x87b4, 0x87d0, 2):
x = pj.m.bu16(a)
softlbl(x, "key_%02x_%04x" % (n, x))
n += 1
cpu.codeptr(pj, a)
n = 1
for a in range(0xa5d3, 0xa687, 2):
x = pj.m.bu16(a)
softlbl(x, "cmd_%02x_%04x" % (n, x))
n += 1
cpu.codeptr(pj, a)
class tt_5(data.Data):
def __init__(self, pj, lo):
hi = lo + 4
super(tt_5, self).__init__(pj, lo, hi, "tt_5")
def render(self, pj):
s = ".TT5\t"
t = pj.m.rd(self.lo)
if t in token:
s += (token[t] + ", ").ljust(8)
else:
s += "T%02x, " % t
s += "0x%02x, " % pj.m.rd(self.lo + 1)
w = pj.m.bu16(self.lo + 2)
s += pj.render_adr(w)
return s
def tt5(a, f, l=None, ex=0):
if l == None:
l = []
pj.set_label(a, "tt5_%04x" % a)
while True:
ll = list(l)
if pj.m.rd(a) == 0:
data.Const(pj, a, a + 1)
break
t = pj.m.rd(a)
if t in token:
ll.append(token[t])
else:
ll.append("T%02x" % t)
e = pj.m.rd(a + 1)
if e != 0:
ex = f + e * 2
z = pj.m.bu16(ex)
# print("%04x" % a, "%04x" % z, "A %02x" % e, ll)
pj.set_label(z, "cmd_" + "_".join(ll))
tt_5(pj, a)
x = pj.m.bu16(a + 2)
if x != 0:
tt5(x, f, ll, ex)
else:
# print("%04x" % a, ll, "%04x" % ex)
y = pj.t.find_lo(ex)
y[0].lcmt += " ".join(ll) + "\n"
# print(y)
a += 4
tt5(0xa3a2, 0xa5d1)
for a in range(0xb7ac, 0xb7c4, 2):
data.Const(pj, a, a + 2)
# Task or coroutine table
for a in range(0xce62, 0xce80, 6):
data.Dataptr(pj, a, a + 2, pj.m.bu16(a))
z = pj.m.bu16(a + 2)
softlbl(z, "task_%04x" % z)
cpu.codeptr(pj, a + 2)
data.Dataptr(pj, a + 4, a + 6, pj.m.bu16(a + 4))
if True:
cpu.disass(pj, 0x8631)
cpu.disass(pj, 0x8b64)
cpu.disass(pj, 0x8d6d)
cpu.disass(pj, 0x8d76)
cpu.disass(pj, 0x8e84)
cpu.disass(pj, 0x8e87)
cpu.disass(pj, 0xab5c)
cpu.disass(pj, 0xc7a2)
cpu.disass(pj, 0xc7ad)
cpu.disass(pj, 0xc7b8)
cpu.disass(pj, 0xc7c5)
cpu.disass(pj, 0xc7d9)
cpu.disass(pj, 0xc7e6)
cpu.disass(pj, 0xc7fc)
cpu.disass(pj, 0xc809)
cpu.disass(pj, 0xc814)
cpu.disass(pj, 0xc821)
cpu.disass(pj, 0xc835)
cpu.disass(pj, 0xc842)
cpu.disass(pj, 0xc84b)
cpu.disass(pj, 0xcf0d)
cpu.disass(pj, 0xc855)
cpu.disass(pj, 0xd3b8)
cpu.disass(pj, 0xd3f8)
if True:
# See above in t1
cpu.disass(pj, 0x8b03)
cpu.disass(pj, 0x8b14)
cpu.disass(pj, 0x8b25)
cpu.disass(pj, 0x8b36)
cpu.disass(pj, 0x8b44)
cpu.disass(pj, 0x8b65)
cpu.disass(pj, 0x8b78)
cpu.disass(pj, 0x8b86)
cpu.disass(pj, 0x8b91)
##############
def fp_val(pj, lo, hi):
e = pj.m.s8(hi - 1)
m = 0
i = 0
a = hi - 2
while a >= lo:
m |= pj.m.rd(a) << i
i += 8
a -= 1
m *= 10**e
return m
class fp(data.Data):
def __init__(self, pj, lo, hi):
super(fp, self).__init__(pj, lo, hi, "fp")
self.val = fp_val(pj, lo, hi)
def render(self, pj):
return ".FP\t%g" % self.val
class tt_2(data.Data):
def __init__(self, pj, lo):
hi = lo + 5 + pj.m.rd(lo + 4) * 4
super(tt_2, self).__init__(pj, lo, hi, "tt_2")
def render(self, pj):
s = ".TT2\t{\n"
w = pj.m.bu16(self.lo + 0)
s += "\t.next = " + pj.render_adr(w) + "\n"
s += "\t.model = %4d\n" % pj.m.bu16(self.lo + 2)
n = pj.m.rd(self.lo + 4)
s += "\t.outputs = %d\n" % n
a = self.lo + 5
for i in range(n):
w = pj.m.bu16(a)
s += "\t.out1[%d] = " % i + pj.render_adr(w) + "\n"
a += 2
w = pj.m.bu16(a)
s += "\t.out2[%d] = " % i + pj.render_adr(w) + "\n"
a += 2
return s + "\t}"
class tt_output1(data.Data):
def __init__(self, pj, lo):
hi = lo + 39
super(tt_output1, self).__init__(pj, lo, hi, "tt_output1")
self.compact = True
def render(self, pj):
s = ".OUTPUT1\t"
a = self.lo
f = ["%4.1f", "%4.1f", "%6.3f", "%6.3f", "%4.1f"]
for i in range(5):
s += "0x%04x, " % pj.m.bu16(a)
a += 2
s += (f[i] + ", ") % fp_val(pj, a, a + 4)
a += 4
for i in range(3):
s += "%5.2f, " % fp_val(pj, a, a + 3)
a += 3
return s[:-2]
class tt_output2(data.Data):
def __init__(self, pj, lo):
hi = lo + 44
super(tt_output2, self).__init__(pj, lo, hi, "tt_output2")
self.compact = True
def render(self, pj):
s = ".OUTPUT2\t"
a = self.lo
f = ["%4.1f", "%4.1f", "%6.3f", "%6.3f", "%4.1f", "%5.3f", "%4.1f"]
for i in range(7):
s += "0x%04x, " % pj.m.bu16(a)
a += 2
s += (f[i] + ", ") % fp_val(pj, a, a + 4)
a += 4
s += "0x%04x" % pj.m.bu16(a)
return s
tt = {}
def tt3_1(a):
if a in tt:
return
tt[a] = True
tt_output1(pj, a)
def tt3_2(a):
if a in tt:
return
tt[a] = True
tt_output2(pj, a)
return
softlbl(a, "tt3_2_%04x" % a)
while True:
if pj.m.rd(a + 2) > 2:
break
data.Const(pj, a, a + 2, fmt="0x%02x")
fp(pj, a + 2, a + 6)
a += 6
data.Const(pj, a, a + 2, fmt="0x%02x")
a = 0xb39c
while a:
pj.set_label(a, "tt2_%04x" % a)
x = pj.m.bu16(a)
if x == 0:
data.Dataptr(pj, a, a + 2, x)
break
y = tt_2(pj, a)
a = x
continue
data.Const(pj, a + 2, a + 4, fmt="%d")
data.Const(pj, a + 4, a + 5)
y = pj.m.rd(a + 4)
a += 5
for i in range(y * 2):
z = pj.m.bu16(a)
tt3_1(z)
data.Dataptr(pj, a, a + 2, z)
a += 2
z = pj.m.bu16(a)
tt3_2(z)
data.Dataptr(pj, a, a + 2, z)
a += 2
a = x
##############
for a in range(0xb437, 0xb46e, 5):
pj.set_label(a, "tt1_%04x" % a)
data.Const(pj, a, a + 1)
z = pj.m.bu16(a + 1)
data.Dataptr(pj, a + 1, a + 3, z)
tt3_1(z)
z = pj.m.bu16(a + 3)
data.Dataptr(pj, a + 3, a + 5, z)
tt3_2(z)
##############
while pj.run():
pass
#############
# Add comment with error message
for i in pj:
if i.tag != "mc6809":
continue
if i.dstadr != 0x91d7:
continue
j = pj.t.find_hi(i.lo)
if len(j) != 1:
continue
j = j[0]
x = pj.m.rd(j.lo)
if x != 0x86:
continue
y = pj.m.rd(j.lo + 1)
j.lcmt += "Error: " + err[y] + "\n"
def dataptr(self, adr):
y = data.Dataptr(self.m, adr, adr + 4, self.m.bu32(adr) & 0x7f00ffff)
return y
