]>
git.proxmox.com Git - mirror_qemu.git/blob - target-mips/helper.c
2 * MIPS emulation helpers for qemu.
4 * Copyright (c) 2004-2005 Jocelyn Mayer
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
39 /* no MMU emulation */
40 int no_mmu_map_address (CPUState
*env
, target_ulong
*physical
, int *prot
,
41 target_ulong address
, int rw
, int access_type
)
44 *prot
= PAGE_READ
| PAGE_WRITE
;
48 /* fixed mapping MMU emulation */
49 int fixed_mmu_map_address (CPUState
*env
, target_ulong
*physical
, int *prot
,
50 target_ulong address
, int rw
, int access_type
)
52 if (address
<= (int32_t)0x7FFFFFFFUL
) {
53 if (!(env
->CP0_Status
& (1 << CP0St_ERL
)))
54 *physical
= address
+ 0x40000000UL
;
57 } else if (address
<= (int32_t)0xBFFFFFFFUL
)
58 *physical
= address
& 0x1FFFFFFF;
62 *prot
= PAGE_READ
| PAGE_WRITE
;
66 /* MIPS32/MIPS64 R4000-style MMU emulation */
67 int r4k_map_address (CPUState
*env
, target_ulong
*physical
, int *prot
,
68 target_ulong address
, int rw
, int access_type
)
70 uint8_t ASID
= env
->CP0_EntryHi
& 0xFF;
73 for (i
= 0; i
< env
->tlb
->tlb_in_use
; i
++) {
74 r4k_tlb_t
*tlb
= &env
->tlb
->mmu
.r4k
.tlb
[i
];
75 /* 1k pages are not supported. */
76 target_ulong mask
= tlb
->PageMask
| ~(TARGET_PAGE_MASK
<< 1);
77 target_ulong tag
= address
& ~mask
;
78 target_ulong VPN
= tlb
->VPN
& ~mask
;
79 #if defined(TARGET_MIPS64)
83 /* Check ASID, virtual page number & size */
84 if ((tlb
->G
== 1 || tlb
->ASID
== ASID
) && VPN
== tag
) {
86 int n
= !!(address
& mask
& ~(mask
>> 1));
87 /* Check access rights */
88 if (!(n
? tlb
->V1
: tlb
->V0
))
89 return TLBRET_INVALID
;
90 if (rw
== 0 || (n
? tlb
->D1
: tlb
->D0
)) {
91 *physical
= tlb
->PFN
[n
] | (address
& (mask
>> 1));
93 if (n
? tlb
->D1
: tlb
->D0
)
100 return TLBRET_NOMATCH
;
103 static int get_physical_address (CPUState
*env
, target_ulong
*physical
,
104 int *prot
, target_ulong address
,
105 int rw
, int access_type
)
107 /* User mode can only access useg/xuseg */
108 int user_mode
= (env
->hflags
& MIPS_HFLAG_MODE
) == MIPS_HFLAG_UM
;
109 int supervisor_mode
= (env
->hflags
& MIPS_HFLAG_MODE
) == MIPS_HFLAG_SM
;
110 int kernel_mode
= !user_mode
&& !supervisor_mode
;
111 #if defined(TARGET_MIPS64)
112 int UX
= (env
->CP0_Status
& (1 << CP0St_UX
)) != 0;
113 int SX
= (env
->CP0_Status
& (1 << CP0St_SX
)) != 0;
114 int KX
= (env
->CP0_Status
& (1 << CP0St_KX
)) != 0;
116 int ret
= TLBRET_MATCH
;
120 fprintf(logfile
, "user mode %d h %08x\n",
121 user_mode
, env
->hflags
);
125 if (address
<= (int32_t)0x7FFFFFFFUL
) {
127 if (env
->CP0_Status
& (1 << CP0St_ERL
)) {
128 *physical
= address
& 0xFFFFFFFF;
129 *prot
= PAGE_READ
| PAGE_WRITE
;
131 ret
= env
->tlb
->map_address(env
, physical
, prot
, address
, rw
, access_type
);
133 #if defined(TARGET_MIPS64)
134 } else if (address
< 0x4000000000000000ULL
) {
136 if (UX
&& address
<= (0x3FFFFFFFFFFFFFFFULL
& env
->SEGMask
)) {
137 ret
= env
->tlb
->map_address(env
, physical
, prot
, address
, rw
, access_type
);
139 ret
= TLBRET_BADADDR
;
141 } else if (address
< 0x8000000000000000ULL
) {
143 if ((supervisor_mode
|| kernel_mode
) &&
144 SX
&& address
<= (0x7FFFFFFFFFFFFFFFULL
& env
->SEGMask
)) {
145 ret
= env
->tlb
->map_address(env
, physical
, prot
, address
, rw
, access_type
);
147 ret
= TLBRET_BADADDR
;
149 } else if (address
< 0xC000000000000000ULL
) {
151 if (kernel_mode
&& KX
&&
152 (address
& 0x07FFFFFFFFFFFFFFULL
) <= env
->PAMask
) {
153 *physical
= address
& env
->PAMask
;
154 *prot
= PAGE_READ
| PAGE_WRITE
;
156 ret
= TLBRET_BADADDR
;
158 } else if (address
< 0xFFFFFFFF80000000ULL
) {
160 if (kernel_mode
&& KX
&&
161 address
<= (0xFFFFFFFF7FFFFFFFULL
& env
->SEGMask
)) {
162 ret
= env
->tlb
->map_address(env
, physical
, prot
, address
, rw
, access_type
);
164 ret
= TLBRET_BADADDR
;
167 } else if (address
< (int32_t)0xA0000000UL
) {
170 *physical
= address
- (int32_t)0x80000000UL
;
171 *prot
= PAGE_READ
| PAGE_WRITE
;
173 ret
= TLBRET_BADADDR
;
175 } else if (address
< (int32_t)0xC0000000UL
) {
178 *physical
= address
- (int32_t)0xA0000000UL
;
179 *prot
= PAGE_READ
| PAGE_WRITE
;
181 ret
= TLBRET_BADADDR
;
183 } else if (address
< (int32_t)0xE0000000UL
) {
185 if (supervisor_mode
|| kernel_mode
) {
186 ret
= env
->tlb
->map_address(env
, physical
, prot
, address
, rw
, access_type
);
188 ret
= TLBRET_BADADDR
;
192 /* XXX: debug segment is not emulated */
194 ret
= env
->tlb
->map_address(env
, physical
, prot
, address
, rw
, access_type
);
196 ret
= TLBRET_BADADDR
;
201 fprintf(logfile
, TARGET_FMT_lx
" %d %d => " TARGET_FMT_lx
" %d (%d)\n",
202 address
, rw
, access_type
, *physical
, *prot
, ret
);
209 #if defined(CONFIG_USER_ONLY)
210 target_phys_addr_t
cpu_get_phys_page_debug(CPUState
*env
, target_ulong addr
)
215 target_phys_addr_t
cpu_get_phys_page_debug(CPUState
*env
, target_ulong addr
)
217 target_ulong phys_addr
;
220 if (get_physical_address(env
, &phys_addr
, &prot
, addr
, 0, ACCESS_INT
) != 0)
225 void cpu_mips_init_mmu (CPUState
*env
)
228 #endif /* !defined(CONFIG_USER_ONLY) */
230 int cpu_mips_handle_mmu_fault (CPUState
*env
, target_ulong address
, int rw
,
231 int mmu_idx
, int is_softmmu
)
233 target_ulong physical
;
235 int exception
= 0, error_code
= 0;
241 cpu_dump_state(env
, logfile
, fprintf
, 0);
243 fprintf(logfile
, "%s pc " TARGET_FMT_lx
" ad " TARGET_FMT_lx
" rw %d mmu_idx %d smmu %d\n",
244 __func__
, env
->PC
[env
->current_tc
], address
, rw
, mmu_idx
, is_softmmu
);
250 /* XXX: put correct access by using cpu_restore_state()
252 access_type
= ACCESS_INT
;
253 if (env
->user_mode_only
) {
254 /* user mode only emulation */
255 ret
= TLBRET_NOMATCH
;
258 ret
= get_physical_address(env
, &physical
, &prot
,
259 address
, rw
, access_type
);
261 fprintf(logfile
, "%s address=" TARGET_FMT_lx
" ret %d physical " TARGET_FMT_lx
" prot %d\n",
262 __func__
, address
, ret
, physical
, prot
);
264 if (ret
== TLBRET_MATCH
) {
265 ret
= tlb_set_page(env
, address
& TARGET_PAGE_MASK
,
266 physical
& TARGET_PAGE_MASK
, prot
,
267 mmu_idx
, is_softmmu
);
268 } else if (ret
< 0) {
273 /* Reference to kernel address from user mode or supervisor mode */
274 /* Reference to supervisor address from user mode */
276 exception
= EXCP_AdES
;
278 exception
= EXCP_AdEL
;
281 /* No TLB match for a mapped address */
283 exception
= EXCP_TLBS
;
285 exception
= EXCP_TLBL
;
289 /* TLB match with no valid bit */
291 exception
= EXCP_TLBS
;
293 exception
= EXCP_TLBL
;
296 /* TLB match but 'D' bit is cleared */
297 exception
= EXCP_LTLBL
;
301 /* Raise exception */
302 env
->CP0_BadVAddr
= address
;
303 env
->CP0_Context
= (env
->CP0_Context
& ~0x007fffff) |
304 ((address
>> 9) & 0x007ffff0);
306 (env
->CP0_EntryHi
& 0xFF) | (address
& (TARGET_PAGE_MASK
<< 1));
307 #if defined(TARGET_MIPS64)
308 env
->CP0_EntryHi
&= env
->SEGMask
;
309 env
->CP0_XContext
= (env
->CP0_XContext
& ((~0ULL) << (env
->SEGBITS
- 7))) |
310 ((address
& 0xC00000000000ULL
) >> (env
->SEGBITS
- 9)) |
311 ((address
& ((1ULL << env
->SEGBITS
) - 1) & 0xFFFFFFFFFFFFE000ULL
) >> 9);
313 env
->exception_index
= exception
;
314 env
->error_code
= error_code
;
321 #if defined(CONFIG_USER_ONLY)
322 void do_interrupt (CPUState
*env
)
324 env
->exception_index
= EXCP_NONE
;
327 void do_interrupt (CPUState
*env
)
332 if (logfile
&& env
->exception_index
!= EXCP_EXT_INTERRUPT
) {
333 fprintf(logfile
, "%s enter: PC " TARGET_FMT_lx
" EPC " TARGET_FMT_lx
" cause %d excp %d\n",
334 __func__
, env
->PC
[env
->current_tc
], env
->CP0_EPC
, cause
, env
->exception_index
);
336 if (env
->exception_index
== EXCP_EXT_INTERRUPT
&&
337 (env
->hflags
& MIPS_HFLAG_DM
))
338 env
->exception_index
= EXCP_DINT
;
340 switch (env
->exception_index
) {
342 env
->CP0_Debug
|= 1 << CP0DB_DSS
;
343 /* Debug single step cannot be raised inside a delay slot and
344 * resume will always occur on the next instruction
345 * (but we assume the pc has always been updated during
348 env
->CP0_DEPC
= env
->PC
[env
->current_tc
];
349 goto enter_debug_mode
;
351 env
->CP0_Debug
|= 1 << CP0DB_DINT
;
354 env
->CP0_Debug
|= 1 << CP0DB_DIB
;
357 env
->CP0_Debug
|= 1 << CP0DB_DBp
;
360 env
->CP0_Debug
|= 1 << CP0DB_DDBS
;
363 env
->CP0_Debug
|= 1 << CP0DB_DDBL
;
365 if (env
->hflags
& MIPS_HFLAG_BMASK
) {
366 /* If the exception was raised from a delay slot,
367 come back to the jump. */
368 env
->CP0_DEPC
= env
->PC
[env
->current_tc
] - 4;
369 env
->hflags
&= ~MIPS_HFLAG_BMASK
;
371 env
->CP0_DEPC
= env
->PC
[env
->current_tc
];
374 env
->hflags
|= MIPS_HFLAG_DM
| MIPS_HFLAG_64
| MIPS_HFLAG_CP0
;
375 env
->hflags
&= ~(MIPS_HFLAG_KSU
);
376 /* EJTAG probe trap enable is not implemented... */
377 if (!(env
->CP0_Status
& (1 << CP0St_EXL
)))
378 env
->CP0_Cause
&= ~(1 << CP0Ca_BD
);
379 env
->PC
[env
->current_tc
] = (int32_t)0xBFC00480;
385 env
->CP0_Status
|= (1 << CP0St_SR
);
386 memset(env
->CP0_WatchLo
, 0, sizeof(*env
->CP0_WatchLo
));
389 env
->CP0_Status
|= (1 << CP0St_NMI
);
391 if (env
->hflags
& MIPS_HFLAG_BMASK
) {
392 /* If the exception was raised from a delay slot,
393 come back to the jump. */
394 env
->CP0_ErrorEPC
= env
->PC
[env
->current_tc
] - 4;
395 env
->hflags
&= ~MIPS_HFLAG_BMASK
;
397 env
->CP0_ErrorEPC
= env
->PC
[env
->current_tc
];
399 env
->CP0_Status
|= (1 << CP0St_ERL
) | (1 << CP0St_BEV
);
400 env
->hflags
|= MIPS_HFLAG_64
| MIPS_HFLAG_CP0
;
401 env
->hflags
&= ~(MIPS_HFLAG_KSU
);
402 if (!(env
->CP0_Status
& (1 << CP0St_EXL
)))
403 env
->CP0_Cause
&= ~(1 << CP0Ca_BD
);
404 env
->PC
[env
->current_tc
] = (int32_t)0xBFC00000;
409 case EXCP_EXT_INTERRUPT
:
411 if (env
->CP0_Cause
& (1 << CP0Ca_IV
))
416 /* XXX: TODO: manage defered watch exceptions */
426 if (env
->error_code
== 1 && !(env
->CP0_Status
& (1 << CP0St_EXL
))) {
427 #if defined(TARGET_MIPS64)
428 int R
= env
->CP0_BadVAddr
>> 62;
429 int UX
= (env
->CP0_Status
& (1 << CP0St_UX
)) != 0;
430 int SX
= (env
->CP0_Status
& (1 << CP0St_SX
)) != 0;
431 int KX
= (env
->CP0_Status
& (1 << CP0St_KX
)) != 0;
433 if ((R
== 0 && UX
) || (R
== 1 && SX
) || (R
== 3 && KX
))
457 env
->CP0_Cause
= (env
->CP0_Cause
& ~(0x3 << CP0Ca_CE
)) |
458 (env
->error_code
<< CP0Ca_CE
);
474 if (env
->error_code
== 1 && !(env
->CP0_Status
& (1 << CP0St_EXL
))) {
475 #if defined(TARGET_MIPS64)
476 int R
= env
->CP0_BadVAddr
>> 62;
477 int UX
= (env
->CP0_Status
& (1 << CP0St_UX
)) != 0;
478 int SX
= (env
->CP0_Status
& (1 << CP0St_SX
)) != 0;
479 int KX
= (env
->CP0_Status
& (1 << CP0St_KX
)) != 0;
481 if ((R
== 0 && UX
) || (R
== 1 && SX
) || (R
== 3 && KX
))
491 if (!(env
->CP0_Status
& (1 << CP0St_EXL
))) {
492 if (env
->hflags
& MIPS_HFLAG_BMASK
) {
493 /* If the exception was raised from a delay slot,
494 come back to the jump. */
495 env
->CP0_EPC
= env
->PC
[env
->current_tc
] - 4;
496 env
->CP0_Cause
|= (1 << CP0Ca_BD
);
498 env
->CP0_EPC
= env
->PC
[env
->current_tc
];
499 env
->CP0_Cause
&= ~(1 << CP0Ca_BD
);
501 env
->CP0_Status
|= (1 << CP0St_EXL
);
502 env
->hflags
|= MIPS_HFLAG_64
| MIPS_HFLAG_CP0
;
503 env
->hflags
&= ~(MIPS_HFLAG_KSU
);
505 env
->hflags
&= ~MIPS_HFLAG_BMASK
;
506 if (env
->CP0_Status
& (1 << CP0St_BEV
)) {
507 env
->PC
[env
->current_tc
] = (int32_t)0xBFC00200;
509 env
->PC
[env
->current_tc
] = (int32_t)(env
->CP0_EBase
& ~0x3ff);
511 env
->PC
[env
->current_tc
] += offset
;
512 env
->CP0_Cause
= (env
->CP0_Cause
& ~(0x1f << CP0Ca_EC
)) | (cause
<< CP0Ca_EC
);
516 fprintf(logfile
, "Invalid MIPS exception %d. Exiting\n",
517 env
->exception_index
);
519 printf("Invalid MIPS exception %d. Exiting\n", env
->exception_index
);
522 if (logfile
&& env
->exception_index
!= EXCP_EXT_INTERRUPT
) {
523 fprintf(logfile
, "%s: PC " TARGET_FMT_lx
" EPC " TARGET_FMT_lx
" cause %d excp %d\n"
524 " S %08x C %08x A " TARGET_FMT_lx
" D " TARGET_FMT_lx
"\n",
525 __func__
, env
->PC
[env
->current_tc
], env
->CP0_EPC
, cause
, env
->exception_index
,
526 env
->CP0_Status
, env
->CP0_Cause
, env
->CP0_BadVAddr
,
529 env
->exception_index
= EXCP_NONE
;
531 #endif /* !defined(CONFIG_USER_ONLY) */
533 void r4k_invalidate_tlb (CPUState
*env
, int idx
, int use_extra
)
538 uint8_t ASID
= env
->CP0_EntryHi
& 0xFF;
541 tlb
= &env
->tlb
->mmu
.r4k
.tlb
[idx
];
542 /* The qemu TLB is flushed when the ASID changes, so no need to
543 flush these entries again. */
544 if (tlb
->G
== 0 && tlb
->ASID
!= ASID
) {
548 if (use_extra
&& env
->tlb
->tlb_in_use
< MIPS_TLB_MAX
) {
549 /* For tlbwr, we can shadow the discarded entry into
550 a new (fake) TLB entry, as long as the guest can not
551 tell that it's there. */
552 env
->tlb
->mmu
.r4k
.tlb
[env
->tlb
->tlb_in_use
] = *tlb
;
553 env
->tlb
->tlb_in_use
++;
557 /* 1k pages are not supported. */
558 mask
= tlb
->PageMask
| ~(TARGET_PAGE_MASK
<< 1);
560 addr
= tlb
->VPN
& ~mask
;
561 #if defined(TARGET_MIPS64)
562 if (addr
>= (0xFFFFFFFF80000000ULL
& env
->SEGMask
)) {
563 addr
|= 0x3FFFFF0000000000ULL
;
566 end
= addr
| (mask
>> 1);
568 tlb_flush_page (env
, addr
);
569 addr
+= TARGET_PAGE_SIZE
;
573 addr
= (tlb
->VPN
& ~mask
) | ((mask
>> 1) + 1);
574 #if defined(TARGET_MIPS64)
575 if (addr
>= (0xFFFFFFFF80000000ULL
& env
->SEGMask
)) {
576 addr
|= 0x3FFFFF0000000000ULL
;
581 tlb_flush_page (env
, addr
);
582 addr
+= TARGET_PAGE_SIZE
;