#include "mmu.h"
#include "debug_rom/debug_rom.h"
-#include "debug_rom/debug_rom_defines.h"
+#include "debug_rom_defines.h"
-#if 1
+#if 0
# define D(x) x
#else
# define D(x)
///////////////////////// debug_module_t
-debug_module_t::debug_module_t(sim_t *sim, unsigned progbufsize, unsigned max_bus_master_bits) :
+debug_module_t::debug_module_t(sim_t *sim, unsigned progbufsize, unsigned max_bus_master_bits,
+ bool require_authentication) :
progbufsize(progbufsize),
program_buffer_bytes(4 + 4*progbufsize),
max_bus_master_bits(max_bus_master_bits),
+ require_authentication(require_authentication),
debug_progbuf_start(debug_data_start - program_buffer_bytes),
debug_abstract_start(debug_progbuf_start - debug_abstract_size*4),
sim(sim)
dmstatus = {0};
dmstatus.impebreak = true;
- dmstatus.authenticated = 1;
+ dmstatus.authenticated = !require_authentication;
dmstatus.version = 2;
abstractcs = {0};
sbcs.access16 = true;
if (max_bus_master_bits >= 8)
sbcs.access8 = true;
+
+ challenge = random();
}
void debug_module_t::add_device(bus_t *bus) {
case DMI_SBDATA3:
result = sbdata[3];
break;
+ case DMI_AUTHDATA:
+ result = challenge;
+ break;
default:
result = 0;
D(fprintf(stderr, "Unexpected. Returning Error."));
return true;
}
- D(fprintf(stderr, ">>> perform_abstract_command(0x%x)\n", command));
-
if ((command >> 24) == 0) {
// register access
unsigned size = get_field(command, AC_ACCESS_REGISTER_SIZE);
return true;
}
+ unsigned i = 0;
if (get_field(command, AC_ACCESS_REGISTER_TRANSFER)) {
- if (regno >= 0x1000 && regno < 0x1020) {
+ if (regno < 0x1000 && progbufsize < 2) {
+ // Make the debugger use the program buffer if it's available, so it
+ // can test both use cases.
+ write32(debug_abstract, i++, csrw(S0, CSR_DSCRATCH));
+
+ if (write) {
+ switch (size) {
+ case 2:
+ write32(debug_abstract, i++, lw(S0, ZERO, debug_data_start));
+ break;
+ case 3:
+ write32(debug_abstract, i++, ld(S0, ZERO, debug_data_start));
+ break;
+ default:
+ abstractcs.cmderr = CMDERR_NOTSUP;
+ return true;
+ }
+ write32(debug_abstract, i++, csrw(S0, regno));
+
+ } else {
+ write32(debug_abstract, i++, csrr(S0, regno));
+ switch (size) {
+ case 2:
+ write32(debug_abstract, i++, sw(S0, ZERO, debug_data_start));
+ break;
+ case 3:
+ write32(debug_abstract, i++, sd(S0, ZERO, debug_data_start));
+ break;
+ default:
+ abstractcs.cmderr = CMDERR_NOTSUP;
+ return true;
+ }
+ }
+ write32(debug_abstract, i++, csrr(S0, CSR_DSCRATCH));
+
+ } else if (regno >= 0x1000 && regno < 0x1020) {
unsigned regnum = regno - 0x1000;
switch (size) {
case 2:
if (write)
- write32(debug_abstract, 0, lw(regnum, ZERO, debug_data_start));
+ write32(debug_abstract, i++, lw(regnum, ZERO, debug_data_start));
else
- write32(debug_abstract, 0, sw(regnum, ZERO, debug_data_start));
+ write32(debug_abstract, i++, sw(regnum, ZERO, debug_data_start));
break;
case 3:
if (write)
- write32(debug_abstract, 0, ld(regnum, ZERO, debug_data_start));
+ write32(debug_abstract, i++, ld(regnum, ZERO, debug_data_start));
else
- write32(debug_abstract, 0, sd(regnum, ZERO, debug_data_start));
+ write32(debug_abstract, i++, sd(regnum, ZERO, debug_data_start));
break;
default:
abstractcs.cmderr = CMDERR_NOTSUP;
return true;
}
+ } else if (regno >= 0x1020 && regno < 0x1040) {
+ // Don't force the debugger to use progbuf if it exists, so the
+ // debugger has to make the decision not to use abstract commands to
+ // access 64-bit FPRs on 32-bit targets.
+ unsigned fprnum = regno - 0x1020;
+
+ if (write) {
+ switch (size) {
+ case 2:
+ write32(debug_abstract, i++, flw(fprnum, ZERO, debug_data_start));
+ break;
+ case 3:
+ write32(debug_abstract, i++, fld(fprnum, ZERO, debug_data_start));
+ break;
+ default:
+ abstractcs.cmderr = CMDERR_NOTSUP;
+ return true;
+ }
+
+ } else {
+ switch (size) {
+ case 2:
+ write32(debug_abstract, i++, fsw(fprnum, ZERO, debug_data_start));
+ break;
+ case 3:
+ write32(debug_abstract, i++, fsd(fprnum, ZERO, debug_data_start));
+ break;
+ default:
+ abstractcs.cmderr = CMDERR_NOTSUP;
+ return true;
+ }
+ }
+
} else {
abstractcs.cmderr = CMDERR_NOTSUP;
return true;
}
+ }
- if (get_field(command, AC_ACCESS_REGISTER_POSTEXEC)) {
- D(fprintf(stderr, ">>> post-exec!\n"));
- write32(debug_abstract, 1,
- jal(ZERO, debug_progbuf_start - debug_abstract_start - 4));
- } else {
- write32(debug_abstract, 1, ebreak());
- }
+ if (get_field(command, AC_ACCESS_REGISTER_POSTEXEC)) {
+ write32(debug_abstract, i,
+ jal(ZERO, debug_progbuf_start - debug_abstract_start - 4 * i));
+ i++;
+ } else {
+ write32(debug_abstract, i++, ebreak());
}
debug_rom_flags[dmcontrol.hartsel] |= 1 << DEBUG_ROM_FLAG_GO;
bool debug_module_t::dmi_write(unsigned address, uint32_t value)
{
D(fprintf(stderr, "dmi_write(0x%x, 0x%x)\n", address, value));
+
+ if (!dmstatus.authenticated && address != DMI_AUTHDATA &&
+ address != DMI_DMCONTROL)
+ return false;
+
if (address >= DMI_DATA0 && address < DMI_DATA0 + abstractcs.datacount) {
unsigned i = address - DMI_DATA0;
if (!abstractcs.busy)
if (!dmcontrol.dmactive && get_field(value, DMI_DMCONTROL_DMACTIVE))
reset();
dmcontrol.dmactive = get_field(value, DMI_DMCONTROL_DMACTIVE);
+ if (!dmstatus.authenticated)
+ return true;
if (dmcontrol.dmactive) {
dmcontrol.haltreq = get_field(value, DMI_DMCONTROL_HALTREQ);
dmcontrol.resumereq = get_field(value, DMI_DMCONTROL_RESUMEREQ);
case DMI_SBDATA3:
sbdata[3] = value;
return true;
+ case DMI_AUTHDATA:
+ D(fprintf(stderr, "debug authentication: got 0x%x; 0x%x unlocks\n", value,
+ challenge + secret));
+ if (require_authentication) {
+ if (value == challenge + secret) {
+ dmstatus.authenticated = true;
+ } else {
+ dmstatus.authenticated = false;
+ challenge = random();
+ }
+ }
+ return true;
}
}
return false;