2 * PowerPC CPU initialization for qemu.
4 * Copyright (c) 2003-2007 Jocelyn Mayer
5 * Copyright 2011 Freescale Semiconductor, Inc.
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
21 /* A lot of PowerPC definition have been included here.
22 * Most of them are not usable for now but have been kept
23 * inside "#if defined(TODO) ... #endif" statements to make tests easier.
31 //#define PPC_DUMP_CPU
32 //#define PPC_DEBUG_SPR
33 //#define PPC_DUMP_SPR_ACCESSES
34 #if defined(CONFIG_USER_ONLY)
35 #define TODO_USER_ONLY 1
38 /* For user-mode emulation, we don't emulate any IRQ controller */
39 #if defined(CONFIG_USER_ONLY)
40 #define PPC_IRQ_INIT_FN(name) \
41 static inline void glue(glue(ppc, name),_irq_init) (CPUPPCState *env) \
45 #define PPC_IRQ_INIT_FN(name) \
46 void glue(glue(ppc, name),_irq_init) (CPUPPCState *env);
52 PPC_IRQ_INIT_FN(POWER7
);
53 PPC_IRQ_INIT_FN(e500
);
56 * do nothing but store/retrieve spr value
58 static void spr_read_generic (void *opaque
, int gprn
, int sprn
)
60 gen_load_spr(cpu_gpr
[gprn
], sprn
);
61 #ifdef PPC_DUMP_SPR_ACCESSES
63 TCGv_i32 t0
= tcg_const_i32(sprn
);
64 gen_helper_load_dump_spr(t0
);
65 tcg_temp_free_i32(t0
);
70 static void spr_write_generic (void *opaque
, int sprn
, int gprn
)
72 gen_store_spr(sprn
, cpu_gpr
[gprn
]);
73 #ifdef PPC_DUMP_SPR_ACCESSES
75 TCGv_i32 t0
= tcg_const_i32(sprn
);
76 gen_helper_store_dump_spr(t0
);
77 tcg_temp_free_i32(t0
);
82 #if !defined(CONFIG_USER_ONLY)
83 static void spr_write_clear (void *opaque
, int sprn
, int gprn
)
85 TCGv t0
= tcg_temp_new();
86 TCGv t1
= tcg_temp_new();
87 gen_load_spr(t0
, sprn
);
88 tcg_gen_neg_tl(t1
, cpu_gpr
[gprn
]);
89 tcg_gen_and_tl(t0
, t0
, t1
);
90 gen_store_spr(sprn
, t0
);
96 /* SPR common to all PowerPC */
98 static void spr_read_xer (void *opaque
, int gprn
, int sprn
)
100 tcg_gen_mov_tl(cpu_gpr
[gprn
], cpu_xer
);
103 static void spr_write_xer (void *opaque
, int sprn
, int gprn
)
105 tcg_gen_mov_tl(cpu_xer
, cpu_gpr
[gprn
]);
109 static void spr_read_lr (void *opaque
, int gprn
, int sprn
)
111 tcg_gen_mov_tl(cpu_gpr
[gprn
], cpu_lr
);
114 static void spr_write_lr (void *opaque
, int sprn
, int gprn
)
116 tcg_gen_mov_tl(cpu_lr
, cpu_gpr
[gprn
]);
120 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
121 static void spr_read_cfar (void *opaque
, int gprn
, int sprn
)
123 tcg_gen_mov_tl(cpu_gpr
[gprn
], cpu_cfar
);
126 static void spr_write_cfar (void *opaque
, int sprn
, int gprn
)
128 tcg_gen_mov_tl(cpu_cfar
, cpu_gpr
[gprn
]);
130 #endif /* defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY) */
133 static void spr_read_ctr (void *opaque
, int gprn
, int sprn
)
135 tcg_gen_mov_tl(cpu_gpr
[gprn
], cpu_ctr
);
138 static void spr_write_ctr (void *opaque
, int sprn
, int gprn
)
140 tcg_gen_mov_tl(cpu_ctr
, cpu_gpr
[gprn
]);
143 /* User read access to SPR */
149 static void spr_read_ureg (void *opaque
, int gprn
, int sprn
)
151 gen_load_spr(cpu_gpr
[gprn
], sprn
+ 0x10);
154 /* SPR common to all non-embedded PowerPC */
156 #if !defined(CONFIG_USER_ONLY)
157 static void spr_read_decr (void *opaque
, int gprn
, int sprn
)
162 gen_helper_load_decr(cpu_gpr
[gprn
]);
165 gen_stop_exception(opaque
);
169 static void spr_write_decr (void *opaque
, int sprn
, int gprn
)
174 gen_helper_store_decr(cpu_gpr
[gprn
]);
177 gen_stop_exception(opaque
);
182 /* SPR common to all non-embedded PowerPC, except 601 */
184 static void spr_read_tbl (void *opaque
, int gprn
, int sprn
)
189 gen_helper_load_tbl(cpu_gpr
[gprn
]);
192 gen_stop_exception(opaque
);
196 static void spr_read_tbu (void *opaque
, int gprn
, int sprn
)
201 gen_helper_load_tbu(cpu_gpr
[gprn
]);
204 gen_stop_exception(opaque
);
208 __attribute__ (( unused
))
209 static void spr_read_atbl (void *opaque
, int gprn
, int sprn
)
211 gen_helper_load_atbl(cpu_gpr
[gprn
]);
214 __attribute__ (( unused
))
215 static void spr_read_atbu (void *opaque
, int gprn
, int sprn
)
217 gen_helper_load_atbu(cpu_gpr
[gprn
]);
220 #if !defined(CONFIG_USER_ONLY)
221 static void spr_write_tbl (void *opaque
, int sprn
, int gprn
)
226 gen_helper_store_tbl(cpu_gpr
[gprn
]);
229 gen_stop_exception(opaque
);
233 static void spr_write_tbu (void *opaque
, int sprn
, int gprn
)
238 gen_helper_store_tbu(cpu_gpr
[gprn
]);
241 gen_stop_exception(opaque
);
245 __attribute__ (( unused
))
246 static void spr_write_atbl (void *opaque
, int sprn
, int gprn
)
248 gen_helper_store_atbl(cpu_gpr
[gprn
]);
251 __attribute__ (( unused
))
252 static void spr_write_atbu (void *opaque
, int sprn
, int gprn
)
254 gen_helper_store_atbu(cpu_gpr
[gprn
]);
257 #if defined(TARGET_PPC64)
258 __attribute__ (( unused
))
259 static void spr_read_purr (void *opaque
, int gprn
, int sprn
)
261 gen_helper_load_purr(cpu_gpr
[gprn
]);
266 #if !defined(CONFIG_USER_ONLY)
267 /* IBAT0U...IBAT0U */
268 /* IBAT0L...IBAT7L */
269 static void spr_read_ibat (void *opaque
, int gprn
, int sprn
)
271 tcg_gen_ld_tl(cpu_gpr
[gprn
], cpu_env
, offsetof(CPUState
, IBAT
[sprn
& 1][(sprn
- SPR_IBAT0U
) / 2]));
274 static void spr_read_ibat_h (void *opaque
, int gprn
, int sprn
)
276 tcg_gen_ld_tl(cpu_gpr
[gprn
], cpu_env
, offsetof(CPUState
, IBAT
[sprn
& 1][(sprn
- SPR_IBAT4U
) / 2]));
279 static void spr_write_ibatu (void *opaque
, int sprn
, int gprn
)
281 TCGv_i32 t0
= tcg_const_i32((sprn
- SPR_IBAT0U
) / 2);
282 gen_helper_store_ibatu(t0
, cpu_gpr
[gprn
]);
283 tcg_temp_free_i32(t0
);
286 static void spr_write_ibatu_h (void *opaque
, int sprn
, int gprn
)
288 TCGv_i32 t0
= tcg_const_i32(((sprn
- SPR_IBAT4U
) / 2) + 4);
289 gen_helper_store_ibatu(t0
, cpu_gpr
[gprn
]);
290 tcg_temp_free_i32(t0
);
293 static void spr_write_ibatl (void *opaque
, int sprn
, int gprn
)
295 TCGv_i32 t0
= tcg_const_i32((sprn
- SPR_IBAT0L
) / 2);
296 gen_helper_store_ibatl(t0
, cpu_gpr
[gprn
]);
297 tcg_temp_free_i32(t0
);
300 static void spr_write_ibatl_h (void *opaque
, int sprn
, int gprn
)
302 TCGv_i32 t0
= tcg_const_i32(((sprn
- SPR_IBAT4L
) / 2) + 4);
303 gen_helper_store_ibatl(t0
, cpu_gpr
[gprn
]);
304 tcg_temp_free_i32(t0
);
307 /* DBAT0U...DBAT7U */
308 /* DBAT0L...DBAT7L */
309 static void spr_read_dbat (void *opaque
, int gprn
, int sprn
)
311 tcg_gen_ld_tl(cpu_gpr
[gprn
], cpu_env
, offsetof(CPUState
, DBAT
[sprn
& 1][(sprn
- SPR_DBAT0U
) / 2]));
314 static void spr_read_dbat_h (void *opaque
, int gprn
, int sprn
)
316 tcg_gen_ld_tl(cpu_gpr
[gprn
], cpu_env
, offsetof(CPUState
, DBAT
[sprn
& 1][((sprn
- SPR_DBAT4U
) / 2) + 4]));
319 static void spr_write_dbatu (void *opaque
, int sprn
, int gprn
)
321 TCGv_i32 t0
= tcg_const_i32((sprn
- SPR_DBAT0U
) / 2);
322 gen_helper_store_dbatu(t0
, cpu_gpr
[gprn
]);
323 tcg_temp_free_i32(t0
);
326 static void spr_write_dbatu_h (void *opaque
, int sprn
, int gprn
)
328 TCGv_i32 t0
= tcg_const_i32(((sprn
- SPR_DBAT4U
) / 2) + 4);
329 gen_helper_store_dbatu(t0
, cpu_gpr
[gprn
]);
330 tcg_temp_free_i32(t0
);
333 static void spr_write_dbatl (void *opaque
, int sprn
, int gprn
)
335 TCGv_i32 t0
= tcg_const_i32((sprn
- SPR_DBAT0L
) / 2);
336 gen_helper_store_dbatl(t0
, cpu_gpr
[gprn
]);
337 tcg_temp_free_i32(t0
);
340 static void spr_write_dbatl_h (void *opaque
, int sprn
, int gprn
)
342 TCGv_i32 t0
= tcg_const_i32(((sprn
- SPR_DBAT4L
) / 2) + 4);
343 gen_helper_store_dbatl(t0
, cpu_gpr
[gprn
]);
344 tcg_temp_free_i32(t0
);
348 static void spr_write_sdr1 (void *opaque
, int sprn
, int gprn
)
350 gen_helper_store_sdr1(cpu_gpr
[gprn
]);
353 /* 64 bits PowerPC specific SPRs */
355 #if defined(TARGET_PPC64)
356 static void spr_read_hior (void *opaque
, int gprn
, int sprn
)
358 tcg_gen_ld_tl(cpu_gpr
[gprn
], cpu_env
, offsetof(CPUState
, excp_prefix
));
361 static void spr_write_hior (void *opaque
, int sprn
, int gprn
)
363 TCGv t0
= tcg_temp_new();
364 tcg_gen_andi_tl(t0
, cpu_gpr
[gprn
], 0x3FFFFF00000ULL
);
365 tcg_gen_st_tl(t0
, cpu_env
, offsetof(CPUState
, excp_prefix
));
369 static void spr_read_asr (void *opaque
, int gprn
, int sprn
)
371 tcg_gen_ld_tl(cpu_gpr
[gprn
], cpu_env
, offsetof(CPUState
, asr
));
374 static void spr_write_asr (void *opaque
, int sprn
, int gprn
)
376 gen_helper_store_asr(cpu_gpr
[gprn
]);
381 /* PowerPC 601 specific registers */
383 static void spr_read_601_rtcl (void *opaque
, int gprn
, int sprn
)
385 gen_helper_load_601_rtcl(cpu_gpr
[gprn
]);
388 static void spr_read_601_rtcu (void *opaque
, int gprn
, int sprn
)
390 gen_helper_load_601_rtcu(cpu_gpr
[gprn
]);
393 #if !defined(CONFIG_USER_ONLY)
394 static void spr_write_601_rtcu (void *opaque
, int sprn
, int gprn
)
396 gen_helper_store_601_rtcu(cpu_gpr
[gprn
]);
399 static void spr_write_601_rtcl (void *opaque
, int sprn
, int gprn
)
401 gen_helper_store_601_rtcl(cpu_gpr
[gprn
]);
404 static void spr_write_hid0_601 (void *opaque
, int sprn
, int gprn
)
406 DisasContext
*ctx
= opaque
;
408 gen_helper_store_hid0_601(cpu_gpr
[gprn
]);
409 /* Must stop the translation as endianness may have changed */
410 gen_stop_exception(ctx
);
415 #if !defined(CONFIG_USER_ONLY)
416 static void spr_read_601_ubat (void *opaque
, int gprn
, int sprn
)
418 tcg_gen_ld_tl(cpu_gpr
[gprn
], cpu_env
, offsetof(CPUState
, IBAT
[sprn
& 1][(sprn
- SPR_IBAT0U
) / 2]));
421 static void spr_write_601_ubatu (void *opaque
, int sprn
, int gprn
)
423 TCGv_i32 t0
= tcg_const_i32((sprn
- SPR_IBAT0U
) / 2);
424 gen_helper_store_601_batl(t0
, cpu_gpr
[gprn
]);
425 tcg_temp_free_i32(t0
);
428 static void spr_write_601_ubatl (void *opaque
, int sprn
, int gprn
)
430 TCGv_i32 t0
= tcg_const_i32((sprn
- SPR_IBAT0U
) / 2);
431 gen_helper_store_601_batu(t0
, cpu_gpr
[gprn
]);
432 tcg_temp_free_i32(t0
);
436 /* PowerPC 40x specific registers */
437 #if !defined(CONFIG_USER_ONLY)
438 static void spr_read_40x_pit (void *opaque
, int gprn
, int sprn
)
440 gen_helper_load_40x_pit(cpu_gpr
[gprn
]);
443 static void spr_write_40x_pit (void *opaque
, int sprn
, int gprn
)
445 gen_helper_store_40x_pit(cpu_gpr
[gprn
]);
448 static void spr_write_40x_dbcr0 (void *opaque
, int sprn
, int gprn
)
450 DisasContext
*ctx
= opaque
;
452 gen_helper_store_40x_dbcr0(cpu_gpr
[gprn
]);
453 /* We must stop translation as we may have rebooted */
454 gen_stop_exception(ctx
);
457 static void spr_write_40x_sler (void *opaque
, int sprn
, int gprn
)
459 gen_helper_store_40x_sler(cpu_gpr
[gprn
]);
462 static void spr_write_booke_tcr (void *opaque
, int sprn
, int gprn
)
464 gen_helper_store_booke_tcr(cpu_gpr
[gprn
]);
467 static void spr_write_booke_tsr (void *opaque
, int sprn
, int gprn
)
469 gen_helper_store_booke_tsr(cpu_gpr
[gprn
]);
473 /* PowerPC 403 specific registers */
474 /* PBL1 / PBU1 / PBL2 / PBU2 */
475 #if !defined(CONFIG_USER_ONLY)
476 static void spr_read_403_pbr (void *opaque
, int gprn
, int sprn
)
478 tcg_gen_ld_tl(cpu_gpr
[gprn
], cpu_env
, offsetof(CPUState
, pb
[sprn
- SPR_403_PBL1
]));
481 static void spr_write_403_pbr (void *opaque
, int sprn
, int gprn
)
483 TCGv_i32 t0
= tcg_const_i32(sprn
- SPR_403_PBL1
);
484 gen_helper_store_403_pbr(t0
, cpu_gpr
[gprn
]);
485 tcg_temp_free_i32(t0
);
488 static void spr_write_pir (void *opaque
, int sprn
, int gprn
)
490 TCGv t0
= tcg_temp_new();
491 tcg_gen_andi_tl(t0
, cpu_gpr
[gprn
], 0xF);
492 gen_store_spr(SPR_PIR
, t0
);
497 /* SPE specific registers */
498 static void spr_read_spefscr (void *opaque
, int gprn
, int sprn
)
500 TCGv_i32 t0
= tcg_temp_new_i32();
501 tcg_gen_ld_i32(t0
, cpu_env
, offsetof(CPUState
, spe_fscr
));
502 tcg_gen_extu_i32_tl(cpu_gpr
[gprn
], t0
);
503 tcg_temp_free_i32(t0
);
506 static void spr_write_spefscr (void *opaque
, int sprn
, int gprn
)
508 TCGv_i32 t0
= tcg_temp_new_i32();
509 tcg_gen_trunc_tl_i32(t0
, cpu_gpr
[gprn
]);
510 tcg_gen_st_i32(t0
, cpu_env
, offsetof(CPUState
, spe_fscr
));
511 tcg_temp_free_i32(t0
);
514 #if !defined(CONFIG_USER_ONLY)
515 /* Callback used to write the exception vector base */
516 static void spr_write_excp_prefix (void *opaque
, int sprn
, int gprn
)
518 TCGv t0
= tcg_temp_new();
519 tcg_gen_ld_tl(t0
, cpu_env
, offsetof(CPUState
, ivpr_mask
));
520 tcg_gen_and_tl(t0
, t0
, cpu_gpr
[gprn
]);
521 tcg_gen_st_tl(t0
, cpu_env
, offsetof(CPUState
, excp_prefix
));
522 gen_store_spr(sprn
, t0
);
526 static void spr_write_excp_vector (void *opaque
, int sprn
, int gprn
)
528 DisasContext
*ctx
= opaque
;
531 if (sprn
>= SPR_BOOKE_IVOR0
&& sprn
<= SPR_BOOKE_IVOR15
) {
532 sprn_offs
= sprn
- SPR_BOOKE_IVOR0
;
533 } else if (sprn
>= SPR_BOOKE_IVOR32
&& sprn
<= SPR_BOOKE_IVOR37
) {
534 sprn_offs
= sprn
- SPR_BOOKE_IVOR32
+ 32;
535 } else if (sprn
>= SPR_BOOKE_IVOR38
&& sprn
<= SPR_BOOKE_IVOR42
) {
536 sprn_offs
= sprn
- SPR_BOOKE_IVOR38
+ 38;
538 printf("Trying to write an unknown exception vector %d %03x\n",
540 gen_inval_exception(ctx
, POWERPC_EXCP_PRIV_REG
);
544 TCGv t0
= tcg_temp_new();
545 tcg_gen_ld_tl(t0
, cpu_env
, offsetof(CPUState
, ivor_mask
));
546 tcg_gen_and_tl(t0
, t0
, cpu_gpr
[gprn
]);
547 tcg_gen_st_tl(t0
, cpu_env
, offsetof(CPUState
, excp_vectors
[sprn_offs
]));
548 gen_store_spr(sprn
, t0
);
553 static inline void vscr_init (CPUPPCState
*env
, uint32_t val
)
556 /* Altivec always uses round-to-nearest */
557 set_float_rounding_mode(float_round_nearest_even
, &env
->vec_status
);
558 set_flush_to_zero(vscr_nj
, &env
->vec_status
);
561 #if defined(CONFIG_USER_ONLY)
562 #define spr_register(env, num, name, uea_read, uea_write, \
563 oea_read, oea_write, initial_value) \
565 _spr_register(env, num, name, uea_read, uea_write, initial_value); \
567 static inline void _spr_register (CPUPPCState
*env
, int num
,
569 void (*uea_read
)(void *opaque
, int gprn
, int sprn
),
570 void (*uea_write
)(void *opaque
, int sprn
, int gprn
),
571 target_ulong initial_value
)
573 static inline void spr_register (CPUPPCState
*env
, int num
,
575 void (*uea_read
)(void *opaque
, int gprn
, int sprn
),
576 void (*uea_write
)(void *opaque
, int sprn
, int gprn
),
577 void (*oea_read
)(void *opaque
, int gprn
, int sprn
),
578 void (*oea_write
)(void *opaque
, int sprn
, int gprn
),
579 target_ulong initial_value
)
584 spr
= &env
->spr_cb
[num
];
585 if (spr
->name
!= NULL
||env
-> spr
[num
] != 0x00000000 ||
586 #if !defined(CONFIG_USER_ONLY)
587 spr
->oea_read
!= NULL
|| spr
->oea_write
!= NULL
||
589 spr
->uea_read
!= NULL
|| spr
->uea_write
!= NULL
) {
590 printf("Error: Trying to register SPR %d (%03x) twice !\n", num
, num
);
593 #if defined(PPC_DEBUG_SPR)
594 printf("*** register spr %d (%03x) %s val " TARGET_FMT_lx
"\n", num
, num
,
595 name
, initial_value
);
598 spr
->uea_read
= uea_read
;
599 spr
->uea_write
= uea_write
;
600 #if !defined(CONFIG_USER_ONLY)
601 spr
->oea_read
= oea_read
;
602 spr
->oea_write
= oea_write
;
604 env
->spr
[num
] = initial_value
;
607 /* Generic PowerPC SPRs */
608 static void gen_spr_generic (CPUPPCState
*env
)
610 /* Integer processing */
611 spr_register(env
, SPR_XER
, "XER",
612 &spr_read_xer
, &spr_write_xer
,
613 &spr_read_xer
, &spr_write_xer
,
616 spr_register(env
, SPR_LR
, "LR",
617 &spr_read_lr
, &spr_write_lr
,
618 &spr_read_lr
, &spr_write_lr
,
620 spr_register(env
, SPR_CTR
, "CTR",
621 &spr_read_ctr
, &spr_write_ctr
,
622 &spr_read_ctr
, &spr_write_ctr
,
624 /* Interrupt processing */
625 spr_register(env
, SPR_SRR0
, "SRR0",
626 SPR_NOACCESS
, SPR_NOACCESS
,
627 &spr_read_generic
, &spr_write_generic
,
629 spr_register(env
, SPR_SRR1
, "SRR1",
630 SPR_NOACCESS
, SPR_NOACCESS
,
631 &spr_read_generic
, &spr_write_generic
,
633 /* Processor control */
634 spr_register(env
, SPR_SPRG0
, "SPRG0",
635 SPR_NOACCESS
, SPR_NOACCESS
,
636 &spr_read_generic
, &spr_write_generic
,
638 spr_register(env
, SPR_SPRG1
, "SPRG1",
639 SPR_NOACCESS
, SPR_NOACCESS
,
640 &spr_read_generic
, &spr_write_generic
,
642 spr_register(env
, SPR_SPRG2
, "SPRG2",
643 SPR_NOACCESS
, SPR_NOACCESS
,
644 &spr_read_generic
, &spr_write_generic
,
646 spr_register(env
, SPR_SPRG3
, "SPRG3",
647 SPR_NOACCESS
, SPR_NOACCESS
,
648 &spr_read_generic
, &spr_write_generic
,
652 /* SPR common to all non-embedded PowerPC, including 601 */
653 static void gen_spr_ne_601 (CPUPPCState
*env
)
655 /* Exception processing */
656 spr_register(env
, SPR_DSISR
, "DSISR",
657 SPR_NOACCESS
, SPR_NOACCESS
,
658 &spr_read_generic
, &spr_write_generic
,
660 spr_register(env
, SPR_DAR
, "DAR",
661 SPR_NOACCESS
, SPR_NOACCESS
,
662 &spr_read_generic
, &spr_write_generic
,
665 spr_register(env
, SPR_DECR
, "DECR",
666 SPR_NOACCESS
, SPR_NOACCESS
,
667 &spr_read_decr
, &spr_write_decr
,
669 /* Memory management */
670 spr_register(env
, SPR_SDR1
, "SDR1",
671 SPR_NOACCESS
, SPR_NOACCESS
,
672 &spr_read_generic
, &spr_write_sdr1
,
677 static void gen_low_BATs (CPUPPCState
*env
)
679 #if !defined(CONFIG_USER_ONLY)
680 spr_register(env
, SPR_IBAT0U
, "IBAT0U",
681 SPR_NOACCESS
, SPR_NOACCESS
,
682 &spr_read_ibat
, &spr_write_ibatu
,
684 spr_register(env
, SPR_IBAT0L
, "IBAT0L",
685 SPR_NOACCESS
, SPR_NOACCESS
,
686 &spr_read_ibat
, &spr_write_ibatl
,
688 spr_register(env
, SPR_IBAT1U
, "IBAT1U",
689 SPR_NOACCESS
, SPR_NOACCESS
,
690 &spr_read_ibat
, &spr_write_ibatu
,
692 spr_register(env
, SPR_IBAT1L
, "IBAT1L",
693 SPR_NOACCESS
, SPR_NOACCESS
,
694 &spr_read_ibat
, &spr_write_ibatl
,
696 spr_register(env
, SPR_IBAT2U
, "IBAT2U",
697 SPR_NOACCESS
, SPR_NOACCESS
,
698 &spr_read_ibat
, &spr_write_ibatu
,
700 spr_register(env
, SPR_IBAT2L
, "IBAT2L",
701 SPR_NOACCESS
, SPR_NOACCESS
,
702 &spr_read_ibat
, &spr_write_ibatl
,
704 spr_register(env
, SPR_IBAT3U
, "IBAT3U",
705 SPR_NOACCESS
, SPR_NOACCESS
,
706 &spr_read_ibat
, &spr_write_ibatu
,
708 spr_register(env
, SPR_IBAT3L
, "IBAT3L",
709 SPR_NOACCESS
, SPR_NOACCESS
,
710 &spr_read_ibat
, &spr_write_ibatl
,
712 spr_register(env
, SPR_DBAT0U
, "DBAT0U",
713 SPR_NOACCESS
, SPR_NOACCESS
,
714 &spr_read_dbat
, &spr_write_dbatu
,
716 spr_register(env
, SPR_DBAT0L
, "DBAT0L",
717 SPR_NOACCESS
, SPR_NOACCESS
,
718 &spr_read_dbat
, &spr_write_dbatl
,
720 spr_register(env
, SPR_DBAT1U
, "DBAT1U",
721 SPR_NOACCESS
, SPR_NOACCESS
,
722 &spr_read_dbat
, &spr_write_dbatu
,
724 spr_register(env
, SPR_DBAT1L
, "DBAT1L",
725 SPR_NOACCESS
, SPR_NOACCESS
,
726 &spr_read_dbat
, &spr_write_dbatl
,
728 spr_register(env
, SPR_DBAT2U
, "DBAT2U",
729 SPR_NOACCESS
, SPR_NOACCESS
,
730 &spr_read_dbat
, &spr_write_dbatu
,
732 spr_register(env
, SPR_DBAT2L
, "DBAT2L",
733 SPR_NOACCESS
, SPR_NOACCESS
,
734 &spr_read_dbat
, &spr_write_dbatl
,
736 spr_register(env
, SPR_DBAT3U
, "DBAT3U",
737 SPR_NOACCESS
, SPR_NOACCESS
,
738 &spr_read_dbat
, &spr_write_dbatu
,
740 spr_register(env
, SPR_DBAT3L
, "DBAT3L",
741 SPR_NOACCESS
, SPR_NOACCESS
,
742 &spr_read_dbat
, &spr_write_dbatl
,
749 static void gen_high_BATs (CPUPPCState
*env
)
751 #if !defined(CONFIG_USER_ONLY)
752 spr_register(env
, SPR_IBAT4U
, "IBAT4U",
753 SPR_NOACCESS
, SPR_NOACCESS
,
754 &spr_read_ibat_h
, &spr_write_ibatu_h
,
756 spr_register(env
, SPR_IBAT4L
, "IBAT4L",
757 SPR_NOACCESS
, SPR_NOACCESS
,
758 &spr_read_ibat_h
, &spr_write_ibatl_h
,
760 spr_register(env
, SPR_IBAT5U
, "IBAT5U",
761 SPR_NOACCESS
, SPR_NOACCESS
,
762 &spr_read_ibat_h
, &spr_write_ibatu_h
,
764 spr_register(env
, SPR_IBAT5L
, "IBAT5L",
765 SPR_NOACCESS
, SPR_NOACCESS
,
766 &spr_read_ibat_h
, &spr_write_ibatl_h
,
768 spr_register(env
, SPR_IBAT6U
, "IBAT6U",
769 SPR_NOACCESS
, SPR_NOACCESS
,
770 &spr_read_ibat_h
, &spr_write_ibatu_h
,
772 spr_register(env
, SPR_IBAT6L
, "IBAT6L",
773 SPR_NOACCESS
, SPR_NOACCESS
,
774 &spr_read_ibat_h
, &spr_write_ibatl_h
,
776 spr_register(env
, SPR_IBAT7U
, "IBAT7U",
777 SPR_NOACCESS
, SPR_NOACCESS
,
778 &spr_read_ibat_h
, &spr_write_ibatu_h
,
780 spr_register(env
, SPR_IBAT7L
, "IBAT7L",
781 SPR_NOACCESS
, SPR_NOACCESS
,
782 &spr_read_ibat_h
, &spr_write_ibatl_h
,
784 spr_register(env
, SPR_DBAT4U
, "DBAT4U",
785 SPR_NOACCESS
, SPR_NOACCESS
,
786 &spr_read_dbat_h
, &spr_write_dbatu_h
,
788 spr_register(env
, SPR_DBAT4L
, "DBAT4L",
789 SPR_NOACCESS
, SPR_NOACCESS
,
790 &spr_read_dbat_h
, &spr_write_dbatl_h
,
792 spr_register(env
, SPR_DBAT5U
, "DBAT5U",
793 SPR_NOACCESS
, SPR_NOACCESS
,
794 &spr_read_dbat_h
, &spr_write_dbatu_h
,
796 spr_register(env
, SPR_DBAT5L
, "DBAT5L",
797 SPR_NOACCESS
, SPR_NOACCESS
,
798 &spr_read_dbat_h
, &spr_write_dbatl_h
,
800 spr_register(env
, SPR_DBAT6U
, "DBAT6U",
801 SPR_NOACCESS
, SPR_NOACCESS
,
802 &spr_read_dbat_h
, &spr_write_dbatu_h
,
804 spr_register(env
, SPR_DBAT6L
, "DBAT6L",
805 SPR_NOACCESS
, SPR_NOACCESS
,
806 &spr_read_dbat_h
, &spr_write_dbatl_h
,
808 spr_register(env
, SPR_DBAT7U
, "DBAT7U",
809 SPR_NOACCESS
, SPR_NOACCESS
,
810 &spr_read_dbat_h
, &spr_write_dbatu_h
,
812 spr_register(env
, SPR_DBAT7L
, "DBAT7L",
813 SPR_NOACCESS
, SPR_NOACCESS
,
814 &spr_read_dbat_h
, &spr_write_dbatl_h
,
820 /* Generic PowerPC time base */
821 static void gen_tbl (CPUPPCState
*env
)
823 spr_register(env
, SPR_VTBL
, "TBL",
824 &spr_read_tbl
, SPR_NOACCESS
,
825 &spr_read_tbl
, SPR_NOACCESS
,
827 spr_register(env
, SPR_TBL
, "TBL",
828 &spr_read_tbl
, SPR_NOACCESS
,
829 &spr_read_tbl
, &spr_write_tbl
,
831 spr_register(env
, SPR_VTBU
, "TBU",
832 &spr_read_tbu
, SPR_NOACCESS
,
833 &spr_read_tbu
, SPR_NOACCESS
,
835 spr_register(env
, SPR_TBU
, "TBU",
836 &spr_read_tbu
, SPR_NOACCESS
,
837 &spr_read_tbu
, &spr_write_tbu
,
841 /* Softare table search registers */
842 static void gen_6xx_7xx_soft_tlb (CPUPPCState
*env
, int nb_tlbs
, int nb_ways
)
844 #if !defined(CONFIG_USER_ONLY)
845 env
->nb_tlb
= nb_tlbs
;
846 env
->nb_ways
= nb_ways
;
848 env
->tlb_type
= TLB_6XX
;
849 spr_register(env
, SPR_DMISS
, "DMISS",
850 SPR_NOACCESS
, SPR_NOACCESS
,
851 &spr_read_generic
, SPR_NOACCESS
,
853 spr_register(env
, SPR_DCMP
, "DCMP",
854 SPR_NOACCESS
, SPR_NOACCESS
,
855 &spr_read_generic
, SPR_NOACCESS
,
857 spr_register(env
, SPR_HASH1
, "HASH1",
858 SPR_NOACCESS
, SPR_NOACCESS
,
859 &spr_read_generic
, SPR_NOACCESS
,
861 spr_register(env
, SPR_HASH2
, "HASH2",
862 SPR_NOACCESS
, SPR_NOACCESS
,
863 &spr_read_generic
, SPR_NOACCESS
,
865 spr_register(env
, SPR_IMISS
, "IMISS",
866 SPR_NOACCESS
, SPR_NOACCESS
,
867 &spr_read_generic
, SPR_NOACCESS
,
869 spr_register(env
, SPR_ICMP
, "ICMP",
870 SPR_NOACCESS
, SPR_NOACCESS
,
871 &spr_read_generic
, SPR_NOACCESS
,
873 spr_register(env
, SPR_RPA
, "RPA",
874 SPR_NOACCESS
, SPR_NOACCESS
,
875 &spr_read_generic
, &spr_write_generic
,
880 /* SPR common to MPC755 and G2 */
881 static void gen_spr_G2_755 (CPUPPCState
*env
)
884 spr_register(env
, SPR_SPRG4
, "SPRG4",
885 SPR_NOACCESS
, SPR_NOACCESS
,
886 &spr_read_generic
, &spr_write_generic
,
888 spr_register(env
, SPR_SPRG5
, "SPRG5",
889 SPR_NOACCESS
, SPR_NOACCESS
,
890 &spr_read_generic
, &spr_write_generic
,
892 spr_register(env
, SPR_SPRG6
, "SPRG6",
893 SPR_NOACCESS
, SPR_NOACCESS
,
894 &spr_read_generic
, &spr_write_generic
,
896 spr_register(env
, SPR_SPRG7
, "SPRG7",
897 SPR_NOACCESS
, SPR_NOACCESS
,
898 &spr_read_generic
, &spr_write_generic
,
902 /* SPR common to all 7xx PowerPC implementations */
903 static void gen_spr_7xx (CPUPPCState
*env
)
906 /* XXX : not implemented */
907 spr_register(env
, SPR_DABR
, "DABR",
908 SPR_NOACCESS
, SPR_NOACCESS
,
909 &spr_read_generic
, &spr_write_generic
,
911 /* XXX : not implemented */
912 spr_register(env
, SPR_IABR
, "IABR",
913 SPR_NOACCESS
, SPR_NOACCESS
,
914 &spr_read_generic
, &spr_write_generic
,
916 /* Cache management */
917 /* XXX : not implemented */
918 spr_register(env
, SPR_ICTC
, "ICTC",
919 SPR_NOACCESS
, SPR_NOACCESS
,
920 &spr_read_generic
, &spr_write_generic
,
922 /* Performance monitors */
923 /* XXX : not implemented */
924 spr_register(env
, SPR_MMCR0
, "MMCR0",
925 SPR_NOACCESS
, SPR_NOACCESS
,
926 &spr_read_generic
, &spr_write_generic
,
928 /* XXX : not implemented */
929 spr_register(env
, SPR_MMCR1
, "MMCR1",
930 SPR_NOACCESS
, SPR_NOACCESS
,
931 &spr_read_generic
, &spr_write_generic
,
933 /* XXX : not implemented */
934 spr_register(env
, SPR_PMC1
, "PMC1",
935 SPR_NOACCESS
, SPR_NOACCESS
,
936 &spr_read_generic
, &spr_write_generic
,
938 /* XXX : not implemented */
939 spr_register(env
, SPR_PMC2
, "PMC2",
940 SPR_NOACCESS
, SPR_NOACCESS
,
941 &spr_read_generic
, &spr_write_generic
,
943 /* XXX : not implemented */
944 spr_register(env
, SPR_PMC3
, "PMC3",
945 SPR_NOACCESS
, SPR_NOACCESS
,
946 &spr_read_generic
, &spr_write_generic
,
948 /* XXX : not implemented */
949 spr_register(env
, SPR_PMC4
, "PMC4",
950 SPR_NOACCESS
, SPR_NOACCESS
,
951 &spr_read_generic
, &spr_write_generic
,
953 /* XXX : not implemented */
954 spr_register(env
, SPR_SIAR
, "SIAR",
955 SPR_NOACCESS
, SPR_NOACCESS
,
956 &spr_read_generic
, SPR_NOACCESS
,
958 /* XXX : not implemented */
959 spr_register(env
, SPR_UMMCR0
, "UMMCR0",
960 &spr_read_ureg
, SPR_NOACCESS
,
961 &spr_read_ureg
, SPR_NOACCESS
,
963 /* XXX : not implemented */
964 spr_register(env
, SPR_UMMCR1
, "UMMCR1",
965 &spr_read_ureg
, SPR_NOACCESS
,
966 &spr_read_ureg
, SPR_NOACCESS
,
968 /* XXX : not implemented */
969 spr_register(env
, SPR_UPMC1
, "UPMC1",
970 &spr_read_ureg
, SPR_NOACCESS
,
971 &spr_read_ureg
, SPR_NOACCESS
,
973 /* XXX : not implemented */
974 spr_register(env
, SPR_UPMC2
, "UPMC2",
975 &spr_read_ureg
, SPR_NOACCESS
,
976 &spr_read_ureg
, SPR_NOACCESS
,
978 /* XXX : not implemented */
979 spr_register(env
, SPR_UPMC3
, "UPMC3",
980 &spr_read_ureg
, SPR_NOACCESS
,
981 &spr_read_ureg
, SPR_NOACCESS
,
983 /* XXX : not implemented */
984 spr_register(env
, SPR_UPMC4
, "UPMC4",
985 &spr_read_ureg
, SPR_NOACCESS
,
986 &spr_read_ureg
, SPR_NOACCESS
,
988 /* XXX : not implemented */
989 spr_register(env
, SPR_USIAR
, "USIAR",
990 &spr_read_ureg
, SPR_NOACCESS
,
991 &spr_read_ureg
, SPR_NOACCESS
,
993 /* External access control */
994 /* XXX : not implemented */
995 spr_register(env
, SPR_EAR
, "EAR",
996 SPR_NOACCESS
, SPR_NOACCESS
,
997 &spr_read_generic
, &spr_write_generic
,
1001 static void gen_spr_thrm (CPUPPCState
*env
)
1003 /* Thermal management */
1004 /* XXX : not implemented */
1005 spr_register(env
, SPR_THRM1
, "THRM1",
1006 SPR_NOACCESS
, SPR_NOACCESS
,
1007 &spr_read_generic
, &spr_write_generic
,
1009 /* XXX : not implemented */
1010 spr_register(env
, SPR_THRM2
, "THRM2",
1011 SPR_NOACCESS
, SPR_NOACCESS
,
1012 &spr_read_generic
, &spr_write_generic
,
1014 /* XXX : not implemented */
1015 spr_register(env
, SPR_THRM3
, "THRM3",
1016 SPR_NOACCESS
, SPR_NOACCESS
,
1017 &spr_read_generic
, &spr_write_generic
,
1021 /* SPR specific to PowerPC 604 implementation */
1022 static void gen_spr_604 (CPUPPCState
*env
)
1024 /* Processor identification */
1025 spr_register(env
, SPR_PIR
, "PIR",
1026 SPR_NOACCESS
, SPR_NOACCESS
,
1027 &spr_read_generic
, &spr_write_pir
,
1030 /* XXX : not implemented */
1031 spr_register(env
, SPR_IABR
, "IABR",
1032 SPR_NOACCESS
, SPR_NOACCESS
,
1033 &spr_read_generic
, &spr_write_generic
,
1035 /* XXX : not implemented */
1036 spr_register(env
, SPR_DABR
, "DABR",
1037 SPR_NOACCESS
, SPR_NOACCESS
,
1038 &spr_read_generic
, &spr_write_generic
,
1040 /* Performance counters */
1041 /* XXX : not implemented */
1042 spr_register(env
, SPR_MMCR0
, "MMCR0",
1043 SPR_NOACCESS
, SPR_NOACCESS
,
1044 &spr_read_generic
, &spr_write_generic
,
1046 /* XXX : not implemented */
1047 spr_register(env
, SPR_PMC1
, "PMC1",
1048 SPR_NOACCESS
, SPR_NOACCESS
,
1049 &spr_read_generic
, &spr_write_generic
,
1051 /* XXX : not implemented */
1052 spr_register(env
, SPR_PMC2
, "PMC2",
1053 SPR_NOACCESS
, SPR_NOACCESS
,
1054 &spr_read_generic
, &spr_write_generic
,
1056 /* XXX : not implemented */
1057 spr_register(env
, SPR_SIAR
, "SIAR",
1058 SPR_NOACCESS
, SPR_NOACCESS
,
1059 &spr_read_generic
, SPR_NOACCESS
,
1061 /* XXX : not implemented */
1062 spr_register(env
, SPR_SDA
, "SDA",
1063 SPR_NOACCESS
, SPR_NOACCESS
,
1064 &spr_read_generic
, SPR_NOACCESS
,
1066 /* External access control */
1067 /* XXX : not implemented */
1068 spr_register(env
, SPR_EAR
, "EAR",
1069 SPR_NOACCESS
, SPR_NOACCESS
,
1070 &spr_read_generic
, &spr_write_generic
,
1074 /* SPR specific to PowerPC 603 implementation */
1075 static void gen_spr_603 (CPUPPCState
*env
)
1077 /* External access control */
1078 /* XXX : not implemented */
1079 spr_register(env
, SPR_EAR
, "EAR",
1080 SPR_NOACCESS
, SPR_NOACCESS
,
1081 &spr_read_generic
, &spr_write_generic
,
1085 /* SPR specific to PowerPC G2 implementation */
1086 static void gen_spr_G2 (CPUPPCState
*env
)
1088 /* Memory base address */
1090 /* XXX : not implemented */
1091 spr_register(env
, SPR_MBAR
, "MBAR",
1092 SPR_NOACCESS
, SPR_NOACCESS
,
1093 &spr_read_generic
, &spr_write_generic
,
1095 /* Exception processing */
1096 spr_register(env
, SPR_BOOKE_CSRR0
, "CSRR0",
1097 SPR_NOACCESS
, SPR_NOACCESS
,
1098 &spr_read_generic
, &spr_write_generic
,
1100 spr_register(env
, SPR_BOOKE_CSRR1
, "CSRR1",
1101 SPR_NOACCESS
, SPR_NOACCESS
,
1102 &spr_read_generic
, &spr_write_generic
,
1105 /* XXX : not implemented */
1106 spr_register(env
, SPR_DABR
, "DABR",
1107 SPR_NOACCESS
, SPR_NOACCESS
,
1108 &spr_read_generic
, &spr_write_generic
,
1110 /* XXX : not implemented */
1111 spr_register(env
, SPR_DABR2
, "DABR2",
1112 SPR_NOACCESS
, SPR_NOACCESS
,
1113 &spr_read_generic
, &spr_write_generic
,
1115 /* XXX : not implemented */
1116 spr_register(env
, SPR_IABR
, "IABR",
1117 SPR_NOACCESS
, SPR_NOACCESS
,
1118 &spr_read_generic
, &spr_write_generic
,
1120 /* XXX : not implemented */
1121 spr_register(env
, SPR_IABR2
, "IABR2",
1122 SPR_NOACCESS
, SPR_NOACCESS
,
1123 &spr_read_generic
, &spr_write_generic
,
1125 /* XXX : not implemented */
1126 spr_register(env
, SPR_IBCR
, "IBCR",
1127 SPR_NOACCESS
, SPR_NOACCESS
,
1128 &spr_read_generic
, &spr_write_generic
,
1130 /* XXX : not implemented */
1131 spr_register(env
, SPR_DBCR
, "DBCR",
1132 SPR_NOACCESS
, SPR_NOACCESS
,
1133 &spr_read_generic
, &spr_write_generic
,
1137 /* SPR specific to PowerPC 602 implementation */
1138 static void gen_spr_602 (CPUPPCState
*env
)
1141 /* XXX : not implemented */
1142 spr_register(env
, SPR_SER
, "SER",
1143 SPR_NOACCESS
, SPR_NOACCESS
,
1144 &spr_read_generic
, &spr_write_generic
,
1146 /* XXX : not implemented */
1147 spr_register(env
, SPR_SEBR
, "SEBR",
1148 SPR_NOACCESS
, SPR_NOACCESS
,
1149 &spr_read_generic
, &spr_write_generic
,
1151 /* XXX : not implemented */
1152 spr_register(env
, SPR_ESASRR
, "ESASRR",
1153 SPR_NOACCESS
, SPR_NOACCESS
,
1154 &spr_read_generic
, &spr_write_generic
,
1156 /* Floating point status */
1157 /* XXX : not implemented */
1158 spr_register(env
, SPR_SP
, "SP",
1159 SPR_NOACCESS
, SPR_NOACCESS
,
1160 &spr_read_generic
, &spr_write_generic
,
1162 /* XXX : not implemented */
1163 spr_register(env
, SPR_LT
, "LT",
1164 SPR_NOACCESS
, SPR_NOACCESS
,
1165 &spr_read_generic
, &spr_write_generic
,
1167 /* Watchdog timer */
1168 /* XXX : not implemented */
1169 spr_register(env
, SPR_TCR
, "TCR",
1170 SPR_NOACCESS
, SPR_NOACCESS
,
1171 &spr_read_generic
, &spr_write_generic
,
1173 /* Interrupt base */
1174 spr_register(env
, SPR_IBR
, "IBR",
1175 SPR_NOACCESS
, SPR_NOACCESS
,
1176 &spr_read_generic
, &spr_write_generic
,
1178 /* XXX : not implemented */
1179 spr_register(env
, SPR_IABR
, "IABR",
1180 SPR_NOACCESS
, SPR_NOACCESS
,
1181 &spr_read_generic
, &spr_write_generic
,
1185 /* SPR specific to PowerPC 601 implementation */
1186 static void gen_spr_601 (CPUPPCState
*env
)
1188 /* Multiplication/division register */
1190 spr_register(env
, SPR_MQ
, "MQ",
1191 &spr_read_generic
, &spr_write_generic
,
1192 &spr_read_generic
, &spr_write_generic
,
1195 spr_register(env
, SPR_601_RTCU
, "RTCU",
1196 SPR_NOACCESS
, SPR_NOACCESS
,
1197 SPR_NOACCESS
, &spr_write_601_rtcu
,
1199 spr_register(env
, SPR_601_VRTCU
, "RTCU",
1200 &spr_read_601_rtcu
, SPR_NOACCESS
,
1201 &spr_read_601_rtcu
, SPR_NOACCESS
,
1203 spr_register(env
, SPR_601_RTCL
, "RTCL",
1204 SPR_NOACCESS
, SPR_NOACCESS
,
1205 SPR_NOACCESS
, &spr_write_601_rtcl
,
1207 spr_register(env
, SPR_601_VRTCL
, "RTCL",
1208 &spr_read_601_rtcl
, SPR_NOACCESS
,
1209 &spr_read_601_rtcl
, SPR_NOACCESS
,
1213 spr_register(env
, SPR_601_UDECR
, "UDECR",
1214 &spr_read_decr
, SPR_NOACCESS
,
1215 &spr_read_decr
, SPR_NOACCESS
,
1218 /* External access control */
1219 /* XXX : not implemented */
1220 spr_register(env
, SPR_EAR
, "EAR",
1221 SPR_NOACCESS
, SPR_NOACCESS
,
1222 &spr_read_generic
, &spr_write_generic
,
1224 /* Memory management */
1225 #if !defined(CONFIG_USER_ONLY)
1226 spr_register(env
, SPR_IBAT0U
, "IBAT0U",
1227 SPR_NOACCESS
, SPR_NOACCESS
,
1228 &spr_read_601_ubat
, &spr_write_601_ubatu
,
1230 spr_register(env
, SPR_IBAT0L
, "IBAT0L",
1231 SPR_NOACCESS
, SPR_NOACCESS
,
1232 &spr_read_601_ubat
, &spr_write_601_ubatl
,
1234 spr_register(env
, SPR_IBAT1U
, "IBAT1U",
1235 SPR_NOACCESS
, SPR_NOACCESS
,
1236 &spr_read_601_ubat
, &spr_write_601_ubatu
,
1238 spr_register(env
, SPR_IBAT1L
, "IBAT1L",
1239 SPR_NOACCESS
, SPR_NOACCESS
,
1240 &spr_read_601_ubat
, &spr_write_601_ubatl
,
1242 spr_register(env
, SPR_IBAT2U
, "IBAT2U",
1243 SPR_NOACCESS
, SPR_NOACCESS
,
1244 &spr_read_601_ubat
, &spr_write_601_ubatu
,
1246 spr_register(env
, SPR_IBAT2L
, "IBAT2L",
1247 SPR_NOACCESS
, SPR_NOACCESS
,
1248 &spr_read_601_ubat
, &spr_write_601_ubatl
,
1250 spr_register(env
, SPR_IBAT3U
, "IBAT3U",
1251 SPR_NOACCESS
, SPR_NOACCESS
,
1252 &spr_read_601_ubat
, &spr_write_601_ubatu
,
1254 spr_register(env
, SPR_IBAT3L
, "IBAT3L",
1255 SPR_NOACCESS
, SPR_NOACCESS
,
1256 &spr_read_601_ubat
, &spr_write_601_ubatl
,
1262 static void gen_spr_74xx (CPUPPCState
*env
)
1264 /* Processor identification */
1265 spr_register(env
, SPR_PIR
, "PIR",
1266 SPR_NOACCESS
, SPR_NOACCESS
,
1267 &spr_read_generic
, &spr_write_pir
,
1269 /* XXX : not implemented */
1270 spr_register(env
, SPR_MMCR2
, "MMCR2",
1271 SPR_NOACCESS
, SPR_NOACCESS
,
1272 &spr_read_generic
, &spr_write_generic
,
1274 /* XXX : not implemented */
1275 spr_register(env
, SPR_UMMCR2
, "UMMCR2",
1276 &spr_read_ureg
, SPR_NOACCESS
,
1277 &spr_read_ureg
, SPR_NOACCESS
,
1279 /* XXX: not implemented */
1280 spr_register(env
, SPR_BAMR
, "BAMR",
1281 SPR_NOACCESS
, SPR_NOACCESS
,
1282 &spr_read_generic
, &spr_write_generic
,
1284 /* XXX : not implemented */
1285 spr_register(env
, SPR_MSSCR0
, "MSSCR0",
1286 SPR_NOACCESS
, SPR_NOACCESS
,
1287 &spr_read_generic
, &spr_write_generic
,
1289 /* Hardware implementation registers */
1290 /* XXX : not implemented */
1291 spr_register(env
, SPR_HID0
, "HID0",
1292 SPR_NOACCESS
, SPR_NOACCESS
,
1293 &spr_read_generic
, &spr_write_generic
,
1295 /* XXX : not implemented */
1296 spr_register(env
, SPR_HID1
, "HID1",
1297 SPR_NOACCESS
, SPR_NOACCESS
,
1298 &spr_read_generic
, &spr_write_generic
,
1301 spr_register(env
, SPR_VRSAVE
, "VRSAVE",
1302 &spr_read_generic
, &spr_write_generic
,
1303 &spr_read_generic
, &spr_write_generic
,
1305 /* XXX : not implemented */
1306 spr_register(env
, SPR_L2CR
, "L2CR",
1307 SPR_NOACCESS
, SPR_NOACCESS
,
1308 &spr_read_generic
, &spr_write_generic
,
1310 /* Not strictly an SPR */
1311 vscr_init(env
, 0x00010000);
1314 static void gen_l3_ctrl (CPUPPCState
*env
)
1317 /* XXX : not implemented */
1318 spr_register(env
, SPR_L3CR
, "L3CR",
1319 SPR_NOACCESS
, SPR_NOACCESS
,
1320 &spr_read_generic
, &spr_write_generic
,
1323 /* XXX : not implemented */
1324 spr_register(env
, SPR_L3ITCR0
, "L3ITCR0",
1325 SPR_NOACCESS
, SPR_NOACCESS
,
1326 &spr_read_generic
, &spr_write_generic
,
1329 /* XXX : not implemented */
1330 spr_register(env
, SPR_L3PM
, "L3PM",
1331 SPR_NOACCESS
, SPR_NOACCESS
,
1332 &spr_read_generic
, &spr_write_generic
,
1336 static void gen_74xx_soft_tlb (CPUPPCState
*env
, int nb_tlbs
, int nb_ways
)
1338 #if !defined(CONFIG_USER_ONLY)
1339 env
->nb_tlb
= nb_tlbs
;
1340 env
->nb_ways
= nb_ways
;
1342 env
->tlb_type
= TLB_6XX
;
1343 /* XXX : not implemented */
1344 spr_register(env
, SPR_PTEHI
, "PTEHI",
1345 SPR_NOACCESS
, SPR_NOACCESS
,
1346 &spr_read_generic
, &spr_write_generic
,
1348 /* XXX : not implemented */
1349 spr_register(env
, SPR_PTELO
, "PTELO",
1350 SPR_NOACCESS
, SPR_NOACCESS
,
1351 &spr_read_generic
, &spr_write_generic
,
1353 /* XXX : not implemented */
1354 spr_register(env
, SPR_TLBMISS
, "TLBMISS",
1355 SPR_NOACCESS
, SPR_NOACCESS
,
1356 &spr_read_generic
, &spr_write_generic
,
1361 #if !defined(CONFIG_USER_ONLY)
1362 static void spr_write_e500_l1csr0 (void *opaque
, int sprn
, int gprn
)
1364 TCGv t0
= tcg_temp_new();
1366 tcg_gen_andi_tl(t0
, cpu_gpr
[gprn
], ~256);
1367 gen_store_spr(sprn
, t0
);
1371 static void spr_write_booke206_mmucsr0 (void *opaque
, int sprn
, int gprn
)
1373 TCGv_i32 t0
= tcg_const_i32(sprn
);
1374 gen_helper_booke206_tlbflush(t0
);
1375 tcg_temp_free_i32(t0
);
1378 static void spr_write_booke_pid (void *opaque
, int sprn
, int gprn
)
1380 TCGv_i32 t0
= tcg_const_i32(sprn
);
1381 gen_helper_booke_setpid(t0
, cpu_gpr
[gprn
]);
1382 tcg_temp_free_i32(t0
);
1386 static void gen_spr_usprgh (CPUPPCState
*env
)
1388 spr_register(env
, SPR_USPRG4
, "USPRG4",
1389 &spr_read_ureg
, SPR_NOACCESS
,
1390 &spr_read_ureg
, SPR_NOACCESS
,
1392 spr_register(env
, SPR_USPRG5
, "USPRG5",
1393 &spr_read_ureg
, SPR_NOACCESS
,
1394 &spr_read_ureg
, SPR_NOACCESS
,
1396 spr_register(env
, SPR_USPRG6
, "USPRG6",
1397 &spr_read_ureg
, SPR_NOACCESS
,
1398 &spr_read_ureg
, SPR_NOACCESS
,
1400 spr_register(env
, SPR_USPRG7
, "USPRG7",
1401 &spr_read_ureg
, SPR_NOACCESS
,
1402 &spr_read_ureg
, SPR_NOACCESS
,
1406 /* PowerPC BookE SPR */
1407 static void gen_spr_BookE (CPUPPCState
*env
, uint64_t ivor_mask
)
1409 const char *ivor_names
[64] = {
1410 "IVOR0", "IVOR1", "IVOR2", "IVOR3",
1411 "IVOR4", "IVOR5", "IVOR6", "IVOR7",
1412 "IVOR8", "IVOR9", "IVOR10", "IVOR11",
1413 "IVOR12", "IVOR13", "IVOR14", "IVOR15",
1414 "IVOR16", "IVOR17", "IVOR18", "IVOR19",
1415 "IVOR20", "IVOR21", "IVOR22", "IVOR23",
1416 "IVOR24", "IVOR25", "IVOR26", "IVOR27",
1417 "IVOR28", "IVOR29", "IVOR30", "IVOR31",
1418 "IVOR32", "IVOR33", "IVOR34", "IVOR35",
1419 "IVOR36", "IVOR37", "IVOR38", "IVOR39",
1420 "IVOR40", "IVOR41", "IVOR42", "IVOR43",
1421 "IVOR44", "IVOR45", "IVOR46", "IVOR47",
1422 "IVOR48", "IVOR49", "IVOR50", "IVOR51",
1423 "IVOR52", "IVOR53", "IVOR54", "IVOR55",
1424 "IVOR56", "IVOR57", "IVOR58", "IVOR59",
1425 "IVOR60", "IVOR61", "IVOR62", "IVOR63",
1427 #define SPR_BOOKE_IVORxx (-1)
1428 int ivor_sprn
[64] = {
1429 SPR_BOOKE_IVOR0
, SPR_BOOKE_IVOR1
, SPR_BOOKE_IVOR2
, SPR_BOOKE_IVOR3
,
1430 SPR_BOOKE_IVOR4
, SPR_BOOKE_IVOR5
, SPR_BOOKE_IVOR6
, SPR_BOOKE_IVOR7
,
1431 SPR_BOOKE_IVOR8
, SPR_BOOKE_IVOR9
, SPR_BOOKE_IVOR10
, SPR_BOOKE_IVOR11
,
1432 SPR_BOOKE_IVOR12
, SPR_BOOKE_IVOR13
, SPR_BOOKE_IVOR14
, SPR_BOOKE_IVOR15
,
1433 SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
,
1434 SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
,
1435 SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
,
1436 SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
,
1437 SPR_BOOKE_IVOR32
, SPR_BOOKE_IVOR33
, SPR_BOOKE_IVOR34
, SPR_BOOKE_IVOR35
,
1438 SPR_BOOKE_IVOR36
, SPR_BOOKE_IVOR37
, SPR_BOOKE_IVOR38
, SPR_BOOKE_IVOR39
,
1439 SPR_BOOKE_IVOR40
, SPR_BOOKE_IVOR41
, SPR_BOOKE_IVOR42
, SPR_BOOKE_IVORxx
,
1440 SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
,
1441 SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
,
1442 SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
,
1443 SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
,
1444 SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
, SPR_BOOKE_IVORxx
,
1448 /* Interrupt processing */
1449 spr_register(env
, SPR_BOOKE_CSRR0
, "CSRR0",
1450 SPR_NOACCESS
, SPR_NOACCESS
,
1451 &spr_read_generic
, &spr_write_generic
,
1453 spr_register(env
, SPR_BOOKE_CSRR1
, "CSRR1",
1454 SPR_NOACCESS
, SPR_NOACCESS
,
1455 &spr_read_generic
, &spr_write_generic
,
1458 /* XXX : not implemented */
1459 spr_register(env
, SPR_BOOKE_IAC1
, "IAC1",
1460 SPR_NOACCESS
, SPR_NOACCESS
,
1461 &spr_read_generic
, &spr_write_generic
,
1463 /* XXX : not implemented */
1464 spr_register(env
, SPR_BOOKE_IAC2
, "IAC2",
1465 SPR_NOACCESS
, SPR_NOACCESS
,
1466 &spr_read_generic
, &spr_write_generic
,
1468 /* XXX : not implemented */
1469 spr_register(env
, SPR_BOOKE_DAC1
, "DAC1",
1470 SPR_NOACCESS
, SPR_NOACCESS
,
1471 &spr_read_generic
, &spr_write_generic
,
1473 /* XXX : not implemented */
1474 spr_register(env
, SPR_BOOKE_DAC2
, "DAC2",
1475 SPR_NOACCESS
, SPR_NOACCESS
,
1476 &spr_read_generic
, &spr_write_generic
,
1478 /* XXX : not implemented */
1479 spr_register(env
, SPR_BOOKE_DBCR0
, "DBCR0",
1480 SPR_NOACCESS
, SPR_NOACCESS
,
1481 &spr_read_generic
, &spr_write_generic
,
1483 /* XXX : not implemented */
1484 spr_register(env
, SPR_BOOKE_DBCR1
, "DBCR1",
1485 SPR_NOACCESS
, SPR_NOACCESS
,
1486 &spr_read_generic
, &spr_write_generic
,
1488 /* XXX : not implemented */
1489 spr_register(env
, SPR_BOOKE_DBCR2
, "DBCR2",
1490 SPR_NOACCESS
, SPR_NOACCESS
,
1491 &spr_read_generic
, &spr_write_generic
,
1493 /* XXX : not implemented */
1494 spr_register(env
, SPR_BOOKE_DBSR
, "DBSR",
1495 SPR_NOACCESS
, SPR_NOACCESS
,
1496 &spr_read_generic
, &spr_write_clear
,
1498 spr_register(env
, SPR_BOOKE_DEAR
, "DEAR",
1499 SPR_NOACCESS
, SPR_NOACCESS
,
1500 &spr_read_generic
, &spr_write_generic
,
1502 spr_register(env
, SPR_BOOKE_ESR
, "ESR",
1503 SPR_NOACCESS
, SPR_NOACCESS
,
1504 &spr_read_generic
, &spr_write_generic
,
1506 spr_register(env
, SPR_BOOKE_IVPR
, "IVPR",
1507 SPR_NOACCESS
, SPR_NOACCESS
,
1508 &spr_read_generic
, &spr_write_excp_prefix
,
1510 /* Exception vectors */
1511 for (i
= 0; i
< 64; i
++) {
1512 if (ivor_mask
& (1ULL << i
)) {
1513 if (ivor_sprn
[i
] == SPR_BOOKE_IVORxx
) {
1514 fprintf(stderr
, "ERROR: IVOR %d SPR is not defined\n", i
);
1517 spr_register(env
, ivor_sprn
[i
], ivor_names
[i
],
1518 SPR_NOACCESS
, SPR_NOACCESS
,
1519 &spr_read_generic
, &spr_write_excp_vector
,
1523 spr_register(env
, SPR_BOOKE_PID
, "PID",
1524 SPR_NOACCESS
, SPR_NOACCESS
,
1525 &spr_read_generic
, &spr_write_booke_pid
,
1527 spr_register(env
, SPR_BOOKE_TCR
, "TCR",
1528 SPR_NOACCESS
, SPR_NOACCESS
,
1529 &spr_read_generic
, &spr_write_booke_tcr
,
1531 spr_register(env
, SPR_BOOKE_TSR
, "TSR",
1532 SPR_NOACCESS
, SPR_NOACCESS
,
1533 &spr_read_generic
, &spr_write_booke_tsr
,
1536 spr_register(env
, SPR_DECR
, "DECR",
1537 SPR_NOACCESS
, SPR_NOACCESS
,
1538 &spr_read_decr
, &spr_write_decr
,
1540 spr_register(env
, SPR_BOOKE_DECAR
, "DECAR",
1541 SPR_NOACCESS
, SPR_NOACCESS
,
1542 SPR_NOACCESS
, &spr_write_generic
,
1545 spr_register(env
, SPR_USPRG0
, "USPRG0",
1546 &spr_read_generic
, &spr_write_generic
,
1547 &spr_read_generic
, &spr_write_generic
,
1549 spr_register(env
, SPR_SPRG4
, "SPRG4",
1550 SPR_NOACCESS
, SPR_NOACCESS
,
1551 &spr_read_generic
, &spr_write_generic
,
1553 spr_register(env
, SPR_SPRG5
, "SPRG5",
1554 SPR_NOACCESS
, SPR_NOACCESS
,
1555 &spr_read_generic
, &spr_write_generic
,
1557 spr_register(env
, SPR_SPRG6
, "SPRG6",
1558 SPR_NOACCESS
, SPR_NOACCESS
,
1559 &spr_read_generic
, &spr_write_generic
,
1561 spr_register(env
, SPR_SPRG7
, "SPRG7",
1562 SPR_NOACCESS
, SPR_NOACCESS
,
1563 &spr_read_generic
, &spr_write_generic
,
1567 static inline uint32_t gen_tlbncfg(uint32_t assoc
, uint32_t minsize
,
1568 uint32_t maxsize
, uint32_t flags
,
1571 return (assoc
<< TLBnCFG_ASSOC_SHIFT
) |
1572 (minsize
<< TLBnCFG_MINSIZE_SHIFT
) |
1573 (maxsize
<< TLBnCFG_MAXSIZE_SHIFT
) |
1577 /* BookE 2.06 storage control registers */
1578 static void gen_spr_BookE206(CPUPPCState
*env
, uint32_t mas_mask
,
1581 #if !defined(CONFIG_USER_ONLY)
1582 const char *mas_names
[8] = {
1583 "MAS0", "MAS1", "MAS2", "MAS3", "MAS4", "MAS5", "MAS6", "MAS7",
1586 SPR_BOOKE_MAS0
, SPR_BOOKE_MAS1
, SPR_BOOKE_MAS2
, SPR_BOOKE_MAS3
,
1587 SPR_BOOKE_MAS4
, SPR_BOOKE_MAS5
, SPR_BOOKE_MAS6
, SPR_BOOKE_MAS7
,
1591 /* TLB assist registers */
1592 /* XXX : not implemented */
1593 for (i
= 0; i
< 8; i
++) {
1594 if (mas_mask
& (1 << i
)) {
1595 spr_register(env
, mas_sprn
[i
], mas_names
[i
],
1596 SPR_NOACCESS
, SPR_NOACCESS
,
1597 &spr_read_generic
, &spr_write_generic
,
1601 if (env
->nb_pids
> 1) {
1602 /* XXX : not implemented */
1603 spr_register(env
, SPR_BOOKE_PID1
, "PID1",
1604 SPR_NOACCESS
, SPR_NOACCESS
,
1605 &spr_read_generic
, &spr_write_booke_pid
,
1608 if (env
->nb_pids
> 2) {
1609 /* XXX : not implemented */
1610 spr_register(env
, SPR_BOOKE_PID2
, "PID2",
1611 SPR_NOACCESS
, SPR_NOACCESS
,
1612 &spr_read_generic
, &spr_write_booke_pid
,
1615 /* XXX : not implemented */
1616 spr_register(env
, SPR_MMUCFG
, "MMUCFG",
1617 SPR_NOACCESS
, SPR_NOACCESS
,
1618 &spr_read_generic
, SPR_NOACCESS
,
1619 0x00000000); /* TOFIX */
1620 switch (env
->nb_ways
) {
1622 spr_register(env
, SPR_BOOKE_TLB3CFG
, "TLB3CFG",
1623 SPR_NOACCESS
, SPR_NOACCESS
,
1624 &spr_read_generic
, SPR_NOACCESS
,
1628 spr_register(env
, SPR_BOOKE_TLB2CFG
, "TLB2CFG",
1629 SPR_NOACCESS
, SPR_NOACCESS
,
1630 &spr_read_generic
, SPR_NOACCESS
,
1634 spr_register(env
, SPR_BOOKE_TLB1CFG
, "TLB1CFG",
1635 SPR_NOACCESS
, SPR_NOACCESS
,
1636 &spr_read_generic
, SPR_NOACCESS
,
1640 spr_register(env
, SPR_BOOKE_TLB0CFG
, "TLB0CFG",
1641 SPR_NOACCESS
, SPR_NOACCESS
,
1642 &spr_read_generic
, SPR_NOACCESS
,
1651 gen_spr_usprgh(env
);
1654 /* SPR specific to PowerPC 440 implementation */
1655 static void gen_spr_440 (CPUPPCState
*env
)
1658 /* XXX : not implemented */
1659 spr_register(env
, SPR_440_DNV0
, "DNV0",
1660 SPR_NOACCESS
, SPR_NOACCESS
,
1661 &spr_read_generic
, &spr_write_generic
,
1663 /* XXX : not implemented */
1664 spr_register(env
, SPR_440_DNV1
, "DNV1",
1665 SPR_NOACCESS
, SPR_NOACCESS
,
1666 &spr_read_generic
, &spr_write_generic
,
1668 /* XXX : not implemented */
1669 spr_register(env
, SPR_440_DNV2
, "DNV2",
1670 SPR_NOACCESS
, SPR_NOACCESS
,
1671 &spr_read_generic
, &spr_write_generic
,
1673 /* XXX : not implemented */
1674 spr_register(env
, SPR_440_DNV3
, "DNV3",
1675 SPR_NOACCESS
, SPR_NOACCESS
,
1676 &spr_read_generic
, &spr_write_generic
,
1678 /* XXX : not implemented */
1679 spr_register(env
, SPR_440_DTV0
, "DTV0",
1680 SPR_NOACCESS
, SPR_NOACCESS
,
1681 &spr_read_generic
, &spr_write_generic
,
1683 /* XXX : not implemented */
1684 spr_register(env
, SPR_440_DTV1
, "DTV1",
1685 SPR_NOACCESS
, SPR_NOACCESS
,
1686 &spr_read_generic
, &spr_write_generic
,
1688 /* XXX : not implemented */
1689 spr_register(env
, SPR_440_DTV2
, "DTV2",
1690 SPR_NOACCESS
, SPR_NOACCESS
,
1691 &spr_read_generic
, &spr_write_generic
,
1693 /* XXX : not implemented */
1694 spr_register(env
, SPR_440_DTV3
, "DTV3",
1695 SPR_NOACCESS
, SPR_NOACCESS
,
1696 &spr_read_generic
, &spr_write_generic
,
1698 /* XXX : not implemented */
1699 spr_register(env
, SPR_440_DVLIM
, "DVLIM",
1700 SPR_NOACCESS
, SPR_NOACCESS
,
1701 &spr_read_generic
, &spr_write_generic
,
1703 /* XXX : not implemented */
1704 spr_register(env
, SPR_440_INV0
, "INV0",
1705 SPR_NOACCESS
, SPR_NOACCESS
,
1706 &spr_read_generic
, &spr_write_generic
,
1708 /* XXX : not implemented */
1709 spr_register(env
, SPR_440_INV1
, "INV1",
1710 SPR_NOACCESS
, SPR_NOACCESS
,
1711 &spr_read_generic
, &spr_write_generic
,
1713 /* XXX : not implemented */
1714 spr_register(env
, SPR_440_INV2
, "INV2",
1715 SPR_NOACCESS
, SPR_NOACCESS
,
1716 &spr_read_generic
, &spr_write_generic
,
1718 /* XXX : not implemented */
1719 spr_register(env
, SPR_440_INV3
, "INV3",
1720 SPR_NOACCESS
, SPR_NOACCESS
,
1721 &spr_read_generic
, &spr_write_generic
,
1723 /* XXX : not implemented */
1724 spr_register(env
, SPR_440_ITV0
, "ITV0",
1725 SPR_NOACCESS
, SPR_NOACCESS
,
1726 &spr_read_generic
, &spr_write_generic
,
1728 /* XXX : not implemented */
1729 spr_register(env
, SPR_440_ITV1
, "ITV1",
1730 SPR_NOACCESS
, SPR_NOACCESS
,
1731 &spr_read_generic
, &spr_write_generic
,
1733 /* XXX : not implemented */
1734 spr_register(env
, SPR_440_ITV2
, "ITV2",
1735 SPR_NOACCESS
, SPR_NOACCESS
,
1736 &spr_read_generic
, &spr_write_generic
,
1738 /* XXX : not implemented */
1739 spr_register(env
, SPR_440_ITV3
, "ITV3",
1740 SPR_NOACCESS
, SPR_NOACCESS
,
1741 &spr_read_generic
, &spr_write_generic
,
1743 /* XXX : not implemented */
1744 spr_register(env
, SPR_440_IVLIM
, "IVLIM",
1745 SPR_NOACCESS
, SPR_NOACCESS
,
1746 &spr_read_generic
, &spr_write_generic
,
1749 /* XXX : not implemented */
1750 spr_register(env
, SPR_BOOKE_DCDBTRH
, "DCDBTRH",
1751 SPR_NOACCESS
, SPR_NOACCESS
,
1752 &spr_read_generic
, SPR_NOACCESS
,
1754 /* XXX : not implemented */
1755 spr_register(env
, SPR_BOOKE_DCDBTRL
, "DCDBTRL",
1756 SPR_NOACCESS
, SPR_NOACCESS
,
1757 &spr_read_generic
, SPR_NOACCESS
,
1759 /* XXX : not implemented */
1760 spr_register(env
, SPR_BOOKE_ICDBDR
, "ICDBDR",
1761 SPR_NOACCESS
, SPR_NOACCESS
,
1762 &spr_read_generic
, SPR_NOACCESS
,
1764 /* XXX : not implemented */
1765 spr_register(env
, SPR_BOOKE_ICDBTRH
, "ICDBTRH",
1766 SPR_NOACCESS
, SPR_NOACCESS
,
1767 &spr_read_generic
, SPR_NOACCESS
,
1769 /* XXX : not implemented */
1770 spr_register(env
, SPR_BOOKE_ICDBTRL
, "ICDBTRL",
1771 SPR_NOACCESS
, SPR_NOACCESS
,
1772 &spr_read_generic
, SPR_NOACCESS
,
1774 /* XXX : not implemented */
1775 spr_register(env
, SPR_440_DBDR
, "DBDR",
1776 SPR_NOACCESS
, SPR_NOACCESS
,
1777 &spr_read_generic
, &spr_write_generic
,
1779 /* Processor control */
1780 spr_register(env
, SPR_4xx_CCR0
, "CCR0",
1781 SPR_NOACCESS
, SPR_NOACCESS
,
1782 &spr_read_generic
, &spr_write_generic
,
1784 spr_register(env
, SPR_440_RSTCFG
, "RSTCFG",
1785 SPR_NOACCESS
, SPR_NOACCESS
,
1786 &spr_read_generic
, SPR_NOACCESS
,
1788 /* Storage control */
1789 spr_register(env
, SPR_440_MMUCR
, "MMUCR",
1790 SPR_NOACCESS
, SPR_NOACCESS
,
1791 &spr_read_generic
, &spr_write_generic
,
1795 /* SPR shared between PowerPC 40x implementations */
1796 static void gen_spr_40x (CPUPPCState
*env
)
1799 /* not emulated, as Qemu do not emulate caches */
1800 spr_register(env
, SPR_40x_DCCR
, "DCCR",
1801 SPR_NOACCESS
, SPR_NOACCESS
,
1802 &spr_read_generic
, &spr_write_generic
,
1804 /* not emulated, as Qemu do not emulate caches */
1805 spr_register(env
, SPR_40x_ICCR
, "ICCR",
1806 SPR_NOACCESS
, SPR_NOACCESS
,
1807 &spr_read_generic
, &spr_write_generic
,
1809 /* not emulated, as Qemu do not emulate caches */
1810 spr_register(env
, SPR_BOOKE_ICDBDR
, "ICDBDR",
1811 SPR_NOACCESS
, SPR_NOACCESS
,
1812 &spr_read_generic
, SPR_NOACCESS
,
1815 spr_register(env
, SPR_40x_DEAR
, "DEAR",
1816 SPR_NOACCESS
, SPR_NOACCESS
,
1817 &spr_read_generic
, &spr_write_generic
,
1819 spr_register(env
, SPR_40x_ESR
, "ESR",
1820 SPR_NOACCESS
, SPR_NOACCESS
,
1821 &spr_read_generic
, &spr_write_generic
,
1823 spr_register(env
, SPR_40x_EVPR
, "EVPR",
1824 SPR_NOACCESS
, SPR_NOACCESS
,
1825 &spr_read_generic
, &spr_write_excp_prefix
,
1827 spr_register(env
, SPR_40x_SRR2
, "SRR2",
1828 &spr_read_generic
, &spr_write_generic
,
1829 &spr_read_generic
, &spr_write_generic
,
1831 spr_register(env
, SPR_40x_SRR3
, "SRR3",
1832 &spr_read_generic
, &spr_write_generic
,
1833 &spr_read_generic
, &spr_write_generic
,
1836 spr_register(env
, SPR_40x_PIT
, "PIT",
1837 SPR_NOACCESS
, SPR_NOACCESS
,
1838 &spr_read_40x_pit
, &spr_write_40x_pit
,
1840 spr_register(env
, SPR_40x_TCR
, "TCR",
1841 SPR_NOACCESS
, SPR_NOACCESS
,
1842 &spr_read_generic
, &spr_write_booke_tcr
,
1844 spr_register(env
, SPR_40x_TSR
, "TSR",
1845 SPR_NOACCESS
, SPR_NOACCESS
,
1846 &spr_read_generic
, &spr_write_booke_tsr
,
1850 /* SPR specific to PowerPC 405 implementation */
1851 static void gen_spr_405 (CPUPPCState
*env
)
1854 spr_register(env
, SPR_40x_PID
, "PID",
1855 SPR_NOACCESS
, SPR_NOACCESS
,
1856 &spr_read_generic
, &spr_write_generic
,
1858 spr_register(env
, SPR_4xx_CCR0
, "CCR0",
1859 SPR_NOACCESS
, SPR_NOACCESS
,
1860 &spr_read_generic
, &spr_write_generic
,
1862 /* Debug interface */
1863 /* XXX : not implemented */
1864 spr_register(env
, SPR_40x_DBCR0
, "DBCR0",
1865 SPR_NOACCESS
, SPR_NOACCESS
,
1866 &spr_read_generic
, &spr_write_40x_dbcr0
,
1868 /* XXX : not implemented */
1869 spr_register(env
, SPR_405_DBCR1
, "DBCR1",
1870 SPR_NOACCESS
, SPR_NOACCESS
,
1871 &spr_read_generic
, &spr_write_generic
,
1873 /* XXX : not implemented */
1874 spr_register(env
, SPR_40x_DBSR
, "DBSR",
1875 SPR_NOACCESS
, SPR_NOACCESS
,
1876 &spr_read_generic
, &spr_write_clear
,
1877 /* Last reset was system reset */
1879 /* XXX : not implemented */
1880 spr_register(env
, SPR_40x_DAC1
, "DAC1",
1881 SPR_NOACCESS
, SPR_NOACCESS
,
1882 &spr_read_generic
, &spr_write_generic
,
1884 spr_register(env
, SPR_40x_DAC2
, "DAC2",
1885 SPR_NOACCESS
, SPR_NOACCESS
,
1886 &spr_read_generic
, &spr_write_generic
,
1888 /* XXX : not implemented */
1889 spr_register(env
, SPR_405_DVC1
, "DVC1",
1890 SPR_NOACCESS
, SPR_NOACCESS
,
1891 &spr_read_generic
, &spr_write_generic
,
1893 /* XXX : not implemented */
1894 spr_register(env
, SPR_405_DVC2
, "DVC2",
1895 SPR_NOACCESS
, SPR_NOACCESS
,
1896 &spr_read_generic
, &spr_write_generic
,
1898 /* XXX : not implemented */
1899 spr_register(env
, SPR_40x_IAC1
, "IAC1",
1900 SPR_NOACCESS
, SPR_NOACCESS
,
1901 &spr_read_generic
, &spr_write_generic
,
1903 spr_register(env
, SPR_40x_IAC2
, "IAC2",
1904 SPR_NOACCESS
, SPR_NOACCESS
,
1905 &spr_read_generic
, &spr_write_generic
,
1907 /* XXX : not implemented */
1908 spr_register(env
, SPR_405_IAC3
, "IAC3",
1909 SPR_NOACCESS
, SPR_NOACCESS
,
1910 &spr_read_generic
, &spr_write_generic
,
1912 /* XXX : not implemented */
1913 spr_register(env
, SPR_405_IAC4
, "IAC4",
1914 SPR_NOACCESS
, SPR_NOACCESS
,
1915 &spr_read_generic
, &spr_write_generic
,
1917 /* Storage control */
1918 /* XXX: TODO: not implemented */
1919 spr_register(env
, SPR_405_SLER
, "SLER",
1920 SPR_NOACCESS
, SPR_NOACCESS
,
1921 &spr_read_generic
, &spr_write_40x_sler
,
1923 spr_register(env
, SPR_40x_ZPR
, "ZPR",
1924 SPR_NOACCESS
, SPR_NOACCESS
,
1925 &spr_read_generic
, &spr_write_generic
,
1927 /* XXX : not implemented */
1928 spr_register(env
, SPR_405_SU0R
, "SU0R",
1929 SPR_NOACCESS
, SPR_NOACCESS
,
1930 &spr_read_generic
, &spr_write_generic
,
1933 spr_register(env
, SPR_USPRG0
, "USPRG0",
1934 &spr_read_ureg
, SPR_NOACCESS
,
1935 &spr_read_ureg
, SPR_NOACCESS
,
1937 spr_register(env
, SPR_SPRG4
, "SPRG4",
1938 SPR_NOACCESS
, SPR_NOACCESS
,
1939 &spr_read_generic
, &spr_write_generic
,
1941 spr_register(env
, SPR_SPRG5
, "SPRG5",
1942 SPR_NOACCESS
, SPR_NOACCESS
,
1943 spr_read_generic
, &spr_write_generic
,
1945 spr_register(env
, SPR_SPRG6
, "SPRG6",
1946 SPR_NOACCESS
, SPR_NOACCESS
,
1947 spr_read_generic
, &spr_write_generic
,
1949 spr_register(env
, SPR_SPRG7
, "SPRG7",
1950 SPR_NOACCESS
, SPR_NOACCESS
,
1951 spr_read_generic
, &spr_write_generic
,
1953 gen_spr_usprgh(env
);
1956 /* SPR shared between PowerPC 401 & 403 implementations */
1957 static void gen_spr_401_403 (CPUPPCState
*env
)
1960 spr_register(env
, SPR_403_VTBL
, "TBL",
1961 &spr_read_tbl
, SPR_NOACCESS
,
1962 &spr_read_tbl
, SPR_NOACCESS
,
1964 spr_register(env
, SPR_403_TBL
, "TBL",
1965 SPR_NOACCESS
, SPR_NOACCESS
,
1966 SPR_NOACCESS
, &spr_write_tbl
,
1968 spr_register(env
, SPR_403_VTBU
, "TBU",
1969 &spr_read_tbu
, SPR_NOACCESS
,
1970 &spr_read_tbu
, SPR_NOACCESS
,
1972 spr_register(env
, SPR_403_TBU
, "TBU",
1973 SPR_NOACCESS
, SPR_NOACCESS
,
1974 SPR_NOACCESS
, &spr_write_tbu
,
1977 /* not emulated, as Qemu do not emulate caches */
1978 spr_register(env
, SPR_403_CDBCR
, "CDBCR",
1979 SPR_NOACCESS
, SPR_NOACCESS
,
1980 &spr_read_generic
, &spr_write_generic
,
1984 /* SPR specific to PowerPC 401 implementation */
1985 static void gen_spr_401 (CPUPPCState
*env
)
1987 /* Debug interface */
1988 /* XXX : not implemented */
1989 spr_register(env
, SPR_40x_DBCR0
, "DBCR",
1990 SPR_NOACCESS
, SPR_NOACCESS
,
1991 &spr_read_generic
, &spr_write_40x_dbcr0
,
1993 /* XXX : not implemented */
1994 spr_register(env
, SPR_40x_DBSR
, "DBSR",
1995 SPR_NOACCESS
, SPR_NOACCESS
,
1996 &spr_read_generic
, &spr_write_clear
,
1997 /* Last reset was system reset */
1999 /* XXX : not implemented */
2000 spr_register(env
, SPR_40x_DAC1
, "DAC",
2001 SPR_NOACCESS
, SPR_NOACCESS
,
2002 &spr_read_generic
, &spr_write_generic
,
2004 /* XXX : not implemented */
2005 spr_register(env
, SPR_40x_IAC1
, "IAC",
2006 SPR_NOACCESS
, SPR_NOACCESS
,
2007 &spr_read_generic
, &spr_write_generic
,
2009 /* Storage control */
2010 /* XXX: TODO: not implemented */
2011 spr_register(env
, SPR_405_SLER
, "SLER",
2012 SPR_NOACCESS
, SPR_NOACCESS
,
2013 &spr_read_generic
, &spr_write_40x_sler
,
2015 /* not emulated, as Qemu never does speculative access */
2016 spr_register(env
, SPR_40x_SGR
, "SGR",
2017 SPR_NOACCESS
, SPR_NOACCESS
,
2018 &spr_read_generic
, &spr_write_generic
,
2020 /* not emulated, as Qemu do not emulate caches */
2021 spr_register(env
, SPR_40x_DCWR
, "DCWR",
2022 SPR_NOACCESS
, SPR_NOACCESS
,
2023 &spr_read_generic
, &spr_write_generic
,
2027 static void gen_spr_401x2 (CPUPPCState
*env
)
2030 spr_register(env
, SPR_40x_PID
, "PID",
2031 SPR_NOACCESS
, SPR_NOACCESS
,
2032 &spr_read_generic
, &spr_write_generic
,
2034 spr_register(env
, SPR_40x_ZPR
, "ZPR",
2035 SPR_NOACCESS
, SPR_NOACCESS
,
2036 &spr_read_generic
, &spr_write_generic
,
2040 /* SPR specific to PowerPC 403 implementation */
2041 static void gen_spr_403 (CPUPPCState
*env
)
2043 /* Debug interface */
2044 /* XXX : not implemented */
2045 spr_register(env
, SPR_40x_DBCR0
, "DBCR0",
2046 SPR_NOACCESS
, SPR_NOACCESS
,
2047 &spr_read_generic
, &spr_write_40x_dbcr0
,
2049 /* XXX : not implemented */
2050 spr_register(env
, SPR_40x_DBSR
, "DBSR",
2051 SPR_NOACCESS
, SPR_NOACCESS
,
2052 &spr_read_generic
, &spr_write_clear
,
2053 /* Last reset was system reset */
2055 /* XXX : not implemented */
2056 spr_register(env
, SPR_40x_DAC1
, "DAC1",
2057 SPR_NOACCESS
, SPR_NOACCESS
,
2058 &spr_read_generic
, &spr_write_generic
,
2060 /* XXX : not implemented */
2061 spr_register(env
, SPR_40x_DAC2
, "DAC2",
2062 SPR_NOACCESS
, SPR_NOACCESS
,
2063 &spr_read_generic
, &spr_write_generic
,
2065 /* XXX : not implemented */
2066 spr_register(env
, SPR_40x_IAC1
, "IAC1",
2067 SPR_NOACCESS
, SPR_NOACCESS
,
2068 &spr_read_generic
, &spr_write_generic
,
2070 /* XXX : not implemented */
2071 spr_register(env
, SPR_40x_IAC2
, "IAC2",
2072 SPR_NOACCESS
, SPR_NOACCESS
,
2073 &spr_read_generic
, &spr_write_generic
,
2077 static void gen_spr_403_real (CPUPPCState
*env
)
2079 spr_register(env
, SPR_403_PBL1
, "PBL1",
2080 SPR_NOACCESS
, SPR_NOACCESS
,
2081 &spr_read_403_pbr
, &spr_write_403_pbr
,
2083 spr_register(env
, SPR_403_PBU1
, "PBU1",
2084 SPR_NOACCESS
, SPR_NOACCESS
,
2085 &spr_read_403_pbr
, &spr_write_403_pbr
,
2087 spr_register(env
, SPR_403_PBL2
, "PBL2",
2088 SPR_NOACCESS
, SPR_NOACCESS
,
2089 &spr_read_403_pbr
, &spr_write_403_pbr
,
2091 spr_register(env
, SPR_403_PBU2
, "PBU2",
2092 SPR_NOACCESS
, SPR_NOACCESS
,
2093 &spr_read_403_pbr
, &spr_write_403_pbr
,
2097 static void gen_spr_403_mmu (CPUPPCState
*env
)
2100 spr_register(env
, SPR_40x_PID
, "PID",
2101 SPR_NOACCESS
, SPR_NOACCESS
,
2102 &spr_read_generic
, &spr_write_generic
,
2104 spr_register(env
, SPR_40x_ZPR
, "ZPR",
2105 SPR_NOACCESS
, SPR_NOACCESS
,
2106 &spr_read_generic
, &spr_write_generic
,
2110 /* SPR specific to PowerPC compression coprocessor extension */
2111 static void gen_spr_compress (CPUPPCState
*env
)
2113 /* XXX : not implemented */
2114 spr_register(env
, SPR_401_SKR
, "SKR",
2115 SPR_NOACCESS
, SPR_NOACCESS
,
2116 &spr_read_generic
, &spr_write_generic
,
2120 #if defined (TARGET_PPC64)
2121 /* SPR specific to PowerPC 620 */
2122 static void gen_spr_620 (CPUPPCState
*env
)
2124 /* Processor identification */
2125 spr_register(env
, SPR_PIR
, "PIR",
2126 SPR_NOACCESS
, SPR_NOACCESS
,
2127 &spr_read_generic
, &spr_write_pir
,
2129 spr_register(env
, SPR_ASR
, "ASR",
2130 SPR_NOACCESS
, SPR_NOACCESS
,
2131 &spr_read_asr
, &spr_write_asr
,
2134 /* XXX : not implemented */
2135 spr_register(env
, SPR_IABR
, "IABR",
2136 SPR_NOACCESS
, SPR_NOACCESS
,
2137 &spr_read_generic
, &spr_write_generic
,
2139 /* XXX : not implemented */
2140 spr_register(env
, SPR_DABR
, "DABR",
2141 SPR_NOACCESS
, SPR_NOACCESS
,
2142 &spr_read_generic
, &spr_write_generic
,
2144 /* XXX : not implemented */
2145 spr_register(env
, SPR_SIAR
, "SIAR",
2146 SPR_NOACCESS
, SPR_NOACCESS
,
2147 &spr_read_generic
, SPR_NOACCESS
,
2149 /* XXX : not implemented */
2150 spr_register(env
, SPR_SDA
, "SDA",
2151 SPR_NOACCESS
, SPR_NOACCESS
,
2152 &spr_read_generic
, SPR_NOACCESS
,
2154 /* XXX : not implemented */
2155 spr_register(env
, SPR_620_PMC1R
, "PMC1",
2156 SPR_NOACCESS
, SPR_NOACCESS
,
2157 &spr_read_generic
, SPR_NOACCESS
,
2159 spr_register(env
, SPR_620_PMC1W
, "PMC1",
2160 SPR_NOACCESS
, SPR_NOACCESS
,
2161 SPR_NOACCESS
, &spr_write_generic
,
2163 /* XXX : not implemented */
2164 spr_register(env
, SPR_620_PMC2R
, "PMC2",
2165 SPR_NOACCESS
, SPR_NOACCESS
,
2166 &spr_read_generic
, SPR_NOACCESS
,
2168 spr_register(env
, SPR_620_PMC2W
, "PMC2",
2169 SPR_NOACCESS
, SPR_NOACCESS
,
2170 SPR_NOACCESS
, &spr_write_generic
,
2172 /* XXX : not implemented */
2173 spr_register(env
, SPR_620_MMCR0R
, "MMCR0",
2174 SPR_NOACCESS
, SPR_NOACCESS
,
2175 &spr_read_generic
, SPR_NOACCESS
,
2177 spr_register(env
, SPR_620_MMCR0W
, "MMCR0",
2178 SPR_NOACCESS
, SPR_NOACCESS
,
2179 SPR_NOACCESS
, &spr_write_generic
,
2181 /* External access control */
2182 /* XXX : not implemented */
2183 spr_register(env
, SPR_EAR
, "EAR",
2184 SPR_NOACCESS
, SPR_NOACCESS
,
2185 &spr_read_generic
, &spr_write_generic
,
2187 #if 0 // XXX: check this
2188 /* XXX : not implemented */
2189 spr_register(env
, SPR_620_PMR0
, "PMR0",
2190 SPR_NOACCESS
, SPR_NOACCESS
,
2191 &spr_read_generic
, &spr_write_generic
,
2193 /* XXX : not implemented */
2194 spr_register(env
, SPR_620_PMR1
, "PMR1",
2195 SPR_NOACCESS
, SPR_NOACCESS
,
2196 &spr_read_generic
, &spr_write_generic
,
2198 /* XXX : not implemented */
2199 spr_register(env
, SPR_620_PMR2
, "PMR2",
2200 SPR_NOACCESS
, SPR_NOACCESS
,
2201 &spr_read_generic
, &spr_write_generic
,
2203 /* XXX : not implemented */
2204 spr_register(env
, SPR_620_PMR3
, "PMR3",
2205 SPR_NOACCESS
, SPR_NOACCESS
,
2206 &spr_read_generic
, &spr_write_generic
,
2208 /* XXX : not implemented */
2209 spr_register(env
, SPR_620_PMR4
, "PMR4",
2210 SPR_NOACCESS
, SPR_NOACCESS
,
2211 &spr_read_generic
, &spr_write_generic
,
2213 /* XXX : not implemented */
2214 spr_register(env
, SPR_620_PMR5
, "PMR5",
2215 SPR_NOACCESS
, SPR_NOACCESS
,
2216 &spr_read_generic
, &spr_write_generic
,
2218 /* XXX : not implemented */
2219 spr_register(env
, SPR_620_PMR6
, "PMR6",
2220 SPR_NOACCESS
, SPR_NOACCESS
,
2221 &spr_read_generic
, &spr_write_generic
,
2223 /* XXX : not implemented */
2224 spr_register(env
, SPR_620_PMR7
, "PMR7",
2225 SPR_NOACCESS
, SPR_NOACCESS
,
2226 &spr_read_generic
, &spr_write_generic
,
2228 /* XXX : not implemented */
2229 spr_register(env
, SPR_620_PMR8
, "PMR8",
2230 SPR_NOACCESS
, SPR_NOACCESS
,
2231 &spr_read_generic
, &spr_write_generic
,
2233 /* XXX : not implemented */
2234 spr_register(env
, SPR_620_PMR9
, "PMR9",
2235 SPR_NOACCESS
, SPR_NOACCESS
,
2236 &spr_read_generic
, &spr_write_generic
,
2238 /* XXX : not implemented */
2239 spr_register(env
, SPR_620_PMRA
, "PMR10",
2240 SPR_NOACCESS
, SPR_NOACCESS
,
2241 &spr_read_generic
, &spr_write_generic
,
2243 /* XXX : not implemented */
2244 spr_register(env
, SPR_620_PMRB
, "PMR11",
2245 SPR_NOACCESS
, SPR_NOACCESS
,
2246 &spr_read_generic
, &spr_write_generic
,
2248 /* XXX : not implemented */
2249 spr_register(env
, SPR_620_PMRC
, "PMR12",
2250 SPR_NOACCESS
, SPR_NOACCESS
,
2251 &spr_read_generic
, &spr_write_generic
,
2253 /* XXX : not implemented */
2254 spr_register(env
, SPR_620_PMRD
, "PMR13",
2255 SPR_NOACCESS
, SPR_NOACCESS
,
2256 &spr_read_generic
, &spr_write_generic
,
2258 /* XXX : not implemented */
2259 spr_register(env
, SPR_620_PMRE
, "PMR14",
2260 SPR_NOACCESS
, SPR_NOACCESS
,
2261 &spr_read_generic
, &spr_write_generic
,
2263 /* XXX : not implemented */
2264 spr_register(env
, SPR_620_PMRF
, "PMR15",
2265 SPR_NOACCESS
, SPR_NOACCESS
,
2266 &spr_read_generic
, &spr_write_generic
,
2269 /* XXX : not implemented */
2270 spr_register(env
, SPR_620_BUSCSR
, "BUSCSR",
2271 SPR_NOACCESS
, SPR_NOACCESS
,
2272 &spr_read_generic
, &spr_write_generic
,
2274 /* XXX : not implemented */
2275 spr_register(env
, SPR_620_L2CR
, "L2CR",
2276 SPR_NOACCESS
, SPR_NOACCESS
,
2277 &spr_read_generic
, &spr_write_generic
,
2279 /* XXX : not implemented */
2280 spr_register(env
, SPR_620_L2SR
, "L2SR",
2281 SPR_NOACCESS
, SPR_NOACCESS
,
2282 &spr_read_generic
, &spr_write_generic
,
2285 #endif /* defined (TARGET_PPC64) */
2287 static void gen_spr_5xx_8xx (CPUPPCState
*env
)
2289 /* Exception processing */
2290 spr_register(env
, SPR_DSISR
, "DSISR",
2291 SPR_NOACCESS
, SPR_NOACCESS
,
2292 &spr_read_generic
, &spr_write_generic
,
2294 spr_register(env
, SPR_DAR
, "DAR",
2295 SPR_NOACCESS
, SPR_NOACCESS
,
2296 &spr_read_generic
, &spr_write_generic
,
2299 spr_register(env
, SPR_DECR
, "DECR",
2300 SPR_NOACCESS
, SPR_NOACCESS
,
2301 &spr_read_decr
, &spr_write_decr
,
2303 /* XXX : not implemented */
2304 spr_register(env
, SPR_MPC_EIE
, "EIE",
2305 SPR_NOACCESS
, SPR_NOACCESS
,
2306 &spr_read_generic
, &spr_write_generic
,
2308 /* XXX : not implemented */
2309 spr_register(env
, SPR_MPC_EID
, "EID",
2310 SPR_NOACCESS
, SPR_NOACCESS
,
2311 &spr_read_generic
, &spr_write_generic
,
2313 /* XXX : not implemented */
2314 spr_register(env
, SPR_MPC_NRI
, "NRI",
2315 SPR_NOACCESS
, SPR_NOACCESS
,
2316 &spr_read_generic
, &spr_write_generic
,
2318 /* XXX : not implemented */
2319 spr_register(env
, SPR_MPC_CMPA
, "CMPA",
2320 SPR_NOACCESS
, SPR_NOACCESS
,
2321 &spr_read_generic
, &spr_write_generic
,
2323 /* XXX : not implemented */
2324 spr_register(env
, SPR_MPC_CMPB
, "CMPB",
2325 SPR_NOACCESS
, SPR_NOACCESS
,
2326 &spr_read_generic
, &spr_write_generic
,
2328 /* XXX : not implemented */
2329 spr_register(env
, SPR_MPC_CMPC
, "CMPC",
2330 SPR_NOACCESS
, SPR_NOACCESS
,
2331 &spr_read_generic
, &spr_write_generic
,
2333 /* XXX : not implemented */
2334 spr_register(env
, SPR_MPC_CMPD
, "CMPD",
2335 SPR_NOACCESS
, SPR_NOACCESS
,
2336 &spr_read_generic
, &spr_write_generic
,
2338 /* XXX : not implemented */
2339 spr_register(env
, SPR_MPC_ECR
, "ECR",
2340 SPR_NOACCESS
, SPR_NOACCESS
,
2341 &spr_read_generic
, &spr_write_generic
,
2343 /* XXX : not implemented */
2344 spr_register(env
, SPR_MPC_DER
, "DER",
2345 SPR_NOACCESS
, SPR_NOACCESS
,
2346 &spr_read_generic
, &spr_write_generic
,
2348 /* XXX : not implemented */
2349 spr_register(env
, SPR_MPC_COUNTA
, "COUNTA",
2350 SPR_NOACCESS
, SPR_NOACCESS
,
2351 &spr_read_generic
, &spr_write_generic
,
2353 /* XXX : not implemented */
2354 spr_register(env
, SPR_MPC_COUNTB
, "COUNTB",
2355 SPR_NOACCESS
, SPR_NOACCESS
,
2356 &spr_read_generic
, &spr_write_generic
,
2358 /* XXX : not implemented */
2359 spr_register(env
, SPR_MPC_CMPE
, "CMPE",
2360 SPR_NOACCESS
, SPR_NOACCESS
,
2361 &spr_read_generic
, &spr_write_generic
,
2363 /* XXX : not implemented */
2364 spr_register(env
, SPR_MPC_CMPF
, "CMPF",
2365 SPR_NOACCESS
, SPR_NOACCESS
,
2366 &spr_read_generic
, &spr_write_generic
,
2368 /* XXX : not implemented */
2369 spr_register(env
, SPR_MPC_CMPG
, "CMPG",
2370 SPR_NOACCESS
, SPR_NOACCESS
,
2371 &spr_read_generic
, &spr_write_generic
,
2373 /* XXX : not implemented */
2374 spr_register(env
, SPR_MPC_CMPH
, "CMPH",
2375 SPR_NOACCESS
, SPR_NOACCESS
,
2376 &spr_read_generic
, &spr_write_generic
,
2378 /* XXX : not implemented */
2379 spr_register(env
, SPR_MPC_LCTRL1
, "LCTRL1",
2380 SPR_NOACCESS
, SPR_NOACCESS
,
2381 &spr_read_generic
, &spr_write_generic
,
2383 /* XXX : not implemented */
2384 spr_register(env
, SPR_MPC_LCTRL2
, "LCTRL2",
2385 SPR_NOACCESS
, SPR_NOACCESS
,
2386 &spr_read_generic
, &spr_write_generic
,
2388 /* XXX : not implemented */
2389 spr_register(env
, SPR_MPC_BAR
, "BAR",
2390 SPR_NOACCESS
, SPR_NOACCESS
,
2391 &spr_read_generic
, &spr_write_generic
,
2393 /* XXX : not implemented */
2394 spr_register(env
, SPR_MPC_DPDR
, "DPDR",
2395 SPR_NOACCESS
, SPR_NOACCESS
,
2396 &spr_read_generic
, &spr_write_generic
,
2398 /* XXX : not implemented */
2399 spr_register(env
, SPR_MPC_IMMR
, "IMMR",
2400 SPR_NOACCESS
, SPR_NOACCESS
,
2401 &spr_read_generic
, &spr_write_generic
,
2405 static void gen_spr_5xx (CPUPPCState
*env
)
2407 /* XXX : not implemented */
2408 spr_register(env
, SPR_RCPU_MI_GRA
, "MI_GRA",
2409 SPR_NOACCESS
, SPR_NOACCESS
,
2410 &spr_read_generic
, &spr_write_generic
,
2412 /* XXX : not implemented */
2413 spr_register(env
, SPR_RCPU_L2U_GRA
, "L2U_GRA",
2414 SPR_NOACCESS
, SPR_NOACCESS
,
2415 &spr_read_generic
, &spr_write_generic
,
2417 /* XXX : not implemented */
2418 spr_register(env
, SPR_RPCU_BBCMCR
, "L2U_BBCMCR",
2419 SPR_NOACCESS
, SPR_NOACCESS
,
2420 &spr_read_generic
, &spr_write_generic
,
2422 /* XXX : not implemented */
2423 spr_register(env
, SPR_RCPU_L2U_MCR
, "L2U_MCR",
2424 SPR_NOACCESS
, SPR_NOACCESS
,
2425 &spr_read_generic
, &spr_write_generic
,
2427 /* XXX : not implemented */
2428 spr_register(env
, SPR_RCPU_MI_RBA0
, "MI_RBA0",
2429 SPR_NOACCESS
, SPR_NOACCESS
,
2430 &spr_read_generic
, &spr_write_generic
,
2432 /* XXX : not implemented */
2433 spr_register(env
, SPR_RCPU_MI_RBA1
, "MI_RBA1",
2434 SPR_NOACCESS
, SPR_NOACCESS
,
2435 &spr_read_generic
, &spr_write_generic
,
2437 /* XXX : not implemented */
2438 spr_register(env
, SPR_RCPU_MI_RBA2
, "MI_RBA2",
2439 SPR_NOACCESS
, SPR_NOACCESS
,
2440 &spr_read_generic
, &spr_write_generic
,
2442 /* XXX : not implemented */
2443 spr_register(env
, SPR_RCPU_MI_RBA3
, "MI_RBA3",
2444 SPR_NOACCESS
, SPR_NOACCESS
,
2445 &spr_read_generic
, &spr_write_generic
,
2447 /* XXX : not implemented */
2448 spr_register(env
, SPR_RCPU_L2U_RBA0
, "L2U_RBA0",
2449 SPR_NOACCESS
, SPR_NOACCESS
,
2450 &spr_read_generic
, &spr_write_generic
,
2452 /* XXX : not implemented */
2453 spr_register(env
, SPR_RCPU_L2U_RBA1
, "L2U_RBA1",
2454 SPR_NOACCESS
, SPR_NOACCESS
,
2455 &spr_read_generic
, &spr_write_generic
,
2457 /* XXX : not implemented */
2458 spr_register(env
, SPR_RCPU_L2U_RBA2
, "L2U_RBA2",
2459 SPR_NOACCESS
, SPR_NOACCESS
,
2460 &spr_read_generic
, &spr_write_generic
,
2462 /* XXX : not implemented */
2463 spr_register(env
, SPR_RCPU_L2U_RBA3
, "L2U_RBA3",
2464 SPR_NOACCESS
, SPR_NOACCESS
,
2465 &spr_read_generic
, &spr_write_generic
,
2467 /* XXX : not implemented */
2468 spr_register(env
, SPR_RCPU_MI_RA0
, "MI_RA0",
2469 SPR_NOACCESS
, SPR_NOACCESS
,
2470 &spr_read_generic
, &spr_write_generic
,
2472 /* XXX : not implemented */
2473 spr_register(env
, SPR_RCPU_MI_RA1
, "MI_RA1",
2474 SPR_NOACCESS
, SPR_NOACCESS
,
2475 &spr_read_generic
, &spr_write_generic
,
2477 /* XXX : not implemented */
2478 spr_register(env
, SPR_RCPU_MI_RA2
, "MI_RA2",
2479 SPR_NOACCESS
, SPR_NOACCESS
,
2480 &spr_read_generic
, &spr_write_generic
,
2482 /* XXX : not implemented */
2483 spr_register(env
, SPR_RCPU_MI_RA3
, "MI_RA3",
2484 SPR_NOACCESS
, SPR_NOACCESS
,
2485 &spr_read_generic
, &spr_write_generic
,
2487 /* XXX : not implemented */
2488 spr_register(env
, SPR_RCPU_L2U_RA0
, "L2U_RA0",
2489 SPR_NOACCESS
, SPR_NOACCESS
,
2490 &spr_read_generic
, &spr_write_generic
,
2492 /* XXX : not implemented */
2493 spr_register(env
, SPR_RCPU_L2U_RA1
, "L2U_RA1",
2494 SPR_NOACCESS
, SPR_NOACCESS
,
2495 &spr_read_generic
, &spr_write_generic
,
2497 /* XXX : not implemented */
2498 spr_register(env
, SPR_RCPU_L2U_RA2
, "L2U_RA2",
2499 SPR_NOACCESS
, SPR_NOACCESS
,
2500 &spr_read_generic
, &spr_write_generic
,
2502 /* XXX : not implemented */
2503 spr_register(env
, SPR_RCPU_L2U_RA3
, "L2U_RA3",
2504 SPR_NOACCESS
, SPR_NOACCESS
,
2505 &spr_read_generic
, &spr_write_generic
,
2507 /* XXX : not implemented */
2508 spr_register(env
, SPR_RCPU_FPECR
, "FPECR",
2509 SPR_NOACCESS
, SPR_NOACCESS
,
2510 &spr_read_generic
, &spr_write_generic
,
2514 static void gen_spr_8xx (CPUPPCState
*env
)
2516 /* XXX : not implemented */
2517 spr_register(env
, SPR_MPC_IC_CST
, "IC_CST",
2518 SPR_NOACCESS
, SPR_NOACCESS
,
2519 &spr_read_generic
, &spr_write_generic
,
2521 /* XXX : not implemented */
2522 spr_register(env
, SPR_MPC_IC_ADR
, "IC_ADR",
2523 SPR_NOACCESS
, SPR_NOACCESS
,
2524 &spr_read_generic
, &spr_write_generic
,
2526 /* XXX : not implemented */
2527 spr_register(env
, SPR_MPC_IC_DAT
, "IC_DAT",
2528 SPR_NOACCESS
, SPR_NOACCESS
,
2529 &spr_read_generic
, &spr_write_generic
,
2531 /* XXX : not implemented */
2532 spr_register(env
, SPR_MPC_DC_CST
, "DC_CST",
2533 SPR_NOACCESS
, SPR_NOACCESS
,
2534 &spr_read_generic
, &spr_write_generic
,
2536 /* XXX : not implemented */
2537 spr_register(env
, SPR_MPC_DC_ADR
, "DC_ADR",
2538 SPR_NOACCESS
, SPR_NOACCESS
,
2539 &spr_read_generic
, &spr_write_generic
,
2541 /* XXX : not implemented */
2542 spr_register(env
, SPR_MPC_DC_DAT
, "DC_DAT",
2543 SPR_NOACCESS
, SPR_NOACCESS
,
2544 &spr_read_generic
, &spr_write_generic
,
2546 /* XXX : not implemented */
2547 spr_register(env
, SPR_MPC_MI_CTR
, "MI_CTR",
2548 SPR_NOACCESS
, SPR_NOACCESS
,
2549 &spr_read_generic
, &spr_write_generic
,
2551 /* XXX : not implemented */
2552 spr_register(env
, SPR_MPC_MI_AP
, "MI_AP",
2553 SPR_NOACCESS
, SPR_NOACCESS
,
2554 &spr_read_generic
, &spr_write_generic
,
2556 /* XXX : not implemented */
2557 spr_register(env
, SPR_MPC_MI_EPN
, "MI_EPN",
2558 SPR_NOACCESS
, SPR_NOACCESS
,
2559 &spr_read_generic
, &spr_write_generic
,
2561 /* XXX : not implemented */
2562 spr_register(env
, SPR_MPC_MI_TWC
, "MI_TWC",
2563 SPR_NOACCESS
, SPR_NOACCESS
,
2564 &spr_read_generic
, &spr_write_generic
,
2566 /* XXX : not implemented */
2567 spr_register(env
, SPR_MPC_MI_RPN
, "MI_RPN",
2568 SPR_NOACCESS
, SPR_NOACCESS
,
2569 &spr_read_generic
, &spr_write_generic
,
2571 /* XXX : not implemented */
2572 spr_register(env
, SPR_MPC_MI_DBCAM
, "MI_DBCAM",
2573 SPR_NOACCESS
, SPR_NOACCESS
,
2574 &spr_read_generic
, &spr_write_generic
,
2576 /* XXX : not implemented */
2577 spr_register(env
, SPR_MPC_MI_DBRAM0
, "MI_DBRAM0",
2578 SPR_NOACCESS
, SPR_NOACCESS
,
2579 &spr_read_generic
, &spr_write_generic
,
2581 /* XXX : not implemented */
2582 spr_register(env
, SPR_MPC_MI_DBRAM1
, "MI_DBRAM1",
2583 SPR_NOACCESS
, SPR_NOACCESS
,
2584 &spr_read_generic
, &spr_write_generic
,
2586 /* XXX : not implemented */
2587 spr_register(env
, SPR_MPC_MD_CTR
, "MD_CTR",
2588 SPR_NOACCESS
, SPR_NOACCESS
,
2589 &spr_read_generic
, &spr_write_generic
,
2591 /* XXX : not implemented */
2592 spr_register(env
, SPR_MPC_MD_CASID
, "MD_CASID",
2593 SPR_NOACCESS
, SPR_NOACCESS
,
2594 &spr_read_generic
, &spr_write_generic
,
2596 /* XXX : not implemented */
2597 spr_register(env
, SPR_MPC_MD_AP
, "MD_AP",
2598 SPR_NOACCESS
, SPR_NOACCESS
,
2599 &spr_read_generic
, &spr_write_generic
,
2601 /* XXX : not implemented */
2602 spr_register(env
, SPR_MPC_MD_EPN
, "MD_EPN",
2603 SPR_NOACCESS
, SPR_NOACCESS
,
2604 &spr_read_generic
, &spr_write_generic
,
2606 /* XXX : not implemented */
2607 spr_register(env
, SPR_MPC_MD_TWB
, "MD_TWB",
2608 SPR_NOACCESS
, SPR_NOACCESS
,
2609 &spr_read_generic
, &spr_write_generic
,
2611 /* XXX : not implemented */
2612 spr_register(env
, SPR_MPC_MD_TWC
, "MD_TWC",
2613 SPR_NOACCESS
, SPR_NOACCESS
,
2614 &spr_read_generic
, &spr_write_generic
,
2616 /* XXX : not implemented */
2617 spr_register(env
, SPR_MPC_MD_RPN
, "MD_RPN",
2618 SPR_NOACCESS
, SPR_NOACCESS
,
2619 &spr_read_generic
, &spr_write_generic
,
2621 /* XXX : not implemented */
2622 spr_register(env
, SPR_MPC_MD_TW
, "MD_TW",
2623 SPR_NOACCESS
, SPR_NOACCESS
,
2624 &spr_read_generic
, &spr_write_generic
,
2626 /* XXX : not implemented */
2627 spr_register(env
, SPR_MPC_MD_DBCAM
, "MD_DBCAM",
2628 SPR_NOACCESS
, SPR_NOACCESS
,
2629 &spr_read_generic
, &spr_write_generic
,
2631 /* XXX : not implemented */
2632 spr_register(env
, SPR_MPC_MD_DBRAM0
, "MD_DBRAM0",
2633 SPR_NOACCESS
, SPR_NOACCESS
,
2634 &spr_read_generic
, &spr_write_generic
,
2636 /* XXX : not implemented */
2637 spr_register(env
, SPR_MPC_MD_DBRAM1
, "MD_DBRAM1",
2638 SPR_NOACCESS
, SPR_NOACCESS
,
2639 &spr_read_generic
, &spr_write_generic
,
2645 * AMR => SPR 29 (Power 2.04)
2646 * CTRL => SPR 136 (Power 2.04)
2647 * CTRL => SPR 152 (Power 2.04)
2648 * SCOMC => SPR 276 (64 bits ?)
2649 * SCOMD => SPR 277 (64 bits ?)
2650 * TBU40 => SPR 286 (Power 2.04 hypv)
2651 * HSPRG0 => SPR 304 (Power 2.04 hypv)
2652 * HSPRG1 => SPR 305 (Power 2.04 hypv)
2653 * HDSISR => SPR 306 (Power 2.04 hypv)
2654 * HDAR => SPR 307 (Power 2.04 hypv)
2655 * PURR => SPR 309 (Power 2.04 hypv)
2656 * HDEC => SPR 310 (Power 2.04 hypv)
2657 * HIOR => SPR 311 (hypv)
2658 * RMOR => SPR 312 (970)
2659 * HRMOR => SPR 313 (Power 2.04 hypv)
2660 * HSRR0 => SPR 314 (Power 2.04 hypv)
2661 * HSRR1 => SPR 315 (Power 2.04 hypv)
2662 * LPCR => SPR 316 (970)
2663 * LPIDR => SPR 317 (970)
2664 * EPR => SPR 702 (Power 2.04 emb)
2665 * perf => 768-783 (Power 2.04)
2666 * perf => 784-799 (Power 2.04)
2667 * PPR => SPR 896 (Power 2.04)
2668 * EPLC => SPR 947 (Power 2.04 emb)
2669 * EPSC => SPR 948 (Power 2.04 emb)
2670 * DABRX => 1015 (Power 2.04 hypv)
2671 * FPECR => SPR 1022 (?)
2672 * ... and more (thermal management, performance counters, ...)
2675 /*****************************************************************************/
2676 /* Exception vectors models */
2677 static void init_excp_4xx_real (CPUPPCState
*env
)
2679 #if !defined(CONFIG_USER_ONLY)
2680 env
->excp_vectors
[POWERPC_EXCP_CRITICAL
] = 0x00000100;
2681 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2682 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2683 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2684 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2685 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
2686 env
->excp_vectors
[POWERPC_EXCP_PIT
] = 0x00001000;
2687 env
->excp_vectors
[POWERPC_EXCP_FIT
] = 0x00001010;
2688 env
->excp_vectors
[POWERPC_EXCP_WDT
] = 0x00001020;
2689 env
->excp_vectors
[POWERPC_EXCP_DEBUG
] = 0x00002000;
2690 env
->hreset_excp_prefix
= 0x00000000UL
;
2691 env
->ivor_mask
= 0x0000FFF0UL
;
2692 env
->ivpr_mask
= 0xFFFF0000UL
;
2693 /* Hardware reset vector */
2694 env
->hreset_vector
= 0xFFFFFFFCUL
;
2698 static void init_excp_4xx_softmmu (CPUPPCState
*env
)
2700 #if !defined(CONFIG_USER_ONLY)
2701 env
->excp_vectors
[POWERPC_EXCP_CRITICAL
] = 0x00000100;
2702 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2703 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
2704 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
2705 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2706 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2707 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2708 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
2709 env
->excp_vectors
[POWERPC_EXCP_PIT
] = 0x00001000;
2710 env
->excp_vectors
[POWERPC_EXCP_FIT
] = 0x00001010;
2711 env
->excp_vectors
[POWERPC_EXCP_WDT
] = 0x00001020;
2712 env
->excp_vectors
[POWERPC_EXCP_DTLB
] = 0x00001100;
2713 env
->excp_vectors
[POWERPC_EXCP_ITLB
] = 0x00001200;
2714 env
->excp_vectors
[POWERPC_EXCP_DEBUG
] = 0x00002000;
2715 env
->hreset_excp_prefix
= 0x00000000UL
;
2716 env
->ivor_mask
= 0x0000FFF0UL
;
2717 env
->ivpr_mask
= 0xFFFF0000UL
;
2718 /* Hardware reset vector */
2719 env
->hreset_vector
= 0xFFFFFFFCUL
;
2723 static void init_excp_MPC5xx (CPUPPCState
*env
)
2725 #if !defined(CONFIG_USER_ONLY)
2726 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
2727 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2728 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2729 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2730 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2731 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000900;
2732 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
2733 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
2734 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
2735 env
->excp_vectors
[POWERPC_EXCP_FPA
] = 0x00000E00;
2736 env
->excp_vectors
[POWERPC_EXCP_EMUL
] = 0x00001000;
2737 env
->excp_vectors
[POWERPC_EXCP_DABR
] = 0x00001C00;
2738 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001C00;
2739 env
->excp_vectors
[POWERPC_EXCP_MEXTBR
] = 0x00001E00;
2740 env
->excp_vectors
[POWERPC_EXCP_NMEXTBR
] = 0x00001F00;
2741 env
->hreset_excp_prefix
= 0x00000000UL
;
2742 env
->ivor_mask
= 0x0000FFF0UL
;
2743 env
->ivpr_mask
= 0xFFFF0000UL
;
2744 /* Hardware reset vector */
2745 env
->hreset_vector
= 0xFFFFFFFCUL
;
2749 static void init_excp_MPC8xx (CPUPPCState
*env
)
2751 #if !defined(CONFIG_USER_ONLY)
2752 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
2753 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2754 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
2755 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
2756 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2757 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2758 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2759 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000900;
2760 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
2761 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
2762 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
2763 env
->excp_vectors
[POWERPC_EXCP_FPA
] = 0x00000E00;
2764 env
->excp_vectors
[POWERPC_EXCP_EMUL
] = 0x00001000;
2765 env
->excp_vectors
[POWERPC_EXCP_ITLB
] = 0x00001100;
2766 env
->excp_vectors
[POWERPC_EXCP_DTLB
] = 0x00001200;
2767 env
->excp_vectors
[POWERPC_EXCP_ITLBE
] = 0x00001300;
2768 env
->excp_vectors
[POWERPC_EXCP_DTLBE
] = 0x00001400;
2769 env
->excp_vectors
[POWERPC_EXCP_DABR
] = 0x00001C00;
2770 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001C00;
2771 env
->excp_vectors
[POWERPC_EXCP_MEXTBR
] = 0x00001E00;
2772 env
->excp_vectors
[POWERPC_EXCP_NMEXTBR
] = 0x00001F00;
2773 env
->hreset_excp_prefix
= 0x00000000UL
;
2774 env
->ivor_mask
= 0x0000FFF0UL
;
2775 env
->ivpr_mask
= 0xFFFF0000UL
;
2776 /* Hardware reset vector */
2777 env
->hreset_vector
= 0xFFFFFFFCUL
;
2781 static void init_excp_G2 (CPUPPCState
*env
)
2783 #if !defined(CONFIG_USER_ONLY)
2784 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
2785 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2786 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
2787 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
2788 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2789 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2790 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2791 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
2792 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
2793 env
->excp_vectors
[POWERPC_EXCP_CRITICAL
] = 0x00000A00;
2794 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
2795 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
2796 env
->excp_vectors
[POWERPC_EXCP_IFTLB
] = 0x00001000;
2797 env
->excp_vectors
[POWERPC_EXCP_DLTLB
] = 0x00001100;
2798 env
->excp_vectors
[POWERPC_EXCP_DSTLB
] = 0x00001200;
2799 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
2800 env
->excp_vectors
[POWERPC_EXCP_SMI
] = 0x00001400;
2801 env
->hreset_excp_prefix
= 0x00000000UL
;
2802 /* Hardware reset vector */
2803 env
->hreset_vector
= 0xFFFFFFFCUL
;
2807 static void init_excp_e200 (CPUPPCState
*env
)
2809 #if !defined(CONFIG_USER_ONLY)
2810 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000FFC;
2811 env
->excp_vectors
[POWERPC_EXCP_CRITICAL
] = 0x00000000;
2812 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000000;
2813 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000000;
2814 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000000;
2815 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000000;
2816 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000000;
2817 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000000;
2818 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000000;
2819 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000000;
2820 env
->excp_vectors
[POWERPC_EXCP_APU
] = 0x00000000;
2821 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000000;
2822 env
->excp_vectors
[POWERPC_EXCP_FIT
] = 0x00000000;
2823 env
->excp_vectors
[POWERPC_EXCP_WDT
] = 0x00000000;
2824 env
->excp_vectors
[POWERPC_EXCP_DTLB
] = 0x00000000;
2825 env
->excp_vectors
[POWERPC_EXCP_ITLB
] = 0x00000000;
2826 env
->excp_vectors
[POWERPC_EXCP_DEBUG
] = 0x00000000;
2827 env
->excp_vectors
[POWERPC_EXCP_SPEU
] = 0x00000000;
2828 env
->excp_vectors
[POWERPC_EXCP_EFPDI
] = 0x00000000;
2829 env
->excp_vectors
[POWERPC_EXCP_EFPRI
] = 0x00000000;
2830 env
->hreset_excp_prefix
= 0x00000000UL
;
2831 env
->ivor_mask
= 0x0000FFF7UL
;
2832 env
->ivpr_mask
= 0xFFFF0000UL
;
2833 /* Hardware reset vector */
2834 env
->hreset_vector
= 0xFFFFFFFCUL
;
2838 static void init_excp_BookE (CPUPPCState
*env
)
2840 #if !defined(CONFIG_USER_ONLY)
2841 env
->excp_vectors
[POWERPC_EXCP_CRITICAL
] = 0x00000000;
2842 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000000;
2843 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000000;
2844 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000000;
2845 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000000;
2846 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000000;
2847 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000000;
2848 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000000;
2849 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000000;
2850 env
->excp_vectors
[POWERPC_EXCP_APU
] = 0x00000000;
2851 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000000;
2852 env
->excp_vectors
[POWERPC_EXCP_FIT
] = 0x00000000;
2853 env
->excp_vectors
[POWERPC_EXCP_WDT
] = 0x00000000;
2854 env
->excp_vectors
[POWERPC_EXCP_DTLB
] = 0x00000000;
2855 env
->excp_vectors
[POWERPC_EXCP_ITLB
] = 0x00000000;
2856 env
->excp_vectors
[POWERPC_EXCP_DEBUG
] = 0x00000000;
2857 env
->hreset_excp_prefix
= 0x00000000UL
;
2858 env
->ivor_mask
= 0x0000FFE0UL
;
2859 env
->ivpr_mask
= 0xFFFF0000UL
;
2860 /* Hardware reset vector */
2861 env
->hreset_vector
= 0xFFFFFFFCUL
;
2865 static void init_excp_601 (CPUPPCState
*env
)
2867 #if !defined(CONFIG_USER_ONLY)
2868 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
2869 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2870 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
2871 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
2872 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2873 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2874 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2875 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
2876 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
2877 env
->excp_vectors
[POWERPC_EXCP_IO
] = 0x00000A00;
2878 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
2879 env
->excp_vectors
[POWERPC_EXCP_RUNM
] = 0x00002000;
2880 env
->hreset_excp_prefix
= 0xFFF00000UL
;
2881 /* Hardware reset vector */
2882 env
->hreset_vector
= 0x00000100UL
;
2886 static void init_excp_602 (CPUPPCState
*env
)
2888 #if !defined(CONFIG_USER_ONLY)
2889 /* XXX: exception prefix has a special behavior on 602 */
2890 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
2891 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2892 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
2893 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
2894 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2895 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2896 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2897 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
2898 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
2899 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
2900 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
2901 env
->excp_vectors
[POWERPC_EXCP_IFTLB
] = 0x00001000;
2902 env
->excp_vectors
[POWERPC_EXCP_DLTLB
] = 0x00001100;
2903 env
->excp_vectors
[POWERPC_EXCP_DSTLB
] = 0x00001200;
2904 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
2905 env
->excp_vectors
[POWERPC_EXCP_SMI
] = 0x00001400;
2906 env
->excp_vectors
[POWERPC_EXCP_WDT
] = 0x00001500;
2907 env
->excp_vectors
[POWERPC_EXCP_EMUL
] = 0x00001600;
2908 env
->hreset_excp_prefix
= 0xFFF00000UL
;
2909 /* Hardware reset vector */
2910 env
->hreset_vector
= 0xFFFFFFFCUL
;
2914 static void init_excp_603 (CPUPPCState
*env
)
2916 #if !defined(CONFIG_USER_ONLY)
2917 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
2918 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2919 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
2920 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
2921 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2922 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2923 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2924 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
2925 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
2926 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
2927 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
2928 env
->excp_vectors
[POWERPC_EXCP_IFTLB
] = 0x00001000;
2929 env
->excp_vectors
[POWERPC_EXCP_DLTLB
] = 0x00001100;
2930 env
->excp_vectors
[POWERPC_EXCP_DSTLB
] = 0x00001200;
2931 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
2932 env
->excp_vectors
[POWERPC_EXCP_SMI
] = 0x00001400;
2933 env
->hreset_excp_prefix
= 0x00000000UL
;
2934 /* Hardware reset vector */
2935 env
->hreset_vector
= 0xFFFFFFFCUL
;
2939 static void init_excp_604 (CPUPPCState
*env
)
2941 #if !defined(CONFIG_USER_ONLY)
2942 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
2943 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2944 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
2945 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
2946 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2947 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2948 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2949 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
2950 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
2951 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
2952 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
2953 env
->excp_vectors
[POWERPC_EXCP_PERFM
] = 0x00000F00;
2954 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
2955 env
->excp_vectors
[POWERPC_EXCP_SMI
] = 0x00001400;
2956 env
->hreset_excp_prefix
= 0xFFF00000UL
;
2957 /* Hardware reset vector */
2958 env
->hreset_vector
= 0x00000100UL
;
2962 #if defined(TARGET_PPC64)
2963 static void init_excp_620 (CPUPPCState
*env
)
2965 #if !defined(CONFIG_USER_ONLY)
2966 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
2967 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2968 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
2969 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
2970 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2971 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2972 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2973 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
2974 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
2975 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
2976 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
2977 env
->excp_vectors
[POWERPC_EXCP_PERFM
] = 0x00000F00;
2978 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
2979 env
->excp_vectors
[POWERPC_EXCP_SMI
] = 0x00001400;
2980 env
->hreset_excp_prefix
= 0xFFF00000UL
;
2981 /* Hardware reset vector */
2982 env
->hreset_vector
= 0x0000000000000100ULL
;
2985 #endif /* defined(TARGET_PPC64) */
2987 static void init_excp_7x0 (CPUPPCState
*env
)
2989 #if !defined(CONFIG_USER_ONLY)
2990 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
2991 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
2992 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
2993 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
2994 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
2995 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
2996 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
2997 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
2998 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
2999 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
3000 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
3001 env
->excp_vectors
[POWERPC_EXCP_PERFM
] = 0x00000F00;
3002 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
3003 env
->excp_vectors
[POWERPC_EXCP_SMI
] = 0x00001400;
3004 env
->excp_vectors
[POWERPC_EXCP_THERM
] = 0x00001700;
3005 env
->hreset_excp_prefix
= 0x00000000UL
;
3006 /* Hardware reset vector */
3007 env
->hreset_vector
= 0xFFFFFFFCUL
;
3011 static void init_excp_750cl (CPUPPCState
*env
)
3013 #if !defined(CONFIG_USER_ONLY)
3014 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
3015 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
3016 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
3017 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
3018 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
3019 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
3020 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
3021 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
3022 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
3023 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
3024 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
3025 env
->excp_vectors
[POWERPC_EXCP_PERFM
] = 0x00000F00;
3026 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
3027 env
->excp_vectors
[POWERPC_EXCP_SMI
] = 0x00001400;
3028 env
->hreset_excp_prefix
= 0x00000000UL
;
3029 /* Hardware reset vector */
3030 env
->hreset_vector
= 0xFFFFFFFCUL
;
3034 static void init_excp_750cx (CPUPPCState
*env
)
3036 #if !defined(CONFIG_USER_ONLY)
3037 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
3038 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
3039 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
3040 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
3041 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
3042 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
3043 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
3044 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
3045 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
3046 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
3047 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
3048 env
->excp_vectors
[POWERPC_EXCP_PERFM
] = 0x00000F00;
3049 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
3050 env
->excp_vectors
[POWERPC_EXCP_THERM
] = 0x00001700;
3051 env
->hreset_excp_prefix
= 0x00000000UL
;
3052 /* Hardware reset vector */
3053 env
->hreset_vector
= 0xFFFFFFFCUL
;
3057 /* XXX: Check if this is correct */
3058 static void init_excp_7x5 (CPUPPCState
*env
)
3060 #if !defined(CONFIG_USER_ONLY)
3061 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
3062 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
3063 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
3064 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
3065 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
3066 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
3067 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
3068 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
3069 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
3070 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
3071 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
3072 env
->excp_vectors
[POWERPC_EXCP_PERFM
] = 0x00000F00;
3073 env
->excp_vectors
[POWERPC_EXCP_IFTLB
] = 0x00001000;
3074 env
->excp_vectors
[POWERPC_EXCP_DLTLB
] = 0x00001100;
3075 env
->excp_vectors
[POWERPC_EXCP_DSTLB
] = 0x00001200;
3076 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
3077 env
->excp_vectors
[POWERPC_EXCP_SMI
] = 0x00001400;
3078 env
->excp_vectors
[POWERPC_EXCP_THERM
] = 0x00001700;
3079 env
->hreset_excp_prefix
= 0x00000000UL
;
3080 /* Hardware reset vector */
3081 env
->hreset_vector
= 0xFFFFFFFCUL
;
3085 static void init_excp_7400 (CPUPPCState
*env
)
3087 #if !defined(CONFIG_USER_ONLY)
3088 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
3089 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
3090 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
3091 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
3092 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
3093 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
3094 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
3095 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
3096 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
3097 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
3098 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
3099 env
->excp_vectors
[POWERPC_EXCP_PERFM
] = 0x00000F00;
3100 env
->excp_vectors
[POWERPC_EXCP_VPU
] = 0x00000F20;
3101 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
3102 env
->excp_vectors
[POWERPC_EXCP_SMI
] = 0x00001400;
3103 env
->excp_vectors
[POWERPC_EXCP_VPUA
] = 0x00001600;
3104 env
->excp_vectors
[POWERPC_EXCP_THERM
] = 0x00001700;
3105 env
->hreset_excp_prefix
= 0x00000000UL
;
3106 /* Hardware reset vector */
3107 env
->hreset_vector
= 0xFFFFFFFCUL
;
3111 static void init_excp_7450 (CPUPPCState
*env
)
3113 #if !defined(CONFIG_USER_ONLY)
3114 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
3115 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
3116 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
3117 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
3118 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
3119 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
3120 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
3121 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
3122 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
3123 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
3124 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
3125 env
->excp_vectors
[POWERPC_EXCP_PERFM
] = 0x00000F00;
3126 env
->excp_vectors
[POWERPC_EXCP_VPU
] = 0x00000F20;
3127 env
->excp_vectors
[POWERPC_EXCP_IFTLB
] = 0x00001000;
3128 env
->excp_vectors
[POWERPC_EXCP_DLTLB
] = 0x00001100;
3129 env
->excp_vectors
[POWERPC_EXCP_DSTLB
] = 0x00001200;
3130 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
3131 env
->excp_vectors
[POWERPC_EXCP_SMI
] = 0x00001400;
3132 env
->excp_vectors
[POWERPC_EXCP_VPUA
] = 0x00001600;
3133 env
->hreset_excp_prefix
= 0x00000000UL
;
3134 /* Hardware reset vector */
3135 env
->hreset_vector
= 0xFFFFFFFCUL
;
3139 #if defined (TARGET_PPC64)
3140 static void init_excp_970 (CPUPPCState
*env
)
3142 #if !defined(CONFIG_USER_ONLY)
3143 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
3144 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
3145 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
3146 env
->excp_vectors
[POWERPC_EXCP_DSEG
] = 0x00000380;
3147 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
3148 env
->excp_vectors
[POWERPC_EXCP_ISEG
] = 0x00000480;
3149 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
3150 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
3151 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
3152 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
3153 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
3154 env
->excp_vectors
[POWERPC_EXCP_HDECR
] = 0x00000980;
3155 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
3156 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
3157 env
->excp_vectors
[POWERPC_EXCP_PERFM
] = 0x00000F00;
3158 env
->excp_vectors
[POWERPC_EXCP_VPU
] = 0x00000F20;
3159 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
3160 env
->excp_vectors
[POWERPC_EXCP_MAINT
] = 0x00001600;
3161 env
->excp_vectors
[POWERPC_EXCP_VPUA
] = 0x00001700;
3162 env
->excp_vectors
[POWERPC_EXCP_THERM
] = 0x00001800;
3163 env
->hreset_excp_prefix
= 0x00000000FFF00000ULL
;
3164 /* Hardware reset vector */
3165 env
->hreset_vector
= 0x0000000000000100ULL
;
3169 static void init_excp_POWER7 (CPUPPCState
*env
)
3171 #if !defined(CONFIG_USER_ONLY)
3172 env
->excp_vectors
[POWERPC_EXCP_RESET
] = 0x00000100;
3173 env
->excp_vectors
[POWERPC_EXCP_MCHECK
] = 0x00000200;
3174 env
->excp_vectors
[POWERPC_EXCP_DSI
] = 0x00000300;
3175 env
->excp_vectors
[POWERPC_EXCP_DSEG
] = 0x00000380;
3176 env
->excp_vectors
[POWERPC_EXCP_ISI
] = 0x00000400;
3177 env
->excp_vectors
[POWERPC_EXCP_ISEG
] = 0x00000480;
3178 env
->excp_vectors
[POWERPC_EXCP_EXTERNAL
] = 0x00000500;
3179 env
->excp_vectors
[POWERPC_EXCP_ALIGN
] = 0x00000600;
3180 env
->excp_vectors
[POWERPC_EXCP_PROGRAM
] = 0x00000700;
3181 env
->excp_vectors
[POWERPC_EXCP_FPU
] = 0x00000800;
3182 env
->excp_vectors
[POWERPC_EXCP_DECR
] = 0x00000900;
3183 env
->excp_vectors
[POWERPC_EXCP_HDECR
] = 0x00000980;
3184 env
->excp_vectors
[POWERPC_EXCP_SYSCALL
] = 0x00000C00;
3185 env
->excp_vectors
[POWERPC_EXCP_TRACE
] = 0x00000D00;
3186 env
->excp_vectors
[POWERPC_EXCP_PERFM
] = 0x00000F00;
3187 env
->excp_vectors
[POWERPC_EXCP_VPU
] = 0x00000F20;
3188 env
->excp_vectors
[POWERPC_EXCP_IABR
] = 0x00001300;
3189 env
->excp_vectors
[POWERPC_EXCP_MAINT
] = 0x00001600;
3190 env
->excp_vectors
[POWERPC_EXCP_VPUA
] = 0x00001700;
3191 env
->excp_vectors
[POWERPC_EXCP_THERM
] = 0x00001800;
3192 env
->hreset_excp_prefix
= 0;
3193 /* Hardware reset vector */
3194 env
->hreset_vector
= 0x0000000000000100ULL
;
3199 /*****************************************************************************/
3200 /* Power management enable checks */
3201 static int check_pow_none (CPUPPCState
*env
)
3206 static int check_pow_nocheck (CPUPPCState
*env
)
3211 static int check_pow_hid0 (CPUPPCState
*env
)
3213 if (env
->spr
[SPR_HID0
] & 0x00E00000)
3219 static int check_pow_hid0_74xx (CPUPPCState
*env
)
3221 if (env
->spr
[SPR_HID0
] & 0x00600000)
3227 /*****************************************************************************/
3228 /* PowerPC implementations definitions */
3231 #define POWERPC_INSNS_401 (PPC_INSNS_BASE | PPC_STRING | \
3232 PPC_WRTEE | PPC_DCR | \
3233 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT | \
3235 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
3236 PPC_4xx_COMMON | PPC_40x_EXCP)
3237 #define POWERPC_INSNS2_401 (PPC_NONE)
3238 #define POWERPC_MSRM_401 (0x00000000000FD201ULL)
3239 #define POWERPC_MMU_401 (POWERPC_MMU_REAL)
3240 #define POWERPC_EXCP_401 (POWERPC_EXCP_40x)
3241 #define POWERPC_INPUT_401 (PPC_FLAGS_INPUT_401)
3242 #define POWERPC_BFDM_401 (bfd_mach_ppc_403)
3243 #define POWERPC_FLAG_401 (POWERPC_FLAG_CE | POWERPC_FLAG_DE | \
3244 POWERPC_FLAG_BUS_CLK)
3245 #define check_pow_401 check_pow_nocheck
3247 static void init_proc_401 (CPUPPCState
*env
)
3250 gen_spr_401_403(env
);
3252 init_excp_4xx_real(env
);
3253 env
->dcache_line_size
= 32;
3254 env
->icache_line_size
= 32;
3255 /* Allocate hardware IRQ controller */
3256 ppc40x_irq_init(env
);
3258 SET_FIT_PERIOD(12, 16, 20, 24);
3259 SET_WDT_PERIOD(16, 20, 24, 28);
3263 #define POWERPC_INSNS_401x2 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
3264 PPC_DCR | PPC_WRTEE | \
3265 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT | \
3266 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
3267 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
3268 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC | \
3269 PPC_4xx_COMMON | PPC_40x_EXCP)
3270 #define POWERPC_INSNS2_401x2 (PPC_NONE)
3271 #define POWERPC_MSRM_401x2 (0x00000000001FD231ULL)
3272 #define POWERPC_MMU_401x2 (POWERPC_MMU_SOFT_4xx_Z)
3273 #define POWERPC_EXCP_401x2 (POWERPC_EXCP_40x)
3274 #define POWERPC_INPUT_401x2 (PPC_FLAGS_INPUT_401)
3275 #define POWERPC_BFDM_401x2 (bfd_mach_ppc_403)
3276 #define POWERPC_FLAG_401x2 (POWERPC_FLAG_CE | POWERPC_FLAG_DE | \
3277 POWERPC_FLAG_BUS_CLK)
3278 #define check_pow_401x2 check_pow_nocheck
3280 static void init_proc_401x2 (CPUPPCState
*env
)
3283 gen_spr_401_403(env
);
3285 gen_spr_compress(env
);
3286 /* Memory management */
3287 #if !defined(CONFIG_USER_ONLY)
3291 env
->tlb_type
= TLB_EMB
;
3293 init_excp_4xx_softmmu(env
);
3294 env
->dcache_line_size
= 32;
3295 env
->icache_line_size
= 32;
3296 /* Allocate hardware IRQ controller */
3297 ppc40x_irq_init(env
);
3299 SET_FIT_PERIOD(12, 16, 20, 24);
3300 SET_WDT_PERIOD(16, 20, 24, 28);
3304 #define POWERPC_INSNS_401x3 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
3305 PPC_DCR | PPC_WRTEE | \
3306 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT | \
3307 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
3308 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
3309 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC | \
3310 PPC_4xx_COMMON | PPC_40x_EXCP)
3311 #define POWERPC_INSNS2_401x3 (PPC_NONE)
3312 #define POWERPC_MSRM_401x3 (0x00000000001FD631ULL)
3313 #define POWERPC_MMU_401x3 (POWERPC_MMU_SOFT_4xx_Z)
3314 #define POWERPC_EXCP_401x3 (POWERPC_EXCP_40x)
3315 #define POWERPC_INPUT_401x3 (PPC_FLAGS_INPUT_401)
3316 #define POWERPC_BFDM_401x3 (bfd_mach_ppc_403)
3317 #define POWERPC_FLAG_401x3 (POWERPC_FLAG_CE | POWERPC_FLAG_DE | \
3318 POWERPC_FLAG_BUS_CLK)
3319 #define check_pow_401x3 check_pow_nocheck
3321 __attribute__ (( unused
))
3322 static void init_proc_401x3 (CPUPPCState
*env
)
3325 gen_spr_401_403(env
);
3328 gen_spr_compress(env
);
3329 init_excp_4xx_softmmu(env
);
3330 env
->dcache_line_size
= 32;
3331 env
->icache_line_size
= 32;
3332 /* Allocate hardware IRQ controller */
3333 ppc40x_irq_init(env
);
3335 SET_FIT_PERIOD(12, 16, 20, 24);
3336 SET_WDT_PERIOD(16, 20, 24, 28);
3340 #define POWERPC_INSNS_IOP480 (PPC_INSNS_BASE | PPC_STRING | \
3341 PPC_DCR | PPC_WRTEE | \
3342 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT | \
3343 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
3344 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
3345 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC | \
3346 PPC_4xx_COMMON | PPC_40x_EXCP)
3347 #define POWERPC_INSNS2_IOP480 (PPC_NONE)
3348 #define POWERPC_MSRM_IOP480 (0x00000000001FD231ULL)
3349 #define POWERPC_MMU_IOP480 (POWERPC_MMU_SOFT_4xx_Z)
3350 #define POWERPC_EXCP_IOP480 (POWERPC_EXCP_40x)
3351 #define POWERPC_INPUT_IOP480 (PPC_FLAGS_INPUT_401)
3352 #define POWERPC_BFDM_IOP480 (bfd_mach_ppc_403)
3353 #define POWERPC_FLAG_IOP480 (POWERPC_FLAG_CE | POWERPC_FLAG_DE | \
3354 POWERPC_FLAG_BUS_CLK)
3355 #define check_pow_IOP480 check_pow_nocheck
3357 static void init_proc_IOP480 (CPUPPCState
*env
)
3360 gen_spr_401_403(env
);
3362 gen_spr_compress(env
);
3363 /* Memory management */
3364 #if !defined(CONFIG_USER_ONLY)
3368 env
->tlb_type
= TLB_EMB
;
3370 init_excp_4xx_softmmu(env
);
3371 env
->dcache_line_size
= 32;
3372 env
->icache_line_size
= 32;
3373 /* Allocate hardware IRQ controller */
3374 ppc40x_irq_init(env
);
3376 SET_FIT_PERIOD(8, 12, 16, 20);
3377 SET_WDT_PERIOD(16, 20, 24, 28);
3381 #define POWERPC_INSNS_403 (PPC_INSNS_BASE | PPC_STRING | \
3382 PPC_DCR | PPC_WRTEE | \
3383 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT | \
3385 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
3386 PPC_4xx_COMMON | PPC_40x_EXCP)
3387 #define POWERPC_INSNS2_403 (PPC_NONE)
3388 #define POWERPC_MSRM_403 (0x000000000007D00DULL)
3389 #define POWERPC_MMU_403 (POWERPC_MMU_REAL)
3390 #define POWERPC_EXCP_403 (POWERPC_EXCP_40x)
3391 #define POWERPC_INPUT_403 (PPC_FLAGS_INPUT_401)
3392 #define POWERPC_BFDM_403 (bfd_mach_ppc_403)
3393 #define POWERPC_FLAG_403 (POWERPC_FLAG_CE | POWERPC_FLAG_PX | \
3394 POWERPC_FLAG_BUS_CLK)
3395 #define check_pow_403 check_pow_nocheck
3397 static void init_proc_403 (CPUPPCState
*env
)
3400 gen_spr_401_403(env
);
3402 gen_spr_403_real(env
);
3403 init_excp_4xx_real(env
);
3404 env
->dcache_line_size
= 32;
3405 env
->icache_line_size
= 32;
3406 /* Allocate hardware IRQ controller */
3407 ppc40x_irq_init(env
);
3409 SET_FIT_PERIOD(8, 12, 16, 20);
3410 SET_WDT_PERIOD(16, 20, 24, 28);
3413 /* PowerPC 403 GCX */
3414 #define POWERPC_INSNS_403GCX (PPC_INSNS_BASE | PPC_STRING | \
3415 PPC_DCR | PPC_WRTEE | \
3416 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT | \
3418 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
3419 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC | \
3420 PPC_4xx_COMMON | PPC_40x_EXCP)
3421 #define POWERPC_INSNS2_403GCX (PPC_NONE)
3422 #define POWERPC_MSRM_403GCX (0x000000000007D00DULL)
3423 #define POWERPC_MMU_403GCX (POWERPC_MMU_SOFT_4xx_Z)
3424 #define POWERPC_EXCP_403GCX (POWERPC_EXCP_40x)
3425 #define POWERPC_INPUT_403GCX (PPC_FLAGS_INPUT_401)
3426 #define POWERPC_BFDM_403GCX (bfd_mach_ppc_403)
3427 #define POWERPC_FLAG_403GCX (POWERPC_FLAG_CE | POWERPC_FLAG_PX | \
3428 POWERPC_FLAG_BUS_CLK)
3429 #define check_pow_403GCX check_pow_nocheck
3431 static void init_proc_403GCX (CPUPPCState
*env
)
3434 gen_spr_401_403(env
);
3436 gen_spr_403_real(env
);
3437 gen_spr_403_mmu(env
);
3438 /* Bus access control */
3439 /* not emulated, as Qemu never does speculative access */
3440 spr_register(env
, SPR_40x_SGR
, "SGR",
3441 SPR_NOACCESS
, SPR_NOACCESS
,
3442 &spr_read_generic
, &spr_write_generic
,
3444 /* not emulated, as Qemu do not emulate caches */
3445 spr_register(env
, SPR_40x_DCWR
, "DCWR",
3446 SPR_NOACCESS
, SPR_NOACCESS
,
3447 &spr_read_generic
, &spr_write_generic
,
3449 /* Memory management */
3450 #if !defined(CONFIG_USER_ONLY)
3454 env
->tlb_type
= TLB_EMB
;
3456 init_excp_4xx_softmmu(env
);
3457 env
->dcache_line_size
= 32;
3458 env
->icache_line_size
= 32;
3459 /* Allocate hardware IRQ controller */
3460 ppc40x_irq_init(env
);
3462 SET_FIT_PERIOD(8, 12, 16, 20);
3463 SET_WDT_PERIOD(16, 20, 24, 28);
3467 #define POWERPC_INSNS_405 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
3468 PPC_DCR | PPC_WRTEE | \
3469 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT | \
3470 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
3471 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
3472 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC | \
3473 PPC_4xx_COMMON | PPC_405_MAC | PPC_40x_EXCP)
3474 #define POWERPC_INSNS2_405 (PPC_NONE)
3475 #define POWERPC_MSRM_405 (0x000000000006E630ULL)
3476 #define POWERPC_MMU_405 (POWERPC_MMU_SOFT_4xx)
3477 #define POWERPC_EXCP_405 (POWERPC_EXCP_40x)
3478 #define POWERPC_INPUT_405 (PPC_FLAGS_INPUT_405)
3479 #define POWERPC_BFDM_405 (bfd_mach_ppc_403)
3480 #define POWERPC_FLAG_405 (POWERPC_FLAG_CE | POWERPC_FLAG_DWE | \
3481 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
3482 #define check_pow_405 check_pow_nocheck
3484 static void init_proc_405 (CPUPPCState
*env
)
3490 /* Bus access control */
3491 /* not emulated, as Qemu never does speculative access */
3492 spr_register(env
, SPR_40x_SGR
, "SGR",
3493 SPR_NOACCESS
, SPR_NOACCESS
,
3494 &spr_read_generic
, &spr_write_generic
,
3496 /* not emulated, as Qemu do not emulate caches */
3497 spr_register(env
, SPR_40x_DCWR
, "DCWR",
3498 SPR_NOACCESS
, SPR_NOACCESS
,
3499 &spr_read_generic
, &spr_write_generic
,
3501 /* Memory management */
3502 #if !defined(CONFIG_USER_ONLY)
3506 env
->tlb_type
= TLB_EMB
;
3508 init_excp_4xx_softmmu(env
);
3509 env
->dcache_line_size
= 32;
3510 env
->icache_line_size
= 32;
3511 /* Allocate hardware IRQ controller */
3512 ppc40x_irq_init(env
);
3514 SET_FIT_PERIOD(8, 12, 16, 20);
3515 SET_WDT_PERIOD(16, 20, 24, 28);
3518 /* PowerPC 440 EP */
3519 #define POWERPC_INSNS_440EP (PPC_INSNS_BASE | PPC_STRING | \
3520 PPC_FLOAT | PPC_FLOAT_FRES | PPC_FLOAT_FSEL | \
3521 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
3522 PPC_FLOAT_STFIWX | \
3523 PPC_DCR | PPC_WRTEE | PPC_RFMCI | \
3524 PPC_CACHE | PPC_CACHE_ICBI | \
3525 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
3526 PPC_MEM_TLBSYNC | PPC_MFTB | \
3527 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC | \
3529 #define POWERPC_INSNS2_440EP (PPC_NONE)
3530 #define POWERPC_MSRM_440EP (0x000000000006FF30ULL)
3531 #define POWERPC_MMU_440EP (POWERPC_MMU_BOOKE)
3532 #define POWERPC_EXCP_440EP (POWERPC_EXCP_BOOKE)
3533 #define POWERPC_INPUT_440EP (PPC_FLAGS_INPUT_BookE)
3534 #define POWERPC_BFDM_440EP (bfd_mach_ppc_403)
3535 #define POWERPC_FLAG_440EP (POWERPC_FLAG_CE | POWERPC_FLAG_DWE | \
3536 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
3537 #define check_pow_440EP check_pow_nocheck
3539 static void init_proc_440EP (CPUPPCState
*env
)
3543 gen_spr_BookE(env
, 0x000000000000FFFFULL
);
3545 gen_spr_usprgh(env
);
3546 /* Processor identification */
3547 spr_register(env
, SPR_BOOKE_PIR
, "PIR",
3548 SPR_NOACCESS
, SPR_NOACCESS
,
3549 &spr_read_generic
, &spr_write_pir
,
3551 /* XXX : not implemented */
3552 spr_register(env
, SPR_BOOKE_IAC3
, "IAC3",
3553 SPR_NOACCESS
, SPR_NOACCESS
,
3554 &spr_read_generic
, &spr_write_generic
,
3556 /* XXX : not implemented */
3557 spr_register(env
, SPR_BOOKE_IAC4
, "IAC4",
3558 SPR_NOACCESS
, SPR_NOACCESS
,
3559 &spr_read_generic
, &spr_write_generic
,
3561 /* XXX : not implemented */
3562 spr_register(env
, SPR_BOOKE_DVC1
, "DVC1",
3563 SPR_NOACCESS
, SPR_NOACCESS
,
3564 &spr_read_generic
, &spr_write_generic
,
3566 /* XXX : not implemented */
3567 spr_register(env
, SPR_BOOKE_DVC2
, "DVC2",
3568 SPR_NOACCESS
, SPR_NOACCESS
,
3569 &spr_read_generic
, &spr_write_generic
,
3571 /* XXX : not implemented */
3572 spr_register(env
, SPR_BOOKE_MCSR
, "MCSR",
3573 SPR_NOACCESS
, SPR_NOACCESS
,
3574 &spr_read_generic
, &spr_write_generic
,
3576 spr_register(env
, SPR_BOOKE_MCSRR0
, "MCSRR0",
3577 SPR_NOACCESS
, SPR_NOACCESS
,
3578 &spr_read_generic
, &spr_write_generic
,
3580 spr_register(env
, SPR_BOOKE_MCSRR1
, "MCSRR1",
3581 SPR_NOACCESS
, SPR_NOACCESS
,
3582 &spr_read_generic
, &spr_write_generic
,
3584 /* XXX : not implemented */
3585 spr_register(env
, SPR_440_CCR1
, "CCR1",
3586 SPR_NOACCESS
, SPR_NOACCESS
,
3587 &spr_read_generic
, &spr_write_generic
,
3589 /* Memory management */
3590 #if !defined(CONFIG_USER_ONLY)
3594 env
->tlb_type
= TLB_EMB
;
3596 init_excp_BookE(env
);
3597 env
->dcache_line_size
= 32;
3598 env
->icache_line_size
= 32;
3599 ppc40x_irq_init(env
);
3601 SET_FIT_PERIOD(12, 16, 20, 24);
3602 SET_WDT_PERIOD(20, 24, 28, 32);
3605 /* PowerPC 440 GP */
3606 #define POWERPC_INSNS_440GP (PPC_INSNS_BASE | PPC_STRING | \
3607 PPC_DCR | PPC_DCRX | PPC_WRTEE | PPC_MFAPIDI | \
3608 PPC_CACHE | PPC_CACHE_ICBI | \
3609 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
3610 PPC_MEM_TLBSYNC | PPC_TLBIVA | PPC_MFTB | \
3611 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC | \
3613 #define POWERPC_INSNS2_440GP (PPC_NONE)
3614 #define POWERPC_MSRM_440GP (0x000000000006FF30ULL)
3615 #define POWERPC_MMU_440GP (POWERPC_MMU_BOOKE)
3616 #define POWERPC_EXCP_440GP (POWERPC_EXCP_BOOKE)
3617 #define POWERPC_INPUT_440GP (PPC_FLAGS_INPUT_BookE)
3618 #define POWERPC_BFDM_440GP (bfd_mach_ppc_403)
3619 #define POWERPC_FLAG_440GP (POWERPC_FLAG_CE | POWERPC_FLAG_DWE | \
3620 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
3621 #define check_pow_440GP check_pow_nocheck
3623 __attribute__ (( unused
))
3624 static void init_proc_440GP (CPUPPCState
*env
)
3628 gen_spr_BookE(env
, 0x000000000000FFFFULL
);
3630 gen_spr_usprgh(env
);
3631 /* Processor identification */
3632 spr_register(env
, SPR_BOOKE_PIR
, "PIR",
3633 SPR_NOACCESS
, SPR_NOACCESS
,
3634 &spr_read_generic
, &spr_write_pir
,
3636 /* XXX : not implemented */
3637 spr_register(env
, SPR_BOOKE_IAC3
, "IAC3",
3638 SPR_NOACCESS
, SPR_NOACCESS
,
3639 &spr_read_generic
, &spr_write_generic
,
3641 /* XXX : not implemented */
3642 spr_register(env
, SPR_BOOKE_IAC4
, "IAC4",
3643 SPR_NOACCESS
, SPR_NOACCESS
,
3644 &spr_read_generic
, &spr_write_generic
,
3646 /* XXX : not implemented */
3647 spr_register(env
, SPR_BOOKE_DVC1
, "DVC1",
3648 SPR_NOACCESS
, SPR_NOACCESS
,
3649 &spr_read_generic
, &spr_write_generic
,
3651 /* XXX : not implemented */
3652 spr_register(env
, SPR_BOOKE_DVC2
, "DVC2",
3653 SPR_NOACCESS
, SPR_NOACCESS
,
3654 &spr_read_generic
, &spr_write_generic
,
3656 /* Memory management */
3657 #if !defined(CONFIG_USER_ONLY)
3661 env
->tlb_type
= TLB_EMB
;
3663 init_excp_BookE(env
);
3664 env
->dcache_line_size
= 32;
3665 env
->icache_line_size
= 32;
3666 /* XXX: TODO: allocate internal IRQ controller */
3668 SET_FIT_PERIOD(12, 16, 20, 24);
3669 SET_WDT_PERIOD(20, 24, 28, 32);
3673 #define POWERPC_INSNS_440x4 (PPC_INSNS_BASE | PPC_STRING | \
3674 PPC_DCR | PPC_WRTEE | \
3675 PPC_CACHE | PPC_CACHE_ICBI | \
3676 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
3677 PPC_MEM_TLBSYNC | PPC_MFTB | \
3678 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC | \
3680 #define POWERPC_INSNS2_440x4 (PPC_NONE)
3681 #define POWERPC_MSRM_440x4 (0x000000000006FF30ULL)
3682 #define POWERPC_MMU_440x4 (POWERPC_MMU_BOOKE)
3683 #define POWERPC_EXCP_440x4 (POWERPC_EXCP_BOOKE)
3684 #define POWERPC_INPUT_440x4 (PPC_FLAGS_INPUT_BookE)
3685 #define POWERPC_BFDM_440x4 (bfd_mach_ppc_403)
3686 #define POWERPC_FLAG_440x4 (POWERPC_FLAG_CE | POWERPC_FLAG_DWE | \
3687 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
3688 #define check_pow_440x4 check_pow_nocheck
3690 __attribute__ (( unused
))
3691 static void init_proc_440x4 (CPUPPCState
*env
)
3695 gen_spr_BookE(env
, 0x000000000000FFFFULL
);
3697 gen_spr_usprgh(env
);
3698 /* Processor identification */
3699 spr_register(env
, SPR_BOOKE_PIR
, "PIR",
3700 SPR_NOACCESS
, SPR_NOACCESS
,
3701 &spr_read_generic
, &spr_write_pir
,
3703 /* XXX : not implemented */
3704 spr_register(env
, SPR_BOOKE_IAC3
, "IAC3",
3705 SPR_NOACCESS
, SPR_NOACCESS
,
3706 &spr_read_generic
, &spr_write_generic
,
3708 /* XXX : not implemented */
3709 spr_register(env
, SPR_BOOKE_IAC4
, "IAC4",
3710 SPR_NOACCESS
, SPR_NOACCESS
,
3711 &spr_read_generic
, &spr_write_generic
,
3713 /* XXX : not implemented */
3714 spr_register(env
, SPR_BOOKE_DVC1
, "DVC1",
3715 SPR_NOACCESS
, SPR_NOACCESS
,
3716 &spr_read_generic
, &spr_write_generic
,
3718 /* XXX : not implemented */
3719 spr_register(env
, SPR_BOOKE_DVC2
, "DVC2",
3720 SPR_NOACCESS
, SPR_NOACCESS
,
3721 &spr_read_generic
, &spr_write_generic
,
3723 /* Memory management */
3724 #if !defined(CONFIG_USER_ONLY)
3728 env
->tlb_type
= TLB_EMB
;
3730 init_excp_BookE(env
);
3731 env
->dcache_line_size
= 32;
3732 env
->icache_line_size
= 32;
3733 /* XXX: TODO: allocate internal IRQ controller */
3735 SET_FIT_PERIOD(12, 16, 20, 24);
3736 SET_WDT_PERIOD(20, 24, 28, 32);
3740 #define POWERPC_INSNS_440x5 (PPC_INSNS_BASE | PPC_STRING | \
3741 PPC_DCR | PPC_WRTEE | PPC_RFMCI | \
3742 PPC_CACHE | PPC_CACHE_ICBI | \
3743 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
3744 PPC_MEM_TLBSYNC | PPC_MFTB | \
3745 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC | \
3747 #define POWERPC_INSNS2_440x5 (PPC_NONE)
3748 #define POWERPC_MSRM_440x5 (0x000000000006FF30ULL)
3749 #define POWERPC_MMU_440x5 (POWERPC_MMU_BOOKE)
3750 #define POWERPC_EXCP_440x5 (POWERPC_EXCP_BOOKE)
3751 #define POWERPC_INPUT_440x5 (PPC_FLAGS_INPUT_BookE)
3752 #define POWERPC_BFDM_440x5 (bfd_mach_ppc_403)
3753 #define POWERPC_FLAG_440x5 (POWERPC_FLAG_CE | POWERPC_FLAG_DWE | \
3754 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
3755 #define check_pow_440x5 check_pow_nocheck
3757 static void init_proc_440x5 (CPUPPCState
*env
)
3761 gen_spr_BookE(env
, 0x000000000000FFFFULL
);
3763 gen_spr_usprgh(env
);
3764 /* Processor identification */
3765 spr_register(env
, SPR_BOOKE_PIR
, "PIR",
3766 SPR_NOACCESS
, SPR_NOACCESS
,
3767 &spr_read_generic
, &spr_write_pir
,
3769 /* XXX : not implemented */
3770 spr_register(env
, SPR_BOOKE_IAC3
, "IAC3",
3771 SPR_NOACCESS
, SPR_NOACCESS
,
3772 &spr_read_generic
, &spr_write_generic
,
3774 /* XXX : not implemented */
3775 spr_register(env
, SPR_BOOKE_IAC4
, "IAC4",
3776 SPR_NOACCESS
, SPR_NOACCESS
,
3777 &spr_read_generic
, &spr_write_generic
,
3779 /* XXX : not implemented */
3780 spr_register(env
, SPR_BOOKE_DVC1
, "DVC1",
3781 SPR_NOACCESS
, SPR_NOACCESS
,
3782 &spr_read_generic
, &spr_write_generic
,
3784 /* XXX : not implemented */
3785 spr_register(env
, SPR_BOOKE_DVC2
, "DVC2",
3786 SPR_NOACCESS
, SPR_NOACCESS
,
3787 &spr_read_generic
, &spr_write_generic
,
3789 /* XXX : not implemented */
3790 spr_register(env
, SPR_BOOKE_MCSR
, "MCSR",
3791 SPR_NOACCESS
, SPR_NOACCESS
,
3792 &spr_read_generic
, &spr_write_generic
,
3794 spr_register(env
, SPR_BOOKE_MCSRR0
, "MCSRR0",
3795 SPR_NOACCESS
, SPR_NOACCESS
,
3796 &spr_read_generic
, &spr_write_generic
,
3798 spr_register(env
, SPR_BOOKE_MCSRR1
, "MCSRR1",
3799 SPR_NOACCESS
, SPR_NOACCESS
,
3800 &spr_read_generic
, &spr_write_generic
,
3802 /* XXX : not implemented */
3803 spr_register(env
, SPR_440_CCR1
, "CCR1",
3804 SPR_NOACCESS
, SPR_NOACCESS
,
3805 &spr_read_generic
, &spr_write_generic
,
3807 /* Memory management */
3808 #if !defined(CONFIG_USER_ONLY)
3812 env
->tlb_type
= TLB_EMB
;
3814 init_excp_BookE(env
);
3815 env
->dcache_line_size
= 32;
3816 env
->icache_line_size
= 32;
3817 ppc40x_irq_init(env
);
3819 SET_FIT_PERIOD(12, 16, 20, 24);
3820 SET_WDT_PERIOD(20, 24, 28, 32);
3823 /* PowerPC 460 (guessed) */
3824 #define POWERPC_INSNS_460 (PPC_INSNS_BASE | PPC_STRING | \
3825 PPC_DCR | PPC_DCRX | PPC_DCRUX | \
3826 PPC_WRTEE | PPC_MFAPIDI | PPC_MFTB | \
3827 PPC_CACHE | PPC_CACHE_ICBI | \
3828 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
3829 PPC_MEM_TLBSYNC | PPC_TLBIVA | \
3830 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC | \
3832 #define POWERPC_INSNS2_460 (PPC_NONE)
3833 #define POWERPC_MSRM_460 (0x000000000006FF30ULL)
3834 #define POWERPC_MMU_460 (POWERPC_MMU_BOOKE)
3835 #define POWERPC_EXCP_460 (POWERPC_EXCP_BOOKE)
3836 #define POWERPC_INPUT_460 (PPC_FLAGS_INPUT_BookE)
3837 #define POWERPC_BFDM_460 (bfd_mach_ppc_403)
3838 #define POWERPC_FLAG_460 (POWERPC_FLAG_CE | POWERPC_FLAG_DWE | \
3839 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
3840 #define check_pow_460 check_pow_nocheck
3842 __attribute__ (( unused
))
3843 static void init_proc_460 (CPUPPCState
*env
)
3847 gen_spr_BookE(env
, 0x000000000000FFFFULL
);
3849 gen_spr_usprgh(env
);
3850 /* Processor identification */
3851 spr_register(env
, SPR_BOOKE_PIR
, "PIR",
3852 SPR_NOACCESS
, SPR_NOACCESS
,
3853 &spr_read_generic
, &spr_write_pir
,
3855 /* XXX : not implemented */
3856 spr_register(env
, SPR_BOOKE_IAC3
, "IAC3",
3857 SPR_NOACCESS
, SPR_NOACCESS
,
3858 &spr_read_generic
, &spr_write_generic
,
3860 /* XXX : not implemented */
3861 spr_register(env
, SPR_BOOKE_IAC4
, "IAC4",
3862 SPR_NOACCESS
, SPR_NOACCESS
,
3863 &spr_read_generic
, &spr_write_generic
,
3865 /* XXX : not implemented */
3866 spr_register(env
, SPR_BOOKE_DVC1
, "DVC1",
3867 SPR_NOACCESS
, SPR_NOACCESS
,
3868 &spr_read_generic
, &spr_write_generic
,
3870 /* XXX : not implemented */
3871 spr_register(env
, SPR_BOOKE_DVC2
, "DVC2",
3872 SPR_NOACCESS
, SPR_NOACCESS
,
3873 &spr_read_generic
, &spr_write_generic
,
3875 /* XXX : not implemented */
3876 spr_register(env
, SPR_BOOKE_MCSR
, "MCSR",
3877 SPR_NOACCESS
, SPR_NOACCESS
,
3878 &spr_read_generic
, &spr_write_generic
,
3880 spr_register(env
, SPR_BOOKE_MCSRR0
, "MCSRR0",
3881 SPR_NOACCESS
, SPR_NOACCESS
,
3882 &spr_read_generic
, &spr_write_generic
,
3884 spr_register(env
, SPR_BOOKE_MCSRR1
, "MCSRR1",
3885 SPR_NOACCESS
, SPR_NOACCESS
,
3886 &spr_read_generic
, &spr_write_generic
,
3888 /* XXX : not implemented */
3889 spr_register(env
, SPR_440_CCR1
, "CCR1",
3890 SPR_NOACCESS
, SPR_NOACCESS
,
3891 &spr_read_generic
, &spr_write_generic
,
3893 /* XXX : not implemented */
3894 spr_register(env
, SPR_DCRIPR
, "SPR_DCRIPR",
3895 &spr_read_generic
, &spr_write_generic
,
3896 &spr_read_generic
, &spr_write_generic
,
3898 /* Memory management */
3899 #if !defined(CONFIG_USER_ONLY)
3903 env
->tlb_type
= TLB_EMB
;
3905 init_excp_BookE(env
);
3906 env
->dcache_line_size
= 32;
3907 env
->icache_line_size
= 32;
3908 /* XXX: TODO: allocate internal IRQ controller */
3910 SET_FIT_PERIOD(12, 16, 20, 24);
3911 SET_WDT_PERIOD(20, 24, 28, 32);
3914 /* PowerPC 460F (guessed) */
3915 #define POWERPC_INSNS_460F (PPC_INSNS_BASE | PPC_STRING | \
3916 PPC_FLOAT | PPC_FLOAT_FRES | PPC_FLOAT_FSEL | \
3917 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
3918 PPC_FLOAT_STFIWX | PPC_MFTB | \
3919 PPC_DCR | PPC_DCRX | PPC_DCRUX | \
3920 PPC_WRTEE | PPC_MFAPIDI | \
3921 PPC_CACHE | PPC_CACHE_ICBI | \
3922 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
3923 PPC_MEM_TLBSYNC | PPC_TLBIVA | \
3924 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC | \
3926 #define POWERPC_INSNS2_460F (PPC_NONE)
3927 #define POWERPC_MSRM_460 (0x000000000006FF30ULL)
3928 #define POWERPC_MMU_460F (POWERPC_MMU_BOOKE)
3929 #define POWERPC_EXCP_460F (POWERPC_EXCP_BOOKE)
3930 #define POWERPC_INPUT_460F (PPC_FLAGS_INPUT_BookE)
3931 #define POWERPC_BFDM_460F (bfd_mach_ppc_403)
3932 #define POWERPC_FLAG_460F (POWERPC_FLAG_CE | POWERPC_FLAG_DWE | \
3933 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK)
3934 #define check_pow_460F check_pow_nocheck
3936 __attribute__ (( unused
))
3937 static void init_proc_460F (CPUPPCState
*env
)
3941 gen_spr_BookE(env
, 0x000000000000FFFFULL
);
3943 gen_spr_usprgh(env
);
3944 /* Processor identification */
3945 spr_register(env
, SPR_BOOKE_PIR
, "PIR",
3946 SPR_NOACCESS
, SPR_NOACCESS
,
3947 &spr_read_generic
, &spr_write_pir
,
3949 /* XXX : not implemented */
3950 spr_register(env
, SPR_BOOKE_IAC3
, "IAC3",
3951 SPR_NOACCESS
, SPR_NOACCESS
,
3952 &spr_read_generic
, &spr_write_generic
,
3954 /* XXX : not implemented */
3955 spr_register(env
, SPR_BOOKE_IAC4
, "IAC4",
3956 SPR_NOACCESS
, SPR_NOACCESS
,
3957 &spr_read_generic
, &spr_write_generic
,
3959 /* XXX : not implemented */
3960 spr_register(env
, SPR_BOOKE_DVC1
, "DVC1",
3961 SPR_NOACCESS
, SPR_NOACCESS
,
3962 &spr_read_generic
, &spr_write_generic
,
3964 /* XXX : not implemented */
3965 spr_register(env
, SPR_BOOKE_DVC2
, "DVC2",
3966 SPR_NOACCESS
, SPR_NOACCESS
,
3967 &spr_read_generic
, &spr_write_generic
,
3969 /* XXX : not implemented */
3970 spr_register(env
, SPR_BOOKE_MCSR
, "MCSR",
3971 SPR_NOACCESS
, SPR_NOACCESS
,
3972 &spr_read_generic
, &spr_write_generic
,
3974 spr_register(env
, SPR_BOOKE_MCSRR0
, "MCSRR0",
3975 SPR_NOACCESS
, SPR_NOACCESS
,
3976 &spr_read_generic
, &spr_write_generic
,
3978 spr_register(env
, SPR_BOOKE_MCSRR1
, "MCSRR1",
3979 SPR_NOACCESS
, SPR_NOACCESS
,
3980 &spr_read_generic
, &spr_write_generic
,
3982 /* XXX : not implemented */
3983 spr_register(env
, SPR_440_CCR1
, "CCR1",
3984 SPR_NOACCESS
, SPR_NOACCESS
,
3985 &spr_read_generic
, &spr_write_generic
,
3987 /* XXX : not implemented */
3988 spr_register(env
, SPR_DCRIPR
, "SPR_DCRIPR",
3989 &spr_read_generic
, &spr_write_generic
,
3990 &spr_read_generic
, &spr_write_generic
,
3992 /* Memory management */
3993 #if !defined(CONFIG_USER_ONLY)
3997 env
->tlb_type
= TLB_EMB
;
3999 init_excp_BookE(env
);
4000 env
->dcache_line_size
= 32;
4001 env
->icache_line_size
= 32;
4002 /* XXX: TODO: allocate internal IRQ controller */
4004 SET_FIT_PERIOD(12, 16, 20, 24);
4005 SET_WDT_PERIOD(20, 24, 28, 32);
4008 /* Freescale 5xx cores (aka RCPU) */
4009 #define POWERPC_INSNS_MPC5xx (PPC_INSNS_BASE | PPC_STRING | \
4010 PPC_MEM_EIEIO | PPC_MEM_SYNC | \
4011 PPC_CACHE_ICBI | PPC_FLOAT | PPC_FLOAT_STFIWX | \
4013 #define POWERPC_INSNS2_MPC5xx (PPC_NONE)
4014 #define POWERPC_MSRM_MPC5xx (0x000000000001FF43ULL)
4015 #define POWERPC_MMU_MPC5xx (POWERPC_MMU_REAL)
4016 #define POWERPC_EXCP_MPC5xx (POWERPC_EXCP_603)
4017 #define POWERPC_INPUT_MPC5xx (PPC_FLAGS_INPUT_RCPU)
4018 #define POWERPC_BFDM_MPC5xx (bfd_mach_ppc_505)
4019 #define POWERPC_FLAG_MPC5xx (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
4020 POWERPC_FLAG_BUS_CLK)
4021 #define check_pow_MPC5xx check_pow_none
4023 __attribute__ (( unused
))
4024 static void init_proc_MPC5xx (CPUPPCState
*env
)
4028 gen_spr_5xx_8xx(env
);
4030 init_excp_MPC5xx(env
);
4031 env
->dcache_line_size
= 32;
4032 env
->icache_line_size
= 32;
4033 /* XXX: TODO: allocate internal IRQ controller */
4036 /* Freescale 8xx cores (aka PowerQUICC) */
4037 #define POWERPC_INSNS_MPC8xx (PPC_INSNS_BASE | PPC_STRING | \
4038 PPC_MEM_EIEIO | PPC_MEM_SYNC | \
4039 PPC_CACHE_ICBI | PPC_MFTB)
4040 #define POWERPC_INSNS2_MPC8xx (PPC_NONE)
4041 #define POWERPC_MSRM_MPC8xx (0x000000000001F673ULL)
4042 #define POWERPC_MMU_MPC8xx (POWERPC_MMU_MPC8xx)
4043 #define POWERPC_EXCP_MPC8xx (POWERPC_EXCP_603)
4044 #define POWERPC_INPUT_MPC8xx (PPC_FLAGS_INPUT_RCPU)
4045 #define POWERPC_BFDM_MPC8xx (bfd_mach_ppc_860)
4046 #define POWERPC_FLAG_MPC8xx (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
4047 POWERPC_FLAG_BUS_CLK)
4048 #define check_pow_MPC8xx check_pow_none
4050 __attribute__ (( unused
))
4051 static void init_proc_MPC8xx (CPUPPCState
*env
)
4055 gen_spr_5xx_8xx(env
);
4057 init_excp_MPC8xx(env
);
4058 env
->dcache_line_size
= 32;
4059 env
->icache_line_size
= 32;
4060 /* XXX: TODO: allocate internal IRQ controller */
4063 /* Freescale 82xx cores (aka PowerQUICC-II) */
4065 #define POWERPC_INSNS_G2 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
4066 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
4067 PPC_FLOAT_STFIWX | \
4068 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4069 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
4070 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
4071 PPC_SEGMENT | PPC_EXTERN)
4072 #define POWERPC_INSNS2_G2 (PPC_NONE)
4073 #define POWERPC_MSRM_G2 (0x000000000006FFF2ULL)
4074 #define POWERPC_MMU_G2 (POWERPC_MMU_SOFT_6xx)
4075 //#define POWERPC_EXCP_G2 (POWERPC_EXCP_G2)
4076 #define POWERPC_INPUT_G2 (PPC_FLAGS_INPUT_6xx)
4077 #define POWERPC_BFDM_G2 (bfd_mach_ppc_ec603e)
4078 #define POWERPC_FLAG_G2 (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE | \
4079 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
4080 #define check_pow_G2 check_pow_hid0
4082 static void init_proc_G2 (CPUPPCState
*env
)
4084 gen_spr_ne_601(env
);
4085 gen_spr_G2_755(env
);
4089 /* External access control */
4090 /* XXX : not implemented */
4091 spr_register(env
, SPR_EAR
, "EAR",
4092 SPR_NOACCESS
, SPR_NOACCESS
,
4093 &spr_read_generic
, &spr_write_generic
,
4095 /* Hardware implementation register */
4096 /* XXX : not implemented */
4097 spr_register(env
, SPR_HID0
, "HID0",
4098 SPR_NOACCESS
, SPR_NOACCESS
,
4099 &spr_read_generic
, &spr_write_generic
,
4101 /* XXX : not implemented */
4102 spr_register(env
, SPR_HID1
, "HID1",
4103 SPR_NOACCESS
, SPR_NOACCESS
,
4104 &spr_read_generic
, &spr_write_generic
,
4106 /* XXX : not implemented */
4107 spr_register(env
, SPR_HID2
, "HID2",
4108 SPR_NOACCESS
, SPR_NOACCESS
,
4109 &spr_read_generic
, &spr_write_generic
,
4111 /* Memory management */
4114 gen_6xx_7xx_soft_tlb(env
, 64, 2);
4116 env
->dcache_line_size
= 32;
4117 env
->icache_line_size
= 32;
4118 /* Allocate hardware IRQ controller */
4119 ppc6xx_irq_init(env
);
4123 #define POWERPC_INSNS_G2LE (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
4124 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
4125 PPC_FLOAT_STFIWX | \
4126 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4127 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
4128 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
4129 PPC_SEGMENT | PPC_EXTERN)
4130 #define POWERPC_INSNS2_G2LE (PPC_NONE)
4131 #define POWERPC_MSRM_G2LE (0x000000000007FFF3ULL)
4132 #define POWERPC_MMU_G2LE (POWERPC_MMU_SOFT_6xx)
4133 #define POWERPC_EXCP_G2LE (POWERPC_EXCP_G2)
4134 #define POWERPC_INPUT_G2LE (PPC_FLAGS_INPUT_6xx)
4135 #define POWERPC_BFDM_G2LE (bfd_mach_ppc_ec603e)
4136 #define POWERPC_FLAG_G2LE (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE | \
4137 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
4138 #define check_pow_G2LE check_pow_hid0
4140 static void init_proc_G2LE (CPUPPCState
*env
)
4142 gen_spr_ne_601(env
);
4143 gen_spr_G2_755(env
);
4147 /* External access control */
4148 /* XXX : not implemented */
4149 spr_register(env
, SPR_EAR
, "EAR",
4150 SPR_NOACCESS
, SPR_NOACCESS
,
4151 &spr_read_generic
, &spr_write_generic
,
4153 /* Hardware implementation register */
4154 /* XXX : not implemented */
4155 spr_register(env
, SPR_HID0
, "HID0",
4156 SPR_NOACCESS
, SPR_NOACCESS
,
4157 &spr_read_generic
, &spr_write_generic
,
4159 /* XXX : not implemented */
4160 spr_register(env
, SPR_HID1
, "HID1",
4161 SPR_NOACCESS
, SPR_NOACCESS
,
4162 &spr_read_generic
, &spr_write_generic
,
4164 /* XXX : not implemented */
4165 spr_register(env
, SPR_HID2
, "HID2",
4166 SPR_NOACCESS
, SPR_NOACCESS
,
4167 &spr_read_generic
, &spr_write_generic
,
4169 /* Memory management */
4172 gen_6xx_7xx_soft_tlb(env
, 64, 2);
4174 env
->dcache_line_size
= 32;
4175 env
->icache_line_size
= 32;
4176 /* Allocate hardware IRQ controller */
4177 ppc6xx_irq_init(env
);
4181 /* XXX: unimplemented instructions:
4188 * all SPE multiply-accumulate instructions
4190 #define POWERPC_INSNS_e200 (PPC_INSNS_BASE | PPC_ISEL | \
4191 PPC_SPE | PPC_SPE_SINGLE | \
4192 PPC_WRTEE | PPC_RFDI | \
4193 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI | \
4194 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
4195 PPC_MEM_TLBSYNC | PPC_TLBIVAX | \
4197 #define POWERPC_INSNS2_e200 (PPC_NONE)
4198 #define POWERPC_MSRM_e200 (0x000000000606FF30ULL)
4199 #define POWERPC_MMU_e200 (POWERPC_MMU_BOOKE206)
4200 #define POWERPC_EXCP_e200 (POWERPC_EXCP_BOOKE)
4201 #define POWERPC_INPUT_e200 (PPC_FLAGS_INPUT_BookE)
4202 #define POWERPC_BFDM_e200 (bfd_mach_ppc_860)
4203 #define POWERPC_FLAG_e200 (POWERPC_FLAG_SPE | POWERPC_FLAG_CE | \
4204 POWERPC_FLAG_UBLE | POWERPC_FLAG_DE | \
4205 POWERPC_FLAG_BUS_CLK)
4206 #define check_pow_e200 check_pow_hid0
4208 __attribute__ (( unused
))
4209 static void init_proc_e200 (CPUPPCState
*env
)
4213 gen_spr_BookE(env
, 0x000000070000FFFFULL
);
4214 /* XXX : not implemented */
4215 spr_register(env
, SPR_BOOKE_SPEFSCR
, "SPEFSCR",
4216 &spr_read_spefscr
, &spr_write_spefscr
,
4217 &spr_read_spefscr
, &spr_write_spefscr
,
4219 /* Memory management */
4220 gen_spr_BookE206(env
, 0x0000005D, NULL
);
4221 /* XXX : not implemented */
4222 spr_register(env
, SPR_HID0
, "HID0",
4223 SPR_NOACCESS
, SPR_NOACCESS
,
4224 &spr_read_generic
, &spr_write_generic
,
4226 /* XXX : not implemented */
4227 spr_register(env
, SPR_HID1
, "HID1",
4228 SPR_NOACCESS
, SPR_NOACCESS
,
4229 &spr_read_generic
, &spr_write_generic
,
4231 /* XXX : not implemented */
4232 spr_register(env
, SPR_Exxx_ALTCTXCR
, "ALTCTXCR",
4233 SPR_NOACCESS
, SPR_NOACCESS
,
4234 &spr_read_generic
, &spr_write_generic
,
4236 /* XXX : not implemented */
4237 spr_register(env
, SPR_Exxx_BUCSR
, "BUCSR",
4238 SPR_NOACCESS
, SPR_NOACCESS
,
4239 &spr_read_generic
, &spr_write_generic
,
4241 /* XXX : not implemented */
4242 spr_register(env
, SPR_Exxx_CTXCR
, "CTXCR",
4243 SPR_NOACCESS
, SPR_NOACCESS
,
4244 &spr_read_generic
, &spr_write_generic
,
4246 /* XXX : not implemented */
4247 spr_register(env
, SPR_Exxx_DBCNT
, "DBCNT",
4248 SPR_NOACCESS
, SPR_NOACCESS
,
4249 &spr_read_generic
, &spr_write_generic
,
4251 /* XXX : not implemented */
4252 spr_register(env
, SPR_Exxx_DBCR3
, "DBCR3",
4253 SPR_NOACCESS
, SPR_NOACCESS
,
4254 &spr_read_generic
, &spr_write_generic
,
4256 /* XXX : not implemented */
4257 spr_register(env
, SPR_Exxx_L1CFG0
, "L1CFG0",
4258 SPR_NOACCESS
, SPR_NOACCESS
,
4259 &spr_read_generic
, &spr_write_generic
,
4261 /* XXX : not implemented */
4262 spr_register(env
, SPR_Exxx_L1CSR0
, "L1CSR0",
4263 SPR_NOACCESS
, SPR_NOACCESS
,
4264 &spr_read_generic
, &spr_write_generic
,
4266 /* XXX : not implemented */
4267 spr_register(env
, SPR_Exxx_L1FINV0
, "L1FINV0",
4268 SPR_NOACCESS
, SPR_NOACCESS
,
4269 &spr_read_generic
, &spr_write_generic
,
4271 /* XXX : not implemented */
4272 spr_register(env
, SPR_BOOKE_TLB0CFG
, "TLB0CFG",
4273 SPR_NOACCESS
, SPR_NOACCESS
,
4274 &spr_read_generic
, &spr_write_generic
,
4276 /* XXX : not implemented */
4277 spr_register(env
, SPR_BOOKE_TLB1CFG
, "TLB1CFG",
4278 SPR_NOACCESS
, SPR_NOACCESS
,
4279 &spr_read_generic
, &spr_write_generic
,
4281 /* XXX : not implemented */
4282 spr_register(env
, SPR_BOOKE_IAC3
, "IAC3",
4283 SPR_NOACCESS
, SPR_NOACCESS
,
4284 &spr_read_generic
, &spr_write_generic
,
4286 /* XXX : not implemented */
4287 spr_register(env
, SPR_BOOKE_IAC4
, "IAC4",
4288 SPR_NOACCESS
, SPR_NOACCESS
,
4289 &spr_read_generic
, &spr_write_generic
,
4291 /* XXX : not implemented */
4292 spr_register(env
, SPR_MMUCSR0
, "MMUCSR0",
4293 SPR_NOACCESS
, SPR_NOACCESS
,
4294 &spr_read_generic
, &spr_write_generic
,
4295 0x00000000); /* TOFIX */
4296 spr_register(env
, SPR_BOOKE_DSRR0
, "DSRR0",
4297 SPR_NOACCESS
, SPR_NOACCESS
,
4298 &spr_read_generic
, &spr_write_generic
,
4300 spr_register(env
, SPR_BOOKE_DSRR1
, "DSRR1",
4301 SPR_NOACCESS
, SPR_NOACCESS
,
4302 &spr_read_generic
, &spr_write_generic
,
4304 #if !defined(CONFIG_USER_ONLY)
4308 env
->tlb_type
= TLB_EMB
;
4310 init_excp_e200(env
);
4311 env
->dcache_line_size
= 32;
4312 env
->icache_line_size
= 32;
4313 /* XXX: TODO: allocate internal IRQ controller */
4317 #define POWERPC_INSNS_e300 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
4318 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
4319 PPC_FLOAT_STFIWX | \
4320 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4321 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
4322 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
4323 PPC_SEGMENT | PPC_EXTERN)
4324 #define POWERPC_INSNS2_e300 (PPC_NONE)
4325 #define POWERPC_MSRM_e300 (0x000000000007FFF3ULL)
4326 #define POWERPC_MMU_e300 (POWERPC_MMU_SOFT_6xx)
4327 #define POWERPC_EXCP_e300 (POWERPC_EXCP_603)
4328 #define POWERPC_INPUT_e300 (PPC_FLAGS_INPUT_6xx)
4329 #define POWERPC_BFDM_e300 (bfd_mach_ppc_603)
4330 #define POWERPC_FLAG_e300 (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE | \
4331 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
4332 #define check_pow_e300 check_pow_hid0
4334 __attribute__ (( unused
))
4335 static void init_proc_e300 (CPUPPCState
*env
)
4337 gen_spr_ne_601(env
);
4341 /* hardware implementation registers */
4342 /* XXX : not implemented */
4343 spr_register(env
, SPR_HID0
, "HID0",
4344 SPR_NOACCESS
, SPR_NOACCESS
,
4345 &spr_read_generic
, &spr_write_generic
,
4347 /* XXX : not implemented */
4348 spr_register(env
, SPR_HID1
, "HID1",
4349 SPR_NOACCESS
, SPR_NOACCESS
,
4350 &spr_read_generic
, &spr_write_generic
,
4352 /* XXX : not implemented */
4353 spr_register(env
, SPR_HID2
, "HID2",
4354 SPR_NOACCESS
, SPR_NOACCESS
,
4355 &spr_read_generic
, &spr_write_generic
,
4357 /* Memory management */
4360 gen_6xx_7xx_soft_tlb(env
, 64, 2);
4362 env
->dcache_line_size
= 32;
4363 env
->icache_line_size
= 32;
4364 /* Allocate hardware IRQ controller */
4365 ppc6xx_irq_init(env
);
4369 #define POWERPC_INSNS_e500v1 (PPC_INSNS_BASE | PPC_ISEL | \
4370 PPC_SPE | PPC_SPE_SINGLE | \
4371 PPC_WRTEE | PPC_RFDI | \
4372 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI | \
4373 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
4374 PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC)
4375 #define POWERPC_INSNS2_e500v1 (PPC2_BOOKE206)
4376 #define POWERPC_MSRM_e500v1 (0x000000000606FF30ULL)
4377 #define POWERPC_MMU_e500v1 (POWERPC_MMU_BOOKE206)
4378 #define POWERPC_EXCP_e500v1 (POWERPC_EXCP_BOOKE)
4379 #define POWERPC_INPUT_e500v1 (PPC_FLAGS_INPUT_BookE)
4380 #define POWERPC_BFDM_e500v1 (bfd_mach_ppc_860)
4381 #define POWERPC_FLAG_e500v1 (POWERPC_FLAG_SPE | POWERPC_FLAG_CE | \
4382 POWERPC_FLAG_UBLE | POWERPC_FLAG_DE | \
4383 POWERPC_FLAG_BUS_CLK)
4384 #define check_pow_e500v1 check_pow_hid0
4385 #define init_proc_e500v1 init_proc_e500v1
4388 #define POWERPC_INSNS_e500v2 (PPC_INSNS_BASE | PPC_ISEL | \
4389 PPC_SPE | PPC_SPE_SINGLE | PPC_SPE_DOUBLE | \
4390 PPC_WRTEE | PPC_RFDI | \
4391 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI | \
4392 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
4393 PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC)
4394 #define POWERPC_INSNS2_e500v2 (PPC2_BOOKE206)
4395 #define POWERPC_MSRM_e500v2 (0x000000000606FF30ULL)
4396 #define POWERPC_MMU_e500v2 (POWERPC_MMU_BOOKE206)
4397 #define POWERPC_EXCP_e500v2 (POWERPC_EXCP_BOOKE)
4398 #define POWERPC_INPUT_e500v2 (PPC_FLAGS_INPUT_BookE)
4399 #define POWERPC_BFDM_e500v2 (bfd_mach_ppc_860)
4400 #define POWERPC_FLAG_e500v2 (POWERPC_FLAG_SPE | POWERPC_FLAG_CE | \
4401 POWERPC_FLAG_UBLE | POWERPC_FLAG_DE | \
4402 POWERPC_FLAG_BUS_CLK)
4403 #define check_pow_e500v2 check_pow_hid0
4404 #define init_proc_e500v2 init_proc_e500v2
4407 #define POWERPC_INSNS_e500mc (PPC_INSNS_BASE | PPC_ISEL | \
4408 PPC_WRTEE | PPC_RFDI | PPC_RFMCI | \
4409 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI | \
4410 PPC_CACHE_DCBZ | PPC_CACHE_DCBA | \
4411 PPC_FLOAT | PPC_FLOAT_FRES | \
4412 PPC_FLOAT_FRSQRTE | PPC_FLOAT_FSEL | \
4413 PPC_FLOAT_STFIWX | PPC_WAIT | \
4414 PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC)
4415 #define POWERPC_INSNS2_e500mc (PPC2_BOOKE206 | PPC2_PRCNTL)
4416 #define POWERPC_MSRM_e500mc (0x000000001402FB36ULL)
4417 #define POWERPC_MMU_e500mc (POWERPC_MMU_BOOKE206)
4418 #define POWERPC_EXCP_e500mc (POWERPC_EXCP_BOOKE)
4419 #define POWERPC_INPUT_e500mc (PPC_FLAGS_INPUT_BookE)
4420 /* Fixme: figure out the correct flag for e500mc */
4421 #define POWERPC_BFDM_e500mc (bfd_mach_ppc_e500)
4422 #define POWERPC_FLAG_e500mc (POWERPC_FLAG_CE | POWERPC_FLAG_DE | \
4423 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
4424 #define check_pow_e500mc check_pow_none
4425 #define init_proc_e500mc init_proc_e500mc
4427 enum fsl_e500_version
{
4433 static void init_proc_e500 (CPUPPCState
*env
, int version
)
4435 uint32_t tlbncfg
[2];
4436 uint64_t ivor_mask
= 0x0000000F0000FFFFULL
;
4437 #if !defined(CONFIG_USER_ONLY)
4444 * XXX The e500 doesn't implement IVOR7 and IVOR9, but doesn't
4445 * complain when accessing them.
4446 * gen_spr_BookE(env, 0x0000000F0000FD7FULL);
4448 if (version
== fsl_e500mc
) {
4449 ivor_mask
= 0x000003FE0000FFFFULL
;
4451 gen_spr_BookE(env
, ivor_mask
);
4452 /* Processor identification */
4453 spr_register(env
, SPR_BOOKE_PIR
, "PIR",
4454 SPR_NOACCESS
, SPR_NOACCESS
,
4455 &spr_read_generic
, &spr_write_pir
,
4457 /* XXX : not implemented */
4458 spr_register(env
, SPR_BOOKE_SPEFSCR
, "SPEFSCR",
4459 &spr_read_spefscr
, &spr_write_spefscr
,
4460 &spr_read_spefscr
, &spr_write_spefscr
,
4462 /* Memory management */
4463 #if !defined(CONFIG_USER_ONLY)
4470 tlbncfg
[0] = gen_tlbncfg(2, 1, 1, 0, 256);
4471 tlbncfg
[1] = gen_tlbncfg(16, 1, 9, TLBnCFG_AVAIL
| TLBnCFG_IPROT
, 16);
4472 env
->dcache_line_size
= 32;
4473 env
->icache_line_size
= 32;
4477 tlbncfg
[0] = gen_tlbncfg(4, 1, 1, 0, 512);
4478 tlbncfg
[1] = gen_tlbncfg(16, 1, 12, TLBnCFG_AVAIL
| TLBnCFG_IPROT
, 16);
4479 env
->dcache_line_size
= 32;
4480 env
->icache_line_size
= 32;
4484 tlbncfg
[0] = gen_tlbncfg(4, 1, 1, 0, 512);
4485 tlbncfg
[1] = gen_tlbncfg(64, 1, 12, TLBnCFG_AVAIL
| TLBnCFG_IPROT
, 64);
4486 env
->dcache_line_size
= 64;
4487 env
->icache_line_size
= 64;
4490 cpu_abort(env
, "Unknown CPU: " TARGET_FMT_lx
"\n", env
->spr
[SPR_PVR
]);
4493 gen_spr_BookE206(env
, 0x000000DF, tlbncfg
);
4494 /* XXX : not implemented */
4495 spr_register(env
, SPR_HID0
, "HID0",
4496 SPR_NOACCESS
, SPR_NOACCESS
,
4497 &spr_read_generic
, &spr_write_generic
,
4499 /* XXX : not implemented */
4500 spr_register(env
, SPR_HID1
, "HID1",
4501 SPR_NOACCESS
, SPR_NOACCESS
,
4502 &spr_read_generic
, &spr_write_generic
,
4504 /* XXX : not implemented */
4505 spr_register(env
, SPR_Exxx_BBEAR
, "BBEAR",
4506 SPR_NOACCESS
, SPR_NOACCESS
,
4507 &spr_read_generic
, &spr_write_generic
,
4509 /* XXX : not implemented */
4510 spr_register(env
, SPR_Exxx_BBTAR
, "BBTAR",
4511 SPR_NOACCESS
, SPR_NOACCESS
,
4512 &spr_read_generic
, &spr_write_generic
,
4514 /* XXX : not implemented */
4515 spr_register(env
, SPR_Exxx_MCAR
, "MCAR",
4516 SPR_NOACCESS
, SPR_NOACCESS
,
4517 &spr_read_generic
, &spr_write_generic
,
4519 /* XXX : not implemented */
4520 spr_register(env
, SPR_BOOKE_MCSR
, "MCSR",
4521 SPR_NOACCESS
, SPR_NOACCESS
,
4522 &spr_read_generic
, &spr_write_generic
,
4524 /* XXX : not implemented */
4525 spr_register(env
, SPR_Exxx_NPIDR
, "NPIDR",
4526 SPR_NOACCESS
, SPR_NOACCESS
,
4527 &spr_read_generic
, &spr_write_generic
,
4529 /* XXX : not implemented */
4530 spr_register(env
, SPR_Exxx_BUCSR
, "BUCSR",
4531 SPR_NOACCESS
, SPR_NOACCESS
,
4532 &spr_read_generic
, &spr_write_generic
,
4534 /* XXX : not implemented */
4535 spr_register(env
, SPR_Exxx_L1CFG0
, "L1CFG0",
4536 SPR_NOACCESS
, SPR_NOACCESS
,
4537 &spr_read_generic
, &spr_write_generic
,
4539 /* XXX : not implemented */
4540 spr_register(env
, SPR_Exxx_L1CSR0
, "L1CSR0",
4541 SPR_NOACCESS
, SPR_NOACCESS
,
4542 &spr_read_generic
, &spr_write_e500_l1csr0
,
4544 /* XXX : not implemented */
4545 spr_register(env
, SPR_Exxx_L1CSR1
, "L1CSR1",
4546 SPR_NOACCESS
, SPR_NOACCESS
,
4547 &spr_read_generic
, &spr_write_generic
,
4549 spr_register(env
, SPR_BOOKE_MCSRR0
, "MCSRR0",
4550 SPR_NOACCESS
, SPR_NOACCESS
,
4551 &spr_read_generic
, &spr_write_generic
,
4553 spr_register(env
, SPR_BOOKE_MCSRR1
, "MCSRR1",
4554 SPR_NOACCESS
, SPR_NOACCESS
,
4555 &spr_read_generic
, &spr_write_generic
,
4557 spr_register(env
, SPR_MMUCSR0
, "MMUCSR0",
4558 SPR_NOACCESS
, SPR_NOACCESS
,
4559 &spr_read_generic
, &spr_write_booke206_mmucsr0
,
4562 #if !defined(CONFIG_USER_ONLY)
4564 env
->tlb_type
= TLB_MAS
;
4565 for (i
= 0; i
< BOOKE206_MAX_TLBN
; i
++) {
4566 env
->nb_tlb
+= booke206_tlb_size(env
, i
);
4570 init_excp_e200(env
);
4571 /* Allocate hardware IRQ controller */
4572 ppce500_irq_init(env
);
4575 static void init_proc_e500v1(CPUPPCState
*env
)
4577 init_proc_e500(env
, fsl_e500v1
);
4580 static void init_proc_e500v2(CPUPPCState
*env
)
4582 init_proc_e500(env
, fsl_e500v2
);
4585 static void init_proc_e500mc(CPUPPCState
*env
)
4587 init_proc_e500(env
, fsl_e500mc
);
4590 /* Non-embedded PowerPC */
4592 /* POWER : same as 601, without mfmsr, mfsr */
4594 #define POWERPC_INSNS_POWER (XXX_TODO)
4595 /* POWER RSC (from RAD6000) */
4596 #define POWERPC_MSRM_POWER (0x00000000FEF0ULL)
4600 #define POWERPC_INSNS_601 (PPC_INSNS_BASE | PPC_STRING | PPC_POWER_BR | \
4602 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4603 PPC_MEM_SYNC | PPC_MEM_EIEIO | PPC_MEM_TLBIE | \
4604 PPC_SEGMENT | PPC_EXTERN)
4605 #define POWERPC_INSNS2_601 (PPC_NONE)
4606 #define POWERPC_MSRM_601 (0x000000000000FD70ULL)
4607 #define POWERPC_MSRR_601 (0x0000000000001040ULL)
4608 //#define POWERPC_MMU_601 (POWERPC_MMU_601)
4609 //#define POWERPC_EXCP_601 (POWERPC_EXCP_601)
4610 #define POWERPC_INPUT_601 (PPC_FLAGS_INPUT_6xx)
4611 #define POWERPC_BFDM_601 (bfd_mach_ppc_601)
4612 #define POWERPC_FLAG_601 (POWERPC_FLAG_SE | POWERPC_FLAG_RTC_CLK)
4613 #define check_pow_601 check_pow_none
4615 static void init_proc_601 (CPUPPCState
*env
)
4617 gen_spr_ne_601(env
);
4619 /* Hardware implementation registers */
4620 /* XXX : not implemented */
4621 spr_register(env
, SPR_HID0
, "HID0",
4622 SPR_NOACCESS
, SPR_NOACCESS
,
4623 &spr_read_generic
, &spr_write_hid0_601
,
4625 /* XXX : not implemented */
4626 spr_register(env
, SPR_HID1
, "HID1",
4627 SPR_NOACCESS
, SPR_NOACCESS
,
4628 &spr_read_generic
, &spr_write_generic
,
4630 /* XXX : not implemented */
4631 spr_register(env
, SPR_601_HID2
, "HID2",
4632 SPR_NOACCESS
, SPR_NOACCESS
,
4633 &spr_read_generic
, &spr_write_generic
,
4635 /* XXX : not implemented */
4636 spr_register(env
, SPR_601_HID5
, "HID5",
4637 SPR_NOACCESS
, SPR_NOACCESS
,
4638 &spr_read_generic
, &spr_write_generic
,
4640 /* Memory management */
4642 /* XXX: beware that dcache line size is 64
4643 * but dcbz uses 32 bytes "sectors"
4644 * XXX: this breaks clcs instruction !
4646 env
->dcache_line_size
= 32;
4647 env
->icache_line_size
= 64;
4648 /* Allocate hardware IRQ controller */
4649 ppc6xx_irq_init(env
);
4653 #define POWERPC_INSNS_601v (PPC_INSNS_BASE | PPC_STRING | PPC_POWER_BR | \
4655 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4656 PPC_MEM_SYNC | PPC_MEM_EIEIO | PPC_MEM_TLBIE | \
4657 PPC_SEGMENT | PPC_EXTERN)
4658 #define POWERPC_INSNS2_601v (PPC_NONE)
4659 #define POWERPC_MSRM_601v (0x000000000000FD70ULL)
4660 #define POWERPC_MSRR_601v (0x0000000000001040ULL)
4661 #define POWERPC_MMU_601v (POWERPC_MMU_601)
4662 #define POWERPC_EXCP_601v (POWERPC_EXCP_601)
4663 #define POWERPC_INPUT_601v (PPC_FLAGS_INPUT_6xx)
4664 #define POWERPC_BFDM_601v (bfd_mach_ppc_601)
4665 #define POWERPC_FLAG_601v (POWERPC_FLAG_SE | POWERPC_FLAG_RTC_CLK)
4666 #define check_pow_601v check_pow_none
4668 static void init_proc_601v (CPUPPCState
*env
)
4671 /* XXX : not implemented */
4672 spr_register(env
, SPR_601_HID15
, "HID15",
4673 SPR_NOACCESS
, SPR_NOACCESS
,
4674 &spr_read_generic
, &spr_write_generic
,
4679 #define POWERPC_INSNS_602 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
4680 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
4681 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
4682 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4683 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
4684 PPC_MEM_TLBIE | PPC_6xx_TLB | PPC_MEM_TLBSYNC | \
4685 PPC_SEGMENT | PPC_602_SPEC)
4686 #define POWERPC_INSNS2_602 (PPC_NONE)
4687 #define POWERPC_MSRM_602 (0x0000000000C7FF73ULL)
4688 /* XXX: 602 MMU is quite specific. Should add a special case */
4689 #define POWERPC_MMU_602 (POWERPC_MMU_SOFT_6xx)
4690 //#define POWERPC_EXCP_602 (POWERPC_EXCP_602)
4691 #define POWERPC_INPUT_602 (PPC_FLAGS_INPUT_6xx)
4692 #define POWERPC_BFDM_602 (bfd_mach_ppc_602)
4693 #define POWERPC_FLAG_602 (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE | \
4694 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
4695 #define check_pow_602 check_pow_hid0
4697 static void init_proc_602 (CPUPPCState
*env
)
4699 gen_spr_ne_601(env
);
4703 /* hardware implementation registers */
4704 /* XXX : not implemented */
4705 spr_register(env
, SPR_HID0
, "HID0",
4706 SPR_NOACCESS
, SPR_NOACCESS
,
4707 &spr_read_generic
, &spr_write_generic
,
4709 /* XXX : not implemented */
4710 spr_register(env
, SPR_HID1
, "HID1",
4711 SPR_NOACCESS
, SPR_NOACCESS
,
4712 &spr_read_generic
, &spr_write_generic
,
4714 /* Memory management */
4716 gen_6xx_7xx_soft_tlb(env
, 64, 2);
4718 env
->dcache_line_size
= 32;
4719 env
->icache_line_size
= 32;
4720 /* Allocate hardware IRQ controller */
4721 ppc6xx_irq_init(env
);
4725 #define POWERPC_INSNS_603 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
4726 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
4727 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
4728 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4729 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
4730 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
4731 PPC_SEGMENT | PPC_EXTERN)
4732 #define POWERPC_INSNS2_603 (PPC_NONE)
4733 #define POWERPC_MSRM_603 (0x000000000007FF73ULL)
4734 #define POWERPC_MMU_603 (POWERPC_MMU_SOFT_6xx)
4735 //#define POWERPC_EXCP_603 (POWERPC_EXCP_603)
4736 #define POWERPC_INPUT_603 (PPC_FLAGS_INPUT_6xx)
4737 #define POWERPC_BFDM_603 (bfd_mach_ppc_603)
4738 #define POWERPC_FLAG_603 (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE | \
4739 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
4740 #define check_pow_603 check_pow_hid0
4742 static void init_proc_603 (CPUPPCState
*env
)
4744 gen_spr_ne_601(env
);
4748 /* hardware implementation registers */
4749 /* XXX : not implemented */
4750 spr_register(env
, SPR_HID0
, "HID0",
4751 SPR_NOACCESS
, SPR_NOACCESS
,
4752 &spr_read_generic
, &spr_write_generic
,
4754 /* XXX : not implemented */
4755 spr_register(env
, SPR_HID1
, "HID1",
4756 SPR_NOACCESS
, SPR_NOACCESS
,
4757 &spr_read_generic
, &spr_write_generic
,
4759 /* Memory management */
4761 gen_6xx_7xx_soft_tlb(env
, 64, 2);
4763 env
->dcache_line_size
= 32;
4764 env
->icache_line_size
= 32;
4765 /* Allocate hardware IRQ controller */
4766 ppc6xx_irq_init(env
);
4770 #define POWERPC_INSNS_603E (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
4771 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
4772 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
4773 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4774 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
4775 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
4776 PPC_SEGMENT | PPC_EXTERN)
4777 #define POWERPC_INSNS2_603E (PPC_NONE)
4778 #define POWERPC_MSRM_603E (0x000000000007FF73ULL)
4779 #define POWERPC_MMU_603E (POWERPC_MMU_SOFT_6xx)
4780 //#define POWERPC_EXCP_603E (POWERPC_EXCP_603E)
4781 #define POWERPC_INPUT_603E (PPC_FLAGS_INPUT_6xx)
4782 #define POWERPC_BFDM_603E (bfd_mach_ppc_ec603e)
4783 #define POWERPC_FLAG_603E (POWERPC_FLAG_TGPR | POWERPC_FLAG_SE | \
4784 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK)
4785 #define check_pow_603E check_pow_hid0
4787 static void init_proc_603E (CPUPPCState
*env
)
4789 gen_spr_ne_601(env
);
4793 /* hardware implementation registers */
4794 /* XXX : not implemented */
4795 spr_register(env
, SPR_HID0
, "HID0",
4796 SPR_NOACCESS
, SPR_NOACCESS
,
4797 &spr_read_generic
, &spr_write_generic
,
4799 /* XXX : not implemented */
4800 spr_register(env
, SPR_HID1
, "HID1",
4801 SPR_NOACCESS
, SPR_NOACCESS
,
4802 &spr_read_generic
, &spr_write_generic
,
4804 /* XXX : not implemented */
4805 spr_register(env
, SPR_IABR
, "IABR",
4806 SPR_NOACCESS
, SPR_NOACCESS
,
4807 &spr_read_generic
, &spr_write_generic
,
4809 /* Memory management */
4811 gen_6xx_7xx_soft_tlb(env
, 64, 2);
4813 env
->dcache_line_size
= 32;
4814 env
->icache_line_size
= 32;
4815 /* Allocate hardware IRQ controller */
4816 ppc6xx_irq_init(env
);
4820 #define POWERPC_INSNS_604 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
4821 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
4822 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
4823 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4824 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
4825 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
4826 PPC_SEGMENT | PPC_EXTERN)
4827 #define POWERPC_INSNS2_604 (PPC_NONE)
4828 #define POWERPC_MSRM_604 (0x000000000005FF77ULL)
4829 #define POWERPC_MMU_604 (POWERPC_MMU_32B)
4830 //#define POWERPC_EXCP_604 (POWERPC_EXCP_604)
4831 #define POWERPC_INPUT_604 (PPC_FLAGS_INPUT_6xx)
4832 #define POWERPC_BFDM_604 (bfd_mach_ppc_604)
4833 #define POWERPC_FLAG_604 (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
4834 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
4835 #define check_pow_604 check_pow_nocheck
4837 static void init_proc_604 (CPUPPCState
*env
)
4839 gen_spr_ne_601(env
);
4843 /* Hardware implementation registers */
4844 /* XXX : not implemented */
4845 spr_register(env
, SPR_HID0
, "HID0",
4846 SPR_NOACCESS
, SPR_NOACCESS
,
4847 &spr_read_generic
, &spr_write_generic
,
4849 /* Memory management */
4852 env
->dcache_line_size
= 32;
4853 env
->icache_line_size
= 32;
4854 /* Allocate hardware IRQ controller */
4855 ppc6xx_irq_init(env
);
4859 #define POWERPC_INSNS_604E (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
4860 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
4861 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
4862 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4863 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
4864 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
4865 PPC_SEGMENT | PPC_EXTERN)
4866 #define POWERPC_INSNS2_604E (PPC_NONE)
4867 #define POWERPC_MSRM_604E (0x000000000005FF77ULL)
4868 #define POWERPC_MMU_604E (POWERPC_MMU_32B)
4869 #define POWERPC_EXCP_604E (POWERPC_EXCP_604)
4870 #define POWERPC_INPUT_604E (PPC_FLAGS_INPUT_6xx)
4871 #define POWERPC_BFDM_604E (bfd_mach_ppc_604)
4872 #define POWERPC_FLAG_604E (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
4873 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
4874 #define check_pow_604E check_pow_nocheck
4876 static void init_proc_604E (CPUPPCState
*env
)
4878 gen_spr_ne_601(env
);
4880 /* XXX : not implemented */
4881 spr_register(env
, SPR_MMCR1
, "MMCR1",
4882 SPR_NOACCESS
, SPR_NOACCESS
,
4883 &spr_read_generic
, &spr_write_generic
,
4885 /* XXX : not implemented */
4886 spr_register(env
, SPR_PMC3
, "PMC3",
4887 SPR_NOACCESS
, SPR_NOACCESS
,
4888 &spr_read_generic
, &spr_write_generic
,
4890 /* XXX : not implemented */
4891 spr_register(env
, SPR_PMC4
, "PMC4",
4892 SPR_NOACCESS
, SPR_NOACCESS
,
4893 &spr_read_generic
, &spr_write_generic
,
4897 /* Hardware implementation registers */
4898 /* XXX : not implemented */
4899 spr_register(env
, SPR_HID0
, "HID0",
4900 SPR_NOACCESS
, SPR_NOACCESS
,
4901 &spr_read_generic
, &spr_write_generic
,
4903 /* XXX : not implemented */
4904 spr_register(env
, SPR_HID1
, "HID1",
4905 SPR_NOACCESS
, SPR_NOACCESS
,
4906 &spr_read_generic
, &spr_write_generic
,
4908 /* Memory management */
4911 env
->dcache_line_size
= 32;
4912 env
->icache_line_size
= 32;
4913 /* Allocate hardware IRQ controller */
4914 ppc6xx_irq_init(env
);
4918 #define POWERPC_INSNS_740 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
4919 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
4920 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
4921 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4922 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
4923 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
4924 PPC_SEGMENT | PPC_EXTERN)
4925 #define POWERPC_INSNS2_740 (PPC_NONE)
4926 #define POWERPC_MSRM_740 (0x000000000005FF77ULL)
4927 #define POWERPC_MMU_740 (POWERPC_MMU_32B)
4928 #define POWERPC_EXCP_740 (POWERPC_EXCP_7x0)
4929 #define POWERPC_INPUT_740 (PPC_FLAGS_INPUT_6xx)
4930 #define POWERPC_BFDM_740 (bfd_mach_ppc_750)
4931 #define POWERPC_FLAG_740 (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
4932 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
4933 #define check_pow_740 check_pow_hid0
4935 static void init_proc_740 (CPUPPCState
*env
)
4937 gen_spr_ne_601(env
);
4941 /* Thermal management */
4943 /* Hardware implementation registers */
4944 /* XXX : not implemented */
4945 spr_register(env
, SPR_HID0
, "HID0",
4946 SPR_NOACCESS
, SPR_NOACCESS
,
4947 &spr_read_generic
, &spr_write_generic
,
4949 /* XXX : not implemented */
4950 spr_register(env
, SPR_HID1
, "HID1",
4951 SPR_NOACCESS
, SPR_NOACCESS
,
4952 &spr_read_generic
, &spr_write_generic
,
4954 /* Memory management */
4957 env
->dcache_line_size
= 32;
4958 env
->icache_line_size
= 32;
4959 /* Allocate hardware IRQ controller */
4960 ppc6xx_irq_init(env
);
4964 #define POWERPC_INSNS_750 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
4965 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
4966 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
4967 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
4968 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
4969 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
4970 PPC_SEGMENT | PPC_EXTERN)
4971 #define POWERPC_INSNS2_750 (PPC_NONE)
4972 #define POWERPC_MSRM_750 (0x000000000005FF77ULL)
4973 #define POWERPC_MMU_750 (POWERPC_MMU_32B)
4974 #define POWERPC_EXCP_750 (POWERPC_EXCP_7x0)
4975 #define POWERPC_INPUT_750 (PPC_FLAGS_INPUT_6xx)
4976 #define POWERPC_BFDM_750 (bfd_mach_ppc_750)
4977 #define POWERPC_FLAG_750 (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
4978 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
4979 #define check_pow_750 check_pow_hid0
4981 static void init_proc_750 (CPUPPCState
*env
)
4983 gen_spr_ne_601(env
);
4985 /* XXX : not implemented */
4986 spr_register(env
, SPR_L2CR
, "L2CR",
4987 SPR_NOACCESS
, SPR_NOACCESS
,
4988 &spr_read_generic
, &spr_write_generic
,
4992 /* Thermal management */
4994 /* Hardware implementation registers */
4995 /* XXX : not implemented */
4996 spr_register(env
, SPR_HID0
, "HID0",
4997 SPR_NOACCESS
, SPR_NOACCESS
,
4998 &spr_read_generic
, &spr_write_generic
,
5000 /* XXX : not implemented */
5001 spr_register(env
, SPR_HID1
, "HID1",
5002 SPR_NOACCESS
, SPR_NOACCESS
,
5003 &spr_read_generic
, &spr_write_generic
,
5005 /* Memory management */
5007 /* XXX: high BATs are also present but are known to be bugged on
5011 env
->dcache_line_size
= 32;
5012 env
->icache_line_size
= 32;
5013 /* Allocate hardware IRQ controller */
5014 ppc6xx_irq_init(env
);
5017 /* PowerPC 750 CL */
5018 /* XXX: not implemented:
5019 * cache lock instructions:
5021 * floating point paired instructions
5056 #define POWERPC_INSNS_750cl (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5057 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5058 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
5059 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
5060 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5061 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
5062 PPC_SEGMENT | PPC_EXTERN)
5063 #define POWERPC_INSNS2_750cl (PPC_NONE)
5064 #define POWERPC_MSRM_750cl (0x000000000005FF77ULL)
5065 #define POWERPC_MMU_750cl (POWERPC_MMU_32B)
5066 #define POWERPC_EXCP_750cl (POWERPC_EXCP_7x0)
5067 #define POWERPC_INPUT_750cl (PPC_FLAGS_INPUT_6xx)
5068 #define POWERPC_BFDM_750cl (bfd_mach_ppc_750)
5069 #define POWERPC_FLAG_750cl (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
5070 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
5071 #define check_pow_750cl check_pow_hid0
5073 static void init_proc_750cl (CPUPPCState
*env
)
5075 gen_spr_ne_601(env
);
5077 /* XXX : not implemented */
5078 spr_register(env
, SPR_L2CR
, "L2CR",
5079 SPR_NOACCESS
, SPR_NOACCESS
,
5080 &spr_read_generic
, &spr_write_generic
,
5084 /* Thermal management */
5085 /* Those registers are fake on 750CL */
5086 spr_register(env
, SPR_THRM1
, "THRM1",
5087 SPR_NOACCESS
, SPR_NOACCESS
,
5088 &spr_read_generic
, &spr_write_generic
,
5090 spr_register(env
, SPR_THRM2
, "THRM2",
5091 SPR_NOACCESS
, SPR_NOACCESS
,
5092 &spr_read_generic
, &spr_write_generic
,
5094 spr_register(env
, SPR_THRM3
, "THRM3",
5095 SPR_NOACCESS
, SPR_NOACCESS
,
5096 &spr_read_generic
, &spr_write_generic
,
5098 /* XXX: not implemented */
5099 spr_register(env
, SPR_750_TDCL
, "TDCL",
5100 SPR_NOACCESS
, SPR_NOACCESS
,
5101 &spr_read_generic
, &spr_write_generic
,
5103 spr_register(env
, SPR_750_TDCH
, "TDCH",
5104 SPR_NOACCESS
, SPR_NOACCESS
,
5105 &spr_read_generic
, &spr_write_generic
,
5108 /* XXX : not implemented */
5109 spr_register(env
, SPR_750_WPAR
, "WPAR",
5110 SPR_NOACCESS
, SPR_NOACCESS
,
5111 &spr_read_generic
, &spr_write_generic
,
5113 spr_register(env
, SPR_750_DMAL
, "DMAL",
5114 SPR_NOACCESS
, SPR_NOACCESS
,
5115 &spr_read_generic
, &spr_write_generic
,
5117 spr_register(env
, SPR_750_DMAU
, "DMAU",
5118 SPR_NOACCESS
, SPR_NOACCESS
,
5119 &spr_read_generic
, &spr_write_generic
,
5121 /* Hardware implementation registers */
5122 /* XXX : not implemented */
5123 spr_register(env
, SPR_HID0
, "HID0",
5124 SPR_NOACCESS
, SPR_NOACCESS
,
5125 &spr_read_generic
, &spr_write_generic
,
5127 /* XXX : not implemented */
5128 spr_register(env
, SPR_HID1
, "HID1",
5129 SPR_NOACCESS
, SPR_NOACCESS
,
5130 &spr_read_generic
, &spr_write_generic
,
5132 /* XXX : not implemented */
5133 spr_register(env
, SPR_750CL_HID2
, "HID2",
5134 SPR_NOACCESS
, SPR_NOACCESS
,
5135 &spr_read_generic
, &spr_write_generic
,
5137 /* XXX : not implemented */
5138 spr_register(env
, SPR_750CL_HID4
, "HID4",
5139 SPR_NOACCESS
, SPR_NOACCESS
,
5140 &spr_read_generic
, &spr_write_generic
,
5142 /* Quantization registers */
5143 /* XXX : not implemented */
5144 spr_register(env
, SPR_750_GQR0
, "GQR0",
5145 SPR_NOACCESS
, SPR_NOACCESS
,
5146 &spr_read_generic
, &spr_write_generic
,
5148 /* XXX : not implemented */
5149 spr_register(env
, SPR_750_GQR1
, "GQR1",
5150 SPR_NOACCESS
, SPR_NOACCESS
,
5151 &spr_read_generic
, &spr_write_generic
,
5153 /* XXX : not implemented */
5154 spr_register(env
, SPR_750_GQR2
, "GQR2",
5155 SPR_NOACCESS
, SPR_NOACCESS
,
5156 &spr_read_generic
, &spr_write_generic
,
5158 /* XXX : not implemented */
5159 spr_register(env
, SPR_750_GQR3
, "GQR3",
5160 SPR_NOACCESS
, SPR_NOACCESS
,
5161 &spr_read_generic
, &spr_write_generic
,
5163 /* XXX : not implemented */
5164 spr_register(env
, SPR_750_GQR4
, "GQR4",
5165 SPR_NOACCESS
, SPR_NOACCESS
,
5166 &spr_read_generic
, &spr_write_generic
,
5168 /* XXX : not implemented */
5169 spr_register(env
, SPR_750_GQR5
, "GQR5",
5170 SPR_NOACCESS
, SPR_NOACCESS
,
5171 &spr_read_generic
, &spr_write_generic
,
5173 /* XXX : not implemented */
5174 spr_register(env
, SPR_750_GQR6
, "GQR6",
5175 SPR_NOACCESS
, SPR_NOACCESS
,
5176 &spr_read_generic
, &spr_write_generic
,
5178 /* XXX : not implemented */
5179 spr_register(env
, SPR_750_GQR7
, "GQR7",
5180 SPR_NOACCESS
, SPR_NOACCESS
,
5181 &spr_read_generic
, &spr_write_generic
,
5183 /* Memory management */
5185 /* PowerPC 750cl has 8 DBATs and 8 IBATs */
5187 init_excp_750cl(env
);
5188 env
->dcache_line_size
= 32;
5189 env
->icache_line_size
= 32;
5190 /* Allocate hardware IRQ controller */
5191 ppc6xx_irq_init(env
);
5195 #define POWERPC_INSNS_750cx (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5196 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5197 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
5198 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
5199 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5200 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
5201 PPC_SEGMENT | PPC_EXTERN)
5202 #define POWERPC_INSNS2_750cx (PPC_NONE)
5203 #define POWERPC_MSRM_750cx (0x000000000005FF77ULL)
5204 #define POWERPC_MMU_750cx (POWERPC_MMU_32B)
5205 #define POWERPC_EXCP_750cx (POWERPC_EXCP_7x0)
5206 #define POWERPC_INPUT_750cx (PPC_FLAGS_INPUT_6xx)
5207 #define POWERPC_BFDM_750cx (bfd_mach_ppc_750)
5208 #define POWERPC_FLAG_750cx (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
5209 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
5210 #define check_pow_750cx check_pow_hid0
5212 static void init_proc_750cx (CPUPPCState
*env
)
5214 gen_spr_ne_601(env
);
5216 /* XXX : not implemented */
5217 spr_register(env
, SPR_L2CR
, "L2CR",
5218 SPR_NOACCESS
, SPR_NOACCESS
,
5219 &spr_read_generic
, &spr_write_generic
,
5223 /* Thermal management */
5225 /* This register is not implemented but is present for compatibility */
5226 spr_register(env
, SPR_SDA
, "SDA",
5227 SPR_NOACCESS
, SPR_NOACCESS
,
5228 &spr_read_generic
, &spr_write_generic
,
5230 /* Hardware implementation registers */
5231 /* XXX : not implemented */
5232 spr_register(env
, SPR_HID0
, "HID0",
5233 SPR_NOACCESS
, SPR_NOACCESS
,
5234 &spr_read_generic
, &spr_write_generic
,
5236 /* XXX : not implemented */
5237 spr_register(env
, SPR_HID1
, "HID1",
5238 SPR_NOACCESS
, SPR_NOACCESS
,
5239 &spr_read_generic
, &spr_write_generic
,
5241 /* Memory management */
5243 /* PowerPC 750cx has 8 DBATs and 8 IBATs */
5245 init_excp_750cx(env
);
5246 env
->dcache_line_size
= 32;
5247 env
->icache_line_size
= 32;
5248 /* Allocate hardware IRQ controller */
5249 ppc6xx_irq_init(env
);
5253 #define POWERPC_INSNS_750fx (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5254 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5255 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
5256 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
5257 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5258 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
5259 PPC_SEGMENT | PPC_EXTERN)
5260 #define POWERPC_INSNS2_750fx (PPC_NONE)
5261 #define POWERPC_MSRM_750fx (0x000000000005FF77ULL)
5262 #define POWERPC_MMU_750fx (POWERPC_MMU_32B)
5263 #define POWERPC_EXCP_750fx (POWERPC_EXCP_7x0)
5264 #define POWERPC_INPUT_750fx (PPC_FLAGS_INPUT_6xx)
5265 #define POWERPC_BFDM_750fx (bfd_mach_ppc_750)
5266 #define POWERPC_FLAG_750fx (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
5267 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
5268 #define check_pow_750fx check_pow_hid0
5270 static void init_proc_750fx (CPUPPCState
*env
)
5272 gen_spr_ne_601(env
);
5274 /* XXX : not implemented */
5275 spr_register(env
, SPR_L2CR
, "L2CR",
5276 SPR_NOACCESS
, SPR_NOACCESS
,
5277 &spr_read_generic
, &spr_write_generic
,
5281 /* Thermal management */
5283 /* XXX : not implemented */
5284 spr_register(env
, SPR_750_THRM4
, "THRM4",
5285 SPR_NOACCESS
, SPR_NOACCESS
,
5286 &spr_read_generic
, &spr_write_generic
,
5288 /* Hardware implementation registers */
5289 /* XXX : not implemented */
5290 spr_register(env
, SPR_HID0
, "HID0",
5291 SPR_NOACCESS
, SPR_NOACCESS
,
5292 &spr_read_generic
, &spr_write_generic
,
5294 /* XXX : not implemented */
5295 spr_register(env
, SPR_HID1
, "HID1",
5296 SPR_NOACCESS
, SPR_NOACCESS
,
5297 &spr_read_generic
, &spr_write_generic
,
5299 /* XXX : not implemented */
5300 spr_register(env
, SPR_750FX_HID2
, "HID2",
5301 SPR_NOACCESS
, SPR_NOACCESS
,
5302 &spr_read_generic
, &spr_write_generic
,
5304 /* Memory management */
5306 /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */
5309 env
->dcache_line_size
= 32;
5310 env
->icache_line_size
= 32;
5311 /* Allocate hardware IRQ controller */
5312 ppc6xx_irq_init(env
);
5316 #define POWERPC_INSNS_750gx (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5317 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5318 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
5319 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
5320 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5321 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
5322 PPC_SEGMENT | PPC_EXTERN)
5323 #define POWERPC_INSNS2_750gx (PPC_NONE)
5324 #define POWERPC_MSRM_750gx (0x000000000005FF77ULL)
5325 #define POWERPC_MMU_750gx (POWERPC_MMU_32B)
5326 #define POWERPC_EXCP_750gx (POWERPC_EXCP_7x0)
5327 #define POWERPC_INPUT_750gx (PPC_FLAGS_INPUT_6xx)
5328 #define POWERPC_BFDM_750gx (bfd_mach_ppc_750)
5329 #define POWERPC_FLAG_750gx (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
5330 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
5331 #define check_pow_750gx check_pow_hid0
5333 static void init_proc_750gx (CPUPPCState
*env
)
5335 gen_spr_ne_601(env
);
5337 /* XXX : not implemented (XXX: different from 750fx) */
5338 spr_register(env
, SPR_L2CR
, "L2CR",
5339 SPR_NOACCESS
, SPR_NOACCESS
,
5340 &spr_read_generic
, &spr_write_generic
,
5344 /* Thermal management */
5346 /* XXX : not implemented */
5347 spr_register(env
, SPR_750_THRM4
, "THRM4",
5348 SPR_NOACCESS
, SPR_NOACCESS
,
5349 &spr_read_generic
, &spr_write_generic
,
5351 /* Hardware implementation registers */
5352 /* XXX : not implemented (XXX: different from 750fx) */
5353 spr_register(env
, SPR_HID0
, "HID0",
5354 SPR_NOACCESS
, SPR_NOACCESS
,
5355 &spr_read_generic
, &spr_write_generic
,
5357 /* XXX : not implemented */
5358 spr_register(env
, SPR_HID1
, "HID1",
5359 SPR_NOACCESS
, SPR_NOACCESS
,
5360 &spr_read_generic
, &spr_write_generic
,
5362 /* XXX : not implemented (XXX: different from 750fx) */
5363 spr_register(env
, SPR_750FX_HID2
, "HID2",
5364 SPR_NOACCESS
, SPR_NOACCESS
,
5365 &spr_read_generic
, &spr_write_generic
,
5367 /* Memory management */
5369 /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */
5372 env
->dcache_line_size
= 32;
5373 env
->icache_line_size
= 32;
5374 /* Allocate hardware IRQ controller */
5375 ppc6xx_irq_init(env
);
5379 #define POWERPC_INSNS_745 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5380 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5381 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
5382 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
5383 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5384 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
5385 PPC_SEGMENT | PPC_EXTERN)
5386 #define POWERPC_INSNS2_745 (PPC_NONE)
5387 #define POWERPC_MSRM_745 (0x000000000005FF77ULL)
5388 #define POWERPC_MMU_745 (POWERPC_MMU_SOFT_6xx)
5389 #define POWERPC_EXCP_745 (POWERPC_EXCP_7x5)
5390 #define POWERPC_INPUT_745 (PPC_FLAGS_INPUT_6xx)
5391 #define POWERPC_BFDM_745 (bfd_mach_ppc_750)
5392 #define POWERPC_FLAG_745 (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
5393 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
5394 #define check_pow_745 check_pow_hid0
5396 static void init_proc_745 (CPUPPCState
*env
)
5398 gen_spr_ne_601(env
);
5400 gen_spr_G2_755(env
);
5403 /* Thermal management */
5405 /* Hardware implementation registers */
5406 /* XXX : not implemented */
5407 spr_register(env
, SPR_HID0
, "HID0",
5408 SPR_NOACCESS
, SPR_NOACCESS
,
5409 &spr_read_generic
, &spr_write_generic
,
5411 /* XXX : not implemented */
5412 spr_register(env
, SPR_HID1
, "HID1",
5413 SPR_NOACCESS
, SPR_NOACCESS
,
5414 &spr_read_generic
, &spr_write_generic
,
5416 /* XXX : not implemented */
5417 spr_register(env
, SPR_HID2
, "HID2",
5418 SPR_NOACCESS
, SPR_NOACCESS
,
5419 &spr_read_generic
, &spr_write_generic
,
5421 /* Memory management */
5424 gen_6xx_7xx_soft_tlb(env
, 64, 2);
5426 env
->dcache_line_size
= 32;
5427 env
->icache_line_size
= 32;
5428 /* Allocate hardware IRQ controller */
5429 ppc6xx_irq_init(env
);
5433 #define POWERPC_INSNS_755 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5434 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5435 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX | \
5436 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
5437 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5438 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB | \
5439 PPC_SEGMENT | PPC_EXTERN)
5440 #define POWERPC_INSNS2_755 (PPC_NONE)
5441 #define POWERPC_MSRM_755 (0x000000000005FF77ULL)
5442 #define POWERPC_MMU_755 (POWERPC_MMU_SOFT_6xx)
5443 #define POWERPC_EXCP_755 (POWERPC_EXCP_7x5)
5444 #define POWERPC_INPUT_755 (PPC_FLAGS_INPUT_6xx)
5445 #define POWERPC_BFDM_755 (bfd_mach_ppc_750)
5446 #define POWERPC_FLAG_755 (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
5447 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
5448 #define check_pow_755 check_pow_hid0
5450 static void init_proc_755 (CPUPPCState
*env
)
5452 gen_spr_ne_601(env
);
5454 gen_spr_G2_755(env
);
5457 /* L2 cache control */
5458 /* XXX : not implemented */
5459 spr_register(env
, SPR_L2CR
, "L2CR",
5460 SPR_NOACCESS
, SPR_NOACCESS
,
5461 &spr_read_generic
, &spr_write_generic
,
5463 /* XXX : not implemented */
5464 spr_register(env
, SPR_L2PMCR
, "L2PMCR",
5465 SPR_NOACCESS
, SPR_NOACCESS
,
5466 &spr_read_generic
, &spr_write_generic
,
5468 /* Thermal management */
5470 /* Hardware implementation registers */
5471 /* XXX : not implemented */
5472 spr_register(env
, SPR_HID0
, "HID0",
5473 SPR_NOACCESS
, SPR_NOACCESS
,
5474 &spr_read_generic
, &spr_write_generic
,
5476 /* XXX : not implemented */
5477 spr_register(env
, SPR_HID1
, "HID1",
5478 SPR_NOACCESS
, SPR_NOACCESS
,
5479 &spr_read_generic
, &spr_write_generic
,
5481 /* XXX : not implemented */
5482 spr_register(env
, SPR_HID2
, "HID2",
5483 SPR_NOACCESS
, SPR_NOACCESS
,
5484 &spr_read_generic
, &spr_write_generic
,
5486 /* Memory management */
5489 gen_6xx_7xx_soft_tlb(env
, 64, 2);
5491 env
->dcache_line_size
= 32;
5492 env
->icache_line_size
= 32;
5493 /* Allocate hardware IRQ controller */
5494 ppc6xx_irq_init(env
);
5497 /* PowerPC 7400 (aka G4) */
5498 #define POWERPC_INSNS_7400 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5499 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5500 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
5501 PPC_FLOAT_STFIWX | \
5502 PPC_CACHE | PPC_CACHE_ICBI | \
5503 PPC_CACHE_DCBA | PPC_CACHE_DCBZ | \
5504 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5505 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
5507 PPC_SEGMENT | PPC_EXTERN | \
5509 #define POWERPC_INSNS2_7400 (PPC_NONE)
5510 #define POWERPC_MSRM_7400 (0x000000000205FF77ULL)
5511 #define POWERPC_MMU_7400 (POWERPC_MMU_32B)
5512 #define POWERPC_EXCP_7400 (POWERPC_EXCP_74xx)
5513 #define POWERPC_INPUT_7400 (PPC_FLAGS_INPUT_6xx)
5514 #define POWERPC_BFDM_7400 (bfd_mach_ppc_7400)
5515 #define POWERPC_FLAG_7400 (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
5516 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
5517 POWERPC_FLAG_BUS_CLK)
5518 #define check_pow_7400 check_pow_hid0
5520 static void init_proc_7400 (CPUPPCState
*env
)
5522 gen_spr_ne_601(env
);
5526 /* 74xx specific SPR */
5528 /* XXX : not implemented */
5529 spr_register(env
, SPR_UBAMR
, "UBAMR",
5530 &spr_read_ureg
, SPR_NOACCESS
,
5531 &spr_read_ureg
, SPR_NOACCESS
,
5533 /* XXX: this seems not implemented on all revisions. */
5534 /* XXX : not implemented */
5535 spr_register(env
, SPR_MSSCR1
, "MSSCR1",
5536 SPR_NOACCESS
, SPR_NOACCESS
,
5537 &spr_read_generic
, &spr_write_generic
,
5539 /* Thermal management */
5541 /* Memory management */
5543 init_excp_7400(env
);
5544 env
->dcache_line_size
= 32;
5545 env
->icache_line_size
= 32;
5546 /* Allocate hardware IRQ controller */
5547 ppc6xx_irq_init(env
);
5550 /* PowerPC 7410 (aka G4) */
5551 #define POWERPC_INSNS_7410 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5552 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5553 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
5554 PPC_FLOAT_STFIWX | \
5555 PPC_CACHE | PPC_CACHE_ICBI | \
5556 PPC_CACHE_DCBA | PPC_CACHE_DCBZ | \
5557 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5558 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
5560 PPC_SEGMENT | PPC_EXTERN | \
5562 #define POWERPC_INSNS2_7410 (PPC_NONE)
5563 #define POWERPC_MSRM_7410 (0x000000000205FF77ULL)
5564 #define POWERPC_MMU_7410 (POWERPC_MMU_32B)
5565 #define POWERPC_EXCP_7410 (POWERPC_EXCP_74xx)
5566 #define POWERPC_INPUT_7410 (PPC_FLAGS_INPUT_6xx)
5567 #define POWERPC_BFDM_7410 (bfd_mach_ppc_7400)
5568 #define POWERPC_FLAG_7410 (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
5569 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
5570 POWERPC_FLAG_BUS_CLK)
5571 #define check_pow_7410 check_pow_hid0
5573 static void init_proc_7410 (CPUPPCState
*env
)
5575 gen_spr_ne_601(env
);
5579 /* 74xx specific SPR */
5581 /* XXX : not implemented */
5582 spr_register(env
, SPR_UBAMR
, "UBAMR",
5583 &spr_read_ureg
, SPR_NOACCESS
,
5584 &spr_read_ureg
, SPR_NOACCESS
,
5586 /* Thermal management */
5589 /* XXX : not implemented */
5590 spr_register(env
, SPR_L2PMCR
, "L2PMCR",
5591 SPR_NOACCESS
, SPR_NOACCESS
,
5592 &spr_read_generic
, &spr_write_generic
,
5595 /* XXX : not implemented */
5596 spr_register(env
, SPR_LDSTDB
, "LDSTDB",
5597 SPR_NOACCESS
, SPR_NOACCESS
,
5598 &spr_read_generic
, &spr_write_generic
,
5600 /* Memory management */
5602 init_excp_7400(env
);
5603 env
->dcache_line_size
= 32;
5604 env
->icache_line_size
= 32;
5605 /* Allocate hardware IRQ controller */
5606 ppc6xx_irq_init(env
);
5609 /* PowerPC 7440 (aka G4) */
5610 #define POWERPC_INSNS_7440 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5611 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5612 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
5613 PPC_FLOAT_STFIWX | \
5614 PPC_CACHE | PPC_CACHE_ICBI | \
5615 PPC_CACHE_DCBA | PPC_CACHE_DCBZ | \
5616 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5617 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
5618 PPC_MEM_TLBIA | PPC_74xx_TLB | \
5619 PPC_SEGMENT | PPC_EXTERN | \
5621 #define POWERPC_INSNS2_7440 (PPC_NONE)
5622 #define POWERPC_MSRM_7440 (0x000000000205FF77ULL)
5623 #define POWERPC_MMU_7440 (POWERPC_MMU_SOFT_74xx)
5624 #define POWERPC_EXCP_7440 (POWERPC_EXCP_74xx)
5625 #define POWERPC_INPUT_7440 (PPC_FLAGS_INPUT_6xx)
5626 #define POWERPC_BFDM_7440 (bfd_mach_ppc_7400)
5627 #define POWERPC_FLAG_7440 (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
5628 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
5629 POWERPC_FLAG_BUS_CLK)
5630 #define check_pow_7440 check_pow_hid0_74xx
5632 __attribute__ (( unused
))
5633 static void init_proc_7440 (CPUPPCState
*env
)
5635 gen_spr_ne_601(env
);
5639 /* 74xx specific SPR */
5641 /* XXX : not implemented */
5642 spr_register(env
, SPR_UBAMR
, "UBAMR",
5643 &spr_read_ureg
, SPR_NOACCESS
,
5644 &spr_read_ureg
, SPR_NOACCESS
,
5647 /* XXX : not implemented */
5648 spr_register(env
, SPR_LDSTCR
, "LDSTCR",
5649 SPR_NOACCESS
, SPR_NOACCESS
,
5650 &spr_read_generic
, &spr_write_generic
,
5653 /* XXX : not implemented */
5654 spr_register(env
, SPR_ICTRL
, "ICTRL",
5655 SPR_NOACCESS
, SPR_NOACCESS
,
5656 &spr_read_generic
, &spr_write_generic
,
5659 /* XXX : not implemented */
5660 spr_register(env
, SPR_MSSSR0
, "MSSSR0",
5661 SPR_NOACCESS
, SPR_NOACCESS
,
5662 &spr_read_generic
, &spr_write_generic
,
5665 /* XXX : not implemented */
5666 spr_register(env
, SPR_PMC5
, "PMC5",
5667 SPR_NOACCESS
, SPR_NOACCESS
,
5668 &spr_read_generic
, &spr_write_generic
,
5670 /* XXX : not implemented */
5671 spr_register(env
, SPR_UPMC5
, "UPMC5",
5672 &spr_read_ureg
, SPR_NOACCESS
,
5673 &spr_read_ureg
, SPR_NOACCESS
,
5675 /* XXX : not implemented */
5676 spr_register(env
, SPR_PMC6
, "PMC6",
5677 SPR_NOACCESS
, SPR_NOACCESS
,
5678 &spr_read_generic
, &spr_write_generic
,
5680 /* XXX : not implemented */
5681 spr_register(env
, SPR_UPMC6
, "UPMC6",
5682 &spr_read_ureg
, SPR_NOACCESS
,
5683 &spr_read_ureg
, SPR_NOACCESS
,
5685 /* Memory management */
5687 gen_74xx_soft_tlb(env
, 128, 2);
5688 init_excp_7450(env
);
5689 env
->dcache_line_size
= 32;
5690 env
->icache_line_size
= 32;
5691 /* Allocate hardware IRQ controller */
5692 ppc6xx_irq_init(env
);
5695 /* PowerPC 7450 (aka G4) */
5696 #define POWERPC_INSNS_7450 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5697 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5698 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
5699 PPC_FLOAT_STFIWX | \
5700 PPC_CACHE | PPC_CACHE_ICBI | \
5701 PPC_CACHE_DCBA | PPC_CACHE_DCBZ | \
5702 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5703 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
5704 PPC_MEM_TLBIA | PPC_74xx_TLB | \
5705 PPC_SEGMENT | PPC_EXTERN | \
5707 #define POWERPC_INSNS2_7450 (PPC_NONE)
5708 #define POWERPC_MSRM_7450 (0x000000000205FF77ULL)
5709 #define POWERPC_MMU_7450 (POWERPC_MMU_SOFT_74xx)
5710 #define POWERPC_EXCP_7450 (POWERPC_EXCP_74xx)
5711 #define POWERPC_INPUT_7450 (PPC_FLAGS_INPUT_6xx)
5712 #define POWERPC_BFDM_7450 (bfd_mach_ppc_7400)
5713 #define POWERPC_FLAG_7450 (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
5714 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
5715 POWERPC_FLAG_BUS_CLK)
5716 #define check_pow_7450 check_pow_hid0_74xx
5718 __attribute__ (( unused
))
5719 static void init_proc_7450 (CPUPPCState
*env
)
5721 gen_spr_ne_601(env
);
5725 /* 74xx specific SPR */
5727 /* Level 3 cache control */
5730 /* XXX : not implemented */
5731 spr_register(env
, SPR_L3ITCR1
, "L3ITCR1",
5732 SPR_NOACCESS
, SPR_NOACCESS
,
5733 &spr_read_generic
, &spr_write_generic
,
5736 /* XXX : not implemented */
5737 spr_register(env
, SPR_L3ITCR2
, "L3ITCR2",
5738 SPR_NOACCESS
, SPR_NOACCESS
,
5739 &spr_read_generic
, &spr_write_generic
,
5742 /* XXX : not implemented */
5743 spr_register(env
, SPR_L3ITCR3
, "L3ITCR3",
5744 SPR_NOACCESS
, SPR_NOACCESS
,
5745 &spr_read_generic
, &spr_write_generic
,
5748 /* XXX : not implemented */
5749 spr_register(env
, SPR_L3OHCR
, "L3OHCR",
5750 SPR_NOACCESS
, SPR_NOACCESS
,
5751 &spr_read_generic
, &spr_write_generic
,
5753 /* XXX : not implemented */
5754 spr_register(env
, SPR_UBAMR
, "UBAMR",
5755 &spr_read_ureg
, SPR_NOACCESS
,
5756 &spr_read_ureg
, SPR_NOACCESS
,
5759 /* XXX : not implemented */
5760 spr_register(env
, SPR_LDSTCR
, "LDSTCR",
5761 SPR_NOACCESS
, SPR_NOACCESS
,
5762 &spr_read_generic
, &spr_write_generic
,
5765 /* XXX : not implemented */
5766 spr_register(env
, SPR_ICTRL
, "ICTRL",
5767 SPR_NOACCESS
, SPR_NOACCESS
,
5768 &spr_read_generic
, &spr_write_generic
,
5771 /* XXX : not implemented */
5772 spr_register(env
, SPR_MSSSR0
, "MSSSR0",
5773 SPR_NOACCESS
, SPR_NOACCESS
,
5774 &spr_read_generic
, &spr_write_generic
,
5777 /* XXX : not implemented */
5778 spr_register(env
, SPR_PMC5
, "PMC5",
5779 SPR_NOACCESS
, SPR_NOACCESS
,
5780 &spr_read_generic
, &spr_write_generic
,
5782 /* XXX : not implemented */
5783 spr_register(env
, SPR_UPMC5
, "UPMC5",
5784 &spr_read_ureg
, SPR_NOACCESS
,
5785 &spr_read_ureg
, SPR_NOACCESS
,
5787 /* XXX : not implemented */
5788 spr_register(env
, SPR_PMC6
, "PMC6",
5789 SPR_NOACCESS
, SPR_NOACCESS
,
5790 &spr_read_generic
, &spr_write_generic
,
5792 /* XXX : not implemented */
5793 spr_register(env
, SPR_UPMC6
, "UPMC6",
5794 &spr_read_ureg
, SPR_NOACCESS
,
5795 &spr_read_ureg
, SPR_NOACCESS
,
5797 /* Memory management */
5799 gen_74xx_soft_tlb(env
, 128, 2);
5800 init_excp_7450(env
);
5801 env
->dcache_line_size
= 32;
5802 env
->icache_line_size
= 32;
5803 /* Allocate hardware IRQ controller */
5804 ppc6xx_irq_init(env
);
5807 /* PowerPC 7445 (aka G4) */
5808 #define POWERPC_INSNS_7445 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5809 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5810 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
5811 PPC_FLOAT_STFIWX | \
5812 PPC_CACHE | PPC_CACHE_ICBI | \
5813 PPC_CACHE_DCBA | PPC_CACHE_DCBZ | \
5814 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5815 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
5816 PPC_MEM_TLBIA | PPC_74xx_TLB | \
5817 PPC_SEGMENT | PPC_EXTERN | \
5819 #define POWERPC_INSNS2_7445 (PPC_NONE)
5820 #define POWERPC_MSRM_7445 (0x000000000205FF77ULL)
5821 #define POWERPC_MMU_7445 (POWERPC_MMU_SOFT_74xx)
5822 #define POWERPC_EXCP_7445 (POWERPC_EXCP_74xx)
5823 #define POWERPC_INPUT_7445 (PPC_FLAGS_INPUT_6xx)
5824 #define POWERPC_BFDM_7445 (bfd_mach_ppc_7400)
5825 #define POWERPC_FLAG_7445 (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
5826 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
5827 POWERPC_FLAG_BUS_CLK)
5828 #define check_pow_7445 check_pow_hid0_74xx
5830 __attribute__ (( unused
))
5831 static void init_proc_7445 (CPUPPCState
*env
)
5833 gen_spr_ne_601(env
);
5837 /* 74xx specific SPR */
5840 /* XXX : not implemented */
5841 spr_register(env
, SPR_LDSTCR
, "LDSTCR",
5842 SPR_NOACCESS
, SPR_NOACCESS
,
5843 &spr_read_generic
, &spr_write_generic
,
5846 /* XXX : not implemented */
5847 spr_register(env
, SPR_ICTRL
, "ICTRL",
5848 SPR_NOACCESS
, SPR_NOACCESS
,
5849 &spr_read_generic
, &spr_write_generic
,
5852 /* XXX : not implemented */
5853 spr_register(env
, SPR_MSSSR0
, "MSSSR0",
5854 SPR_NOACCESS
, SPR_NOACCESS
,
5855 &spr_read_generic
, &spr_write_generic
,
5858 /* XXX : not implemented */
5859 spr_register(env
, SPR_PMC5
, "PMC5",
5860 SPR_NOACCESS
, SPR_NOACCESS
,
5861 &spr_read_generic
, &spr_write_generic
,
5863 /* XXX : not implemented */
5864 spr_register(env
, SPR_UPMC5
, "UPMC5",
5865 &spr_read_ureg
, SPR_NOACCESS
,
5866 &spr_read_ureg
, SPR_NOACCESS
,
5868 /* XXX : not implemented */
5869 spr_register(env
, SPR_PMC6
, "PMC6",
5870 SPR_NOACCESS
, SPR_NOACCESS
,
5871 &spr_read_generic
, &spr_write_generic
,
5873 /* XXX : not implemented */
5874 spr_register(env
, SPR_UPMC6
, "UPMC6",
5875 &spr_read_ureg
, SPR_NOACCESS
,
5876 &spr_read_ureg
, SPR_NOACCESS
,
5879 spr_register(env
, SPR_SPRG4
, "SPRG4",
5880 SPR_NOACCESS
, SPR_NOACCESS
,
5881 &spr_read_generic
, &spr_write_generic
,
5883 spr_register(env
, SPR_USPRG4
, "USPRG4",
5884 &spr_read_ureg
, SPR_NOACCESS
,
5885 &spr_read_ureg
, SPR_NOACCESS
,
5887 spr_register(env
, SPR_SPRG5
, "SPRG5",
5888 SPR_NOACCESS
, SPR_NOACCESS
,
5889 &spr_read_generic
, &spr_write_generic
,
5891 spr_register(env
, SPR_USPRG5
, "USPRG5",
5892 &spr_read_ureg
, SPR_NOACCESS
,
5893 &spr_read_ureg
, SPR_NOACCESS
,
5895 spr_register(env
, SPR_SPRG6
, "SPRG6",
5896 SPR_NOACCESS
, SPR_NOACCESS
,
5897 &spr_read_generic
, &spr_write_generic
,
5899 spr_register(env
, SPR_USPRG6
, "USPRG6",
5900 &spr_read_ureg
, SPR_NOACCESS
,
5901 &spr_read_ureg
, SPR_NOACCESS
,
5903 spr_register(env
, SPR_SPRG7
, "SPRG7",
5904 SPR_NOACCESS
, SPR_NOACCESS
,
5905 &spr_read_generic
, &spr_write_generic
,
5907 spr_register(env
, SPR_USPRG7
, "USPRG7",
5908 &spr_read_ureg
, SPR_NOACCESS
,
5909 &spr_read_ureg
, SPR_NOACCESS
,
5911 /* Memory management */
5914 gen_74xx_soft_tlb(env
, 128, 2);
5915 init_excp_7450(env
);
5916 env
->dcache_line_size
= 32;
5917 env
->icache_line_size
= 32;
5918 /* Allocate hardware IRQ controller */
5919 ppc6xx_irq_init(env
);
5922 /* PowerPC 7455 (aka G4) */
5923 #define POWERPC_INSNS_7455 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
5924 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
5925 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
5926 PPC_FLOAT_STFIWX | \
5927 PPC_CACHE | PPC_CACHE_ICBI | \
5928 PPC_CACHE_DCBA | PPC_CACHE_DCBZ | \
5929 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
5930 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
5931 PPC_MEM_TLBIA | PPC_74xx_TLB | \
5932 PPC_SEGMENT | PPC_EXTERN | \
5934 #define POWERPC_INSNS2_7455 (PPC_NONE)
5935 #define POWERPC_MSRM_7455 (0x000000000205FF77ULL)
5936 #define POWERPC_MMU_7455 (POWERPC_MMU_SOFT_74xx)
5937 #define POWERPC_EXCP_7455 (POWERPC_EXCP_74xx)
5938 #define POWERPC_INPUT_7455 (PPC_FLAGS_INPUT_6xx)
5939 #define POWERPC_BFDM_7455 (bfd_mach_ppc_7400)
5940 #define POWERPC_FLAG_7455 (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
5941 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
5942 POWERPC_FLAG_BUS_CLK)
5943 #define check_pow_7455 check_pow_hid0_74xx
5945 __attribute__ (( unused
))
5946 static void init_proc_7455 (CPUPPCState
*env
)
5948 gen_spr_ne_601(env
);
5952 /* 74xx specific SPR */
5954 /* Level 3 cache control */
5957 /* XXX : not implemented */
5958 spr_register(env
, SPR_LDSTCR
, "LDSTCR",
5959 SPR_NOACCESS
, SPR_NOACCESS
,
5960 &spr_read_generic
, &spr_write_generic
,
5963 /* XXX : not implemented */
5964 spr_register(env
, SPR_ICTRL
, "ICTRL",
5965 SPR_NOACCESS
, SPR_NOACCESS
,
5966 &spr_read_generic
, &spr_write_generic
,
5969 /* XXX : not implemented */
5970 spr_register(env
, SPR_MSSSR0
, "MSSSR0",
5971 SPR_NOACCESS
, SPR_NOACCESS
,
5972 &spr_read_generic
, &spr_write_generic
,
5975 /* XXX : not implemented */
5976 spr_register(env
, SPR_PMC5
, "PMC5",
5977 SPR_NOACCESS
, SPR_NOACCESS
,
5978 &spr_read_generic
, &spr_write_generic
,
5980 /* XXX : not implemented */
5981 spr_register(env
, SPR_UPMC5
, "UPMC5",
5982 &spr_read_ureg
, SPR_NOACCESS
,
5983 &spr_read_ureg
, SPR_NOACCESS
,
5985 /* XXX : not implemented */
5986 spr_register(env
, SPR_PMC6
, "PMC6",
5987 SPR_NOACCESS
, SPR_NOACCESS
,
5988 &spr_read_generic
, &spr_write_generic
,
5990 /* XXX : not implemented */
5991 spr_register(env
, SPR_UPMC6
, "UPMC6",
5992 &spr_read_ureg
, SPR_NOACCESS
,
5993 &spr_read_ureg
, SPR_NOACCESS
,
5996 spr_register(env
, SPR_SPRG4
, "SPRG4",
5997 SPR_NOACCESS
, SPR_NOACCESS
,
5998 &spr_read_generic
, &spr_write_generic
,
6000 spr_register(env
, SPR_USPRG4
, "USPRG4",
6001 &spr_read_ureg
, SPR_NOACCESS
,
6002 &spr_read_ureg
, SPR_NOACCESS
,
6004 spr_register(env
, SPR_SPRG5
, "SPRG5",
6005 SPR_NOACCESS
, SPR_NOACCESS
,
6006 &spr_read_generic
, &spr_write_generic
,
6008 spr_register(env
, SPR_USPRG5
, "USPRG5",
6009 &spr_read_ureg
, SPR_NOACCESS
,
6010 &spr_read_ureg
, SPR_NOACCESS
,
6012 spr_register(env
, SPR_SPRG6
, "SPRG6",
6013 SPR_NOACCESS
, SPR_NOACCESS
,
6014 &spr_read_generic
, &spr_write_generic
,
6016 spr_register(env
, SPR_USPRG6
, "USPRG6",
6017 &spr_read_ureg
, SPR_NOACCESS
,
6018 &spr_read_ureg
, SPR_NOACCESS
,
6020 spr_register(env
, SPR_SPRG7
, "SPRG7",
6021 SPR_NOACCESS
, SPR_NOACCESS
,
6022 &spr_read_generic
, &spr_write_generic
,
6024 spr_register(env
, SPR_USPRG7
, "USPRG7",
6025 &spr_read_ureg
, SPR_NOACCESS
,
6026 &spr_read_ureg
, SPR_NOACCESS
,
6028 /* Memory management */
6031 gen_74xx_soft_tlb(env
, 128, 2);
6032 init_excp_7450(env
);
6033 env
->dcache_line_size
= 32;
6034 env
->icache_line_size
= 32;
6035 /* Allocate hardware IRQ controller */
6036 ppc6xx_irq_init(env
);
6039 /* PowerPC 7457 (aka G4) */
6040 #define POWERPC_INSNS_7457 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
6041 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
6042 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
6043 PPC_FLOAT_STFIWX | \
6044 PPC_CACHE | PPC_CACHE_ICBI | \
6045 PPC_CACHE_DCBA | PPC_CACHE_DCBZ | \
6046 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
6047 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
6048 PPC_MEM_TLBIA | PPC_74xx_TLB | \
6049 PPC_SEGMENT | PPC_EXTERN | \
6051 #define POWERPC_INSNS2_7457 (PPC_NONE)
6052 #define POWERPC_MSRM_7457 (0x000000000205FF77ULL)
6053 #define POWERPC_MMU_7457 (POWERPC_MMU_SOFT_74xx)
6054 #define POWERPC_EXCP_7457 (POWERPC_EXCP_74xx)
6055 #define POWERPC_INPUT_7457 (PPC_FLAGS_INPUT_6xx)
6056 #define POWERPC_BFDM_7457 (bfd_mach_ppc_7400)
6057 #define POWERPC_FLAG_7457 (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
6058 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
6059 POWERPC_FLAG_BUS_CLK)
6060 #define check_pow_7457 check_pow_hid0_74xx
6062 __attribute__ (( unused
))
6063 static void init_proc_7457 (CPUPPCState
*env
)
6065 gen_spr_ne_601(env
);
6069 /* 74xx specific SPR */
6071 /* Level 3 cache control */
6074 /* XXX : not implemented */
6075 spr_register(env
, SPR_L3ITCR1
, "L3ITCR1",
6076 SPR_NOACCESS
, SPR_NOACCESS
,
6077 &spr_read_generic
, &spr_write_generic
,
6080 /* XXX : not implemented */
6081 spr_register(env
, SPR_L3ITCR2
, "L3ITCR2",
6082 SPR_NOACCESS
, SPR_NOACCESS
,
6083 &spr_read_generic
, &spr_write_generic
,
6086 /* XXX : not implemented */
6087 spr_register(env
, SPR_L3ITCR3
, "L3ITCR3",
6088 SPR_NOACCESS
, SPR_NOACCESS
,
6089 &spr_read_generic
, &spr_write_generic
,
6092 /* XXX : not implemented */
6093 spr_register(env
, SPR_L3OHCR
, "L3OHCR",
6094 SPR_NOACCESS
, SPR_NOACCESS
,
6095 &spr_read_generic
, &spr_write_generic
,
6098 /* XXX : not implemented */
6099 spr_register(env
, SPR_LDSTCR
, "LDSTCR",
6100 SPR_NOACCESS
, SPR_NOACCESS
,
6101 &spr_read_generic
, &spr_write_generic
,
6104 /* XXX : not implemented */
6105 spr_register(env
, SPR_ICTRL
, "ICTRL",
6106 SPR_NOACCESS
, SPR_NOACCESS
,
6107 &spr_read_generic
, &spr_write_generic
,
6110 /* XXX : not implemented */
6111 spr_register(env
, SPR_MSSSR0
, "MSSSR0",
6112 SPR_NOACCESS
, SPR_NOACCESS
,
6113 &spr_read_generic
, &spr_write_generic
,
6116 /* XXX : not implemented */
6117 spr_register(env
, SPR_PMC5
, "PMC5",
6118 SPR_NOACCESS
, SPR_NOACCESS
,
6119 &spr_read_generic
, &spr_write_generic
,
6121 /* XXX : not implemented */
6122 spr_register(env
, SPR_UPMC5
, "UPMC5",
6123 &spr_read_ureg
, SPR_NOACCESS
,
6124 &spr_read_ureg
, SPR_NOACCESS
,
6126 /* XXX : not implemented */
6127 spr_register(env
, SPR_PMC6
, "PMC6",
6128 SPR_NOACCESS
, SPR_NOACCESS
,
6129 &spr_read_generic
, &spr_write_generic
,
6131 /* XXX : not implemented */
6132 spr_register(env
, SPR_UPMC6
, "UPMC6",
6133 &spr_read_ureg
, SPR_NOACCESS
,
6134 &spr_read_ureg
, SPR_NOACCESS
,
6137 spr_register(env
, SPR_SPRG4
, "SPRG4",
6138 SPR_NOACCESS
, SPR_NOACCESS
,
6139 &spr_read_generic
, &spr_write_generic
,
6141 spr_register(env
, SPR_USPRG4
, "USPRG4",
6142 &spr_read_ureg
, SPR_NOACCESS
,
6143 &spr_read_ureg
, SPR_NOACCESS
,
6145 spr_register(env
, SPR_SPRG5
, "SPRG5",
6146 SPR_NOACCESS
, SPR_NOACCESS
,
6147 &spr_read_generic
, &spr_write_generic
,
6149 spr_register(env
, SPR_USPRG5
, "USPRG5",
6150 &spr_read_ureg
, SPR_NOACCESS
,
6151 &spr_read_ureg
, SPR_NOACCESS
,
6153 spr_register(env
, SPR_SPRG6
, "SPRG6",
6154 SPR_NOACCESS
, SPR_NOACCESS
,
6155 &spr_read_generic
, &spr_write_generic
,
6157 spr_register(env
, SPR_USPRG6
, "USPRG6",
6158 &spr_read_ureg
, SPR_NOACCESS
,
6159 &spr_read_ureg
, SPR_NOACCESS
,
6161 spr_register(env
, SPR_SPRG7
, "SPRG7",
6162 SPR_NOACCESS
, SPR_NOACCESS
,
6163 &spr_read_generic
, &spr_write_generic
,
6165 spr_register(env
, SPR_USPRG7
, "USPRG7",
6166 &spr_read_ureg
, SPR_NOACCESS
,
6167 &spr_read_ureg
, SPR_NOACCESS
,
6169 /* Memory management */
6172 gen_74xx_soft_tlb(env
, 128, 2);
6173 init_excp_7450(env
);
6174 env
->dcache_line_size
= 32;
6175 env
->icache_line_size
= 32;
6176 /* Allocate hardware IRQ controller */
6177 ppc6xx_irq_init(env
);
6180 #if defined (TARGET_PPC64)
6182 #define POWERPC_INSNS_970 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
6183 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
6184 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
6185 PPC_FLOAT_STFIWX | \
6186 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZT | \
6187 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
6188 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
6189 PPC_64B | PPC_ALTIVEC | \
6190 PPC_SEGMENT_64B | PPC_SLBI)
6191 #define POWERPC_INSNS2_970 (PPC_NONE)
6192 #define POWERPC_MSRM_970 (0x900000000204FF36ULL)
6193 #define POWERPC_MMU_970 (POWERPC_MMU_64B)
6194 //#define POWERPC_EXCP_970 (POWERPC_EXCP_970)
6195 #define POWERPC_INPUT_970 (PPC_FLAGS_INPUT_970)
6196 #define POWERPC_BFDM_970 (bfd_mach_ppc64)
6197 #define POWERPC_FLAG_970 (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
6198 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
6199 POWERPC_FLAG_BUS_CLK)
6201 #if defined(CONFIG_USER_ONLY)
6202 #define POWERPC970_HID5_INIT 0x00000080
6204 #define POWERPC970_HID5_INIT 0x00000000
6207 static int check_pow_970 (CPUPPCState
*env
)
6209 if (env
->spr
[SPR_HID0
] & 0x00600000)
6215 static void init_proc_970 (CPUPPCState
*env
)
6217 gen_spr_ne_601(env
);
6221 /* Hardware implementation registers */
6222 /* XXX : not implemented */
6223 spr_register(env
, SPR_HID0
, "HID0",
6224 SPR_NOACCESS
, SPR_NOACCESS
,
6225 &spr_read_generic
, &spr_write_clear
,
6227 /* XXX : not implemented */
6228 spr_register(env
, SPR_HID1
, "HID1",
6229 SPR_NOACCESS
, SPR_NOACCESS
,
6230 &spr_read_generic
, &spr_write_generic
,
6232 /* XXX : not implemented */
6233 spr_register(env
, SPR_750FX_HID2
, "HID2",
6234 SPR_NOACCESS
, SPR_NOACCESS
,
6235 &spr_read_generic
, &spr_write_generic
,
6237 /* XXX : not implemented */
6238 spr_register(env
, SPR_970_HID5
, "HID5",
6239 SPR_NOACCESS
, SPR_NOACCESS
,
6240 &spr_read_generic
, &spr_write_generic
,
6241 POWERPC970_HID5_INIT
);
6242 /* XXX : not implemented */
6243 spr_register(env
, SPR_L2CR
, "L2CR",
6244 SPR_NOACCESS
, SPR_NOACCESS
,
6245 &spr_read_generic
, &spr_write_generic
,
6247 /* Memory management */
6248 /* XXX: not correct */
6250 /* XXX : not implemented */
6251 spr_register(env
, SPR_MMUCFG
, "MMUCFG",
6252 SPR_NOACCESS
, SPR_NOACCESS
,
6253 &spr_read_generic
, SPR_NOACCESS
,
6254 0x00000000); /* TOFIX */
6255 /* XXX : not implemented */
6256 spr_register(env
, SPR_MMUCSR0
, "MMUCSR0",
6257 SPR_NOACCESS
, SPR_NOACCESS
,
6258 &spr_read_generic
, &spr_write_generic
,
6259 0x00000000); /* TOFIX */
6260 spr_register(env
, SPR_HIOR
, "SPR_HIOR",
6261 SPR_NOACCESS
, SPR_NOACCESS
,
6262 &spr_read_hior
, &spr_write_hior
,
6264 #if !defined(CONFIG_USER_ONLY)
6268 env
->dcache_line_size
= 128;
6269 env
->icache_line_size
= 128;
6270 /* Allocate hardware IRQ controller */
6271 ppc970_irq_init(env
);
6272 /* Can't find information on what this should be on reset. This
6273 * value is the one used by 74xx processors. */
6274 vscr_init(env
, 0x00010000);
6277 /* PowerPC 970FX (aka G5) */
6278 #define POWERPC_INSNS_970FX (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
6279 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
6280 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
6281 PPC_FLOAT_STFIWX | \
6282 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZT | \
6283 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
6284 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
6285 PPC_64B | PPC_ALTIVEC | \
6286 PPC_SEGMENT_64B | PPC_SLBI)
6287 #define POWERPC_INSNS2_970FX (PPC_NONE)
6288 #define POWERPC_MSRM_970FX (0x800000000204FF36ULL)
6289 #define POWERPC_MMU_970FX (POWERPC_MMU_64B)
6290 #define POWERPC_EXCP_970FX (POWERPC_EXCP_970)
6291 #define POWERPC_INPUT_970FX (PPC_FLAGS_INPUT_970)
6292 #define POWERPC_BFDM_970FX (bfd_mach_ppc64)
6293 #define POWERPC_FLAG_970FX (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
6294 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
6295 POWERPC_FLAG_BUS_CLK)
6297 static int check_pow_970FX (CPUPPCState
*env
)
6299 if (env
->spr
[SPR_HID0
] & 0x00600000)
6305 static void init_proc_970FX (CPUPPCState
*env
)
6307 gen_spr_ne_601(env
);
6311 /* Hardware implementation registers */
6312 /* XXX : not implemented */
6313 spr_register(env
, SPR_HID0
, "HID0",
6314 SPR_NOACCESS
, SPR_NOACCESS
,
6315 &spr_read_generic
, &spr_write_clear
,
6317 /* XXX : not implemented */
6318 spr_register(env
, SPR_HID1
, "HID1",
6319 SPR_NOACCESS
, SPR_NOACCESS
,
6320 &spr_read_generic
, &spr_write_generic
,
6322 /* XXX : not implemented */
6323 spr_register(env
, SPR_750FX_HID2
, "HID2",
6324 SPR_NOACCESS
, SPR_NOACCESS
,
6325 &spr_read_generic
, &spr_write_generic
,
6327 /* XXX : not implemented */
6328 spr_register(env
, SPR_970_HID5
, "HID5",
6329 SPR_NOACCESS
, SPR_NOACCESS
,
6330 &spr_read_generic
, &spr_write_generic
,
6331 POWERPC970_HID5_INIT
);
6332 /* XXX : not implemented */
6333 spr_register(env
, SPR_L2CR
, "L2CR",
6334 SPR_NOACCESS
, SPR_NOACCESS
,
6335 &spr_read_generic
, &spr_write_generic
,
6337 /* Memory management */
6338 /* XXX: not correct */
6340 /* XXX : not implemented */
6341 spr_register(env
, SPR_MMUCFG
, "MMUCFG",
6342 SPR_NOACCESS
, SPR_NOACCESS
,
6343 &spr_read_generic
, SPR_NOACCESS
,
6344 0x00000000); /* TOFIX */
6345 /* XXX : not implemented */
6346 spr_register(env
, SPR_MMUCSR0
, "MMUCSR0",
6347 SPR_NOACCESS
, SPR_NOACCESS
,
6348 &spr_read_generic
, &spr_write_generic
,
6349 0x00000000); /* TOFIX */
6350 spr_register(env
, SPR_HIOR
, "SPR_HIOR",
6351 SPR_NOACCESS
, SPR_NOACCESS
,
6352 &spr_read_hior
, &spr_write_hior
,
6354 spr_register(env
, SPR_CTRL
, "SPR_CTRL",
6355 SPR_NOACCESS
, SPR_NOACCESS
,
6356 &spr_read_generic
, &spr_write_generic
,
6358 spr_register(env
, SPR_UCTRL
, "SPR_UCTRL",
6359 SPR_NOACCESS
, SPR_NOACCESS
,
6360 &spr_read_generic
, &spr_write_generic
,
6362 spr_register(env
, SPR_VRSAVE
, "SPR_VRSAVE",
6363 &spr_read_generic
, &spr_write_generic
,
6364 &spr_read_generic
, &spr_write_generic
,
6366 #if !defined(CONFIG_USER_ONLY)
6370 env
->dcache_line_size
= 128;
6371 env
->icache_line_size
= 128;
6372 /* Allocate hardware IRQ controller */
6373 ppc970_irq_init(env
);
6374 /* Can't find information on what this should be on reset. This
6375 * value is the one used by 74xx processors. */
6376 vscr_init(env
, 0x00010000);
6379 /* PowerPC 970 GX */
6380 #define POWERPC_INSNS_970GX (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
6381 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
6382 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
6383 PPC_FLOAT_STFIWX | \
6384 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZT | \
6385 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
6386 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
6387 PPC_64B | PPC_ALTIVEC | \
6388 PPC_SEGMENT_64B | PPC_SLBI)
6389 #define POWERPC_INSNS2_970GX (PPC_NONE)
6390 #define POWERPC_MSRM_970GX (0x800000000204FF36ULL)
6391 #define POWERPC_MMU_970GX (POWERPC_MMU_64B)
6392 #define POWERPC_EXCP_970GX (POWERPC_EXCP_970)
6393 #define POWERPC_INPUT_970GX (PPC_FLAGS_INPUT_970)
6394 #define POWERPC_BFDM_970GX (bfd_mach_ppc64)
6395 #define POWERPC_FLAG_970GX (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
6396 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
6397 POWERPC_FLAG_BUS_CLK)
6399 static int check_pow_970GX (CPUPPCState
*env
)
6401 if (env
->spr
[SPR_HID0
] & 0x00600000)
6407 static void init_proc_970GX (CPUPPCState
*env
)
6409 gen_spr_ne_601(env
);
6413 /* Hardware implementation registers */
6414 /* XXX : not implemented */
6415 spr_register(env
, SPR_HID0
, "HID0",
6416 SPR_NOACCESS
, SPR_NOACCESS
,
6417 &spr_read_generic
, &spr_write_clear
,
6419 /* XXX : not implemented */
6420 spr_register(env
, SPR_HID1
, "HID1",
6421 SPR_NOACCESS
, SPR_NOACCESS
,
6422 &spr_read_generic
, &spr_write_generic
,
6424 /* XXX : not implemented */
6425 spr_register(env
, SPR_750FX_HID2
, "HID2",
6426 SPR_NOACCESS
, SPR_NOACCESS
,
6427 &spr_read_generic
, &spr_write_generic
,
6429 /* XXX : not implemented */
6430 spr_register(env
, SPR_970_HID5
, "HID5",
6431 SPR_NOACCESS
, SPR_NOACCESS
,
6432 &spr_read_generic
, &spr_write_generic
,
6433 POWERPC970_HID5_INIT
);
6434 /* XXX : not implemented */
6435 spr_register(env
, SPR_L2CR
, "L2CR",
6436 SPR_NOACCESS
, SPR_NOACCESS
,
6437 &spr_read_generic
, &spr_write_generic
,
6439 /* Memory management */
6440 /* XXX: not correct */
6442 /* XXX : not implemented */
6443 spr_register(env
, SPR_MMUCFG
, "MMUCFG",
6444 SPR_NOACCESS
, SPR_NOACCESS
,
6445 &spr_read_generic
, SPR_NOACCESS
,
6446 0x00000000); /* TOFIX */
6447 /* XXX : not implemented */
6448 spr_register(env
, SPR_MMUCSR0
, "MMUCSR0",
6449 SPR_NOACCESS
, SPR_NOACCESS
,
6450 &spr_read_generic
, &spr_write_generic
,
6451 0x00000000); /* TOFIX */
6452 spr_register(env
, SPR_HIOR
, "SPR_HIOR",
6453 SPR_NOACCESS
, SPR_NOACCESS
,
6454 &spr_read_hior
, &spr_write_hior
,
6456 #if !defined(CONFIG_USER_ONLY)
6460 env
->dcache_line_size
= 128;
6461 env
->icache_line_size
= 128;
6462 /* Allocate hardware IRQ controller */
6463 ppc970_irq_init(env
);
6464 /* Can't find information on what this should be on reset. This
6465 * value is the one used by 74xx processors. */
6466 vscr_init(env
, 0x00010000);
6469 /* PowerPC 970 MP */
6470 #define POWERPC_INSNS_970MP (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
6471 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
6472 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
6473 PPC_FLOAT_STFIWX | \
6474 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZT | \
6475 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
6476 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
6477 PPC_64B | PPC_ALTIVEC | \
6478 PPC_SEGMENT_64B | PPC_SLBI)
6479 #define POWERPC_INSNS2_970MP (PPC_NONE)
6480 #define POWERPC_MSRM_970MP (0x900000000204FF36ULL)
6481 #define POWERPC_MMU_970MP (POWERPC_MMU_64B)
6482 #define POWERPC_EXCP_970MP (POWERPC_EXCP_970)
6483 #define POWERPC_INPUT_970MP (PPC_FLAGS_INPUT_970)
6484 #define POWERPC_BFDM_970MP (bfd_mach_ppc64)
6485 #define POWERPC_FLAG_970MP (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
6486 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
6487 POWERPC_FLAG_BUS_CLK)
6489 static int check_pow_970MP (CPUPPCState
*env
)
6491 if (env
->spr
[SPR_HID0
] & 0x01C00000)
6497 static void init_proc_970MP (CPUPPCState
*env
)
6499 gen_spr_ne_601(env
);
6503 /* Hardware implementation registers */
6504 /* XXX : not implemented */
6505 spr_register(env
, SPR_HID0
, "HID0",
6506 SPR_NOACCESS
, SPR_NOACCESS
,
6507 &spr_read_generic
, &spr_write_clear
,
6509 /* XXX : not implemented */
6510 spr_register(env
, SPR_HID1
, "HID1",
6511 SPR_NOACCESS
, SPR_NOACCESS
,
6512 &spr_read_generic
, &spr_write_generic
,
6514 /* XXX : not implemented */
6515 spr_register(env
, SPR_750FX_HID2
, "HID2",
6516 SPR_NOACCESS
, SPR_NOACCESS
,
6517 &spr_read_generic
, &spr_write_generic
,
6519 /* XXX : not implemented */
6520 spr_register(env
, SPR_970_HID5
, "HID5",
6521 SPR_NOACCESS
, SPR_NOACCESS
,
6522 &spr_read_generic
, &spr_write_generic
,
6523 POWERPC970_HID5_INIT
);
6524 /* XXX : not implemented */
6525 spr_register(env
, SPR_L2CR
, "L2CR",
6526 SPR_NOACCESS
, SPR_NOACCESS
,
6527 &spr_read_generic
, &spr_write_generic
,
6529 /* Memory management */
6530 /* XXX: not correct */
6532 /* XXX : not implemented */
6533 spr_register(env
, SPR_MMUCFG
, "MMUCFG",
6534 SPR_NOACCESS
, SPR_NOACCESS
,
6535 &spr_read_generic
, SPR_NOACCESS
,
6536 0x00000000); /* TOFIX */
6537 /* XXX : not implemented */
6538 spr_register(env
, SPR_MMUCSR0
, "MMUCSR0",
6539 SPR_NOACCESS
, SPR_NOACCESS
,
6540 &spr_read_generic
, &spr_write_generic
,
6541 0x00000000); /* TOFIX */
6542 spr_register(env
, SPR_HIOR
, "SPR_HIOR",
6543 SPR_NOACCESS
, SPR_NOACCESS
,
6544 &spr_read_hior
, &spr_write_hior
,
6546 #if !defined(CONFIG_USER_ONLY)
6550 env
->dcache_line_size
= 128;
6551 env
->icache_line_size
= 128;
6552 /* Allocate hardware IRQ controller */
6553 ppc970_irq_init(env
);
6554 /* Can't find information on what this should be on reset. This
6555 * value is the one used by 74xx processors. */
6556 vscr_init(env
, 0x00010000);
6559 #if defined(TARGET_PPC64)
6561 #define POWERPC_INSNS_POWER7 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
6562 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
6563 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
6564 PPC_FLOAT_STFIWX | \
6565 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZT | \
6566 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
6567 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
6568 PPC_64B | PPC_ALTIVEC | \
6569 PPC_SEGMENT_64B | PPC_SLBI | \
6570 PPC_POPCNTB | PPC_POPCNTWD)
6571 #define POWERPC_INSNS2_POWER7 (PPC2_VSX | PPC2_DFP)
6572 #define POWERPC_MSRM_POWER7 (0x800000000204FF36ULL)
6573 #define POWERPC_MMU_POWER7 (POWERPC_MMU_2_06)
6574 #define POWERPC_EXCP_POWER7 (POWERPC_EXCP_POWER7)
6575 #define POWERPC_INPUT_POWER7 (PPC_FLAGS_INPUT_POWER7)
6576 #define POWERPC_BFDM_POWER7 (bfd_mach_ppc64)
6577 #define POWERPC_FLAG_POWER7 (POWERPC_FLAG_VRE | POWERPC_FLAG_SE | \
6578 POWERPC_FLAG_BE | POWERPC_FLAG_PMM | \
6579 POWERPC_FLAG_BUS_CLK | POWERPC_FLAG_CFAR)
6580 #define check_pow_POWER7 check_pow_nocheck
6582 static void init_proc_POWER7 (CPUPPCState
*env
)
6584 gen_spr_ne_601(env
);
6588 #if !defined(CONFIG_USER_ONLY)
6589 /* PURR & SPURR: Hack - treat these as aliases for the TB for now */
6590 spr_register(env
, SPR_PURR
, "PURR",
6591 &spr_read_purr
, SPR_NOACCESS
,
6592 &spr_read_purr
, SPR_NOACCESS
,
6594 spr_register(env
, SPR_SPURR
, "SPURR",
6595 &spr_read_purr
, SPR_NOACCESS
,
6596 &spr_read_purr
, SPR_NOACCESS
,
6598 spr_register(env
, SPR_CFAR
, "SPR_CFAR",
6599 SPR_NOACCESS
, SPR_NOACCESS
,
6600 &spr_read_cfar
, &spr_write_cfar
,
6602 spr_register(env
, SPR_DSCR
, "SPR_DSCR",
6603 SPR_NOACCESS
, SPR_NOACCESS
,
6604 &spr_read_generic
, &spr_write_generic
,
6606 #endif /* !CONFIG_USER_ONLY */
6607 /* Memory management */
6608 /* XXX : not implemented */
6609 spr_register(env
, SPR_MMUCFG
, "MMUCFG",
6610 SPR_NOACCESS
, SPR_NOACCESS
,
6611 &spr_read_generic
, SPR_NOACCESS
,
6612 0x00000000); /* TOFIX */
6613 /* XXX : not implemented */
6614 spr_register(env
, SPR_CTRL
, "SPR_CTRLT",
6615 SPR_NOACCESS
, SPR_NOACCESS
,
6616 &spr_read_generic
, &spr_write_generic
,
6618 spr_register(env
, SPR_UCTRL
, "SPR_CTRLF",
6619 SPR_NOACCESS
, SPR_NOACCESS
,
6620 &spr_read_generic
, &spr_write_generic
,
6622 spr_register(env
, SPR_VRSAVE
, "SPR_VRSAVE",
6623 &spr_read_generic
, &spr_write_generic
,
6624 &spr_read_generic
, &spr_write_generic
,
6626 #if !defined(CONFIG_USER_ONLY)
6629 init_excp_POWER7(env
);
6630 env
->dcache_line_size
= 128;
6631 env
->icache_line_size
= 128;
6632 /* Allocate hardware IRQ controller */
6633 ppcPOWER7_irq_init(env
);
6634 /* Can't find information on what this should be on reset. This
6635 * value is the one used by 74xx processors. */
6636 vscr_init(env
, 0x00010000);
6638 #endif /* TARGET_PPC64 */
6641 #define POWERPC_INSNS_620 (PPC_INSNS_BASE | PPC_STRING | PPC_MFTB | \
6642 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES | \
6643 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE | \
6644 PPC_FLOAT_STFIWX | \
6645 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ | \
6646 PPC_MEM_SYNC | PPC_MEM_EIEIO | \
6647 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | \
6648 PPC_SEGMENT | PPC_EXTERN | \
6650 #define POWERPC_INSNS2_620 (PPC_NONE)
6651 #define POWERPC_MSRM_620 (0x800000000005FF77ULL)
6652 //#define POWERPC_MMU_620 (POWERPC_MMU_620)
6653 #define POWERPC_EXCP_620 (POWERPC_EXCP_970)
6654 #define POWERPC_INPUT_620 (PPC_FLAGS_INPUT_6xx)
6655 #define POWERPC_BFDM_620 (bfd_mach_ppc64)
6656 #define POWERPC_FLAG_620 (POWERPC_FLAG_SE | POWERPC_FLAG_BE | \
6657 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK)
6658 #define check_pow_620 check_pow_nocheck /* Check this */
6660 __attribute__ (( unused
))
6661 static void init_proc_620 (CPUPPCState
*env
)
6663 gen_spr_ne_601(env
);
6667 /* Hardware implementation registers */
6668 /* XXX : not implemented */
6669 spr_register(env
, SPR_HID0
, "HID0",
6670 SPR_NOACCESS
, SPR_NOACCESS
,
6671 &spr_read_generic
, &spr_write_generic
,
6673 /* Memory management */
6676 env
->dcache_line_size
= 64;
6677 env
->icache_line_size
= 64;
6678 /* Allocate hardware IRQ controller */
6679 ppc6xx_irq_init(env
);
6681 #endif /* defined (TARGET_PPC64) */
6683 /* Default 32 bits PowerPC target will be 604 */
6684 #define CPU_POWERPC_PPC32 CPU_POWERPC_604
6685 #define POWERPC_INSNS_PPC32 POWERPC_INSNS_604
6686 #define POWERPC_INSNS2_PPC32 POWERPC_INSNS2_604
6687 #define POWERPC_MSRM_PPC32 POWERPC_MSRM_604
6688 #define POWERPC_MMU_PPC32 POWERPC_MMU_604
6689 #define POWERPC_EXCP_PPC32 POWERPC_EXCP_604
6690 #define POWERPC_INPUT_PPC32 POWERPC_INPUT_604
6691 #define POWERPC_BFDM_PPC32 POWERPC_BFDM_604
6692 #define POWERPC_FLAG_PPC32 POWERPC_FLAG_604
6693 #define check_pow_PPC32 check_pow_604
6694 #define init_proc_PPC32 init_proc_604
6696 /* Default 64 bits PowerPC target will be 970 FX */
6697 #define CPU_POWERPC_PPC64 CPU_POWERPC_970FX
6698 #define POWERPC_INSNS_PPC64 POWERPC_INSNS_970FX
6699 #define POWERPC_INSNS2_PPC64 POWERPC_INSNS2_970FX
6700 #define POWERPC_MSRM_PPC64 POWERPC_MSRM_970FX
6701 #define POWERPC_MMU_PPC64 POWERPC_MMU_970FX
6702 #define POWERPC_EXCP_PPC64 POWERPC_EXCP_970FX
6703 #define POWERPC_INPUT_PPC64 POWERPC_INPUT_970FX
6704 #define POWERPC_BFDM_PPC64 POWERPC_BFDM_970FX
6705 #define POWERPC_FLAG_PPC64 POWERPC_FLAG_970FX
6706 #define check_pow_PPC64 check_pow_970FX
6707 #define init_proc_PPC64 init_proc_970FX
6709 /* Default PowerPC target will be PowerPC 32 */
6710 #if defined (TARGET_PPC64) && 0 // XXX: TODO
6711 #define CPU_POWERPC_DEFAULT CPU_POWERPC_PPC64
6712 #define POWERPC_INSNS_DEFAULT POWERPC_INSNS_PPC64
6713 #define POWERPC_INSNS2_DEFAULT POWERPC_INSNS_PPC64
6714 #define POWERPC_MSRM_DEFAULT POWERPC_MSRM_PPC64
6715 #define POWERPC_MMU_DEFAULT POWERPC_MMU_PPC64
6716 #define POWERPC_EXCP_DEFAULT POWERPC_EXCP_PPC64
6717 #define POWERPC_INPUT_DEFAULT POWERPC_INPUT_PPC64
6718 #define POWERPC_BFDM_DEFAULT POWERPC_BFDM_PPC64
6719 #define POWERPC_FLAG_DEFAULT POWERPC_FLAG_PPC64
6720 #define check_pow_DEFAULT check_pow_PPC64
6721 #define init_proc_DEFAULT init_proc_PPC64
6723 #define CPU_POWERPC_DEFAULT CPU_POWERPC_PPC32
6724 #define POWERPC_INSNS_DEFAULT POWERPC_INSNS_PPC32
6725 #define POWERPC_INSNS2_DEFAULT POWERPC_INSNS_PPC32
6726 #define POWERPC_MSRM_DEFAULT POWERPC_MSRM_PPC32
6727 #define POWERPC_MMU_DEFAULT POWERPC_MMU_PPC32
6728 #define POWERPC_EXCP_DEFAULT POWERPC_EXCP_PPC32
6729 #define POWERPC_INPUT_DEFAULT POWERPC_INPUT_PPC32
6730 #define POWERPC_BFDM_DEFAULT POWERPC_BFDM_PPC32
6731 #define POWERPC_FLAG_DEFAULT POWERPC_FLAG_PPC32
6732 #define check_pow_DEFAULT check_pow_PPC32
6733 #define init_proc_DEFAULT init_proc_PPC32
6736 /*****************************************************************************/
6737 /* PVR definitions for most known PowerPC */
6739 /* PowerPC 401 family */
6740 /* Generic PowerPC 401 */
6741 #define CPU_POWERPC_401 CPU_POWERPC_401G2
6742 /* PowerPC 401 cores */
6743 CPU_POWERPC_401A1
= 0x00210000,
6744 CPU_POWERPC_401B2
= 0x00220000,
6746 CPU_POWERPC_401B3
= xxx
,
6748 CPU_POWERPC_401C2
= 0x00230000,
6749 CPU_POWERPC_401D2
= 0x00240000,
6750 CPU_POWERPC_401E2
= 0x00250000,
6751 CPU_POWERPC_401F2
= 0x00260000,
6752 CPU_POWERPC_401G2
= 0x00270000,
6753 /* PowerPC 401 microcontrolers */
6755 CPU_POWERPC_401GF
= xxx
,
6757 #define CPU_POWERPC_IOP480 CPU_POWERPC_401B2
6758 /* IBM Processor for Network Resources */
6759 CPU_POWERPC_COBRA
= 0x10100000, /* XXX: 405 ? */
6761 CPU_POWERPC_XIPCHIP
= xxx
,
6763 /* PowerPC 403 family */
6764 /* Generic PowerPC 403 */
6765 #define CPU_POWERPC_403 CPU_POWERPC_403GC
6766 /* PowerPC 403 microcontrollers */
6767 CPU_POWERPC_403GA
= 0x00200011,
6768 CPU_POWERPC_403GB
= 0x00200100,
6769 CPU_POWERPC_403GC
= 0x00200200,
6770 CPU_POWERPC_403GCX
= 0x00201400,
6772 CPU_POWERPC_403GP
= xxx
,
6774 /* PowerPC 405 family */
6775 /* Generic PowerPC 405 */
6776 #define CPU_POWERPC_405 CPU_POWERPC_405D4
6777 /* PowerPC 405 cores */
6779 CPU_POWERPC_405A3
= xxx
,
6782 CPU_POWERPC_405A4
= xxx
,
6785 CPU_POWERPC_405B3
= xxx
,
6788 CPU_POWERPC_405B4
= xxx
,
6791 CPU_POWERPC_405C3
= xxx
,
6794 CPU_POWERPC_405C4
= xxx
,
6796 CPU_POWERPC_405D2
= 0x20010000,
6798 CPU_POWERPC_405D3
= xxx
,
6800 CPU_POWERPC_405D4
= 0x41810000,
6802 CPU_POWERPC_405D5
= xxx
,
6805 CPU_POWERPC_405E4
= xxx
,
6808 CPU_POWERPC_405F4
= xxx
,
6811 CPU_POWERPC_405F5
= xxx
,
6814 CPU_POWERPC_405F6
= xxx
,
6816 /* PowerPC 405 microcontrolers */
6817 /* XXX: missing 0x200108a0 */
6818 #define CPU_POWERPC_405CR CPU_POWERPC_405CRc
6819 CPU_POWERPC_405CRa
= 0x40110041,
6820 CPU_POWERPC_405CRb
= 0x401100C5,
6821 CPU_POWERPC_405CRc
= 0x40110145,
6822 CPU_POWERPC_405EP
= 0x51210950,
6824 CPU_POWERPC_405EXr
= xxx
,
6826 CPU_POWERPC_405EZ
= 0x41511460, /* 0x51210950 ? */
6828 CPU_POWERPC_405FX
= xxx
,
6830 #define CPU_POWERPC_405GP CPU_POWERPC_405GPd
6831 CPU_POWERPC_405GPa
= 0x40110000,
6832 CPU_POWERPC_405GPb
= 0x40110040,
6833 CPU_POWERPC_405GPc
= 0x40110082,
6834 CPU_POWERPC_405GPd
= 0x401100C4,
6835 #define CPU_POWERPC_405GPe CPU_POWERPC_405CRc
6836 CPU_POWERPC_405GPR
= 0x50910951,
6838 CPU_POWERPC_405H
= xxx
,
6841 CPU_POWERPC_405L
= xxx
,
6843 CPU_POWERPC_405LP
= 0x41F10000,
6845 CPU_POWERPC_405PM
= xxx
,
6848 CPU_POWERPC_405PS
= xxx
,
6851 CPU_POWERPC_405S
= xxx
,
6853 /* IBM network processors */
6854 CPU_POWERPC_NPE405H
= 0x414100C0,
6855 CPU_POWERPC_NPE405H2
= 0x41410140,
6856 CPU_POWERPC_NPE405L
= 0x416100C0,
6857 CPU_POWERPC_NPE4GS3
= 0x40B10000,
6859 CPU_POWERPC_NPCxx1
= xxx
,
6862 CPU_POWERPC_NPR161
= xxx
,
6865 CPU_POWERPC_LC77700
= xxx
,
6867 /* IBM STBxxx (PowerPC 401/403/405 core based microcontrollers) */
6869 CPU_POWERPC_STB01000
= xxx
,
6872 CPU_POWERPC_STB01010
= xxx
,
6875 CPU_POWERPC_STB0210
= xxx
, /* 401B3 */
6877 CPU_POWERPC_STB03
= 0x40310000, /* 0x40130000 ? */
6879 CPU_POWERPC_STB043
= xxx
,
6882 CPU_POWERPC_STB045
= xxx
,
6884 CPU_POWERPC_STB04
= 0x41810000,
6885 CPU_POWERPC_STB25
= 0x51510950,
6887 CPU_POWERPC_STB130
= xxx
,
6890 CPU_POWERPC_X2VP4
= 0x20010820,
6891 #define CPU_POWERPC_X2VP7 CPU_POWERPC_X2VP4
6892 CPU_POWERPC_X2VP20
= 0x20010860,
6893 #define CPU_POWERPC_X2VP50 CPU_POWERPC_X2VP20
6895 CPU_POWERPC_ZL10310
= xxx
,
6898 CPU_POWERPC_ZL10311
= xxx
,
6901 CPU_POWERPC_ZL10320
= xxx
,
6904 CPU_POWERPC_ZL10321
= xxx
,
6906 /* PowerPC 440 family */
6907 /* Generic PowerPC 440 */
6908 #define CPU_POWERPC_440 CPU_POWERPC_440GXf
6909 /* PowerPC 440 cores */
6911 CPU_POWERPC_440A4
= xxx
,
6913 CPU_POWERPC_440_XILINX
= 0x7ff21910,
6915 CPU_POWERPC_440A5
= xxx
,
6918 CPU_POWERPC_440B4
= xxx
,
6921 CPU_POWERPC_440F5
= xxx
,
6924 CPU_POWERPC_440G5
= xxx
,
6927 CPU_POWERPC_440H4
= xxx
,
6930 CPU_POWERPC_440H6
= xxx
,
6932 /* PowerPC 440 microcontrolers */
6933 #define CPU_POWERPC_440EP CPU_POWERPC_440EPb
6934 CPU_POWERPC_440EPa
= 0x42221850,
6935 CPU_POWERPC_440EPb
= 0x422218D3,
6936 #define CPU_POWERPC_440GP CPU_POWERPC_440GPc
6937 CPU_POWERPC_440GPb
= 0x40120440,
6938 CPU_POWERPC_440GPc
= 0x40120481,
6939 #define CPU_POWERPC_440GR CPU_POWERPC_440GRa
6940 #define CPU_POWERPC_440GRa CPU_POWERPC_440EPb
6941 CPU_POWERPC_440GRX
= 0x200008D0,
6942 #define CPU_POWERPC_440EPX CPU_POWERPC_440GRX
6943 #define CPU_POWERPC_440GX CPU_POWERPC_440GXf
6944 CPU_POWERPC_440GXa
= 0x51B21850,
6945 CPU_POWERPC_440GXb
= 0x51B21851,
6946 CPU_POWERPC_440GXc
= 0x51B21892,
6947 CPU_POWERPC_440GXf
= 0x51B21894,
6949 CPU_POWERPC_440S
= xxx
,
6951 CPU_POWERPC_440SP
= 0x53221850,
6952 CPU_POWERPC_440SP2
= 0x53221891,
6953 CPU_POWERPC_440SPE
= 0x53421890,
6954 /* PowerPC 460 family */
6956 /* Generic PowerPC 464 */
6957 #define CPU_POWERPC_464 CPU_POWERPC_464H90
6959 /* PowerPC 464 microcontrolers */
6961 CPU_POWERPC_464H90
= xxx
,
6964 CPU_POWERPC_464H90FP
= xxx
,
6966 /* Freescale embedded PowerPC cores */
6967 /* PowerPC MPC 5xx cores (aka RCPU) */
6968 CPU_POWERPC_MPC5xx
= 0x00020020,
6969 #define CPU_POWERPC_MGT560 CPU_POWERPC_MPC5xx
6970 #define CPU_POWERPC_MPC509 CPU_POWERPC_MPC5xx
6971 #define CPU_POWERPC_MPC533 CPU_POWERPC_MPC5xx
6972 #define CPU_POWERPC_MPC534 CPU_POWERPC_MPC5xx
6973 #define CPU_POWERPC_MPC555 CPU_POWERPC_MPC5xx
6974 #define CPU_POWERPC_MPC556 CPU_POWERPC_MPC5xx
6975 #define CPU_POWERPC_MPC560 CPU_POWERPC_MPC5xx
6976 #define CPU_POWERPC_MPC561 CPU_POWERPC_MPC5xx
6977 #define CPU_POWERPC_MPC562 CPU_POWERPC_MPC5xx
6978 #define CPU_POWERPC_MPC563 CPU_POWERPC_MPC5xx
6979 #define CPU_POWERPC_MPC564 CPU_POWERPC_MPC5xx
6980 #define CPU_POWERPC_MPC565 CPU_POWERPC_MPC5xx
6981 #define CPU_POWERPC_MPC566 CPU_POWERPC_MPC5xx
6982 /* PowerPC MPC 8xx cores (aka PowerQUICC) */
6983 CPU_POWERPC_MPC8xx
= 0x00500000,
6984 #define CPU_POWERPC_MGT823 CPU_POWERPC_MPC8xx
6985 #define CPU_POWERPC_MPC821 CPU_POWERPC_MPC8xx
6986 #define CPU_POWERPC_MPC823 CPU_POWERPC_MPC8xx
6987 #define CPU_POWERPC_MPC850 CPU_POWERPC_MPC8xx
6988 #define CPU_POWERPC_MPC852T CPU_POWERPC_MPC8xx
6989 #define CPU_POWERPC_MPC855T CPU_POWERPC_MPC8xx
6990 #define CPU_POWERPC_MPC857 CPU_POWERPC_MPC8xx
6991 #define CPU_POWERPC_MPC859 CPU_POWERPC_MPC8xx
6992 #define CPU_POWERPC_MPC860 CPU_POWERPC_MPC8xx
6993 #define CPU_POWERPC_MPC862 CPU_POWERPC_MPC8xx
6994 #define CPU_POWERPC_MPC866 CPU_POWERPC_MPC8xx
6995 #define CPU_POWERPC_MPC870 CPU_POWERPC_MPC8xx
6996 #define CPU_POWERPC_MPC875 CPU_POWERPC_MPC8xx
6997 #define CPU_POWERPC_MPC880 CPU_POWERPC_MPC8xx
6998 #define CPU_POWERPC_MPC885 CPU_POWERPC_MPC8xx
6999 /* G2 cores (aka PowerQUICC-II) */
7000 CPU_POWERPC_G2
= 0x00810011,
7001 CPU_POWERPC_G2H4
= 0x80811010,
7002 CPU_POWERPC_G2gp
= 0x80821010,
7003 CPU_POWERPC_G2ls
= 0x90810010,
7004 CPU_POWERPC_MPC603
= 0x00810100,
7005 CPU_POWERPC_G2_HIP3
= 0x00810101,
7006 CPU_POWERPC_G2_HIP4
= 0x80811014,
7007 /* G2_LE core (aka PowerQUICC-II) */
7008 CPU_POWERPC_G2LE
= 0x80820010,
7009 CPU_POWERPC_G2LEgp
= 0x80822010,
7010 CPU_POWERPC_G2LEls
= 0xA0822010,
7011 CPU_POWERPC_G2LEgp1
= 0x80822011,
7012 CPU_POWERPC_G2LEgp3
= 0x80822013,
7013 /* MPC52xx microcontrollers */
7014 /* XXX: MPC 5121 ? */
7015 #define CPU_POWERPC_MPC52xx CPU_POWERPC_MPC5200
7016 #define CPU_POWERPC_MPC5200 CPU_POWERPC_MPC5200_v12
7017 #define CPU_POWERPC_MPC5200_v10 CPU_POWERPC_G2LEgp1
7018 #define CPU_POWERPC_MPC5200_v11 CPU_POWERPC_G2LEgp1
7019 #define CPU_POWERPC_MPC5200_v12 CPU_POWERPC_G2LEgp1
7020 #define CPU_POWERPC_MPC5200B CPU_POWERPC_MPC5200B_v21
7021 #define CPU_POWERPC_MPC5200B_v20 CPU_POWERPC_G2LEgp1
7022 #define CPU_POWERPC_MPC5200B_v21 CPU_POWERPC_G2LEgp1
7023 /* MPC82xx microcontrollers */
7024 #define CPU_POWERPC_MPC82xx CPU_POWERPC_MPC8280
7025 #define CPU_POWERPC_MPC8240 CPU_POWERPC_MPC603
7026 #define CPU_POWERPC_MPC8241 CPU_POWERPC_G2_HIP4
7027 #define CPU_POWERPC_MPC8245 CPU_POWERPC_G2_HIP4
7028 #define CPU_POWERPC_MPC8247 CPU_POWERPC_G2LEgp3
7029 #define CPU_POWERPC_MPC8248 CPU_POWERPC_G2LEgp3
7030 #define CPU_POWERPC_MPC8250 CPU_POWERPC_MPC8250_HiP4
7031 #define CPU_POWERPC_MPC8250_HiP3 CPU_POWERPC_G2_HIP3
7032 #define CPU_POWERPC_MPC8250_HiP4 CPU_POWERPC_G2_HIP4
7033 #define CPU_POWERPC_MPC8255 CPU_POWERPC_MPC8255_HiP4
7034 #define CPU_POWERPC_MPC8255_HiP3 CPU_POWERPC_G2_HIP3
7035 #define CPU_POWERPC_MPC8255_HiP4 CPU_POWERPC_G2_HIP4
7036 #define CPU_POWERPC_MPC8260 CPU_POWERPC_MPC8260_HiP4
7037 #define CPU_POWERPC_MPC8260_HiP3 CPU_POWERPC_G2_HIP3
7038 #define CPU_POWERPC_MPC8260_HiP4 CPU_POWERPC_G2_HIP4
7039 #define CPU_POWERPC_MPC8264 CPU_POWERPC_MPC8264_HiP4
7040 #define CPU_POWERPC_MPC8264_HiP3 CPU_POWERPC_G2_HIP3
7041 #define CPU_POWERPC_MPC8264_HiP4 CPU_POWERPC_G2_HIP4
7042 #define CPU_POWERPC_MPC8265 CPU_POWERPC_MPC8265_HiP4
7043 #define CPU_POWERPC_MPC8265_HiP3 CPU_POWERPC_G2_HIP3
7044 #define CPU_POWERPC_MPC8265_HiP4 CPU_POWERPC_G2_HIP4
7045 #define CPU_POWERPC_MPC8266 CPU_POWERPC_MPC8266_HiP4
7046 #define CPU_POWERPC_MPC8266_HiP3 CPU_POWERPC_G2_HIP3
7047 #define CPU_POWERPC_MPC8266_HiP4 CPU_POWERPC_G2_HIP4
7048 #define CPU_POWERPC_MPC8270 CPU_POWERPC_G2LEgp3
7049 #define CPU_POWERPC_MPC8271 CPU_POWERPC_G2LEgp3
7050 #define CPU_POWERPC_MPC8272 CPU_POWERPC_G2LEgp3
7051 #define CPU_POWERPC_MPC8275 CPU_POWERPC_G2LEgp3
7052 #define CPU_POWERPC_MPC8280 CPU_POWERPC_G2LEgp3
7055 #define CPU_POWERPC_e200 CPU_POWERPC_e200z6
7057 CPU_POWERPC_e200z0
= xxx
,
7060 CPU_POWERPC_e200z1
= xxx
,
7063 CPU_POWERPC_e200z3
= 0x81120000,
7065 CPU_POWERPC_e200z5
= 0x81000000,
7066 CPU_POWERPC_e200z6
= 0x81120000,
7067 /* MPC55xx microcontrollers */
7068 #define CPU_POWERPC_MPC55xx CPU_POWERPC_MPC5567
7070 #define CPU_POWERPC_MPC5514E CPU_POWERPC_MPC5514E_v1
7071 #define CPU_POWERPC_MPC5514E_v0 CPU_POWERPC_e200z0
7072 #define CPU_POWERPC_MPC5514E_v1 CPU_POWERPC_e200z1
7073 #define CPU_POWERPC_MPC5514G CPU_POWERPC_MPC5514G_v1
7074 #define CPU_POWERPC_MPC5514G_v0 CPU_POWERPC_e200z0
7075 #define CPU_POWERPC_MPC5514G_v1 CPU_POWERPC_e200z1
7076 #define CPU_POWERPC_MPC5515S CPU_POWERPC_e200z1
7077 #define CPU_POWERPC_MPC5516E CPU_POWERPC_MPC5516E_v1
7078 #define CPU_POWERPC_MPC5516E_v0 CPU_POWERPC_e200z0
7079 #define CPU_POWERPC_MPC5516E_v1 CPU_POWERPC_e200z1
7080 #define CPU_POWERPC_MPC5516G CPU_POWERPC_MPC5516G_v1
7081 #define CPU_POWERPC_MPC5516G_v0 CPU_POWERPC_e200z0
7082 #define CPU_POWERPC_MPC5516G_v1 CPU_POWERPC_e200z1
7083 #define CPU_POWERPC_MPC5516S CPU_POWERPC_e200z1
7086 #define CPU_POWERPC_MPC5533 CPU_POWERPC_e200z3
7087 #define CPU_POWERPC_MPC5534 CPU_POWERPC_e200z3
7089 #define CPU_POWERPC_MPC5553 CPU_POWERPC_e200z6
7090 #define CPU_POWERPC_MPC5554 CPU_POWERPC_e200z6
7091 #define CPU_POWERPC_MPC5561 CPU_POWERPC_e200z6
7092 #define CPU_POWERPC_MPC5565 CPU_POWERPC_e200z6
7093 #define CPU_POWERPC_MPC5566 CPU_POWERPC_e200z6
7094 #define CPU_POWERPC_MPC5567 CPU_POWERPC_e200z6
7097 #define CPU_POWERPC_e300 CPU_POWERPC_e300c3
7098 CPU_POWERPC_e300c1
= 0x00830010,
7099 CPU_POWERPC_e300c2
= 0x00840010,
7100 CPU_POWERPC_e300c3
= 0x00850010,
7101 CPU_POWERPC_e300c4
= 0x00860010,
7102 /* MPC83xx microcontrollers */
7103 #define CPU_POWERPC_MPC831x CPU_POWERPC_e300c3
7104 #define CPU_POWERPC_MPC832x CPU_POWERPC_e300c2
7105 #define CPU_POWERPC_MPC834x CPU_POWERPC_e300c1
7106 #define CPU_POWERPC_MPC835x CPU_POWERPC_e300c1
7107 #define CPU_POWERPC_MPC836x CPU_POWERPC_e300c1
7108 #define CPU_POWERPC_MPC837x CPU_POWERPC_e300c4
7111 #define CPU_POWERPC_e500 CPU_POWERPC_e500v2_v22
7112 #define CPU_POWERPC_e500v1 CPU_POWERPC_e500v1_v20
7113 #define CPU_POWERPC_e500v2 CPU_POWERPC_e500v2_v22
7114 CPU_POWERPC_e500v1_v10
= 0x80200010,
7115 CPU_POWERPC_e500v1_v20
= 0x80200020,
7116 CPU_POWERPC_e500v2_v10
= 0x80210010,
7117 CPU_POWERPC_e500v2_v11
= 0x80210011,
7118 CPU_POWERPC_e500v2_v20
= 0x80210020,
7119 CPU_POWERPC_e500v2_v21
= 0x80210021,
7120 CPU_POWERPC_e500v2_v22
= 0x80210022,
7121 CPU_POWERPC_e500v2_v30
= 0x80210030,
7122 CPU_POWERPC_e500mc
= 0x80230020,
7123 /* MPC85xx microcontrollers */
7124 #define CPU_POWERPC_MPC8533 CPU_POWERPC_MPC8533_v11
7125 #define CPU_POWERPC_MPC8533_v10 CPU_POWERPC_e500v2_v21
7126 #define CPU_POWERPC_MPC8533_v11 CPU_POWERPC_e500v2_v22
7127 #define CPU_POWERPC_MPC8533E CPU_POWERPC_MPC8533E_v11
7128 #define CPU_POWERPC_MPC8533E_v10 CPU_POWERPC_e500v2_v21
7129 #define CPU_POWERPC_MPC8533E_v11 CPU_POWERPC_e500v2_v22
7130 #define CPU_POWERPC_MPC8540 CPU_POWERPC_MPC8540_v21
7131 #define CPU_POWERPC_MPC8540_v10 CPU_POWERPC_e500v1_v10
7132 #define CPU_POWERPC_MPC8540_v20 CPU_POWERPC_e500v1_v20
7133 #define CPU_POWERPC_MPC8540_v21 CPU_POWERPC_e500v1_v20
7134 #define CPU_POWERPC_MPC8541 CPU_POWERPC_MPC8541_v11
7135 #define CPU_POWERPC_MPC8541_v10 CPU_POWERPC_e500v1_v20
7136 #define CPU_POWERPC_MPC8541_v11 CPU_POWERPC_e500v1_v20
7137 #define CPU_POWERPC_MPC8541E CPU_POWERPC_MPC8541E_v11
7138 #define CPU_POWERPC_MPC8541E_v10 CPU_POWERPC_e500v1_v20
7139 #define CPU_POWERPC_MPC8541E_v11 CPU_POWERPC_e500v1_v20
7140 #define CPU_POWERPC_MPC8543 CPU_POWERPC_MPC8543_v21
7141 #define CPU_POWERPC_MPC8543_v10 CPU_POWERPC_e500v2_v10
7142 #define CPU_POWERPC_MPC8543_v11 CPU_POWERPC_e500v2_v11
7143 #define CPU_POWERPC_MPC8543_v20 CPU_POWERPC_e500v2_v20
7144 #define CPU_POWERPC_MPC8543_v21 CPU_POWERPC_e500v2_v21
7145 #define CPU_POWERPC_MPC8543E CPU_POWERPC_MPC8543E_v21
7146 #define CPU_POWERPC_MPC8543E_v10 CPU_POWERPC_e500v2_v10
7147 #define CPU_POWERPC_MPC8543E_v11 CPU_POWERPC_e500v2_v11
7148 #define CPU_POWERPC_MPC8543E_v20 CPU_POWERPC_e500v2_v20
7149 #define CPU_POWERPC_MPC8543E_v21 CPU_POWERPC_e500v2_v21
7150 #define CPU_POWERPC_MPC8544 CPU_POWERPC_MPC8544_v11
7151 #define CPU_POWERPC_MPC8544_v10 CPU_POWERPC_e500v2_v21
7152 #define CPU_POWERPC_MPC8544_v11 CPU_POWERPC_e500v2_v22
7153 #define CPU_POWERPC_MPC8544E_v11 CPU_POWERPC_e500v2_v22
7154 #define CPU_POWERPC_MPC8544E CPU_POWERPC_MPC8544E_v11
7155 #define CPU_POWERPC_MPC8544E_v10 CPU_POWERPC_e500v2_v21
7156 #define CPU_POWERPC_MPC8545 CPU_POWERPC_MPC8545_v21
7157 #define CPU_POWERPC_MPC8545_v10 CPU_POWERPC_e500v2_v10
7158 #define CPU_POWERPC_MPC8545_v20 CPU_POWERPC_e500v2_v20
7159 #define CPU_POWERPC_MPC8545_v21 CPU_POWERPC_e500v2_v21
7160 #define CPU_POWERPC_MPC8545E CPU_POWERPC_MPC8545E_v21
7161 #define CPU_POWERPC_MPC8545E_v10 CPU_POWERPC_e500v2_v10
7162 #define CPU_POWERPC_MPC8545E_v20 CPU_POWERPC_e500v2_v20
7163 #define CPU_POWERPC_MPC8545E_v21 CPU_POWERPC_e500v2_v21
7164 #define CPU_POWERPC_MPC8547E CPU_POWERPC_MPC8545E_v21
7165 #define CPU_POWERPC_MPC8547E_v10 CPU_POWERPC_e500v2_v10
7166 #define CPU_POWERPC_MPC8547E_v20 CPU_POWERPC_e500v2_v20
7167 #define CPU_POWERPC_MPC8547E_v21 CPU_POWERPC_e500v2_v21
7168 #define CPU_POWERPC_MPC8548 CPU_POWERPC_MPC8548_v21
7169 #define CPU_POWERPC_MPC8548_v10 CPU_POWERPC_e500v2_v10
7170 #define CPU_POWERPC_MPC8548_v11 CPU_POWERPC_e500v2_v11
7171 #define CPU_POWERPC_MPC8548_v20 CPU_POWERPC_e500v2_v20
7172 #define CPU_POWERPC_MPC8548_v21 CPU_POWERPC_e500v2_v21
7173 #define CPU_POWERPC_MPC8548E CPU_POWERPC_MPC8548E_v21
7174 #define CPU_POWERPC_MPC8548E_v10 CPU_POWERPC_e500v2_v10
7175 #define CPU_POWERPC_MPC8548E_v11 CPU_POWERPC_e500v2_v11
7176 #define CPU_POWERPC_MPC8548E_v20 CPU_POWERPC_e500v2_v20
7177 #define CPU_POWERPC_MPC8548E_v21 CPU_POWERPC_e500v2_v21
7178 #define CPU_POWERPC_MPC8555 CPU_POWERPC_MPC8555_v11
7179 #define CPU_POWERPC_MPC8555_v10 CPU_POWERPC_e500v2_v10
7180 #define CPU_POWERPC_MPC8555_v11 CPU_POWERPC_e500v2_v11
7181 #define CPU_POWERPC_MPC8555E CPU_POWERPC_MPC8555E_v11
7182 #define CPU_POWERPC_MPC8555E_v10 CPU_POWERPC_e500v2_v10
7183 #define CPU_POWERPC_MPC8555E_v11 CPU_POWERPC_e500v2_v11
7184 #define CPU_POWERPC_MPC8560 CPU_POWERPC_MPC8560_v21
7185 #define CPU_POWERPC_MPC8560_v10 CPU_POWERPC_e500v2_v10
7186 #define CPU_POWERPC_MPC8560_v20 CPU_POWERPC_e500v2_v20
7187 #define CPU_POWERPC_MPC8560_v21 CPU_POWERPC_e500v2_v21
7188 #define CPU_POWERPC_MPC8567 CPU_POWERPC_e500v2_v22
7189 #define CPU_POWERPC_MPC8567E CPU_POWERPC_e500v2_v22
7190 #define CPU_POWERPC_MPC8568 CPU_POWERPC_e500v2_v22
7191 #define CPU_POWERPC_MPC8568E CPU_POWERPC_e500v2_v22
7192 #define CPU_POWERPC_MPC8572 CPU_POWERPC_e500v2_v30
7193 #define CPU_POWERPC_MPC8572E CPU_POWERPC_e500v2_v30
7196 CPU_POWERPC_e600
= 0x80040010,
7197 /* MPC86xx microcontrollers */
7198 #define CPU_POWERPC_MPC8610 CPU_POWERPC_e600
7199 #define CPU_POWERPC_MPC8641 CPU_POWERPC_e600
7200 #define CPU_POWERPC_MPC8641D CPU_POWERPC_e600
7201 /* PowerPC 6xx cores */
7202 #define CPU_POWERPC_601 CPU_POWERPC_601_v2
7203 CPU_POWERPC_601_v0
= 0x00010001,
7204 CPU_POWERPC_601_v1
= 0x00010001,
7205 #define CPU_POWERPC_601v CPU_POWERPC_601_v2
7206 CPU_POWERPC_601_v2
= 0x00010002,
7207 CPU_POWERPC_602
= 0x00050100,
7208 CPU_POWERPC_603
= 0x00030100,
7209 #define CPU_POWERPC_603E CPU_POWERPC_603E_v41
7210 CPU_POWERPC_603E_v11
= 0x00060101,
7211 CPU_POWERPC_603E_v12
= 0x00060102,
7212 CPU_POWERPC_603E_v13
= 0x00060103,
7213 CPU_POWERPC_603E_v14
= 0x00060104,
7214 CPU_POWERPC_603E_v22
= 0x00060202,
7215 CPU_POWERPC_603E_v3
= 0x00060300,
7216 CPU_POWERPC_603E_v4
= 0x00060400,
7217 CPU_POWERPC_603E_v41
= 0x00060401,
7218 CPU_POWERPC_603E7t
= 0x00071201,
7219 CPU_POWERPC_603E7v
= 0x00070100,
7220 CPU_POWERPC_603E7v1
= 0x00070101,
7221 CPU_POWERPC_603E7v2
= 0x00070201,
7222 CPU_POWERPC_603E7
= 0x00070200,
7223 CPU_POWERPC_603P
= 0x00070000,
7224 #define CPU_POWERPC_603R CPU_POWERPC_603E7t
7225 /* XXX: missing 0x00040303 (604) */
7226 CPU_POWERPC_604
= 0x00040103,
7227 #define CPU_POWERPC_604E CPU_POWERPC_604E_v24
7228 /* XXX: missing 0x00091203 */
7229 /* XXX: missing 0x00092110 */
7230 /* XXX: missing 0x00092120 */
7231 CPU_POWERPC_604E_v10
= 0x00090100,
7232 CPU_POWERPC_604E_v22
= 0x00090202,
7233 CPU_POWERPC_604E_v24
= 0x00090204,
7234 /* XXX: missing 0x000a0100 */
7235 /* XXX: missing 0x00093102 */
7236 CPU_POWERPC_604R
= 0x000a0101,
7238 CPU_POWERPC_604EV
= xxx
, /* XXX: same as 604R ? */
7240 /* PowerPC 740/750 cores (aka G3) */
7241 /* XXX: missing 0x00084202 */
7242 #define CPU_POWERPC_7x0 CPU_POWERPC_7x0_v31
7243 CPU_POWERPC_7x0_v10
= 0x00080100,
7244 CPU_POWERPC_7x0_v20
= 0x00080200,
7245 CPU_POWERPC_7x0_v21
= 0x00080201,
7246 CPU_POWERPC_7x0_v22
= 0x00080202,
7247 CPU_POWERPC_7x0_v30
= 0x00080300,
7248 CPU_POWERPC_7x0_v31
= 0x00080301,
7249 CPU_POWERPC_740E
= 0x00080100,
7250 CPU_POWERPC_750E
= 0x00080200,
7251 CPU_POWERPC_7x0P
= 0x10080000,
7252 /* XXX: missing 0x00087010 (CL ?) */
7253 #define CPU_POWERPC_750CL CPU_POWERPC_750CL_v20
7254 CPU_POWERPC_750CL_v10
= 0x00087200,
7255 CPU_POWERPC_750CL_v20
= 0x00087210, /* aka rev E */
7256 #define CPU_POWERPC_750CX CPU_POWERPC_750CX_v22
7257 CPU_POWERPC_750CX_v10
= 0x00082100,
7258 CPU_POWERPC_750CX_v20
= 0x00082200,
7259 CPU_POWERPC_750CX_v21
= 0x00082201,
7260 CPU_POWERPC_750CX_v22
= 0x00082202,
7261 #define CPU_POWERPC_750CXE CPU_POWERPC_750CXE_v31b
7262 CPU_POWERPC_750CXE_v21
= 0x00082211,
7263 CPU_POWERPC_750CXE_v22
= 0x00082212,
7264 CPU_POWERPC_750CXE_v23
= 0x00082213,
7265 CPU_POWERPC_750CXE_v24
= 0x00082214,
7266 CPU_POWERPC_750CXE_v24b
= 0x00083214,
7267 CPU_POWERPC_750CXE_v30
= 0x00082310,
7268 CPU_POWERPC_750CXE_v31
= 0x00082311,
7269 CPU_POWERPC_750CXE_v31b
= 0x00083311,
7270 CPU_POWERPC_750CXR
= 0x00083410,
7271 CPU_POWERPC_750FL
= 0x70000203,
7272 #define CPU_POWERPC_750FX CPU_POWERPC_750FX_v23
7273 CPU_POWERPC_750FX_v10
= 0x70000100,
7274 CPU_POWERPC_750FX_v20
= 0x70000200,
7275 CPU_POWERPC_750FX_v21
= 0x70000201,
7276 CPU_POWERPC_750FX_v22
= 0x70000202,
7277 CPU_POWERPC_750FX_v23
= 0x70000203,
7278 CPU_POWERPC_750GL
= 0x70020102,
7279 #define CPU_POWERPC_750GX CPU_POWERPC_750GX_v12
7280 CPU_POWERPC_750GX_v10
= 0x70020100,
7281 CPU_POWERPC_750GX_v11
= 0x70020101,
7282 CPU_POWERPC_750GX_v12
= 0x70020102,
7283 #define CPU_POWERPC_750L CPU_POWERPC_750L_v32 /* Aka LoneStar */
7284 CPU_POWERPC_750L_v20
= 0x00088200,
7285 CPU_POWERPC_750L_v21
= 0x00088201,
7286 CPU_POWERPC_750L_v22
= 0x00088202,
7287 CPU_POWERPC_750L_v30
= 0x00088300,
7288 CPU_POWERPC_750L_v32
= 0x00088302,
7289 /* PowerPC 745/755 cores */
7290 #define CPU_POWERPC_7x5 CPU_POWERPC_7x5_v28
7291 CPU_POWERPC_7x5_v10
= 0x00083100,
7292 CPU_POWERPC_7x5_v11
= 0x00083101,
7293 CPU_POWERPC_7x5_v20
= 0x00083200,
7294 CPU_POWERPC_7x5_v21
= 0x00083201,
7295 CPU_POWERPC_7x5_v22
= 0x00083202, /* aka D */
7296 CPU_POWERPC_7x5_v23
= 0x00083203, /* aka E */
7297 CPU_POWERPC_7x5_v24
= 0x00083204,
7298 CPU_POWERPC_7x5_v25
= 0x00083205,
7299 CPU_POWERPC_7x5_v26
= 0x00083206,
7300 CPU_POWERPC_7x5_v27
= 0x00083207,
7301 CPU_POWERPC_7x5_v28
= 0x00083208,
7303 CPU_POWERPC_7x5P
= xxx
,
7305 /* PowerPC 74xx cores (aka G4) */
7306 /* XXX: missing 0x000C1101 */
7307 #define CPU_POWERPC_7400 CPU_POWERPC_7400_v29
7308 CPU_POWERPC_7400_v10
= 0x000C0100,
7309 CPU_POWERPC_7400_v11
= 0x000C0101,
7310 CPU_POWERPC_7400_v20
= 0x000C0200,
7311 CPU_POWERPC_7400_v21
= 0x000C0201,
7312 CPU_POWERPC_7400_v22
= 0x000C0202,
7313 CPU_POWERPC_7400_v26
= 0x000C0206,
7314 CPU_POWERPC_7400_v27
= 0x000C0207,
7315 CPU_POWERPC_7400_v28
= 0x000C0208,
7316 CPU_POWERPC_7400_v29
= 0x000C0209,
7317 #define CPU_POWERPC_7410 CPU_POWERPC_7410_v14
7318 CPU_POWERPC_7410_v10
= 0x800C1100,
7319 CPU_POWERPC_7410_v11
= 0x800C1101,
7320 CPU_POWERPC_7410_v12
= 0x800C1102, /* aka C */
7321 CPU_POWERPC_7410_v13
= 0x800C1103, /* aka D */
7322 CPU_POWERPC_7410_v14
= 0x800C1104, /* aka E */
7323 #define CPU_POWERPC_7448 CPU_POWERPC_7448_v21
7324 CPU_POWERPC_7448_v10
= 0x80040100,
7325 CPU_POWERPC_7448_v11
= 0x80040101,
7326 CPU_POWERPC_7448_v20
= 0x80040200,
7327 CPU_POWERPC_7448_v21
= 0x80040201,
7328 #define CPU_POWERPC_7450 CPU_POWERPC_7450_v21
7329 CPU_POWERPC_7450_v10
= 0x80000100,
7330 CPU_POWERPC_7450_v11
= 0x80000101,
7331 CPU_POWERPC_7450_v12
= 0x80000102,
7332 CPU_POWERPC_7450_v20
= 0x80000200, /* aka A, B, C, D: 2.04 */
7333 CPU_POWERPC_7450_v21
= 0x80000201, /* aka E */
7334 #define CPU_POWERPC_74x1 CPU_POWERPC_74x1_v23
7335 CPU_POWERPC_74x1_v23
= 0x80000203, /* aka G: 2.3 */
7336 /* XXX: this entry might be a bug in some documentation */
7337 CPU_POWERPC_74x1_v210
= 0x80000210, /* aka G: 2.3 ? */
7338 #define CPU_POWERPC_74x5 CPU_POWERPC_74x5_v32
7339 CPU_POWERPC_74x5_v10
= 0x80010100,
7340 /* XXX: missing 0x80010200 */
7341 CPU_POWERPC_74x5_v21
= 0x80010201, /* aka C: 2.1 */
7342 CPU_POWERPC_74x5_v32
= 0x80010302,
7343 CPU_POWERPC_74x5_v33
= 0x80010303, /* aka F: 3.3 */
7344 CPU_POWERPC_74x5_v34
= 0x80010304, /* aka G: 3.4 */
7345 #define CPU_POWERPC_74x7 CPU_POWERPC_74x7_v12
7346 CPU_POWERPC_74x7_v10
= 0x80020100, /* aka A: 1.0 */
7347 CPU_POWERPC_74x7_v11
= 0x80020101, /* aka B: 1.1 */
7348 CPU_POWERPC_74x7_v12
= 0x80020102, /* aka C: 1.2 */
7349 #define CPU_POWERPC_74x7A CPU_POWERPC_74x7A_v12
7350 CPU_POWERPC_74x7A_v10
= 0x80030100, /* aka A: 1.0 */
7351 CPU_POWERPC_74x7A_v11
= 0x80030101, /* aka B: 1.1 */
7352 CPU_POWERPC_74x7A_v12
= 0x80030102, /* aka C: 1.2 */
7353 /* 64 bits PowerPC */
7354 #if defined(TARGET_PPC64)
7355 CPU_POWERPC_620
= 0x00140000,
7356 CPU_POWERPC_630
= 0x00400000,
7357 CPU_POWERPC_631
= 0x00410104,
7358 CPU_POWERPC_POWER4
= 0x00350000,
7359 CPU_POWERPC_POWER4P
= 0x00380000,
7360 /* XXX: missing 0x003A0201 */
7361 CPU_POWERPC_POWER5
= 0x003A0203,
7362 #define CPU_POWERPC_POWER5GR CPU_POWERPC_POWER5
7363 CPU_POWERPC_POWER5P
= 0x003B0000,
7364 #define CPU_POWERPC_POWER5GS CPU_POWERPC_POWER5P
7365 CPU_POWERPC_POWER6
= 0x003E0000,
7366 CPU_POWERPC_POWER6_5
= 0x0F000001, /* POWER6 in POWER5 mode */
7367 CPU_POWERPC_POWER6A
= 0x0F000002,
7368 #define CPU_POWERPC_POWER7 CPU_POWERPC_POWER7_v20
7369 CPU_POWERPC_POWER7_v20
= 0x003F0200,
7370 CPU_POWERPC_POWER7_v21
= 0x003F0201,
7371 CPU_POWERPC_POWER7_v23
= 0x003F0203,
7372 CPU_POWERPC_970
= 0x00390202,
7373 #define CPU_POWERPC_970FX CPU_POWERPC_970FX_v31
7374 CPU_POWERPC_970FX_v10
= 0x00391100,
7375 CPU_POWERPC_970FX_v20
= 0x003C0200,
7376 CPU_POWERPC_970FX_v21
= 0x003C0201,
7377 CPU_POWERPC_970FX_v30
= 0x003C0300,
7378 CPU_POWERPC_970FX_v31
= 0x003C0301,
7379 CPU_POWERPC_970GX
= 0x00450000,
7380 #define CPU_POWERPC_970MP CPU_POWERPC_970MP_v11
7381 CPU_POWERPC_970MP_v10
= 0x00440100,
7382 CPU_POWERPC_970MP_v11
= 0x00440101,
7383 #define CPU_POWERPC_CELL CPU_POWERPC_CELL_v32
7384 CPU_POWERPC_CELL_v10
= 0x00700100,
7385 CPU_POWERPC_CELL_v20
= 0x00700400,
7386 CPU_POWERPC_CELL_v30
= 0x00700500,
7387 CPU_POWERPC_CELL_v31
= 0x00700501,
7388 #define CPU_POWERPC_CELL_v32 CPU_POWERPC_CELL_v31
7389 CPU_POWERPC_RS64
= 0x00330000,
7390 CPU_POWERPC_RS64II
= 0x00340000,
7391 CPU_POWERPC_RS64III
= 0x00360000,
7392 CPU_POWERPC_RS64IV
= 0x00370000,
7393 #endif /* defined(TARGET_PPC64) */
7394 /* Original POWER */
7395 /* XXX: should be POWER (RIOS), RSC3308, RSC4608,
7396 * POWER2 (RIOS2) & RSC2 (P2SC) here
7399 CPU_POWER
= xxx
, /* 0x20000 ? 0x30000 for RSC ? */
7402 CPU_POWER2
= xxx
, /* 0x40000 ? */
7405 CPU_POWERPC_PA6T
= 0x00900000,
7408 /* System version register (used on MPC 8xxx) */
7410 POWERPC_SVR_NONE
= 0x00000000,
7411 #define POWERPC_SVR_52xx POWERPC_SVR_5200
7412 #define POWERPC_SVR_5200 POWERPC_SVR_5200_v12
7413 POWERPC_SVR_5200_v10
= 0x80110010,
7414 POWERPC_SVR_5200_v11
= 0x80110011,
7415 POWERPC_SVR_5200_v12
= 0x80110012,
7416 #define POWERPC_SVR_5200B POWERPC_SVR_5200B_v21
7417 POWERPC_SVR_5200B_v20
= 0x80110020,
7418 POWERPC_SVR_5200B_v21
= 0x80110021,
7419 #define POWERPC_SVR_55xx POWERPC_SVR_5567
7421 POWERPC_SVR_5533
= xxx
,
7424 POWERPC_SVR_5534
= xxx
,
7427 POWERPC_SVR_5553
= xxx
,
7430 POWERPC_SVR_5554
= xxx
,
7433 POWERPC_SVR_5561
= xxx
,
7436 POWERPC_SVR_5565
= xxx
,
7439 POWERPC_SVR_5566
= xxx
,
7442 POWERPC_SVR_5567
= xxx
,
7445 POWERPC_SVR_8313
= xxx
,
7448 POWERPC_SVR_8313E
= xxx
,
7451 POWERPC_SVR_8314
= xxx
,
7454 POWERPC_SVR_8314E
= xxx
,
7457 POWERPC_SVR_8315
= xxx
,
7460 POWERPC_SVR_8315E
= xxx
,
7463 POWERPC_SVR_8321
= xxx
,
7466 POWERPC_SVR_8321E
= xxx
,
7469 POWERPC_SVR_8323
= xxx
,
7472 POWERPC_SVR_8323E
= xxx
,
7474 POWERPC_SVR_8343
= 0x80570010,
7475 POWERPC_SVR_8343A
= 0x80570030,
7476 POWERPC_SVR_8343E
= 0x80560010,
7477 POWERPC_SVR_8343EA
= 0x80560030,
7478 #define POWERPC_SVR_8347 POWERPC_SVR_8347T
7479 POWERPC_SVR_8347P
= 0x80550010, /* PBGA package */
7480 POWERPC_SVR_8347T
= 0x80530010, /* TBGA package */
7481 #define POWERPC_SVR_8347A POWERPC_SVR_8347AT
7482 POWERPC_SVR_8347AP
= 0x80550030, /* PBGA package */
7483 POWERPC_SVR_8347AT
= 0x80530030, /* TBGA package */
7484 #define POWERPC_SVR_8347E POWERPC_SVR_8347ET
7485 POWERPC_SVR_8347EP
= 0x80540010, /* PBGA package */
7486 POWERPC_SVR_8347ET
= 0x80520010, /* TBGA package */
7487 #define POWERPC_SVR_8347EA POWERPC_SVR_8347EAT
7488 POWERPC_SVR_8347EAP
= 0x80540030, /* PBGA package */
7489 POWERPC_SVR_8347EAT
= 0x80520030, /* TBGA package */
7490 POWERPC_SVR_8349
= 0x80510010,
7491 POWERPC_SVR_8349A
= 0x80510030,
7492 POWERPC_SVR_8349E
= 0x80500010,
7493 POWERPC_SVR_8349EA
= 0x80500030,
7495 POWERPC_SVR_8358E
= xxx
,
7498 POWERPC_SVR_8360E
= xxx
,
7500 #define POWERPC_SVR_E500 0x40000000
7501 POWERPC_SVR_8377
= 0x80C70010 | POWERPC_SVR_E500
,
7502 POWERPC_SVR_8377E
= 0x80C60010 | POWERPC_SVR_E500
,
7503 POWERPC_SVR_8378
= 0x80C50010 | POWERPC_SVR_E500
,
7504 POWERPC_SVR_8378E
= 0x80C40010 | POWERPC_SVR_E500
,
7505 POWERPC_SVR_8379
= 0x80C30010 | POWERPC_SVR_E500
,
7506 POWERPC_SVR_8379E
= 0x80C00010 | POWERPC_SVR_E500
,
7507 #define POWERPC_SVR_8533 POWERPC_SVR_8533_v11
7508 POWERPC_SVR_8533_v10
= 0x80340010 | POWERPC_SVR_E500
,
7509 POWERPC_SVR_8533_v11
= 0x80340011 | POWERPC_SVR_E500
,
7510 #define POWERPC_SVR_8533E POWERPC_SVR_8533E_v11
7511 POWERPC_SVR_8533E_v10
= 0x803C0010 | POWERPC_SVR_E500
,
7512 POWERPC_SVR_8533E_v11
= 0x803C0011 | POWERPC_SVR_E500
,
7513 #define POWERPC_SVR_8540 POWERPC_SVR_8540_v21
7514 POWERPC_SVR_8540_v10
= 0x80300010 | POWERPC_SVR_E500
,
7515 POWERPC_SVR_8540_v20
= 0x80300020 | POWERPC_SVR_E500
,
7516 POWERPC_SVR_8540_v21
= 0x80300021 | POWERPC_SVR_E500
,
7517 #define POWERPC_SVR_8541 POWERPC_SVR_8541_v11
7518 POWERPC_SVR_8541_v10
= 0x80720010 | POWERPC_SVR_E500
,
7519 POWERPC_SVR_8541_v11
= 0x80720011 | POWERPC_SVR_E500
,
7520 #define POWERPC_SVR_8541E POWERPC_SVR_8541E_v11
7521 POWERPC_SVR_8541E_v10
= 0x807A0010 | POWERPC_SVR_E500
,
7522 POWERPC_SVR_8541E_v11
= 0x807A0011 | POWERPC_SVR_E500
,
7523 #define POWERPC_SVR_8543 POWERPC_SVR_8543_v21
7524 POWERPC_SVR_8543_v10
= 0x80320010 | POWERPC_SVR_E500
,
7525 POWERPC_SVR_8543_v11
= 0x80320011 | POWERPC_SVR_E500
,
7526 POWERPC_SVR_8543_v20
= 0x80320020 | POWERPC_SVR_E500
,
7527 POWERPC_SVR_8543_v21
= 0x80320021 | POWERPC_SVR_E500
,
7528 #define POWERPC_SVR_8543E POWERPC_SVR_8543E_v21
7529 POWERPC_SVR_8543E_v10
= 0x803A0010 | POWERPC_SVR_E500
,
7530 POWERPC_SVR_8543E_v11
= 0x803A0011 | POWERPC_SVR_E500
,
7531 POWERPC_SVR_8543E_v20
= 0x803A0020 | POWERPC_SVR_E500
,
7532 POWERPC_SVR_8543E_v21
= 0x803A0021 | POWERPC_SVR_E500
,
7533 #define POWERPC_SVR_8544 POWERPC_SVR_8544_v11
7534 POWERPC_SVR_8544_v10
= 0x80340110 | POWERPC_SVR_E500
,
7535 POWERPC_SVR_8544_v11
= 0x80340111 | POWERPC_SVR_E500
,
7536 #define POWERPC_SVR_8544E POWERPC_SVR_8544E_v11
7537 POWERPC_SVR_8544E_v10
= 0x803C0110 | POWERPC_SVR_E500
,
7538 POWERPC_SVR_8544E_v11
= 0x803C0111 | POWERPC_SVR_E500
,
7539 #define POWERPC_SVR_8545 POWERPC_SVR_8545_v21
7540 POWERPC_SVR_8545_v20
= 0x80310220 | POWERPC_SVR_E500
,
7541 POWERPC_SVR_8545_v21
= 0x80310221 | POWERPC_SVR_E500
,
7542 #define POWERPC_SVR_8545E POWERPC_SVR_8545E_v21
7543 POWERPC_SVR_8545E_v20
= 0x80390220 | POWERPC_SVR_E500
,
7544 POWERPC_SVR_8545E_v21
= 0x80390221 | POWERPC_SVR_E500
,
7545 #define POWERPC_SVR_8547E POWERPC_SVR_8547E_v21
7546 POWERPC_SVR_8547E_v20
= 0x80390120 | POWERPC_SVR_E500
,
7547 POWERPC_SVR_8547E_v21
= 0x80390121 | POWERPC_SVR_E500
,
7548 #define POWERPC_SVR_8548 POWERPC_SVR_8548_v21
7549 POWERPC_SVR_8548_v10
= 0x80310010 | POWERPC_SVR_E500
,
7550 POWERPC_SVR_8548_v11
= 0x80310011 | POWERPC_SVR_E500
,
7551 POWERPC_SVR_8548_v20
= 0x80310020 | POWERPC_SVR_E500
,
7552 POWERPC_SVR_8548_v21
= 0x80310021 | POWERPC_SVR_E500
,
7553 #define POWERPC_SVR_8548E POWERPC_SVR_8548E_v21
7554 POWERPC_SVR_8548E_v10
= 0x80390010 | POWERPC_SVR_E500
,
7555 POWERPC_SVR_8548E_v11
= 0x80390011 | POWERPC_SVR_E500
,
7556 POWERPC_SVR_8548E_v20
= 0x80390020 | POWERPC_SVR_E500
,
7557 POWERPC_SVR_8548E_v21
= 0x80390021 | POWERPC_SVR_E500
,
7558 #define POWERPC_SVR_8555 POWERPC_SVR_8555_v11
7559 POWERPC_SVR_8555_v10
= 0x80710010 | POWERPC_SVR_E500
,
7560 POWERPC_SVR_8555_v11
= 0x80710011 | POWERPC_SVR_E500
,
7561 #define POWERPC_SVR_8555E POWERPC_SVR_8555_v11
7562 POWERPC_SVR_8555E_v10
= 0x80790010 | POWERPC_SVR_E500
,
7563 POWERPC_SVR_8555E_v11
= 0x80790011 | POWERPC_SVR_E500
,
7564 #define POWERPC_SVR_8560 POWERPC_SVR_8560_v21
7565 POWERPC_SVR_8560_v10
= 0x80700010 | POWERPC_SVR_E500
,
7566 POWERPC_SVR_8560_v20
= 0x80700020 | POWERPC_SVR_E500
,
7567 POWERPC_SVR_8560_v21
= 0x80700021 | POWERPC_SVR_E500
,
7568 POWERPC_SVR_8567
= 0x80750111 | POWERPC_SVR_E500
,
7569 POWERPC_SVR_8567E
= 0x807D0111 | POWERPC_SVR_E500
,
7570 POWERPC_SVR_8568
= 0x80750011 | POWERPC_SVR_E500
,
7571 POWERPC_SVR_8568E
= 0x807D0011 | POWERPC_SVR_E500
,
7572 POWERPC_SVR_8572
= 0x80E00010 | POWERPC_SVR_E500
,
7573 POWERPC_SVR_8572E
= 0x80E80010 | POWERPC_SVR_E500
,
7575 POWERPC_SVR_8610
= xxx
,
7577 POWERPC_SVR_8641
= 0x80900021,
7578 POWERPC_SVR_8641D
= 0x80900121,
7581 /*****************************************************************************/
7582 /* PowerPC CPU definitions */
7583 #define POWERPC_DEF_SVR(_name, _pvr, _svr, _type) \
7588 .insns_flags = glue(POWERPC_INSNS_,_type), \
7589 .insns_flags2 = glue(POWERPC_INSNS2_,_type), \
7590 .msr_mask = glue(POWERPC_MSRM_,_type), \
7591 .mmu_model = glue(POWERPC_MMU_,_type), \
7592 .excp_model = glue(POWERPC_EXCP_,_type), \
7593 .bus_model = glue(POWERPC_INPUT_,_type), \
7594 .bfd_mach = glue(POWERPC_BFDM_,_type), \
7595 .flags = glue(POWERPC_FLAG_,_type), \
7596 .init_proc = &glue(init_proc_,_type), \
7597 .check_pow = &glue(check_pow_,_type), \
7599 #define POWERPC_DEF(_name, _pvr, _type) \
7600 POWERPC_DEF_SVR(_name, _pvr, POWERPC_SVR_NONE, _type)
7602 static const ppc_def_t ppc_defs
[] = {
7603 /* Embedded PowerPC */
7604 /* PowerPC 401 family */
7605 /* Generic PowerPC 401 */
7606 POWERPC_DEF("401", CPU_POWERPC_401
, 401),
7607 /* PowerPC 401 cores */
7609 POWERPC_DEF("401A1", CPU_POWERPC_401A1
, 401),
7611 POWERPC_DEF("401B2", CPU_POWERPC_401B2
, 401x2
),
7614 POWERPC_DEF("401B3", CPU_POWERPC_401B3
, 401x3
),
7617 POWERPC_DEF("401C2", CPU_POWERPC_401C2
, 401x2
),
7619 POWERPC_DEF("401D2", CPU_POWERPC_401D2
, 401x2
),
7621 POWERPC_DEF("401E2", CPU_POWERPC_401E2
, 401x2
),
7623 POWERPC_DEF("401F2", CPU_POWERPC_401F2
, 401x2
),
7625 /* XXX: to be checked */
7626 POWERPC_DEF("401G2", CPU_POWERPC_401G2
, 401x2
),
7627 /* PowerPC 401 microcontrolers */
7630 POWERPC_DEF("401GF", CPU_POWERPC_401GF
, 401),
7632 /* IOP480 (401 microcontroler) */
7633 POWERPC_DEF("IOP480", CPU_POWERPC_IOP480
, IOP480
),
7634 /* IBM Processor for Network Resources */
7635 POWERPC_DEF("Cobra", CPU_POWERPC_COBRA
, 401),
7637 POWERPC_DEF("Xipchip", CPU_POWERPC_XIPCHIP
, 401),
7639 /* PowerPC 403 family */
7640 /* Generic PowerPC 403 */
7641 POWERPC_DEF("403", CPU_POWERPC_403
, 403),
7642 /* PowerPC 403 microcontrolers */
7643 /* PowerPC 403 GA */
7644 POWERPC_DEF("403GA", CPU_POWERPC_403GA
, 403),
7645 /* PowerPC 403 GB */
7646 POWERPC_DEF("403GB", CPU_POWERPC_403GB
, 403),
7647 /* PowerPC 403 GC */
7648 POWERPC_DEF("403GC", CPU_POWERPC_403GC
, 403),
7649 /* PowerPC 403 GCX */
7650 POWERPC_DEF("403GCX", CPU_POWERPC_403GCX
, 403GCX
),
7652 /* PowerPC 403 GP */
7653 POWERPC_DEF("403GP", CPU_POWERPC_403GP
, 403),
7655 /* PowerPC 405 family */
7656 /* Generic PowerPC 405 */
7657 POWERPC_DEF("405", CPU_POWERPC_405
, 405),
7658 /* PowerPC 405 cores */
7660 /* PowerPC 405 A3 */
7661 POWERPC_DEF("405A3", CPU_POWERPC_405A3
, 405),
7664 /* PowerPC 405 A4 */
7665 POWERPC_DEF("405A4", CPU_POWERPC_405A4
, 405),
7668 /* PowerPC 405 B3 */
7669 POWERPC_DEF("405B3", CPU_POWERPC_405B3
, 405),
7672 /* PowerPC 405 B4 */
7673 POWERPC_DEF("405B4", CPU_POWERPC_405B4
, 405),
7676 /* PowerPC 405 C3 */
7677 POWERPC_DEF("405C3", CPU_POWERPC_405C3
, 405),
7680 /* PowerPC 405 C4 */
7681 POWERPC_DEF("405C4", CPU_POWERPC_405C4
, 405),
7683 /* PowerPC 405 D2 */
7684 POWERPC_DEF("405D2", CPU_POWERPC_405D2
, 405),
7686 /* PowerPC 405 D3 */
7687 POWERPC_DEF("405D3", CPU_POWERPC_405D3
, 405),
7689 /* PowerPC 405 D4 */
7690 POWERPC_DEF("405D4", CPU_POWERPC_405D4
, 405),
7692 /* PowerPC 405 D5 */
7693 POWERPC_DEF("405D5", CPU_POWERPC_405D5
, 405),
7696 /* PowerPC 405 E4 */
7697 POWERPC_DEF("405E4", CPU_POWERPC_405E4
, 405),
7700 /* PowerPC 405 F4 */
7701 POWERPC_DEF("405F4", CPU_POWERPC_405F4
, 405),
7704 /* PowerPC 405 F5 */
7705 POWERPC_DEF("405F5", CPU_POWERPC_405F5
, 405),
7708 /* PowerPC 405 F6 */
7709 POWERPC_DEF("405F6", CPU_POWERPC_405F6
, 405),
7711 /* PowerPC 405 microcontrolers */
7712 /* PowerPC 405 CR */
7713 POWERPC_DEF("405CR", CPU_POWERPC_405CR
, 405),
7714 /* PowerPC 405 CRa */
7715 POWERPC_DEF("405CRa", CPU_POWERPC_405CRa
, 405),
7716 /* PowerPC 405 CRb */
7717 POWERPC_DEF("405CRb", CPU_POWERPC_405CRb
, 405),
7718 /* PowerPC 405 CRc */
7719 POWERPC_DEF("405CRc", CPU_POWERPC_405CRc
, 405),
7720 /* PowerPC 405 EP */
7721 POWERPC_DEF("405EP", CPU_POWERPC_405EP
, 405),
7723 /* PowerPC 405 EXr */
7724 POWERPC_DEF("405EXr", CPU_POWERPC_405EXr
, 405),
7726 /* PowerPC 405 EZ */
7727 POWERPC_DEF("405EZ", CPU_POWERPC_405EZ
, 405),
7729 /* PowerPC 405 FX */
7730 POWERPC_DEF("405FX", CPU_POWERPC_405FX
, 405),
7732 /* PowerPC 405 GP */
7733 POWERPC_DEF("405GP", CPU_POWERPC_405GP
, 405),
7734 /* PowerPC 405 GPa */
7735 POWERPC_DEF("405GPa", CPU_POWERPC_405GPa
, 405),
7736 /* PowerPC 405 GPb */
7737 POWERPC_DEF("405GPb", CPU_POWERPC_405GPb
, 405),
7738 /* PowerPC 405 GPc */
7739 POWERPC_DEF("405GPc", CPU_POWERPC_405GPc
, 405),
7740 /* PowerPC 405 GPd */
7741 POWERPC_DEF("405GPd", CPU_POWERPC_405GPd
, 405),
7742 /* PowerPC 405 GPe */
7743 POWERPC_DEF("405GPe", CPU_POWERPC_405GPe
, 405),
7744 /* PowerPC 405 GPR */
7745 POWERPC_DEF("405GPR", CPU_POWERPC_405GPR
, 405),
7748 POWERPC_DEF("405H", CPU_POWERPC_405H
, 405),
7752 POWERPC_DEF("405L", CPU_POWERPC_405L
, 405),
7754 /* PowerPC 405 LP */
7755 POWERPC_DEF("405LP", CPU_POWERPC_405LP
, 405),
7757 /* PowerPC 405 PM */
7758 POWERPC_DEF("405PM", CPU_POWERPC_405PM
, 405),
7761 /* PowerPC 405 PS */
7762 POWERPC_DEF("405PS", CPU_POWERPC_405PS
, 405),
7766 POWERPC_DEF("405S", CPU_POWERPC_405S
, 405),
7769 POWERPC_DEF("Npe405H", CPU_POWERPC_NPE405H
, 405),
7771 POWERPC_DEF("Npe405H2", CPU_POWERPC_NPE405H2
, 405),
7773 POWERPC_DEF("Npe405L", CPU_POWERPC_NPE405L
, 405),
7775 POWERPC_DEF("Npe4GS3", CPU_POWERPC_NPE4GS3
, 405),
7777 POWERPC_DEF("Npcxx1", CPU_POWERPC_NPCxx1
, 405),
7780 POWERPC_DEF("Npr161", CPU_POWERPC_NPR161
, 405),
7783 /* PowerPC LC77700 (Sanyo) */
7784 POWERPC_DEF("LC77700", CPU_POWERPC_LC77700
, 405),
7786 /* PowerPC 401/403/405 based set-top-box microcontrolers */
7789 POWERPC_DEF("STB01000", CPU_POWERPC_STB01000
, 401x2
),
7793 POWERPC_DEF("STB01010", CPU_POWERPC_STB01010
, 401x2
),
7797 POWERPC_DEF("STB0210", CPU_POWERPC_STB0210
, 401x3
),
7800 POWERPC_DEF("STB03", CPU_POWERPC_STB03
, 405),
7803 POWERPC_DEF("STB043", CPU_POWERPC_STB043
, 405),
7807 POWERPC_DEF("STB045", CPU_POWERPC_STB045
, 405),
7810 POWERPC_DEF("STB04", CPU_POWERPC_STB04
, 405),
7812 POWERPC_DEF("STB25", CPU_POWERPC_STB25
, 405),
7815 POWERPC_DEF("STB130", CPU_POWERPC_STB130
, 405),
7817 /* Xilinx PowerPC 405 cores */
7818 POWERPC_DEF("x2vp4", CPU_POWERPC_X2VP4
, 405),
7819 POWERPC_DEF("x2vp7", CPU_POWERPC_X2VP7
, 405),
7820 POWERPC_DEF("x2vp20", CPU_POWERPC_X2VP20
, 405),
7821 POWERPC_DEF("x2vp50", CPU_POWERPC_X2VP50
, 405),
7823 /* Zarlink ZL10310 */
7824 POWERPC_DEF("zl10310", CPU_POWERPC_ZL10310
, 405),
7827 /* Zarlink ZL10311 */
7828 POWERPC_DEF("zl10311", CPU_POWERPC_ZL10311
, 405),
7831 /* Zarlink ZL10320 */
7832 POWERPC_DEF("zl10320", CPU_POWERPC_ZL10320
, 405),
7835 /* Zarlink ZL10321 */
7836 POWERPC_DEF("zl10321", CPU_POWERPC_ZL10321
, 405),
7838 /* PowerPC 440 family */
7839 #if defined(TODO_USER_ONLY)
7840 /* Generic PowerPC 440 */
7841 POWERPC_DEF("440", CPU_POWERPC_440
, 440GP
),
7843 /* PowerPC 440 cores */
7845 /* PowerPC 440 A4 */
7846 POWERPC_DEF("440A4", CPU_POWERPC_440A4
, 440x4
),
7848 /* PowerPC 440 Xilinx 5 */
7849 POWERPC_DEF("440-Xilinx", CPU_POWERPC_440_XILINX
, 440x5
),
7851 /* PowerPC 440 A5 */
7852 POWERPC_DEF("440A5", CPU_POWERPC_440A5
, 440x5
),
7855 /* PowerPC 440 B4 */
7856 POWERPC_DEF("440B4", CPU_POWERPC_440B4
, 440x4
),
7859 /* PowerPC 440 G4 */
7860 POWERPC_DEF("440G4", CPU_POWERPC_440G4
, 440x4
),
7863 /* PowerPC 440 F5 */
7864 POWERPC_DEF("440F5", CPU_POWERPC_440F5
, 440x5
),
7867 /* PowerPC 440 G5 */
7868 POWERPC_DEF("440G5", CPU_POWERPC_440G5
, 440x5
),
7872 POWERPC_DEF("440H4", CPU_POWERPC_440H4
, 440x4
),
7876 POWERPC_DEF("440H6", CPU_POWERPC_440H6
, 440Gx5
),
7878 /* PowerPC 440 microcontrolers */
7879 /* PowerPC 440 EP */
7880 POWERPC_DEF("440EP", CPU_POWERPC_440EP
, 440EP
),
7881 /* PowerPC 440 EPa */
7882 POWERPC_DEF("440EPa", CPU_POWERPC_440EPa
, 440EP
),
7883 /* PowerPC 440 EPb */
7884 POWERPC_DEF("440EPb", CPU_POWERPC_440EPb
, 440EP
),
7885 /* PowerPC 440 EPX */
7886 POWERPC_DEF("440EPX", CPU_POWERPC_440EPX
, 440EP
),
7887 #if defined(TODO_USER_ONLY)
7888 /* PowerPC 440 GP */
7889 POWERPC_DEF("440GP", CPU_POWERPC_440GP
, 440GP
),
7891 #if defined(TODO_USER_ONLY)
7892 /* PowerPC 440 GPb */
7893 POWERPC_DEF("440GPb", CPU_POWERPC_440GPb
, 440GP
),
7895 #if defined(TODO_USER_ONLY)
7896 /* PowerPC 440 GPc */
7897 POWERPC_DEF("440GPc", CPU_POWERPC_440GPc
, 440GP
),
7899 #if defined(TODO_USER_ONLY)
7900 /* PowerPC 440 GR */
7901 POWERPC_DEF("440GR", CPU_POWERPC_440GR
, 440x5
),
7903 #if defined(TODO_USER_ONLY)
7904 /* PowerPC 440 GRa */
7905 POWERPC_DEF("440GRa", CPU_POWERPC_440GRa
, 440x5
),
7907 #if defined(TODO_USER_ONLY)
7908 /* PowerPC 440 GRX */
7909 POWERPC_DEF("440GRX", CPU_POWERPC_440GRX
, 440x5
),
7911 #if defined(TODO_USER_ONLY)
7912 /* PowerPC 440 GX */
7913 POWERPC_DEF("440GX", CPU_POWERPC_440GX
, 440EP
),
7915 #if defined(TODO_USER_ONLY)
7916 /* PowerPC 440 GXa */
7917 POWERPC_DEF("440GXa", CPU_POWERPC_440GXa
, 440EP
),
7919 #if defined(TODO_USER_ONLY)
7920 /* PowerPC 440 GXb */
7921 POWERPC_DEF("440GXb", CPU_POWERPC_440GXb
, 440EP
),
7923 #if defined(TODO_USER_ONLY)
7924 /* PowerPC 440 GXc */
7925 POWERPC_DEF("440GXc", CPU_POWERPC_440GXc
, 440EP
),
7927 #if defined(TODO_USER_ONLY)
7928 /* PowerPC 440 GXf */
7929 POWERPC_DEF("440GXf", CPU_POWERPC_440GXf
, 440EP
),
7933 POWERPC_DEF("440S", CPU_POWERPC_440S
, 440),
7935 #if defined(TODO_USER_ONLY)
7936 /* PowerPC 440 SP */
7937 POWERPC_DEF("440SP", CPU_POWERPC_440SP
, 440EP
),
7939 #if defined(TODO_USER_ONLY)
7940 /* PowerPC 440 SP2 */
7941 POWERPC_DEF("440SP2", CPU_POWERPC_440SP2
, 440EP
),
7943 #if defined(TODO_USER_ONLY)
7944 /* PowerPC 440 SPE */
7945 POWERPC_DEF("440SPE", CPU_POWERPC_440SPE
, 440EP
),
7947 /* PowerPC 460 family */
7949 /* Generic PowerPC 464 */
7950 POWERPC_DEF("464", CPU_POWERPC_464
, 460),
7952 /* PowerPC 464 microcontrolers */
7954 /* PowerPC 464H90 */
7955 POWERPC_DEF("464H90", CPU_POWERPC_464H90
, 460),
7958 /* PowerPC 464H90F */
7959 POWERPC_DEF("464H90F", CPU_POWERPC_464H90F
, 460F
),
7961 /* Freescale embedded PowerPC cores */
7962 /* MPC5xx family (aka RCPU) */
7963 #if defined(TODO_USER_ONLY)
7964 /* Generic MPC5xx core */
7965 POWERPC_DEF("MPC5xx", CPU_POWERPC_MPC5xx
, MPC5xx
),
7967 #if defined(TODO_USER_ONLY)
7968 /* Codename for MPC5xx core */
7969 POWERPC_DEF("RCPU", CPU_POWERPC_MPC5xx
, MPC5xx
),
7971 /* MPC5xx microcontrollers */
7972 #if defined(TODO_USER_ONLY)
7974 POWERPC_DEF("MGT560", CPU_POWERPC_MGT560
, MPC5xx
),
7976 #if defined(TODO_USER_ONLY)
7978 POWERPC_DEF("MPC509", CPU_POWERPC_MPC509
, MPC5xx
),
7980 #if defined(TODO_USER_ONLY)
7982 POWERPC_DEF("MPC533", CPU_POWERPC_MPC533
, MPC5xx
),
7984 #if defined(TODO_USER_ONLY)
7986 POWERPC_DEF("MPC534", CPU_POWERPC_MPC534
, MPC5xx
),
7988 #if defined(TODO_USER_ONLY)
7990 POWERPC_DEF("MPC555", CPU_POWERPC_MPC555
, MPC5xx
),
7992 #if defined(TODO_USER_ONLY)
7994 POWERPC_DEF("MPC556", CPU_POWERPC_MPC556
, MPC5xx
),
7996 #if defined(TODO_USER_ONLY)
7998 POWERPC_DEF("MPC560", CPU_POWERPC_MPC560
, MPC5xx
),
8000 #if defined(TODO_USER_ONLY)
8002 POWERPC_DEF("MPC561", CPU_POWERPC_MPC561
, MPC5xx
),
8004 #if defined(TODO_USER_ONLY)
8006 POWERPC_DEF("MPC562", CPU_POWERPC_MPC562
, MPC5xx
),
8008 #if defined(TODO_USER_ONLY)
8010 POWERPC_DEF("MPC563", CPU_POWERPC_MPC563
, MPC5xx
),
8012 #if defined(TODO_USER_ONLY)
8014 POWERPC_DEF("MPC564", CPU_POWERPC_MPC564
, MPC5xx
),
8016 #if defined(TODO_USER_ONLY)
8018 POWERPC_DEF("MPC565", CPU_POWERPC_MPC565
, MPC5xx
),
8020 #if defined(TODO_USER_ONLY)
8022 POWERPC_DEF("MPC566", CPU_POWERPC_MPC566
, MPC5xx
),
8024 /* MPC8xx family (aka PowerQUICC) */
8025 #if defined(TODO_USER_ONLY)
8026 /* Generic MPC8xx core */
8027 POWERPC_DEF("MPC8xx", CPU_POWERPC_MPC8xx
, MPC8xx
),
8029 #if defined(TODO_USER_ONLY)
8030 /* Codename for MPC8xx core */
8031 POWERPC_DEF("PowerQUICC", CPU_POWERPC_MPC8xx
, MPC8xx
),
8033 /* MPC8xx microcontrollers */
8034 #if defined(TODO_USER_ONLY)
8036 POWERPC_DEF("MGT823", CPU_POWERPC_MGT823
, MPC8xx
),
8038 #if defined(TODO_USER_ONLY)
8040 POWERPC_DEF("MPC821", CPU_POWERPC_MPC821
, MPC8xx
),
8042 #if defined(TODO_USER_ONLY)
8044 POWERPC_DEF("MPC823", CPU_POWERPC_MPC823
, MPC8xx
),
8046 #if defined(TODO_USER_ONLY)
8048 POWERPC_DEF("MPC850", CPU_POWERPC_MPC850
, MPC8xx
),
8050 #if defined(TODO_USER_ONLY)
8052 POWERPC_DEF("MPC852T", CPU_POWERPC_MPC852T
, MPC8xx
),
8054 #if defined(TODO_USER_ONLY)
8056 POWERPC_DEF("MPC855T", CPU_POWERPC_MPC855T
, MPC8xx
),
8058 #if defined(TODO_USER_ONLY)
8060 POWERPC_DEF("MPC857", CPU_POWERPC_MPC857
, MPC8xx
),
8062 #if defined(TODO_USER_ONLY)
8064 POWERPC_DEF("MPC859", CPU_POWERPC_MPC859
, MPC8xx
),
8066 #if defined(TODO_USER_ONLY)
8068 POWERPC_DEF("MPC860", CPU_POWERPC_MPC860
, MPC8xx
),
8070 #if defined(TODO_USER_ONLY)
8072 POWERPC_DEF("MPC862", CPU_POWERPC_MPC862
, MPC8xx
),
8074 #if defined(TODO_USER_ONLY)
8076 POWERPC_DEF("MPC866", CPU_POWERPC_MPC866
, MPC8xx
),
8078 #if defined(TODO_USER_ONLY)
8080 POWERPC_DEF("MPC870", CPU_POWERPC_MPC870
, MPC8xx
),
8082 #if defined(TODO_USER_ONLY)
8084 POWERPC_DEF("MPC875", CPU_POWERPC_MPC875
, MPC8xx
),
8086 #if defined(TODO_USER_ONLY)
8088 POWERPC_DEF("MPC880", CPU_POWERPC_MPC880
, MPC8xx
),
8090 #if defined(TODO_USER_ONLY)
8092 POWERPC_DEF("MPC885", CPU_POWERPC_MPC885
, MPC8xx
),
8094 /* MPC82xx family (aka PowerQUICC-II) */
8095 /* Generic MPC52xx core */
8096 POWERPC_DEF_SVR("MPC52xx",
8097 CPU_POWERPC_MPC52xx
, POWERPC_SVR_52xx
, G2LE
),
8098 /* Generic MPC82xx core */
8099 POWERPC_DEF("MPC82xx", CPU_POWERPC_MPC82xx
, G2
),
8100 /* Codename for MPC82xx */
8101 POWERPC_DEF("PowerQUICC-II", CPU_POWERPC_MPC82xx
, G2
),
8102 /* PowerPC G2 core */
8103 POWERPC_DEF("G2", CPU_POWERPC_G2
, G2
),
8104 /* PowerPC G2 H4 core */
8105 POWERPC_DEF("G2H4", CPU_POWERPC_G2H4
, G2
),
8106 /* PowerPC G2 GP core */
8107 POWERPC_DEF("G2GP", CPU_POWERPC_G2gp
, G2
),
8108 /* PowerPC G2 LS core */
8109 POWERPC_DEF("G2LS", CPU_POWERPC_G2ls
, G2
),
8110 /* PowerPC G2 HiP3 core */
8111 POWERPC_DEF("G2HiP3", CPU_POWERPC_G2_HIP3
, G2
),
8112 /* PowerPC G2 HiP4 core */
8113 POWERPC_DEF("G2HiP4", CPU_POWERPC_G2_HIP4
, G2
),
8114 /* PowerPC MPC603 core */
8115 POWERPC_DEF("MPC603", CPU_POWERPC_MPC603
, 603E
),
8116 /* PowerPC G2le core (same as G2 plus little-endian mode support) */
8117 POWERPC_DEF("G2le", CPU_POWERPC_G2LE
, G2LE
),
8118 /* PowerPC G2LE GP core */
8119 POWERPC_DEF("G2leGP", CPU_POWERPC_G2LEgp
, G2LE
),
8120 /* PowerPC G2LE LS core */
8121 POWERPC_DEF("G2leLS", CPU_POWERPC_G2LEls
, G2LE
),
8122 /* PowerPC G2LE GP1 core */
8123 POWERPC_DEF("G2leGP1", CPU_POWERPC_G2LEgp1
, G2LE
),
8124 /* PowerPC G2LE GP3 core */
8125 POWERPC_DEF("G2leGP3", CPU_POWERPC_G2LEgp1
, G2LE
),
8126 /* PowerPC MPC603 microcontrollers */
8128 POWERPC_DEF("MPC8240", CPU_POWERPC_MPC8240
, 603E
),
8129 /* PowerPC G2 microcontrollers */
8132 POWERPC_DEF_SVR("MPC5121",
8133 CPU_POWERPC_MPC5121
, POWERPC_SVR_5121
, G2LE
),
8136 POWERPC_DEF_SVR("MPC5200",
8137 CPU_POWERPC_MPC5200
, POWERPC_SVR_5200
, G2LE
),
8139 POWERPC_DEF_SVR("MPC5200_v10",
8140 CPU_POWERPC_MPC5200_v10
, POWERPC_SVR_5200_v10
, G2LE
),
8142 POWERPC_DEF_SVR("MPC5200_v11",
8143 CPU_POWERPC_MPC5200_v11
, POWERPC_SVR_5200_v11
, G2LE
),
8145 POWERPC_DEF_SVR("MPC5200_v12",
8146 CPU_POWERPC_MPC5200_v12
, POWERPC_SVR_5200_v12
, G2LE
),
8148 POWERPC_DEF_SVR("MPC5200B",
8149 CPU_POWERPC_MPC5200B
, POWERPC_SVR_5200B
, G2LE
),
8151 POWERPC_DEF_SVR("MPC5200B_v20",
8152 CPU_POWERPC_MPC5200B_v20
, POWERPC_SVR_5200B_v20
, G2LE
),
8154 POWERPC_DEF_SVR("MPC5200B_v21",
8155 CPU_POWERPC_MPC5200B_v21
, POWERPC_SVR_5200B_v21
, G2LE
),
8157 POWERPC_DEF("MPC8241", CPU_POWERPC_MPC8241
, G2
),
8159 POWERPC_DEF("MPC8245", CPU_POWERPC_MPC8245
, G2
),
8161 POWERPC_DEF("MPC8247", CPU_POWERPC_MPC8247
, G2LE
),
8163 POWERPC_DEF("MPC8248", CPU_POWERPC_MPC8248
, G2LE
),
8165 POWERPC_DEF("MPC8250", CPU_POWERPC_MPC8250
, G2
),
8167 POWERPC_DEF("MPC8250_HiP3", CPU_POWERPC_MPC8250_HiP3
, G2
),
8169 POWERPC_DEF("MPC8250_HiP4", CPU_POWERPC_MPC8250_HiP4
, G2
),
8171 POWERPC_DEF("MPC8255", CPU_POWERPC_MPC8255
, G2
),
8173 POWERPC_DEF("MPC8255_HiP3", CPU_POWERPC_MPC8255_HiP3
, G2
),
8175 POWERPC_DEF("MPC8255_HiP4", CPU_POWERPC_MPC8255_HiP4
, G2
),
8177 POWERPC_DEF("MPC8260", CPU_POWERPC_MPC8260
, G2
),
8179 POWERPC_DEF("MPC8260_HiP3", CPU_POWERPC_MPC8260_HiP3
, G2
),
8181 POWERPC_DEF("MPC8260_HiP4", CPU_POWERPC_MPC8260_HiP4
, G2
),
8183 POWERPC_DEF("MPC8264", CPU_POWERPC_MPC8264
, G2
),
8185 POWERPC_DEF("MPC8264_HiP3", CPU_POWERPC_MPC8264_HiP3
, G2
),
8187 POWERPC_DEF("MPC8264_HiP4", CPU_POWERPC_MPC8264_HiP4
, G2
),
8189 POWERPC_DEF("MPC8265", CPU_POWERPC_MPC8265
, G2
),
8191 POWERPC_DEF("MPC8265_HiP3", CPU_POWERPC_MPC8265_HiP3
, G2
),
8193 POWERPC_DEF("MPC8265_HiP4", CPU_POWERPC_MPC8265_HiP4
, G2
),
8195 POWERPC_DEF("MPC8266", CPU_POWERPC_MPC8266
, G2
),
8197 POWERPC_DEF("MPC8266_HiP3", CPU_POWERPC_MPC8266_HiP3
, G2
),
8199 POWERPC_DEF("MPC8266_HiP4", CPU_POWERPC_MPC8266_HiP4
, G2
),
8201 POWERPC_DEF("MPC8270", CPU_POWERPC_MPC8270
, G2LE
),
8203 POWERPC_DEF("MPC8271", CPU_POWERPC_MPC8271
, G2LE
),
8205 POWERPC_DEF("MPC8272", CPU_POWERPC_MPC8272
, G2LE
),
8207 POWERPC_DEF("MPC8275", CPU_POWERPC_MPC8275
, G2LE
),
8209 POWERPC_DEF("MPC8280", CPU_POWERPC_MPC8280
, G2LE
),
8211 /* Generic PowerPC e200 core */
8212 POWERPC_DEF("e200", CPU_POWERPC_e200
, e200
),
8213 /* Generic MPC55xx core */
8215 POWERPC_DEF_SVR("MPC55xx",
8216 CPU_POWERPC_MPC55xx
, POWERPC_SVR_55xx
, e200
),
8219 /* PowerPC e200z0 core */
8220 POWERPC_DEF("e200z0", CPU_POWERPC_e200z0
, e200
),
8223 /* PowerPC e200z1 core */
8224 POWERPC_DEF("e200z1", CPU_POWERPC_e200z1
, e200
),
8227 /* PowerPC e200z3 core */
8228 POWERPC_DEF("e200z3", CPU_POWERPC_e200z3
, e200
),
8230 /* PowerPC e200z5 core */
8231 POWERPC_DEF("e200z5", CPU_POWERPC_e200z5
, e200
),
8232 /* PowerPC e200z6 core */
8233 POWERPC_DEF("e200z6", CPU_POWERPC_e200z6
, e200
),
8234 /* PowerPC e200 microcontrollers */
8237 POWERPC_DEF_SVR("MPC5514E",
8238 CPU_POWERPC_MPC5514E
, POWERPC_SVR_5514E
, e200
),
8242 POWERPC_DEF_SVR("MPC5514E_v0",
8243 CPU_POWERPC_MPC5514E_v0
, POWERPC_SVR_5514E_v0
, e200
),
8247 POWERPC_DEF_SVR("MPC5514E_v1",
8248 CPU_POWERPC_MPC5514E_v1
, POWERPC_SVR_5514E_v1
, e200
),
8252 POWERPC_DEF_SVR("MPC5514G",
8253 CPU_POWERPC_MPC5514G
, POWERPC_SVR_5514G
, e200
),
8257 POWERPC_DEF_SVR("MPC5514G_v0",
8258 CPU_POWERPC_MPC5514G_v0
, POWERPC_SVR_5514G_v0
, e200
),
8262 POWERPC_DEF_SVR("MPC5514G_v1",
8263 CPU_POWERPC_MPC5514G_v1
, POWERPC_SVR_5514G_v1
, e200
),
8267 POWERPC_DEF_SVR("MPC5515S",
8268 CPU_POWERPC_MPC5515S
, POWERPC_SVR_5515S
, e200
),
8272 POWERPC_DEF_SVR("MPC5516E",
8273 CPU_POWERPC_MPC5516E
, POWERPC_SVR_5516E
, e200
),
8277 POWERPC_DEF_SVR("MPC5516E_v0",
8278 CPU_POWERPC_MPC5516E_v0
, POWERPC_SVR_5516E_v0
, e200
),
8282 POWERPC_DEF_SVR("MPC5516E_v1",
8283 CPU_POWERPC_MPC5516E_v1
, POWERPC_SVR_5516E_v1
, e200
),
8287 POWERPC_DEF_SVR("MPC5516G",
8288 CPU_POWERPC_MPC5516G
, POWERPC_SVR_5516G
, e200
),
8292 POWERPC_DEF_SVR("MPC5516G_v0",
8293 CPU_POWERPC_MPC5516G_v0
, POWERPC_SVR_5516G_v0
, e200
),
8297 POWERPC_DEF_SVR("MPC5516G_v1",
8298 CPU_POWERPC_MPC5516G_v1
, POWERPC_SVR_5516G_v1
, e200
),
8302 POWERPC_DEF_SVR("MPC5516S",
8303 CPU_POWERPC_MPC5516S
, POWERPC_SVR_5516S
, e200
),
8307 POWERPC_DEF_SVR("MPC5533",
8308 CPU_POWERPC_MPC5533
, POWERPC_SVR_5533
, e200
),
8312 POWERPC_DEF_SVR("MPC5534",
8313 CPU_POWERPC_MPC5534
, POWERPC_SVR_5534
, e200
),
8317 POWERPC_DEF_SVR("MPC5553",
8318 CPU_POWERPC_MPC5553
, POWERPC_SVR_5553
, e200
),
8322 POWERPC_DEF_SVR("MPC5554",
8323 CPU_POWERPC_MPC5554
, POWERPC_SVR_5554
, e200
),
8327 POWERPC_DEF_SVR("MPC5561",
8328 CPU_POWERPC_MPC5561
, POWERPC_SVR_5561
, e200
),
8332 POWERPC_DEF_SVR("MPC5565",
8333 CPU_POWERPC_MPC5565
, POWERPC_SVR_5565
, e200
),
8337 POWERPC_DEF_SVR("MPC5566",
8338 CPU_POWERPC_MPC5566
, POWERPC_SVR_5566
, e200
),
8342 POWERPC_DEF_SVR("MPC5567",
8343 CPU_POWERPC_MPC5567
, POWERPC_SVR_5567
, e200
),
8346 /* Generic PowerPC e300 core */
8347 POWERPC_DEF("e300", CPU_POWERPC_e300
, e300
),
8348 /* PowerPC e300c1 core */
8349 POWERPC_DEF("e300c1", CPU_POWERPC_e300c1
, e300
),
8350 /* PowerPC e300c2 core */
8351 POWERPC_DEF("e300c2", CPU_POWERPC_e300c2
, e300
),
8352 /* PowerPC e300c3 core */
8353 POWERPC_DEF("e300c3", CPU_POWERPC_e300c3
, e300
),
8354 /* PowerPC e300c4 core */
8355 POWERPC_DEF("e300c4", CPU_POWERPC_e300c4
, e300
),
8356 /* PowerPC e300 microcontrollers */
8359 POWERPC_DEF_SVR("MPC8313",
8360 CPU_POWERPC_MPC831x
, POWERPC_SVR_8313
, e300
),
8364 POWERPC_DEF_SVR("MPC8313E",
8365 CPU_POWERPC_MPC831x
, POWERPC_SVR_8313E
, e300
),
8369 POWERPC_DEF_SVR("MPC8314",
8370 CPU_POWERPC_MPC831x
, POWERPC_SVR_8314
, e300
),
8374 POWERPC_DEF_SVR("MPC8314E",
8375 CPU_POWERPC_MPC831x
, POWERPC_SVR_8314E
, e300
),
8379 POWERPC_DEF_SVR("MPC8315",
8380 CPU_POWERPC_MPC831x
, POWERPC_SVR_8315
, e300
),
8384 POWERPC_DEF_SVR("MPC8315E",
8385 CPU_POWERPC_MPC831x
, POWERPC_SVR_8315E
, e300
),
8389 POWERPC_DEF_SVR("MPC8321",
8390 CPU_POWERPC_MPC832x
, POWERPC_SVR_8321
, e300
),
8394 POWERPC_DEF_SVR("MPC8321E",
8395 CPU_POWERPC_MPC832x
, POWERPC_SVR_8321E
, e300
),
8399 POWERPC_DEF_SVR("MPC8323",
8400 CPU_POWERPC_MPC832x
, POWERPC_SVR_8323
, e300
),
8404 POWERPC_DEF_SVR("MPC8323E",
8405 CPU_POWERPC_MPC832x
, POWERPC_SVR_8323E
, e300
),
8408 POWERPC_DEF_SVR("MPC8343",
8409 CPU_POWERPC_MPC834x
, POWERPC_SVR_8343
, e300
),
8411 POWERPC_DEF_SVR("MPC8343A",
8412 CPU_POWERPC_MPC834x
, POWERPC_SVR_8343A
, e300
),
8414 POWERPC_DEF_SVR("MPC8343E",
8415 CPU_POWERPC_MPC834x
, POWERPC_SVR_8343E
, e300
),
8417 POWERPC_DEF_SVR("MPC8343EA",
8418 CPU_POWERPC_MPC834x
, POWERPC_SVR_8343EA
, e300
),
8420 POWERPC_DEF_SVR("MPC8347",
8421 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347
, e300
),
8423 POWERPC_DEF_SVR("MPC8347T",
8424 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347T
, e300
),
8426 POWERPC_DEF_SVR("MPC8347P",
8427 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347P
, e300
),
8429 POWERPC_DEF_SVR("MPC8347A",
8430 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347A
, e300
),
8432 POWERPC_DEF_SVR("MPC8347AT",
8433 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347AT
, e300
),
8435 POWERPC_DEF_SVR("MPC8347AP",
8436 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347AP
, e300
),
8438 POWERPC_DEF_SVR("MPC8347E",
8439 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347E
, e300
),
8441 POWERPC_DEF_SVR("MPC8347ET",
8442 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347ET
, e300
),
8444 POWERPC_DEF_SVR("MPC8347EP",
8445 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347EP
, e300
),
8447 POWERPC_DEF_SVR("MPC8347EA",
8448 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347EA
, e300
),
8450 POWERPC_DEF_SVR("MPC8347EAT",
8451 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347EAT
, e300
),
8453 POWERPC_DEF_SVR("MPC8347EAP",
8454 CPU_POWERPC_MPC834x
, POWERPC_SVR_8347EAP
, e300
),
8456 POWERPC_DEF_SVR("MPC8349",
8457 CPU_POWERPC_MPC834x
, POWERPC_SVR_8349
, e300
),
8459 POWERPC_DEF_SVR("MPC8349A",
8460 CPU_POWERPC_MPC834x
, POWERPC_SVR_8349A
, e300
),
8462 POWERPC_DEF_SVR("MPC8349E",
8463 CPU_POWERPC_MPC834x
, POWERPC_SVR_8349E
, e300
),
8465 POWERPC_DEF_SVR("MPC8349EA",
8466 CPU_POWERPC_MPC834x
, POWERPC_SVR_8349EA
, e300
),
8469 POWERPC_DEF_SVR("MPC8358E",
8470 CPU_POWERPC_MPC835x
, POWERPC_SVR_8358E
, e300
),
8474 POWERPC_DEF_SVR("MPC8360E",
8475 CPU_POWERPC_MPC836x
, POWERPC_SVR_8360E
, e300
),
8478 POWERPC_DEF_SVR("MPC8377",
8479 CPU_POWERPC_MPC837x
, POWERPC_SVR_8377
, e300
),
8481 POWERPC_DEF_SVR("MPC8377E",
8482 CPU_POWERPC_MPC837x
, POWERPC_SVR_8377E
, e300
),
8484 POWERPC_DEF_SVR("MPC8378",
8485 CPU_POWERPC_MPC837x
, POWERPC_SVR_8378
, e300
),
8487 POWERPC_DEF_SVR("MPC8378E",
8488 CPU_POWERPC_MPC837x
, POWERPC_SVR_8378E
, e300
),
8490 POWERPC_DEF_SVR("MPC8379",
8491 CPU_POWERPC_MPC837x
, POWERPC_SVR_8379
, e300
),
8493 POWERPC_DEF_SVR("MPC8379E",
8494 CPU_POWERPC_MPC837x
, POWERPC_SVR_8379E
, e300
),
8496 /* PowerPC e500 core */
8497 POWERPC_DEF("e500", CPU_POWERPC_e500v2_v22
, e500v2
),
8498 /* PowerPC e500v1 core */
8499 POWERPC_DEF("e500v1", CPU_POWERPC_e500v1
, e500v1
),
8500 /* PowerPC e500 v1.0 core */
8501 POWERPC_DEF("e500_v10", CPU_POWERPC_e500v1_v10
, e500v1
),
8502 /* PowerPC e500 v2.0 core */
8503 POWERPC_DEF("e500_v20", CPU_POWERPC_e500v1_v20
, e500v1
),
8504 /* PowerPC e500v2 core */
8505 POWERPC_DEF("e500v2", CPU_POWERPC_e500v2
, e500v2
),
8506 /* PowerPC e500v2 v1.0 core */
8507 POWERPC_DEF("e500v2_v10", CPU_POWERPC_e500v2_v10
, e500v2
),
8508 /* PowerPC e500v2 v2.0 core */
8509 POWERPC_DEF("e500v2_v20", CPU_POWERPC_e500v2_v20
, e500v2
),
8510 /* PowerPC e500v2 v2.1 core */
8511 POWERPC_DEF("e500v2_v21", CPU_POWERPC_e500v2_v21
, e500v2
),
8512 /* PowerPC e500v2 v2.2 core */
8513 POWERPC_DEF("e500v2_v22", CPU_POWERPC_e500v2_v22
, e500v2
),
8514 /* PowerPC e500v2 v3.0 core */
8515 POWERPC_DEF("e500v2_v30", CPU_POWERPC_e500v2_v30
, e500v2
),
8516 POWERPC_DEF("e500mc", CPU_POWERPC_e500mc
, e500mc
),
8517 /* PowerPC e500 microcontrollers */
8519 POWERPC_DEF_SVR("MPC8533",
8520 CPU_POWERPC_MPC8533
, POWERPC_SVR_8533
, e500v2
),
8522 POWERPC_DEF_SVR("MPC8533_v10",
8523 CPU_POWERPC_MPC8533_v10
, POWERPC_SVR_8533_v10
, e500v2
),
8525 POWERPC_DEF_SVR("MPC8533_v11",
8526 CPU_POWERPC_MPC8533_v11
, POWERPC_SVR_8533_v11
, e500v2
),
8528 POWERPC_DEF_SVR("MPC8533E",
8529 CPU_POWERPC_MPC8533E
, POWERPC_SVR_8533E
, e500v2
),
8531 POWERPC_DEF_SVR("MPC8533E_v10",
8532 CPU_POWERPC_MPC8533E_v10
, POWERPC_SVR_8533E_v10
, e500v2
),
8533 POWERPC_DEF_SVR("MPC8533E_v11",
8534 CPU_POWERPC_MPC8533E_v11
, POWERPC_SVR_8533E_v11
, e500v2
),
8536 POWERPC_DEF_SVR("MPC8540",
8537 CPU_POWERPC_MPC8540
, POWERPC_SVR_8540
, e500v1
),
8539 POWERPC_DEF_SVR("MPC8540_v10",
8540 CPU_POWERPC_MPC8540_v10
, POWERPC_SVR_8540_v10
, e500v1
),
8542 POWERPC_DEF_SVR("MPC8540_v20",
8543 CPU_POWERPC_MPC8540_v20
, POWERPC_SVR_8540_v20
, e500v1
),
8545 POWERPC_DEF_SVR("MPC8540_v21",
8546 CPU_POWERPC_MPC8540_v21
, POWERPC_SVR_8540_v21
, e500v1
),
8548 POWERPC_DEF_SVR("MPC8541",
8549 CPU_POWERPC_MPC8541
, POWERPC_SVR_8541
, e500v1
),
8551 POWERPC_DEF_SVR("MPC8541_v10",
8552 CPU_POWERPC_MPC8541_v10
, POWERPC_SVR_8541_v10
, e500v1
),
8554 POWERPC_DEF_SVR("MPC8541_v11",
8555 CPU_POWERPC_MPC8541_v11
, POWERPC_SVR_8541_v11
, e500v1
),
8557 POWERPC_DEF_SVR("MPC8541E",
8558 CPU_POWERPC_MPC8541E
, POWERPC_SVR_8541E
, e500v1
),
8560 POWERPC_DEF_SVR("MPC8541E_v10",
8561 CPU_POWERPC_MPC8541E_v10
, POWERPC_SVR_8541E_v10
, e500v1
),
8563 POWERPC_DEF_SVR("MPC8541E_v11",
8564 CPU_POWERPC_MPC8541E_v11
, POWERPC_SVR_8541E_v11
, e500v1
),
8566 POWERPC_DEF_SVR("MPC8543",
8567 CPU_POWERPC_MPC8543
, POWERPC_SVR_8543
, e500v2
),
8569 POWERPC_DEF_SVR("MPC8543_v10",
8570 CPU_POWERPC_MPC8543_v10
, POWERPC_SVR_8543_v10
, e500v2
),
8572 POWERPC_DEF_SVR("MPC8543_v11",
8573 CPU_POWERPC_MPC8543_v11
, POWERPC_SVR_8543_v11
, e500v2
),
8575 POWERPC_DEF_SVR("MPC8543_v20",
8576 CPU_POWERPC_MPC8543_v20
, POWERPC_SVR_8543_v20
, e500v2
),
8578 POWERPC_DEF_SVR("MPC8543_v21",
8579 CPU_POWERPC_MPC8543_v21
, POWERPC_SVR_8543_v21
, e500v2
),
8581 POWERPC_DEF_SVR("MPC8543E",
8582 CPU_POWERPC_MPC8543E
, POWERPC_SVR_8543E
, e500v2
),
8584 POWERPC_DEF_SVR("MPC8543E_v10",
8585 CPU_POWERPC_MPC8543E_v10
, POWERPC_SVR_8543E_v10
, e500v2
),
8587 POWERPC_DEF_SVR("MPC8543E_v11",
8588 CPU_POWERPC_MPC8543E_v11
, POWERPC_SVR_8543E_v11
, e500v2
),
8590 POWERPC_DEF_SVR("MPC8543E_v20",
8591 CPU_POWERPC_MPC8543E_v20
, POWERPC_SVR_8543E_v20
, e500v2
),
8593 POWERPC_DEF_SVR("MPC8543E_v21",
8594 CPU_POWERPC_MPC8543E_v21
, POWERPC_SVR_8543E_v21
, e500v2
),
8596 POWERPC_DEF_SVR("MPC8544",
8597 CPU_POWERPC_MPC8544
, POWERPC_SVR_8544
, e500v2
),
8599 POWERPC_DEF_SVR("MPC8544_v10",
8600 CPU_POWERPC_MPC8544_v10
, POWERPC_SVR_8544_v10
, e500v2
),
8602 POWERPC_DEF_SVR("MPC8544_v11",
8603 CPU_POWERPC_MPC8544_v11
, POWERPC_SVR_8544_v11
, e500v2
),
8605 POWERPC_DEF_SVR("MPC8544E",
8606 CPU_POWERPC_MPC8544E
, POWERPC_SVR_8544E
, e500v2
),
8608 POWERPC_DEF_SVR("MPC8544E_v10",
8609 CPU_POWERPC_MPC8544E_v10
, POWERPC_SVR_8544E_v10
, e500v2
),
8611 POWERPC_DEF_SVR("MPC8544E_v11",
8612 CPU_POWERPC_MPC8544E_v11
, POWERPC_SVR_8544E_v11
, e500v2
),
8614 POWERPC_DEF_SVR("MPC8545",
8615 CPU_POWERPC_MPC8545
, POWERPC_SVR_8545
, e500v2
),
8617 POWERPC_DEF_SVR("MPC8545_v20",
8618 CPU_POWERPC_MPC8545_v20
, POWERPC_SVR_8545_v20
, e500v2
),
8620 POWERPC_DEF_SVR("MPC8545_v21",
8621 CPU_POWERPC_MPC8545_v21
, POWERPC_SVR_8545_v21
, e500v2
),
8623 POWERPC_DEF_SVR("MPC8545E",
8624 CPU_POWERPC_MPC8545E
, POWERPC_SVR_8545E
, e500v2
),
8626 POWERPC_DEF_SVR("MPC8545E_v20",
8627 CPU_POWERPC_MPC8545E_v20
, POWERPC_SVR_8545E_v20
, e500v2
),
8629 POWERPC_DEF_SVR("MPC8545E_v21",
8630 CPU_POWERPC_MPC8545E_v21
, POWERPC_SVR_8545E_v21
, e500v2
),
8632 POWERPC_DEF_SVR("MPC8547E",
8633 CPU_POWERPC_MPC8547E
, POWERPC_SVR_8547E
, e500v2
),
8635 POWERPC_DEF_SVR("MPC8547E_v20",
8636 CPU_POWERPC_MPC8547E_v20
, POWERPC_SVR_8547E_v20
, e500v2
),
8638 POWERPC_DEF_SVR("MPC8547E_v21",
8639 CPU_POWERPC_MPC8547E_v21
, POWERPC_SVR_8547E_v21
, e500v2
),
8641 POWERPC_DEF_SVR("MPC8548",
8642 CPU_POWERPC_MPC8548
, POWERPC_SVR_8548
, e500v2
),
8644 POWERPC_DEF_SVR("MPC8548_v10",
8645 CPU_POWERPC_MPC8548_v10
, POWERPC_SVR_8548_v10
, e500v2
),
8647 POWERPC_DEF_SVR("MPC8548_v11",
8648 CPU_POWERPC_MPC8548_v11
, POWERPC_SVR_8548_v11
, e500v2
),
8650 POWERPC_DEF_SVR("MPC8548_v20",
8651 CPU_POWERPC_MPC8548_v20
, POWERPC_SVR_8548_v20
, e500v2
),
8653 POWERPC_DEF_SVR("MPC8548_v21",
8654 CPU_POWERPC_MPC8548_v21
, POWERPC_SVR_8548_v21
, e500v2
),
8656 POWERPC_DEF_SVR("MPC8548E",
8657 CPU_POWERPC_MPC8548E
, POWERPC_SVR_8548E
, e500v2
),
8659 POWERPC_DEF_SVR("MPC8548E_v10",
8660 CPU_POWERPC_MPC8548E_v10
, POWERPC_SVR_8548E_v10
, e500v2
),
8662 POWERPC_DEF_SVR("MPC8548E_v11",
8663 CPU_POWERPC_MPC8548E_v11
, POWERPC_SVR_8548E_v11
, e500v2
),
8665 POWERPC_DEF_SVR("MPC8548E_v20",
8666 CPU_POWERPC_MPC8548E_v20
, POWERPC_SVR_8548E_v20
, e500v2
),
8668 POWERPC_DEF_SVR("MPC8548E_v21",
8669 CPU_POWERPC_MPC8548E_v21
, POWERPC_SVR_8548E_v21
, e500v2
),
8671 POWERPC_DEF_SVR("MPC8555",
8672 CPU_POWERPC_MPC8555
, POWERPC_SVR_8555
, e500v2
),
8674 POWERPC_DEF_SVR("MPC8555_v10",
8675 CPU_POWERPC_MPC8555_v10
, POWERPC_SVR_8555_v10
, e500v2
),
8677 POWERPC_DEF_SVR("MPC8555_v11",
8678 CPU_POWERPC_MPC8555_v11
, POWERPC_SVR_8555_v11
, e500v2
),
8680 POWERPC_DEF_SVR("MPC8555E",
8681 CPU_POWERPC_MPC8555E
, POWERPC_SVR_8555E
, e500v2
),
8683 POWERPC_DEF_SVR("MPC8555E_v10",
8684 CPU_POWERPC_MPC8555E_v10
, POWERPC_SVR_8555E_v10
, e500v2
),
8686 POWERPC_DEF_SVR("MPC8555E_v11",
8687 CPU_POWERPC_MPC8555E_v11
, POWERPC_SVR_8555E_v11
, e500v2
),
8689 POWERPC_DEF_SVR("MPC8560",
8690 CPU_POWERPC_MPC8560
, POWERPC_SVR_8560
, e500v2
),
8692 POWERPC_DEF_SVR("MPC8560_v10",
8693 CPU_POWERPC_MPC8560_v10
, POWERPC_SVR_8560_v10
, e500v2
),
8695 POWERPC_DEF_SVR("MPC8560_v20",
8696 CPU_POWERPC_MPC8560_v20
, POWERPC_SVR_8560_v20
, e500v2
),
8698 POWERPC_DEF_SVR("MPC8560_v21",
8699 CPU_POWERPC_MPC8560_v21
, POWERPC_SVR_8560_v21
, e500v2
),
8701 POWERPC_DEF_SVR("MPC8567",
8702 CPU_POWERPC_MPC8567
, POWERPC_SVR_8567
, e500v2
),
8704 POWERPC_DEF_SVR("MPC8567E",
8705 CPU_POWERPC_MPC8567E
, POWERPC_SVR_8567E
, e500v2
),
8707 POWERPC_DEF_SVR("MPC8568",
8708 CPU_POWERPC_MPC8568
, POWERPC_SVR_8568
, e500v2
),
8710 POWERPC_DEF_SVR("MPC8568E",
8711 CPU_POWERPC_MPC8568E
, POWERPC_SVR_8568E
, e500v2
),
8713 POWERPC_DEF_SVR("MPC8572",
8714 CPU_POWERPC_MPC8572
, POWERPC_SVR_8572
, e500v2
),
8716 POWERPC_DEF_SVR("MPC8572E",
8717 CPU_POWERPC_MPC8572E
, POWERPC_SVR_8572E
, e500v2
),
8719 /* PowerPC e600 core */
8720 POWERPC_DEF("e600", CPU_POWERPC_e600
, 7400),
8721 /* PowerPC e600 microcontrollers */
8724 POWERPC_DEF_SVR("MPC8610",
8725 CPU_POWERPC_MPC8610
, POWERPC_SVR_8610
, 7400),
8728 POWERPC_DEF_SVR("MPC8641",
8729 CPU_POWERPC_MPC8641
, POWERPC_SVR_8641
, 7400),
8731 POWERPC_DEF_SVR("MPC8641D",
8732 CPU_POWERPC_MPC8641D
, POWERPC_SVR_8641D
, 7400),
8733 /* 32 bits "classic" PowerPC */
8734 /* PowerPC 6xx family */
8736 POWERPC_DEF("601", CPU_POWERPC_601
, 601v
),
8738 POWERPC_DEF("601_v0", CPU_POWERPC_601_v0
, 601),
8740 POWERPC_DEF("601_v1", CPU_POWERPC_601_v1
, 601),
8742 POWERPC_DEF("601v", CPU_POWERPC_601v
, 601v
),
8744 POWERPC_DEF("601_v2", CPU_POWERPC_601_v2
, 601v
),
8746 POWERPC_DEF("602", CPU_POWERPC_602
, 602),
8748 POWERPC_DEF("603", CPU_POWERPC_603
, 603),
8749 /* Code name for PowerPC 603 */
8750 POWERPC_DEF("Vanilla", CPU_POWERPC_603
, 603),
8751 /* PowerPC 603e (aka PID6) */
8752 POWERPC_DEF("603e", CPU_POWERPC_603E
, 603E
),
8753 /* Code name for PowerPC 603e */
8754 POWERPC_DEF("Stretch", CPU_POWERPC_603E
, 603E
),
8755 /* PowerPC 603e v1.1 */
8756 POWERPC_DEF("603e_v1.1", CPU_POWERPC_603E_v11
, 603E
),
8757 /* PowerPC 603e v1.2 */
8758 POWERPC_DEF("603e_v1.2", CPU_POWERPC_603E_v12
, 603E
),
8759 /* PowerPC 603e v1.3 */
8760 POWERPC_DEF("603e_v1.3", CPU_POWERPC_603E_v13
, 603E
),
8761 /* PowerPC 603e v1.4 */
8762 POWERPC_DEF("603e_v1.4", CPU_POWERPC_603E_v14
, 603E
),
8763 /* PowerPC 603e v2.2 */
8764 POWERPC_DEF("603e_v2.2", CPU_POWERPC_603E_v22
, 603E
),
8765 /* PowerPC 603e v3 */
8766 POWERPC_DEF("603e_v3", CPU_POWERPC_603E_v3
, 603E
),
8767 /* PowerPC 603e v4 */
8768 POWERPC_DEF("603e_v4", CPU_POWERPC_603E_v4
, 603E
),
8769 /* PowerPC 603e v4.1 */
8770 POWERPC_DEF("603e_v4.1", CPU_POWERPC_603E_v41
, 603E
),
8771 /* PowerPC 603e (aka PID7) */
8772 POWERPC_DEF("603e7", CPU_POWERPC_603E7
, 603E
),
8773 /* PowerPC 603e7t */
8774 POWERPC_DEF("603e7t", CPU_POWERPC_603E7t
, 603E
),
8775 /* PowerPC 603e7v */
8776 POWERPC_DEF("603e7v", CPU_POWERPC_603E7v
, 603E
),
8777 /* Code name for PowerPC 603ev */
8778 POWERPC_DEF("Vaillant", CPU_POWERPC_603E7v
, 603E
),
8779 /* PowerPC 603e7v1 */
8780 POWERPC_DEF("603e7v1", CPU_POWERPC_603E7v1
, 603E
),
8781 /* PowerPC 603e7v2 */
8782 POWERPC_DEF("603e7v2", CPU_POWERPC_603E7v2
, 603E
),
8783 /* PowerPC 603p (aka PID7v) */
8784 POWERPC_DEF("603p", CPU_POWERPC_603P
, 603E
),
8785 /* PowerPC 603r (aka PID7t) */
8786 POWERPC_DEF("603r", CPU_POWERPC_603R
, 603E
),
8787 /* Code name for PowerPC 603r */
8788 POWERPC_DEF("Goldeneye", CPU_POWERPC_603R
, 603E
),
8790 POWERPC_DEF("604", CPU_POWERPC_604
, 604),
8791 /* PowerPC 604e (aka PID9) */
8792 POWERPC_DEF("604e", CPU_POWERPC_604E
, 604E
),
8793 /* Code name for PowerPC 604e */
8794 POWERPC_DEF("Sirocco", CPU_POWERPC_604E
, 604E
),
8795 /* PowerPC 604e v1.0 */
8796 POWERPC_DEF("604e_v1.0", CPU_POWERPC_604E_v10
, 604E
),
8797 /* PowerPC 604e v2.2 */
8798 POWERPC_DEF("604e_v2.2", CPU_POWERPC_604E_v22
, 604E
),
8799 /* PowerPC 604e v2.4 */
8800 POWERPC_DEF("604e_v2.4", CPU_POWERPC_604E_v24
, 604E
),
8801 /* PowerPC 604r (aka PIDA) */
8802 POWERPC_DEF("604r", CPU_POWERPC_604R
, 604E
),
8803 /* Code name for PowerPC 604r */
8804 POWERPC_DEF("Mach5", CPU_POWERPC_604R
, 604E
),
8807 POWERPC_DEF("604ev", CPU_POWERPC_604EV
, 604E
),
8809 /* PowerPC 7xx family */
8810 /* Generic PowerPC 740 (G3) */
8811 POWERPC_DEF("740", CPU_POWERPC_7x0
, 740),
8812 /* Code name for PowerPC 740 */
8813 POWERPC_DEF("Arthur", CPU_POWERPC_7x0
, 740),
8814 /* Generic PowerPC 750 (G3) */
8815 POWERPC_DEF("750", CPU_POWERPC_7x0
, 750),
8816 /* Code name for PowerPC 750 */
8817 POWERPC_DEF("Typhoon", CPU_POWERPC_7x0
, 750),
8818 /* PowerPC 740/750 is also known as G3 */
8819 POWERPC_DEF("G3", CPU_POWERPC_7x0
, 750),
8820 /* PowerPC 740 v1.0 (G3) */
8821 POWERPC_DEF("740_v1.0", CPU_POWERPC_7x0_v10
, 740),
8822 /* PowerPC 750 v1.0 (G3) */
8823 POWERPC_DEF("750_v1.0", CPU_POWERPC_7x0_v10
, 750),
8824 /* PowerPC 740 v2.0 (G3) */
8825 POWERPC_DEF("740_v2.0", CPU_POWERPC_7x0_v20
, 740),
8826 /* PowerPC 750 v2.0 (G3) */
8827 POWERPC_DEF("750_v2.0", CPU_POWERPC_7x0_v20
, 750),
8828 /* PowerPC 740 v2.1 (G3) */
8829 POWERPC_DEF("740_v2.1", CPU_POWERPC_7x0_v21
, 740),
8830 /* PowerPC 750 v2.1 (G3) */
8831 POWERPC_DEF("750_v2.1", CPU_POWERPC_7x0_v21
, 750),
8832 /* PowerPC 740 v2.2 (G3) */
8833 POWERPC_DEF("740_v2.2", CPU_POWERPC_7x0_v22
, 740),
8834 /* PowerPC 750 v2.2 (G3) */
8835 POWERPC_DEF("750_v2.2", CPU_POWERPC_7x0_v22
, 750),
8836 /* PowerPC 740 v3.0 (G3) */
8837 POWERPC_DEF("740_v3.0", CPU_POWERPC_7x0_v30
, 740),
8838 /* PowerPC 750 v3.0 (G3) */
8839 POWERPC_DEF("750_v3.0", CPU_POWERPC_7x0_v30
, 750),
8840 /* PowerPC 740 v3.1 (G3) */
8841 POWERPC_DEF("740_v3.1", CPU_POWERPC_7x0_v31
, 740),
8842 /* PowerPC 750 v3.1 (G3) */
8843 POWERPC_DEF("750_v3.1", CPU_POWERPC_7x0_v31
, 750),
8844 /* PowerPC 740E (G3) */
8845 POWERPC_DEF("740e", CPU_POWERPC_740E
, 740),
8846 /* PowerPC 750E (G3) */
8847 POWERPC_DEF("750e", CPU_POWERPC_750E
, 750),
8848 /* PowerPC 740P (G3) */
8849 POWERPC_DEF("740p", CPU_POWERPC_7x0P
, 740),
8850 /* PowerPC 750P (G3) */
8851 POWERPC_DEF("750p", CPU_POWERPC_7x0P
, 750),
8852 /* Code name for PowerPC 740P/750P (G3) */
8853 POWERPC_DEF("Conan/Doyle", CPU_POWERPC_7x0P
, 750),
8854 /* PowerPC 750CL (G3 embedded) */
8855 POWERPC_DEF("750cl", CPU_POWERPC_750CL
, 750cl
),
8856 /* PowerPC 750CL v1.0 */
8857 POWERPC_DEF("750cl_v1.0", CPU_POWERPC_750CL_v10
, 750cl
),
8858 /* PowerPC 750CL v2.0 */
8859 POWERPC_DEF("750cl_v2.0", CPU_POWERPC_750CL_v20
, 750cl
),
8860 /* PowerPC 750CX (G3 embedded) */
8861 POWERPC_DEF("750cx", CPU_POWERPC_750CX
, 750cx
),
8862 /* PowerPC 750CX v1.0 (G3 embedded) */
8863 POWERPC_DEF("750cx_v1.0", CPU_POWERPC_750CX_v10
, 750cx
),
8864 /* PowerPC 750CX v2.1 (G3 embedded) */
8865 POWERPC_DEF("750cx_v2.0", CPU_POWERPC_750CX_v20
, 750cx
),
8866 /* PowerPC 750CX v2.1 (G3 embedded) */
8867 POWERPC_DEF("750cx_v2.1", CPU_POWERPC_750CX_v21
, 750cx
),
8868 /* PowerPC 750CX v2.2 (G3 embedded) */
8869 POWERPC_DEF("750cx_v2.2", CPU_POWERPC_750CX_v22
, 750cx
),
8870 /* PowerPC 750CXe (G3 embedded) */
8871 POWERPC_DEF("750cxe", CPU_POWERPC_750CXE
, 750cx
),
8872 /* PowerPC 750CXe v2.1 (G3 embedded) */
8873 POWERPC_DEF("750cxe_v2.1", CPU_POWERPC_750CXE_v21
, 750cx
),
8874 /* PowerPC 750CXe v2.2 (G3 embedded) */
8875 POWERPC_DEF("750cxe_v2.2", CPU_POWERPC_750CXE_v22
, 750cx
),
8876 /* PowerPC 750CXe v2.3 (G3 embedded) */
8877 POWERPC_DEF("750cxe_v2.3", CPU_POWERPC_750CXE_v23
, 750cx
),
8878 /* PowerPC 750CXe v2.4 (G3 embedded) */
8879 POWERPC_DEF("750cxe_v2.4", CPU_POWERPC_750CXE_v24
, 750cx
),
8880 /* PowerPC 750CXe v2.4b (G3 embedded) */
8881 POWERPC_DEF("750cxe_v2.4b", CPU_POWERPC_750CXE_v24b
, 750cx
),
8882 /* PowerPC 750CXe v3.0 (G3 embedded) */
8883 POWERPC_DEF("750cxe_v3.0", CPU_POWERPC_750CXE_v30
, 750cx
),
8884 /* PowerPC 750CXe v3.1 (G3 embedded) */
8885 POWERPC_DEF("750cxe_v3.1", CPU_POWERPC_750CXE_v31
, 750cx
),
8886 /* PowerPC 750CXe v3.1b (G3 embedded) */
8887 POWERPC_DEF("750cxe_v3.1b", CPU_POWERPC_750CXE_v31b
, 750cx
),
8888 /* PowerPC 750CXr (G3 embedded) */
8889 POWERPC_DEF("750cxr", CPU_POWERPC_750CXR
, 750cx
),
8890 /* PowerPC 750FL (G3 embedded) */
8891 POWERPC_DEF("750fl", CPU_POWERPC_750FL
, 750fx
),
8892 /* PowerPC 750FX (G3 embedded) */
8893 POWERPC_DEF("750fx", CPU_POWERPC_750FX
, 750fx
),
8894 /* PowerPC 750FX v1.0 (G3 embedded) */
8895 POWERPC_DEF("750fx_v1.0", CPU_POWERPC_750FX_v10
, 750fx
),
8896 /* PowerPC 750FX v2.0 (G3 embedded) */
8897 POWERPC_DEF("750fx_v2.0", CPU_POWERPC_750FX_v20
, 750fx
),
8898 /* PowerPC 750FX v2.1 (G3 embedded) */
8899 POWERPC_DEF("750fx_v2.1", CPU_POWERPC_750FX_v21
, 750fx
),
8900 /* PowerPC 750FX v2.2 (G3 embedded) */
8901 POWERPC_DEF("750fx_v2.2", CPU_POWERPC_750FX_v22
, 750fx
),
8902 /* PowerPC 750FX v2.3 (G3 embedded) */
8903 POWERPC_DEF("750fx_v2.3", CPU_POWERPC_750FX_v23
, 750fx
),
8904 /* PowerPC 750GL (G3 embedded) */
8905 POWERPC_DEF("750gl", CPU_POWERPC_750GL
, 750gx
),
8906 /* PowerPC 750GX (G3 embedded) */
8907 POWERPC_DEF("750gx", CPU_POWERPC_750GX
, 750gx
),
8908 /* PowerPC 750GX v1.0 (G3 embedded) */
8909 POWERPC_DEF("750gx_v1.0", CPU_POWERPC_750GX_v10
, 750gx
),
8910 /* PowerPC 750GX v1.1 (G3 embedded) */
8911 POWERPC_DEF("750gx_v1.1", CPU_POWERPC_750GX_v11
, 750gx
),
8912 /* PowerPC 750GX v1.2 (G3 embedded) */
8913 POWERPC_DEF("750gx_v1.2", CPU_POWERPC_750GX_v12
, 750gx
),
8914 /* PowerPC 750L (G3 embedded) */
8915 POWERPC_DEF("750l", CPU_POWERPC_750L
, 750),
8916 /* Code name for PowerPC 750L (G3 embedded) */
8917 POWERPC_DEF("LoneStar", CPU_POWERPC_750L
, 750),
8918 /* PowerPC 750L v2.0 (G3 embedded) */
8919 POWERPC_DEF("750l_v2.0", CPU_POWERPC_750L_v20
, 750),
8920 /* PowerPC 750L v2.1 (G3 embedded) */
8921 POWERPC_DEF("750l_v2.1", CPU_POWERPC_750L_v21
, 750),
8922 /* PowerPC 750L v2.2 (G3 embedded) */
8923 POWERPC_DEF("750l_v2.2", CPU_POWERPC_750L_v22
, 750),
8924 /* PowerPC 750L v3.0 (G3 embedded) */
8925 POWERPC_DEF("750l_v3.0", CPU_POWERPC_750L_v30
, 750),
8926 /* PowerPC 750L v3.2 (G3 embedded) */
8927 POWERPC_DEF("750l_v3.2", CPU_POWERPC_750L_v32
, 750),
8928 /* Generic PowerPC 745 */
8929 POWERPC_DEF("745", CPU_POWERPC_7x5
, 745),
8930 /* Generic PowerPC 755 */
8931 POWERPC_DEF("755", CPU_POWERPC_7x5
, 755),
8932 /* Code name for PowerPC 745/755 */
8933 POWERPC_DEF("Goldfinger", CPU_POWERPC_7x5
, 755),
8934 /* PowerPC 745 v1.0 */
8935 POWERPC_DEF("745_v1.0", CPU_POWERPC_7x5_v10
, 745),
8936 /* PowerPC 755 v1.0 */
8937 POWERPC_DEF("755_v1.0", CPU_POWERPC_7x5_v10
, 755),
8938 /* PowerPC 745 v1.1 */
8939 POWERPC_DEF("745_v1.1", CPU_POWERPC_7x5_v11
, 745),
8940 /* PowerPC 755 v1.1 */
8941 POWERPC_DEF("755_v1.1", CPU_POWERPC_7x5_v11
, 755),
8942 /* PowerPC 745 v2.0 */
8943 POWERPC_DEF("745_v2.0", CPU_POWERPC_7x5_v20
, 745),
8944 /* PowerPC 755 v2.0 */
8945 POWERPC_DEF("755_v2.0", CPU_POWERPC_7x5_v20
, 755),
8946 /* PowerPC 745 v2.1 */
8947 POWERPC_DEF("745_v2.1", CPU_POWERPC_7x5_v21
, 745),
8948 /* PowerPC 755 v2.1 */
8949 POWERPC_DEF("755_v2.1", CPU_POWERPC_7x5_v21
, 755),
8950 /* PowerPC 745 v2.2 */
8951 POWERPC_DEF("745_v2.2", CPU_POWERPC_7x5_v22
, 745),
8952 /* PowerPC 755 v2.2 */
8953 POWERPC_DEF("755_v2.2", CPU_POWERPC_7x5_v22
, 755),
8954 /* PowerPC 745 v2.3 */
8955 POWERPC_DEF("745_v2.3", CPU_POWERPC_7x5_v23
, 745),
8956 /* PowerPC 755 v2.3 */
8957 POWERPC_DEF("755_v2.3", CPU_POWERPC_7x5_v23
, 755),
8958 /* PowerPC 745 v2.4 */
8959 POWERPC_DEF("745_v2.4", CPU_POWERPC_7x5_v24
, 745),
8960 /* PowerPC 755 v2.4 */
8961 POWERPC_DEF("755_v2.4", CPU_POWERPC_7x5_v24
, 755),
8962 /* PowerPC 745 v2.5 */
8963 POWERPC_DEF("745_v2.5", CPU_POWERPC_7x5_v25
, 745),
8964 /* PowerPC 755 v2.5 */
8965 POWERPC_DEF("755_v2.5", CPU_POWERPC_7x5_v25
, 755),
8966 /* PowerPC 745 v2.6 */
8967 POWERPC_DEF("745_v2.6", CPU_POWERPC_7x5_v26
, 745),
8968 /* PowerPC 755 v2.6 */
8969 POWERPC_DEF("755_v2.6", CPU_POWERPC_7x5_v26
, 755),
8970 /* PowerPC 745 v2.7 */
8971 POWERPC_DEF("745_v2.7", CPU_POWERPC_7x5_v27
, 745),
8972 /* PowerPC 755 v2.7 */
8973 POWERPC_DEF("755_v2.7", CPU_POWERPC_7x5_v27
, 755),
8974 /* PowerPC 745 v2.8 */
8975 POWERPC_DEF("745_v2.8", CPU_POWERPC_7x5_v28
, 745),
8976 /* PowerPC 755 v2.8 */
8977 POWERPC_DEF("755_v2.8", CPU_POWERPC_7x5_v28
, 755),
8979 /* PowerPC 745P (G3) */
8980 POWERPC_DEF("745p", CPU_POWERPC_7x5P
, 745),
8981 /* PowerPC 755P (G3) */
8982 POWERPC_DEF("755p", CPU_POWERPC_7x5P
, 755),
8984 /* PowerPC 74xx family */
8985 /* PowerPC 7400 (G4) */
8986 POWERPC_DEF("7400", CPU_POWERPC_7400
, 7400),
8987 /* Code name for PowerPC 7400 */
8988 POWERPC_DEF("Max", CPU_POWERPC_7400
, 7400),
8989 /* PowerPC 74xx is also well known as G4 */
8990 POWERPC_DEF("G4", CPU_POWERPC_7400
, 7400),
8991 /* PowerPC 7400 v1.0 (G4) */
8992 POWERPC_DEF("7400_v1.0", CPU_POWERPC_7400_v10
, 7400),
8993 /* PowerPC 7400 v1.1 (G4) */
8994 POWERPC_DEF("7400_v1.1", CPU_POWERPC_7400_v11
, 7400),
8995 /* PowerPC 7400 v2.0 (G4) */
8996 POWERPC_DEF("7400_v2.0", CPU_POWERPC_7400_v20
, 7400),
8997 /* PowerPC 7400 v2.1 (G4) */
8998 POWERPC_DEF("7400_v2.1", CPU_POWERPC_7400_v21
, 7400),
8999 /* PowerPC 7400 v2.2 (G4) */
9000 POWERPC_DEF("7400_v2.2", CPU_POWERPC_7400_v22
, 7400),
9001 /* PowerPC 7400 v2.6 (G4) */
9002 POWERPC_DEF("7400_v2.6", CPU_POWERPC_7400_v26
, 7400),
9003 /* PowerPC 7400 v2.7 (G4) */
9004 POWERPC_DEF("7400_v2.7", CPU_POWERPC_7400_v27
, 7400),
9005 /* PowerPC 7400 v2.8 (G4) */
9006 POWERPC_DEF("7400_v2.8", CPU_POWERPC_7400_v28
, 7400),
9007 /* PowerPC 7400 v2.9 (G4) */
9008 POWERPC_DEF("7400_v2.9", CPU_POWERPC_7400_v29
, 7400),
9009 /* PowerPC 7410 (G4) */
9010 POWERPC_DEF("7410", CPU_POWERPC_7410
, 7410),
9011 /* Code name for PowerPC 7410 */
9012 POWERPC_DEF("Nitro", CPU_POWERPC_7410
, 7410),
9013 /* PowerPC 7410 v1.0 (G4) */
9014 POWERPC_DEF("7410_v1.0", CPU_POWERPC_7410_v10
, 7410),
9015 /* PowerPC 7410 v1.1 (G4) */
9016 POWERPC_DEF("7410_v1.1", CPU_POWERPC_7410_v11
, 7410),
9017 /* PowerPC 7410 v1.2 (G4) */
9018 POWERPC_DEF("7410_v1.2", CPU_POWERPC_7410_v12
, 7410),
9019 /* PowerPC 7410 v1.3 (G4) */
9020 POWERPC_DEF("7410_v1.3", CPU_POWERPC_7410_v13
, 7410),
9021 /* PowerPC 7410 v1.4 (G4) */
9022 POWERPC_DEF("7410_v1.4", CPU_POWERPC_7410_v14
, 7410),
9023 /* PowerPC 7448 (G4) */
9024 POWERPC_DEF("7448", CPU_POWERPC_7448
, 7400),
9025 /* PowerPC 7448 v1.0 (G4) */
9026 POWERPC_DEF("7448_v1.0", CPU_POWERPC_7448_v10
, 7400),
9027 /* PowerPC 7448 v1.1 (G4) */
9028 POWERPC_DEF("7448_v1.1", CPU_POWERPC_7448_v11
, 7400),
9029 /* PowerPC 7448 v2.0 (G4) */
9030 POWERPC_DEF("7448_v2.0", CPU_POWERPC_7448_v20
, 7400),
9031 /* PowerPC 7448 v2.1 (G4) */
9032 POWERPC_DEF("7448_v2.1", CPU_POWERPC_7448_v21
, 7400),
9033 /* PowerPC 7450 (G4) */
9034 POWERPC_DEF("7450", CPU_POWERPC_7450
, 7450),
9035 /* Code name for PowerPC 7450 */
9036 POWERPC_DEF("Vger", CPU_POWERPC_7450
, 7450),
9037 /* PowerPC 7450 v1.0 (G4) */
9038 POWERPC_DEF("7450_v1.0", CPU_POWERPC_7450_v10
, 7450),
9039 /* PowerPC 7450 v1.1 (G4) */
9040 POWERPC_DEF("7450_v1.1", CPU_POWERPC_7450_v11
, 7450),
9041 /* PowerPC 7450 v1.2 (G4) */
9042 POWERPC_DEF("7450_v1.2", CPU_POWERPC_7450_v12
, 7450),
9043 /* PowerPC 7450 v2.0 (G4) */
9044 POWERPC_DEF("7450_v2.0", CPU_POWERPC_7450_v20
, 7450),
9045 /* PowerPC 7450 v2.1 (G4) */
9046 POWERPC_DEF("7450_v2.1", CPU_POWERPC_7450_v21
, 7450),
9047 /* PowerPC 7441 (G4) */
9048 POWERPC_DEF("7441", CPU_POWERPC_74x1
, 7440),
9049 /* PowerPC 7451 (G4) */
9050 POWERPC_DEF("7451", CPU_POWERPC_74x1
, 7450),
9051 /* PowerPC 7441 v2.1 (G4) */
9052 POWERPC_DEF("7441_v2.1", CPU_POWERPC_7450_v21
, 7440),
9053 /* PowerPC 7441 v2.3 (G4) */
9054 POWERPC_DEF("7441_v2.3", CPU_POWERPC_74x1_v23
, 7440),
9055 /* PowerPC 7451 v2.3 (G4) */
9056 POWERPC_DEF("7451_v2.3", CPU_POWERPC_74x1_v23
, 7450),
9057 /* PowerPC 7441 v2.10 (G4) */
9058 POWERPC_DEF("7441_v2.10", CPU_POWERPC_74x1_v210
, 7440),
9059 /* PowerPC 7451 v2.10 (G4) */
9060 POWERPC_DEF("7451_v2.10", CPU_POWERPC_74x1_v210
, 7450),
9061 /* PowerPC 7445 (G4) */
9062 POWERPC_DEF("7445", CPU_POWERPC_74x5
, 7445),
9063 /* PowerPC 7455 (G4) */
9064 POWERPC_DEF("7455", CPU_POWERPC_74x5
, 7455),
9065 /* Code name for PowerPC 7445/7455 */
9066 POWERPC_DEF("Apollo6", CPU_POWERPC_74x5
, 7455),
9067 /* PowerPC 7445 v1.0 (G4) */
9068 POWERPC_DEF("7445_v1.0", CPU_POWERPC_74x5_v10
, 7445),
9069 /* PowerPC 7455 v1.0 (G4) */
9070 POWERPC_DEF("7455_v1.0", CPU_POWERPC_74x5_v10
, 7455),
9071 /* PowerPC 7445 v2.1 (G4) */
9072 POWERPC_DEF("7445_v2.1", CPU_POWERPC_74x5_v21
, 7445),
9073 /* PowerPC 7455 v2.1 (G4) */
9074 POWERPC_DEF("7455_v2.1", CPU_POWERPC_74x5_v21
, 7455),
9075 /* PowerPC 7445 v3.2 (G4) */
9076 POWERPC_DEF("7445_v3.2", CPU_POWERPC_74x5_v32
, 7445),
9077 /* PowerPC 7455 v3.2 (G4) */
9078 POWERPC_DEF("7455_v3.2", CPU_POWERPC_74x5_v32
, 7455),
9079 /* PowerPC 7445 v3.3 (G4) */
9080 POWERPC_DEF("7445_v3.3", CPU_POWERPC_74x5_v33
, 7445),
9081 /* PowerPC 7455 v3.3 (G4) */
9082 POWERPC_DEF("7455_v3.3", CPU_POWERPC_74x5_v33
, 7455),
9083 /* PowerPC 7445 v3.4 (G4) */
9084 POWERPC_DEF("7445_v3.4", CPU_POWERPC_74x5_v34
, 7445),
9085 /* PowerPC 7455 v3.4 (G4) */
9086 POWERPC_DEF("7455_v3.4", CPU_POWERPC_74x5_v34
, 7455),
9087 /* PowerPC 7447 (G4) */
9088 POWERPC_DEF("7447", CPU_POWERPC_74x7
, 7445),
9089 /* PowerPC 7457 (G4) */
9090 POWERPC_DEF("7457", CPU_POWERPC_74x7
, 7455),
9091 /* Code name for PowerPC 7447/7457 */
9092 POWERPC_DEF("Apollo7", CPU_POWERPC_74x7
, 7455),
9093 /* PowerPC 7447 v1.0 (G4) */
9094 POWERPC_DEF("7447_v1.0", CPU_POWERPC_74x7_v10
, 7445),
9095 /* PowerPC 7457 v1.0 (G4) */
9096 POWERPC_DEF("7457_v1.0", CPU_POWERPC_74x7_v10
, 7455),
9097 /* PowerPC 7447 v1.1 (G4) */
9098 POWERPC_DEF("7447_v1.1", CPU_POWERPC_74x7_v11
, 7445),
9099 /* PowerPC 7457 v1.1 (G4) */
9100 POWERPC_DEF("7457_v1.1", CPU_POWERPC_74x7_v11
, 7455),
9101 /* PowerPC 7457 v1.2 (G4) */
9102 POWERPC_DEF("7457_v1.2", CPU_POWERPC_74x7_v12
, 7455),
9103 /* PowerPC 7447A (G4) */
9104 POWERPC_DEF("7447A", CPU_POWERPC_74x7A
, 7445),
9105 /* PowerPC 7457A (G4) */
9106 POWERPC_DEF("7457A", CPU_POWERPC_74x7A
, 7455),
9107 /* PowerPC 7447A v1.0 (G4) */
9108 POWERPC_DEF("7447A_v1.0", CPU_POWERPC_74x7A_v10
, 7445),
9109 /* PowerPC 7457A v1.0 (G4) */
9110 POWERPC_DEF("7457A_v1.0", CPU_POWERPC_74x7A_v10
, 7455),
9111 /* Code name for PowerPC 7447A/7457A */
9112 POWERPC_DEF("Apollo7PM", CPU_POWERPC_74x7A_v10
, 7455),
9113 /* PowerPC 7447A v1.1 (G4) */
9114 POWERPC_DEF("7447A_v1.1", CPU_POWERPC_74x7A_v11
, 7445),
9115 /* PowerPC 7457A v1.1 (G4) */
9116 POWERPC_DEF("7457A_v1.1", CPU_POWERPC_74x7A_v11
, 7455),
9117 /* PowerPC 7447A v1.2 (G4) */
9118 POWERPC_DEF("7447A_v1.2", CPU_POWERPC_74x7A_v12
, 7445),
9119 /* PowerPC 7457A v1.2 (G4) */
9120 POWERPC_DEF("7457A_v1.2", CPU_POWERPC_74x7A_v12
, 7455),
9121 /* 64 bits PowerPC */
9122 #if defined (TARGET_PPC64)
9124 POWERPC_DEF("620", CPU_POWERPC_620
, 620),
9125 /* Code name for PowerPC 620 */
9126 POWERPC_DEF("Trident", CPU_POWERPC_620
, 620),
9128 /* PowerPC 630 (POWER3) */
9129 POWERPC_DEF("630", CPU_POWERPC_630
, 630),
9130 POWERPC_DEF("POWER3", CPU_POWERPC_630
, 630),
9131 /* Code names for POWER3 */
9132 POWERPC_DEF("Boxer", CPU_POWERPC_630
, 630),
9133 POWERPC_DEF("Dino", CPU_POWERPC_630
, 630),
9136 /* PowerPC 631 (Power 3+) */
9137 POWERPC_DEF("631", CPU_POWERPC_631
, 631),
9138 POWERPC_DEF("POWER3+", CPU_POWERPC_631
, 631),
9142 POWERPC_DEF("POWER4", CPU_POWERPC_POWER4
, POWER4
),
9146 POWERPC_DEF("POWER4+", CPU_POWERPC_POWER4P
, POWER4P
),
9150 POWERPC_DEF("POWER5", CPU_POWERPC_POWER5
, POWER5
),
9152 POWERPC_DEF("POWER5gr", CPU_POWERPC_POWER5GR
, POWER5
),
9156 POWERPC_DEF("POWER5+", CPU_POWERPC_POWER5P
, POWER5P
),
9158 POWERPC_DEF("POWER5gs", CPU_POWERPC_POWER5GS
, POWER5P
),
9162 POWERPC_DEF("POWER6", CPU_POWERPC_POWER6
, POWER6
),
9163 /* POWER6 running in POWER5 mode */
9164 POWERPC_DEF("POWER6_5", CPU_POWERPC_POWER6_5
, POWER5
),
9166 POWERPC_DEF("POWER6A", CPU_POWERPC_POWER6A
, POWER6
),
9169 POWERPC_DEF("POWER7", CPU_POWERPC_POWER7
, POWER7
),
9170 POWERPC_DEF("POWER7_v2.0", CPU_POWERPC_POWER7_v20
, POWER7
),
9171 POWERPC_DEF("POWER7_v2.1", CPU_POWERPC_POWER7_v21
, POWER7
),
9172 POWERPC_DEF("POWER7_v2.3", CPU_POWERPC_POWER7_v23
, POWER7
),
9174 POWERPC_DEF("970", CPU_POWERPC_970
, 970),
9175 /* PowerPC 970FX (G5) */
9176 POWERPC_DEF("970fx", CPU_POWERPC_970FX
, 970FX
),
9177 /* PowerPC 970FX v1.0 (G5) */
9178 POWERPC_DEF("970fx_v1.0", CPU_POWERPC_970FX_v10
, 970FX
),
9179 /* PowerPC 970FX v2.0 (G5) */
9180 POWERPC_DEF("970fx_v2.0", CPU_POWERPC_970FX_v20
, 970FX
),
9181 /* PowerPC 970FX v2.1 (G5) */
9182 POWERPC_DEF("970fx_v2.1", CPU_POWERPC_970FX_v21
, 970FX
),
9183 /* PowerPC 970FX v3.0 (G5) */
9184 POWERPC_DEF("970fx_v3.0", CPU_POWERPC_970FX_v30
, 970FX
),
9185 /* PowerPC 970FX v3.1 (G5) */
9186 POWERPC_DEF("970fx_v3.1", CPU_POWERPC_970FX_v31
, 970FX
),
9187 /* PowerPC 970GX (G5) */
9188 POWERPC_DEF("970gx", CPU_POWERPC_970GX
, 970GX
),
9190 POWERPC_DEF("970mp", CPU_POWERPC_970MP
, 970MP
),
9191 /* PowerPC 970MP v1.0 */
9192 POWERPC_DEF("970mp_v1.0", CPU_POWERPC_970MP_v10
, 970MP
),
9193 /* PowerPC 970MP v1.1 */
9194 POWERPC_DEF("970mp_v1.1", CPU_POWERPC_970MP_v11
, 970MP
),
9197 POWERPC_DEF("Cell", CPU_POWERPC_CELL
, 970),
9200 /* PowerPC Cell v1.0 */
9201 POWERPC_DEF("Cell_v1.0", CPU_POWERPC_CELL_v10
, 970),
9204 /* PowerPC Cell v2.0 */
9205 POWERPC_DEF("Cell_v2.0", CPU_POWERPC_CELL_v20
, 970),
9208 /* PowerPC Cell v3.0 */
9209 POWERPC_DEF("Cell_v3.0", CPU_POWERPC_CELL_v30
, 970),
9212 /* PowerPC Cell v3.1 */
9213 POWERPC_DEF("Cell_v3.1", CPU_POWERPC_CELL_v31
, 970),
9216 /* PowerPC Cell v3.2 */
9217 POWERPC_DEF("Cell_v3.2", CPU_POWERPC_CELL_v32
, 970),
9220 /* RS64 (Apache/A35) */
9221 /* This one seems to support the whole POWER2 instruction set
9222 * and the PowerPC 64 one.
9224 /* What about A10 & A30 ? */
9225 POWERPC_DEF("RS64", CPU_POWERPC_RS64
, RS64
),
9226 POWERPC_DEF("Apache", CPU_POWERPC_RS64
, RS64
),
9227 POWERPC_DEF("A35", CPU_POWERPC_RS64
, RS64
),
9230 /* RS64-II (NorthStar/A50) */
9231 POWERPC_DEF("RS64-II", CPU_POWERPC_RS64II
, RS64
),
9232 POWERPC_DEF("NorthStar", CPU_POWERPC_RS64II
, RS64
),
9233 POWERPC_DEF("A50", CPU_POWERPC_RS64II
, RS64
),
9236 /* RS64-III (Pulsar) */
9237 POWERPC_DEF("RS64-III", CPU_POWERPC_RS64III
, RS64
),
9238 POWERPC_DEF("Pulsar", CPU_POWERPC_RS64III
, RS64
),
9241 /* RS64-IV (IceStar/IStar/SStar) */
9242 POWERPC_DEF("RS64-IV", CPU_POWERPC_RS64IV
, RS64
),
9243 POWERPC_DEF("IceStar", CPU_POWERPC_RS64IV
, RS64
),
9244 POWERPC_DEF("IStar", CPU_POWERPC_RS64IV
, RS64
),
9245 POWERPC_DEF("SStar", CPU_POWERPC_RS64IV
, RS64
),
9247 #endif /* defined (TARGET_PPC64) */
9250 /* Original POWER */
9251 POWERPC_DEF("POWER", CPU_POWERPC_POWER
, POWER
),
9252 POWERPC_DEF("RIOS", CPU_POWERPC_POWER
, POWER
),
9253 POWERPC_DEF("RSC", CPU_POWERPC_POWER
, POWER
),
9254 POWERPC_DEF("RSC3308", CPU_POWERPC_POWER
, POWER
),
9255 POWERPC_DEF("RSC4608", CPU_POWERPC_POWER
, POWER
),
9259 POWERPC_DEF("POWER2", CPU_POWERPC_POWER2
, POWER
),
9260 POWERPC_DEF("RSC2", CPU_POWERPC_POWER2
, POWER
),
9261 POWERPC_DEF("P2SC", CPU_POWERPC_POWER2
, POWER
),
9266 POWERPC_DEF("PA6T", CPU_POWERPC_PA6T
, PA6T
),
9268 /* Generic PowerPCs */
9269 #if defined (TARGET_PPC64)
9270 POWERPC_DEF("ppc64", CPU_POWERPC_PPC64
, PPC64
),
9272 POWERPC_DEF("ppc32", CPU_POWERPC_PPC32
, PPC32
),
9273 POWERPC_DEF("ppc", CPU_POWERPC_DEFAULT
, DEFAULT
),
9275 POWERPC_DEF("default", CPU_POWERPC_DEFAULT
, DEFAULT
),
9278 /*****************************************************************************/
9279 /* Generic CPU instantiation routine */
9280 static void init_ppc_proc (CPUPPCState
*env
, const ppc_def_t
*def
)
9282 #if !defined(CONFIG_USER_ONLY)
9285 env
->irq_inputs
= NULL
;
9286 /* Set all exception vectors to an invalid address */
9287 for (i
= 0; i
< POWERPC_EXCP_NB
; i
++)
9288 env
->excp_vectors
[i
] = (target_ulong
)(-1ULL);
9289 env
->hreset_excp_prefix
= 0x00000000;
9290 env
->ivor_mask
= 0x00000000;
9291 env
->ivpr_mask
= 0x00000000;
9292 /* Default MMU definitions */
9296 env
->tlb_type
= TLB_NONE
;
9298 /* Register SPR common to all PowerPC implementations */
9299 gen_spr_generic(env
);
9300 spr_register(env
, SPR_PVR
, "PVR",
9301 /* Linux permits userspace to read PVR */
9302 #if defined(CONFIG_LINUX_USER)
9308 &spr_read_generic
, SPR_NOACCESS
,
9310 /* Register SVR if it's defined to anything else than POWERPC_SVR_NONE */
9311 if (def
->svr
!= POWERPC_SVR_NONE
) {
9312 if (def
->svr
& POWERPC_SVR_E500
) {
9313 spr_register(env
, SPR_E500_SVR
, "SVR",
9314 SPR_NOACCESS
, SPR_NOACCESS
,
9315 &spr_read_generic
, SPR_NOACCESS
,
9316 def
->svr
& ~POWERPC_SVR_E500
);
9318 spr_register(env
, SPR_SVR
, "SVR",
9319 SPR_NOACCESS
, SPR_NOACCESS
,
9320 &spr_read_generic
, SPR_NOACCESS
,
9324 /* PowerPC implementation specific initialisations (SPRs, timers, ...) */
9325 (*def
->init_proc
)(env
);
9326 #if !defined(CONFIG_USER_ONLY)
9327 env
->excp_prefix
= env
->hreset_excp_prefix
;
9329 /* MSR bits & flags consistency checks */
9330 if (env
->msr_mask
& (1 << 25)) {
9331 switch (env
->flags
& (POWERPC_FLAG_SPE
| POWERPC_FLAG_VRE
)) {
9332 case POWERPC_FLAG_SPE
:
9333 case POWERPC_FLAG_VRE
:
9336 fprintf(stderr
, "PowerPC MSR definition inconsistency\n"
9337 "Should define POWERPC_FLAG_SPE or POWERPC_FLAG_VRE\n");
9340 } else if (env
->flags
& (POWERPC_FLAG_SPE
| POWERPC_FLAG_VRE
)) {
9341 fprintf(stderr
, "PowerPC MSR definition inconsistency\n"
9342 "Should not define POWERPC_FLAG_SPE nor POWERPC_FLAG_VRE\n");
9345 if (env
->msr_mask
& (1 << 17)) {
9346 switch (env
->flags
& (POWERPC_FLAG_TGPR
| POWERPC_FLAG_CE
)) {
9347 case POWERPC_FLAG_TGPR
:
9348 case POWERPC_FLAG_CE
:
9351 fprintf(stderr
, "PowerPC MSR definition inconsistency\n"
9352 "Should define POWERPC_FLAG_TGPR or POWERPC_FLAG_CE\n");
9355 } else if (env
->flags
& (POWERPC_FLAG_TGPR
| POWERPC_FLAG_CE
)) {
9356 fprintf(stderr
, "PowerPC MSR definition inconsistency\n"
9357 "Should not define POWERPC_FLAG_TGPR nor POWERPC_FLAG_CE\n");
9360 if (env
->msr_mask
& (1 << 10)) {
9361 switch (env
->flags
& (POWERPC_FLAG_SE
| POWERPC_FLAG_DWE
|
9362 POWERPC_FLAG_UBLE
)) {
9363 case POWERPC_FLAG_SE
:
9364 case POWERPC_FLAG_DWE
:
9365 case POWERPC_FLAG_UBLE
:
9368 fprintf(stderr
, "PowerPC MSR definition inconsistency\n"
9369 "Should define POWERPC_FLAG_SE or POWERPC_FLAG_DWE or "
9370 "POWERPC_FLAG_UBLE\n");
9373 } else if (env
->flags
& (POWERPC_FLAG_SE
| POWERPC_FLAG_DWE
|
9374 POWERPC_FLAG_UBLE
)) {
9375 fprintf(stderr
, "PowerPC MSR definition inconsistency\n"
9376 "Should not define POWERPC_FLAG_SE nor POWERPC_FLAG_DWE nor "
9377 "POWERPC_FLAG_UBLE\n");
9380 if (env
->msr_mask
& (1 << 9)) {
9381 switch (env
->flags
& (POWERPC_FLAG_BE
| POWERPC_FLAG_DE
)) {
9382 case POWERPC_FLAG_BE
:
9383 case POWERPC_FLAG_DE
:
9386 fprintf(stderr
, "PowerPC MSR definition inconsistency\n"
9387 "Should define POWERPC_FLAG_BE or POWERPC_FLAG_DE\n");
9390 } else if (env
->flags
& (POWERPC_FLAG_BE
| POWERPC_FLAG_DE
)) {
9391 fprintf(stderr
, "PowerPC MSR definition inconsistency\n"
9392 "Should not define POWERPC_FLAG_BE nor POWERPC_FLAG_DE\n");
9395 if (env
->msr_mask
& (1 << 2)) {
9396 switch (env
->flags
& (POWERPC_FLAG_PX
| POWERPC_FLAG_PMM
)) {
9397 case POWERPC_FLAG_PX
:
9398 case POWERPC_FLAG_PMM
:
9401 fprintf(stderr
, "PowerPC MSR definition inconsistency\n"
9402 "Should define POWERPC_FLAG_PX or POWERPC_FLAG_PMM\n");
9405 } else if (env
->flags
& (POWERPC_FLAG_PX
| POWERPC_FLAG_PMM
)) {
9406 fprintf(stderr
, "PowerPC MSR definition inconsistency\n"
9407 "Should not define POWERPC_FLAG_PX nor POWERPC_FLAG_PMM\n");
9410 if ((env
->flags
& (POWERPC_FLAG_RTC_CLK
| POWERPC_FLAG_BUS_CLK
)) == 0) {
9411 fprintf(stderr
, "PowerPC flags inconsistency\n"
9412 "Should define the time-base and decrementer clock source\n");
9415 /* Allocate TLBs buffer when needed */
9416 #if !defined(CONFIG_USER_ONLY)
9417 if (env
->nb_tlb
!= 0) {
9418 int nb_tlb
= env
->nb_tlb
;
9419 if (env
->id_tlbs
!= 0)
9421 switch (env
->tlb_type
) {
9423 env
->tlb
.tlb6
= g_malloc0(nb_tlb
* sizeof(ppc6xx_tlb_t
));
9426 env
->tlb
.tlbe
= g_malloc0(nb_tlb
* sizeof(ppcemb_tlb_t
));
9429 env
->tlb
.tlbm
= g_malloc0(nb_tlb
* sizeof(ppcmas_tlb_t
));
9432 /* Pre-compute some useful values */
9433 env
->tlb_per_way
= env
->nb_tlb
/ env
->nb_ways
;
9435 if (env
->irq_inputs
== NULL
) {
9436 fprintf(stderr
, "WARNING: no internal IRQ controller registered.\n"
9437 " Attempt Qemu to crash very soon !\n");
9440 if (env
->check_pow
== NULL
) {
9441 fprintf(stderr
, "WARNING: no power management check handler "
9443 " Attempt Qemu to crash very soon !\n");
9447 #if defined(PPC_DUMP_CPU)
9448 static void dump_ppc_sprs (CPUPPCState
*env
)
9451 #if !defined(CONFIG_USER_ONLY)
9457 printf("Special purpose registers:\n");
9458 for (i
= 0; i
< 32; i
++) {
9459 for (j
= 0; j
< 32; j
++) {
9461 spr
= &env
->spr_cb
[n
];
9462 uw
= spr
->uea_write
!= NULL
&& spr
->uea_write
!= SPR_NOACCESS
;
9463 ur
= spr
->uea_read
!= NULL
&& spr
->uea_read
!= SPR_NOACCESS
;
9464 #if !defined(CONFIG_USER_ONLY)
9465 sw
= spr
->oea_write
!= NULL
&& spr
->oea_write
!= SPR_NOACCESS
;
9466 sr
= spr
->oea_read
!= NULL
&& spr
->oea_read
!= SPR_NOACCESS
;
9467 if (sw
|| sr
|| uw
|| ur
) {
9468 printf("SPR: %4d (%03x) %-8s s%c%c u%c%c\n",
9469 (i
<< 5) | j
, (i
<< 5) | j
, spr
->name
,
9470 sw
? 'w' : '-', sr
? 'r' : '-',
9471 uw
? 'w' : '-', ur
? 'r' : '-');
9475 printf("SPR: %4d (%03x) %-8s u%c%c\n",
9476 (i
<< 5) | j
, (i
<< 5) | j
, spr
->name
,
9477 uw
? 'w' : '-', ur
? 'r' : '-');
9487 /*****************************************************************************/
9493 PPC_DIRECT
= 0, /* Opcode routine */
9494 PPC_INDIRECT
= 1, /* Indirect opcode table */
9497 static inline int is_indirect_opcode (void *handler
)
9499 return ((unsigned long)handler
& 0x03) == PPC_INDIRECT
;
9502 static inline opc_handler_t
**ind_table(void *handler
)
9504 return (opc_handler_t
**)((unsigned long)handler
& ~3);
9507 /* Instruction table creation */
9508 /* Opcodes tables creation */
9509 static void fill_new_table (opc_handler_t
**table
, int len
)
9513 for (i
= 0; i
< len
; i
++)
9514 table
[i
] = &invalid_handler
;
9517 static int create_new_table (opc_handler_t
**table
, unsigned char idx
)
9519 opc_handler_t
**tmp
;
9521 tmp
= malloc(0x20 * sizeof(opc_handler_t
));
9522 fill_new_table(tmp
, 0x20);
9523 table
[idx
] = (opc_handler_t
*)((unsigned long)tmp
| PPC_INDIRECT
);
9528 static int insert_in_table (opc_handler_t
**table
, unsigned char idx
,
9529 opc_handler_t
*handler
)
9531 if (table
[idx
] != &invalid_handler
)
9533 table
[idx
] = handler
;
9538 static int register_direct_insn (opc_handler_t
**ppc_opcodes
,
9539 unsigned char idx
, opc_handler_t
*handler
)
9541 if (insert_in_table(ppc_opcodes
, idx
, handler
) < 0) {
9542 printf("*** ERROR: opcode %02x already assigned in main "
9543 "opcode table\n", idx
);
9544 #if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)
9545 printf(" Registered handler '%s' - new handler '%s'\n",
9546 ppc_opcodes
[idx
]->oname
, handler
->oname
);
9554 static int register_ind_in_table (opc_handler_t
**table
,
9555 unsigned char idx1
, unsigned char idx2
,
9556 opc_handler_t
*handler
)
9558 if (table
[idx1
] == &invalid_handler
) {
9559 if (create_new_table(table
, idx1
) < 0) {
9560 printf("*** ERROR: unable to create indirect table "
9561 "idx=%02x\n", idx1
);
9565 if (!is_indirect_opcode(table
[idx1
])) {
9566 printf("*** ERROR: idx %02x already assigned to a direct "
9568 #if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)
9569 printf(" Registered handler '%s' - new handler '%s'\n",
9570 ind_table(table
[idx1
])[idx2
]->oname
, handler
->oname
);
9575 if (handler
!= NULL
&&
9576 insert_in_table(ind_table(table
[idx1
]), idx2
, handler
) < 0) {
9577 printf("*** ERROR: opcode %02x already assigned in "
9578 "opcode table %02x\n", idx2
, idx1
);
9579 #if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)
9580 printf(" Registered handler '%s' - new handler '%s'\n",
9581 ind_table(table
[idx1
])[idx2
]->oname
, handler
->oname
);
9589 static int register_ind_insn (opc_handler_t
**ppc_opcodes
,
9590 unsigned char idx1
, unsigned char idx2
,
9591 opc_handler_t
*handler
)
9595 ret
= register_ind_in_table(ppc_opcodes
, idx1
, idx2
, handler
);
9600 static int register_dblind_insn (opc_handler_t
**ppc_opcodes
,
9601 unsigned char idx1
, unsigned char idx2
,
9602 unsigned char idx3
, opc_handler_t
*handler
)
9604 if (register_ind_in_table(ppc_opcodes
, idx1
, idx2
, NULL
) < 0) {
9605 printf("*** ERROR: unable to join indirect table idx "
9606 "[%02x-%02x]\n", idx1
, idx2
);
9609 if (register_ind_in_table(ind_table(ppc_opcodes
[idx1
]), idx2
, idx3
,
9611 printf("*** ERROR: unable to insert opcode "
9612 "[%02x-%02x-%02x]\n", idx1
, idx2
, idx3
);
9619 static int register_insn (opc_handler_t
**ppc_opcodes
, opcode_t
*insn
)
9621 if (insn
->opc2
!= 0xFF) {
9622 if (insn
->opc3
!= 0xFF) {
9623 if (register_dblind_insn(ppc_opcodes
, insn
->opc1
, insn
->opc2
,
9624 insn
->opc3
, &insn
->handler
) < 0)
9627 if (register_ind_insn(ppc_opcodes
, insn
->opc1
,
9628 insn
->opc2
, &insn
->handler
) < 0)
9632 if (register_direct_insn(ppc_opcodes
, insn
->opc1
, &insn
->handler
) < 0)
9639 static int test_opcode_table (opc_handler_t
**table
, int len
)
9643 for (i
= 0, count
= 0; i
< len
; i
++) {
9644 /* Consistency fixup */
9645 if (table
[i
] == NULL
)
9646 table
[i
] = &invalid_handler
;
9647 if (table
[i
] != &invalid_handler
) {
9648 if (is_indirect_opcode(table
[i
])) {
9649 tmp
= test_opcode_table(ind_table(table
[i
]), 0x20);
9652 table
[i
] = &invalid_handler
;
9665 static void fix_opcode_tables (opc_handler_t
**ppc_opcodes
)
9667 if (test_opcode_table(ppc_opcodes
, 0x40) == 0)
9668 printf("*** WARNING: no opcode defined !\n");
9671 /*****************************************************************************/
9672 static int create_ppc_opcodes (CPUPPCState
*env
, const ppc_def_t
*def
)
9676 fill_new_table(env
->opcodes
, 0x40);
9677 for (opc
= opcodes
; opc
< &opcodes
[ARRAY_SIZE(opcodes
)]; opc
++) {
9678 if (((opc
->handler
.type
& def
->insns_flags
) != 0) ||
9679 ((opc
->handler
.type2
& def
->insns_flags2
) != 0)) {
9680 if (register_insn(env
->opcodes
, opc
) < 0) {
9681 printf("*** ERROR initializing PowerPC instruction "
9682 "0x%02x 0x%02x 0x%02x\n", opc
->opc1
, opc
->opc2
,
9688 fix_opcode_tables(env
->opcodes
);
9695 #if defined(PPC_DUMP_CPU)
9696 static void dump_ppc_insns (CPUPPCState
*env
)
9698 opc_handler_t
**table
, *handler
;
9700 uint8_t opc1
, opc2
, opc3
;
9702 printf("Instructions set:\n");
9703 /* opc1 is 6 bits long */
9704 for (opc1
= 0x00; opc1
< 0x40; opc1
++) {
9705 table
= env
->opcodes
;
9706 handler
= table
[opc1
];
9707 if (is_indirect_opcode(handler
)) {
9708 /* opc2 is 5 bits long */
9709 for (opc2
= 0; opc2
< 0x20; opc2
++) {
9710 table
= env
->opcodes
;
9711 handler
= env
->opcodes
[opc1
];
9712 table
= ind_table(handler
);
9713 handler
= table
[opc2
];
9714 if (is_indirect_opcode(handler
)) {
9715 table
= ind_table(handler
);
9716 /* opc3 is 5 bits long */
9717 for (opc3
= 0; opc3
< 0x20; opc3
++) {
9718 handler
= table
[opc3
];
9719 if (handler
->handler
!= &gen_invalid
) {
9720 /* Special hack to properly dump SPE insns */
9721 p
= strchr(handler
->oname
, '_');
9723 printf("INSN: %02x %02x %02x (%02d %04d) : "
9725 opc1
, opc2
, opc3
, opc1
,
9730 if ((p
- handler
->oname
) != strlen(q
) ||
9731 memcmp(handler
->oname
, q
, strlen(q
)) != 0) {
9732 /* First instruction */
9733 printf("INSN: %02x %02x %02x (%02d %04d) : "
9735 opc1
, opc2
<< 1, opc3
, opc1
,
9736 (opc3
<< 6) | (opc2
<< 1),
9737 (int)(p
- handler
->oname
),
9740 if (strcmp(p
+ 1, q
) != 0) {
9741 /* Second instruction */
9742 printf("INSN: %02x %02x %02x (%02d %04d) : "
9744 opc1
, (opc2
<< 1) | 1, opc3
, opc1
,
9745 (opc3
<< 6) | (opc2
<< 1) | 1,
9752 if (handler
->handler
!= &gen_invalid
) {
9753 printf("INSN: %02x %02x -- (%02d %04d) : %s\n",
9754 opc1
, opc2
, opc1
, opc2
, handler
->oname
);
9759 if (handler
->handler
!= &gen_invalid
) {
9760 printf("INSN: %02x -- -- (%02d ----) : %s\n",
9761 opc1
, opc1
, handler
->oname
);
9768 static int gdb_get_float_reg(CPUState
*env
, uint8_t *mem_buf
, int n
)
9771 stfq_p(mem_buf
, env
->fpr
[n
]);
9775 stl_p(mem_buf
, env
->fpscr
);
9781 static int gdb_set_float_reg(CPUState
*env
, uint8_t *mem_buf
, int n
)
9784 env
->fpr
[n
] = ldfq_p(mem_buf
);
9788 /* FPSCR not implemented */
9794 static int gdb_get_avr_reg(CPUState
*env
, uint8_t *mem_buf
, int n
)
9797 #ifdef HOST_WORDS_BIGENDIAN
9798 stq_p(mem_buf
, env
->avr
[n
].u64
[0]);
9799 stq_p(mem_buf
+8, env
->avr
[n
].u64
[1]);
9801 stq_p(mem_buf
, env
->avr
[n
].u64
[1]);
9802 stq_p(mem_buf
+8, env
->avr
[n
].u64
[0]);
9807 stl_p(mem_buf
, env
->vscr
);
9811 stl_p(mem_buf
, (uint32_t)env
->spr
[SPR_VRSAVE
]);
9817 static int gdb_set_avr_reg(CPUState
*env
, uint8_t *mem_buf
, int n
)
9820 #ifdef HOST_WORDS_BIGENDIAN
9821 env
->avr
[n
].u64
[0] = ldq_p(mem_buf
);
9822 env
->avr
[n
].u64
[1] = ldq_p(mem_buf
+8);
9824 env
->avr
[n
].u64
[1] = ldq_p(mem_buf
);
9825 env
->avr
[n
].u64
[0] = ldq_p(mem_buf
+8);
9830 env
->vscr
= ldl_p(mem_buf
);
9834 env
->spr
[SPR_VRSAVE
] = (target_ulong
)ldl_p(mem_buf
);
9840 static int gdb_get_spe_reg(CPUState
*env
, uint8_t *mem_buf
, int n
)
9843 #if defined(TARGET_PPC64)
9844 stl_p(mem_buf
, env
->gpr
[n
] >> 32);
9846 stl_p(mem_buf
, env
->gprh
[n
]);
9851 stq_p(mem_buf
, env
->spe_acc
);
9855 stl_p(mem_buf
, env
->spe_fscr
);
9861 static int gdb_set_spe_reg(CPUState
*env
, uint8_t *mem_buf
, int n
)
9864 #if defined(TARGET_PPC64)
9865 target_ulong lo
= (uint32_t)env
->gpr
[n
];
9866 target_ulong hi
= (target_ulong
)ldl_p(mem_buf
) << 32;
9867 env
->gpr
[n
] = lo
| hi
;
9869 env
->gprh
[n
] = ldl_p(mem_buf
);
9874 env
->spe_acc
= ldq_p(mem_buf
);
9878 env
->spe_fscr
= ldl_p(mem_buf
);
9884 int cpu_ppc_register_internal (CPUPPCState
*env
, const ppc_def_t
*def
)
9886 env
->msr_mask
= def
->msr_mask
;
9887 env
->mmu_model
= def
->mmu_model
;
9888 env
->excp_model
= def
->excp_model
;
9889 env
->bus_model
= def
->bus_model
;
9890 env
->insns_flags
= def
->insns_flags
;
9891 env
->insns_flags2
= def
->insns_flags2
;
9892 if (!kvm_enabled()) {
9893 /* TCG doesn't (yet) emulate some groups of instructions that
9894 * are implemented on some otherwise supported CPUs (e.g. VSX
9895 * and decimal floating point instructions on POWER7). We
9896 * remove unsupported instruction groups from the cpu state's
9897 * instruction masks and hope the guest can cope. For at
9898 * least the pseries machine, the unavailability of these
9899 * instructions can be advertise to the guest via the device
9902 * FIXME: we should have a similar masking for CPU features
9903 * not accessible under KVM, but so far, there aren't any of
9905 env
->insns_flags
&= PPC_TCG_INSNS
;
9906 env
->insns_flags2
&= PPC_TCG_INSNS2
;
9908 env
->flags
= def
->flags
;
9909 env
->bfd_mach
= def
->bfd_mach
;
9910 env
->check_pow
= def
->check_pow
;
9911 if (create_ppc_opcodes(env
, def
) < 0)
9913 init_ppc_proc(env
, def
);
9915 if (def
->insns_flags
& PPC_FLOAT
) {
9916 gdb_register_coprocessor(env
, gdb_get_float_reg
, gdb_set_float_reg
,
9917 33, "power-fpu.xml", 0);
9919 if (def
->insns_flags
& PPC_ALTIVEC
) {
9920 gdb_register_coprocessor(env
, gdb_get_avr_reg
, gdb_set_avr_reg
,
9921 34, "power-altivec.xml", 0);
9923 if (def
->insns_flags
& PPC_SPE
) {
9924 gdb_register_coprocessor(env
, gdb_get_spe_reg
, gdb_set_spe_reg
,
9925 34, "power-spe.xml", 0);
9928 #if defined(PPC_DUMP_CPU)
9930 const char *mmu_model
, *excp_model
, *bus_model
;
9931 switch (env
->mmu_model
) {
9932 case POWERPC_MMU_32B
:
9933 mmu_model
= "PowerPC 32";
9935 case POWERPC_MMU_SOFT_6xx
:
9936 mmu_model
= "PowerPC 6xx/7xx with software driven TLBs";
9938 case POWERPC_MMU_SOFT_74xx
:
9939 mmu_model
= "PowerPC 74xx with software driven TLBs";
9941 case POWERPC_MMU_SOFT_4xx
:
9942 mmu_model
= "PowerPC 4xx with software driven TLBs";
9944 case POWERPC_MMU_SOFT_4xx_Z
:
9945 mmu_model
= "PowerPC 4xx with software driven TLBs "
9946 "and zones protections";
9948 case POWERPC_MMU_REAL
:
9949 mmu_model
= "PowerPC real mode only";
9951 case POWERPC_MMU_MPC8xx
:
9952 mmu_model
= "PowerPC MPC8xx";
9954 case POWERPC_MMU_BOOKE
:
9955 mmu_model
= "PowerPC BookE";
9957 case POWERPC_MMU_BOOKE206
:
9958 mmu_model
= "PowerPC BookE 2.06";
9960 case POWERPC_MMU_601
:
9961 mmu_model
= "PowerPC 601";
9963 #if defined (TARGET_PPC64)
9964 case POWERPC_MMU_64B
:
9965 mmu_model
= "PowerPC 64";
9967 case POWERPC_MMU_620
:
9968 mmu_model
= "PowerPC 620";
9972 mmu_model
= "Unknown or invalid";
9975 switch (env
->excp_model
) {
9976 case POWERPC_EXCP_STD
:
9977 excp_model
= "PowerPC";
9979 case POWERPC_EXCP_40x
:
9980 excp_model
= "PowerPC 40x";
9982 case POWERPC_EXCP_601
:
9983 excp_model
= "PowerPC 601";
9985 case POWERPC_EXCP_602
:
9986 excp_model
= "PowerPC 602";
9988 case POWERPC_EXCP_603
:
9989 excp_model
= "PowerPC 603";
9991 case POWERPC_EXCP_603E
:
9992 excp_model
= "PowerPC 603e";
9994 case POWERPC_EXCP_604
:
9995 excp_model
= "PowerPC 604";
9997 case POWERPC_EXCP_7x0
:
9998 excp_model
= "PowerPC 740/750";
10000 case POWERPC_EXCP_7x5
:
10001 excp_model
= "PowerPC 745/755";
10003 case POWERPC_EXCP_74xx
:
10004 excp_model
= "PowerPC 74xx";
10006 case POWERPC_EXCP_BOOKE
:
10007 excp_model
= "PowerPC BookE";
10009 #if defined (TARGET_PPC64)
10010 case POWERPC_EXCP_970
:
10011 excp_model
= "PowerPC 970";
10015 excp_model
= "Unknown or invalid";
10018 switch (env
->bus_model
) {
10019 case PPC_FLAGS_INPUT_6xx
:
10020 bus_model
= "PowerPC 6xx";
10022 case PPC_FLAGS_INPUT_BookE
:
10023 bus_model
= "PowerPC BookE";
10025 case PPC_FLAGS_INPUT_405
:
10026 bus_model
= "PowerPC 405";
10028 case PPC_FLAGS_INPUT_401
:
10029 bus_model
= "PowerPC 401/403";
10031 case PPC_FLAGS_INPUT_RCPU
:
10032 bus_model
= "RCPU / MPC8xx";
10034 #if defined (TARGET_PPC64)
10035 case PPC_FLAGS_INPUT_970
:
10036 bus_model
= "PowerPC 970";
10040 bus_model
= "Unknown or invalid";
10043 printf("PowerPC %-12s : PVR %08x MSR %016" PRIx64
"\n"
10044 " MMU model : %s\n",
10045 def
->name
, def
->pvr
, def
->msr_mask
, mmu_model
);
10046 #if !defined(CONFIG_USER_ONLY)
10047 if (env
->tlb
!= NULL
) {
10048 printf(" %d %s TLB in %d ways\n",
10049 env
->nb_tlb
, env
->id_tlbs
? "splitted" : "merged",
10053 printf(" Exceptions model : %s\n"
10054 " Bus model : %s\n",
10055 excp_model
, bus_model
);
10056 printf(" MSR features :\n");
10057 if (env
->flags
& POWERPC_FLAG_SPE
)
10058 printf(" signal processing engine enable"
10060 else if (env
->flags
& POWERPC_FLAG_VRE
)
10061 printf(" vector processor enable\n");
10062 if (env
->flags
& POWERPC_FLAG_TGPR
)
10063 printf(" temporary GPRs\n");
10064 else if (env
->flags
& POWERPC_FLAG_CE
)
10065 printf(" critical input enable\n");
10066 if (env
->flags
& POWERPC_FLAG_SE
)
10067 printf(" single-step trace mode\n");
10068 else if (env
->flags
& POWERPC_FLAG_DWE
)
10069 printf(" debug wait enable\n");
10070 else if (env
->flags
& POWERPC_FLAG_UBLE
)
10071 printf(" user BTB lock enable\n");
10072 if (env
->flags
& POWERPC_FLAG_BE
)
10073 printf(" branch-step trace mode\n");
10074 else if (env
->flags
& POWERPC_FLAG_DE
)
10075 printf(" debug interrupt enable\n");
10076 if (env
->flags
& POWERPC_FLAG_PX
)
10077 printf(" inclusive protection\n");
10078 else if (env
->flags
& POWERPC_FLAG_PMM
)
10079 printf(" performance monitor mark\n");
10080 if (env
->flags
== POWERPC_FLAG_NONE
)
10082 printf(" Time-base/decrementer clock source: %s\n",
10083 env
->flags
& POWERPC_FLAG_RTC_CLK
? "RTC clock" : "bus clock");
10085 dump_ppc_insns(env
);
10086 dump_ppc_sprs(env
);
10093 static bool ppc_cpu_usable(const ppc_def_t
*def
)
10095 #if defined(TARGET_PPCEMB)
10096 /* When using the ppcemb target, we only support 440 style cores */
10097 if (def
->mmu_model
!= POWERPC_MMU_BOOKE
) {
10105 const ppc_def_t
*ppc_find_by_pvr(uint32_t pvr
)
10109 for (i
= 0; i
< ARRAY_SIZE(ppc_defs
); i
++) {
10110 if (!ppc_cpu_usable(&ppc_defs
[i
])) {
10114 /* If we have an exact match, we're done */
10115 if (pvr
== ppc_defs
[i
].pvr
) {
10116 return &ppc_defs
[i
];
10125 const ppc_def_t
*cpu_ppc_find_by_name (const char *name
)
10127 const ppc_def_t
*ret
;
10131 if (kvm_enabled() && (strcasecmp(name
, "host") == 0)) {
10132 return kvmppc_host_cpu_def();
10135 /* Check if the given name is a PVR */
10136 len
= strlen(name
);
10137 if (len
== 10 && name
[0] == '0' && name
[1] == 'x') {
10140 } else if (len
== 8) {
10143 for (i
= 0; i
< 8; i
++) {
10144 if (!qemu_isxdigit(*p
++))
10148 return ppc_find_by_pvr(strtoul(name
, NULL
, 16));
10151 max
= ARRAY_SIZE(ppc_defs
);
10152 for (i
= 0; i
< max
; i
++) {
10153 if (!ppc_cpu_usable(&ppc_defs
[i
])) {
10157 if (strcasecmp(name
, ppc_defs
[i
].name
) == 0) {
10158 ret
= &ppc_defs
[i
];
10166 void ppc_cpu_list (FILE *f
, fprintf_function cpu_fprintf
)
10170 max
= ARRAY_SIZE(ppc_defs
);
10171 for (i
= 0; i
< max
; i
++) {
10172 if (!ppc_cpu_usable(&ppc_defs
[i
])) {
10176 (*cpu_fprintf
)(f
, "PowerPC %-16s PVR %08x\n",
10177 ppc_defs
[i
].name
, ppc_defs
[i
].pvr
);