configure: fix --meson=/path/to/meson
[qemu.git] / target / ppc / translate_init.c.inc
1 /*
2  *  PowerPC CPU initialization for qemu.
3  *
4  *  Copyright (c) 2003-2007 Jocelyn Mayer
5  *  Copyright 2011 Freescale Semiconductor, Inc.
6  *
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.
11  *
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.
16  *
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/>.
19  */
20
21 #include "disas/dis-asm.h"
22 #include "exec/gdbstub.h"
23 #include "kvm_ppc.h"
24 #include "sysemu/arch_init.h"
25 #include "sysemu/cpus.h"
26 #include "sysemu/hw_accel.h"
27 #include "sysemu/tcg.h"
28 #include "cpu-models.h"
29 #include "mmu-hash32.h"
30 #include "mmu-hash64.h"
31 #include "qemu/error-report.h"
32 #include "qemu/module.h"
33 #include "qemu/qemu-print.h"
34 #include "qapi/error.h"
35 #include "qapi/qmp/qnull.h"
36 #include "qapi/visitor.h"
37 #include "hw/qdev-properties.h"
38 #include "hw/ppc/ppc.h"
39 #include "mmu-book3s-v3.h"
40 #include "sysemu/qtest.h"
41 #include "qemu/cutils.h"
42 #include "disas/capstone.h"
43 #include "fpu/softfloat.h"
44 #include "qapi/qapi-commands-machine-target.h"
45
46 /* #define PPC_DUMP_CPU */
47 /* #define PPC_DEBUG_SPR */
48 /* #define PPC_DUMP_SPR_ACCESSES */
49 /* #define USE_APPLE_GDB */
50
51 /*
52  * Generic callbacks:
53  * do nothing but store/retrieve spr value
54  */
55 static void spr_load_dump_spr(int sprn)
56 {
57 #ifdef PPC_DUMP_SPR_ACCESSES
58     TCGv_i32 t0 = tcg_const_i32(sprn);
59     gen_helper_load_dump_spr(cpu_env, t0);
60     tcg_temp_free_i32(t0);
61 #endif
62 }
63
64 static void spr_read_generic(DisasContext *ctx, int gprn, int sprn)
65 {
66     gen_load_spr(cpu_gpr[gprn], sprn);
67     spr_load_dump_spr(sprn);
68 }
69
70 static void spr_store_dump_spr(int sprn)
71 {
72 #ifdef PPC_DUMP_SPR_ACCESSES
73     TCGv_i32 t0 = tcg_const_i32(sprn);
74     gen_helper_store_dump_spr(cpu_env, t0);
75     tcg_temp_free_i32(t0);
76 #endif
77 }
78
79 static void spr_write_generic(DisasContext *ctx, int sprn, int gprn)
80 {
81     gen_store_spr(sprn, cpu_gpr[gprn]);
82     spr_store_dump_spr(sprn);
83 }
84
85 #if !defined(CONFIG_USER_ONLY)
86 static void spr_write_generic32(DisasContext *ctx, int sprn, int gprn)
87 {
88 #ifdef TARGET_PPC64
89     TCGv t0 = tcg_temp_new();
90     tcg_gen_ext32u_tl(t0, cpu_gpr[gprn]);
91     gen_store_spr(sprn, t0);
92     tcg_temp_free(t0);
93     spr_store_dump_spr(sprn);
94 #else
95     spr_write_generic(ctx, sprn, gprn);
96 #endif
97 }
98
99 static void spr_write_clear(DisasContext *ctx, int sprn, int gprn)
100 {
101     TCGv t0 = tcg_temp_new();
102     TCGv t1 = tcg_temp_new();
103     gen_load_spr(t0, sprn);
104     tcg_gen_neg_tl(t1, cpu_gpr[gprn]);
105     tcg_gen_and_tl(t0, t0, t1);
106     gen_store_spr(sprn, t0);
107     tcg_temp_free(t0);
108     tcg_temp_free(t1);
109 }
110
111 static void spr_access_nop(DisasContext *ctx, int sprn, int gprn)
112 {
113 }
114
115 #endif
116
117 /* SPR common to all PowerPC */
118 /* XER */
119 static void spr_read_xer(DisasContext *ctx, int gprn, int sprn)
120 {
121     gen_read_xer(ctx, cpu_gpr[gprn]);
122 }
123
124 static void spr_write_xer(DisasContext *ctx, int sprn, int gprn)
125 {
126     gen_write_xer(cpu_gpr[gprn]);
127 }
128
129 /* LR */
130 static void spr_read_lr(DisasContext *ctx, int gprn, int sprn)
131 {
132     tcg_gen_mov_tl(cpu_gpr[gprn], cpu_lr);
133 }
134
135 static void spr_write_lr(DisasContext *ctx, int sprn, int gprn)
136 {
137     tcg_gen_mov_tl(cpu_lr, cpu_gpr[gprn]);
138 }
139
140 /* CFAR */
141 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
142 static void spr_read_cfar(DisasContext *ctx, int gprn, int sprn)
143 {
144     tcg_gen_mov_tl(cpu_gpr[gprn], cpu_cfar);
145 }
146
147 static void spr_write_cfar(DisasContext *ctx, int sprn, int gprn)
148 {
149     tcg_gen_mov_tl(cpu_cfar, cpu_gpr[gprn]);
150 }
151 #endif /* defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY) */
152
153 /* CTR */
154 static void spr_read_ctr(DisasContext *ctx, int gprn, int sprn)
155 {
156     tcg_gen_mov_tl(cpu_gpr[gprn], cpu_ctr);
157 }
158
159 static void spr_write_ctr(DisasContext *ctx, int sprn, int gprn)
160 {
161     tcg_gen_mov_tl(cpu_ctr, cpu_gpr[gprn]);
162 }
163
164 /* User read access to SPR */
165 /* USPRx */
166 /* UMMCRx */
167 /* UPMCx */
168 /* USIA */
169 /* UDECR */
170 static void spr_read_ureg(DisasContext *ctx, int gprn, int sprn)
171 {
172     gen_load_spr(cpu_gpr[gprn], sprn + 0x10);
173 }
174
175 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
176 static void spr_write_ureg(DisasContext *ctx, int sprn, int gprn)
177 {
178     gen_store_spr(sprn + 0x10, cpu_gpr[gprn]);
179 }
180 #endif
181
182 /* SPR common to all non-embedded PowerPC */
183 /* DECR */
184 #if !defined(CONFIG_USER_ONLY)
185 static void spr_read_decr(DisasContext *ctx, int gprn, int sprn)
186 {
187     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
188         gen_io_start();
189     }
190     gen_helper_load_decr(cpu_gpr[gprn], cpu_env);
191     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
192         gen_stop_exception(ctx);
193     }
194 }
195
196 static void spr_write_decr(DisasContext *ctx, int sprn, int gprn)
197 {
198     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
199         gen_io_start();
200     }
201     gen_helper_store_decr(cpu_env, cpu_gpr[gprn]);
202     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
203         gen_stop_exception(ctx);
204     }
205 }
206 #endif
207
208 /* SPR common to all non-embedded PowerPC, except 601 */
209 /* Time base */
210 static void spr_read_tbl(DisasContext *ctx, int gprn, int sprn)
211 {
212     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
213         gen_io_start();
214     }
215     gen_helper_load_tbl(cpu_gpr[gprn], cpu_env);
216     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
217         gen_io_end();
218         gen_stop_exception(ctx);
219     }
220 }
221
222 static void spr_read_tbu(DisasContext *ctx, int gprn, int sprn)
223 {
224     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
225         gen_io_start();
226     }
227     gen_helper_load_tbu(cpu_gpr[gprn], cpu_env);
228     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
229         gen_io_end();
230         gen_stop_exception(ctx);
231     }
232 }
233
234 ATTRIBUTE_UNUSED
235 static void spr_read_atbl(DisasContext *ctx, int gprn, int sprn)
236 {
237     gen_helper_load_atbl(cpu_gpr[gprn], cpu_env);
238 }
239
240 ATTRIBUTE_UNUSED
241 static void spr_read_atbu(DisasContext *ctx, int gprn, int sprn)
242 {
243     gen_helper_load_atbu(cpu_gpr[gprn], cpu_env);
244 }
245
246 #if !defined(CONFIG_USER_ONLY)
247 static void spr_write_tbl(DisasContext *ctx, int sprn, int gprn)
248 {
249     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
250         gen_io_start();
251     }
252     gen_helper_store_tbl(cpu_env, cpu_gpr[gprn]);
253     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
254         gen_io_end();
255         gen_stop_exception(ctx);
256     }
257 }
258
259 static void spr_write_tbu(DisasContext *ctx, int sprn, int gprn)
260 {
261     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
262         gen_io_start();
263     }
264     gen_helper_store_tbu(cpu_env, cpu_gpr[gprn]);
265     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
266         gen_io_end();
267         gen_stop_exception(ctx);
268     }
269 }
270
271 ATTRIBUTE_UNUSED
272 static void spr_write_atbl(DisasContext *ctx, int sprn, int gprn)
273 {
274     gen_helper_store_atbl(cpu_env, cpu_gpr[gprn]);
275 }
276
277 ATTRIBUTE_UNUSED
278 static void spr_write_atbu(DisasContext *ctx, int sprn, int gprn)
279 {
280     gen_helper_store_atbu(cpu_env, cpu_gpr[gprn]);
281 }
282
283 #if defined(TARGET_PPC64)
284 ATTRIBUTE_UNUSED
285 static void spr_read_purr(DisasContext *ctx, int gprn, int sprn)
286 {
287     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
288         gen_io_start();
289     }
290     gen_helper_load_purr(cpu_gpr[gprn], cpu_env);
291     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
292         gen_stop_exception(ctx);
293     }
294 }
295
296 static void spr_write_purr(DisasContext *ctx, int sprn, int gprn)
297 {
298     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
299         gen_io_start();
300     }
301     gen_helper_store_purr(cpu_env, cpu_gpr[gprn]);
302     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
303         gen_stop_exception(ctx);
304     }
305 }
306
307 /* HDECR */
308 static void spr_read_hdecr(DisasContext *ctx, int gprn, int sprn)
309 {
310     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
311         gen_io_start();
312     }
313     gen_helper_load_hdecr(cpu_gpr[gprn], cpu_env);
314     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
315         gen_io_end();
316         gen_stop_exception(ctx);
317     }
318 }
319
320 static void spr_write_hdecr(DisasContext *ctx, int sprn, int gprn)
321 {
322     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
323         gen_io_start();
324     }
325     gen_helper_store_hdecr(cpu_env, cpu_gpr[gprn]);
326     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
327         gen_io_end();
328         gen_stop_exception(ctx);
329     }
330 }
331
332 static void spr_read_vtb(DisasContext *ctx, int gprn, int sprn)
333 {
334     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
335         gen_io_start();
336     }
337     gen_helper_load_vtb(cpu_gpr[gprn], cpu_env);
338     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
339         gen_stop_exception(ctx);
340     }
341 }
342
343 static void spr_write_vtb(DisasContext *ctx, int sprn, int gprn)
344 {
345     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
346         gen_io_start();
347     }
348     gen_helper_store_vtb(cpu_env, cpu_gpr[gprn]);
349     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
350         gen_stop_exception(ctx);
351     }
352 }
353
354 static void spr_write_tbu40(DisasContext *ctx, int sprn, int gprn)
355 {
356     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
357         gen_io_start();
358     }
359     gen_helper_store_tbu40(cpu_env, cpu_gpr[gprn]);
360     if (tb_cflags(ctx->base.tb) & CF_USE_ICOUNT) {
361         gen_stop_exception(ctx);
362     }
363 }
364
365 #endif
366 #endif
367
368 #if !defined(CONFIG_USER_ONLY)
369 /* IBAT0U...IBAT0U */
370 /* IBAT0L...IBAT7L */
371 static void spr_read_ibat(DisasContext *ctx, int gprn, int sprn)
372 {
373     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env,
374                   offsetof(CPUPPCState,
375                            IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
376 }
377
378 static void spr_read_ibat_h(DisasContext *ctx, int gprn, int sprn)
379 {
380     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env,
381                   offsetof(CPUPPCState,
382                            IBAT[sprn & 1][((sprn - SPR_IBAT4U) / 2) + 4]));
383 }
384
385 static void spr_write_ibatu(DisasContext *ctx, int sprn, int gprn)
386 {
387     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
388     gen_helper_store_ibatu(cpu_env, t0, cpu_gpr[gprn]);
389     tcg_temp_free_i32(t0);
390 }
391
392 static void spr_write_ibatu_h(DisasContext *ctx, int sprn, int gprn)
393 {
394     TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_IBAT4U) / 2) + 4);
395     gen_helper_store_ibatu(cpu_env, t0, cpu_gpr[gprn]);
396     tcg_temp_free_i32(t0);
397 }
398
399 static void spr_write_ibatl(DisasContext *ctx, int sprn, int gprn)
400 {
401     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0L) / 2);
402     gen_helper_store_ibatl(cpu_env, t0, cpu_gpr[gprn]);
403     tcg_temp_free_i32(t0);
404 }
405
406 static void spr_write_ibatl_h(DisasContext *ctx, int sprn, int gprn)
407 {
408     TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_IBAT4L) / 2) + 4);
409     gen_helper_store_ibatl(cpu_env, t0, cpu_gpr[gprn]);
410     tcg_temp_free_i32(t0);
411 }
412
413 /* DBAT0U...DBAT7U */
414 /* DBAT0L...DBAT7L */
415 static void spr_read_dbat(DisasContext *ctx, int gprn, int sprn)
416 {
417     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env,
418                   offsetof(CPUPPCState,
419                            DBAT[sprn & 1][(sprn - SPR_DBAT0U) / 2]));
420 }
421
422 static void spr_read_dbat_h(DisasContext *ctx, int gprn, int sprn)
423 {
424     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env,
425                   offsetof(CPUPPCState,
426                            DBAT[sprn & 1][((sprn - SPR_DBAT4U) / 2) + 4]));
427 }
428
429 static void spr_write_dbatu(DisasContext *ctx, int sprn, int gprn)
430 {
431     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_DBAT0U) / 2);
432     gen_helper_store_dbatu(cpu_env, t0, cpu_gpr[gprn]);
433     tcg_temp_free_i32(t0);
434 }
435
436 static void spr_write_dbatu_h(DisasContext *ctx, int sprn, int gprn)
437 {
438     TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_DBAT4U) / 2) + 4);
439     gen_helper_store_dbatu(cpu_env, t0, cpu_gpr[gprn]);
440     tcg_temp_free_i32(t0);
441 }
442
443 static void spr_write_dbatl(DisasContext *ctx, int sprn, int gprn)
444 {
445     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_DBAT0L) / 2);
446     gen_helper_store_dbatl(cpu_env, t0, cpu_gpr[gprn]);
447     tcg_temp_free_i32(t0);
448 }
449
450 static void spr_write_dbatl_h(DisasContext *ctx, int sprn, int gprn)
451 {
452     TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_DBAT4L) / 2) + 4);
453     gen_helper_store_dbatl(cpu_env, t0, cpu_gpr[gprn]);
454     tcg_temp_free_i32(t0);
455 }
456
457 /* SDR1 */
458 static void spr_write_sdr1(DisasContext *ctx, int sprn, int gprn)
459 {
460     gen_helper_store_sdr1(cpu_env, cpu_gpr[gprn]);
461 }
462
463 #if defined(TARGET_PPC64)
464 /* 64 bits PowerPC specific SPRs */
465 /* PIDR */
466 static void spr_write_pidr(DisasContext *ctx, int sprn, int gprn)
467 {
468     gen_helper_store_pidr(cpu_env, cpu_gpr[gprn]);
469 }
470
471 static void spr_write_lpidr(DisasContext *ctx, int sprn, int gprn)
472 {
473     gen_helper_store_lpidr(cpu_env, cpu_gpr[gprn]);
474 }
475
476 static void spr_read_hior(DisasContext *ctx, int gprn, int sprn)
477 {
478     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, excp_prefix));
479 }
480
481 static void spr_write_hior(DisasContext *ctx, int sprn, int gprn)
482 {
483     TCGv t0 = tcg_temp_new();
484     tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0x3FFFFF00000ULL);
485     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_prefix));
486     tcg_temp_free(t0);
487 }
488 static void spr_write_ptcr(DisasContext *ctx, int sprn, int gprn)
489 {
490     gen_helper_store_ptcr(cpu_env, cpu_gpr[gprn]);
491 }
492
493 static void spr_write_pcr(DisasContext *ctx, int sprn, int gprn)
494 {
495     gen_helper_store_pcr(cpu_env, cpu_gpr[gprn]);
496 }
497
498 /* DPDES */
499 static void spr_read_dpdes(DisasContext *ctx, int gprn, int sprn)
500 {
501     gen_helper_load_dpdes(cpu_gpr[gprn], cpu_env);
502 }
503
504 static void spr_write_dpdes(DisasContext *ctx, int sprn, int gprn)
505 {
506     gen_helper_store_dpdes(cpu_env, cpu_gpr[gprn]);
507 }
508 #endif
509 #endif
510
511 /* PowerPC 601 specific registers */
512 /* RTC */
513 static void spr_read_601_rtcl(DisasContext *ctx, int gprn, int sprn)
514 {
515     gen_helper_load_601_rtcl(cpu_gpr[gprn], cpu_env);
516 }
517
518 static void spr_read_601_rtcu(DisasContext *ctx, int gprn, int sprn)
519 {
520     gen_helper_load_601_rtcu(cpu_gpr[gprn], cpu_env);
521 }
522
523 #if !defined(CONFIG_USER_ONLY)
524 static void spr_write_601_rtcu(DisasContext *ctx, int sprn, int gprn)
525 {
526     gen_helper_store_601_rtcu(cpu_env, cpu_gpr[gprn]);
527 }
528
529 static void spr_write_601_rtcl(DisasContext *ctx, int sprn, int gprn)
530 {
531     gen_helper_store_601_rtcl(cpu_env, cpu_gpr[gprn]);
532 }
533
534 static void spr_write_hid0_601(DisasContext *ctx, int sprn, int gprn)
535 {
536     gen_helper_store_hid0_601(cpu_env, cpu_gpr[gprn]);
537     /* Must stop the translation as endianness may have changed */
538     gen_stop_exception(ctx);
539 }
540 #endif
541
542 /* Unified bats */
543 #if !defined(CONFIG_USER_ONLY)
544 static void spr_read_601_ubat(DisasContext *ctx, int gprn, int sprn)
545 {
546     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env,
547                   offsetof(CPUPPCState,
548                            IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
549 }
550
551 static void spr_write_601_ubatu(DisasContext *ctx, int sprn, int gprn)
552 {
553     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
554     gen_helper_store_601_batl(cpu_env, t0, cpu_gpr[gprn]);
555     tcg_temp_free_i32(t0);
556 }
557
558 static void spr_write_601_ubatl(DisasContext *ctx, int sprn, int gprn)
559 {
560     TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
561     gen_helper_store_601_batu(cpu_env, t0, cpu_gpr[gprn]);
562     tcg_temp_free_i32(t0);
563 }
564 #endif
565
566 /* PowerPC 40x specific registers */
567 #if !defined(CONFIG_USER_ONLY)
568 static void spr_read_40x_pit(DisasContext *ctx, int gprn, int sprn)
569 {
570     gen_helper_load_40x_pit(cpu_gpr[gprn], cpu_env);
571 }
572
573 static void spr_write_40x_pit(DisasContext *ctx, int sprn, int gprn)
574 {
575     gen_helper_store_40x_pit(cpu_env, cpu_gpr[gprn]);
576 }
577
578 static void spr_write_40x_dbcr0(DisasContext *ctx, int sprn, int gprn)
579 {
580     gen_store_spr(sprn, cpu_gpr[gprn]);
581     gen_helper_store_40x_dbcr0(cpu_env, cpu_gpr[gprn]);
582     /* We must stop translation as we may have rebooted */
583     gen_stop_exception(ctx);
584 }
585
586 static void spr_write_40x_sler(DisasContext *ctx, int sprn, int gprn)
587 {
588     gen_helper_store_40x_sler(cpu_env, cpu_gpr[gprn]);
589 }
590
591 static void spr_write_booke_tcr(DisasContext *ctx, int sprn, int gprn)
592 {
593     gen_helper_store_booke_tcr(cpu_env, cpu_gpr[gprn]);
594 }
595
596 static void spr_write_booke_tsr(DisasContext *ctx, int sprn, int gprn)
597 {
598     gen_helper_store_booke_tsr(cpu_env, cpu_gpr[gprn]);
599 }
600 #endif
601
602 /* PowerPC 403 specific registers */
603 /* PBL1 / PBU1 / PBL2 / PBU2 */
604 #if !defined(CONFIG_USER_ONLY)
605 static void spr_read_403_pbr(DisasContext *ctx, int gprn, int sprn)
606 {
607     tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env,
608                   offsetof(CPUPPCState, pb[sprn - SPR_403_PBL1]));
609 }
610
611 static void spr_write_403_pbr(DisasContext *ctx, int sprn, int gprn)
612 {
613     TCGv_i32 t0 = tcg_const_i32(sprn - SPR_403_PBL1);
614     gen_helper_store_403_pbr(cpu_env, t0, cpu_gpr[gprn]);
615     tcg_temp_free_i32(t0);
616 }
617
618 static void spr_write_pir(DisasContext *ctx, int sprn, int gprn)
619 {
620     TCGv t0 = tcg_temp_new();
621     tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0xF);
622     gen_store_spr(SPR_PIR, t0);
623     tcg_temp_free(t0);
624 }
625 #endif
626
627 /* SPE specific registers */
628 static void spr_read_spefscr(DisasContext *ctx, int gprn, int sprn)
629 {
630     TCGv_i32 t0 = tcg_temp_new_i32();
631     tcg_gen_ld_i32(t0, cpu_env, offsetof(CPUPPCState, spe_fscr));
632     tcg_gen_extu_i32_tl(cpu_gpr[gprn], t0);
633     tcg_temp_free_i32(t0);
634 }
635
636 static void spr_write_spefscr(DisasContext *ctx, int sprn, int gprn)
637 {
638     TCGv_i32 t0 = tcg_temp_new_i32();
639     tcg_gen_trunc_tl_i32(t0, cpu_gpr[gprn]);
640     tcg_gen_st_i32(t0, cpu_env, offsetof(CPUPPCState, spe_fscr));
641     tcg_temp_free_i32(t0);
642 }
643
644 #if !defined(CONFIG_USER_ONLY)
645 /* Callback used to write the exception vector base */
646 static void spr_write_excp_prefix(DisasContext *ctx, int sprn, int gprn)
647 {
648     TCGv t0 = tcg_temp_new();
649     tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUPPCState, ivpr_mask));
650     tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
651     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_prefix));
652     gen_store_spr(sprn, t0);
653     tcg_temp_free(t0);
654 }
655
656 static void spr_write_excp_vector(DisasContext *ctx, int sprn, int gprn)
657 {
658     int sprn_offs;
659
660     if (sprn >= SPR_BOOKE_IVOR0 && sprn <= SPR_BOOKE_IVOR15) {
661         sprn_offs = sprn - SPR_BOOKE_IVOR0;
662     } else if (sprn >= SPR_BOOKE_IVOR32 && sprn <= SPR_BOOKE_IVOR37) {
663         sprn_offs = sprn - SPR_BOOKE_IVOR32 + 32;
664     } else if (sprn >= SPR_BOOKE_IVOR38 && sprn <= SPR_BOOKE_IVOR42) {
665         sprn_offs = sprn - SPR_BOOKE_IVOR38 + 38;
666     } else {
667         printf("Trying to write an unknown exception vector %d %03x\n",
668                sprn, sprn);
669         gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
670         return;
671     }
672
673     TCGv t0 = tcg_temp_new();
674     tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUPPCState, ivor_mask));
675     tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
676     tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_vectors[sprn_offs]));
677     gen_store_spr(sprn, t0);
678     tcg_temp_free(t0);
679 }
680 #endif
681
682 static inline void vscr_init(CPUPPCState *env, uint32_t val)
683 {
684     /* Altivec always uses round-to-nearest */
685     set_float_rounding_mode(float_round_nearest_even, &env->vec_status);
686     helper_mtvscr(env, val);
687 }
688
689 #ifdef CONFIG_USER_ONLY
690 #define spr_register_kvm(env, num, name, uea_read, uea_write,                  \
691                          oea_read, oea_write, one_reg_id, initial_value)       \
692     _spr_register(env, num, name, uea_read, uea_write, initial_value)
693 #define spr_register_kvm_hv(env, num, name, uea_read, uea_write,               \
694                             oea_read, oea_write, hea_read, hea_write,          \
695                             one_reg_id, initial_value)                         \
696     _spr_register(env, num, name, uea_read, uea_write, initial_value)
697 #else
698 #if !defined(CONFIG_KVM)
699 #define spr_register_kvm(env, num, name, uea_read, uea_write,                  \
700                          oea_read, oea_write, one_reg_id, initial_value)       \
701     _spr_register(env, num, name, uea_read, uea_write,                         \
702                   oea_read, oea_write, oea_read, oea_write, initial_value)
703 #define spr_register_kvm_hv(env, num, name, uea_read, uea_write,               \
704                             oea_read, oea_write, hea_read, hea_write,          \
705                             one_reg_id, initial_value)                         \
706     _spr_register(env, num, name, uea_read, uea_write,                         \
707                   oea_read, oea_write, hea_read, hea_write, initial_value)
708 #else
709 #define spr_register_kvm(env, num, name, uea_read, uea_write,                  \
710                          oea_read, oea_write, one_reg_id, initial_value)       \
711     _spr_register(env, num, name, uea_read, uea_write,                         \
712                   oea_read, oea_write, oea_read, oea_write,                    \
713                   one_reg_id, initial_value)
714 #define spr_register_kvm_hv(env, num, name, uea_read, uea_write,               \
715                             oea_read, oea_write, hea_read, hea_write,          \
716                             one_reg_id, initial_value)                         \
717     _spr_register(env, num, name, uea_read, uea_write,                         \
718                   oea_read, oea_write, hea_read, hea_write,                    \
719                   one_reg_id, initial_value)
720 #endif
721 #endif
722
723 #define spr_register(env, num, name, uea_read, uea_write,                      \
724                      oea_read, oea_write, initial_value)                       \
725     spr_register_kvm(env, num, name, uea_read, uea_write,                      \
726                      oea_read, oea_write, 0, initial_value)
727
728 #define spr_register_hv(env, num, name, uea_read, uea_write,                   \
729                         oea_read, oea_write, hea_read, hea_write,              \
730                         initial_value)                                         \
731     spr_register_kvm_hv(env, num, name, uea_read, uea_write,                   \
732                         oea_read, oea_write, hea_read, hea_write,              \
733                         0, initial_value)
734
735 static inline void _spr_register(CPUPPCState *env, int num,
736                                  const char *name,
737                                  void (*uea_read)(DisasContext *ctx,
738                                                   int gprn, int sprn),
739                                  void (*uea_write)(DisasContext *ctx,
740                                                    int sprn, int gprn),
741 #if !defined(CONFIG_USER_ONLY)
742
743                                  void (*oea_read)(DisasContext *ctx,
744                                                   int gprn, int sprn),
745                                  void (*oea_write)(DisasContext *ctx,
746                                                    int sprn, int gprn),
747                                  void (*hea_read)(DisasContext *opaque,
748                                                   int gprn, int sprn),
749                                  void (*hea_write)(DisasContext *opaque,
750                                                    int sprn, int gprn),
751 #endif
752 #if defined(CONFIG_KVM)
753                                  uint64_t one_reg_id,
754 #endif
755                                  target_ulong initial_value)
756 {
757     ppc_spr_t *spr;
758
759     spr = &env->spr_cb[num];
760     if (spr->name != NULL || env->spr[num] != 0x00000000 ||
761 #if !defined(CONFIG_USER_ONLY)
762         spr->oea_read != NULL || spr->oea_write != NULL ||
763 #endif
764         spr->uea_read != NULL || spr->uea_write != NULL) {
765         printf("Error: Trying to register SPR %d (%03x) twice !\n", num, num);
766         exit(1);
767     }
768 #if defined(PPC_DEBUG_SPR)
769     printf("*** register spr %d (%03x) %s val " TARGET_FMT_lx "\n", num, num,
770            name, initial_value);
771 #endif
772     spr->name = name;
773     spr->uea_read = uea_read;
774     spr->uea_write = uea_write;
775 #if !defined(CONFIG_USER_ONLY)
776     spr->oea_read = oea_read;
777     spr->oea_write = oea_write;
778     spr->hea_read = hea_read;
779     spr->hea_write = hea_write;
780 #endif
781 #if defined(CONFIG_KVM)
782     spr->one_reg_id = one_reg_id,
783 #endif
784     env->spr[num] = spr->default_value = initial_value;
785 }
786
787 /* Generic PowerPC SPRs */
788 static void gen_spr_generic(CPUPPCState *env)
789 {
790     /* Integer processing */
791     spr_register(env, SPR_XER, "XER",
792                  &spr_read_xer, &spr_write_xer,
793                  &spr_read_xer, &spr_write_xer,
794                  0x00000000);
795     /* Branch contol */
796     spr_register(env, SPR_LR, "LR",
797                  &spr_read_lr, &spr_write_lr,
798                  &spr_read_lr, &spr_write_lr,
799                  0x00000000);
800     spr_register(env, SPR_CTR, "CTR",
801                  &spr_read_ctr, &spr_write_ctr,
802                  &spr_read_ctr, &spr_write_ctr,
803                  0x00000000);
804     /* Interrupt processing */
805     spr_register(env, SPR_SRR0, "SRR0",
806                  SPR_NOACCESS, SPR_NOACCESS,
807                  &spr_read_generic, &spr_write_generic,
808                  0x00000000);
809     spr_register(env, SPR_SRR1, "SRR1",
810                  SPR_NOACCESS, SPR_NOACCESS,
811                  &spr_read_generic, &spr_write_generic,
812                  0x00000000);
813     /* Processor control */
814     spr_register(env, SPR_SPRG0, "SPRG0",
815                  SPR_NOACCESS, SPR_NOACCESS,
816                  &spr_read_generic, &spr_write_generic,
817                  0x00000000);
818     spr_register(env, SPR_SPRG1, "SPRG1",
819                  SPR_NOACCESS, SPR_NOACCESS,
820                  &spr_read_generic, &spr_write_generic,
821                  0x00000000);
822     spr_register(env, SPR_SPRG2, "SPRG2",
823                  SPR_NOACCESS, SPR_NOACCESS,
824                  &spr_read_generic, &spr_write_generic,
825                  0x00000000);
826     spr_register(env, SPR_SPRG3, "SPRG3",
827                  SPR_NOACCESS, SPR_NOACCESS,
828                  &spr_read_generic, &spr_write_generic,
829                  0x00000000);
830 }
831
832 /* SPR common to all non-embedded PowerPC, including 601 */
833 static void gen_spr_ne_601(CPUPPCState *env)
834 {
835     /* Exception processing */
836     spr_register_kvm(env, SPR_DSISR, "DSISR",
837                      SPR_NOACCESS, SPR_NOACCESS,
838                      &spr_read_generic, &spr_write_generic,
839                      KVM_REG_PPC_DSISR, 0x00000000);
840     spr_register_kvm(env, SPR_DAR, "DAR",
841                      SPR_NOACCESS, SPR_NOACCESS,
842                      &spr_read_generic, &spr_write_generic,
843                      KVM_REG_PPC_DAR, 0x00000000);
844     /* Timer */
845     spr_register(env, SPR_DECR, "DECR",
846                  SPR_NOACCESS, SPR_NOACCESS,
847                  &spr_read_decr, &spr_write_decr,
848                  0x00000000);
849 }
850
851 /* Storage Description Register 1 */
852 static void gen_spr_sdr1(CPUPPCState *env)
853 {
854 #ifndef CONFIG_USER_ONLY
855     if (env->has_hv_mode) {
856         /*
857          * SDR1 is a hypervisor resource on CPUs which have a
858          * hypervisor mode
859          */
860         spr_register_hv(env, SPR_SDR1, "SDR1",
861                         SPR_NOACCESS, SPR_NOACCESS,
862                         SPR_NOACCESS, SPR_NOACCESS,
863                         &spr_read_generic, &spr_write_sdr1,
864                         0x00000000);
865     } else {
866         spr_register(env, SPR_SDR1, "SDR1",
867                      SPR_NOACCESS, SPR_NOACCESS,
868                      &spr_read_generic, &spr_write_sdr1,
869                      0x00000000);
870     }
871 #endif
872 }
873
874 /* BATs 0-3 */
875 static void gen_low_BATs(CPUPPCState *env)
876 {
877 #if !defined(CONFIG_USER_ONLY)
878     spr_register(env, SPR_IBAT0U, "IBAT0U",
879                  SPR_NOACCESS, SPR_NOACCESS,
880                  &spr_read_ibat, &spr_write_ibatu,
881                  0x00000000);
882     spr_register(env, SPR_IBAT0L, "IBAT0L",
883                  SPR_NOACCESS, SPR_NOACCESS,
884                  &spr_read_ibat, &spr_write_ibatl,
885                  0x00000000);
886     spr_register(env, SPR_IBAT1U, "IBAT1U",
887                  SPR_NOACCESS, SPR_NOACCESS,
888                  &spr_read_ibat, &spr_write_ibatu,
889                  0x00000000);
890     spr_register(env, SPR_IBAT1L, "IBAT1L",
891                  SPR_NOACCESS, SPR_NOACCESS,
892                  &spr_read_ibat, &spr_write_ibatl,
893                  0x00000000);
894     spr_register(env, SPR_IBAT2U, "IBAT2U",
895                  SPR_NOACCESS, SPR_NOACCESS,
896                  &spr_read_ibat, &spr_write_ibatu,
897                  0x00000000);
898     spr_register(env, SPR_IBAT2L, "IBAT2L",
899                  SPR_NOACCESS, SPR_NOACCESS,
900                  &spr_read_ibat, &spr_write_ibatl,
901                  0x00000000);
902     spr_register(env, SPR_IBAT3U, "IBAT3U",
903                  SPR_NOACCESS, SPR_NOACCESS,
904                  &spr_read_ibat, &spr_write_ibatu,
905                  0x00000000);
906     spr_register(env, SPR_IBAT3L, "IBAT3L",
907                  SPR_NOACCESS, SPR_NOACCESS,
908                  &spr_read_ibat, &spr_write_ibatl,
909                  0x00000000);
910     spr_register(env, SPR_DBAT0U, "DBAT0U",
911                  SPR_NOACCESS, SPR_NOACCESS,
912                  &spr_read_dbat, &spr_write_dbatu,
913                  0x00000000);
914     spr_register(env, SPR_DBAT0L, "DBAT0L",
915                  SPR_NOACCESS, SPR_NOACCESS,
916                  &spr_read_dbat, &spr_write_dbatl,
917                  0x00000000);
918     spr_register(env, SPR_DBAT1U, "DBAT1U",
919                  SPR_NOACCESS, SPR_NOACCESS,
920                  &spr_read_dbat, &spr_write_dbatu,
921                  0x00000000);
922     spr_register(env, SPR_DBAT1L, "DBAT1L",
923                  SPR_NOACCESS, SPR_NOACCESS,
924                  &spr_read_dbat, &spr_write_dbatl,
925                  0x00000000);
926     spr_register(env, SPR_DBAT2U, "DBAT2U",
927                  SPR_NOACCESS, SPR_NOACCESS,
928                  &spr_read_dbat, &spr_write_dbatu,
929                  0x00000000);
930     spr_register(env, SPR_DBAT2L, "DBAT2L",
931                  SPR_NOACCESS, SPR_NOACCESS,
932                  &spr_read_dbat, &spr_write_dbatl,
933                  0x00000000);
934     spr_register(env, SPR_DBAT3U, "DBAT3U",
935                  SPR_NOACCESS, SPR_NOACCESS,
936                  &spr_read_dbat, &spr_write_dbatu,
937                  0x00000000);
938     spr_register(env, SPR_DBAT3L, "DBAT3L",
939                  SPR_NOACCESS, SPR_NOACCESS,
940                  &spr_read_dbat, &spr_write_dbatl,
941                  0x00000000);
942     env->nb_BATs += 4;
943 #endif
944 }
945
946 /* BATs 4-7 */
947 static void gen_high_BATs(CPUPPCState *env)
948 {
949 #if !defined(CONFIG_USER_ONLY)
950     spr_register(env, SPR_IBAT4U, "IBAT4U",
951                  SPR_NOACCESS, SPR_NOACCESS,
952                  &spr_read_ibat_h, &spr_write_ibatu_h,
953                  0x00000000);
954     spr_register(env, SPR_IBAT4L, "IBAT4L",
955                  SPR_NOACCESS, SPR_NOACCESS,
956                  &spr_read_ibat_h, &spr_write_ibatl_h,
957                  0x00000000);
958     spr_register(env, SPR_IBAT5U, "IBAT5U",
959                  SPR_NOACCESS, SPR_NOACCESS,
960                  &spr_read_ibat_h, &spr_write_ibatu_h,
961                  0x00000000);
962     spr_register(env, SPR_IBAT5L, "IBAT5L",
963                  SPR_NOACCESS, SPR_NOACCESS,
964                  &spr_read_ibat_h, &spr_write_ibatl_h,
965                  0x00000000);
966     spr_register(env, SPR_IBAT6U, "IBAT6U",
967                  SPR_NOACCESS, SPR_NOACCESS,
968                  &spr_read_ibat_h, &spr_write_ibatu_h,
969                  0x00000000);
970     spr_register(env, SPR_IBAT6L, "IBAT6L",
971                  SPR_NOACCESS, SPR_NOACCESS,
972                  &spr_read_ibat_h, &spr_write_ibatl_h,
973                  0x00000000);
974     spr_register(env, SPR_IBAT7U, "IBAT7U",
975                  SPR_NOACCESS, SPR_NOACCESS,
976                  &spr_read_ibat_h, &spr_write_ibatu_h,
977                  0x00000000);
978     spr_register(env, SPR_IBAT7L, "IBAT7L",
979                  SPR_NOACCESS, SPR_NOACCESS,
980                  &spr_read_ibat_h, &spr_write_ibatl_h,
981                  0x00000000);
982     spr_register(env, SPR_DBAT4U, "DBAT4U",
983                  SPR_NOACCESS, SPR_NOACCESS,
984                  &spr_read_dbat_h, &spr_write_dbatu_h,
985                  0x00000000);
986     spr_register(env, SPR_DBAT4L, "DBAT4L",
987                  SPR_NOACCESS, SPR_NOACCESS,
988                  &spr_read_dbat_h, &spr_write_dbatl_h,
989                  0x00000000);
990     spr_register(env, SPR_DBAT5U, "DBAT5U",
991                  SPR_NOACCESS, SPR_NOACCESS,
992                  &spr_read_dbat_h, &spr_write_dbatu_h,
993                  0x00000000);
994     spr_register(env, SPR_DBAT5L, "DBAT5L",
995                  SPR_NOACCESS, SPR_NOACCESS,
996                  &spr_read_dbat_h, &spr_write_dbatl_h,
997                  0x00000000);
998     spr_register(env, SPR_DBAT6U, "DBAT6U",
999                  SPR_NOACCESS, SPR_NOACCESS,
1000                  &spr_read_dbat_h, &spr_write_dbatu_h,
1001                  0x00000000);
1002     spr_register(env, SPR_DBAT6L, "DBAT6L",
1003                  SPR_NOACCESS, SPR_NOACCESS,
1004                  &spr_read_dbat_h, &spr_write_dbatl_h,
1005                  0x00000000);
1006     spr_register(env, SPR_DBAT7U, "DBAT7U",
1007                  SPR_NOACCESS, SPR_NOACCESS,
1008                  &spr_read_dbat_h, &spr_write_dbatu_h,
1009                  0x00000000);
1010     spr_register(env, SPR_DBAT7L, "DBAT7L",
1011                  SPR_NOACCESS, SPR_NOACCESS,
1012                  &spr_read_dbat_h, &spr_write_dbatl_h,
1013                  0x00000000);
1014     env->nb_BATs += 4;
1015 #endif
1016 }
1017
1018 /* Generic PowerPC time base */
1019 static void gen_tbl(CPUPPCState *env)
1020 {
1021     spr_register(env, SPR_VTBL,  "TBL",
1022                  &spr_read_tbl, SPR_NOACCESS,
1023                  &spr_read_tbl, SPR_NOACCESS,
1024                  0x00000000);
1025     spr_register(env, SPR_TBL,   "TBL",
1026                  &spr_read_tbl, SPR_NOACCESS,
1027                  &spr_read_tbl, &spr_write_tbl,
1028                  0x00000000);
1029     spr_register(env, SPR_VTBU,  "TBU",
1030                  &spr_read_tbu, SPR_NOACCESS,
1031                  &spr_read_tbu, SPR_NOACCESS,
1032                  0x00000000);
1033     spr_register(env, SPR_TBU,   "TBU",
1034                  &spr_read_tbu, SPR_NOACCESS,
1035                  &spr_read_tbu, &spr_write_tbu,
1036                  0x00000000);
1037 }
1038
1039 /* Softare table search registers */
1040 static void gen_6xx_7xx_soft_tlb(CPUPPCState *env, int nb_tlbs, int nb_ways)
1041 {
1042 #if !defined(CONFIG_USER_ONLY)
1043     env->nb_tlb = nb_tlbs;
1044     env->nb_ways = nb_ways;
1045     env->id_tlbs = 1;
1046     env->tlb_type = TLB_6XX;
1047     spr_register(env, SPR_DMISS, "DMISS",
1048                  SPR_NOACCESS, SPR_NOACCESS,
1049                  &spr_read_generic, SPR_NOACCESS,
1050                  0x00000000);
1051     spr_register(env, SPR_DCMP, "DCMP",
1052                  SPR_NOACCESS, SPR_NOACCESS,
1053                  &spr_read_generic, SPR_NOACCESS,
1054                  0x00000000);
1055     spr_register(env, SPR_HASH1, "HASH1",
1056                  SPR_NOACCESS, SPR_NOACCESS,
1057                  &spr_read_generic, SPR_NOACCESS,
1058                  0x00000000);
1059     spr_register(env, SPR_HASH2, "HASH2",
1060                  SPR_NOACCESS, SPR_NOACCESS,
1061                  &spr_read_generic, SPR_NOACCESS,
1062                  0x00000000);
1063     spr_register(env, SPR_IMISS, "IMISS",
1064                  SPR_NOACCESS, SPR_NOACCESS,
1065                  &spr_read_generic, SPR_NOACCESS,
1066                  0x00000000);
1067     spr_register(env, SPR_ICMP, "ICMP",
1068                  SPR_NOACCESS, SPR_NOACCESS,
1069                  &spr_read_generic, SPR_NOACCESS,
1070                  0x00000000);
1071     spr_register(env, SPR_RPA, "RPA",
1072                  SPR_NOACCESS, SPR_NOACCESS,
1073                  &spr_read_generic, &spr_write_generic,
1074                  0x00000000);
1075 #endif
1076 }
1077
1078 /* SPR common to MPC755 and G2 */
1079 static void gen_spr_G2_755(CPUPPCState *env)
1080 {
1081     /* SGPRs */
1082     spr_register(env, SPR_SPRG4, "SPRG4",
1083                  SPR_NOACCESS, SPR_NOACCESS,
1084                  &spr_read_generic, &spr_write_generic,
1085                  0x00000000);
1086     spr_register(env, SPR_SPRG5, "SPRG5",
1087                  SPR_NOACCESS, SPR_NOACCESS,
1088                  &spr_read_generic, &spr_write_generic,
1089                  0x00000000);
1090     spr_register(env, SPR_SPRG6, "SPRG6",
1091                  SPR_NOACCESS, SPR_NOACCESS,
1092                  &spr_read_generic, &spr_write_generic,
1093                  0x00000000);
1094     spr_register(env, SPR_SPRG7, "SPRG7",
1095                  SPR_NOACCESS, SPR_NOACCESS,
1096                  &spr_read_generic, &spr_write_generic,
1097                  0x00000000);
1098 }
1099
1100 /* SPR common to all 7xx PowerPC implementations */
1101 static void gen_spr_7xx(CPUPPCState *env)
1102 {
1103     /* Breakpoints */
1104     /* XXX : not implemented */
1105     spr_register_kvm(env, SPR_DABR, "DABR",
1106                      SPR_NOACCESS, SPR_NOACCESS,
1107                      &spr_read_generic, &spr_write_generic,
1108                      KVM_REG_PPC_DABR, 0x00000000);
1109     /* XXX : not implemented */
1110     spr_register(env, SPR_IABR, "IABR",
1111                  SPR_NOACCESS, SPR_NOACCESS,
1112                  &spr_read_generic, &spr_write_generic,
1113                  0x00000000);
1114     /* Cache management */
1115     /* XXX : not implemented */
1116     spr_register(env, SPR_ICTC, "ICTC",
1117                  SPR_NOACCESS, SPR_NOACCESS,
1118                  &spr_read_generic, &spr_write_generic,
1119                  0x00000000);
1120     /* Performance monitors */
1121     /* XXX : not implemented */
1122     spr_register(env, SPR_7XX_MMCR0, "MMCR0",
1123                  SPR_NOACCESS, SPR_NOACCESS,
1124                  &spr_read_generic, &spr_write_generic,
1125                  0x00000000);
1126     /* XXX : not implemented */
1127     spr_register(env, SPR_7XX_MMCR1, "MMCR1",
1128                  SPR_NOACCESS, SPR_NOACCESS,
1129                  &spr_read_generic, &spr_write_generic,
1130                  0x00000000);
1131     /* XXX : not implemented */
1132     spr_register(env, SPR_7XX_PMC1, "PMC1",
1133                  SPR_NOACCESS, SPR_NOACCESS,
1134                  &spr_read_generic, &spr_write_generic,
1135                  0x00000000);
1136     /* XXX : not implemented */
1137     spr_register(env, SPR_7XX_PMC2, "PMC2",
1138                  SPR_NOACCESS, SPR_NOACCESS,
1139                  &spr_read_generic, &spr_write_generic,
1140                  0x00000000);
1141     /* XXX : not implemented */
1142     spr_register(env, SPR_7XX_PMC3, "PMC3",
1143                  SPR_NOACCESS, SPR_NOACCESS,
1144                  &spr_read_generic, &spr_write_generic,
1145                  0x00000000);
1146     /* XXX : not implemented */
1147     spr_register(env, SPR_7XX_PMC4, "PMC4",
1148                  SPR_NOACCESS, SPR_NOACCESS,
1149                  &spr_read_generic, &spr_write_generic,
1150                  0x00000000);
1151     /* XXX : not implemented */
1152     spr_register(env, SPR_7XX_SIAR, "SIAR",
1153                  SPR_NOACCESS, SPR_NOACCESS,
1154                  &spr_read_generic, SPR_NOACCESS,
1155                  0x00000000);
1156     /* XXX : not implemented */
1157     spr_register(env, SPR_7XX_UMMCR0, "UMMCR0",
1158                  &spr_read_ureg, SPR_NOACCESS,
1159                  &spr_read_ureg, SPR_NOACCESS,
1160                  0x00000000);
1161     /* XXX : not implemented */
1162     spr_register(env, SPR_7XX_UMMCR1, "UMMCR1",
1163                  &spr_read_ureg, SPR_NOACCESS,
1164                  &spr_read_ureg, SPR_NOACCESS,
1165                  0x00000000);
1166     /* XXX : not implemented */
1167     spr_register(env, SPR_7XX_UPMC1, "UPMC1",
1168                  &spr_read_ureg, SPR_NOACCESS,
1169                  &spr_read_ureg, SPR_NOACCESS,
1170                  0x00000000);
1171     /* XXX : not implemented */
1172     spr_register(env, SPR_7XX_UPMC2, "UPMC2",
1173                  &spr_read_ureg, SPR_NOACCESS,
1174                  &spr_read_ureg, SPR_NOACCESS,
1175                  0x00000000);
1176     /* XXX : not implemented */
1177     spr_register(env, SPR_7XX_UPMC3, "UPMC3",
1178                  &spr_read_ureg, SPR_NOACCESS,
1179                  &spr_read_ureg, SPR_NOACCESS,
1180                  0x00000000);
1181     /* XXX : not implemented */
1182     spr_register(env, SPR_7XX_UPMC4, "UPMC4",
1183                  &spr_read_ureg, SPR_NOACCESS,
1184                  &spr_read_ureg, SPR_NOACCESS,
1185                  0x00000000);
1186     /* XXX : not implemented */
1187     spr_register(env, SPR_7XX_USIAR, "USIAR",
1188                  &spr_read_ureg, SPR_NOACCESS,
1189                  &spr_read_ureg, SPR_NOACCESS,
1190                  0x00000000);
1191     /* External access control */
1192     /* XXX : not implemented */
1193     spr_register(env, SPR_EAR, "EAR",
1194                  SPR_NOACCESS, SPR_NOACCESS,
1195                  &spr_read_generic, &spr_write_generic,
1196                  0x00000000);
1197 }
1198
1199 #ifdef TARGET_PPC64
1200 #ifndef CONFIG_USER_ONLY
1201 static void spr_write_amr(DisasContext *ctx, int sprn, int gprn)
1202 {
1203     TCGv t0 = tcg_temp_new();
1204     TCGv t1 = tcg_temp_new();
1205     TCGv t2 = tcg_temp_new();
1206
1207     /*
1208      * Note, the HV=1 PR=0 case is handled earlier by simply using
1209      * spr_write_generic for HV mode in the SPR table
1210      */
1211
1212     /* Build insertion mask into t1 based on context */
1213     if (ctx->pr) {
1214         gen_load_spr(t1, SPR_UAMOR);
1215     } else {
1216         gen_load_spr(t1, SPR_AMOR);
1217     }
1218
1219     /* Mask new bits into t2 */
1220     tcg_gen_and_tl(t2, t1, cpu_gpr[gprn]);
1221
1222     /* Load AMR and clear new bits in t0 */
1223     gen_load_spr(t0, SPR_AMR);
1224     tcg_gen_andc_tl(t0, t0, t1);
1225
1226     /* Or'in new bits and write it out */
1227     tcg_gen_or_tl(t0, t0, t2);
1228     gen_store_spr(SPR_AMR, t0);
1229     spr_store_dump_spr(SPR_AMR);
1230
1231     tcg_temp_free(t0);
1232     tcg_temp_free(t1);
1233     tcg_temp_free(t2);
1234 }
1235
1236 static void spr_write_uamor(DisasContext *ctx, int sprn, int gprn)
1237 {
1238     TCGv t0 = tcg_temp_new();
1239     TCGv t1 = tcg_temp_new();
1240     TCGv t2 = tcg_temp_new();
1241
1242     /*
1243      * Note, the HV=1 case is handled earlier by simply using
1244      * spr_write_generic for HV mode in the SPR table
1245      */
1246
1247     /* Build insertion mask into t1 based on context */
1248     gen_load_spr(t1, SPR_AMOR);
1249
1250     /* Mask new bits into t2 */
1251     tcg_gen_and_tl(t2, t1, cpu_gpr[gprn]);
1252
1253     /* Load AMR and clear new bits in t0 */
1254     gen_load_spr(t0, SPR_UAMOR);
1255     tcg_gen_andc_tl(t0, t0, t1);
1256
1257     /* Or'in new bits and write it out */
1258     tcg_gen_or_tl(t0, t0, t2);
1259     gen_store_spr(SPR_UAMOR, t0);
1260     spr_store_dump_spr(SPR_UAMOR);
1261
1262     tcg_temp_free(t0);
1263     tcg_temp_free(t1);
1264     tcg_temp_free(t2);
1265 }
1266
1267 static void spr_write_iamr(DisasContext *ctx, int sprn, int gprn)
1268 {
1269     TCGv t0 = tcg_temp_new();
1270     TCGv t1 = tcg_temp_new();
1271     TCGv t2 = tcg_temp_new();
1272
1273     /*
1274      * Note, the HV=1 case is handled earlier by simply using
1275      * spr_write_generic for HV mode in the SPR table
1276      */
1277
1278     /* Build insertion mask into t1 based on context */
1279     gen_load_spr(t1, SPR_AMOR);
1280
1281     /* Mask new bits into t2 */
1282     tcg_gen_and_tl(t2, t1, cpu_gpr[gprn]);
1283
1284     /* Load AMR and clear new bits in t0 */
1285     gen_load_spr(t0, SPR_IAMR);
1286     tcg_gen_andc_tl(t0, t0, t1);
1287
1288     /* Or'in new bits and write it out */
1289     tcg_gen_or_tl(t0, t0, t2);
1290     gen_store_spr(SPR_IAMR, t0);
1291     spr_store_dump_spr(SPR_IAMR);
1292
1293     tcg_temp_free(t0);
1294     tcg_temp_free(t1);
1295     tcg_temp_free(t2);
1296 }
1297 #endif /* CONFIG_USER_ONLY */
1298
1299 static void gen_spr_amr(CPUPPCState *env)
1300 {
1301 #ifndef CONFIG_USER_ONLY
1302     /*
1303      * Virtual Page Class Key protection
1304      *
1305      * The AMR is accessible either via SPR 13 or SPR 29.  13 is
1306      * userspace accessible, 29 is privileged.  So we only need to set
1307      * the kvm ONE_REG id on one of them, we use 29
1308      */
1309     spr_register(env, SPR_UAMR, "UAMR",
1310                  &spr_read_generic, &spr_write_amr,
1311                  &spr_read_generic, &spr_write_amr,
1312                  0);
1313     spr_register_kvm_hv(env, SPR_AMR, "AMR",
1314                      SPR_NOACCESS, SPR_NOACCESS,
1315                      &spr_read_generic, &spr_write_amr,
1316                      &spr_read_generic, &spr_write_generic,
1317                      KVM_REG_PPC_AMR, 0);
1318     spr_register_kvm_hv(env, SPR_UAMOR, "UAMOR",
1319                      SPR_NOACCESS, SPR_NOACCESS,
1320                      &spr_read_generic, &spr_write_uamor,
1321                      &spr_read_generic, &spr_write_generic,
1322                      KVM_REG_PPC_UAMOR, 0);
1323     spr_register_hv(env, SPR_AMOR, "AMOR",
1324                     SPR_NOACCESS, SPR_NOACCESS,
1325                     SPR_NOACCESS, SPR_NOACCESS,
1326                     &spr_read_generic, &spr_write_generic,
1327                     0);
1328 #endif /* !CONFIG_USER_ONLY */
1329 }
1330
1331 static void gen_spr_iamr(CPUPPCState *env)
1332 {
1333 #ifndef CONFIG_USER_ONLY
1334     spr_register_kvm_hv(env, SPR_IAMR, "IAMR",
1335                         SPR_NOACCESS, SPR_NOACCESS,
1336                         &spr_read_generic, &spr_write_iamr,
1337                         &spr_read_generic, &spr_write_generic,
1338                         KVM_REG_PPC_IAMR, 0);
1339 #endif /* !CONFIG_USER_ONLY */
1340 }
1341 #endif /* TARGET_PPC64 */
1342
1343 #ifndef CONFIG_USER_ONLY
1344 static void spr_read_thrm(DisasContext *ctx, int gprn, int sprn)
1345 {
1346     gen_helper_fixup_thrm(cpu_env);
1347     gen_load_spr(cpu_gpr[gprn], sprn);
1348     spr_load_dump_spr(sprn);
1349 }
1350 #endif /* !CONFIG_USER_ONLY */
1351
1352 static void gen_spr_thrm(CPUPPCState *env)
1353 {
1354     /* Thermal management */
1355     /* XXX : not implemented */
1356     spr_register(env, SPR_THRM1, "THRM1",
1357                  SPR_NOACCESS, SPR_NOACCESS,
1358                  &spr_read_thrm, &spr_write_generic,
1359                  0x00000000);
1360     /* XXX : not implemented */
1361     spr_register(env, SPR_THRM2, "THRM2",
1362                  SPR_NOACCESS, SPR_NOACCESS,
1363                  &spr_read_thrm, &spr_write_generic,
1364                  0x00000000);
1365     /* XXX : not implemented */
1366     spr_register(env, SPR_THRM3, "THRM3",
1367                  SPR_NOACCESS, SPR_NOACCESS,
1368                  &spr_read_thrm, &spr_write_generic,
1369                  0x00000000);
1370 }
1371
1372 /* SPR specific to PowerPC 604 implementation */
1373 static void gen_spr_604(CPUPPCState *env)
1374 {
1375     /* Processor identification */
1376     spr_register(env, SPR_PIR, "PIR",
1377                  SPR_NOACCESS, SPR_NOACCESS,
1378                  &spr_read_generic, &spr_write_pir,
1379                  0x00000000);
1380     /* Breakpoints */
1381     /* XXX : not implemented */
1382     spr_register(env, SPR_IABR, "IABR",
1383                  SPR_NOACCESS, SPR_NOACCESS,
1384                  &spr_read_generic, &spr_write_generic,
1385                  0x00000000);
1386     /* XXX : not implemented */
1387     spr_register_kvm(env, SPR_DABR, "DABR",
1388                      SPR_NOACCESS, SPR_NOACCESS,
1389                      &spr_read_generic, &spr_write_generic,
1390                      KVM_REG_PPC_DABR, 0x00000000);
1391     /* Performance counters */
1392     /* XXX : not implemented */
1393     spr_register(env, SPR_7XX_MMCR0, "MMCR0",
1394                  SPR_NOACCESS, SPR_NOACCESS,
1395                  &spr_read_generic, &spr_write_generic,
1396                  0x00000000);
1397     /* XXX : not implemented */
1398     spr_register(env, SPR_7XX_PMC1, "PMC1",
1399                  SPR_NOACCESS, SPR_NOACCESS,
1400                  &spr_read_generic, &spr_write_generic,
1401                  0x00000000);
1402     /* XXX : not implemented */
1403     spr_register(env, SPR_7XX_PMC2, "PMC2",
1404                  SPR_NOACCESS, SPR_NOACCESS,
1405                  &spr_read_generic, &spr_write_generic,
1406                  0x00000000);
1407     /* XXX : not implemented */
1408     spr_register(env, SPR_7XX_SIAR, "SIAR",
1409                  SPR_NOACCESS, SPR_NOACCESS,
1410                  &spr_read_generic, SPR_NOACCESS,
1411                  0x00000000);
1412     /* XXX : not implemented */
1413     spr_register(env, SPR_SDA, "SDA",
1414                  SPR_NOACCESS, SPR_NOACCESS,
1415                  &spr_read_generic, SPR_NOACCESS,
1416                  0x00000000);
1417     /* External access control */
1418     /* XXX : not implemented */
1419     spr_register(env, SPR_EAR, "EAR",
1420                  SPR_NOACCESS, SPR_NOACCESS,
1421                  &spr_read_generic, &spr_write_generic,
1422                  0x00000000);
1423 }
1424
1425 /* SPR specific to PowerPC 603 implementation */
1426 static void gen_spr_603(CPUPPCState *env)
1427 {
1428     /* External access control */
1429     /* XXX : not implemented */
1430     spr_register(env, SPR_EAR, "EAR",
1431                  SPR_NOACCESS, SPR_NOACCESS,
1432                  &spr_read_generic, &spr_write_generic,
1433                  0x00000000);
1434     /* Breakpoints */
1435     /* XXX : not implemented */
1436     spr_register(env, SPR_IABR, "IABR",
1437                  SPR_NOACCESS, SPR_NOACCESS,
1438                  &spr_read_generic, &spr_write_generic,
1439                  0x00000000);
1440
1441 }
1442
1443 /* SPR specific to PowerPC G2 implementation */
1444 static void gen_spr_G2(CPUPPCState *env)
1445 {
1446     /* Memory base address */
1447     /* MBAR */
1448     /* XXX : not implemented */
1449     spr_register(env, SPR_MBAR, "MBAR",
1450                  SPR_NOACCESS, SPR_NOACCESS,
1451                  &spr_read_generic, &spr_write_generic,
1452                  0x00000000);
1453     /* Exception processing */
1454     spr_register(env, SPR_BOOKE_CSRR0, "CSRR0",
1455                  SPR_NOACCESS, SPR_NOACCESS,
1456                  &spr_read_generic, &spr_write_generic,
1457                  0x00000000);
1458     spr_register(env, SPR_BOOKE_CSRR1, "CSRR1",
1459                  SPR_NOACCESS, SPR_NOACCESS,
1460                  &spr_read_generic, &spr_write_generic,
1461                  0x00000000);
1462     /* Breakpoints */
1463     /* XXX : not implemented */
1464     spr_register(env, SPR_DABR, "DABR",
1465                  SPR_NOACCESS, SPR_NOACCESS,
1466                  &spr_read_generic, &spr_write_generic,
1467                  0x00000000);
1468     /* XXX : not implemented */
1469     spr_register(env, SPR_DABR2, "DABR2",
1470                  SPR_NOACCESS, SPR_NOACCESS,
1471                  &spr_read_generic, &spr_write_generic,
1472                  0x00000000);
1473     /* XXX : not implemented */
1474     spr_register(env, SPR_IABR, "IABR",
1475                  SPR_NOACCESS, SPR_NOACCESS,
1476                  &spr_read_generic, &spr_write_generic,
1477                  0x00000000);
1478     /* XXX : not implemented */
1479     spr_register(env, SPR_IABR2, "IABR2",
1480                  SPR_NOACCESS, SPR_NOACCESS,
1481                  &spr_read_generic, &spr_write_generic,
1482                  0x00000000);
1483     /* XXX : not implemented */
1484     spr_register(env, SPR_IBCR, "IBCR",
1485                  SPR_NOACCESS, SPR_NOACCESS,
1486                  &spr_read_generic, &spr_write_generic,
1487                  0x00000000);
1488     /* XXX : not implemented */
1489     spr_register(env, SPR_DBCR, "DBCR",
1490                  SPR_NOACCESS, SPR_NOACCESS,
1491                  &spr_read_generic, &spr_write_generic,
1492                  0x00000000);
1493 }
1494
1495 /* SPR specific to PowerPC 602 implementation */
1496 static void gen_spr_602(CPUPPCState *env)
1497 {
1498     /* ESA registers */
1499     /* XXX : not implemented */
1500     spr_register(env, SPR_SER, "SER",
1501                  SPR_NOACCESS, SPR_NOACCESS,
1502                  &spr_read_generic, &spr_write_generic,
1503                  0x00000000);
1504     /* XXX : not implemented */
1505     spr_register(env, SPR_SEBR, "SEBR",
1506                  SPR_NOACCESS, SPR_NOACCESS,
1507                  &spr_read_generic, &spr_write_generic,
1508                  0x00000000);
1509     /* XXX : not implemented */
1510     spr_register(env, SPR_ESASRR, "ESASRR",
1511                  SPR_NOACCESS, SPR_NOACCESS,
1512                  &spr_read_generic, &spr_write_generic,
1513                  0x00000000);
1514     /* Floating point status */
1515     /* XXX : not implemented */
1516     spr_register(env, SPR_SP, "SP",
1517                  SPR_NOACCESS, SPR_NOACCESS,
1518                  &spr_read_generic, &spr_write_generic,
1519                  0x00000000);
1520     /* XXX : not implemented */
1521     spr_register(env, SPR_LT, "LT",
1522                  SPR_NOACCESS, SPR_NOACCESS,
1523                  &spr_read_generic, &spr_write_generic,
1524                  0x00000000);
1525     /* Watchdog timer */
1526     /* XXX : not implemented */
1527     spr_register(env, SPR_TCR, "TCR",
1528                  SPR_NOACCESS, SPR_NOACCESS,
1529                  &spr_read_generic, &spr_write_generic,
1530                  0x00000000);
1531     /* Interrupt base */
1532     spr_register(env, SPR_IBR, "IBR",
1533                  SPR_NOACCESS, SPR_NOACCESS,
1534                  &spr_read_generic, &spr_write_generic,
1535                  0x00000000);
1536     /* XXX : not implemented */
1537     spr_register(env, SPR_IABR, "IABR",
1538                  SPR_NOACCESS, SPR_NOACCESS,
1539                  &spr_read_generic, &spr_write_generic,
1540                  0x00000000);
1541 }
1542
1543 /* SPR specific to PowerPC 601 implementation */
1544 static void gen_spr_601(CPUPPCState *env)
1545 {
1546     /* Multiplication/division register */
1547     /* MQ */
1548     spr_register(env, SPR_MQ, "MQ",
1549                  &spr_read_generic, &spr_write_generic,
1550                  &spr_read_generic, &spr_write_generic,
1551                  0x00000000);
1552     /* RTC registers */
1553     spr_register(env, SPR_601_RTCU, "RTCU",
1554                  SPR_NOACCESS, SPR_NOACCESS,
1555                  SPR_NOACCESS, &spr_write_601_rtcu,
1556                  0x00000000);
1557     spr_register(env, SPR_601_VRTCU, "RTCU",
1558                  &spr_read_601_rtcu, SPR_NOACCESS,
1559                  &spr_read_601_rtcu, SPR_NOACCESS,
1560                  0x00000000);
1561     spr_register(env, SPR_601_RTCL, "RTCL",
1562                  SPR_NOACCESS, SPR_NOACCESS,
1563                  SPR_NOACCESS, &spr_write_601_rtcl,
1564                  0x00000000);
1565     spr_register(env, SPR_601_VRTCL, "RTCL",
1566                  &spr_read_601_rtcl, SPR_NOACCESS,
1567                  &spr_read_601_rtcl, SPR_NOACCESS,
1568                  0x00000000);
1569     /* Timer */
1570 #if 0 /* ? */
1571     spr_register(env, SPR_601_UDECR, "UDECR",
1572                  &spr_read_decr, SPR_NOACCESS,
1573                  &spr_read_decr, SPR_NOACCESS,
1574                  0x00000000);
1575 #endif
1576     /* External access control */
1577     /* XXX : not implemented */
1578     spr_register(env, SPR_EAR, "EAR",
1579                  SPR_NOACCESS, SPR_NOACCESS,
1580                  &spr_read_generic, &spr_write_generic,
1581                  0x00000000);
1582     /* Memory management */
1583 #if !defined(CONFIG_USER_ONLY)
1584     spr_register(env, SPR_IBAT0U, "IBAT0U",
1585                  SPR_NOACCESS, SPR_NOACCESS,
1586                  &spr_read_601_ubat, &spr_write_601_ubatu,
1587                  0x00000000);
1588     spr_register(env, SPR_IBAT0L, "IBAT0L",
1589                  SPR_NOACCESS, SPR_NOACCESS,
1590                  &spr_read_601_ubat, &spr_write_601_ubatl,
1591                  0x00000000);
1592     spr_register(env, SPR_IBAT1U, "IBAT1U",
1593                  SPR_NOACCESS, SPR_NOACCESS,
1594                  &spr_read_601_ubat, &spr_write_601_ubatu,
1595                  0x00000000);
1596     spr_register(env, SPR_IBAT1L, "IBAT1L",
1597                  SPR_NOACCESS, SPR_NOACCESS,
1598                  &spr_read_601_ubat, &spr_write_601_ubatl,
1599                  0x00000000);
1600     spr_register(env, SPR_IBAT2U, "IBAT2U",
1601                  SPR_NOACCESS, SPR_NOACCESS,
1602                  &spr_read_601_ubat, &spr_write_601_ubatu,
1603                  0x00000000);
1604     spr_register(env, SPR_IBAT2L, "IBAT2L",
1605                  SPR_NOACCESS, SPR_NOACCESS,
1606                  &spr_read_601_ubat, &spr_write_601_ubatl,
1607                  0x00000000);
1608     spr_register(env, SPR_IBAT3U, "IBAT3U",
1609                  SPR_NOACCESS, SPR_NOACCESS,
1610                  &spr_read_601_ubat, &spr_write_601_ubatu,
1611                  0x00000000);
1612     spr_register(env, SPR_IBAT3L, "IBAT3L",
1613                  SPR_NOACCESS, SPR_NOACCESS,
1614                  &spr_read_601_ubat, &spr_write_601_ubatl,
1615                  0x00000000);
1616     env->nb_BATs = 4;
1617 #endif
1618 }
1619
1620 static void gen_spr_74xx(CPUPPCState *env)
1621 {
1622     /* Processor identification */
1623     spr_register(env, SPR_PIR, "PIR",
1624                  SPR_NOACCESS, SPR_NOACCESS,
1625                  &spr_read_generic, &spr_write_pir,
1626                  0x00000000);
1627     /* XXX : not implemented */
1628     spr_register(env, SPR_74XX_MMCR2, "MMCR2",
1629                  SPR_NOACCESS, SPR_NOACCESS,
1630                  &spr_read_generic, &spr_write_generic,
1631                  0x00000000);
1632     /* XXX : not implemented */
1633     spr_register(env, SPR_74XX_UMMCR2, "UMMCR2",
1634                  &spr_read_ureg, SPR_NOACCESS,
1635                  &spr_read_ureg, SPR_NOACCESS,
1636                  0x00000000);
1637     /* XXX: not implemented */
1638     spr_register(env, SPR_BAMR, "BAMR",
1639                  SPR_NOACCESS, SPR_NOACCESS,
1640                  &spr_read_generic, &spr_write_generic,
1641                  0x00000000);
1642     /* XXX : not implemented */
1643     spr_register(env, SPR_MSSCR0, "MSSCR0",
1644                  SPR_NOACCESS, SPR_NOACCESS,
1645                  &spr_read_generic, &spr_write_generic,
1646                  0x00000000);
1647     /* Hardware implementation registers */
1648     /* XXX : not implemented */
1649     spr_register(env, SPR_HID0, "HID0",
1650                  SPR_NOACCESS, SPR_NOACCESS,
1651                  &spr_read_generic, &spr_write_generic,
1652                  0x00000000);
1653     /* XXX : not implemented */
1654     spr_register(env, SPR_HID1, "HID1",
1655                  SPR_NOACCESS, SPR_NOACCESS,
1656                  &spr_read_generic, &spr_write_generic,
1657                  0x00000000);
1658     /* Altivec */
1659     spr_register(env, SPR_VRSAVE, "VRSAVE",
1660                  &spr_read_generic, &spr_write_generic,
1661                  &spr_read_generic, &spr_write_generic,
1662                  0x00000000);
1663     /* XXX : not implemented */
1664     spr_register(env, SPR_L2CR, "L2CR",
1665                  SPR_NOACCESS, SPR_NOACCESS,
1666                  &spr_read_generic, spr_access_nop,
1667                  0x00000000);
1668     /* Not strictly an SPR */
1669     vscr_init(env, 0x00010000);
1670 }
1671
1672 static void gen_l3_ctrl(CPUPPCState *env)
1673 {
1674     /* L3CR */
1675     /* XXX : not implemented */
1676     spr_register(env, SPR_L3CR, "L3CR",
1677                  SPR_NOACCESS, SPR_NOACCESS,
1678                  &spr_read_generic, &spr_write_generic,
1679                  0x00000000);
1680     /* L3ITCR0 */
1681     /* XXX : not implemented */
1682     spr_register(env, SPR_L3ITCR0, "L3ITCR0",
1683                  SPR_NOACCESS, SPR_NOACCESS,
1684                  &spr_read_generic, &spr_write_generic,
1685                  0x00000000);
1686     /* L3PM */
1687     /* XXX : not implemented */
1688     spr_register(env, SPR_L3PM, "L3PM",
1689                  SPR_NOACCESS, SPR_NOACCESS,
1690                  &spr_read_generic, &spr_write_generic,
1691                  0x00000000);
1692 }
1693
1694 static void gen_74xx_soft_tlb(CPUPPCState *env, int nb_tlbs, int nb_ways)
1695 {
1696 #if !defined(CONFIG_USER_ONLY)
1697     env->nb_tlb = nb_tlbs;
1698     env->nb_ways = nb_ways;
1699     env->id_tlbs = 1;
1700     env->tlb_type = TLB_6XX;
1701     /* XXX : not implemented */
1702     spr_register(env, SPR_PTEHI, "PTEHI",
1703                  SPR_NOACCESS, SPR_NOACCESS,
1704                  &spr_read_generic, &spr_write_generic,
1705                  0x00000000);
1706     /* XXX : not implemented */
1707     spr_register(env, SPR_PTELO, "PTELO",
1708                  SPR_NOACCESS, SPR_NOACCESS,
1709                  &spr_read_generic, &spr_write_generic,
1710                  0x00000000);
1711     /* XXX : not implemented */
1712     spr_register(env, SPR_TLBMISS, "TLBMISS",
1713                  SPR_NOACCESS, SPR_NOACCESS,
1714                  &spr_read_generic, &spr_write_generic,
1715                  0x00000000);
1716 #endif
1717 }
1718
1719 #if !defined(CONFIG_USER_ONLY)
1720 static void spr_write_e500_l1csr0(DisasContext *ctx, int sprn, int gprn)
1721 {
1722     TCGv t0 = tcg_temp_new();
1723
1724     tcg_gen_andi_tl(t0, cpu_gpr[gprn], L1CSR0_DCE | L1CSR0_CPE);
1725     gen_store_spr(sprn, t0);
1726     tcg_temp_free(t0);
1727 }
1728
1729 static void spr_write_e500_l1csr1(DisasContext *ctx, int sprn, int gprn)
1730 {
1731     TCGv t0 = tcg_temp_new();
1732
1733     tcg_gen_andi_tl(t0, cpu_gpr[gprn], L1CSR1_ICE | L1CSR1_CPE);
1734     gen_store_spr(sprn, t0);
1735     tcg_temp_free(t0);
1736 }
1737
1738 static void spr_write_booke206_mmucsr0(DisasContext *ctx, int sprn, int gprn)
1739 {
1740     gen_helper_booke206_tlbflush(cpu_env, cpu_gpr[gprn]);
1741 }
1742
1743 static void spr_write_booke_pid(DisasContext *ctx, int sprn, int gprn)
1744 {
1745     TCGv_i32 t0 = tcg_const_i32(sprn);
1746     gen_helper_booke_setpid(cpu_env, t0, cpu_gpr[gprn]);
1747     tcg_temp_free_i32(t0);
1748 }
1749 static void spr_write_eplc(DisasContext *ctx, int sprn, int gprn)
1750 {
1751     gen_helper_booke_set_eplc(cpu_env, cpu_gpr[gprn]);
1752 }
1753 static void spr_write_epsc(DisasContext *ctx, int sprn, int gprn)
1754 {
1755     gen_helper_booke_set_epsc(cpu_env, cpu_gpr[gprn]);
1756 }
1757
1758 #endif
1759
1760 static void gen_spr_usprg3(CPUPPCState *env)
1761 {
1762     spr_register(env, SPR_USPRG3, "USPRG3",
1763                  &spr_read_ureg, SPR_NOACCESS,
1764                  &spr_read_ureg, SPR_NOACCESS,
1765                  0x00000000);
1766 }
1767
1768 static void gen_spr_usprgh(CPUPPCState *env)
1769 {
1770     spr_register(env, SPR_USPRG4, "USPRG4",
1771                  &spr_read_ureg, SPR_NOACCESS,
1772                  &spr_read_ureg, SPR_NOACCESS,
1773                  0x00000000);
1774     spr_register(env, SPR_USPRG5, "USPRG5",
1775                  &spr_read_ureg, SPR_NOACCESS,
1776                  &spr_read_ureg, SPR_NOACCESS,
1777                  0x00000000);
1778     spr_register(env, SPR_USPRG6, "USPRG6",
1779                  &spr_read_ureg, SPR_NOACCESS,
1780                  &spr_read_ureg, SPR_NOACCESS,
1781                  0x00000000);
1782     spr_register(env, SPR_USPRG7, "USPRG7",
1783                  &spr_read_ureg, SPR_NOACCESS,
1784                  &spr_read_ureg, SPR_NOACCESS,
1785                  0x00000000);
1786 }
1787
1788 /* PowerPC BookE SPR */
1789 static void gen_spr_BookE(CPUPPCState *env, uint64_t ivor_mask)
1790 {
1791     const char *ivor_names[64] = {
1792         "IVOR0",  "IVOR1",  "IVOR2",  "IVOR3",
1793         "IVOR4",  "IVOR5",  "IVOR6",  "IVOR7",
1794         "IVOR8",  "IVOR9",  "IVOR10", "IVOR11",
1795         "IVOR12", "IVOR13", "IVOR14", "IVOR15",
1796         "IVOR16", "IVOR17", "IVOR18", "IVOR19",
1797         "IVOR20", "IVOR21", "IVOR22", "IVOR23",
1798         "IVOR24", "IVOR25", "IVOR26", "IVOR27",
1799         "IVOR28", "IVOR29", "IVOR30", "IVOR31",
1800         "IVOR32", "IVOR33", "IVOR34", "IVOR35",
1801         "IVOR36", "IVOR37", "IVOR38", "IVOR39",
1802         "IVOR40", "IVOR41", "IVOR42", "IVOR43",
1803         "IVOR44", "IVOR45", "IVOR46", "IVOR47",
1804         "IVOR48", "IVOR49", "IVOR50", "IVOR51",
1805         "IVOR52", "IVOR53", "IVOR54", "IVOR55",
1806         "IVOR56", "IVOR57", "IVOR58", "IVOR59",
1807         "IVOR60", "IVOR61", "IVOR62", "IVOR63",
1808     };
1809 #define SPR_BOOKE_IVORxx (-1)
1810     int ivor_sprn[64] = {
1811         SPR_BOOKE_IVOR0,  SPR_BOOKE_IVOR1,  SPR_BOOKE_IVOR2,  SPR_BOOKE_IVOR3,
1812         SPR_BOOKE_IVOR4,  SPR_BOOKE_IVOR5,  SPR_BOOKE_IVOR6,  SPR_BOOKE_IVOR7,
1813         SPR_BOOKE_IVOR8,  SPR_BOOKE_IVOR9,  SPR_BOOKE_IVOR10, SPR_BOOKE_IVOR11,
1814         SPR_BOOKE_IVOR12, SPR_BOOKE_IVOR13, SPR_BOOKE_IVOR14, SPR_BOOKE_IVOR15,
1815         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1816         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1817         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1818         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1819         SPR_BOOKE_IVOR32, SPR_BOOKE_IVOR33, SPR_BOOKE_IVOR34, SPR_BOOKE_IVOR35,
1820         SPR_BOOKE_IVOR36, SPR_BOOKE_IVOR37, SPR_BOOKE_IVOR38, SPR_BOOKE_IVOR39,
1821         SPR_BOOKE_IVOR40, SPR_BOOKE_IVOR41, SPR_BOOKE_IVOR42, SPR_BOOKE_IVORxx,
1822         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1823         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1824         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1825         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1826         SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1827     };
1828     int i;
1829
1830     /* Interrupt processing */
1831     spr_register(env, SPR_BOOKE_CSRR0, "CSRR0",
1832                  SPR_NOACCESS, SPR_NOACCESS,
1833                  &spr_read_generic, &spr_write_generic,
1834                  0x00000000);
1835     spr_register(env, SPR_BOOKE_CSRR1, "CSRR1",
1836                  SPR_NOACCESS, SPR_NOACCESS,
1837                  &spr_read_generic, &spr_write_generic,
1838                  0x00000000);
1839     /* Debug */
1840     /* XXX : not implemented */
1841     spr_register(env, SPR_BOOKE_IAC1, "IAC1",
1842                  SPR_NOACCESS, SPR_NOACCESS,
1843                  &spr_read_generic, &spr_write_generic,
1844                  0x00000000);
1845     /* XXX : not implemented */
1846     spr_register(env, SPR_BOOKE_IAC2, "IAC2",
1847                  SPR_NOACCESS, SPR_NOACCESS,
1848                  &spr_read_generic, &spr_write_generic,
1849                  0x00000000);
1850     /* XXX : not implemented */
1851     spr_register(env, SPR_BOOKE_DAC1, "DAC1",
1852                  SPR_NOACCESS, SPR_NOACCESS,
1853                  &spr_read_generic, &spr_write_generic,
1854                  0x00000000);
1855     /* XXX : not implemented */
1856     spr_register(env, SPR_BOOKE_DAC2, "DAC2",
1857                  SPR_NOACCESS, SPR_NOACCESS,
1858                  &spr_read_generic, &spr_write_generic,
1859                  0x00000000);
1860     /* XXX : not implemented */
1861     spr_register(env, SPR_BOOKE_DBCR0, "DBCR0",
1862                  SPR_NOACCESS, SPR_NOACCESS,
1863                  &spr_read_generic, &spr_write_40x_dbcr0,
1864                  0x00000000);
1865     /* XXX : not implemented */
1866     spr_register(env, SPR_BOOKE_DBCR1, "DBCR1",
1867                  SPR_NOACCESS, SPR_NOACCESS,
1868                  &spr_read_generic, &spr_write_generic,
1869                  0x00000000);
1870     /* XXX : not implemented */
1871     spr_register(env, SPR_BOOKE_DBCR2, "DBCR2",
1872                  SPR_NOACCESS, SPR_NOACCESS,
1873                  &spr_read_generic, &spr_write_generic,
1874                  0x00000000);
1875     spr_register(env, SPR_BOOKE_DSRR0, "DSRR0",
1876                  SPR_NOACCESS, SPR_NOACCESS,
1877                  &spr_read_generic, &spr_write_generic,
1878                  0x00000000);
1879     spr_register(env, SPR_BOOKE_DSRR1, "DSRR1",
1880                  SPR_NOACCESS, SPR_NOACCESS,
1881                  &spr_read_generic, &spr_write_generic,
1882                  0x00000000);
1883     /* XXX : not implemented */
1884     spr_register(env, SPR_BOOKE_DBSR, "DBSR",
1885                  SPR_NOACCESS, SPR_NOACCESS,
1886                  &spr_read_generic, &spr_write_clear,
1887                  0x00000000);
1888     spr_register(env, SPR_BOOKE_DEAR, "DEAR",
1889                  SPR_NOACCESS, SPR_NOACCESS,
1890                  &spr_read_generic, &spr_write_generic,
1891                  0x00000000);
1892     spr_register(env, SPR_BOOKE_ESR, "ESR",
1893                  SPR_NOACCESS, SPR_NOACCESS,
1894                  &spr_read_generic, &spr_write_generic,
1895                  0x00000000);
1896     spr_register(env, SPR_BOOKE_IVPR, "IVPR",
1897                  SPR_NOACCESS, SPR_NOACCESS,
1898                  &spr_read_generic, &spr_write_excp_prefix,
1899                  0x00000000);
1900     /* Exception vectors */
1901     for (i = 0; i < 64; i++) {
1902         if (ivor_mask & (1ULL << i)) {
1903             if (ivor_sprn[i] == SPR_BOOKE_IVORxx) {
1904                 fprintf(stderr, "ERROR: IVOR %d SPR is not defined\n", i);
1905                 exit(1);
1906             }
1907             spr_register(env, ivor_sprn[i], ivor_names[i],
1908                          SPR_NOACCESS, SPR_NOACCESS,
1909                          &spr_read_generic, &spr_write_excp_vector,
1910                          0x00000000);
1911         }
1912     }
1913     spr_register(env, SPR_BOOKE_PID, "PID",
1914                  SPR_NOACCESS, SPR_NOACCESS,
1915                  &spr_read_generic, &spr_write_booke_pid,
1916                  0x00000000);
1917     spr_register(env, SPR_BOOKE_TCR, "TCR",
1918                  SPR_NOACCESS, SPR_NOACCESS,
1919                  &spr_read_generic, &spr_write_booke_tcr,
1920                  0x00000000);
1921     spr_register(env, SPR_BOOKE_TSR, "TSR",
1922                  SPR_NOACCESS, SPR_NOACCESS,
1923                  &spr_read_generic, &spr_write_booke_tsr,
1924                  0x00000000);
1925     /* Timer */
1926     spr_register(env, SPR_DECR, "DECR",
1927                  SPR_NOACCESS, SPR_NOACCESS,
1928                  &spr_read_decr, &spr_write_decr,
1929                  0x00000000);
1930     spr_register(env, SPR_BOOKE_DECAR, "DECAR",
1931                  SPR_NOACCESS, SPR_NOACCESS,
1932                  SPR_NOACCESS, &spr_write_generic,
1933                  0x00000000);
1934     /* SPRGs */
1935     spr_register(env, SPR_USPRG0, "USPRG0",
1936                  &spr_read_generic, &spr_write_generic,
1937                  &spr_read_generic, &spr_write_generic,
1938                  0x00000000);
1939     spr_register(env, SPR_SPRG4, "SPRG4",
1940                  SPR_NOACCESS, SPR_NOACCESS,
1941                  &spr_read_generic, &spr_write_generic,
1942                  0x00000000);
1943     spr_register(env, SPR_SPRG5, "SPRG5",
1944                  SPR_NOACCESS, SPR_NOACCESS,
1945                  &spr_read_generic, &spr_write_generic,
1946                  0x00000000);
1947     spr_register(env, SPR_SPRG6, "SPRG6",
1948                  SPR_NOACCESS, SPR_NOACCESS,
1949                  &spr_read_generic, &spr_write_generic,
1950                  0x00000000);
1951     spr_register(env, SPR_SPRG7, "SPRG7",
1952                  SPR_NOACCESS, SPR_NOACCESS,
1953                  &spr_read_generic, &spr_write_generic,
1954                  0x00000000);
1955     spr_register(env, SPR_BOOKE_SPRG8, "SPRG8",
1956                  SPR_NOACCESS, SPR_NOACCESS,
1957                  &spr_read_generic, &spr_write_generic,
1958                  0x00000000);
1959     spr_register(env, SPR_BOOKE_SPRG9, "SPRG9",
1960                  SPR_NOACCESS, SPR_NOACCESS,
1961                  &spr_read_generic, &spr_write_generic,
1962                  0x00000000);
1963 }
1964
1965 static inline uint32_t gen_tlbncfg(uint32_t assoc, uint32_t minsize,
1966                                    uint32_t maxsize, uint32_t flags,
1967                                    uint32_t nentries)
1968 {
1969     return (assoc << TLBnCFG_ASSOC_SHIFT) |
1970            (minsize << TLBnCFG_MINSIZE_SHIFT) |
1971            (maxsize << TLBnCFG_MAXSIZE_SHIFT) |
1972            flags | nentries;
1973 }
1974
1975 /* BookE 2.06 storage control registers */
1976 static void gen_spr_BookE206(CPUPPCState *env, uint32_t mas_mask,
1977                              uint32_t *tlbncfg, uint32_t mmucfg)
1978 {
1979 #if !defined(CONFIG_USER_ONLY)
1980     const char *mas_names[8] = {
1981         "MAS0", "MAS1", "MAS2", "MAS3", "MAS4", "MAS5", "MAS6", "MAS7",
1982     };
1983     int mas_sprn[8] = {
1984         SPR_BOOKE_MAS0, SPR_BOOKE_MAS1, SPR_BOOKE_MAS2, SPR_BOOKE_MAS3,
1985         SPR_BOOKE_MAS4, SPR_BOOKE_MAS5, SPR_BOOKE_MAS6, SPR_BOOKE_MAS7,
1986     };
1987     int i;
1988
1989     /* TLB assist registers */
1990     /* XXX : not implemented */
1991     for (i = 0; i < 8; i++) {
1992         void (*uea_write)(DisasContext *ctx, int sprn, int gprn) =
1993             &spr_write_generic32;
1994         if (i == 2 && (mas_mask & (1 << i)) && (env->insns_flags & PPC_64B)) {
1995             uea_write = &spr_write_generic;
1996         }
1997         if (mas_mask & (1 << i)) {
1998             spr_register(env, mas_sprn[i], mas_names[i],
1999                          SPR_NOACCESS, SPR_NOACCESS,
2000                          &spr_read_generic, uea_write,
2001                          0x00000000);
2002         }
2003     }
2004     if (env->nb_pids > 1) {
2005         /* XXX : not implemented */
2006         spr_register(env, SPR_BOOKE_PID1, "PID1",
2007                      SPR_NOACCESS, SPR_NOACCESS,
2008                      &spr_read_generic, &spr_write_booke_pid,
2009                      0x00000000);
2010     }
2011     if (env->nb_pids > 2) {
2012         /* XXX : not implemented */
2013         spr_register(env, SPR_BOOKE_PID2, "PID2",
2014                      SPR_NOACCESS, SPR_NOACCESS,
2015                      &spr_read_generic, &spr_write_booke_pid,
2016                      0x00000000);
2017     }
2018
2019     spr_register(env, SPR_BOOKE_EPLC, "EPLC",
2020                  SPR_NOACCESS, SPR_NOACCESS,
2021                  &spr_read_generic, &spr_write_eplc,
2022                  0x00000000);
2023     spr_register(env, SPR_BOOKE_EPSC, "EPSC",
2024                  SPR_NOACCESS, SPR_NOACCESS,
2025                  &spr_read_generic, &spr_write_epsc,
2026                  0x00000000);
2027
2028     /* XXX : not implemented */
2029     spr_register(env, SPR_MMUCFG, "MMUCFG",
2030                  SPR_NOACCESS, SPR_NOACCESS,
2031                  &spr_read_generic, SPR_NOACCESS,
2032                  mmucfg);
2033     switch (env->nb_ways) {
2034     case 4:
2035         spr_register(env, SPR_BOOKE_TLB3CFG, "TLB3CFG",
2036                      SPR_NOACCESS, SPR_NOACCESS,
2037                      &spr_read_generic, SPR_NOACCESS,
2038                      tlbncfg[3]);
2039         /* Fallthru */
2040     case 3:
2041         spr_register(env, SPR_BOOKE_TLB2CFG, "TLB2CFG",
2042                      SPR_NOACCESS, SPR_NOACCESS,
2043                      &spr_read_generic, SPR_NOACCESS,
2044                      tlbncfg[2]);
2045         /* Fallthru */
2046     case 2:
2047         spr_register(env, SPR_BOOKE_TLB1CFG, "TLB1CFG",
2048                      SPR_NOACCESS, SPR_NOACCESS,
2049                      &spr_read_generic, SPR_NOACCESS,
2050                      tlbncfg[1]);
2051         /* Fallthru */
2052     case 1:
2053         spr_register(env, SPR_BOOKE_TLB0CFG, "TLB0CFG",
2054                      SPR_NOACCESS, SPR_NOACCESS,
2055                      &spr_read_generic, SPR_NOACCESS,
2056                      tlbncfg[0]);
2057         /* Fallthru */
2058     case 0:
2059     default:
2060         break;
2061     }
2062 #endif
2063
2064     gen_spr_usprgh(env);
2065 }
2066
2067 /* SPR specific to PowerPC 440 implementation */
2068 static void gen_spr_440(CPUPPCState *env)
2069 {
2070     /* Cache control */
2071     /* XXX : not implemented */
2072     spr_register(env, SPR_440_DNV0, "DNV0",
2073                  SPR_NOACCESS, SPR_NOACCESS,
2074                  &spr_read_generic, &spr_write_generic,
2075                  0x00000000);
2076     /* XXX : not implemented */
2077     spr_register(env, SPR_440_DNV1, "DNV1",
2078                  SPR_NOACCESS, SPR_NOACCESS,
2079                  &spr_read_generic, &spr_write_generic,
2080                  0x00000000);
2081     /* XXX : not implemented */
2082     spr_register(env, SPR_440_DNV2, "DNV2",
2083                  SPR_NOACCESS, SPR_NOACCESS,
2084                  &spr_read_generic, &spr_write_generic,
2085                  0x00000000);
2086     /* XXX : not implemented */
2087     spr_register(env, SPR_440_DNV3, "DNV3",
2088                  SPR_NOACCESS, SPR_NOACCESS,
2089                  &spr_read_generic, &spr_write_generic,
2090                  0x00000000);
2091     /* XXX : not implemented */
2092     spr_register(env, SPR_440_DTV0, "DTV0",
2093                  SPR_NOACCESS, SPR_NOACCESS,
2094                  &spr_read_generic, &spr_write_generic,
2095                  0x00000000);
2096     /* XXX : not implemented */
2097     spr_register(env, SPR_440_DTV1, "DTV1",
2098                  SPR_NOACCESS, SPR_NOACCESS,
2099                  &spr_read_generic, &spr_write_generic,
2100                  0x00000000);
2101     /* XXX : not implemented */
2102     spr_register(env, SPR_440_DTV2, "DTV2",
2103                  SPR_NOACCESS, SPR_NOACCESS,
2104                  &spr_read_generic, &spr_write_generic,
2105                  0x00000000);
2106     /* XXX : not implemented */
2107     spr_register(env, SPR_440_DTV3, "DTV3",
2108                  SPR_NOACCESS, SPR_NOACCESS,
2109                  &spr_read_generic, &spr_write_generic,
2110                  0x00000000);
2111     /* XXX : not implemented */
2112     spr_register(env, SPR_440_DVLIM, "DVLIM",
2113                  SPR_NOACCESS, SPR_NOACCESS,
2114                  &spr_read_generic, &spr_write_generic,
2115                  0x00000000);
2116     /* XXX : not implemented */
2117     spr_register(env, SPR_440_INV0, "INV0",
2118                  SPR_NOACCESS, SPR_NOACCESS,
2119                  &spr_read_generic, &spr_write_generic,
2120                  0x00000000);
2121     /* XXX : not implemented */
2122     spr_register(env, SPR_440_INV1, "INV1",
2123                  SPR_NOACCESS, SPR_NOACCESS,
2124                  &spr_read_generic, &spr_write_generic,
2125                  0x00000000);
2126     /* XXX : not implemented */
2127     spr_register(env, SPR_440_INV2, "INV2",
2128                  SPR_NOACCESS, SPR_NOACCESS,
2129                  &spr_read_generic, &spr_write_generic,
2130                  0x00000000);
2131     /* XXX : not implemented */
2132     spr_register(env, SPR_440_INV3, "INV3",
2133                  SPR_NOACCESS, SPR_NOACCESS,
2134                  &spr_read_generic, &spr_write_generic,
2135                  0x00000000);
2136     /* XXX : not implemented */
2137     spr_register(env, SPR_440_ITV0, "ITV0",
2138                  SPR_NOACCESS, SPR_NOACCESS,
2139                  &spr_read_generic, &spr_write_generic,
2140                  0x00000000);
2141     /* XXX : not implemented */
2142     spr_register(env, SPR_440_ITV1, "ITV1",
2143                  SPR_NOACCESS, SPR_NOACCESS,
2144                  &spr_read_generic, &spr_write_generic,
2145                  0x00000000);
2146     /* XXX : not implemented */
2147     spr_register(env, SPR_440_ITV2, "ITV2",
2148                  SPR_NOACCESS, SPR_NOACCESS,
2149                  &spr_read_generic, &spr_write_generic,
2150                  0x00000000);
2151     /* XXX : not implemented */
2152     spr_register(env, SPR_440_ITV3, "ITV3",
2153                  SPR_NOACCESS, SPR_NOACCESS,
2154                  &spr_read_generic, &spr_write_generic,
2155                  0x00000000);
2156     /* XXX : not implemented */
2157     spr_register(env, SPR_440_IVLIM, "IVLIM",
2158                  SPR_NOACCESS, SPR_NOACCESS,
2159                  &spr_read_generic, &spr_write_generic,
2160                  0x00000000);
2161     /* Cache debug */
2162     /* XXX : not implemented */
2163     spr_register(env, SPR_BOOKE_DCDBTRH, "DCDBTRH",
2164                  SPR_NOACCESS, SPR_NOACCESS,
2165                  &spr_read_generic, SPR_NOACCESS,
2166                  0x00000000);
2167     /* XXX : not implemented */
2168     spr_register(env, SPR_BOOKE_DCDBTRL, "DCDBTRL",
2169                  SPR_NOACCESS, SPR_NOACCESS,
2170                  &spr_read_generic, SPR_NOACCESS,
2171                  0x00000000);
2172     /* XXX : not implemented */
2173     spr_register(env, SPR_BOOKE_ICDBDR, "ICDBDR",
2174                  SPR_NOACCESS, SPR_NOACCESS,
2175                  &spr_read_generic, SPR_NOACCESS,
2176                  0x00000000);
2177     /* XXX : not implemented */
2178     spr_register(env, SPR_BOOKE_ICDBTRH, "ICDBTRH",
2179                  SPR_NOACCESS, SPR_NOACCESS,
2180                  &spr_read_generic, SPR_NOACCESS,
2181                  0x00000000);
2182     /* XXX : not implemented */
2183     spr_register(env, SPR_BOOKE_ICDBTRL, "ICDBTRL",
2184                  SPR_NOACCESS, SPR_NOACCESS,
2185                  &spr_read_generic, SPR_NOACCESS,
2186                  0x00000000);
2187     /* XXX : not implemented */
2188     spr_register(env, SPR_440_DBDR, "DBDR",
2189                  SPR_NOACCESS, SPR_NOACCESS,
2190                  &spr_read_generic, &spr_write_generic,
2191                  0x00000000);
2192     /* Processor control */
2193     spr_register(env, SPR_4xx_CCR0, "CCR0",
2194                  SPR_NOACCESS, SPR_NOACCESS,
2195                  &spr_read_generic, &spr_write_generic,
2196                  0x00000000);
2197     spr_register(env, SPR_440_RSTCFG, "RSTCFG",
2198                  SPR_NOACCESS, SPR_NOACCESS,
2199                  &spr_read_generic, SPR_NOACCESS,
2200                  0x00000000);
2201     /* Storage control */
2202     spr_register(env, SPR_440_MMUCR, "MMUCR",
2203                  SPR_NOACCESS, SPR_NOACCESS,
2204                  &spr_read_generic, &spr_write_generic,
2205                  0x00000000);
2206 }
2207
2208 /* SPR shared between PowerPC 40x implementations */
2209 static void gen_spr_40x(CPUPPCState *env)
2210 {
2211     /* Cache */
2212     /* not emulated, as QEMU do not emulate caches */
2213     spr_register(env, SPR_40x_DCCR, "DCCR",
2214                  SPR_NOACCESS, SPR_NOACCESS,
2215                  &spr_read_generic, &spr_write_generic,
2216                  0x00000000);
2217     /* not emulated, as QEMU do not emulate caches */
2218     spr_register(env, SPR_40x_ICCR, "ICCR",
2219                  SPR_NOACCESS, SPR_NOACCESS,
2220                  &spr_read_generic, &spr_write_generic,
2221                  0x00000000);
2222     /* not emulated, as QEMU do not emulate caches */
2223     spr_register(env, SPR_BOOKE_ICDBDR, "ICDBDR",
2224                  SPR_NOACCESS, SPR_NOACCESS,
2225                  &spr_read_generic, SPR_NOACCESS,
2226                  0x00000000);
2227     /* Exception */
2228     spr_register(env, SPR_40x_DEAR, "DEAR",
2229                  SPR_NOACCESS, SPR_NOACCESS,
2230                  &spr_read_generic, &spr_write_generic,
2231                  0x00000000);
2232     spr_register(env, SPR_40x_ESR, "ESR",
2233                  SPR_NOACCESS, SPR_NOACCESS,
2234                  &spr_read_generic, &spr_write_generic,
2235                  0x00000000);
2236     spr_register(env, SPR_40x_EVPR, "EVPR",
2237                  SPR_NOACCESS, SPR_NOACCESS,
2238                  &spr_read_generic, &spr_write_excp_prefix,
2239                  0x00000000);
2240     spr_register(env, SPR_40x_SRR2, "SRR2",
2241                  &spr_read_generic, &spr_write_generic,
2242                  &spr_read_generic, &spr_write_generic,
2243                  0x00000000);
2244     spr_register(env, SPR_40x_SRR3, "SRR3",
2245                  &spr_read_generic, &spr_write_generic,
2246                  &spr_read_generic, &spr_write_generic,
2247                  0x00000000);
2248     /* Timers */
2249     spr_register(env, SPR_40x_PIT, "PIT",
2250                  SPR_NOACCESS, SPR_NOACCESS,
2251                  &spr_read_40x_pit, &spr_write_40x_pit,
2252                  0x00000000);
2253     spr_register(env, SPR_40x_TCR, "TCR",
2254                  SPR_NOACCESS, SPR_NOACCESS,
2255                  &spr_read_generic, &spr_write_booke_tcr,
2256                  0x00000000);
2257     spr_register(env, SPR_40x_TSR, "TSR",
2258                  SPR_NOACCESS, SPR_NOACCESS,
2259                  &spr_read_generic, &spr_write_booke_tsr,
2260                  0x00000000);
2261 }
2262
2263 /* SPR specific to PowerPC 405 implementation */
2264 static void gen_spr_405(CPUPPCState *env)
2265 {
2266     /* MMU */
2267     spr_register(env, SPR_40x_PID, "PID",
2268                  SPR_NOACCESS, SPR_NOACCESS,
2269                  &spr_read_generic, &spr_write_generic,
2270                  0x00000000);
2271     spr_register(env, SPR_4xx_CCR0, "CCR0",
2272                  SPR_NOACCESS, SPR_NOACCESS,
2273                  &spr_read_generic, &spr_write_generic,
2274                  0x00700000);
2275     /* Debug interface */
2276     /* XXX : not implemented */
2277     spr_register(env, SPR_40x_DBCR0, "DBCR0",
2278                  SPR_NOACCESS, SPR_NOACCESS,
2279                  &spr_read_generic, &spr_write_40x_dbcr0,
2280                  0x00000000);
2281     /* XXX : not implemented */
2282     spr_register(env, SPR_405_DBCR1, "DBCR1",
2283                  SPR_NOACCESS, SPR_NOACCESS,
2284                  &spr_read_generic, &spr_write_generic,
2285                  0x00000000);
2286     /* XXX : not implemented */
2287     spr_register(env, SPR_40x_DBSR, "DBSR",
2288                  SPR_NOACCESS, SPR_NOACCESS,
2289                  &spr_read_generic, &spr_write_clear,
2290                  /* Last reset was system reset */
2291                  0x00000300);
2292     /* XXX : not implemented */
2293     spr_register(env, SPR_40x_DAC1, "DAC1",
2294                  SPR_NOACCESS, SPR_NOACCESS,
2295                  &spr_read_generic, &spr_write_generic,
2296                  0x00000000);
2297     spr_register(env, SPR_40x_DAC2, "DAC2",
2298                  SPR_NOACCESS, SPR_NOACCESS,
2299                  &spr_read_generic, &spr_write_generic,
2300                  0x00000000);
2301     /* XXX : not implemented */
2302     spr_register(env, SPR_405_DVC1, "DVC1",
2303                  SPR_NOACCESS, SPR_NOACCESS,
2304                  &spr_read_generic, &spr_write_generic,
2305                  0x00000000);
2306     /* XXX : not implemented */
2307     spr_register(env, SPR_405_DVC2, "DVC2",
2308                  SPR_NOACCESS, SPR_NOACCESS,
2309                  &spr_read_generic, &spr_write_generic,
2310                  0x00000000);
2311     /* XXX : not implemented */
2312     spr_register(env, SPR_40x_IAC1, "IAC1",
2313                  SPR_NOACCESS, SPR_NOACCESS,
2314                  &spr_read_generic, &spr_write_generic,
2315                  0x00000000);
2316     spr_register(env, SPR_40x_IAC2, "IAC2",
2317                  SPR_NOACCESS, SPR_NOACCESS,
2318                  &spr_read_generic, &spr_write_generic,
2319                  0x00000000);
2320     /* XXX : not implemented */
2321     spr_register(env, SPR_405_IAC3, "IAC3",
2322                  SPR_NOACCESS, SPR_NOACCESS,
2323                  &spr_read_generic, &spr_write_generic,
2324                  0x00000000);
2325     /* XXX : not implemented */
2326     spr_register(env, SPR_405_IAC4, "IAC4",
2327                  SPR_NOACCESS, SPR_NOACCESS,
2328                  &spr_read_generic, &spr_write_generic,
2329                  0x00000000);
2330     /* Storage control */
2331     /* XXX: TODO: not implemented */
2332     spr_register(env, SPR_405_SLER, "SLER",
2333                  SPR_NOACCESS, SPR_NOACCESS,
2334                  &spr_read_generic, &spr_write_40x_sler,
2335                  0x00000000);
2336     spr_register(env, SPR_40x_ZPR, "ZPR",
2337                  SPR_NOACCESS, SPR_NOACCESS,
2338                  &spr_read_generic, &spr_write_generic,
2339                  0x00000000);
2340     /* XXX : not implemented */
2341     spr_register(env, SPR_405_SU0R, "SU0R",
2342                  SPR_NOACCESS, SPR_NOACCESS,
2343                  &spr_read_generic, &spr_write_generic,
2344                  0x00000000);
2345     /* SPRG */
2346     spr_register(env, SPR_USPRG0, "USPRG0",
2347                  &spr_read_ureg, SPR_NOACCESS,
2348                  &spr_read_ureg, SPR_NOACCESS,
2349                  0x00000000);
2350     spr_register(env, SPR_SPRG4, "SPRG4",
2351                  SPR_NOACCESS, SPR_NOACCESS,
2352                  &spr_read_generic, &spr_write_generic,
2353                  0x00000000);
2354     spr_register(env, SPR_SPRG5, "SPRG5",
2355                  SPR_NOACCESS, SPR_NOACCESS,
2356                  spr_read_generic, &spr_write_generic,
2357                  0x00000000);
2358     spr_register(env, SPR_SPRG6, "SPRG6",
2359                  SPR_NOACCESS, SPR_NOACCESS,
2360                  spr_read_generic, &spr_write_generic,
2361                  0x00000000);
2362     spr_register(env, SPR_SPRG7, "SPRG7",
2363                  SPR_NOACCESS, SPR_NOACCESS,
2364                  spr_read_generic, &spr_write_generic,
2365                  0x00000000);
2366     gen_spr_usprgh(env);
2367 }
2368
2369 /* SPR shared between PowerPC 401 & 403 implementations */
2370 static void gen_spr_401_403(CPUPPCState *env)
2371 {
2372     /* Time base */
2373     spr_register(env, SPR_403_VTBL,  "TBL",
2374                  &spr_read_tbl, SPR_NOACCESS,
2375                  &spr_read_tbl, SPR_NOACCESS,
2376                  0x00000000);
2377     spr_register(env, SPR_403_TBL,   "TBL",
2378                  SPR_NOACCESS, SPR_NOACCESS,
2379                  SPR_NOACCESS, &spr_write_tbl,
2380                  0x00000000);
2381     spr_register(env, SPR_403_VTBU,  "TBU",
2382                  &spr_read_tbu, SPR_NOACCESS,
2383                  &spr_read_tbu, SPR_NOACCESS,
2384                  0x00000000);
2385     spr_register(env, SPR_403_TBU,   "TBU",
2386                  SPR_NOACCESS, SPR_NOACCESS,
2387                  SPR_NOACCESS, &spr_write_tbu,
2388                  0x00000000);
2389     /* Debug */
2390     /* not emulated, as QEMU do not emulate caches */
2391     spr_register(env, SPR_403_CDBCR, "CDBCR",
2392                  SPR_NOACCESS, SPR_NOACCESS,
2393                  &spr_read_generic, &spr_write_generic,
2394                  0x00000000);
2395 }
2396
2397 /* SPR specific to PowerPC 401 implementation */
2398 static void gen_spr_401(CPUPPCState *env)
2399 {
2400     /* Debug interface */
2401     /* XXX : not implemented */
2402     spr_register(env, SPR_40x_DBCR0, "DBCR",
2403                  SPR_NOACCESS, SPR_NOACCESS,
2404                  &spr_read_generic, &spr_write_40x_dbcr0,
2405                  0x00000000);
2406     /* XXX : not implemented */
2407     spr_register(env, SPR_40x_DBSR, "DBSR",
2408                  SPR_NOACCESS, SPR_NOACCESS,
2409                  &spr_read_generic, &spr_write_clear,
2410                  /* Last reset was system reset */
2411                  0x00000300);
2412     /* XXX : not implemented */
2413     spr_register(env, SPR_40x_DAC1, "DAC",
2414                  SPR_NOACCESS, SPR_NOACCESS,
2415                  &spr_read_generic, &spr_write_generic,
2416                  0x00000000);
2417     /* XXX : not implemented */
2418     spr_register(env, SPR_40x_IAC1, "IAC",
2419                  SPR_NOACCESS, SPR_NOACCESS,
2420                  &spr_read_generic, &spr_write_generic,
2421                  0x00000000);
2422     /* Storage control */
2423     /* XXX: TODO: not implemented */
2424     spr_register(env, SPR_405_SLER, "SLER",
2425                  SPR_NOACCESS, SPR_NOACCESS,
2426                  &spr_read_generic, &spr_write_40x_sler,
2427                  0x00000000);
2428     /* not emulated, as QEMU never does speculative access */
2429     spr_register(env, SPR_40x_SGR, "SGR",
2430                  SPR_NOACCESS, SPR_NOACCESS,
2431                  &spr_read_generic, &spr_write_generic,
2432                  0xFFFFFFFF);
2433     /* not emulated, as QEMU do not emulate caches */
2434     spr_register(env, SPR_40x_DCWR, "DCWR",
2435                  SPR_NOACCESS, SPR_NOACCESS,
2436                  &spr_read_generic, &spr_write_generic,
2437                  0x00000000);
2438 }
2439
2440 static void gen_spr_401x2(CPUPPCState *env)
2441 {
2442     gen_spr_401(env);
2443     spr_register(env, SPR_40x_PID, "PID",
2444                  SPR_NOACCESS, SPR_NOACCESS,
2445                  &spr_read_generic, &spr_write_generic,
2446                  0x00000000);
2447     spr_register(env, SPR_40x_ZPR, "ZPR",
2448                  SPR_NOACCESS, SPR_NOACCESS,
2449                  &spr_read_generic, &spr_write_generic,
2450                  0x00000000);
2451 }
2452
2453 /* SPR specific to PowerPC 403 implementation */
2454 static void gen_spr_403(CPUPPCState *env)
2455 {
2456     /* Debug interface */
2457     /* XXX : not implemented */
2458     spr_register(env, SPR_40x_DBCR0, "DBCR0",
2459                  SPR_NOACCESS, SPR_NOACCESS,
2460                  &spr_read_generic, &spr_write_40x_dbcr0,
2461                  0x00000000);
2462     /* XXX : not implemented */
2463     spr_register(env, SPR_40x_DBSR, "DBSR",
2464                  SPR_NOACCESS, SPR_NOACCESS,
2465                  &spr_read_generic, &spr_write_clear,
2466                  /* Last reset was system reset */
2467                  0x00000300);
2468     /* XXX : not implemented */
2469     spr_register(env, SPR_40x_DAC1, "DAC1",
2470                  SPR_NOACCESS, SPR_NOACCESS,
2471                  &spr_read_generic, &spr_write_generic,
2472                  0x00000000);
2473     /* XXX : not implemented */
2474     spr_register(env, SPR_40x_DAC2, "DAC2",
2475                  SPR_NOACCESS, SPR_NOACCESS,
2476                  &spr_read_generic, &spr_write_generic,
2477                  0x00000000);
2478     /* XXX : not implemented */
2479     spr_register(env, SPR_40x_IAC1, "IAC1",
2480                  SPR_NOACCESS, SPR_NOACCESS,
2481                  &spr_read_generic, &spr_write_generic,
2482                  0x00000000);
2483     /* XXX : not implemented */
2484     spr_register(env, SPR_40x_IAC2, "IAC2",
2485                  SPR_NOACCESS, SPR_NOACCESS,
2486                  &spr_read_generic, &spr_write_generic,
2487                  0x00000000);
2488 }
2489
2490 static void gen_spr_403_real(CPUPPCState *env)
2491 {
2492     spr_register(env, SPR_403_PBL1,  "PBL1",
2493                  SPR_NOACCESS, SPR_NOACCESS,
2494                  &spr_read_403_pbr, &spr_write_403_pbr,
2495                  0x00000000);
2496     spr_register(env, SPR_403_PBU1,  "PBU1",
2497                  SPR_NOACCESS, SPR_NOACCESS,
2498                  &spr_read_403_pbr, &spr_write_403_pbr,
2499                  0x00000000);
2500     spr_register(env, SPR_403_PBL2,  "PBL2",
2501                  SPR_NOACCESS, SPR_NOACCESS,
2502                  &spr_read_403_pbr, &spr_write_403_pbr,
2503                  0x00000000);
2504     spr_register(env, SPR_403_PBU2,  "PBU2",
2505                  SPR_NOACCESS, SPR_NOACCESS,
2506                  &spr_read_403_pbr, &spr_write_403_pbr,
2507                  0x00000000);
2508 }
2509
2510 static void gen_spr_403_mmu(CPUPPCState *env)
2511 {
2512     /* MMU */
2513     spr_register(env, SPR_40x_PID, "PID",
2514                  SPR_NOACCESS, SPR_NOACCESS,
2515                  &spr_read_generic, &spr_write_generic,
2516                  0x00000000);
2517     spr_register(env, SPR_40x_ZPR, "ZPR",
2518                  SPR_NOACCESS, SPR_NOACCESS,
2519                  &spr_read_generic, &spr_write_generic,
2520                  0x00000000);
2521 }
2522
2523 /* SPR specific to PowerPC compression coprocessor extension */
2524 static void gen_spr_compress(CPUPPCState *env)
2525 {
2526     /* XXX : not implemented */
2527     spr_register(env, SPR_401_SKR, "SKR",
2528                  SPR_NOACCESS, SPR_NOACCESS,
2529                  &spr_read_generic, &spr_write_generic,
2530                  0x00000000);
2531 }
2532
2533 static void gen_spr_5xx_8xx(CPUPPCState *env)
2534 {
2535     /* Exception processing */
2536     spr_register_kvm(env, SPR_DSISR, "DSISR",
2537                      SPR_NOACCESS, SPR_NOACCESS,
2538                      &spr_read_generic, &spr_write_generic,
2539                      KVM_REG_PPC_DSISR, 0x00000000);
2540     spr_register_kvm(env, SPR_DAR, "DAR",
2541                      SPR_NOACCESS, SPR_NOACCESS,
2542                      &spr_read_generic, &spr_write_generic,
2543                      KVM_REG_PPC_DAR, 0x00000000);
2544     /* Timer */
2545     spr_register(env, SPR_DECR, "DECR",
2546                  SPR_NOACCESS, SPR_NOACCESS,
2547                  &spr_read_decr, &spr_write_decr,
2548                  0x00000000);
2549     /* XXX : not implemented */
2550     spr_register(env, SPR_MPC_EIE, "EIE",
2551                  SPR_NOACCESS, SPR_NOACCESS,
2552                  &spr_read_generic, &spr_write_generic,
2553                  0x00000000);
2554     /* XXX : not implemented */
2555     spr_register(env, SPR_MPC_EID, "EID",
2556                  SPR_NOACCESS, SPR_NOACCESS,
2557                  &spr_read_generic, &spr_write_generic,
2558                  0x00000000);
2559     /* XXX : not implemented */
2560     spr_register(env, SPR_MPC_NRI, "NRI",
2561                  SPR_NOACCESS, SPR_NOACCESS,
2562                  &spr_read_generic, &spr_write_generic,
2563                  0x00000000);
2564     /* XXX : not implemented */
2565     spr_register(env, SPR_MPC_CMPA, "CMPA",
2566                  SPR_NOACCESS, SPR_NOACCESS,
2567                  &spr_read_generic, &spr_write_generic,
2568                  0x00000000);
2569     /* XXX : not implemented */
2570     spr_register(env, SPR_MPC_CMPB, "CMPB",
2571                  SPR_NOACCESS, SPR_NOACCESS,
2572                  &spr_read_generic, &spr_write_generic,
2573                  0x00000000);
2574     /* XXX : not implemented */
2575     spr_register(env, SPR_MPC_CMPC, "CMPC",
2576                  SPR_NOACCESS, SPR_NOACCESS,
2577                  &spr_read_generic, &spr_write_generic,
2578                  0x00000000);
2579     /* XXX : not implemented */
2580     spr_register(env, SPR_MPC_CMPD, "CMPD",
2581                  SPR_NOACCESS, SPR_NOACCESS,
2582                  &spr_read_generic, &spr_write_generic,
2583                  0x00000000);
2584     /* XXX : not implemented */
2585     spr_register(env, SPR_MPC_ECR, "ECR",
2586                  SPR_NOACCESS, SPR_NOACCESS,
2587                  &spr_read_generic, &spr_write_generic,
2588                  0x00000000);
2589     /* XXX : not implemented */
2590     spr_register(env, SPR_MPC_DER, "DER",
2591                  SPR_NOACCESS, SPR_NOACCESS,
2592                  &spr_read_generic, &spr_write_generic,
2593                  0x00000000);
2594     /* XXX : not implemented */
2595     spr_register(env, SPR_MPC_COUNTA, "COUNTA",
2596                  SPR_NOACCESS, SPR_NOACCESS,
2597                  &spr_read_generic, &spr_write_generic,
2598                  0x00000000);
2599     /* XXX : not implemented */
2600     spr_register(env, SPR_MPC_COUNTB, "COUNTB",
2601                  SPR_NOACCESS, SPR_NOACCESS,
2602                  &spr_read_generic, &spr_write_generic,
2603                  0x00000000);
2604     /* XXX : not implemented */
2605     spr_register(env, SPR_MPC_CMPE, "CMPE",
2606                  SPR_NOACCESS, SPR_NOACCESS,
2607                  &spr_read_generic, &spr_write_generic,
2608                  0x00000000);
2609     /* XXX : not implemented */
2610     spr_register(env, SPR_MPC_CMPF, "CMPF",
2611                  SPR_NOACCESS, SPR_NOACCESS,
2612                  &spr_read_generic, &spr_write_generic,
2613                  0x00000000);
2614     /* XXX : not implemented */
2615     spr_register(env, SPR_MPC_CMPG, "CMPG",
2616                  SPR_NOACCESS, SPR_NOACCESS,
2617                  &spr_read_generic, &spr_write_generic,
2618                  0x00000000);
2619     /* XXX : not implemented */
2620     spr_register(env, SPR_MPC_CMPH, "CMPH",
2621                  SPR_NOACCESS, SPR_NOACCESS,
2622                  &spr_read_generic, &spr_write_generic,
2623                  0x00000000);
2624     /* XXX : not implemented */
2625     spr_register(env, SPR_MPC_LCTRL1, "LCTRL1",
2626                  SPR_NOACCESS, SPR_NOACCESS,
2627                  &spr_read_generic, &spr_write_generic,
2628                  0x00000000);
2629     /* XXX : not implemented */
2630     spr_register(env, SPR_MPC_LCTRL2, "LCTRL2",
2631                  SPR_NOACCESS, SPR_NOACCESS,
2632                  &spr_read_generic, &spr_write_generic,
2633                  0x00000000);
2634     /* XXX : not implemented */
2635     spr_register(env, SPR_MPC_BAR, "BAR",
2636                  SPR_NOACCESS, SPR_NOACCESS,
2637                  &spr_read_generic, &spr_write_generic,
2638                  0x00000000);
2639     /* XXX : not implemented */
2640     spr_register(env, SPR_MPC_DPDR, "DPDR",
2641                  SPR_NOACCESS, SPR_NOACCESS,
2642                  &spr_read_generic, &spr_write_generic,
2643                  0x00000000);
2644     /* XXX : not implemented */
2645     spr_register(env, SPR_MPC_IMMR, "IMMR",
2646                  SPR_NOACCESS, SPR_NOACCESS,
2647                  &spr_read_generic, &spr_write_generic,
2648                  0x00000000);
2649 }
2650
2651 static void gen_spr_5xx(CPUPPCState *env)
2652 {
2653     /* XXX : not implemented */
2654     spr_register(env, SPR_RCPU_MI_GRA, "MI_GRA",
2655                  SPR_NOACCESS, SPR_NOACCESS,
2656                  &spr_read_generic, &spr_write_generic,
2657                  0x00000000);
2658     /* XXX : not implemented */
2659     spr_register(env, SPR_RCPU_L2U_GRA, "L2U_GRA",
2660                  SPR_NOACCESS, SPR_NOACCESS,
2661                  &spr_read_generic, &spr_write_generic,
2662                  0x00000000);
2663     /* XXX : not implemented */
2664     spr_register(env, SPR_RPCU_BBCMCR, "L2U_BBCMCR",
2665                  SPR_NOACCESS, SPR_NOACCESS,
2666                  &spr_read_generic, &spr_write_generic,
2667                  0x00000000);
2668     /* XXX : not implemented */
2669     spr_register(env, SPR_RCPU_L2U_MCR, "L2U_MCR",
2670                  SPR_NOACCESS, SPR_NOACCESS,
2671                  &spr_read_generic, &spr_write_generic,
2672                  0x00000000);
2673     /* XXX : not implemented */
2674     spr_register(env, SPR_RCPU_MI_RBA0, "MI_RBA0",
2675                  SPR_NOACCESS, SPR_NOACCESS,
2676                  &spr_read_generic, &spr_write_generic,
2677                  0x00000000);
2678     /* XXX : not implemented */
2679     spr_register(env, SPR_RCPU_MI_RBA1, "MI_RBA1",
2680                  SPR_NOACCESS, SPR_NOACCESS,
2681                  &spr_read_generic, &spr_write_generic,
2682                  0x00000000);
2683     /* XXX : not implemented */
2684     spr_register(env, SPR_RCPU_MI_RBA2, "MI_RBA2",
2685                  SPR_NOACCESS, SPR_NOACCESS,
2686                  &spr_read_generic, &spr_write_generic,
2687                  0x00000000);
2688     /* XXX : not implemented */
2689     spr_register(env, SPR_RCPU_MI_RBA3, "MI_RBA3",
2690                  SPR_NOACCESS, SPR_NOACCESS,
2691                  &spr_read_generic, &spr_write_generic,
2692                  0x00000000);
2693     /* XXX : not implemented */
2694     spr_register(env, SPR_RCPU_L2U_RBA0, "L2U_RBA0",
2695                  SPR_NOACCESS, SPR_NOACCESS,
2696                  &spr_read_generic, &spr_write_generic,
2697                  0x00000000);
2698     /* XXX : not implemented */
2699     spr_register(env, SPR_RCPU_L2U_RBA1, "L2U_RBA1",
2700                  SPR_NOACCESS, SPR_NOACCESS,
2701                  &spr_read_generic, &spr_write_generic,
2702                  0x00000000);
2703     /* XXX : not implemented */
2704     spr_register(env, SPR_RCPU_L2U_RBA2, "L2U_RBA2",
2705                  SPR_NOACCESS, SPR_NOACCESS,
2706                  &spr_read_generic, &spr_write_generic,
2707                  0x00000000);
2708     /* XXX : not implemented */
2709     spr_register(env, SPR_RCPU_L2U_RBA3, "L2U_RBA3",
2710                  SPR_NOACCESS, SPR_NOACCESS,
2711                  &spr_read_generic, &spr_write_generic,
2712                  0x00000000);
2713     /* XXX : not implemented */
2714     spr_register(env, SPR_RCPU_MI_RA0, "MI_RA0",
2715                  SPR_NOACCESS, SPR_NOACCESS,
2716                  &spr_read_generic, &spr_write_generic,
2717                  0x00000000);
2718     /* XXX : not implemented */
2719     spr_register(env, SPR_RCPU_MI_RA1, "MI_RA1",
2720                  SPR_NOACCESS, SPR_NOACCESS,
2721                  &spr_read_generic, &spr_write_generic,
2722                  0x00000000);
2723     /* XXX : not implemented */
2724     spr_register(env, SPR_RCPU_MI_RA2, "MI_RA2",
2725                  SPR_NOACCESS, SPR_NOACCESS,
2726                  &spr_read_generic, &spr_write_generic,
2727                  0x00000000);
2728     /* XXX : not implemented */
2729     spr_register(env, SPR_RCPU_MI_RA3, "MI_RA3",
2730                  SPR_NOACCESS, SPR_NOACCESS,
2731                  &spr_read_generic, &spr_write_generic,
2732                  0x00000000);
2733     /* XXX : not implemented */
2734     spr_register(env, SPR_RCPU_L2U_RA0, "L2U_RA0",
2735                  SPR_NOACCESS, SPR_NOACCESS,
2736                  &spr_read_generic, &spr_write_generic,
2737                  0x00000000);
2738     /* XXX : not implemented */
2739     spr_register(env, SPR_RCPU_L2U_RA1, "L2U_RA1",
2740                  SPR_NOACCESS, SPR_NOACCESS,
2741                  &spr_read_generic, &spr_write_generic,
2742                  0x00000000);
2743     /* XXX : not implemented */
2744     spr_register(env, SPR_RCPU_L2U_RA2, "L2U_RA2",
2745                  SPR_NOACCESS, SPR_NOACCESS,
2746                  &spr_read_generic, &spr_write_generic,
2747                  0x00000000);
2748     /* XXX : not implemented */
2749     spr_register(env, SPR_RCPU_L2U_RA3, "L2U_RA3",
2750                  SPR_NOACCESS, SPR_NOACCESS,
2751                  &spr_read_generic, &spr_write_generic,
2752                  0x00000000);
2753     /* XXX : not implemented */
2754     spr_register(env, SPR_RCPU_FPECR, "FPECR",
2755                  SPR_NOACCESS, SPR_NOACCESS,
2756                  &spr_read_generic, &spr_write_generic,
2757                  0x00000000);
2758 }
2759
2760 static void gen_spr_8xx(CPUPPCState *env)
2761 {
2762     /* XXX : not implemented */
2763     spr_register(env, SPR_MPC_IC_CST, "IC_CST",
2764                  SPR_NOACCESS, SPR_NOACCESS,
2765                  &spr_read_generic, &spr_write_generic,
2766                  0x00000000);
2767     /* XXX : not implemented */
2768     spr_register(env, SPR_MPC_IC_ADR, "IC_ADR",
2769                  SPR_NOACCESS, SPR_NOACCESS,
2770                  &spr_read_generic, &spr_write_generic,
2771                  0x00000000);
2772     /* XXX : not implemented */
2773     spr_register(env, SPR_MPC_IC_DAT, "IC_DAT",
2774                  SPR_NOACCESS, SPR_NOACCESS,
2775                  &spr_read_generic, &spr_write_generic,
2776                  0x00000000);
2777     /* XXX : not implemented */
2778     spr_register(env, SPR_MPC_DC_CST, "DC_CST",
2779                  SPR_NOACCESS, SPR_NOACCESS,
2780                  &spr_read_generic, &spr_write_generic,
2781                  0x00000000);
2782     /* XXX : not implemented */
2783     spr_register(env, SPR_MPC_DC_ADR, "DC_ADR",
2784                  SPR_NOACCESS, SPR_NOACCESS,
2785                  &spr_read_generic, &spr_write_generic,
2786                  0x00000000);
2787     /* XXX : not implemented */
2788     spr_register(env, SPR_MPC_DC_DAT, "DC_DAT",
2789                  SPR_NOACCESS, SPR_NOACCESS,
2790                  &spr_read_generic, &spr_write_generic,
2791                  0x00000000);
2792     /* XXX : not implemented */
2793     spr_register(env, SPR_MPC_MI_CTR, "MI_CTR",
2794                  SPR_NOACCESS, SPR_NOACCESS,
2795                  &spr_read_generic, &spr_write_generic,
2796                  0x00000000);
2797     /* XXX : not implemented */
2798     spr_register(env, SPR_MPC_MI_AP, "MI_AP",
2799                  SPR_NOACCESS, SPR_NOACCESS,
2800                  &spr_read_generic, &spr_write_generic,
2801                  0x00000000);
2802     /* XXX : not implemented */
2803     spr_register(env, SPR_MPC_MI_EPN, "MI_EPN",
2804                  SPR_NOACCESS, SPR_NOACCESS,
2805                  &spr_read_generic, &spr_write_generic,
2806                  0x00000000);
2807     /* XXX : not implemented */
2808     spr_register(env, SPR_MPC_MI_TWC, "MI_TWC",
2809                  SPR_NOACCESS, SPR_NOACCESS,
2810                  &spr_read_generic, &spr_write_generic,
2811                  0x00000000);
2812     /* XXX : not implemented */
2813     spr_register(env, SPR_MPC_MI_RPN, "MI_RPN",
2814                  SPR_NOACCESS, SPR_NOACCESS,
2815                  &spr_read_generic, &spr_write_generic,
2816                  0x00000000);
2817     /* XXX : not implemented */
2818     spr_register(env, SPR_MPC_MI_DBCAM, "MI_DBCAM",
2819                  SPR_NOACCESS, SPR_NOACCESS,
2820                  &spr_read_generic, &spr_write_generic,
2821                  0x00000000);
2822     /* XXX : not implemented */
2823     spr_register(env, SPR_MPC_MI_DBRAM0, "MI_DBRAM0",
2824                  SPR_NOACCESS, SPR_NOACCESS,
2825                  &spr_read_generic, &spr_write_generic,
2826                  0x00000000);
2827     /* XXX : not implemented */
2828     spr_register(env, SPR_MPC_MI_DBRAM1, "MI_DBRAM1",
2829                  SPR_NOACCESS, SPR_NOACCESS,
2830                  &spr_read_generic, &spr_write_generic,
2831                  0x00000000);
2832     /* XXX : not implemented */
2833     spr_register(env, SPR_MPC_MD_CTR, "MD_CTR",
2834                  SPR_NOACCESS, SPR_NOACCESS,
2835                  &spr_read_generic, &spr_write_generic,
2836                  0x00000000);
2837     /* XXX : not implemented */
2838     spr_register(env, SPR_MPC_MD_CASID, "MD_CASID",
2839                  SPR_NOACCESS, SPR_NOACCESS,
2840                  &spr_read_generic, &spr_write_generic,
2841                  0x00000000);
2842     /* XXX : not implemented */
2843     spr_register(env, SPR_MPC_MD_AP, "MD_AP",
2844                  SPR_NOACCESS, SPR_NOACCESS,
2845                  &spr_read_generic, &spr_write_generic,
2846                  0x00000000);
2847     /* XXX : not implemented */
2848     spr_register(env, SPR_MPC_MD_EPN, "MD_EPN",
2849                  SPR_NOACCESS, SPR_NOACCESS,
2850                  &spr_read_generic, &spr_write_generic,
2851                  0x00000000);
2852     /* XXX : not implemented */
2853     spr_register(env, SPR_MPC_MD_TWB, "MD_TWB",
2854                  SPR_NOACCESS, SPR_NOACCESS,
2855                  &spr_read_generic, &spr_write_generic,
2856                  0x00000000);
2857     /* XXX : not implemented */
2858     spr_register(env, SPR_MPC_MD_TWC, "MD_TWC",
2859                  SPR_NOACCESS, SPR_NOACCESS,
2860                  &spr_read_generic, &spr_write_generic,
2861                  0x00000000);
2862     /* XXX : not implemented */
2863     spr_register(env, SPR_MPC_MD_RPN, "MD_RPN",
2864                  SPR_NOACCESS, SPR_NOACCESS,
2865                  &spr_read_generic, &spr_write_generic,
2866                  0x00000000);
2867     /* XXX : not implemented */
2868     spr_register(env, SPR_MPC_MD_TW, "MD_TW",
2869                  SPR_NOACCESS, SPR_NOACCESS,
2870                  &spr_read_generic, &spr_write_generic,
2871                  0x00000000);
2872     /* XXX : not implemented */
2873     spr_register(env, SPR_MPC_MD_DBCAM, "MD_DBCAM",
2874                  SPR_NOACCESS, SPR_NOACCESS,
2875                  &spr_read_generic, &spr_write_generic,
2876                  0x00000000);
2877     /* XXX : not implemented */
2878     spr_register(env, SPR_MPC_MD_DBRAM0, "MD_DBRAM0",
2879                  SPR_NOACCESS, SPR_NOACCESS,
2880                  &spr_read_generic, &spr_write_generic,
2881                  0x00000000);
2882     /* XXX : not implemented */
2883     spr_register(env, SPR_MPC_MD_DBRAM1, "MD_DBRAM1",
2884                  SPR_NOACCESS, SPR_NOACCESS,
2885                  &spr_read_generic, &spr_write_generic,
2886                  0x00000000);
2887 }
2888
2889 /*
2890  * AMR     => SPR 29 (Power 2.04)
2891  * CTRL    => SPR 136 (Power 2.04)
2892  * CTRL    => SPR 152 (Power 2.04)
2893  * SCOMC   => SPR 276 (64 bits ?)
2894  * SCOMD   => SPR 277 (64 bits ?)
2895  * TBU40   => SPR 286 (Power 2.04 hypv)
2896  * HSPRG0  => SPR 304 (Power 2.04 hypv)
2897  * HSPRG1  => SPR 305 (Power 2.04 hypv)
2898  * HDSISR  => SPR 306 (Power 2.04 hypv)
2899  * HDAR    => SPR 307 (Power 2.04 hypv)
2900  * PURR    => SPR 309 (Power 2.04 hypv)
2901  * HDEC    => SPR 310 (Power 2.04 hypv)
2902  * HIOR    => SPR 311 (hypv)
2903  * RMOR    => SPR 312 (970)
2904  * HRMOR   => SPR 313 (Power 2.04 hypv)
2905  * HSRR0   => SPR 314 (Power 2.04 hypv)
2906  * HSRR1   => SPR 315 (Power 2.04 hypv)
2907  * LPIDR   => SPR 317 (970)
2908  * EPR     => SPR 702 (Power 2.04 emb)
2909  * perf    => 768-783 (Power 2.04)
2910  * perf    => 784-799 (Power 2.04)
2911  * PPR     => SPR 896 (Power 2.04)
2912  * DABRX   => 1015    (Power 2.04 hypv)
2913  * FPECR   => SPR 1022 (?)
2914  * ... and more (thermal management, performance counters, ...)
2915  */
2916
2917 /*****************************************************************************/
2918 /* Exception vectors models                                                  */
2919 static void init_excp_4xx_real(CPUPPCState *env)
2920 {
2921 #if !defined(CONFIG_USER_ONLY)
2922     env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000100;
2923     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
2924     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2925     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2926     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2927     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
2928     env->excp_vectors[POWERPC_EXCP_PIT]      = 0x00001000;
2929     env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00001010;
2930     env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00001020;
2931     env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00002000;
2932     env->ivor_mask = 0x0000FFF0UL;
2933     env->ivpr_mask = 0xFFFF0000UL;
2934     /* Hardware reset vector */
2935     env->hreset_vector = 0xFFFFFFFCUL;
2936 #endif
2937 }
2938
2939 static void init_excp_4xx_softmmu(CPUPPCState *env)
2940 {
2941 #if !defined(CONFIG_USER_ONLY)
2942     env->excp_vectors[POWERPC_EXCP_CRITICAL] = 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_SYSCALL]  = 0x00000C00;
2950     env->excp_vectors[POWERPC_EXCP_PIT]      = 0x00001000;
2951     env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00001010;
2952     env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00001020;
2953     env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00001100;
2954     env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00001200;
2955     env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00002000;
2956     env->ivor_mask = 0x0000FFF0UL;
2957     env->ivpr_mask = 0xFFFF0000UL;
2958     /* Hardware reset vector */
2959     env->hreset_vector = 0xFFFFFFFCUL;
2960 #endif
2961 }
2962
2963 static void init_excp_MPC5xx(CPUPPCState *env)
2964 {
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_EXTERNAL] = 0x00000500;
2969     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2970     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2971     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000900;
2972     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
2973     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
2974     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
2975     env->excp_vectors[POWERPC_EXCP_FPA]      = 0x00000E00;
2976     env->excp_vectors[POWERPC_EXCP_EMUL]     = 0x00001000;
2977     env->excp_vectors[POWERPC_EXCP_DABR]     = 0x00001C00;
2978     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001C00;
2979     env->excp_vectors[POWERPC_EXCP_MEXTBR]   = 0x00001E00;
2980     env->excp_vectors[POWERPC_EXCP_NMEXTBR]  = 0x00001F00;
2981     env->ivor_mask = 0x0000FFF0UL;
2982     env->ivpr_mask = 0xFFFF0000UL;
2983     /* Hardware reset vector */
2984     env->hreset_vector = 0x00000100UL;
2985 #endif
2986 }
2987
2988 static void init_excp_MPC8xx(CPUPPCState *env)
2989 {
2990 #if !defined(CONFIG_USER_ONLY)
2991     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
2992     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
2993     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
2994     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
2995     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2996     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
2997     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
2998     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000900;
2999     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3000     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3001     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3002     env->excp_vectors[POWERPC_EXCP_FPA]      = 0x00000E00;
3003     env->excp_vectors[POWERPC_EXCP_EMUL]     = 0x00001000;
3004     env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00001100;
3005     env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00001200;
3006     env->excp_vectors[POWERPC_EXCP_ITLBE]    = 0x00001300;
3007     env->excp_vectors[POWERPC_EXCP_DTLBE]    = 0x00001400;
3008     env->excp_vectors[POWERPC_EXCP_DABR]     = 0x00001C00;
3009     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001C00;
3010     env->excp_vectors[POWERPC_EXCP_MEXTBR]   = 0x00001E00;
3011     env->excp_vectors[POWERPC_EXCP_NMEXTBR]  = 0x00001F00;
3012     env->ivor_mask = 0x0000FFF0UL;
3013     env->ivpr_mask = 0xFFFF0000UL;
3014     /* Hardware reset vector */
3015     env->hreset_vector = 0x00000100UL;
3016 #endif
3017 }
3018
3019 static void init_excp_G2(CPUPPCState *env)
3020 {
3021 #if !defined(CONFIG_USER_ONLY)
3022     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3023     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3024     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3025     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3026     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3027     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3028     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3029     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3030     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3031     env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000A00;
3032     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3033     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3034     env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
3035     env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
3036     env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
3037     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3038     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3039     /* Hardware reset vector */
3040     env->hreset_vector = 0x00000100UL;
3041 #endif
3042 }
3043
3044 static void init_excp_e200(CPUPPCState *env, target_ulong ivpr_mask)
3045 {
3046 #if !defined(CONFIG_USER_ONLY)
3047     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000FFC;
3048     env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000000;
3049     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000000;
3050     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000000;
3051     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000000;
3052     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000000;
3053     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000000;
3054     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000000;
3055     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000000;
3056     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000000;
3057     env->excp_vectors[POWERPC_EXCP_APU]      = 0x00000000;
3058     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000000;
3059     env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00000000;
3060     env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00000000;
3061     env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00000000;
3062     env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00000000;
3063     env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00000000;
3064     env->excp_vectors[POWERPC_EXCP_SPEU]     = 0x00000000;
3065     env->excp_vectors[POWERPC_EXCP_EFPDI]    = 0x00000000;
3066     env->excp_vectors[POWERPC_EXCP_EFPRI]    = 0x00000000;
3067     env->ivor_mask = 0x0000FFF7UL;
3068     env->ivpr_mask = ivpr_mask;
3069     /* Hardware reset vector */
3070     env->hreset_vector = 0xFFFFFFFCUL;
3071 #endif
3072 }
3073
3074 static void init_excp_BookE(CPUPPCState *env)
3075 {
3076 #if !defined(CONFIG_USER_ONLY)
3077     env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000000;
3078     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000000;
3079     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000000;
3080     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000000;
3081     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000000;
3082     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000000;
3083     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000000;
3084     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000000;
3085     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000000;
3086     env->excp_vectors[POWERPC_EXCP_APU]      = 0x00000000;
3087     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000000;
3088     env->excp_vectors[POWERPC_EXCP_FIT]      = 0x00000000;
3089     env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00000000;
3090     env->excp_vectors[POWERPC_EXCP_DTLB]     = 0x00000000;
3091     env->excp_vectors[POWERPC_EXCP_ITLB]     = 0x00000000;
3092     env->excp_vectors[POWERPC_EXCP_DEBUG]    = 0x00000000;
3093     env->ivor_mask = 0x0000FFF0UL;
3094     env->ivpr_mask = 0xFFFF0000UL;
3095     /* Hardware reset vector */
3096     env->hreset_vector = 0xFFFFFFFCUL;
3097 #endif
3098 }
3099
3100 static void init_excp_601(CPUPPCState *env)
3101 {
3102 #if !defined(CONFIG_USER_ONLY)
3103     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3104     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3105     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3106     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3107     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3108     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3109     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3110     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3111     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3112     env->excp_vectors[POWERPC_EXCP_IO]       = 0x00000A00;
3113     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3114     env->excp_vectors[POWERPC_EXCP_RUNM]     = 0x00002000;
3115     /* Hardware reset vector */
3116     env->hreset_vector = 0x00000100UL;
3117 #endif
3118 }
3119
3120 static void init_excp_602(CPUPPCState *env)
3121 {
3122 #if !defined(CONFIG_USER_ONLY)
3123     /* XXX: exception prefix has a special behavior on 602 */
3124     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3125     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3126     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3127     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3128     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3129     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3130     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3131     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3132     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3133     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3134     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3135     env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
3136     env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
3137     env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
3138     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3139     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3140     env->excp_vectors[POWERPC_EXCP_WDT]      = 0x00001500;
3141     env->excp_vectors[POWERPC_EXCP_EMUL]     = 0x00001600;
3142     /* Hardware reset vector */
3143     env->hreset_vector = 0x00000100UL;
3144 #endif
3145 }
3146
3147 static void init_excp_603(CPUPPCState *env)
3148 {
3149 #if !defined(CONFIG_USER_ONLY)
3150     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3151     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3152     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3153     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3154     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3155     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3156     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3157     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3158     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3159     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3160     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3161     env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
3162     env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
3163     env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
3164     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3165     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3166     /* Hardware reset vector */
3167     env->hreset_vector = 0x00000100UL;
3168 #endif
3169 }
3170
3171 static void init_excp_604(CPUPPCState *env)
3172 {
3173 #if !defined(CONFIG_USER_ONLY)
3174     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3175     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3176     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3177     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
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_SYSCALL]  = 0x00000C00;
3184     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3185     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3186     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3187     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3188     /* Hardware reset vector */
3189     env->hreset_vector = 0x00000100UL;
3190 #endif
3191 }
3192
3193 static void init_excp_7x0(CPUPPCState *env)
3194 {
3195 #if !defined(CONFIG_USER_ONLY)
3196     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3197     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3198     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3199     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3200     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3201     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3202     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3203     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3204     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3205     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3206     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3207     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3208     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3209     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3210     env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
3211     /* Hardware reset vector */
3212     env->hreset_vector = 0x00000100UL;
3213 #endif
3214 }
3215
3216 static void init_excp_750cl(CPUPPCState *env)
3217 {
3218 #if !defined(CONFIG_USER_ONLY)
3219     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3220     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3221     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3222     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3223     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3224     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3225     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3226     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3227     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3228     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3229     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3230     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3231     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3232     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3233     /* Hardware reset vector */
3234     env->hreset_vector = 0x00000100UL;
3235 #endif
3236 }
3237
3238 static void init_excp_750cx(CPUPPCState *env)
3239 {
3240 #if !defined(CONFIG_USER_ONLY)
3241     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3242     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3243     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3244     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3245     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3246     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3247     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3248     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3249     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3250     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3251     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3252     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3253     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3254     env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
3255     /* Hardware reset vector */
3256     env->hreset_vector = 0x00000100UL;
3257 #endif
3258 }
3259
3260 /* XXX: Check if this is correct */
3261 static void init_excp_7x5(CPUPPCState *env)
3262 {
3263 #if !defined(CONFIG_USER_ONLY)
3264     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3265     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3266     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3267     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3268     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3269     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3270     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3271     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3272     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3273     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3274     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3275     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3276     env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
3277     env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
3278     env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
3279     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3280     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3281     env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
3282     /* Hardware reset vector */
3283     env->hreset_vector = 0x00000100UL;
3284 #endif
3285 }
3286
3287 static void init_excp_7400(CPUPPCState *env)
3288 {
3289 #if !defined(CONFIG_USER_ONLY)
3290     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3291     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3292     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3293     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3294     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3295     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3296     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3297     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3298     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3299     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3300     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3301     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3302     env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
3303     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3304     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3305     env->excp_vectors[POWERPC_EXCP_VPUA]     = 0x00001600;
3306     env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001700;
3307     /* Hardware reset vector */
3308     env->hreset_vector = 0x00000100UL;
3309 #endif
3310 }
3311
3312 static void init_excp_7450(CPUPPCState *env)
3313 {
3314 #if !defined(CONFIG_USER_ONLY)
3315     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3316     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3317     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3318     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3319     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3320     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3321     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3322     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3323     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3324     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3325     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3326     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3327     env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
3328     env->excp_vectors[POWERPC_EXCP_IFTLB]    = 0x00001000;
3329     env->excp_vectors[POWERPC_EXCP_DLTLB]    = 0x00001100;
3330     env->excp_vectors[POWERPC_EXCP_DSTLB]    = 0x00001200;
3331     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3332     env->excp_vectors[POWERPC_EXCP_SMI]      = 0x00001400;
3333     env->excp_vectors[POWERPC_EXCP_VPUA]     = 0x00001600;
3334     /* Hardware reset vector */
3335     env->hreset_vector = 0x00000100UL;
3336 #endif
3337 }
3338
3339 #if defined(TARGET_PPC64)
3340 static void init_excp_970(CPUPPCState *env)
3341 {
3342 #if !defined(CONFIG_USER_ONLY)
3343     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3344     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3345     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3346     env->excp_vectors[POWERPC_EXCP_DSEG]     = 0x00000380;
3347     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3348     env->excp_vectors[POWERPC_EXCP_ISEG]     = 0x00000480;
3349     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3350     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3351     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3352     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3353     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3354     env->excp_vectors[POWERPC_EXCP_HDECR]    = 0x00000980;
3355     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3356     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3357     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3358     env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
3359     env->excp_vectors[POWERPC_EXCP_IABR]     = 0x00001300;
3360     env->excp_vectors[POWERPC_EXCP_MAINT]    = 0x00001600;
3361     env->excp_vectors[POWERPC_EXCP_VPUA]     = 0x00001700;
3362     env->excp_vectors[POWERPC_EXCP_THERM]    = 0x00001800;
3363     /* Hardware reset vector */
3364     env->hreset_vector = 0x0000000000000100ULL;
3365 #endif
3366 }
3367
3368 static void init_excp_POWER7(CPUPPCState *env)
3369 {
3370 #if !defined(CONFIG_USER_ONLY)
3371     env->excp_vectors[POWERPC_EXCP_RESET]    = 0x00000100;
3372     env->excp_vectors[POWERPC_EXCP_MCHECK]   = 0x00000200;
3373     env->excp_vectors[POWERPC_EXCP_DSI]      = 0x00000300;
3374     env->excp_vectors[POWERPC_EXCP_DSEG]     = 0x00000380;
3375     env->excp_vectors[POWERPC_EXCP_ISI]      = 0x00000400;
3376     env->excp_vectors[POWERPC_EXCP_ISEG]     = 0x00000480;
3377     env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3378     env->excp_vectors[POWERPC_EXCP_ALIGN]    = 0x00000600;
3379     env->excp_vectors[POWERPC_EXCP_PROGRAM]  = 0x00000700;
3380     env->excp_vectors[POWERPC_EXCP_FPU]      = 0x00000800;
3381     env->excp_vectors[POWERPC_EXCP_DECR]     = 0x00000900;
3382     env->excp_vectors[POWERPC_EXCP_HDECR]    = 0x00000980;
3383     env->excp_vectors[POWERPC_EXCP_SYSCALL]  = 0x00000C00;
3384     env->excp_vectors[POWERPC_EXCP_TRACE]    = 0x00000D00;
3385     env->excp_vectors[POWERPC_EXCP_HDSI]     = 0x00000E00;
3386     env->excp_vectors[POWERPC_EXCP_HISI]     = 0x00000E20;
3387     env->excp_vectors[POWERPC_EXCP_HV_EMU]   = 0x00000E40;
3388     env->excp_vectors[POWERPC_EXCP_HV_MAINT] = 0x00000E60;
3389     env->excp_vectors[POWERPC_EXCP_PERFM]    = 0x00000F00;
3390     env->excp_vectors[POWERPC_EXCP_VPU]      = 0x00000F20;
3391     env->excp_vectors[POWERPC_EXCP_VSXU]     = 0x00000F40;
3392     /* Hardware reset vector */
3393     env->hreset_vector = 0x0000000000000100ULL;
3394 #endif
3395 }
3396
3397 static void init_excp_POWER8(CPUPPCState *env)
3398 {
3399     init_excp_POWER7(env);
3400
3401 #if !defined(CONFIG_USER_ONLY)
3402     env->excp_vectors[POWERPC_EXCP_SDOOR]    = 0x00000A00;
3403     env->excp_vectors[POWERPC_EXCP_FU]       = 0x00000F60;
3404     env->excp_vectors[POWERPC_EXCP_HV_FU]    = 0x00000F80;
3405     env->excp_vectors[POWERPC_EXCP_SDOOR_HV] = 0x00000E80;
3406 #endif
3407 }
3408
3409 static void init_excp_POWER9(CPUPPCState *env)
3410 {
3411     init_excp_POWER8(env);
3412
3413 #if !defined(CONFIG_USER_ONLY)
3414     env->excp_vectors[POWERPC_EXCP_HVIRT]    = 0x00000EA0;
3415     env->excp_vectors[POWERPC_EXCP_SYSCALL_VECTORED] = 0x00000000;
3416 #endif
3417 }
3418
3419 static void init_excp_POWER10(CPUPPCState *env)
3420 {
3421     init_excp_POWER9(env);
3422 }
3423
3424 #endif
3425
3426 /*****************************************************************************/
3427 /* Power management enable checks                                            */
3428 static int check_pow_none(CPUPPCState *env)
3429 {
3430     return 0;
3431 }
3432
3433 static int check_pow_nocheck(CPUPPCState *env)
3434 {
3435     return 1;
3436 }
3437
3438 static int check_pow_hid0(CPUPPCState *env)
3439 {
3440     if (env->spr[SPR_HID0] & 0x00E00000) {
3441         return 1;
3442     }
3443
3444     return 0;
3445 }
3446
3447 static int check_pow_hid0_74xx(CPUPPCState *env)
3448 {
3449     if (env->spr[SPR_HID0] & 0x00600000) {
3450         return 1;