2011-09-06 01:55:25 +02:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2011, Max Filippov, Open Source and Linux Lab.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
* * Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* * Neither the name of the Open Source and Linux Lab nor the
|
|
|
|
* names of its contributors may be used to endorse or promote products
|
|
|
|
* derived from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
|
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2016-01-26 19:17:21 +01:00
|
|
|
#include "qemu/osdep.h"
|
2018-06-25 14:42:13 +02:00
|
|
|
#include "qemu/units.h"
|
2011-09-06 01:55:25 +02:00
|
|
|
#include "cpu.h"
|
2012-12-17 18:19:49 +01:00
|
|
|
#include "exec/exec-all.h"
|
|
|
|
#include "exec/gdbstub.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/host-utils.h"
|
2011-09-06 01:55:25 +02:00
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
#include "hw/loader.h"
|
|
|
|
#endif
|
|
|
|
|
2011-10-16 00:56:04 +02:00
|
|
|
static struct XtensaConfigList *xtensa_cores;
|
|
|
|
|
2013-07-07 01:47:51 +02:00
|
|
|
static void xtensa_core_class_init(ObjectClass *oc, void *data)
|
|
|
|
{
|
2013-06-28 23:18:47 +02:00
|
|
|
CPUClass *cc = CPU_CLASS(oc);
|
2013-07-07 01:47:51 +02:00
|
|
|
XtensaCPUClass *xcc = XTENSA_CPU_CLASS(oc);
|
|
|
|
const XtensaConfig *config = data;
|
|
|
|
|
|
|
|
xcc->config = config;
|
2013-06-28 23:18:47 +02:00
|
|
|
|
|
|
|
/* Use num_core_regs to see only non-privileged registers in an unmodified
|
|
|
|
* gdb. Use num_regs to see all registers. gdb modification is required
|
|
|
|
* for that: reset bit 0 in the 'flags' field of the registers definitions
|
|
|
|
* in the gdb/xtensa-config.c inside gdb source tree or inside gdb overlay.
|
|
|
|
*/
|
|
|
|
cc->gdb_num_core_regs = config->gdb_regmap.num_regs;
|
2013-07-07 01:47:51 +02:00
|
|
|
}
|
|
|
|
|
2017-11-04 03:44:46 +01:00
|
|
|
static void init_libisa(XtensaConfig *config)
|
|
|
|
{
|
|
|
|
unsigned i, j;
|
|
|
|
unsigned opcodes;
|
|
|
|
|
|
|
|
config->isa = xtensa_isa_init(config->isa_internal, NULL, NULL);
|
|
|
|
assert(xtensa_isa_maxlength(config->isa) <= MAX_INSN_LENGTH);
|
|
|
|
opcodes = xtensa_isa_num_opcodes(config->isa);
|
|
|
|
config->opcode_ops = g_new(XtensaOpcodeOps *, opcodes);
|
|
|
|
|
|
|
|
for (i = 0; i < opcodes; ++i) {
|
|
|
|
const char *opc_name = xtensa_opcode_name(config->isa, i);
|
|
|
|
XtensaOpcodeOps *ops = NULL;
|
|
|
|
|
|
|
|
assert(xtensa_opcode_num_operands(config->isa, i) <= MAX_OPCODE_ARGS);
|
|
|
|
if (!config->opcode_translators) {
|
|
|
|
ops = xtensa_find_opcode_ops(&xtensa_core_opcodes, opc_name);
|
|
|
|
} else {
|
|
|
|
for (j = 0; !ops && config->opcode_translators[j]; ++j) {
|
|
|
|
ops = xtensa_find_opcode_ops(config->opcode_translators[j],
|
|
|
|
opc_name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
|
|
if (ops == NULL) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"opcode translator not found for %s's opcode '%s'\n",
|
|
|
|
config->name, opc_name);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
config->opcode_ops[i] = ops;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-01 12:00:29 +02:00
|
|
|
void xtensa_finalize_config(XtensaConfig *config)
|
|
|
|
{
|
2017-11-04 03:44:46 +01:00
|
|
|
if (config->isa_internal) {
|
|
|
|
init_libisa(config);
|
|
|
|
}
|
2015-07-01 12:00:29 +02:00
|
|
|
|
2018-02-04 08:55:06 +01:00
|
|
|
if (config->gdb_regmap.num_regs == 0 ||
|
|
|
|
config->gdb_regmap.num_core_regs == 0) {
|
|
|
|
unsigned i;
|
|
|
|
unsigned n_regs = 0;
|
|
|
|
unsigned n_core_regs = 0;
|
|
|
|
|
|
|
|
for (i = 0; config->gdb_regmap.reg[i].targno >= 0; ++i) {
|
|
|
|
if (config->gdb_regmap.reg[i].type != 6) {
|
|
|
|
++n_regs;
|
|
|
|
if ((config->gdb_regmap.reg[i].flags & 0x1) == 0) {
|
|
|
|
++n_core_regs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (config->gdb_regmap.num_regs == 0) {
|
|
|
|
config->gdb_regmap.num_regs = n_regs;
|
|
|
|
}
|
|
|
|
if (config->gdb_regmap.num_core_regs == 0) {
|
|
|
|
config->gdb_regmap.num_core_regs = n_core_regs;
|
|
|
|
}
|
2015-07-01 12:00:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-16 00:56:04 +02:00
|
|
|
void xtensa_register_core(XtensaConfigList *node)
|
|
|
|
{
|
2013-07-07 01:47:51 +02:00
|
|
|
TypeInfo type = {
|
|
|
|
.parent = TYPE_XTENSA_CPU,
|
|
|
|
.class_init = xtensa_core_class_init,
|
|
|
|
.class_data = (void *)node->config,
|
|
|
|
};
|
|
|
|
|
2011-10-16 00:56:04 +02:00
|
|
|
node->next = xtensa_cores;
|
|
|
|
xtensa_cores = node;
|
2017-10-05 15:50:58 +02:00
|
|
|
type.name = g_strdup_printf(XTENSA_CPU_TYPE_NAME("%s"), node->config->name);
|
2013-07-07 01:47:51 +02:00
|
|
|
type_register(&type);
|
|
|
|
g_free((gpointer)type.name);
|
2011-10-16 00:56:04 +02:00
|
|
|
}
|
2011-09-06 01:55:27 +02:00
|
|
|
|
2012-03-14 01:38:23 +01:00
|
|
|
static uint32_t check_hw_breakpoints(CPUXtensaState *env)
|
2012-01-29 02:28:21 +01:00
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for (i = 0; i < env->config->ndbreak; ++i) {
|
|
|
|
if (env->cpu_watchpoint[i] &&
|
|
|
|
env->cpu_watchpoint[i]->flags & BP_WATCHPOINT_HIT) {
|
|
|
|
return DEBUGCAUSE_DB | (i << DEBUGCAUSE_DBNUM_SHIFT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-12 15:06:48 +02:00
|
|
|
void xtensa_breakpoint_handler(CPUState *cs)
|
2012-01-29 02:28:21 +01:00
|
|
|
{
|
2014-09-12 15:06:48 +02:00
|
|
|
XtensaCPU *cpu = XTENSA_CPU(cs);
|
|
|
|
CPUXtensaState *env = &cpu->env;
|
2013-08-26 18:23:18 +02:00
|
|
|
|
|
|
|
if (cs->watchpoint_hit) {
|
|
|
|
if (cs->watchpoint_hit->flags & BP_CPU) {
|
2012-01-29 02:28:21 +01:00
|
|
|
uint32_t cause;
|
|
|
|
|
2013-08-26 18:23:18 +02:00
|
|
|
cs->watchpoint_hit = NULL;
|
2012-01-29 02:28:21 +01:00
|
|
|
cause = check_hw_breakpoints(env);
|
|
|
|
if (cause) {
|
|
|
|
debug_exception_env(env, cause);
|
|
|
|
}
|
2016-05-17 16:18:04 +02:00
|
|
|
cpu_loop_exit_noexc(cs);
|
2012-01-29 02:28:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-06 01:55:25 +02:00
|
|
|
void xtensa_cpu_list(FILE *f, fprintf_function cpu_fprintf)
|
|
|
|
{
|
2011-10-16 00:56:04 +02:00
|
|
|
XtensaConfigList *core = xtensa_cores;
|
2011-09-06 01:55:27 +02:00
|
|
|
cpu_fprintf(f, "Available CPUs:\n");
|
2011-10-16 00:56:04 +02:00
|
|
|
for (; core; core = core->next) {
|
|
|
|
cpu_fprintf(f, " %s\n", core->config->name);
|
2011-09-06 01:55:27 +02:00
|
|
|
}
|
2011-09-06 01:55:25 +02:00
|
|
|
}
|
|
|
|
|
2013-06-29 18:55:54 +02:00
|
|
|
hwaddr xtensa_cpu_get_phys_page_debug(CPUState *cs, vaddr addr)
|
2011-09-06 01:55:25 +02:00
|
|
|
{
|
2017-01-25 19:54:11 +01:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2013-06-29 18:55:54 +02:00
|
|
|
XtensaCPU *cpu = XTENSA_CPU(cs);
|
2011-09-06 01:55:53 +02:00
|
|
|
uint32_t paddr;
|
|
|
|
uint32_t page_size;
|
|
|
|
unsigned access;
|
|
|
|
|
2013-06-29 18:55:54 +02:00
|
|
|
if (xtensa_get_physical_addr(&cpu->env, false, addr, 0, 0,
|
2011-09-06 01:55:53 +02:00
|
|
|
&paddr, &page_size, &access) == 0) {
|
|
|
|
return paddr;
|
|
|
|
}
|
2013-06-29 18:55:54 +02:00
|
|
|
if (xtensa_get_physical_addr(&cpu->env, false, addr, 2, 0,
|
2011-09-06 01:55:53 +02:00
|
|
|
&paddr, &page_size, &access) == 0) {
|
|
|
|
return paddr;
|
|
|
|
}
|
|
|
|
return ~0;
|
2017-01-25 19:54:11 +01:00
|
|
|
#else
|
|
|
|
return addr;
|
|
|
|
#endif
|
2011-09-06 01:55:25 +02:00
|
|
|
}
|
|
|
|
|
2017-01-25 19:54:11 +01:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
|
2012-03-14 01:38:23 +01:00
|
|
|
static uint32_t relocated_vector(CPUXtensaState *env, uint32_t vector)
|
2011-09-06 01:55:51 +02:00
|
|
|
{
|
|
|
|
if (xtensa_option_enabled(env->config,
|
|
|
|
XTENSA_OPTION_RELOCATABLE_VECTOR)) {
|
|
|
|
return vector - env->config->vecbase + env->sregs[VECBASE];
|
|
|
|
} else {
|
|
|
|
return vector;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-06 01:55:48 +02:00
|
|
|
/*!
|
|
|
|
* Handle penging IRQ.
|
|
|
|
* For the high priority interrupt jump to the corresponding interrupt vector.
|
|
|
|
* For the level-1 interrupt convert it to either user, kernel or double
|
|
|
|
* exception with the 'level-1 interrupt' exception cause.
|
|
|
|
*/
|
2012-03-14 01:38:23 +01:00
|
|
|
static void handle_interrupt(CPUXtensaState *env)
|
2011-09-06 01:55:48 +02:00
|
|
|
{
|
|
|
|
int level = env->pending_irq_level;
|
|
|
|
|
|
|
|
if (level > xtensa_get_cintlevel(env) &&
|
|
|
|
level <= env->config->nlevel &&
|
|
|
|
(env->config->level_mask[level] &
|
|
|
|
env->sregs[INTSET] &
|
|
|
|
env->sregs[INTENABLE])) {
|
2013-08-26 08:31:06 +02:00
|
|
|
CPUState *cs = CPU(xtensa_env_get_cpu(env));
|
|
|
|
|
2011-09-06 01:55:48 +02:00
|
|
|
if (level > 1) {
|
|
|
|
env->sregs[EPC1 + level - 1] = env->pc;
|
|
|
|
env->sregs[EPS2 + level - 2] = env->sregs[PS];
|
|
|
|
env->sregs[PS] =
|
|
|
|
(env->sregs[PS] & ~PS_INTLEVEL) | level | PS_EXCM;
|
2011-09-06 01:55:51 +02:00
|
|
|
env->pc = relocated_vector(env,
|
|
|
|
env->config->interrupt_vector[level]);
|
2011-09-06 01:55:48 +02:00
|
|
|
} else {
|
|
|
|
env->sregs[EXCCAUSE] = LEVEL1_INTERRUPT_CAUSE;
|
|
|
|
|
|
|
|
if (env->sregs[PS] & PS_EXCM) {
|
|
|
|
if (env->config->ndepc) {
|
|
|
|
env->sregs[DEPC] = env->pc;
|
|
|
|
} else {
|
|
|
|
env->sregs[EPC1] = env->pc;
|
|
|
|
}
|
2013-08-26 08:31:06 +02:00
|
|
|
cs->exception_index = EXC_DOUBLE;
|
2011-09-06 01:55:48 +02:00
|
|
|
} else {
|
|
|
|
env->sregs[EPC1] = env->pc;
|
2013-08-26 08:31:06 +02:00
|
|
|
cs->exception_index =
|
2011-09-06 01:55:48 +02:00
|
|
|
(env->sregs[PS] & PS_UM) ? EXC_USER : EXC_KERNEL;
|
|
|
|
}
|
|
|
|
env->sregs[PS] |= PS_EXCM;
|
|
|
|
}
|
|
|
|
env->exception_taken = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-01 21:29:10 +01:00
|
|
|
/* Called from cpu_handle_interrupt with BQL held */
|
2013-02-02 10:57:51 +01:00
|
|
|
void xtensa_cpu_do_interrupt(CPUState *cs)
|
2011-09-06 01:55:25 +02:00
|
|
|
{
|
2013-02-02 10:57:51 +01:00
|
|
|
XtensaCPU *cpu = XTENSA_CPU(cs);
|
|
|
|
CPUXtensaState *env = &cpu->env;
|
|
|
|
|
2013-08-26 08:31:06 +02:00
|
|
|
if (cs->exception_index == EXC_IRQ) {
|
2011-09-06 01:55:48 +02:00
|
|
|
qemu_log_mask(CPU_LOG_INT,
|
|
|
|
"%s(EXC_IRQ) level = %d, cintlevel = %d, "
|
|
|
|
"pc = %08x, a0 = %08x, ps = %08x, "
|
|
|
|
"intset = %08x, intenable = %08x, "
|
|
|
|
"ccount = %08x\n",
|
|
|
|
__func__, env->pending_irq_level, xtensa_get_cintlevel(env),
|
|
|
|
env->pc, env->regs[0], env->sregs[PS],
|
|
|
|
env->sregs[INTSET], env->sregs[INTENABLE],
|
|
|
|
env->sregs[CCOUNT]);
|
|
|
|
handle_interrupt(env);
|
|
|
|
}
|
|
|
|
|
2013-08-26 08:31:06 +02:00
|
|
|
switch (cs->exception_index) {
|
2011-09-06 01:55:41 +02:00
|
|
|
case EXC_WINDOW_OVERFLOW4:
|
|
|
|
case EXC_WINDOW_UNDERFLOW4:
|
|
|
|
case EXC_WINDOW_OVERFLOW8:
|
|
|
|
case EXC_WINDOW_UNDERFLOW8:
|
|
|
|
case EXC_WINDOW_OVERFLOW12:
|
|
|
|
case EXC_WINDOW_UNDERFLOW12:
|
|
|
|
case EXC_KERNEL:
|
|
|
|
case EXC_USER:
|
|
|
|
case EXC_DOUBLE:
|
2012-01-13 06:21:32 +01:00
|
|
|
case EXC_DEBUG:
|
2011-09-06 01:55:48 +02:00
|
|
|
qemu_log_mask(CPU_LOG_INT, "%s(%d) "
|
|
|
|
"pc = %08x, a0 = %08x, ps = %08x, ccount = %08x\n",
|
2013-08-26 08:31:06 +02:00
|
|
|
__func__, cs->exception_index,
|
2011-09-06 01:55:48 +02:00
|
|
|
env->pc, env->regs[0], env->sregs[PS], env->sregs[CCOUNT]);
|
2013-08-26 08:31:06 +02:00
|
|
|
if (env->config->exception_vector[cs->exception_index]) {
|
2011-09-06 01:55:51 +02:00
|
|
|
env->pc = relocated_vector(env,
|
2013-08-26 08:31:06 +02:00
|
|
|
env->config->exception_vector[cs->exception_index]);
|
2011-09-06 01:55:41 +02:00
|
|
|
env->exception_taken = 1;
|
|
|
|
} else {
|
2015-11-13 13:43:35 +01:00
|
|
|
qemu_log_mask(CPU_LOG_INT, "%s(pc = %08x) bad exception_index: %d\n",
|
|
|
|
__func__, env->pc, cs->exception_index);
|
2011-09-06 01:55:41 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2011-09-06 01:55:48 +02:00
|
|
|
case EXC_IRQ:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
qemu_log("%s(pc = %08x) unknown exception_index: %d\n",
|
2013-08-26 08:31:06 +02:00
|
|
|
__func__, env->pc, cs->exception_index);
|
2011-09-06 01:55:48 +02:00
|
|
|
break;
|
2011-09-06 01:55:41 +02:00
|
|
|
}
|
2011-09-06 01:55:48 +02:00
|
|
|
check_interrupts(env);
|
2011-09-06 01:55:25 +02:00
|
|
|
}
|
2017-01-25 19:54:11 +01:00
|
|
|
#else
|
|
|
|
void xtensa_cpu_do_interrupt(CPUState *cs)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
2011-09-06 01:55:53 +02:00
|
|
|
|
2014-09-13 18:45:18 +02:00
|
|
|
bool xtensa_cpu_exec_interrupt(CPUState *cs, int interrupt_request)
|
|
|
|
{
|
|
|
|
if (interrupt_request & CPU_INTERRUPT_HARD) {
|
|
|
|
cs->exception_index = EXC_IRQ;
|
|
|
|
xtensa_cpu_do_interrupt(cs);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-01-25 19:54:11 +01:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
|
|
|
|
int xtensa_cpu_handle_mmu_fault(CPUState *cs, vaddr address, int size, int rw,
|
|
|
|
int mmu_idx)
|
|
|
|
{
|
|
|
|
XtensaCPU *cpu = XTENSA_CPU(cs);
|
|
|
|
CPUXtensaState *env = &cpu->env;
|
|
|
|
|
|
|
|
qemu_log_mask(CPU_LOG_INT,
|
|
|
|
"%s: rw = %d, address = 0x%08" VADDR_PRIx ", size = %d\n",
|
|
|
|
__func__, rw, address, size);
|
|
|
|
env->sregs[EXCVADDR] = address;
|
|
|
|
env->sregs[EXCCAUSE] = rw ? STORE_PROHIBITED_CAUSE : LOAD_PROHIBITED_CAUSE;
|
|
|
|
cs->exception_index = EXC_USER;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2012-03-14 01:38:23 +01:00
|
|
|
static void reset_tlb_mmu_all_ways(CPUXtensaState *env,
|
2011-09-06 01:55:53 +02:00
|
|
|
const xtensa_tlb *tlb, xtensa_tlb_entry entry[][MAX_TLB_WAY_SIZE])
|
|
|
|
{
|
|
|
|
unsigned wi, ei;
|
|
|
|
|
|
|
|
for (wi = 0; wi < tlb->nways; ++wi) {
|
|
|
|
for (ei = 0; ei < tlb->way_size[wi]; ++ei) {
|
|
|
|
entry[wi][ei].asid = 0;
|
|
|
|
entry[wi][ei].variable = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-14 01:38:23 +01:00
|
|
|
static void reset_tlb_mmu_ways56(CPUXtensaState *env,
|
2011-09-06 01:55:53 +02:00
|
|
|
const xtensa_tlb *tlb, xtensa_tlb_entry entry[][MAX_TLB_WAY_SIZE])
|
|
|
|
{
|
|
|
|
if (!tlb->varway56) {
|
|
|
|
static const xtensa_tlb_entry way5[] = {
|
|
|
|
{
|
|
|
|
.vaddr = 0xd0000000,
|
|
|
|
.paddr = 0,
|
|
|
|
.asid = 1,
|
|
|
|
.attr = 7,
|
|
|
|
.variable = false,
|
|
|
|
}, {
|
|
|
|
.vaddr = 0xd8000000,
|
|
|
|
.paddr = 0,
|
|
|
|
.asid = 1,
|
|
|
|
.attr = 3,
|
|
|
|
.variable = false,
|
|
|
|
}
|
|
|
|
};
|
|
|
|
static const xtensa_tlb_entry way6[] = {
|
|
|
|
{
|
|
|
|
.vaddr = 0xe0000000,
|
|
|
|
.paddr = 0xf0000000,
|
|
|
|
.asid = 1,
|
|
|
|
.attr = 7,
|
|
|
|
.variable = false,
|
|
|
|
}, {
|
|
|
|
.vaddr = 0xf0000000,
|
|
|
|
.paddr = 0xf0000000,
|
|
|
|
.asid = 1,
|
|
|
|
.attr = 3,
|
|
|
|
.variable = false,
|
|
|
|
}
|
|
|
|
};
|
|
|
|
memcpy(entry[5], way5, sizeof(way5));
|
|
|
|
memcpy(entry[6], way6, sizeof(way6));
|
|
|
|
} else {
|
|
|
|
uint32_t ei;
|
|
|
|
for (ei = 0; ei < 8; ++ei) {
|
|
|
|
entry[6][ei].vaddr = ei << 29;
|
|
|
|
entry[6][ei].paddr = ei << 29;
|
|
|
|
entry[6][ei].asid = 1;
|
2011-11-22 08:59:16 +01:00
|
|
|
entry[6][ei].attr = 3;
|
2011-09-06 01:55:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-14 01:38:23 +01:00
|
|
|
static void reset_tlb_region_way0(CPUXtensaState *env,
|
2011-09-06 01:55:53 +02:00
|
|
|
xtensa_tlb_entry entry[][MAX_TLB_WAY_SIZE])
|
|
|
|
{
|
|
|
|
unsigned ei;
|
|
|
|
|
|
|
|
for (ei = 0; ei < 8; ++ei) {
|
|
|
|
entry[0][ei].vaddr = ei << 29;
|
|
|
|
entry[0][ei].paddr = ei << 29;
|
|
|
|
entry[0][ei].asid = 1;
|
|
|
|
entry[0][ei].attr = 2;
|
|
|
|
entry[0][ei].variable = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-11 18:24:49 +02:00
|
|
|
void reset_mmu(CPUXtensaState *env)
|
2011-09-06 01:55:53 +02:00
|
|
|
{
|
|
|
|
if (xtensa_option_enabled(env->config, XTENSA_OPTION_MMU)) {
|
|
|
|
env->sregs[RASID] = 0x04030201;
|
|
|
|
env->sregs[ITLBCFG] = 0;
|
|
|
|
env->sregs[DTLBCFG] = 0;
|
|
|
|
env->autorefill_idx = 0;
|
|
|
|
reset_tlb_mmu_all_ways(env, &env->config->itlb, env->itlb);
|
|
|
|
reset_tlb_mmu_all_ways(env, &env->config->dtlb, env->dtlb);
|
|
|
|
reset_tlb_mmu_ways56(env, &env->config->itlb, env->itlb);
|
|
|
|
reset_tlb_mmu_ways56(env, &env->config->dtlb, env->dtlb);
|
|
|
|
} else {
|
|
|
|
reset_tlb_region_way0(env, env->itlb);
|
|
|
|
reset_tlb_region_way0(env, env->dtlb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-14 01:38:23 +01:00
|
|
|
static unsigned get_ring(const CPUXtensaState *env, uint8_t asid)
|
2011-09-06 01:55:53 +02:00
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
for (i = 0; i < 4; ++i) {
|
|
|
|
if (((env->sregs[RASID] >> i * 8) & 0xff) == asid) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0xff;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* Lookup xtensa TLB for the given virtual address.
|
|
|
|
* See ISA, 4.6.2.2
|
|
|
|
*
|
|
|
|
* \param pwi: [out] way index
|
|
|
|
* \param pei: [out] entry index
|
|
|
|
* \param pring: [out] access ring
|
|
|
|
* \return 0 if ok, exception cause code otherwise
|
|
|
|
*/
|
2012-03-14 01:38:23 +01:00
|
|
|
int xtensa_tlb_lookup(const CPUXtensaState *env, uint32_t addr, bool dtlb,
|
2011-09-06 01:55:53 +02:00
|
|
|
uint32_t *pwi, uint32_t *pei, uint8_t *pring)
|
|
|
|
{
|
|
|
|
const xtensa_tlb *tlb = dtlb ?
|
|
|
|
&env->config->dtlb : &env->config->itlb;
|
|
|
|
const xtensa_tlb_entry (*entry)[MAX_TLB_WAY_SIZE] = dtlb ?
|
|
|
|
env->dtlb : env->itlb;
|
|
|
|
|
|
|
|
int nhits = 0;
|
|
|
|
unsigned wi;
|
|
|
|
|
|
|
|
for (wi = 0; wi < tlb->nways; ++wi) {
|
|
|
|
uint32_t vpn;
|
|
|
|
uint32_t ei;
|
|
|
|
split_tlb_entry_spec_way(env, addr, dtlb, &vpn, wi, &ei);
|
|
|
|
if (entry[wi][ei].vaddr == vpn && entry[wi][ei].asid) {
|
|
|
|
unsigned ring = get_ring(env, entry[wi][ei].asid);
|
|
|
|
if (ring < 4) {
|
|
|
|
if (++nhits > 1) {
|
|
|
|
return dtlb ?
|
|
|
|
LOAD_STORE_TLB_MULTI_HIT_CAUSE :
|
|
|
|
INST_TLB_MULTI_HIT_CAUSE;
|
|
|
|
}
|
|
|
|
*pwi = wi;
|
|
|
|
*pei = ei;
|
|
|
|
*pring = ring;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nhits ? 0 :
|
|
|
|
(dtlb ? LOAD_STORE_TLB_MISS_CAUSE : INST_TLB_MISS_CAUSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* Convert MMU ATTR to PAGE_{READ,WRITE,EXEC} mask.
|
|
|
|
* See ISA, 4.6.5.10
|
|
|
|
*/
|
|
|
|
static unsigned mmu_attr_to_access(uint32_t attr)
|
|
|
|
{
|
|
|
|
unsigned access = 0;
|
2012-12-05 04:15:20 +01:00
|
|
|
|
2011-09-06 01:55:53 +02:00
|
|
|
if (attr < 12) {
|
|
|
|
access |= PAGE_READ;
|
|
|
|
if (attr & 0x1) {
|
|
|
|
access |= PAGE_EXEC;
|
|
|
|
}
|
|
|
|
if (attr & 0x2) {
|
|
|
|
access |= PAGE_WRITE;
|
|
|
|
}
|
2012-12-05 04:15:20 +01:00
|
|
|
|
|
|
|
switch (attr & 0xc) {
|
|
|
|
case 0:
|
|
|
|
access |= PAGE_CACHE_BYPASS;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
access |= PAGE_CACHE_WB;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 8:
|
|
|
|
access |= PAGE_CACHE_WT;
|
|
|
|
break;
|
|
|
|
}
|
2011-09-06 01:55:53 +02:00
|
|
|
} else if (attr == 13) {
|
2012-12-05 04:15:20 +01:00
|
|
|
access |= PAGE_READ | PAGE_WRITE | PAGE_CACHE_ISOLATE;
|
2011-09-06 01:55:53 +02:00
|
|
|
}
|
|
|
|
return access;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* Convert region protection ATTR to PAGE_{READ,WRITE,EXEC} mask.
|
|
|
|
* See ISA, 4.6.3.3
|
|
|
|
*/
|
|
|
|
static unsigned region_attr_to_access(uint32_t attr)
|
|
|
|
{
|
2012-12-05 04:15:20 +01:00
|
|
|
static const unsigned access[16] = {
|
|
|
|
[0] = PAGE_READ | PAGE_WRITE | PAGE_CACHE_WT,
|
|
|
|
[1] = PAGE_READ | PAGE_WRITE | PAGE_EXEC | PAGE_CACHE_WT,
|
|
|
|
[2] = PAGE_READ | PAGE_WRITE | PAGE_EXEC | PAGE_CACHE_BYPASS,
|
|
|
|
[3] = PAGE_EXEC | PAGE_CACHE_WB,
|
|
|
|
[4] = PAGE_READ | PAGE_WRITE | PAGE_EXEC | PAGE_CACHE_WB,
|
|
|
|
[5] = PAGE_READ | PAGE_WRITE | PAGE_EXEC | PAGE_CACHE_WB,
|
|
|
|
[14] = PAGE_READ | PAGE_WRITE | PAGE_CACHE_ISOLATE,
|
|
|
|
};
|
|
|
|
|
|
|
|
return access[attr & 0xf];
|
2011-09-06 01:55:53 +02:00
|
|
|
}
|
|
|
|
|
2012-12-05 04:15:21 +01:00
|
|
|
/*!
|
|
|
|
* Convert cacheattr to PAGE_{READ,WRITE,EXEC} mask.
|
|
|
|
* See ISA, A.2.14 The Cache Attribute Register
|
|
|
|
*/
|
|
|
|
static unsigned cacheattr_attr_to_access(uint32_t attr)
|
|
|
|
{
|
|
|
|
static const unsigned access[16] = {
|
|
|
|
[0] = PAGE_READ | PAGE_WRITE | PAGE_CACHE_WT,
|
|
|
|
[1] = PAGE_READ | PAGE_WRITE | PAGE_EXEC | PAGE_CACHE_WT,
|
|
|
|
[2] = PAGE_READ | PAGE_WRITE | PAGE_EXEC | PAGE_CACHE_BYPASS,
|
|
|
|
[3] = PAGE_EXEC | PAGE_CACHE_WB,
|
|
|
|
[4] = PAGE_READ | PAGE_WRITE | PAGE_EXEC | PAGE_CACHE_WB,
|
|
|
|
[14] = PAGE_READ | PAGE_WRITE | PAGE_CACHE_ISOLATE,
|
|
|
|
};
|
|
|
|
|
|
|
|
return access[attr & 0xf];
|
|
|
|
}
|
|
|
|
|
2011-09-06 01:55:53 +02:00
|
|
|
static bool is_access_granted(unsigned access, int is_write)
|
|
|
|
{
|
|
|
|
switch (is_write) {
|
|
|
|
case 0:
|
|
|
|
return access & PAGE_READ;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
return access & PAGE_WRITE;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
return access & PAGE_EXEC;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-27 16:34:52 +02:00
|
|
|
static int get_pte(CPUXtensaState *env, uint32_t vaddr, uint32_t *pte);
|
2011-09-06 01:55:53 +02:00
|
|
|
|
2012-05-27 16:34:52 +02:00
|
|
|
static int get_physical_addr_mmu(CPUXtensaState *env, bool update_tlb,
|
2011-09-06 01:55:53 +02:00
|
|
|
uint32_t vaddr, int is_write, int mmu_idx,
|
2012-05-27 16:34:53 +02:00
|
|
|
uint32_t *paddr, uint32_t *page_size, unsigned *access,
|
|
|
|
bool may_lookup_pt)
|
2011-09-06 01:55:53 +02:00
|
|
|
{
|
|
|
|
bool dtlb = is_write != 2;
|
|
|
|
uint32_t wi;
|
|
|
|
uint32_t ei;
|
|
|
|
uint8_t ring;
|
2012-05-27 16:34:52 +02:00
|
|
|
uint32_t vpn;
|
|
|
|
uint32_t pte;
|
|
|
|
const xtensa_tlb_entry *entry = NULL;
|
|
|
|
xtensa_tlb_entry tmp_entry;
|
2011-09-06 01:55:53 +02:00
|
|
|
int ret = xtensa_tlb_lookup(env, vaddr, dtlb, &wi, &ei, &ring);
|
|
|
|
|
|
|
|
if ((ret == INST_TLB_MISS_CAUSE || ret == LOAD_STORE_TLB_MISS_CAUSE) &&
|
2012-05-27 16:34:53 +02:00
|
|
|
may_lookup_pt && get_pte(env, vaddr, &pte) == 0) {
|
2012-05-27 16:34:52 +02:00
|
|
|
ring = (pte >> 4) & 0x3;
|
|
|
|
wi = 0;
|
|
|
|
split_tlb_entry_spec_way(env, vaddr, dtlb, &vpn, wi, &ei);
|
|
|
|
|
|
|
|
if (update_tlb) {
|
|
|
|
wi = ++env->autorefill_idx & 0x3;
|
|
|
|
xtensa_tlb_set_entry(env, dtlb, wi, ei, vpn, pte);
|
|
|
|
env->sregs[EXCVADDR] = vaddr;
|
2015-09-21 19:37:07 +02:00
|
|
|
qemu_log_mask(CPU_LOG_MMU, "%s: autorefill(%08x): %08x -> %08x\n",
|
|
|
|
__func__, vaddr, vpn, pte);
|
2012-05-27 16:34:52 +02:00
|
|
|
} else {
|
|
|
|
xtensa_tlb_set_entry_mmu(env, &tmp_entry, dtlb, wi, ei, vpn, pte);
|
|
|
|
entry = &tmp_entry;
|
|
|
|
}
|
2011-09-06 01:55:53 +02:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
if (ret != 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-27 16:34:52 +02:00
|
|
|
if (entry == NULL) {
|
|
|
|
entry = xtensa_tlb_get_entry(env, dtlb, wi, ei);
|
|
|
|
}
|
2011-09-06 01:55:53 +02:00
|
|
|
|
|
|
|
if (ring < mmu_idx) {
|
|
|
|
return dtlb ?
|
|
|
|
LOAD_STORE_PRIVILEGE_CAUSE :
|
|
|
|
INST_FETCH_PRIVILEGE_CAUSE;
|
|
|
|
}
|
|
|
|
|
target-xtensa: fix ITLB/DTLB page protection flags
With MMU option xtensa architecture has two TLBs: ITLB and DTLB. ITLB is
only used for code access, DTLB is only for data. However TLB entries in
both TLBs have attribute field controlling write and exec access. These
bits need to be properly masked off depending on TLB type before being
used as tlb_set_page prot argument. Otherwise the following happens:
(1) ITLB entry for some PFN gets invalidated
(2) DTLB entry for the same PFN gets updated, attributes allow code
execution
(3) code at the page with that PFN is executed (possible due to step 2),
entry for the TB is written into the jump cache
(4) QEMU TLB entry for the PFN gets replaced with an entry for some
other PFN
(5) code in the TB from step 3 is executed (possible due to jump cache)
and it accesses data, for which there's no DTLB entry, causing DTLB
miss exception
(6) re-translation of the TB from step 5 is attempted, but there's no
QEMU TLB entry nor xtensa ITLB entry for that PFN, which causes ITLB
miss exception at the TB start address
(7) ITLB miss exception is handled by the guest, but execution is
resumed from the beginning of the faulting TB (the point where ITLB
miss occured), not from the point where DTLB miss occured, which is
wrong.
With that fix the above scenario causes ITLB miss exception (that used
to be step 7) at step 3, right at the beginning of the TB.
Signed-off-by: Max Filippov <jcmvbkbc@gmail.com>
Cc: qemu-stable@nongnu.org
Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
2012-12-13 01:13:41 +01:00
|
|
|
*access = mmu_attr_to_access(entry->attr) &
|
|
|
|
~(dtlb ? PAGE_EXEC : PAGE_READ | PAGE_WRITE);
|
2011-09-06 01:55:53 +02:00
|
|
|
if (!is_access_granted(*access, is_write)) {
|
|
|
|
return dtlb ?
|
|
|
|
(is_write ?
|
|
|
|
STORE_PROHIBITED_CAUSE :
|
|
|
|
LOAD_PROHIBITED_CAUSE) :
|
|
|
|
INST_FETCH_PROHIBITED_CAUSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*paddr = entry->paddr | (vaddr & ~xtensa_tlb_get_addr_mask(env, dtlb, wi));
|
|
|
|
*page_size = ~xtensa_tlb_get_addr_mask(env, dtlb, wi) + 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-27 16:34:52 +02:00
|
|
|
static int get_pte(CPUXtensaState *env, uint32_t vaddr, uint32_t *pte)
|
2011-09-06 01:55:53 +02:00
|
|
|
{
|
2014-03-09 20:02:29 +01:00
|
|
|
CPUState *cs = CPU(xtensa_env_get_cpu(env));
|
2011-09-06 01:55:53 +02:00
|
|
|
uint32_t paddr;
|
|
|
|
uint32_t page_size;
|
|
|
|
unsigned access;
|
|
|
|
uint32_t pt_vaddr =
|
|
|
|
(env->sregs[PTEVADDR] | (vaddr >> 10)) & 0xfffffffc;
|
2012-05-27 16:34:52 +02:00
|
|
|
int ret = get_physical_addr_mmu(env, false, pt_vaddr, 0, 0,
|
2012-05-27 16:34:53 +02:00
|
|
|
&paddr, &page_size, &access, false);
|
2011-09-06 01:55:53 +02:00
|
|
|
|
2015-09-21 19:37:07 +02:00
|
|
|
qemu_log_mask(CPU_LOG_MMU, "%s: trying autorefill(%08x) -> %08x\n",
|
|
|
|
__func__, vaddr, ret ? ~0 : paddr);
|
2011-09-06 01:55:53 +02:00
|
|
|
|
|
|
|
if (ret == 0) {
|
2013-11-15 14:46:38 +01:00
|
|
|
*pte = ldl_phys(cs->as, paddr);
|
2011-09-06 01:55:53 +02:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-03-14 01:38:23 +01:00
|
|
|
static int get_physical_addr_region(CPUXtensaState *env,
|
2011-09-06 01:55:53 +02:00
|
|
|
uint32_t vaddr, int is_write, int mmu_idx,
|
|
|
|
uint32_t *paddr, uint32_t *page_size, unsigned *access)
|
|
|
|
{
|
|
|
|
bool dtlb = is_write != 2;
|
|
|
|
uint32_t wi = 0;
|
|
|
|
uint32_t ei = (vaddr >> 29) & 0x7;
|
|
|
|
const xtensa_tlb_entry *entry =
|
|
|
|
xtensa_tlb_get_entry(env, dtlb, wi, ei);
|
|
|
|
|
|
|
|
*access = region_attr_to_access(entry->attr);
|
|
|
|
if (!is_access_granted(*access, is_write)) {
|
|
|
|
return dtlb ?
|
|
|
|
(is_write ?
|
|
|
|
STORE_PROHIBITED_CAUSE :
|
|
|
|
LOAD_PROHIBITED_CAUSE) :
|
|
|
|
INST_FETCH_PROHIBITED_CAUSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*paddr = entry->paddr | (vaddr & ~REGION_PAGE_MASK);
|
|
|
|
*page_size = ~REGION_PAGE_MASK + 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* Convert virtual address to physical addr.
|
|
|
|
* MMU may issue pagewalk and change xtensa autorefill TLB way entry.
|
|
|
|
*
|
|
|
|
* \return 0 if ok, exception cause code otherwise
|
|
|
|
*/
|
2012-05-27 16:34:52 +02:00
|
|
|
int xtensa_get_physical_addr(CPUXtensaState *env, bool update_tlb,
|
2011-09-06 01:55:53 +02:00
|
|
|
uint32_t vaddr, int is_write, int mmu_idx,
|
|
|
|
uint32_t *paddr, uint32_t *page_size, unsigned *access)
|
|
|
|
{
|
|
|
|
if (xtensa_option_enabled(env->config, XTENSA_OPTION_MMU)) {
|
2012-05-27 16:34:52 +02:00
|
|
|
return get_physical_addr_mmu(env, update_tlb,
|
2012-05-27 16:34:53 +02:00
|
|
|
vaddr, is_write, mmu_idx, paddr, page_size, access, true);
|
2011-09-06 01:55:53 +02:00
|
|
|
} else if (xtensa_option_bits_enabled(env->config,
|
|
|
|
XTENSA_OPTION_BIT(XTENSA_OPTION_REGION_PROTECTION) |
|
|
|
|
XTENSA_OPTION_BIT(XTENSA_OPTION_REGION_TRANSLATION))) {
|
|
|
|
return get_physical_addr_region(env, vaddr, is_write, mmu_idx,
|
|
|
|
paddr, page_size, access);
|
|
|
|
} else {
|
|
|
|
*paddr = vaddr;
|
|
|
|
*page_size = TARGET_PAGE_SIZE;
|
2012-12-05 04:15:21 +01:00
|
|
|
*access = cacheattr_attr_to_access(
|
|
|
|
env->sregs[CACHEATTR] >> ((vaddr & 0xe0000000) >> 27));
|
2011-09-06 01:55:53 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2012-01-07 17:02:40 +01:00
|
|
|
|
|
|
|
static void dump_tlb(FILE *f, fprintf_function cpu_fprintf,
|
2012-03-14 01:38:23 +01:00
|
|
|
CPUXtensaState *env, bool dtlb)
|
2012-01-07 17:02:40 +01:00
|
|
|
{
|
|
|
|
unsigned wi, ei;
|
|
|
|
const xtensa_tlb *conf =
|
|
|
|
dtlb ? &env->config->dtlb : &env->config->itlb;
|
|
|
|
unsigned (*attr_to_access)(uint32_t) =
|
|
|
|
xtensa_option_enabled(env->config, XTENSA_OPTION_MMU) ?
|
|
|
|
mmu_attr_to_access : region_attr_to_access;
|
|
|
|
|
|
|
|
for (wi = 0; wi < conf->nways; ++wi) {
|
|
|
|
uint32_t sz = ~xtensa_tlb_get_addr_mask(env, dtlb, wi) + 1;
|
|
|
|
const char *sz_text;
|
|
|
|
bool print_header = true;
|
|
|
|
|
|
|
|
if (sz >= 0x100000) {
|
2018-06-25 14:42:13 +02:00
|
|
|
sz /= MiB;
|
2012-01-07 17:02:40 +01:00
|
|
|
sz_text = "MB";
|
|
|
|
} else {
|
2018-06-25 14:42:13 +02:00
|
|
|
sz /= KiB;
|
2012-01-07 17:02:40 +01:00
|
|
|
sz_text = "KB";
|
|
|
|
}
|
|
|
|
|
|
|
|
for (ei = 0; ei < conf->way_size[wi]; ++ei) {
|
|
|
|
const xtensa_tlb_entry *entry =
|
|
|
|
xtensa_tlb_get_entry(env, dtlb, wi, ei);
|
|
|
|
|
|
|
|
if (entry->asid) {
|
2012-12-05 04:15:20 +01:00
|
|
|
static const char * const cache_text[8] = {
|
|
|
|
[PAGE_CACHE_BYPASS >> PAGE_CACHE_SHIFT] = "Bypass",
|
|
|
|
[PAGE_CACHE_WT >> PAGE_CACHE_SHIFT] = "WT",
|
|
|
|
[PAGE_CACHE_WB >> PAGE_CACHE_SHIFT] = "WB",
|
|
|
|
[PAGE_CACHE_ISOLATE >> PAGE_CACHE_SHIFT] = "Isolate",
|
|
|
|
};
|
2012-01-07 17:02:40 +01:00
|
|
|
unsigned access = attr_to_access(entry->attr);
|
2012-12-05 04:15:20 +01:00
|
|
|
unsigned cache_idx = (access & PAGE_CACHE_MASK) >>
|
|
|
|
PAGE_CACHE_SHIFT;
|
2012-01-07 17:02:40 +01:00
|
|
|
|
|
|
|
if (print_header) {
|
|
|
|
print_header = false;
|
|
|
|
cpu_fprintf(f, "Way %u (%d %s)\n", wi, sz, sz_text);
|
|
|
|
cpu_fprintf(f,
|
2012-12-05 04:15:20 +01:00
|
|
|
"\tVaddr Paddr ASID Attr RWX Cache\n"
|
|
|
|
"\t---------- ---------- ---- ---- --- -------\n");
|
2012-01-07 17:02:40 +01:00
|
|
|
}
|
|
|
|
cpu_fprintf(f,
|
2012-12-05 04:15:20 +01:00
|
|
|
"\t0x%08x 0x%08x 0x%02x 0x%02x %c%c%c %-7s\n",
|
2012-01-07 17:02:40 +01:00
|
|
|
entry->vaddr,
|
|
|
|
entry->paddr,
|
|
|
|
entry->asid,
|
|
|
|
entry->attr,
|
|
|
|
(access & PAGE_READ) ? 'R' : '-',
|
|
|
|
(access & PAGE_WRITE) ? 'W' : '-',
|
2012-12-05 04:15:20 +01:00
|
|
|
(access & PAGE_EXEC) ? 'X' : '-',
|
|
|
|
cache_text[cache_idx] ? cache_text[cache_idx] :
|
|
|
|
"Invalid");
|
2012-01-07 17:02:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-14 01:38:23 +01:00
|
|
|
void dump_mmu(FILE *f, fprintf_function cpu_fprintf, CPUXtensaState *env)
|
2012-01-07 17:02:40 +01:00
|
|
|
{
|
|
|
|
if (xtensa_option_bits_enabled(env->config,
|
|
|
|
XTENSA_OPTION_BIT(XTENSA_OPTION_REGION_PROTECTION) |
|
|
|
|
XTENSA_OPTION_BIT(XTENSA_OPTION_REGION_TRANSLATION) |
|
|
|
|
XTENSA_OPTION_BIT(XTENSA_OPTION_MMU))) {
|
|
|
|
|
|
|
|
cpu_fprintf(f, "ITLB:\n");
|
|
|
|
dump_tlb(f, cpu_fprintf, env, false);
|
|
|
|
cpu_fprintf(f, "\nDTLB:\n");
|
|
|
|
dump_tlb(f, cpu_fprintf, env, true);
|
|
|
|
} else {
|
|
|
|
cpu_fprintf(f, "No TLB for this CPU core\n");
|
|
|
|
}
|
|
|
|
}
|
2016-12-14 03:52:08 +01:00
|
|
|
|
|
|
|
void xtensa_runstall(CPUXtensaState *env, bool runstall)
|
|
|
|
{
|
|
|
|
CPUState *cpu = CPU(xtensa_env_get_cpu(env));
|
|
|
|
|
|
|
|
env->runstall = runstall;
|
|
|
|
cpu->halted = runstall;
|
|
|
|
if (runstall) {
|
|
|
|
cpu_interrupt(cpu, CPU_INTERRUPT_HALT);
|
|
|
|
} else {
|
|
|
|
cpu_reset_interrupt(cpu, CPU_INTERRUPT_HALT);
|
|
|
|
}
|
|
|
|
}
|
2017-01-25 19:54:11 +01:00
|
|
|
#endif
|