Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 | /*
* Softmmu related functions
*
* Copyright (C) 2010-2012 Guan Xuetao
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation, or any later version.
* See the COPYING file in the top-level directory.
*/
#ifdef CONFIG_USER_ONLY
#error This file only exist under softmmu circumstance
#endif
#include <cpu.h>
#undef DEBUG_UC32
#ifdef DEBUG_UC32
#define DPRINTF(fmt, ...) printf("%s: " fmt , __func__, ## __VA_ARGS__)
#else
#define DPRINTF(fmt, ...) do {} while (0)
#endif
#define SUPERPAGE_SIZE (1 << 22)
#define UC32_PAGETABLE_READ (1 << 8)
#define UC32_PAGETABLE_WRITE (1 << 7)
#define UC32_PAGETABLE_EXEC (1 << 6)
#define UC32_PAGETABLE_EXIST (1 << 2)
#define PAGETABLE_TYPE(x) ((x) & 3)
/* Map CPU modes onto saved register banks. */
static inline int bank_number(CPUUniCore32State *env, int mode)
{
UniCore32CPU *cpu = uc32_env_get_cpu(env);
switch (mode) {
case ASR_MODE_USER:
case ASR_MODE_SUSR:
return 0;
case ASR_MODE_PRIV:
return 1;
case ASR_MODE_TRAP:
return 2;
case ASR_MODE_EXTN:
return 3;
case ASR_MODE_INTR:
return 4;
}
cpu_abort(CPU(cpu), "Bad mode %x\n", mode);
return -1;
}
void switch_mode(CPUUniCore32State *env, int mode)
{
int old_mode;
int i;
old_mode = env->uncached_asr & ASR_M;
if (mode == old_mode) {
return;
}
i = bank_number(env, old_mode);
env->banked_r29[i] = env->regs[29];
env->banked_r30[i] = env->regs[30];
env->banked_bsr[i] = env->bsr;
i = bank_number(env, mode);
env->regs[29] = env->banked_r29[i];
env->regs[30] = env->banked_r30[i];
env->bsr = env->banked_bsr[i];
}
/* Handle a CPU exception. */
void uc32_cpu_do_interrupt(CPUState *cs)
{
UniCore32CPU *cpu = UNICORE32_CPU(cs);
CPUUniCore32State *env = &cpu->env;
uint32_t addr;
int new_mode;
switch (cs->exception_index) {
case UC32_EXCP_PRIV:
new_mode = ASR_MODE_PRIV;
addr = 0x08;
break;
case UC32_EXCP_ITRAP:
DPRINTF("itrap happened at %x\n", env->regs[31]);
new_mode = ASR_MODE_TRAP;
addr = 0x0c;
break;
case UC32_EXCP_DTRAP:
DPRINTF("dtrap happened at %x\n", env->regs[31]);
new_mode = ASR_MODE_TRAP;
addr = 0x10;
break;
case UC32_EXCP_INTR:
new_mode = ASR_MODE_INTR;
addr = 0x18;
break;
default:
cpu_abort(cs, "Unhandled exception 0x%x\n", cs->exception_index);
return;
}
/* High vectors. */
if (env->cp0.c1_sys & (1 << 13)) {
addr += 0xffff0000;
}
switch_mode(env, new_mode);
env->bsr = cpu_asr_read(env);
env->uncached_asr = (env->uncached_asr & ~ASR_M) | new_mode;
env->uncached_asr |= ASR_I;
/* The PC already points to the proper instruction. */
env->regs[30] = env->regs[31];
env->regs[31] = addr;
cs->interrupt_request |= CPU_INTERRUPT_EXITTB;
}
static int get_phys_addr_ucv2(CPUUniCore32State *env, uint32_t address,
int access_type, int is_user, uint32_t *phys_ptr, int *prot,
target_ulong *page_size)
{
UniCore32CPU *cpu = uc32_env_get_cpu(env);
CPUState *cs = CPU(cpu);
int code;
uint32_t table;
uint32_t desc;
uint32_t phys_addr;
/* Pagetable walk. */
/* Lookup l1 descriptor. */
table = env->cp0.c2_base & 0xfffff000;
table |= (address >> 20) & 0xffc;
desc = ldl_phys(cs->as, table);
code = 0;
switch (PAGETABLE_TYPE(desc)) {
case 3:
/* Superpage */
if (!(desc & UC32_PAGETABLE_EXIST)) {
code = 0x0b; /* superpage miss */
goto do_fault;
}
phys_addr = (desc & 0xffc00000) | (address & 0x003fffff);
*page_size = SUPERPAGE_SIZE;
break;
case 0:
/* Lookup l2 entry. */
if (is_user) {
DPRINTF("PGD address %x, desc %x\n", table, desc);
}
if (!(desc & UC32_PAGETABLE_EXIST)) {
code = 0x05; /* second pagetable miss */
goto do_fault;
}
table = (desc & 0xfffff000) | ((address >> 10) & 0xffc);
desc = ldl_phys(cs->as, table);
/* 4k page. */
if (is_user) {
DPRINTF("PTE address %x, desc %x\n", table, desc);
}
if (!(desc & UC32_PAGETABLE_EXIST)) {
code = 0x08; /* page miss */
goto do_fault;
}
switch (PAGETABLE_TYPE(desc)) {
case 0:
phys_addr = (desc & 0xfffff000) | (address & 0xfff);
*page_size = TARGET_PAGE_SIZE;
break;
default:
cpu_abort(CPU(cpu), "wrong page type!");
}
break;
default:
cpu_abort(CPU(cpu), "wrong page type!");
}
*phys_ptr = phys_addr;
*prot = 0;
/* Check access permissions. */
if (desc & UC32_PAGETABLE_READ) {
*prot |= PAGE_READ;
} else {
if (is_user && (access_type == 0)) {
code = 0x11; /* access unreadable area */
goto do_fault;
}
}
if (desc & UC32_PAGETABLE_WRITE) {
*prot |= PAGE_WRITE;
} else {
if (is_user && (access_type == 1)) {
code = 0x12; /* access unwritable area */
goto do_fault;
}
}
if (desc & UC32_PAGETABLE_EXEC) {
*prot |= PAGE_EXEC;
} else {
if (is_user && (access_type == 2)) {
code = 0x13; /* access unexecutable area */
goto do_fault;
}
}
do_fault:
return code;
}
int uc32_cpu_handle_mmu_fault(CPUState *cs, vaddr address,
int access_type, int mmu_idx)
{
UniCore32CPU *cpu = UNICORE32_CPU(cs);
CPUUniCore32State *env = &cpu->env;
uint32_t phys_addr;
target_ulong page_size;
int prot;
int ret, is_user;
ret = 1;
is_user = mmu_idx == MMU_USER_IDX;
if ((env->cp0.c1_sys & 1) == 0) {
/* MMU disabled. */
phys_addr = address;
prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
page_size = TARGET_PAGE_SIZE;
ret = 0;
} else {
if ((address & (1 << 31)) || (is_user)) {
ret = get_phys_addr_ucv2(env, address, access_type, is_user,
&phys_addr, &prot, &page_size);
if (is_user) {
DPRINTF("user space access: ret %x, address %" VADDR_PRIx ", "
"access_type %x, phys_addr %x, prot %x\n",
ret, address, access_type, phys_addr, prot);
}
} else {
/*IO memory */
phys_addr = address | (1 << 31);
prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
page_size = TARGET_PAGE_SIZE;
ret = 0;
}
}
if (ret == 0) {
/* Map a single page. */
phys_addr &= TARGET_PAGE_MASK;
address &= TARGET_PAGE_MASK;
tlb_set_page(cs, address, phys_addr, prot, mmu_idx, page_size);
return 0;
}
env->cp0.c3_faultstatus = ret;
env->cp0.c4_faultaddr = address;
if (access_type == 2) {
cs->exception_index = UC32_EXCP_ITRAP;
} else {
cs->exception_index = UC32_EXCP_DTRAP;
}
return ret;
}
hwaddr uc32_cpu_get_phys_page_debug(CPUState *cs, vaddr addr)
{
UniCore32CPU *cpu = UNICORE32_CPU(cs);
cpu_abort(CPU(cpu), "%s not supported yet\n", __func__);
return addr;
}
|