]>
git.proxmox.com Git - qemu.git/blob - target-sparc/ldst_helper.c
2 * Helpers for loads and stores
4 * Copyright (c) 2003-2005 Fabrice Bellard
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, see <http://www.gnu.org/licenses/>.
25 //#define DEBUG_UNALIGNED
26 //#define DEBUG_UNASSIGNED
28 //#define DEBUG_CACHE_CONTROL
31 #define DPRINTF_MMU(fmt, ...) \
32 do { printf("MMU: " fmt , ## __VA_ARGS__); } while (0)
34 #define DPRINTF_MMU(fmt, ...) do {} while (0)
38 #define DPRINTF_MXCC(fmt, ...) \
39 do { printf("MXCC: " fmt , ## __VA_ARGS__); } while (0)
41 #define DPRINTF_MXCC(fmt, ...) do {} while (0)
45 #define DPRINTF_ASI(fmt, ...) \
46 do { printf("ASI: " fmt , ## __VA_ARGS__); } while (0)
49 #ifdef DEBUG_CACHE_CONTROL
50 #define DPRINTF_CACHE_CONTROL(fmt, ...) \
51 do { printf("CACHE_CONTROL: " fmt , ## __VA_ARGS__); } while (0)
53 #define DPRINTF_CACHE_CONTROL(fmt, ...) do {} while (0)
58 #define AM_CHECK(env1) ((env1)->pstate & PS_AM)
60 #define AM_CHECK(env1) (1)
64 #define QT0 (env->qt0)
65 #define QT1 (env->qt1)
67 #if defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY)
68 /* Calculates TSB pointer value for fault page size 8k or 64k */
69 static uint64_t ultrasparc_tsb_pointer(uint64_t tsb_register
,
70 uint64_t tag_access_register
,
73 uint64_t tsb_base
= tsb_register
& ~0x1fffULL
;
74 int tsb_split
= (tsb_register
& 0x1000ULL
) ? 1 : 0;
75 int tsb_size
= tsb_register
& 0xf;
77 /* discard lower 13 bits which hold tag access context */
78 uint64_t tag_access_va
= tag_access_register
& ~0x1fffULL
;
80 /* now reorder bits */
81 uint64_t tsb_base_mask
= ~0x1fffULL
;
82 uint64_t va
= tag_access_va
;
84 /* move va bits to correct position */
85 if (page_size
== 8*1024) {
87 } else if (page_size
== 64*1024) {
92 tsb_base_mask
<<= tsb_size
;
95 /* calculate tsb_base mask and adjust va if split is in use */
97 if (page_size
== 8*1024) {
98 va
&= ~(1ULL << (13 + tsb_size
));
99 } else if (page_size
== 64*1024) {
100 va
|= (1ULL << (13 + tsb_size
));
105 return ((tsb_base
& tsb_base_mask
) | (va
& ~tsb_base_mask
)) & ~0xfULL
;
108 /* Calculates tag target register value by reordering bits
109 in tag access register */
110 static uint64_t ultrasparc_tag_target(uint64_t tag_access_register
)
112 return ((tag_access_register
& 0x1fff) << 48) | (tag_access_register
>> 22);
115 static void replace_tlb_entry(SparcTLBEntry
*tlb
,
116 uint64_t tlb_tag
, uint64_t tlb_tte
,
119 target_ulong mask
, size
, va
, offset
;
121 /* flush page range if translation is valid */
122 if (TTE_IS_VALID(tlb
->tte
)) {
124 mask
= 0xffffffffffffe000ULL
;
125 mask
<<= 3 * ((tlb
->tte
>> 61) & 3);
128 va
= tlb
->tag
& mask
;
130 for (offset
= 0; offset
< size
; offset
+= TARGET_PAGE_SIZE
) {
131 tlb_flush_page(env1
, va
+ offset
);
139 static void demap_tlb(SparcTLBEntry
*tlb
, target_ulong demap_addr
,
140 const char *strmmu
, CPUSPARCState
*env1
)
146 int is_demap_context
= (demap_addr
>> 6) & 1;
149 switch ((demap_addr
>> 4) & 3) {
150 case 0: /* primary */
151 context
= env1
->dmmu
.mmu_primary_context
;
153 case 1: /* secondary */
154 context
= env1
->dmmu
.mmu_secondary_context
;
156 case 2: /* nucleus */
159 case 3: /* reserved */
164 for (i
= 0; i
< 64; i
++) {
165 if (TTE_IS_VALID(tlb
[i
].tte
)) {
167 if (is_demap_context
) {
168 /* will remove non-global entries matching context value */
169 if (TTE_IS_GLOBAL(tlb
[i
].tte
) ||
170 !tlb_compare_context(&tlb
[i
], context
)) {
175 will remove any entry matching VA */
176 mask
= 0xffffffffffffe000ULL
;
177 mask
<<= 3 * ((tlb
[i
].tte
>> 61) & 3);
179 if (!compare_masked(demap_addr
, tlb
[i
].tag
, mask
)) {
183 /* entry should be global or matching context value */
184 if (!TTE_IS_GLOBAL(tlb
[i
].tte
) &&
185 !tlb_compare_context(&tlb
[i
], context
)) {
190 replace_tlb_entry(&tlb
[i
], 0, 0, env1
);
192 DPRINTF_MMU("%s demap invalidated entry [%02u]\n", strmmu
, i
);
193 dump_mmu(stdout
, fprintf
, env1
);
199 static void replace_tlb_1bit_lru(SparcTLBEntry
*tlb
,
200 uint64_t tlb_tag
, uint64_t tlb_tte
,
201 const char *strmmu
, CPUSPARCState
*env1
)
203 unsigned int i
, replace_used
;
205 /* Try replacing invalid entry */
206 for (i
= 0; i
< 64; i
++) {
207 if (!TTE_IS_VALID(tlb
[i
].tte
)) {
208 replace_tlb_entry(&tlb
[i
], tlb_tag
, tlb_tte
, env1
);
210 DPRINTF_MMU("%s lru replaced invalid entry [%i]\n", strmmu
, i
);
211 dump_mmu(stdout
, fprintf
, env1
);
217 /* All entries are valid, try replacing unlocked entry */
219 for (replace_used
= 0; replace_used
< 2; ++replace_used
) {
221 /* Used entries are not replaced on first pass */
223 for (i
= 0; i
< 64; i
++) {
224 if (!TTE_IS_LOCKED(tlb
[i
].tte
) && !TTE_IS_USED(tlb
[i
].tte
)) {
226 replace_tlb_entry(&tlb
[i
], tlb_tag
, tlb_tte
, env1
);
228 DPRINTF_MMU("%s lru replaced unlocked %s entry [%i]\n",
229 strmmu
, (replace_used
? "used" : "unused"), i
);
230 dump_mmu(stdout
, fprintf
, env1
);
236 /* Now reset used bit and search for unused entries again */
238 for (i
= 0; i
< 64; i
++) {
239 TTE_SET_UNUSED(tlb
[i
].tte
);
244 DPRINTF_MMU("%s lru replacement failed: no entries available\n", strmmu
);
251 static inline target_ulong
address_mask(CPUSPARCState
*env1
, target_ulong addr
)
253 #ifdef TARGET_SPARC64
254 if (AM_CHECK(env1
)) {
255 addr
&= 0xffffffffULL
;
261 /* returns true if access using this ASI is to have address translated by MMU
262 otherwise access is to raw physical address */
263 static inline int is_translating_asi(int asi
)
265 #ifdef TARGET_SPARC64
266 /* Ultrasparc IIi translating asi
267 - note this list is defined by cpu implementation
283 /* TODO: check sparc32 bits */
288 static inline target_ulong
asi_address_mask(CPUSPARCState
*env
,
289 int asi
, target_ulong addr
)
291 if (is_translating_asi(asi
)) {
292 return address_mask(env
, addr
);
298 void helper_check_align(CPUSPARCState
*env
, target_ulong addr
, uint32_t align
)
301 #ifdef DEBUG_UNALIGNED
302 printf("Unaligned access to 0x" TARGET_FMT_lx
" from 0x" TARGET_FMT_lx
303 "\n", addr
, env
->pc
);
305 helper_raise_exception(env
, TT_UNALIGNED
);
309 #if !defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY) && \
311 static void dump_mxcc(CPUSPARCState
*env
)
313 printf("mxccdata: %016" PRIx64
" %016" PRIx64
" %016" PRIx64
" %016" PRIx64
315 env
->mxccdata
[0], env
->mxccdata
[1],
316 env
->mxccdata
[2], env
->mxccdata
[3]);
317 printf("mxccregs: %016" PRIx64
" %016" PRIx64
" %016" PRIx64
" %016" PRIx64
319 " %016" PRIx64
" %016" PRIx64
" %016" PRIx64
" %016" PRIx64
321 env
->mxccregs
[0], env
->mxccregs
[1],
322 env
->mxccregs
[2], env
->mxccregs
[3],
323 env
->mxccregs
[4], env
->mxccregs
[5],
324 env
->mxccregs
[6], env
->mxccregs
[7]);
328 #if (defined(TARGET_SPARC64) || !defined(CONFIG_USER_ONLY)) \
329 && defined(DEBUG_ASI)
330 static void dump_asi(const char *txt
, target_ulong addr
, int asi
, int size
,
335 DPRINTF_ASI("%s "TARGET_FMT_lx
" asi 0x%02x = %02" PRIx64
"\n", txt
,
336 addr
, asi
, r1
& 0xff);
339 DPRINTF_ASI("%s "TARGET_FMT_lx
" asi 0x%02x = %04" PRIx64
"\n", txt
,
340 addr
, asi
, r1
& 0xffff);
343 DPRINTF_ASI("%s "TARGET_FMT_lx
" asi 0x%02x = %08" PRIx64
"\n", txt
,
344 addr
, asi
, r1
& 0xffffffff);
347 DPRINTF_ASI("%s "TARGET_FMT_lx
" asi 0x%02x = %016" PRIx64
"\n", txt
,
354 #ifndef TARGET_SPARC64
355 #ifndef CONFIG_USER_ONLY
358 /* Leon3 cache control */
360 static void leon3_cache_control_st(CPUSPARCState
*env
, target_ulong addr
,
361 uint64_t val
, int size
)
363 DPRINTF_CACHE_CONTROL("st addr:%08x, val:%" PRIx64
", size:%d\n",
367 DPRINTF_CACHE_CONTROL("32bits only\n");
372 case 0x00: /* Cache control */
374 /* These values must always be read as zeros */
375 val
&= ~CACHE_CTRL_FD
;
376 val
&= ~CACHE_CTRL_FI
;
377 val
&= ~CACHE_CTRL_IB
;
378 val
&= ~CACHE_CTRL_IP
;
379 val
&= ~CACHE_CTRL_DP
;
381 env
->cache_control
= val
;
383 case 0x04: /* Instruction cache configuration */
384 case 0x08: /* Data cache configuration */
388 DPRINTF_CACHE_CONTROL("write unknown register %08x\n", addr
);
393 static uint64_t leon3_cache_control_ld(CPUSPARCState
*env
, target_ulong addr
,
399 DPRINTF_CACHE_CONTROL("32bits only\n");
404 case 0x00: /* Cache control */
405 ret
= env
->cache_control
;
408 /* Configuration registers are read and only always keep those
411 case 0x04: /* Instruction cache configuration */
414 case 0x08: /* Data cache configuration */
418 DPRINTF_CACHE_CONTROL("read unknown register %08x\n", addr
);
421 DPRINTF_CACHE_CONTROL("ld addr:%08x, ret:0x%" PRIx64
", size:%d\n",
426 uint64_t helper_ld_asi(CPUSPARCState
*env
, target_ulong addr
, int asi
, int size
,
430 #if defined(DEBUG_MXCC) || defined(DEBUG_ASI)
431 uint32_t last_addr
= addr
;
434 helper_check_align(env
, addr
, size
- 1);
436 case 2: /* SuperSparc MXCC registers and Leon3 cache control */
438 case 0x00: /* Leon3 Cache Control */
439 case 0x08: /* Leon3 Instruction Cache config */
440 case 0x0C: /* Leon3 Date Cache config */
441 if (env
->def
->features
& CPU_FEATURE_CACHE_CTRL
) {
442 ret
= leon3_cache_control_ld(env
, addr
, size
);
445 case 0x01c00a00: /* MXCC control register */
447 ret
= env
->mxccregs
[3];
449 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
453 case 0x01c00a04: /* MXCC control register */
455 ret
= env
->mxccregs
[3];
457 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
461 case 0x01c00c00: /* Module reset register */
463 ret
= env
->mxccregs
[5];
464 /* should we do something here? */
466 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
470 case 0x01c00f00: /* MBus port address register */
472 ret
= env
->mxccregs
[7];
474 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
479 DPRINTF_MXCC("%08x: unimplemented address, size: %d\n", addr
,
483 DPRINTF_MXCC("asi = %d, size = %d, sign = %d, "
484 "addr = %08x -> ret = %" PRIx64
","
485 "addr = %08x\n", asi
, size
, sign
, last_addr
, ret
, addr
);
490 case 3: /* MMU probe */
494 mmulev
= (addr
>> 8) & 15;
498 ret
= mmu_probe(env
, addr
, mmulev
);
500 DPRINTF_MMU("mmu_probe: 0x%08x (lev %d) -> 0x%08" PRIx64
"\n",
504 case 4: /* read MMU regs */
506 int reg
= (addr
>> 8) & 0x1f;
508 ret
= env
->mmuregs
[reg
];
509 if (reg
== 3) { /* Fault status cleared on read */
511 } else if (reg
== 0x13) { /* Fault status read */
512 ret
= env
->mmuregs
[3];
513 } else if (reg
== 0x14) { /* Fault address read */
514 ret
= env
->mmuregs
[4];
516 DPRINTF_MMU("mmu_read: reg[%d] = 0x%08" PRIx64
"\n", reg
, ret
);
519 case 5: /* Turbosparc ITLB Diagnostic */
520 case 6: /* Turbosparc DTLB Diagnostic */
521 case 7: /* Turbosparc IOTLB Diagnostic */
523 case 9: /* Supervisor code access */
526 ret
= ldub_code(addr
);
529 ret
= lduw_code(addr
);
533 ret
= ldl_code(addr
);
536 ret
= ldq_code(addr
);
540 case 0xa: /* User data access */
543 ret
= cpu_ldub_user(env
, addr
);
546 ret
= cpu_lduw_user(env
, addr
);
550 ret
= cpu_ldl_user(env
, addr
);
553 ret
= cpu_ldq_user(env
, addr
);
557 case 0xb: /* Supervisor data access */
560 ret
= cpu_ldub_kernel(env
, addr
);
563 ret
= cpu_lduw_kernel(env
, addr
);
567 ret
= cpu_ldl_kernel(env
, addr
);
570 ret
= cpu_ldq_kernel(env
, addr
);
574 case 0xc: /* I-cache tag */
575 case 0xd: /* I-cache data */
576 case 0xe: /* D-cache tag */
577 case 0xf: /* D-cache data */
579 case 0x20: /* MMU passthrough */
582 ret
= ldub_phys(addr
);
585 ret
= lduw_phys(addr
);
589 ret
= ldl_phys(addr
);
592 ret
= ldq_phys(addr
);
596 case 0x21 ... 0x2f: /* MMU passthrough, 0x100000000 to 0xfffffffff */
599 ret
= ldub_phys((target_phys_addr_t
)addr
600 | ((target_phys_addr_t
)(asi
& 0xf) << 32));
603 ret
= lduw_phys((target_phys_addr_t
)addr
604 | ((target_phys_addr_t
)(asi
& 0xf) << 32));
608 ret
= ldl_phys((target_phys_addr_t
)addr
609 | ((target_phys_addr_t
)(asi
& 0xf) << 32));
612 ret
= ldq_phys((target_phys_addr_t
)addr
613 | ((target_phys_addr_t
)(asi
& 0xf) << 32));
617 case 0x30: /* Turbosparc secondary cache diagnostic */
618 case 0x31: /* Turbosparc RAM snoop */
619 case 0x32: /* Turbosparc page table descriptor diagnostic */
620 case 0x39: /* data cache diagnostic register */
623 case 0x38: /* SuperSPARC MMU Breakpoint Control Registers */
625 int reg
= (addr
>> 8) & 3;
628 case 0: /* Breakpoint Value (Addr) */
629 ret
= env
->mmubpregs
[reg
];
631 case 1: /* Breakpoint Mask */
632 ret
= env
->mmubpregs
[reg
];
634 case 2: /* Breakpoint Control */
635 ret
= env
->mmubpregs
[reg
];
637 case 3: /* Breakpoint Status */
638 ret
= env
->mmubpregs
[reg
];
639 env
->mmubpregs
[reg
] = 0ULL;
642 DPRINTF_MMU("read breakpoint reg[%d] 0x%016" PRIx64
"\n", reg
,
646 case 0x49: /* SuperSPARC MMU Counter Breakpoint Value */
647 ret
= env
->mmubpctrv
;
649 case 0x4a: /* SuperSPARC MMU Counter Breakpoint Control */
650 ret
= env
->mmubpctrc
;
652 case 0x4b: /* SuperSPARC MMU Counter Breakpoint Status */
653 ret
= env
->mmubpctrs
;
655 case 0x4c: /* SuperSPARC MMU Breakpoint Action */
656 ret
= env
->mmubpaction
;
658 case 8: /* User code access, XXX */
660 cpu_unassigned_access(env
, addr
, 0, 0, asi
, size
);
680 dump_asi("read ", last_addr
, asi
, size
, ret
);
685 void helper_st_asi(CPUSPARCState
*env
, target_ulong addr
, uint64_t val
, int asi
,
688 helper_check_align(env
, addr
, size
- 1);
690 case 2: /* SuperSparc MXCC registers and Leon3 cache control */
692 case 0x00: /* Leon3 Cache Control */
693 case 0x08: /* Leon3 Instruction Cache config */
694 case 0x0C: /* Leon3 Date Cache config */
695 if (env
->def
->features
& CPU_FEATURE_CACHE_CTRL
) {
696 leon3_cache_control_st(env
, addr
, val
, size
);
700 case 0x01c00000: /* MXCC stream data register 0 */
702 env
->mxccdata
[0] = val
;
704 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
708 case 0x01c00008: /* MXCC stream data register 1 */
710 env
->mxccdata
[1] = val
;
712 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
716 case 0x01c00010: /* MXCC stream data register 2 */
718 env
->mxccdata
[2] = val
;
720 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
724 case 0x01c00018: /* MXCC stream data register 3 */
726 env
->mxccdata
[3] = val
;
728 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
732 case 0x01c00100: /* MXCC stream source */
734 env
->mxccregs
[0] = val
;
736 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
739 env
->mxccdata
[0] = ldq_phys((env
->mxccregs
[0] & 0xffffffffULL
) +
741 env
->mxccdata
[1] = ldq_phys((env
->mxccregs
[0] & 0xffffffffULL
) +
743 env
->mxccdata
[2] = ldq_phys((env
->mxccregs
[0] & 0xffffffffULL
) +
745 env
->mxccdata
[3] = ldq_phys((env
->mxccregs
[0] & 0xffffffffULL
) +
748 case 0x01c00200: /* MXCC stream destination */
750 env
->mxccregs
[1] = val
;
752 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
755 stq_phys((env
->mxccregs
[1] & 0xffffffffULL
) + 0,
757 stq_phys((env
->mxccregs
[1] & 0xffffffffULL
) + 8,
759 stq_phys((env
->mxccregs
[1] & 0xffffffffULL
) + 16,
761 stq_phys((env
->mxccregs
[1] & 0xffffffffULL
) + 24,
764 case 0x01c00a00: /* MXCC control register */
766 env
->mxccregs
[3] = val
;
768 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
772 case 0x01c00a04: /* MXCC control register */
774 env
->mxccregs
[3] = (env
->mxccregs
[3] & 0xffffffff00000000ULL
)
777 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
781 case 0x01c00e00: /* MXCC error register */
782 /* writing a 1 bit clears the error */
784 env
->mxccregs
[6] &= ~val
;
786 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
790 case 0x01c00f00: /* MBus port address register */
792 env
->mxccregs
[7] = val
;
794 DPRINTF_MXCC("%08x: unimplemented access size: %d\n", addr
,
799 DPRINTF_MXCC("%08x: unimplemented address, size: %d\n", addr
,
803 DPRINTF_MXCC("asi = %d, size = %d, addr = %08x, val = %" PRIx64
"\n",
804 asi
, size
, addr
, val
);
809 case 3: /* MMU flush */
813 mmulev
= (addr
>> 8) & 15;
814 DPRINTF_MMU("mmu flush level %d\n", mmulev
);
816 case 0: /* flush page */
817 tlb_flush_page(env
, addr
& 0xfffff000);
819 case 1: /* flush segment (256k) */
820 case 2: /* flush region (16M) */
821 case 3: /* flush context (4G) */
822 case 4: /* flush entire */
829 dump_mmu(stdout
, fprintf
, env
);
833 case 4: /* write MMU regs */
835 int reg
= (addr
>> 8) & 0x1f;
838 oldreg
= env
->mmuregs
[reg
];
840 case 0: /* Control Register */
841 env
->mmuregs
[reg
] = (env
->mmuregs
[reg
] & 0xff000000) |
843 /* Mappings generated during no-fault mode or MMU
844 disabled mode are invalid in normal mode */
845 if ((oldreg
& (MMU_E
| MMU_NF
| env
->def
->mmu_bm
)) !=
846 (env
->mmuregs
[reg
] & (MMU_E
| MMU_NF
| env
->def
->mmu_bm
))) {
850 case 1: /* Context Table Pointer Register */
851 env
->mmuregs
[reg
] = val
& env
->def
->mmu_ctpr_mask
;
853 case 2: /* Context Register */
854 env
->mmuregs
[reg
] = val
& env
->def
->mmu_cxr_mask
;
855 if (oldreg
!= env
->mmuregs
[reg
]) {
856 /* we flush when the MMU context changes because
857 QEMU has no MMU context support */
861 case 3: /* Synchronous Fault Status Register with Clear */
862 case 4: /* Synchronous Fault Address Register */
864 case 0x10: /* TLB Replacement Control Register */
865 env
->mmuregs
[reg
] = val
& env
->def
->mmu_trcr_mask
;
867 case 0x13: /* Synchronous Fault Status Register with Read
869 env
->mmuregs
[3] = val
& env
->def
->mmu_sfsr_mask
;
871 case 0x14: /* Synchronous Fault Address Register */
872 env
->mmuregs
[4] = val
;
875 env
->mmuregs
[reg
] = val
;
878 if (oldreg
!= env
->mmuregs
[reg
]) {
879 DPRINTF_MMU("mmu change reg[%d]: 0x%08x -> 0x%08x\n",
880 reg
, oldreg
, env
->mmuregs
[reg
]);
883 dump_mmu(stdout
, fprintf
, env
);
887 case 5: /* Turbosparc ITLB Diagnostic */
888 case 6: /* Turbosparc DTLB Diagnostic */
889 case 7: /* Turbosparc IOTLB Diagnostic */
891 case 0xa: /* User data access */
894 cpu_stb_user(env
, addr
, val
);
897 cpu_stw_user(env
, addr
, val
);
901 cpu_stl_user(env
, addr
, val
);
904 cpu_stq_user(env
, addr
, val
);
908 case 0xb: /* Supervisor data access */
911 cpu_stb_kernel(env
, addr
, val
);
914 cpu_stw_kernel(env
, addr
, val
);
918 cpu_stl_kernel(env
, addr
, val
);
921 cpu_stq_kernel(env
, addr
, val
);
925 case 0xc: /* I-cache tag */
926 case 0xd: /* I-cache data */
927 case 0xe: /* D-cache tag */
928 case 0xf: /* D-cache data */
929 case 0x10: /* I/D-cache flush page */
930 case 0x11: /* I/D-cache flush segment */
931 case 0x12: /* I/D-cache flush region */
932 case 0x13: /* I/D-cache flush context */
933 case 0x14: /* I/D-cache flush user */
935 case 0x17: /* Block copy, sta access */
941 uint32_t src
= val
& ~3, dst
= addr
& ~3, temp
;
943 for (i
= 0; i
< 32; i
+= 4, src
+= 4, dst
+= 4) {
944 temp
= cpu_ldl_kernel(env
, src
);
945 cpu_stl_kernel(env
, dst
, temp
);
949 case 0x1f: /* Block fill, stda access */
952 fill 32 bytes with val */
954 uint32_t dst
= addr
& 7;
956 for (i
= 0; i
< 32; i
+= 8, dst
+= 8) {
957 cpu_stq_kernel(env
, dst
, val
);
961 case 0x20: /* MMU passthrough */
980 case 0x21 ... 0x2f: /* MMU passthrough, 0x100000000 to 0xfffffffff */
984 stb_phys((target_phys_addr_t
)addr
985 | ((target_phys_addr_t
)(asi
& 0xf) << 32), val
);
988 stw_phys((target_phys_addr_t
)addr
989 | ((target_phys_addr_t
)(asi
& 0xf) << 32), val
);
993 stl_phys((target_phys_addr_t
)addr
994 | ((target_phys_addr_t
)(asi
& 0xf) << 32), val
);
997 stq_phys((target_phys_addr_t
)addr
998 | ((target_phys_addr_t
)(asi
& 0xf) << 32), val
);
1003 case 0x30: /* store buffer tags or Turbosparc secondary cache diagnostic */
1004 case 0x31: /* store buffer data, Ross RT620 I-cache flush or
1005 Turbosparc snoop RAM */
1006 case 0x32: /* store buffer control or Turbosparc page table
1007 descriptor diagnostic */
1008 case 0x36: /* I-cache flash clear */
1009 case 0x37: /* D-cache flash clear */
1011 case 0x38: /* SuperSPARC MMU Breakpoint Control Registers*/
1013 int reg
= (addr
>> 8) & 3;
1016 case 0: /* Breakpoint Value (Addr) */
1017 env
->mmubpregs
[reg
] = (val
& 0xfffffffffULL
);
1019 case 1: /* Breakpoint Mask */
1020 env
->mmubpregs
[reg
] = (val
& 0xfffffffffULL
);
1022 case 2: /* Breakpoint Control */
1023 env
->mmubpregs
[reg
] = (val
& 0x7fULL
);
1025 case 3: /* Breakpoint Status */
1026 env
->mmubpregs
[reg
] = (val
& 0xfULL
);
1029 DPRINTF_MMU("write breakpoint reg[%d] 0x%016x\n", reg
,
1033 case 0x49: /* SuperSPARC MMU Counter Breakpoint Value */
1034 env
->mmubpctrv
= val
& 0xffffffff;
1036 case 0x4a: /* SuperSPARC MMU Counter Breakpoint Control */
1037 env
->mmubpctrc
= val
& 0x3;
1039 case 0x4b: /* SuperSPARC MMU Counter Breakpoint Status */
1040 env
->mmubpctrs
= val
& 0x3;
1042 case 0x4c: /* SuperSPARC MMU Breakpoint Action */
1043 env
->mmubpaction
= val
& 0x1fff;
1045 case 8: /* User code access, XXX */
1046 case 9: /* Supervisor code access, XXX */
1048 cpu_unassigned_access(env
, addr
, 1, 0, asi
, size
);
1052 dump_asi("write", addr
, asi
, size
, val
);
1056 #endif /* CONFIG_USER_ONLY */
1057 #else /* TARGET_SPARC64 */
1059 #ifdef CONFIG_USER_ONLY
1060 uint64_t helper_ld_asi(CPUSPARCState
*env
, target_ulong addr
, int asi
, int size
,
1064 #if defined(DEBUG_ASI)
1065 target_ulong last_addr
= addr
;
1069 helper_raise_exception(env
, TT_PRIV_ACT
);
1072 helper_check_align(env
, addr
, size
- 1);
1073 addr
= asi_address_mask(env
, asi
, addr
);
1076 case 0x82: /* Primary no-fault */
1077 case 0x8a: /* Primary no-fault LE */
1078 if (page_check_range(addr
, size
, PAGE_READ
) == -1) {
1080 dump_asi("read ", last_addr
, asi
, size
, ret
);
1085 case 0x80: /* Primary */
1086 case 0x88: /* Primary LE */
1090 ret
= ldub_raw(addr
);
1093 ret
= lduw_raw(addr
);
1096 ret
= ldl_raw(addr
);
1100 ret
= ldq_raw(addr
);
1105 case 0x83: /* Secondary no-fault */
1106 case 0x8b: /* Secondary no-fault LE */
1107 if (page_check_range(addr
, size
, PAGE_READ
) == -1) {
1109 dump_asi("read ", last_addr
, asi
, size
, ret
);
1114 case 0x81: /* Secondary */
1115 case 0x89: /* Secondary LE */
1122 /* Convert from little endian */
1124 case 0x88: /* Primary LE */
1125 case 0x89: /* Secondary LE */
1126 case 0x8a: /* Primary no-fault LE */
1127 case 0x8b: /* Secondary no-fault LE */
1145 /* Convert to signed number */
1152 ret
= (int16_t) ret
;
1155 ret
= (int32_t) ret
;
1162 dump_asi("read ", last_addr
, asi
, size
, ret
);
1167 void helper_st_asi(CPUSPARCState
*env
, target_ulong addr
, target_ulong val
,
1171 dump_asi("write", addr
, asi
, size
, val
);
1174 helper_raise_exception(env
, TT_PRIV_ACT
);
1177 helper_check_align(env
, addr
, size
- 1);
1178 addr
= asi_address_mask(env
, asi
, addr
);
1180 /* Convert to little endian */
1182 case 0x88: /* Primary LE */
1183 case 0x89: /* Secondary LE */
1202 case 0x80: /* Primary */
1203 case 0x88: /* Primary LE */
1222 case 0x81: /* Secondary */
1223 case 0x89: /* Secondary LE */
1227 case 0x82: /* Primary no-fault, RO */
1228 case 0x83: /* Secondary no-fault, RO */
1229 case 0x8a: /* Primary no-fault LE, RO */
1230 case 0x8b: /* Secondary no-fault LE, RO */
1232 helper_raise_exception(env
, TT_DATA_ACCESS
);
1237 #else /* CONFIG_USER_ONLY */
1239 uint64_t helper_ld_asi(CPUSPARCState
*env
, target_ulong addr
, int asi
, int size
,
1243 #if defined(DEBUG_ASI)
1244 target_ulong last_addr
= addr
;
1249 if ((asi
< 0x80 && (env
->pstate
& PS_PRIV
) == 0)
1250 || (cpu_has_hypervisor(env
)
1251 && asi
>= 0x30 && asi
< 0x80
1252 && !(env
->hpstate
& HS_PRIV
))) {
1253 helper_raise_exception(env
, TT_PRIV_ACT
);
1256 helper_check_align(env
, addr
, size
- 1);
1257 addr
= asi_address_mask(env
, asi
, addr
);
1259 /* process nonfaulting loads first */
1260 if ((asi
& 0xf6) == 0x82) {
1263 /* secondary space access has lowest asi bit equal to 1 */
1264 if (env
->pstate
& PS_PRIV
) {
1265 mmu_idx
= (asi
& 1) ? MMU_KERNEL_SECONDARY_IDX
: MMU_KERNEL_IDX
;
1267 mmu_idx
= (asi
& 1) ? MMU_USER_SECONDARY_IDX
: MMU_USER_IDX
;
1270 if (cpu_get_phys_page_nofault(env
, addr
, mmu_idx
) == -1ULL) {
1272 dump_asi("read ", last_addr
, asi
, size
, ret
);
1274 /* env->exception_index is set in get_physical_address_data(). */
1275 helper_raise_exception(env
, env
->exception_index
);
1278 /* convert nonfaulting load ASIs to normal load ASIs */
1283 case 0x10: /* As if user primary */
1284 case 0x11: /* As if user secondary */
1285 case 0x18: /* As if user primary LE */
1286 case 0x19: /* As if user secondary LE */
1287 case 0x80: /* Primary */
1288 case 0x81: /* Secondary */
1289 case 0x88: /* Primary LE */
1290 case 0x89: /* Secondary LE */
1291 case 0xe2: /* UA2007 Primary block init */
1292 case 0xe3: /* UA2007 Secondary block init */
1293 if ((asi
& 0x80) && (env
->pstate
& PS_PRIV
)) {
1294 if (cpu_hypervisor_mode(env
)) {
1297 ret
= cpu_ldub_hypv(env
, addr
);
1300 ret
= cpu_lduw_hypv(env
, addr
);
1303 ret
= cpu_ldl_hypv(env
, addr
);
1307 ret
= cpu_ldq_hypv(env
, addr
);
1311 /* secondary space access has lowest asi bit equal to 1 */
1315 ret
= cpu_ldub_kernel_secondary(env
, addr
);
1318 ret
= cpu_lduw_kernel_secondary(env
, addr
);
1321 ret
= cpu_ldl_kernel_secondary(env
, addr
);
1325 ret
= cpu_ldq_kernel_secondary(env
, addr
);
1331 ret
= cpu_ldub_kernel(env
, addr
);
1334 ret
= cpu_lduw_kernel(env
, addr
);
1337 ret
= cpu_ldl_kernel(env
, addr
);
1341 ret
= cpu_ldq_kernel(env
, addr
);
1347 /* secondary space access has lowest asi bit equal to 1 */
1351 ret
= cpu_ldub_user_secondary(env
, addr
);
1354 ret
= cpu_lduw_user_secondary(env
, addr
);
1357 ret
= cpu_ldl_user_secondary(env
, addr
);
1361 ret
= cpu_ldq_user_secondary(env
, addr
);
1367 ret
= cpu_ldub_user(env
, addr
);
1370 ret
= cpu_lduw_user(env
, addr
);
1373 ret
= cpu_ldl_user(env
, addr
);
1377 ret
= cpu_ldq_user(env
, addr
);
1383 case 0x14: /* Bypass */
1384 case 0x15: /* Bypass, non-cacheable */
1385 case 0x1c: /* Bypass LE */
1386 case 0x1d: /* Bypass, non-cacheable LE */
1390 ret
= ldub_phys(addr
);
1393 ret
= lduw_phys(addr
);
1396 ret
= ldl_phys(addr
);
1400 ret
= ldq_phys(addr
);
1405 case 0x24: /* Nucleus quad LDD 128 bit atomic */
1406 case 0x2c: /* Nucleus quad LDD 128 bit atomic LE
1407 Only ldda allowed */
1408 helper_raise_exception(env
, TT_ILL_INSN
);
1410 case 0x04: /* Nucleus */
1411 case 0x0c: /* Nucleus Little Endian (LE) */
1415 ret
= cpu_ldub_nucleus(env
, addr
);
1418 ret
= cpu_lduw_nucleus(env
, addr
);
1421 ret
= cpu_ldl_nucleus(env
, addr
);
1425 ret
= cpu_ldq_nucleus(env
, addr
);
1430 case 0x4a: /* UPA config */
1433 case 0x45: /* LSU */
1436 case 0x50: /* I-MMU regs */
1438 int reg
= (addr
>> 3) & 0xf;
1441 /* I-TSB Tag Target register */
1442 ret
= ultrasparc_tag_target(env
->immu
.tag_access
);
1444 ret
= env
->immuregs
[reg
];
1449 case 0x51: /* I-MMU 8k TSB pointer */
1451 /* env->immuregs[5] holds I-MMU TSB register value
1452 env->immuregs[6] holds I-MMU Tag Access register value */
1453 ret
= ultrasparc_tsb_pointer(env
->immu
.tsb
, env
->immu
.tag_access
,
1457 case 0x52: /* I-MMU 64k TSB pointer */
1459 /* env->immuregs[5] holds I-MMU TSB register value
1460 env->immuregs[6] holds I-MMU Tag Access register value */
1461 ret
= ultrasparc_tsb_pointer(env
->immu
.tsb
, env
->immu
.tag_access
,
1465 case 0x55: /* I-MMU data access */
1467 int reg
= (addr
>> 3) & 0x3f;
1469 ret
= env
->itlb
[reg
].tte
;
1472 case 0x56: /* I-MMU tag read */
1474 int reg
= (addr
>> 3) & 0x3f;
1476 ret
= env
->itlb
[reg
].tag
;
1479 case 0x58: /* D-MMU regs */
1481 int reg
= (addr
>> 3) & 0xf;
1484 /* D-TSB Tag Target register */
1485 ret
= ultrasparc_tag_target(env
->dmmu
.tag_access
);
1487 ret
= env
->dmmuregs
[reg
];
1491 case 0x59: /* D-MMU 8k TSB pointer */
1493 /* env->dmmuregs[5] holds D-MMU TSB register value
1494 env->dmmuregs[6] holds D-MMU Tag Access register value */
1495 ret
= ultrasparc_tsb_pointer(env
->dmmu
.tsb
, env
->dmmu
.tag_access
,
1499 case 0x5a: /* D-MMU 64k TSB pointer */
1501 /* env->dmmuregs[5] holds D-MMU TSB register value
1502 env->dmmuregs[6] holds D-MMU Tag Access register value */
1503 ret
= ultrasparc_tsb_pointer(env
->dmmu
.tsb
, env
->dmmu
.tag_access
,
1507 case 0x5d: /* D-MMU data access */
1509 int reg
= (addr
>> 3) & 0x3f;
1511 ret
= env
->dtlb
[reg
].tte
;
1514 case 0x5e: /* D-MMU tag read */
1516 int reg
= (addr
>> 3) & 0x3f;
1518 ret
= env
->dtlb
[reg
].tag
;
1521 case 0x48: /* Interrupt dispatch, RO */
1523 case 0x49: /* Interrupt data receive */
1524 ret
= env
->ivec_status
;
1526 case 0x7f: /* Incoming interrupt vector, RO */
1528 int reg
= (addr
>> 4) & 0x3;
1530 ret
= env
->ivec_data
[reg
];
1534 case 0x46: /* D-cache data */
1535 case 0x47: /* D-cache tag access */
1536 case 0x4b: /* E-cache error enable */
1537 case 0x4c: /* E-cache asynchronous fault status */
1538 case 0x4d: /* E-cache asynchronous fault address */
1539 case 0x4e: /* E-cache tag data */
1540 case 0x66: /* I-cache instruction access */
1541 case 0x67: /* I-cache tag access */
1542 case 0x6e: /* I-cache predecode */
1543 case 0x6f: /* I-cache LRU etc. */
1544 case 0x76: /* E-cache tag */
1545 case 0x7e: /* E-cache tag */
1547 case 0x5b: /* D-MMU data pointer */
1548 case 0x54: /* I-MMU data in, WO */
1549 case 0x57: /* I-MMU demap, WO */
1550 case 0x5c: /* D-MMU data in, WO */
1551 case 0x5f: /* D-MMU demap, WO */
1552 case 0x77: /* Interrupt vector, WO */
1554 cpu_unassigned_access(env
, addr
, 0, 0, 1, size
);
1559 /* Convert from little endian */
1561 case 0x0c: /* Nucleus Little Endian (LE) */
1562 case 0x18: /* As if user primary LE */
1563 case 0x19: /* As if user secondary LE */
1564 case 0x1c: /* Bypass LE */
1565 case 0x1d: /* Bypass, non-cacheable LE */
1566 case 0x88: /* Primary LE */
1567 case 0x89: /* Secondary LE */
1585 /* Convert to signed number */
1592 ret
= (int16_t) ret
;
1595 ret
= (int32_t) ret
;
1602 dump_asi("read ", last_addr
, asi
, size
, ret
);
1607 void helper_st_asi(CPUSPARCState
*env
, target_ulong addr
, target_ulong val
,
1611 dump_asi("write", addr
, asi
, size
, val
);
1616 if ((asi
< 0x80 && (env
->pstate
& PS_PRIV
) == 0)
1617 || (cpu_has_hypervisor(env
)
1618 && asi
>= 0x30 && asi
< 0x80
1619 && !(env
->hpstate
& HS_PRIV
))) {
1620 helper_raise_exception(env
, TT_PRIV_ACT
);
1623 helper_check_align(env
, addr
, size
- 1);
1624 addr
= asi_address_mask(env
, asi
, addr
);
1626 /* Convert to little endian */
1628 case 0x0c: /* Nucleus Little Endian (LE) */
1629 case 0x18: /* As if user primary LE */
1630 case 0x19: /* As if user secondary LE */
1631 case 0x1c: /* Bypass LE */
1632 case 0x1d: /* Bypass, non-cacheable LE */
1633 case 0x88: /* Primary LE */
1634 case 0x89: /* Secondary LE */
1653 case 0x10: /* As if user primary */
1654 case 0x11: /* As if user secondary */
1655 case 0x18: /* As if user primary LE */
1656 case 0x19: /* As if user secondary LE */
1657 case 0x80: /* Primary */
1658 case 0x81: /* Secondary */
1659 case 0x88: /* Primary LE */
1660 case 0x89: /* Secondary LE */
1661 case 0xe2: /* UA2007 Primary block init */
1662 case 0xe3: /* UA2007 Secondary block init */
1663 if ((asi
& 0x80) && (env
->pstate
& PS_PRIV
)) {
1664 if (cpu_hypervisor_mode(env
)) {
1667 cpu_stb_hypv(env
, addr
, val
);
1670 cpu_stw_hypv(env
, addr
, val
);
1673 cpu_stl_hypv(env
, addr
, val
);
1677 cpu_stq_hypv(env
, addr
, val
);
1681 /* secondary space access has lowest asi bit equal to 1 */
1685 cpu_stb_kernel_secondary(env
, addr
, val
);
1688 cpu_stw_kernel_secondary(env
, addr
, val
);
1691 cpu_stl_kernel_secondary(env
, addr
, val
);
1695 cpu_stq_kernel_secondary(env
, addr
, val
);
1701 cpu_stb_kernel(env
, addr
, val
);
1704 cpu_stw_kernel(env
, addr
, val
);
1707 cpu_stl_kernel(env
, addr
, val
);
1711 cpu_stq_kernel(env
, addr
, val
);
1717 /* secondary space access has lowest asi bit equal to 1 */
1721 cpu_stb_user_secondary(env
, addr
, val
);
1724 cpu_stw_user_secondary(env
, addr
, val
);
1727 cpu_stl_user_secondary(env
, addr
, val
);
1731 cpu_stq_user_secondary(env
, addr
, val
);
1737 cpu_stb_user(env
, addr
, val
);
1740 cpu_stw_user(env
, addr
, val
);
1743 cpu_stl_user(env
, addr
, val
);
1747 cpu_stq_user(env
, addr
, val
);
1753 case 0x14: /* Bypass */
1754 case 0x15: /* Bypass, non-cacheable */
1755 case 0x1c: /* Bypass LE */
1756 case 0x1d: /* Bypass, non-cacheable LE */
1760 stb_phys(addr
, val
);
1763 stw_phys(addr
, val
);
1766 stl_phys(addr
, val
);
1770 stq_phys(addr
, val
);
1775 case 0x24: /* Nucleus quad LDD 128 bit atomic */
1776 case 0x2c: /* Nucleus quad LDD 128 bit atomic LE
1777 Only ldda allowed */
1778 helper_raise_exception(env
, TT_ILL_INSN
);
1780 case 0x04: /* Nucleus */
1781 case 0x0c: /* Nucleus Little Endian (LE) */
1785 cpu_stb_nucleus(env
, addr
, val
);
1788 cpu_stw_nucleus(env
, addr
, val
);
1791 cpu_stl_nucleus(env
, addr
, val
);
1795 cpu_stq_nucleus(env
, addr
, val
);
1801 case 0x4a: /* UPA config */
1804 case 0x45: /* LSU */
1809 env
->lsu
= val
& (DMMU_E
| IMMU_E
);
1810 /* Mappings generated during D/I MMU disabled mode are
1811 invalid in normal mode */
1812 if (oldreg
!= env
->lsu
) {
1813 DPRINTF_MMU("LSU change: 0x%" PRIx64
" -> 0x%" PRIx64
"\n",
1816 dump_mmu(stdout
, fprintf
, env1
);
1822 case 0x50: /* I-MMU regs */
1824 int reg
= (addr
>> 3) & 0xf;
1827 oldreg
= env
->immuregs
[reg
];
1831 case 1: /* Not in I-MMU */
1835 if ((val
& 1) == 0) {
1836 val
= 0; /* Clear SFSR */
1838 env
->immu
.sfsr
= val
;
1842 case 5: /* TSB access */
1843 DPRINTF_MMU("immu TSB write: 0x%016" PRIx64
" -> 0x%016"
1844 PRIx64
"\n", env
->immu
.tsb
, val
);
1845 env
->immu
.tsb
= val
;
1847 case 6: /* Tag access */
1848 env
->immu
.tag_access
= val
;
1857 if (oldreg
!= env
->immuregs
[reg
]) {
1858 DPRINTF_MMU("immu change reg[%d]: 0x%016" PRIx64
" -> 0x%016"
1859 PRIx64
"\n", reg
, oldreg
, env
->immuregs
[reg
]);
1862 dump_mmu(stdout
, fprintf
, env
);
1866 case 0x54: /* I-MMU data in */
1867 replace_tlb_1bit_lru(env
->itlb
, env
->immu
.tag_access
, val
, "immu", env
);
1869 case 0x55: /* I-MMU data access */
1871 /* TODO: auto demap */
1873 unsigned int i
= (addr
>> 3) & 0x3f;
1875 replace_tlb_entry(&env
->itlb
[i
], env
->immu
.tag_access
, val
, env
);
1878 DPRINTF_MMU("immu data access replaced entry [%i]\n", i
);
1879 dump_mmu(stdout
, fprintf
, env
);
1883 case 0x57: /* I-MMU demap */
1884 demap_tlb(env
->itlb
, addr
, "immu", env
);
1886 case 0x58: /* D-MMU regs */
1888 int reg
= (addr
>> 3) & 0xf;
1891 oldreg
= env
->dmmuregs
[reg
];
1897 if ((val
& 1) == 0) {
1898 val
= 0; /* Clear SFSR, Fault address */
1901 env
->dmmu
.sfsr
= val
;
1903 case 1: /* Primary context */
1904 env
->dmmu
.mmu_primary_context
= val
;
1905 /* can be optimized to only flush MMU_USER_IDX
1906 and MMU_KERNEL_IDX entries */
1909 case 2: /* Secondary context */
1910 env
->dmmu
.mmu_secondary_context
= val
;
1911 /* can be optimized to only flush MMU_USER_SECONDARY_IDX
1912 and MMU_KERNEL_SECONDARY_IDX entries */
1915 case 5: /* TSB access */
1916 DPRINTF_MMU("dmmu TSB write: 0x%016" PRIx64
" -> 0x%016"
1917 PRIx64
"\n", env
->dmmu
.tsb
, val
);
1918 env
->dmmu
.tsb
= val
;
1920 case 6: /* Tag access */
1921 env
->dmmu
.tag_access
= val
;
1923 case 7: /* Virtual Watchpoint */
1924 case 8: /* Physical Watchpoint */
1926 env
->dmmuregs
[reg
] = val
;
1930 if (oldreg
!= env
->dmmuregs
[reg
]) {
1931 DPRINTF_MMU("dmmu change reg[%d]: 0x%016" PRIx64
" -> 0x%016"
1932 PRIx64
"\n", reg
, oldreg
, env
->dmmuregs
[reg
]);
1935 dump_mmu(stdout
, fprintf
, env
);
1939 case 0x5c: /* D-MMU data in */
1940 replace_tlb_1bit_lru(env
->dtlb
, env
->dmmu
.tag_access
, val
, "dmmu", env
);
1942 case 0x5d: /* D-MMU data access */
1944 unsigned int i
= (addr
>> 3) & 0x3f;
1946 replace_tlb_entry(&env
->dtlb
[i
], env
->dmmu
.tag_access
, val
, env
);
1949 DPRINTF_MMU("dmmu data access replaced entry [%i]\n", i
);
1950 dump_mmu(stdout
, fprintf
, env
);
1954 case 0x5f: /* D-MMU demap */
1955 demap_tlb(env
->dtlb
, addr
, "dmmu", env
);
1957 case 0x49: /* Interrupt data receive */
1958 env
->ivec_status
= val
& 0x20;
1960 case 0x46: /* D-cache data */
1961 case 0x47: /* D-cache tag access */
1962 case 0x4b: /* E-cache error enable */
1963 case 0x4c: /* E-cache asynchronous fault status */
1964 case 0x4d: /* E-cache asynchronous fault address */
1965 case 0x4e: /* E-cache tag data */
1966 case 0x66: /* I-cache instruction access */
1967 case 0x67: /* I-cache tag access */
1968 case 0x6e: /* I-cache predecode */
1969 case 0x6f: /* I-cache LRU etc. */
1970 case 0x76: /* E-cache tag */
1971 case 0x7e: /* E-cache tag */
1973 case 0x51: /* I-MMU 8k TSB pointer, RO */
1974 case 0x52: /* I-MMU 64k TSB pointer, RO */
1975 case 0x56: /* I-MMU tag read, RO */
1976 case 0x59: /* D-MMU 8k TSB pointer, RO */
1977 case 0x5a: /* D-MMU 64k TSB pointer, RO */
1978 case 0x5b: /* D-MMU data pointer, RO */
1979 case 0x5e: /* D-MMU tag read, RO */
1980 case 0x48: /* Interrupt dispatch, RO */
1981 case 0x7f: /* Incoming interrupt vector, RO */
1982 case 0x82: /* Primary no-fault, RO */
1983 case 0x83: /* Secondary no-fault, RO */
1984 case 0x8a: /* Primary no-fault LE, RO */
1985 case 0x8b: /* Secondary no-fault LE, RO */
1987 cpu_unassigned_access(env
, addr
, 1, 0, 1, size
);
1991 #endif /* CONFIG_USER_ONLY */
1993 void helper_ldda_asi(CPUSPARCState
*env
, target_ulong addr
, int asi
, int rd
)
1995 if ((asi
< 0x80 && (env
->pstate
& PS_PRIV
) == 0)
1996 || (cpu_has_hypervisor(env
)
1997 && asi
>= 0x30 && asi
< 0x80
1998 && !(env
->hpstate
& HS_PRIV
))) {
1999 helper_raise_exception(env
, TT_PRIV_ACT
);
2002 addr
= asi_address_mask(env
, asi
, addr
);
2005 #if !defined(CONFIG_USER_ONLY)
2006 case 0x24: /* Nucleus quad LDD 128 bit atomic */
2007 case 0x2c: /* Nucleus quad LDD 128 bit atomic LE */
2008 helper_check_align(env
, addr
, 0xf);
2010 env
->gregs
[1] = cpu_ldq_nucleus(env
, addr
+ 8);
2012 bswap64s(&env
->gregs
[1]);
2014 } else if (rd
< 8) {
2015 env
->gregs
[rd
] = cpu_ldq_nucleus(env
, addr
);
2016 env
->gregs
[rd
+ 1] = cpu_ldq_nucleus(env
, addr
+ 8);
2018 bswap64s(&env
->gregs
[rd
]);
2019 bswap64s(&env
->gregs
[rd
+ 1]);
2022 env
->regwptr
[rd
] = cpu_ldq_nucleus(env
, addr
);
2023 env
->regwptr
[rd
+ 1] = cpu_ldq_nucleus(env
, addr
+ 8);
2025 bswap64s(&env
->regwptr
[rd
]);
2026 bswap64s(&env
->regwptr
[rd
+ 1]);
2032 helper_check_align(env
, addr
, 0x3);
2034 env
->gregs
[1] = helper_ld_asi(env
, addr
+ 4, asi
, 4, 0);
2035 } else if (rd
< 8) {
2036 env
->gregs
[rd
] = helper_ld_asi(env
, addr
, asi
, 4, 0);
2037 env
->gregs
[rd
+ 1] = helper_ld_asi(env
, addr
+ 4, asi
, 4, 0);
2039 env
->regwptr
[rd
] = helper_ld_asi(env
, addr
, asi
, 4, 0);
2040 env
->regwptr
[rd
+ 1] = helper_ld_asi(env
, addr
+ 4, asi
, 4, 0);
2046 void helper_ldf_asi(CPUSPARCState
*env
, target_ulong addr
, int asi
, int size
,
2052 helper_check_align(env
, addr
, 3);
2053 addr
= asi_address_mask(env
, asi
, addr
);
2056 case 0xf0: /* UA2007/JPS1 Block load primary */
2057 case 0xf1: /* UA2007/JPS1 Block load secondary */
2058 case 0xf8: /* UA2007/JPS1 Block load primary LE */
2059 case 0xf9: /* UA2007/JPS1 Block load secondary LE */
2061 helper_raise_exception(env
, TT_ILL_INSN
);
2064 helper_check_align(env
, addr
, 0x3f);
2065 for (i
= 0; i
< 8; i
++, rd
+= 2, addr
+= 8) {
2066 env
->fpr
[rd
/ 2].ll
= helper_ld_asi(env
, addr
, asi
& 0x8f, 8, 0);
2070 case 0x16: /* UA2007 Block load primary, user privilege */
2071 case 0x17: /* UA2007 Block load secondary, user privilege */
2072 case 0x1e: /* UA2007 Block load primary LE, user privilege */
2073 case 0x1f: /* UA2007 Block load secondary LE, user privilege */
2074 case 0x70: /* JPS1 Block load primary, user privilege */
2075 case 0x71: /* JPS1 Block load secondary, user privilege */
2076 case 0x78: /* JPS1 Block load primary LE, user privilege */
2077 case 0x79: /* JPS1 Block load secondary LE, user privilege */
2079 helper_raise_exception(env
, TT_ILL_INSN
);
2082 helper_check_align(env
, addr
, 0x3f);
2083 for (i
= 0; i
< 8; i
++, rd
+= 2, addr
+= 4) {
2084 env
->fpr
[rd
/ 2].ll
= helper_ld_asi(env
, addr
, asi
& 0x19, 8, 0);
2095 val
= helper_ld_asi(env
, addr
, asi
, size
, 0);
2097 env
->fpr
[rd
/ 2].l
.lower
= val
;
2099 env
->fpr
[rd
/ 2].l
.upper
= val
;
2103 env
->fpr
[rd
/ 2].ll
= helper_ld_asi(env
, addr
, asi
, size
, 0);
2106 env
->fpr
[rd
/ 2].ll
= helper_ld_asi(env
, addr
, asi
, 8, 0);
2107 env
->fpr
[rd
/ 2 + 1].ll
= helper_ld_asi(env
, addr
+ 8, asi
, 8, 0);
2112 void helper_stf_asi(CPUSPARCState
*env
, target_ulong addr
, int asi
, int size
,
2118 helper_check_align(env
, addr
, 3);
2119 addr
= asi_address_mask(env
, asi
, addr
);
2122 case 0xe0: /* UA2007/JPS1 Block commit store primary (cache flush) */
2123 case 0xe1: /* UA2007/JPS1 Block commit store secondary (cache flush) */
2124 case 0xf0: /* UA2007/JPS1 Block store primary */
2125 case 0xf1: /* UA2007/JPS1 Block store secondary */
2126 case 0xf8: /* UA2007/JPS1 Block store primary LE */
2127 case 0xf9: /* UA2007/JPS1 Block store secondary LE */
2129 helper_raise_exception(env
, TT_ILL_INSN
);
2132 helper_check_align(env
, addr
, 0x3f);
2133 for (i
= 0; i
< 8; i
++, rd
+= 2, addr
+= 8) {
2134 helper_st_asi(env
, addr
, env
->fpr
[rd
/ 2].ll
, asi
& 0x8f, 8);
2138 case 0x16: /* UA2007 Block load primary, user privilege */
2139 case 0x17: /* UA2007 Block load secondary, user privilege */
2140 case 0x1e: /* UA2007 Block load primary LE, user privilege */
2141 case 0x1f: /* UA2007 Block load secondary LE, user privilege */
2142 case 0x70: /* JPS1 Block store primary, user privilege */
2143 case 0x71: /* JPS1 Block store secondary, user privilege */
2144 case 0x78: /* JPS1 Block load primary LE, user privilege */
2145 case 0x79: /* JPS1 Block load secondary LE, user privilege */
2147 helper_raise_exception(env
, TT_ILL_INSN
);
2150 helper_check_align(env
, addr
, 0x3f);
2151 for (i
= 0; i
< 8; i
++, rd
+= 2, addr
+= 8) {
2152 helper_st_asi(env
, addr
, env
->fpr
[rd
/ 2].ll
, asi
& 0x19, 8);
2164 val
= env
->fpr
[rd
/ 2].l
.lower
;
2166 val
= env
->fpr
[rd
/ 2].l
.upper
;
2168 helper_st_asi(env
, addr
, val
, asi
, size
);
2171 helper_st_asi(env
, addr
, env
->fpr
[rd
/ 2].ll
, asi
, size
);
2174 helper_st_asi(env
, addr
, env
->fpr
[rd
/ 2].ll
, asi
, 8);
2175 helper_st_asi(env
, addr
+ 8, env
->fpr
[rd
/ 2 + 1].ll
, asi
, 8);
2180 target_ulong
helper_cas_asi(CPUSPARCState
*env
, target_ulong addr
,
2181 target_ulong val1
, target_ulong val2
, uint32_t asi
)
2185 val2
&= 0xffffffffUL
;
2186 ret
= helper_ld_asi(env
, addr
, asi
, 4, 0);
2187 ret
&= 0xffffffffUL
;
2189 helper_st_asi(env
, addr
, val1
& 0xffffffffUL
, asi
, 4);
2194 target_ulong
helper_casx_asi(CPUSPARCState
*env
, target_ulong addr
,
2195 target_ulong val1
, target_ulong val2
,
2200 ret
= helper_ld_asi(env
, addr
, asi
, 8, 0);
2202 helper_st_asi(env
, addr
, val1
, asi
, 8);
2206 #endif /* TARGET_SPARC64 */
2208 void helper_ldqf(CPUSPARCState
*env
, target_ulong addr
, int mem_idx
)
2210 /* XXX add 128 bit load */
2213 helper_check_align(env
, addr
, 7);
2214 #if !defined(CONFIG_USER_ONLY)
2217 u
.ll
.upper
= cpu_ldq_user(env
, addr
);
2218 u
.ll
.lower
= cpu_ldq_user(env
, addr
+ 8);
2221 case MMU_KERNEL_IDX
:
2222 u
.ll
.upper
= cpu_ldq_kernel(env
, addr
);
2223 u
.ll
.lower
= cpu_ldq_kernel(env
, addr
+ 8);
2226 #ifdef TARGET_SPARC64
2228 u
.ll
.upper
= cpu_ldq_hypv(env
, addr
);
2229 u
.ll
.lower
= cpu_ldq_hypv(env
, addr
+ 8);
2234 DPRINTF_MMU("helper_ldqf: need to check MMU idx %d\n", mem_idx
);
2238 u
.ll
.upper
= ldq_raw(address_mask(env
, addr
));
2239 u
.ll
.lower
= ldq_raw(address_mask(env
, addr
+ 8));
2244 void helper_stqf(CPUSPARCState
*env
, target_ulong addr
, int mem_idx
)
2246 /* XXX add 128 bit store */
2249 helper_check_align(env
, addr
, 7);
2250 #if !defined(CONFIG_USER_ONLY)
2254 cpu_stq_user(env
, addr
, u
.ll
.upper
);
2255 cpu_stq_user(env
, addr
+ 8, u
.ll
.lower
);
2257 case MMU_KERNEL_IDX
:
2259 cpu_stq_kernel(env
, addr
, u
.ll
.upper
);
2260 cpu_stq_kernel(env
, addr
+ 8, u
.ll
.lower
);
2262 #ifdef TARGET_SPARC64
2265 cpu_stq_hypv(env
, addr
, u
.ll
.upper
);
2266 cpu_stq_hypv(env
, addr
+ 8, u
.ll
.lower
);
2270 DPRINTF_MMU("helper_stqf: need to check MMU idx %d\n", mem_idx
);
2275 stq_raw(address_mask(env
, addr
), u
.ll
.upper
);
2276 stq_raw(address_mask(env
, addr
+ 8), u
.ll
.lower
);
2280 #if !defined(CONFIG_USER_ONLY)
2281 #ifndef TARGET_SPARC64
2282 void cpu_unassigned_access(CPUSPARCState
*env
, target_phys_addr_t addr
,
2283 int is_write
, int is_exec
, int is_asi
, int size
)
2287 #ifdef DEBUG_UNASSIGNED
2289 printf("Unassigned mem %s access of %d byte%s to " TARGET_FMT_plx
2290 " asi 0x%02x from " TARGET_FMT_lx
"\n",
2291 is_exec
? "exec" : is_write
? "write" : "read", size
,
2292 size
== 1 ? "" : "s", addr
, is_asi
, env
->pc
);
2294 printf("Unassigned mem %s access of %d byte%s to " TARGET_FMT_plx
2295 " from " TARGET_FMT_lx
"\n",
2296 is_exec
? "exec" : is_write
? "write" : "read", size
,
2297 size
== 1 ? "" : "s", addr
, env
->pc
);
2300 /* Don't overwrite translation and access faults */
2301 fault_type
= (env
->mmuregs
[3] & 0x1c) >> 2;
2302 if ((fault_type
> 4) || (fault_type
== 0)) {
2303 env
->mmuregs
[3] = 0; /* Fault status register */
2305 env
->mmuregs
[3] |= 1 << 16;
2308 env
->mmuregs
[3] |= 1 << 5;
2311 env
->mmuregs
[3] |= 1 << 6;
2314 env
->mmuregs
[3] |= 1 << 7;
2316 env
->mmuregs
[3] |= (5 << 2) | 2;
2317 /* SuperSPARC will never place instruction fault addresses in the FAR */
2319 env
->mmuregs
[4] = addr
; /* Fault address register */
2322 /* overflow (same type fault was not read before another fault) */
2323 if (fault_type
== ((env
->mmuregs
[3] & 0x1c)) >> 2) {
2324 env
->mmuregs
[3] |= 1;
2327 if ((env
->mmuregs
[0] & MMU_E
) && !(env
->mmuregs
[0] & MMU_NF
)) {
2329 helper_raise_exception(env
, TT_CODE_ACCESS
);
2331 helper_raise_exception(env
, TT_DATA_ACCESS
);
2335 /* flush neverland mappings created during no-fault mode,
2336 so the sequential MMU faults report proper fault types */
2337 if (env
->mmuregs
[0] & MMU_NF
) {
2342 void cpu_unassigned_access(CPUSPARCState
*env
, target_phys_addr_t addr
,
2343 int is_write
, int is_exec
, int is_asi
, int size
)
2345 #ifdef DEBUG_UNASSIGNED
2346 printf("Unassigned mem access to " TARGET_FMT_plx
" from " TARGET_FMT_lx
2347 "\n", addr
, env
->pc
);
2351 helper_raise_exception(env
, TT_CODE_ACCESS
);
2353 helper_raise_exception(env
, TT_DATA_ACCESS
);