def reset(self, line=''):
"""Reset and reopen the USB interface."""
args = parse_argstring(self.reset, line)
d = self.shell.user_ns.get('d_remote')
if not d:
# Recover from starting up without a device
d = remote.Device()
self.shell.user_ns['d_remote'] = d
self.shell.user_ns['d'] = d
d.reset()
if args.arm:
reset_arm(d)
if address not in address_to_column:
add_column(address)
legend_countdown = 0
# Print the legend when we get new columns, or every 'legend_interval' lines
if legend_countdown == 0:
yield timestamp_blank + ' ' + ' '.join(['_' * 8 for a in column_to_address])
yield timestamp_blank + ' ' + ' '.join(['%08x' % a for a in column_to_address])
yield timestamp_blank + ' ' + '+'.join(['-' * 8 for a in column_to_address])
legend_countdown = legend_interval
# Put this change in the right column, show before-and-after
yield timestamp_blank + ' ' * (9 * address_to_column[address]) + ' %08x>' % old_value
yield timestamp_str + ' ' * (9 * address_to_column[address]) + '>%08x' % new_value
legend_countdown -= 1
if __name__ == "__main__":
import remote
if len(sys.argv) < 2:
print("usage: %s address [addresses ...]" % sys.argv[0])
print(" Each address can be a single word or a range a:b including both ends")
sys.exit(1)
d = remote.Device()
addrs = [tuple(int(n.replace('_',''), 16) for n in arg.split(':')) for arg in sys.argv[1:]]
changes = watch_scanner(d, addrs)
for line in watch_tabulator(changes):
print(line)
output_timestamp = now
except IOError:
# The device layer will already complain for us.
# Wait a tiny bit to let the device cool off...
time.sleep(0.1)
continue
except ConsoleOverflowError as e:
# Warn loudly that we missed some data
sys.stderr.write('\n\n======== %s ========\n\n' % e)
except KeyboardInterrupt:
return
finally:
# On our way out, update the buffer FIFO so the next console knows where to start
console_buffer.flush()
if log_file:
log_file.close()
if __name__ == "__main__":
import remote
if len(sys.argv) != 1:
print("usage: %s" % sys.argv[0])
sys.exit(1)
console_mainloop(remote.Device())
if delay:
time.sleep(delay)
def bitfuzz_round(d, address, wordcount, pattern):
values = []
pattern_str = pattern is not None and hex(pattern)[-1:] or ' '
for word in range(wordcount):
if pattern is not None:
d.poke(address + word * 4, pattern)
values.append(d.peek(address + word * 4))
return "%s %s" % (pattern_str, ' '.join(word_bits(w) for w in values))
def bitfuzz_heading(address, wordcount):
return ' ' + ''.join(
['%-37s' % '%08x' % (address + i * 4) for i in range(wordcount)])
if __name__ == "__main__":
import remote
if len(sys.argv) != 3:
print("usage: %s address wordcount" % sys.argv[0])
sys.exit(1)
for line in bitfuzz_rounds(remote.Device(),
int(sys.argv[1].replace('_', ''), 16),
int(sys.argv[2].replace('_', ''), 16)):
print(line)
def dma():
# DMA memory space, starting with DRAM.
memsquare(remote.Device(), 'memsquare-dma-000000-ffffff.png', 0, 16, 1024,
'dma')
if check_fast:
assert read_block(d,
address,
size,
fast=not fast,
addr_space=addr_space) == data
sys.stdout.write(hexdump(data, 16, address, log_file))
def dump_words(d,
address,
wordcount,
log_file='result.log',
fast=False,
addr_space='arm'):
data = read_block(d,
address,
wordcount * 4,
fast=fast,
addr_space=addr_space)
sys.stdout.write(hexdump_words(data, 8, address, log_file))
if __name__ == "__main__":
import remote
if len(sys.argv) != 3:
print "usage: %s address size" % sys.argv[0]
sys.exit(1)
dump(remote.Device(), int(sys.argv[1].replace('_', ''), 16),
int(sys.argv[2].replace('_', ''), 16))
def sram():
# Small 8kB mapping, looks like SRAM. 2-byte scale.
memsquare(remote.Device(), 'memsquare-02000000-02001fff.png', 0x02000000,
2, 64)
def dram():
# Fast dump of DRAM. 512x512, 16 byte scale.
# Runs in a few minutes, okay for differential testing.
memsquare(remote.Device(), 'memsquare-01c00000-01ffffff.png', 0x01c00000,
16, 512)
def mmio():
# Map every byte in 4MB of MMIO space
memsquare(remote.Device(), 'memsquare-04000000-043fffff.png', 0x04000000,
1, 2048)
def low64():
# Just the active region in the low 64MB of address space.
# Each pixel is 4 bytes, so this is about as much resolution as we could want.
memsquare(remote.Device(), 'memsquare-00000000-3fffffff.png', 0, 4)
def survey():
# Survey of all address space, each pixel is 0x100 bytes
memsquare(remote.Device(), 'memsquare-00000000-ffffffff.png', 0, 0x100)