target/openrisc/cpu.h

   1 /*
   2  * OpenRISC virtual CPU header.
   3  *
   4  * Copyright (c) 2011-2012 Jia Liu <[email protected]>
   5  *
   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.
  10  *
  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.
  15  *
  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/>.
  18  */
  19
  20 #ifndef OPENRISC_CPU_H
  21 #define OPENRISC_CPU_H
  22
  23 #define TARGET_LONG_BITS 32
  24
  25 #define CPUArchState struct CPUOpenRISCState
  26
  27 /* cpu_openrisc_map_address_* in CPUOpenRISCTLBContext need this decl.  */
  28 struct OpenRISCCPU;
  29
  30 #include "qemu-common.h"
  31 #include "exec/cpu-defs.h"
  32 #include "fpu/softfloat.h"
  33 #include "qom/cpu.h"
  34
  35 #define TYPE_OPENRISC_CPU "or1k-cpu"
  36
  37 #define OPENRISC_CPU_CLASS(klass) \
  38     OBJECT_CLASS_CHECK(OpenRISCCPUClass, (klass), TYPE_OPENRISC_CPU)
  39 #define OPENRISC_CPU(obj) \
  40     OBJECT_CHECK(OpenRISCCPU, (obj), TYPE_OPENRISC_CPU)
  41 #define OPENRISC_CPU_GET_CLASS(obj) \
  42     OBJECT_GET_CLASS(OpenRISCCPUClass, (obj), TYPE_OPENRISC_CPU)
  43
  44 /**
  45  * OpenRISCCPUClass:
  46  * @parent_realize: The parent class' realize handler.
  47  * @parent_reset: The parent class' reset handler.
  48  *
  49  * A OpenRISC CPU model.
  50  */
  51 typedef struct OpenRISCCPUClass {
  52     /*< private >*/
  53     CPUClass parent_class;
  54     /*< public >*/
  55
  56     DeviceRealize parent_realize;
  57     void (*parent_reset)(CPUState *cpu);
  58 } OpenRISCCPUClass;
  59
  60 #define NB_MMU_MODES    3
  61 #define TARGET_INSN_START_EXTRA_WORDS 1
  62
  63 enum {
  64     MMU_NOMMU_IDX = 0,
  65     MMU_SUPERVISOR_IDX = 1,
  66     MMU_USER_IDX = 2,
  67 };
  68
  69 #define TARGET_PAGE_BITS 13
  70
  71 #define TARGET_PHYS_ADDR_SPACE_BITS 32
  72 #define TARGET_VIRT_ADDR_SPACE_BITS 32
  73
  74 #define SET_FP_CAUSE(reg, v)    do {\
  75                                     (reg) = ((reg) & ~(0x3f << 12)) | \
  76                                             ((v & 0x3f) << 12);\
  77                                 } while (0)
  78 #define GET_FP_ENABLE(reg)       (((reg) >>  7) & 0x1f)
  79 #define UPDATE_FP_FLAGS(reg, v)   do {\
  80                                       (reg) |= ((v & 0x1f) << 2);\
  81                                   } while (0)
  82
  83 /* Version Register */
  84 #define SPR_VR 0xFFFF003F
  85
  86 /* Interrupt */
  87 #define NR_IRQS  32
  88
  89 /* Unit presece register */
  90 enum {
  91     UPR_UP = (1 << 0),
  92     UPR_DCP = (1 << 1),
  93     UPR_ICP = (1 << 2),
  94     UPR_DMP = (1 << 3),
  95     UPR_IMP = (1 << 4),
  96     UPR_MP = (1 << 5),
  97     UPR_DUP = (1 << 6),
  98     UPR_PCUR = (1 << 7),
  99     UPR_PMP = (1 << 8),
 100     UPR_PICP = (1 << 9),
 101     UPR_TTP = (1 << 10),
 102     UPR_CUP = (255 << 24),
 103 };
 104
 105 /* CPU configure register */
 106 enum {
 107     CPUCFGR_NSGF = (15 << 0),
 108     CPUCFGR_CGF = (1 << 4),
 109     CPUCFGR_OB32S = (1 << 5),
 110     CPUCFGR_OB64S = (1 << 6),
 111     CPUCFGR_OF32S = (1 << 7),
 112     CPUCFGR_OF64S = (1 << 8),
 113     CPUCFGR_OV64S = (1 << 9),
 114     /* CPUCFGR_ND = (1 << 10), */
 115     /* CPUCFGR_AVRP = (1 << 11), */
 116     CPUCFGR_EVBARP = (1 << 12),
 117     /* CPUCFGR_ISRP = (1 << 13), */
 118     /* CPUCFGR_AECSRP = (1 << 14), */
 119 };
 120
 121 /* DMMU configure register */
 122 enum {
 123     DMMUCFGR_NTW = (3 << 0),
 124     DMMUCFGR_NTS = (7 << 2),
 125     DMMUCFGR_NAE = (7 << 5),
 126     DMMUCFGR_CRI = (1 << 8),
 127     DMMUCFGR_PRI = (1 << 9),
 128     DMMUCFGR_TEIRI = (1 << 10),
 129     DMMUCFGR_HTR = (1 << 11),
 130 };
 131
 132 /* IMMU configure register */
 133 enum {
 134     IMMUCFGR_NTW = (3 << 0),
 135     IMMUCFGR_NTS = (7 << 2),
 136     IMMUCFGR_NAE = (7 << 5),
 137     IMMUCFGR_CRI = (1 << 8),
 138     IMMUCFGR_PRI = (1 << 9),
 139     IMMUCFGR_TEIRI = (1 << 10),
 140     IMMUCFGR_HTR = (1 << 11),
 141 };
 142
 143 /* Float point control status register */
 144 enum {
 145     FPCSR_FPEE = 1,
 146     FPCSR_RM = (3 << 1),
 147     FPCSR_OVF = (1 << 3),
 148     FPCSR_UNF = (1 << 4),
 149     FPCSR_SNF = (1 << 5),
 150     FPCSR_QNF = (1 << 6),
 151     FPCSR_ZF = (1 << 7),
 152     FPCSR_IXF = (1 << 8),
 153     FPCSR_IVF = (1 << 9),
 154     FPCSR_INF = (1 << 10),
 155     FPCSR_DZF = (1 << 11),
 156 };
 157
 158 /* Exceptions indices */
 159 enum {
 160     EXCP_RESET    = 0x1,
 161     EXCP_BUSERR   = 0x2,
 162     EXCP_DPF      = 0x3,
 163     EXCP_IPF      = 0x4,
 164     EXCP_TICK     = 0x5,
 165     EXCP_ALIGN    = 0x6,
 166     EXCP_ILLEGAL  = 0x7,
 167     EXCP_INT      = 0x8,
 168     EXCP_DTLBMISS = 0x9,
 169     EXCP_ITLBMISS = 0xa,
 170     EXCP_RANGE    = 0xb,
 171     EXCP_SYSCALL  = 0xc,
 172     EXCP_FPE      = 0xd,
 173     EXCP_TRAP     = 0xe,
 174     EXCP_NR,
 175 };
 176
 177 /* Supervisor register */
 178 enum {
 179     SR_SM = (1 << 0),
 180     SR_TEE = (1 << 1),
 181     SR_IEE = (1 << 2),
 182     SR_DCE = (1 << 3),
 183     SR_ICE = (1 << 4),
 184     SR_DME = (1 << 5),
 185     SR_IME = (1 << 6),
 186     SR_LEE = (1 << 7),
 187     SR_CE  = (1 << 8),
 188     SR_F   = (1 << 9),
 189     SR_CY  = (1 << 10),
 190     SR_OV  = (1 << 11),
 191     SR_OVE = (1 << 12),
 192     SR_DSX = (1 << 13),
 193     SR_EPH = (1 << 14),
 194     SR_FO  = (1 << 15),
 195     SR_SUMRA = (1 << 16),
 196     SR_SCE = (1 << 17),
 197 };
 198
 199 /* OpenRISC Hardware Capabilities */
 200 enum {
 201     OPENRISC_FEATURE_NSGF = (15 << 0),
 202     OPENRISC_FEATURE_CGF = (1 << 4),
 203     OPENRISC_FEATURE_OB32S = (1 << 5),
 204     OPENRISC_FEATURE_OB64S = (1 << 6),
 205     OPENRISC_FEATURE_OF32S = (1 << 7),
 206     OPENRISC_FEATURE_OF64S = (1 << 8),
 207     OPENRISC_FEATURE_OV64S = (1 << 9),
 208     OPENRISC_FEATURE_EVBAR = (1 << 12),
 209 };
 210
 211 /* Tick Timer Mode Register */
 212 enum {
 213     TTMR_TP = (0xfffffff),
 214     TTMR_IP = (1 << 28),
 215     TTMR_IE = (1 << 29),
 216     TTMR_M  = (3 << 30),
 217 };
 218
 219 /* Timer Mode */
 220 enum {
 221     TIMER_NONE = (0 << 30),
 222     TIMER_INTR = (1 << 30),
 223     TIMER_SHOT = (2 << 30),
 224     TIMER_CONT = (3 << 30),
 225 };
 226
 227 /* TLB size */
 228 enum {
 229     DTLB_WAYS = 1,
 230     DTLB_SIZE = 64,
 231     DTLB_MASK = (DTLB_SIZE-1),
 232     ITLB_WAYS = 1,
 233     ITLB_SIZE = 64,
 234     ITLB_MASK = (ITLB_SIZE-1),
 235 };
 236
 237 /* TLB prot */
 238 enum {
 239     URE = (1 << 6),
 240     UWE = (1 << 7),
 241     SRE = (1 << 8),
 242     SWE = (1 << 9),
 243
 244     SXE = (1 << 6),
 245     UXE = (1 << 7),
 246 };
 247
 248 /* check if tlb available */
 249 enum {
 250     TLBRET_INVALID = -3,
 251     TLBRET_NOMATCH = -2,
 252     TLBRET_BADADDR = -1,
 253     TLBRET_MATCH = 0
 254 };
 255
 256 typedef struct OpenRISCTLBEntry {
 257     uint32_t mr;
 258     uint32_t tr;
 259 } OpenRISCTLBEntry;
 260
 261 #ifndef CONFIG_USER_ONLY
 262 typedef struct CPUOpenRISCTLBContext {
 263     OpenRISCTLBEntry itlb[ITLB_WAYS][ITLB_SIZE];
 264     OpenRISCTLBEntry dtlb[DTLB_WAYS][DTLB_SIZE];
 265
 266     int (*cpu_openrisc_map_address_code)(struct OpenRISCCPU *cpu,
 267                                          hwaddr *physical,
 268                                          int *prot,
 269                                          target_ulong address, int rw);
 270     int (*cpu_openrisc_map_address_data)(struct OpenRISCCPU *cpu,
 271                                          hwaddr *physical,
 272                                          int *prot,
 273                                          target_ulong address, int rw);
 274 } CPUOpenRISCTLBContext;
 275 #endif
 276
 277 typedef struct CPUOpenRISCState {
 278     target_ulong gpr[32];     /* General registers */
 279     target_ulong pc;          /* Program counter */
 280     target_ulong ppc;         /* Prev PC */
 281     target_ulong jmp_pc;      /* Jump PC */
 282
 283     uint64_t mac;             /* Multiply registers MACHI:MACLO */
 284
 285     target_ulong epcr;        /* Exception PC register */
 286     target_ulong eear;        /* Exception EA register */
 287
 288     target_ulong sr_f;        /* the SR_F bit, values 0, 1.  */
 289     target_ulong sr_cy;       /* the SR_CY bit, values 0, 1.  */
 290     target_long  sr_ov;       /* the SR_OV bit (in the sign bit only) */
 291     uint32_t sr;              /* Supervisor register, without SR_{F,CY,OV} */
 292     uint32_t vr;              /* Version register */
 293     uint32_t upr;             /* Unit presence register */
 294     uint32_t cpucfgr;         /* CPU configure register */
 295     uint32_t dmmucfgr;        /* DMMU configure register */
 296     uint32_t immucfgr;        /* IMMU configure register */
 297     uint32_t esr;             /* Exception supervisor register */
 298     uint32_t evbar;           /* Exception vector base address register */
 299     uint32_t fpcsr;           /* Float register */
 300     float_status fp_status;
 301
 302     target_ulong lock_addr;
 303     target_ulong lock_value;
 304
 305     uint32_t dflag;           /* In delay slot (boolean) */
 306
 307     /* Fields up to this point are cleared by a CPU reset */
 308     struct {} end_reset_fields;
 309
 310     CPU_COMMON
 311
 312     /* Fields from here on are preserved across CPU reset. */
 313 #ifndef CONFIG_USER_ONLY
 314     CPUOpenRISCTLBContext * tlb;
 315
 316     QEMUTimer *timer;
 317     uint32_t ttmr;          /* Timer tick mode register */
 318     uint32_t ttcr;          /* Timer tick count register */
 319
 320     uint32_t picmr;         /* Interrupt mask register */
 321     uint32_t picsr;         /* Interrupt contrl register*/
 322 #endif
 323     void *irq[32];          /* Interrupt irq input */
 324 } CPUOpenRISCState;
 325
 326 /**
 327  * OpenRISCCPU:
 328  * @env: #CPUOpenRISCState
 329  *
 330  * A OpenRISC CPU.
 331  */
 332 typedef struct OpenRISCCPU {
 333     /*< private >*/
 334     CPUState parent_obj;
 335     /*< public >*/
 336
 337     CPUOpenRISCState env;
 338
 339     uint32_t feature;       /* CPU Capabilities */
 340 } OpenRISCCPU;
 341
 342 static inline OpenRISCCPU *openrisc_env_get_cpu(CPUOpenRISCState *env)
 343 {
 344     return container_of(env, OpenRISCCPU, env);
 345 }
 346
 347 #define ENV_GET_CPU(e) CPU(openrisc_env_get_cpu(e))
 348
 349 #define ENV_OFFSET offsetof(OpenRISCCPU, env)
 350
 351 OpenRISCCPU *cpu_openrisc_init(const char *cpu_model);
 352
 353 void cpu_openrisc_list(FILE *f, fprintf_function cpu_fprintf);
 354 void openrisc_cpu_do_interrupt(CPUState *cpu);
 355 bool openrisc_cpu_exec_interrupt(CPUState *cpu, int int_req);
 356 void openrisc_cpu_dump_state(CPUState *cpu, FILE *f,
 357                              fprintf_function cpu_fprintf, int flags);
 358 hwaddr openrisc_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
 359 int openrisc_cpu_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg);
 360 int openrisc_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);
 361 void openrisc_translate_init(void);
 362 int openrisc_cpu_handle_mmu_fault(CPUState *cpu, vaddr address,
 363                                   int rw, int mmu_idx);
 364 int cpu_openrisc_signal_handler(int host_signum, void *pinfo, void *puc);
 365
 366 #define cpu_list cpu_openrisc_list
 367 #define cpu_signal_handler cpu_openrisc_signal_handler
 368
 369 #ifndef CONFIG_USER_ONLY
 370 extern const struct VMStateDescription vmstate_openrisc_cpu;
 371
 372 /* hw/openrisc_pic.c */
 373 void cpu_openrisc_pic_init(OpenRISCCPU *cpu);
 374
 375 /* hw/openrisc_timer.c */
 376 void cpu_openrisc_clock_init(OpenRISCCPU *cpu);
 377 void cpu_openrisc_count_update(OpenRISCCPU *cpu);
 378 void cpu_openrisc_timer_update(OpenRISCCPU *cpu);
 379 void cpu_openrisc_count_start(OpenRISCCPU *cpu);
 380 void cpu_openrisc_count_stop(OpenRISCCPU *cpu);
 381
 382 void cpu_openrisc_mmu_init(OpenRISCCPU *cpu);
 383 int cpu_openrisc_get_phys_nommu(OpenRISCCPU *cpu,
 384                                 hwaddr *physical,
 385                                 int *prot, target_ulong address, int rw);
 386 int cpu_openrisc_get_phys_code(OpenRISCCPU *cpu,
 387                                hwaddr *physical,
 388                                int *prot, target_ulong address, int rw);
 389 int cpu_openrisc_get_phys_data(OpenRISCCPU *cpu,
 390                                hwaddr *physical,
 391                                int *prot, target_ulong address, int rw);
 392 #endif
 393
 394 #define cpu_init(cpu_model) CPU(cpu_openrisc_init(cpu_model))
 395
 396 #include "exec/cpu-all.h"
 397
 398 #define TB_FLAGS_DFLAG 1
 399 #define TB_FLAGS_R0_0  2
 400 #define TB_FLAGS_OVE   SR_OVE
 401
 402 static inline void cpu_get_tb_cpu_state(CPUOpenRISCState *env,
 403                                         target_ulong *pc,
 404                                         target_ulong *cs_base, uint32_t *flags)
 405 {
 406     *pc = env->pc;
 407     *cs_base = 0;
 408     *flags = (env->dflag
 409               | (env->gpr[0] == 0 ? TB_FLAGS_R0_0 : 0)
 410               | (env->sr & SR_OVE));
 411 }
 412
 413 static inline int cpu_mmu_index(CPUOpenRISCState *env, bool ifetch)
 414 {
 415     if (!(env->sr & SR_IME)) {
 416         return MMU_NOMMU_IDX;
 417     }
 418     return (env->sr & SR_SM) == 0 ? MMU_USER_IDX : MMU_SUPERVISOR_IDX;
 419 }
 420
 421 static inline uint32_t cpu_get_sr(const CPUOpenRISCState *env)
 422 {
 423     return (env->sr
 424             + env->sr_f * SR_F
 425             + env->sr_cy * SR_CY
 426             + (env->sr_ov < 0) * SR_OV);
 427 }
 428
 429 static inline void cpu_set_sr(CPUOpenRISCState *env, uint32_t val)
 430 {
 431     env->sr_f = (val & SR_F) != 0;
 432     env->sr_cy = (val & SR_CY) != 0;
 433     env->sr_ov = (val & SR_OV ? -1 : 0);
 434     env->sr = (val & ~(SR_F | SR_CY | SR_OV)) | SR_FO;
 435 }
 436
 437 #define CPU_INTERRUPT_TIMER   CPU_INTERRUPT_TGT_INT_0
 438
 439 #endif /* OPENRISC_CPU_H */