2 * OpenRISC virtual CPU header.
4 * Copyright (c) 2011-2012 Jia Liu <proljc@gmail.com>
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.1 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/>.
20 #ifndef OPENRISC_CPU_H
21 #define OPENRISC_CPU_H
23 #include "exec/cpu-defs.h"
24 #include "fpu/softfloat-types.h"
25 #include "hw/core/cpu.h"
26 #include "qom/object.h"
28 #define TYPE_OPENRISC_CPU "or1k-cpu"
30 OBJECT_DECLARE_CPU_TYPE(OpenRISCCPU
, OpenRISCCPUClass
, OPENRISC_CPU
)
34 * @parent_realize: The parent class' realize handler.
35 * @parent_reset: The parent class' reset handler.
37 * A OpenRISC CPU model.
39 struct OpenRISCCPUClass
{
41 CPUClass parent_class
;
44 DeviceRealize parent_realize
;
45 DeviceReset parent_reset
;
48 #define TARGET_INSN_START_EXTRA_WORDS 1
52 MMU_SUPERVISOR_IDX
= 1,
56 #define SET_FP_CAUSE(reg, v) do {\
57 (reg) = ((reg) & ~(0x3f << 12)) | \
60 #define GET_FP_ENABLE(reg) (((reg) >> 7) & 0x1f)
61 #define UPDATE_FP_FLAGS(reg, v) do {\
62 (reg) |= ((v & 0x1f) << 2);\
68 /* Unit presece register */
81 UPR_CUP
= (255 << 24),
84 /* CPU configure register */
86 CPUCFGR_NSGF
= (15 << 0),
87 CPUCFGR_CGF
= (1 << 4),
88 CPUCFGR_OB32S
= (1 << 5),
89 CPUCFGR_OB64S
= (1 << 6),
90 CPUCFGR_OF32S
= (1 << 7),
91 CPUCFGR_OF64S
= (1 << 8),
92 CPUCFGR_OV64S
= (1 << 9),
93 CPUCFGR_ND
= (1 << 10),
94 CPUCFGR_AVRP
= (1 << 11),
95 CPUCFGR_EVBARP
= (1 << 12),
96 CPUCFGR_ISRP
= (1 << 13),
97 CPUCFGR_AECSRP
= (1 << 14),
98 CPUCFGR_OF64A32S
= (1 << 15),
101 /* DMMU configure register */
103 DMMUCFGR_NTW
= (3 << 0),
104 DMMUCFGR_NTS
= (7 << 2),
105 DMMUCFGR_NAE
= (7 << 5),
106 DMMUCFGR_CRI
= (1 << 8),
107 DMMUCFGR_PRI
= (1 << 9),
108 DMMUCFGR_TEIRI
= (1 << 10),
109 DMMUCFGR_HTR
= (1 << 11),
112 /* IMMU configure register */
114 IMMUCFGR_NTW
= (3 << 0),
115 IMMUCFGR_NTS
= (7 << 2),
116 IMMUCFGR_NAE
= (7 << 5),
117 IMMUCFGR_CRI
= (1 << 8),
118 IMMUCFGR_PRI
= (1 << 9),
119 IMMUCFGR_TEIRI
= (1 << 10),
120 IMMUCFGR_HTR
= (1 << 11),
123 /* Power management register */
132 /* Float point control status register */
136 FPCSR_OVF
= (1 << 3),
137 FPCSR_UNF
= (1 << 4),
138 FPCSR_SNF
= (1 << 5),
139 FPCSR_QNF
= (1 << 6),
141 FPCSR_IXF
= (1 << 8),
142 FPCSR_IVF
= (1 << 9),
143 FPCSR_INF
= (1 << 10),
144 FPCSR_DZF
= (1 << 11),
147 /* Exceptions indices */
166 /* Supervisor register */
184 SR_SUMRA
= (1 << 16),
188 /* Tick Timer Mode Register */
190 TTMR_TP
= (0xfffffff),
198 TIMER_NONE
= (0 << 30),
199 TIMER_INTR
= (1 << 30),
200 TIMER_SHOT
= (2 << 30),
201 TIMER_CONT
= (3 << 30),
207 TLB_MASK
= TLB_SIZE
- 1,
221 typedef struct OpenRISCTLBEntry
{
226 #ifndef CONFIG_USER_ONLY
227 typedef struct CPUOpenRISCTLBContext
{
228 OpenRISCTLBEntry itlb
[TLB_SIZE
];
229 OpenRISCTLBEntry dtlb
[TLB_SIZE
];
231 int (*cpu_openrisc_map_address_code
)(OpenRISCCPU
*cpu
,
234 target_ulong address
, int rw
);
235 int (*cpu_openrisc_map_address_data
)(OpenRISCCPU
*cpu
,
238 target_ulong address
, int rw
);
239 } CPUOpenRISCTLBContext
;
242 typedef struct CPUArchState
{
243 target_ulong shadow_gpr
[16][32]; /* Shadow registers */
245 target_ulong pc
; /* Program counter */
246 target_ulong ppc
; /* Prev PC */
247 target_ulong jmp_pc
; /* Jump PC */
249 uint64_t mac
; /* Multiply registers MACHI:MACLO */
251 target_ulong epcr
; /* Exception PC register */
252 target_ulong eear
; /* Exception EA register */
254 target_ulong sr_f
; /* the SR_F bit, values 0, 1. */
255 target_ulong sr_cy
; /* the SR_CY bit, values 0, 1. */
256 target_long sr_ov
; /* the SR_OV bit (in the sign bit only) */
257 uint32_t sr
; /* Supervisor register, without SR_{F,CY,OV} */
258 uint32_t esr
; /* Exception supervisor register */
259 uint32_t evbar
; /* Exception vector base address register */
260 uint32_t pmr
; /* Power Management Register */
261 uint32_t fpcsr
; /* Float register */
262 float_status fp_status
;
264 target_ulong lock_addr
;
265 target_ulong lock_value
;
267 uint32_t dflag
; /* In delay slot (boolean) */
269 #ifndef CONFIG_USER_ONLY
270 CPUOpenRISCTLBContext tlb
;
273 /* Fields up to this point are cleared by a CPU reset */
274 struct {} end_reset_fields
;
276 /* Fields from here on are preserved across CPU reset. */
277 uint32_t vr
; /* Version register */
278 uint32_t vr2
; /* Version register 2 */
279 uint32_t avr
; /* Architecture version register */
280 uint32_t upr
; /* Unit presence register */
281 uint32_t cpucfgr
; /* CPU configure register */
282 uint32_t dmmucfgr
; /* DMMU configure register */
283 uint32_t immucfgr
; /* IMMU configure register */
285 #ifndef CONFIG_USER_ONLY
287 uint32_t ttmr
; /* Timer tick mode register */
290 uint32_t picmr
; /* Interrupt mask register */
291 uint32_t picsr
; /* Interrupt contrl register*/
297 * @env: #CPUOpenRISCState
306 CPUNegativeOffsetState neg
;
307 CPUOpenRISCState env
;
311 void cpu_openrisc_list(void);
312 void openrisc_cpu_dump_state(CPUState
*cpu
, FILE *f
, int flags
);
313 hwaddr
openrisc_cpu_get_phys_page_debug(CPUState
*cpu
, vaddr addr
);
314 int openrisc_cpu_gdb_read_register(CPUState
*cpu
, GByteArray
*buf
, int reg
);
315 int openrisc_cpu_gdb_write_register(CPUState
*cpu
, uint8_t *buf
, int reg
);
316 void openrisc_translate_init(void);
317 int print_insn_or1k(bfd_vma addr
, disassemble_info
*info
);
319 #define cpu_list cpu_openrisc_list
321 #ifndef CONFIG_USER_ONLY
322 bool openrisc_cpu_tlb_fill(CPUState
*cs
, vaddr address
, int size
,
323 MMUAccessType access_type
, int mmu_idx
,
324 bool probe
, uintptr_t retaddr
);
326 extern const VMStateDescription vmstate_openrisc_cpu
;
328 void openrisc_cpu_do_interrupt(CPUState
*cpu
);
329 bool openrisc_cpu_exec_interrupt(CPUState
*cpu
, int int_req
);
331 /* hw/openrisc_pic.c */
332 void cpu_openrisc_pic_init(OpenRISCCPU
*cpu
);
334 /* hw/openrisc_timer.c */
335 void cpu_openrisc_clock_init(OpenRISCCPU
*cpu
);
336 uint32_t cpu_openrisc_count_get(OpenRISCCPU
*cpu
);
337 void cpu_openrisc_count_set(OpenRISCCPU
*cpu
, uint32_t val
);
338 void cpu_openrisc_count_update(OpenRISCCPU
*cpu
);
339 void cpu_openrisc_timer_update(OpenRISCCPU
*cpu
);
340 void cpu_openrisc_count_start(OpenRISCCPU
*cpu
);
341 void cpu_openrisc_count_stop(OpenRISCCPU
*cpu
);
344 #define OPENRISC_CPU_TYPE_SUFFIX "-" TYPE_OPENRISC_CPU
345 #define OPENRISC_CPU_TYPE_NAME(model) model OPENRISC_CPU_TYPE_SUFFIX
346 #define CPU_RESOLVING_TYPE TYPE_OPENRISC_CPU
348 #include "exec/cpu-all.h"
350 #define TB_FLAGS_SM SR_SM
351 #define TB_FLAGS_DME SR_DME
352 #define TB_FLAGS_IME SR_IME
353 #define TB_FLAGS_OVE SR_OVE
354 #define TB_FLAGS_DFLAG 2 /* reuse SR_TEE */
355 #define TB_FLAGS_R0_0 4 /* reuse SR_IEE */
357 static inline uint32_t cpu_get_gpr(const CPUOpenRISCState
*env
, int i
)
359 return env
->shadow_gpr
[0][i
];
362 static inline void cpu_set_gpr(CPUOpenRISCState
*env
, int i
, uint32_t val
)
364 env
->shadow_gpr
[0][i
] = val
;
367 static inline void cpu_get_tb_cpu_state(CPUOpenRISCState
*env
,
369 target_ulong
*cs_base
, uint32_t *flags
)
373 *flags
= (env
->dflag
? TB_FLAGS_DFLAG
: 0)
374 | (cpu_get_gpr(env
, 0) ? 0 : TB_FLAGS_R0_0
)
375 | (env
->sr
& (SR_SM
| SR_DME
| SR_IME
| SR_OVE
));
378 static inline int cpu_mmu_index(CPUOpenRISCState
*env
, bool ifetch
)
380 int ret
= MMU_NOMMU_IDX
; /* mmu is disabled */
382 if (env
->sr
& (ifetch
? SR_IME
: SR_DME
)) {
383 /* The mmu is enabled; test supervisor state. */
384 ret
= env
->sr
& SR_SM
? MMU_SUPERVISOR_IDX
: MMU_USER_IDX
;
390 static inline uint32_t cpu_get_sr(const CPUOpenRISCState
*env
)
395 + (env
->sr_ov
< 0) * SR_OV
);
398 static inline void cpu_set_sr(CPUOpenRISCState
*env
, uint32_t val
)
400 env
->sr_f
= (val
& SR_F
) != 0;
401 env
->sr_cy
= (val
& SR_CY
) != 0;
402 env
->sr_ov
= (val
& SR_OV
? -1 : 0);
403 env
->sr
= (val
& ~(SR_F
| SR_CY
| SR_OV
)) | SR_FO
;
406 void cpu_set_fpcsr(CPUOpenRISCState
*env
, uint32_t val
);
408 #define CPU_INTERRUPT_TIMER CPU_INTERRUPT_TGT_INT_0
410 #endif /* OPENRISC_CPU_H */