]> git.proxmox.com Git - qemu.git/blob - target-ppc/translate_init.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'mdroth/qga-pull-3-11-2013' into staging
[qemu.git] / target-ppc / translate_init.c
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/bfd.h"
22 #include "exec/gdbstub.h"
23 #include <sysemu/kvm.h>
24 #include "kvm_ppc.h"
25 #include "sysemu/arch_init.h"
26 #include "sysemu/cpus.h"
27 #include "cpu-models.h"
28
29 //#define PPC_DUMP_CPU
30 //#define PPC_DEBUG_SPR
31 //#define PPC_DUMP_SPR_ACCESSES
32
33 /* For user-mode emulation, we don't emulate any IRQ controller */
34 #if defined(CONFIG_USER_ONLY)
35 #define PPC_IRQ_INIT_FN(name) \
36 static inline void glue(glue(ppc, name),_irq_init) (CPUPPCState *env) \
37 { \
38 }
39 #else
40 #define PPC_IRQ_INIT_FN(name) \
41 void glue(glue(ppc, name),_irq_init) (CPUPPCState *env);
42 #endif
43
44 PPC_IRQ_INIT_FN(40x);
45 PPC_IRQ_INIT_FN(6xx);
46 PPC_IRQ_INIT_FN(970);
47 PPC_IRQ_INIT_FN(POWER7);
48 PPC_IRQ_INIT_FN(e500);
49
50 /* Generic callbacks:
51 * do nothing but store/retrieve spr value
52 */
53 static void spr_load_dump_spr(int sprn)
54 {
55 #ifdef PPC_DUMP_SPR_ACCESSES
56 TCGv_i32 t0 = tcg_const_i32(sprn);
57 gen_helper_load_dump_spr(cpu_env, t0);
58 tcg_temp_free_i32(t0);
59 #endif
60 }
61
62 static void spr_read_generic (void *opaque, int gprn, int sprn)
63 {
64 gen_load_spr(cpu_gpr[gprn], sprn);
65 spr_load_dump_spr(sprn);
66 }
67
68 static void spr_store_dump_spr(int sprn)
69 {
70 #ifdef PPC_DUMP_SPR_ACCESSES
71 TCGv_i32 t0 = tcg_const_i32(sprn);
72 gen_helper_store_dump_spr(cpu_env, t0);
73 tcg_temp_free_i32(t0);
74 #endif
75 }
76
77 static void spr_write_generic (void *opaque, int sprn, int gprn)
78 {
79 gen_store_spr(sprn, cpu_gpr[gprn]);
80 spr_store_dump_spr(sprn);
81 }
82
83 #if !defined(CONFIG_USER_ONLY)
84 static void spr_write_generic32(void *opaque, int sprn, int gprn)
85 {
86 #ifdef TARGET_PPC64
87 TCGv t0 = tcg_temp_new();
88 tcg_gen_ext32u_tl(t0, cpu_gpr[gprn]);
89 gen_store_spr(sprn, t0);
90 tcg_temp_free(t0);
91 spr_store_dump_spr(sprn);
92 #else
93 spr_write_generic(opaque, sprn, gprn);
94 #endif
95 }
96
97 static void spr_write_clear (void *opaque, int sprn, int gprn)
98 {
99 TCGv t0 = tcg_temp_new();
100 TCGv t1 = tcg_temp_new();
101 gen_load_spr(t0, sprn);
102 tcg_gen_neg_tl(t1, cpu_gpr[gprn]);
103 tcg_gen_and_tl(t0, t0, t1);
104 gen_store_spr(sprn, t0);
105 tcg_temp_free(t0);
106 tcg_temp_free(t1);
107 }
108 #endif
109
110 /* SPR common to all PowerPC */
111 /* XER */
112 static void spr_read_xer (void *opaque, int gprn, int sprn)
113 {
114 gen_read_xer(cpu_gpr[gprn]);
115 }
116
117 static void spr_write_xer (void *opaque, int sprn, int gprn)
118 {
119 gen_write_xer(cpu_gpr[gprn]);
120 }
121
122 /* LR */
123 static void spr_read_lr (void *opaque, int gprn, int sprn)
124 {
125 tcg_gen_mov_tl(cpu_gpr[gprn], cpu_lr);
126 }
127
128 static void spr_write_lr (void *opaque, int sprn, int gprn)
129 {
130 tcg_gen_mov_tl(cpu_lr, cpu_gpr[gprn]);
131 }
132
133 /* CFAR */
134 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
135 static void spr_read_cfar (void *opaque, int gprn, int sprn)
136 {
137 tcg_gen_mov_tl(cpu_gpr[gprn], cpu_cfar);
138 }
139
140 static void spr_write_cfar (void *opaque, int sprn, int gprn)
141 {
142 tcg_gen_mov_tl(cpu_cfar, cpu_gpr[gprn]);
143 }
144 #endif /* defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY) */
145
146 /* CTR */
147 static void spr_read_ctr (void *opaque, int gprn, int sprn)
148 {
149 tcg_gen_mov_tl(cpu_gpr[gprn], cpu_ctr);
150 }
151
152 static void spr_write_ctr (void *opaque, int sprn, int gprn)
153 {
154 tcg_gen_mov_tl(cpu_ctr, cpu_gpr[gprn]);
155 }
156
157 /* User read access to SPR */
158 /* USPRx */
159 /* UMMCRx */
160 /* UPMCx */
161 /* USIA */
162 /* UDECR */
163 static void spr_read_ureg (void *opaque, int gprn, int sprn)
164 {
165 gen_load_spr(cpu_gpr[gprn], sprn + 0x10);
166 }
167
168 /* SPR common to all non-embedded PowerPC */
169 /* DECR */
170 #if !defined(CONFIG_USER_ONLY)
171 static void spr_read_decr (void *opaque, int gprn, int sprn)
172 {
173 if (use_icount) {
174 gen_io_start();
175 }
176 gen_helper_load_decr(cpu_gpr[gprn], cpu_env);
177 if (use_icount) {
178 gen_io_end();
179 gen_stop_exception(opaque);
180 }
181 }
182
183 static void spr_write_decr (void *opaque, int sprn, int gprn)
184 {
185 if (use_icount) {
186 gen_io_start();
187 }
188 gen_helper_store_decr(cpu_env, cpu_gpr[gprn]);
189 if (use_icount) {
190 gen_io_end();
191 gen_stop_exception(opaque);
192 }
193 }
194 #endif
195
196 /* SPR common to all non-embedded PowerPC, except 601 */
197 /* Time base */
198 static void spr_read_tbl (void *opaque, int gprn, int sprn)
199 {
200 if (use_icount) {
201 gen_io_start();
202 }
203 gen_helper_load_tbl(cpu_gpr[gprn], cpu_env);
204 if (use_icount) {
205 gen_io_end();
206 gen_stop_exception(opaque);
207 }
208 }
209
210 static void spr_read_tbu (void *opaque, int gprn, int sprn)
211 {
212 if (use_icount) {
213 gen_io_start();
214 }
215 gen_helper_load_tbu(cpu_gpr[gprn], cpu_env);
216 if (use_icount) {
217 gen_io_end();
218 gen_stop_exception(opaque);
219 }
220 }
221
222 __attribute__ (( unused ))
223 static void spr_read_atbl (void *opaque, int gprn, int sprn)
224 {
225 gen_helper_load_atbl(cpu_gpr[gprn], cpu_env);
226 }
227
228 __attribute__ (( unused ))
229 static void spr_read_atbu (void *opaque, int gprn, int sprn)
230 {
231 gen_helper_load_atbu(cpu_gpr[gprn], cpu_env);
232 }
233
234 #if !defined(CONFIG_USER_ONLY)
235 static void spr_write_tbl (void *opaque, int sprn, int gprn)
236 {
237 if (use_icount) {
238 gen_io_start();
239 }
240 gen_helper_store_tbl(cpu_env, cpu_gpr[gprn]);
241 if (use_icount) {
242 gen_io_end();
243 gen_stop_exception(opaque);
244 }
245 }
246
247 static void spr_write_tbu (void *opaque, int sprn, int gprn)
248 {
249 if (use_icount) {
250 gen_io_start();
251 }
252 gen_helper_store_tbu(cpu_env, cpu_gpr[gprn]);
253 if (use_icount) {
254 gen_io_end();
255 gen_stop_exception(opaque);
256 }
257 }
258
259 __attribute__ (( unused ))
260 static void spr_write_atbl (void *opaque, int sprn, int gprn)
261 {
262 gen_helper_store_atbl(cpu_env, cpu_gpr[gprn]);
263 }
264
265 __attribute__ (( unused ))
266 static void spr_write_atbu (void *opaque, int sprn, int gprn)
267 {
268 gen_helper_store_atbu(cpu_env, cpu_gpr[gprn]);
269 }
270
271 #if defined(TARGET_PPC64)
272 __attribute__ (( unused ))
273 static void spr_read_purr (void *opaque, int gprn, int sprn)
274 {
275 gen_helper_load_purr(cpu_gpr[gprn], cpu_env);
276 }
277 #endif
278 #endif
279
280 #if !defined(CONFIG_USER_ONLY)
281 /* IBAT0U...IBAT0U */
282 /* IBAT0L...IBAT7L */
283 static void spr_read_ibat (void *opaque, int gprn, int sprn)
284 {
285 tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
286 }
287
288 static void spr_read_ibat_h (void *opaque, int gprn, int sprn)
289 {
290 tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, IBAT[sprn & 1][(sprn - SPR_IBAT4U) / 2]));
291 }
292
293 static void spr_write_ibatu (void *opaque, int sprn, int gprn)
294 {
295 TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
296 gen_helper_store_ibatu(cpu_env, t0, cpu_gpr[gprn]);
297 tcg_temp_free_i32(t0);
298 }
299
300 static void spr_write_ibatu_h (void *opaque, int sprn, int gprn)
301 {
302 TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_IBAT4U) / 2) + 4);
303 gen_helper_store_ibatu(cpu_env, t0, cpu_gpr[gprn]);
304 tcg_temp_free_i32(t0);
305 }
306
307 static void spr_write_ibatl (void *opaque, int sprn, int gprn)
308 {
309 TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0L) / 2);
310 gen_helper_store_ibatl(cpu_env, t0, cpu_gpr[gprn]);
311 tcg_temp_free_i32(t0);
312 }
313
314 static void spr_write_ibatl_h (void *opaque, int sprn, int gprn)
315 {
316 TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_IBAT4L) / 2) + 4);
317 gen_helper_store_ibatl(cpu_env, t0, cpu_gpr[gprn]);
318 tcg_temp_free_i32(t0);
319 }
320
321 /* DBAT0U...DBAT7U */
322 /* DBAT0L...DBAT7L */
323 static void spr_read_dbat (void *opaque, int gprn, int sprn)
324 {
325 tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, DBAT[sprn & 1][(sprn - SPR_DBAT0U) / 2]));
326 }
327
328 static void spr_read_dbat_h (void *opaque, int gprn, int sprn)
329 {
330 tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, DBAT[sprn & 1][((sprn - SPR_DBAT4U) / 2) + 4]));
331 }
332
333 static void spr_write_dbatu (void *opaque, int sprn, int gprn)
334 {
335 TCGv_i32 t0 = tcg_const_i32((sprn - SPR_DBAT0U) / 2);
336 gen_helper_store_dbatu(cpu_env, t0, cpu_gpr[gprn]);
337 tcg_temp_free_i32(t0);
338 }
339
340 static void spr_write_dbatu_h (void *opaque, int sprn, int gprn)
341 {
342 TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_DBAT4U) / 2) + 4);
343 gen_helper_store_dbatu(cpu_env, t0, cpu_gpr[gprn]);
344 tcg_temp_free_i32(t0);
345 }
346
347 static void spr_write_dbatl (void *opaque, int sprn, int gprn)
348 {
349 TCGv_i32 t0 = tcg_const_i32((sprn - SPR_DBAT0L) / 2);
350 gen_helper_store_dbatl(cpu_env, t0, cpu_gpr[gprn]);
351 tcg_temp_free_i32(t0);
352 }
353
354 static void spr_write_dbatl_h (void *opaque, int sprn, int gprn)
355 {
356 TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_DBAT4L) / 2) + 4);
357 gen_helper_store_dbatl(cpu_env, t0, cpu_gpr[gprn]);
358 tcg_temp_free_i32(t0);
359 }
360
361 /* SDR1 */
362 static void spr_write_sdr1 (void *opaque, int sprn, int gprn)
363 {
364 gen_helper_store_sdr1(cpu_env, cpu_gpr[gprn]);
365 }
366
367 /* 64 bits PowerPC specific SPRs */
368 /* ASR */
369 #if defined(TARGET_PPC64)
370 static void spr_read_hior (void *opaque, int gprn, int sprn)
371 {
372 tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, excp_prefix));
373 }
374
375 static void spr_write_hior (void *opaque, int sprn, int gprn)
376 {
377 TCGv t0 = tcg_temp_new();
378 tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0x3FFFFF00000ULL);
379 tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_prefix));
380 tcg_temp_free(t0);
381 }
382
383 static void spr_read_asr (void *opaque, int gprn, int sprn)
384 {
385 tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, asr));
386 }
387
388 static void spr_write_asr (void *opaque, int sprn, int gprn)
389 {
390 gen_helper_store_asr(cpu_env, cpu_gpr[gprn]);
391 }
392 #endif
393 #endif
394
395 /* PowerPC 601 specific registers */
396 /* RTC */
397 static void spr_read_601_rtcl (void *opaque, int gprn, int sprn)
398 {
399 gen_helper_load_601_rtcl(cpu_gpr[gprn], cpu_env);
400 }
401
402 static void spr_read_601_rtcu (void *opaque, int gprn, int sprn)
403 {
404 gen_helper_load_601_rtcu(cpu_gpr[gprn], cpu_env);
405 }
406
407 #if !defined(CONFIG_USER_ONLY)
408 static void spr_write_601_rtcu (void *opaque, int sprn, int gprn)
409 {
410 gen_helper_store_601_rtcu(cpu_env, cpu_gpr[gprn]);
411 }
412
413 static void spr_write_601_rtcl (void *opaque, int sprn, int gprn)
414 {
415 gen_helper_store_601_rtcl(cpu_env, cpu_gpr[gprn]);
416 }
417
418 static void spr_write_hid0_601 (void *opaque, int sprn, int gprn)
419 {
420 DisasContext *ctx = opaque;
421
422 gen_helper_store_hid0_601(cpu_env, cpu_gpr[gprn]);
423 /* Must stop the translation as endianness may have changed */
424 gen_stop_exception(ctx);
425 }
426 #endif
427
428 /* Unified bats */
429 #if !defined(CONFIG_USER_ONLY)
430 static void spr_read_601_ubat (void *opaque, int gprn, int sprn)
431 {
432 tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
433 }
434
435 static void spr_write_601_ubatu (void *opaque, int sprn, int gprn)
436 {
437 TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
438 gen_helper_store_601_batl(cpu_env, t0, cpu_gpr[gprn]);
439 tcg_temp_free_i32(t0);
440 }
441
442 static void spr_write_601_ubatl (void *opaque, int sprn, int gprn)
443 {
444 TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
445 gen_helper_store_601_batu(cpu_env, t0, cpu_gpr[gprn]);
446 tcg_temp_free_i32(t0);
447 }
448 #endif
449
450 /* PowerPC 40x specific registers */
451 #if !defined(CONFIG_USER_ONLY)
452 static void spr_read_40x_pit (void *opaque, int gprn, int sprn)
453 {
454 gen_helper_load_40x_pit(cpu_gpr[gprn], cpu_env);
455 }
456
457 static void spr_write_40x_pit (void *opaque, int sprn, int gprn)
458 {
459 gen_helper_store_40x_pit(cpu_env, cpu_gpr[gprn]);
460 }
461
462 static void spr_write_40x_dbcr0 (void *opaque, int sprn, int gprn)
463 {
464 DisasContext *ctx = opaque;
465
466 gen_helper_store_40x_dbcr0(cpu_env, cpu_gpr[gprn]);
467 /* We must stop translation as we may have rebooted */
468 gen_stop_exception(ctx);
469 }
470
471 static void spr_write_40x_sler (void *opaque, int sprn, int gprn)
472 {
473 gen_helper_store_40x_sler(cpu_env, cpu_gpr[gprn]);
474 }
475
476 static void spr_write_booke_tcr (void *opaque, int sprn, int gprn)
477 {
478 gen_helper_store_booke_tcr(cpu_env, cpu_gpr[gprn]);
479 }
480
481 static void spr_write_booke_tsr (void *opaque, int sprn, int gprn)
482 {
483 gen_helper_store_booke_tsr(cpu_env, cpu_gpr[gprn]);
484 }
485 #endif
486
487 /* PowerPC 403 specific registers */
488 /* PBL1 / PBU1 / PBL2 / PBU2 */
489 #if !defined(CONFIG_USER_ONLY)
490 static void spr_read_403_pbr (void *opaque, int gprn, int sprn)
491 {
492 tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUPPCState, pb[sprn - SPR_403_PBL1]));
493 }
494
495 static void spr_write_403_pbr (void *opaque, int sprn, int gprn)
496 {
497 TCGv_i32 t0 = tcg_const_i32(sprn - SPR_403_PBL1);
498 gen_helper_store_403_pbr(cpu_env, t0, cpu_gpr[gprn]);
499 tcg_temp_free_i32(t0);
500 }
501
502 static void spr_write_pir (void *opaque, int sprn, int gprn)
503 {
504 TCGv t0 = tcg_temp_new();
505 tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0xF);
506 gen_store_spr(SPR_PIR, t0);
507 tcg_temp_free(t0);
508 }
509 #endif
510
511 /* SPE specific registers */
512 static void spr_read_spefscr (void *opaque, int gprn, int sprn)
513 {
514 TCGv_i32 t0 = tcg_temp_new_i32();
515 tcg_gen_ld_i32(t0, cpu_env, offsetof(CPUPPCState, spe_fscr));
516 tcg_gen_extu_i32_tl(cpu_gpr[gprn], t0);
517 tcg_temp_free_i32(t0);
518 }
519
520 static void spr_write_spefscr (void *opaque, int sprn, int gprn)
521 {
522 TCGv_i32 t0 = tcg_temp_new_i32();
523 tcg_gen_trunc_tl_i32(t0, cpu_gpr[gprn]);
524 tcg_gen_st_i32(t0, cpu_env, offsetof(CPUPPCState, spe_fscr));
525 tcg_temp_free_i32(t0);
526 }
527
528 #if !defined(CONFIG_USER_ONLY)
529 /* Callback used to write the exception vector base */
530 static void spr_write_excp_prefix (void *opaque, int sprn, int gprn)
531 {
532 TCGv t0 = tcg_temp_new();
533 tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUPPCState, ivpr_mask));
534 tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
535 tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_prefix));
536 gen_store_spr(sprn, t0);
537 tcg_temp_free(t0);
538 }
539
540 static void spr_write_excp_vector (void *opaque, int sprn, int gprn)
541 {
542 DisasContext *ctx = opaque;
543 int sprn_offs;
544
545 if (sprn >= SPR_BOOKE_IVOR0 && sprn <= SPR_BOOKE_IVOR15) {
546 sprn_offs = sprn - SPR_BOOKE_IVOR0;
547 } else if (sprn >= SPR_BOOKE_IVOR32 && sprn <= SPR_BOOKE_IVOR37) {
548 sprn_offs = sprn - SPR_BOOKE_IVOR32 + 32;
549 } else if (sprn >= SPR_BOOKE_IVOR38 && sprn <= SPR_BOOKE_IVOR42) {
550 sprn_offs = sprn - SPR_BOOKE_IVOR38 + 38;
551 } else {
552 printf("Trying to write an unknown exception vector %d %03x\n",
553 sprn, sprn);
554 gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
555 return;
556 }
557
558 TCGv t0 = tcg_temp_new();
559 tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUPPCState, ivor_mask));
560 tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
561 tcg_gen_st_tl(t0, cpu_env, offsetof(CPUPPCState, excp_vectors[sprn_offs]));
562 gen_store_spr(sprn, t0);
563 tcg_temp_free(t0);
564 }
565 #endif
566
567 static inline void vscr_init (CPUPPCState *env, uint32_t val)
568 {
569 env->vscr = val;
570 /* Altivec always uses round-to-nearest */
571 set_float_rounding_mode(float_round_nearest_even, &env->vec_status);
572 set_flush_to_zero(vscr_nj, &env->vec_status);
573 }
574
575 #ifdef CONFIG_USER_ONLY
576 #define spr_register_kvm(env, num, name, uea_read, uea_write, \
577 oea_read, oea_write, one_reg_id, initial_value) \
578 _spr_register(env, num, name, uea_read, uea_write, initial_value)
579 #else
580 #if !defined(CONFIG_KVM)
581 #define spr_register_kvm(env, num, name, uea_read, uea_write, \
582 oea_read, oea_write, one_reg_id, initial_value) \
583 _spr_register(env, num, name, uea_read, uea_write, \
584 oea_read, oea_write, initial_value)
585 #else
586 #define spr_register_kvm(env, num, name, uea_read, uea_write, \
587 oea_read, oea_write, one_reg_id, initial_value) \
588 _spr_register(env, num, name, uea_read, uea_write, \
589 oea_read, oea_write, one_reg_id, initial_value)
590 #endif
591 #endif
592
593 #define spr_register(env, num, name, uea_read, uea_write, \
594 oea_read, oea_write, initial_value) \
595 spr_register_kvm(env, num, name, uea_read, uea_write, \
596 oea_read, oea_write, 0, initial_value)
597
598 static inline void _spr_register(CPUPPCState *env, int num,
599 const char *name,
600 void (*uea_read)(void *opaque, int gprn, int sprn),
601 void (*uea_write)(void *opaque, int sprn, int gprn),
602 #if !defined(CONFIG_USER_ONLY)
603
604 void (*oea_read)(void *opaque, int gprn, int sprn),
605 void (*oea_write)(void *opaque, int sprn, int gprn),
606 #endif
607 #if defined(CONFIG_KVM)
608 uint64_t one_reg_id,
609 #endif
610 target_ulong initial_value)
611 {
612 ppc_spr_t *spr;
613
614 spr = &env->spr_cb[num];
615 if (spr->name != NULL ||env-> spr[num] != 0x00000000 ||
616 #if !defined(CONFIG_USER_ONLY)
617 spr->oea_read != NULL || spr->oea_write != NULL ||
618 #endif
619 spr->uea_read != NULL || spr->uea_write != NULL) {
620 printf("Error: Trying to register SPR %d (%03x) twice !\n", num, num);
621 exit(1);
622 }
623 #if defined(PPC_DEBUG_SPR)
624 printf("*** register spr %d (%03x) %s val " TARGET_FMT_lx "\n", num, num,
625 name, initial_value);
626 #endif
627 spr->name = name;
628 spr->uea_read = uea_read;
629 spr->uea_write = uea_write;
630 #if !defined(CONFIG_USER_ONLY)
631 spr->oea_read = oea_read;
632 spr->oea_write = oea_write;
633 #endif
634 env->spr[num] = initial_value;
635 }
636
637 /* Generic PowerPC SPRs */
638 static void gen_spr_generic (CPUPPCState *env)
639 {
640 /* Integer processing */
641 spr_register(env, SPR_XER, "XER",
642 &spr_read_xer, &spr_write_xer,
643 &spr_read_xer, &spr_write_xer,
644 0x00000000);
645 /* Branch contol */
646 spr_register(env, SPR_LR, "LR",
647 &spr_read_lr, &spr_write_lr,
648 &spr_read_lr, &spr_write_lr,
649 0x00000000);
650 spr_register(env, SPR_CTR, "CTR",
651 &spr_read_ctr, &spr_write_ctr,
652 &spr_read_ctr, &spr_write_ctr,
653 0x00000000);
654 /* Interrupt processing */
655 spr_register(env, SPR_SRR0, "SRR0",
656 SPR_NOACCESS, SPR_NOACCESS,
657 &spr_read_generic, &spr_write_generic,
658 0x00000000);
659 spr_register(env, SPR_SRR1, "SRR1",
660 SPR_NOACCESS, SPR_NOACCESS,
661 &spr_read_generic, &spr_write_generic,
662 0x00000000);
663 /* Processor control */
664 spr_register(env, SPR_SPRG0, "SPRG0",
665 SPR_NOACCESS, SPR_NOACCESS,
666 &spr_read_generic, &spr_write_generic,
667 0x00000000);
668 spr_register(env, SPR_SPRG1, "SPRG1",
669 SPR_NOACCESS, SPR_NOACCESS,
670 &spr_read_generic, &spr_write_generic,
671 0x00000000);
672 spr_register(env, SPR_SPRG2, "SPRG2",
673 SPR_NOACCESS, SPR_NOACCESS,
674 &spr_read_generic, &spr_write_generic,
675 0x00000000);
676 spr_register(env, SPR_SPRG3, "SPRG3",
677 SPR_NOACCESS, SPR_NOACCESS,
678 &spr_read_generic, &spr_write_generic,
679 0x00000000);
680 }
681
682 /* SPR common to all non-embedded PowerPC, including 601 */
683 static void gen_spr_ne_601 (CPUPPCState *env)
684 {
685 /* Exception processing */
686 spr_register_kvm(env, SPR_DSISR, "DSISR",
687 SPR_NOACCESS, SPR_NOACCESS,
688 &spr_read_generic, &spr_write_generic,
689 KVM_REG_PPC_DSISR, 0x00000000);
690 spr_register_kvm(env, SPR_DAR, "DAR",
691 SPR_NOACCESS, SPR_NOACCESS,
692 &spr_read_generic, &spr_write_generic,
693 KVM_REG_PPC_DAR, 0x00000000);
694 /* Timer */
695 spr_register(env, SPR_DECR, "DECR",
696 SPR_NOACCESS, SPR_NOACCESS,
697 &spr_read_decr, &spr_write_decr,
698 0x00000000);
699 /* Memory management */
700 spr_register(env, SPR_SDR1, "SDR1",
701 SPR_NOACCESS, SPR_NOACCESS,
702 &spr_read_generic, &spr_write_sdr1,
703 0x00000000);
704 }
705
706 /* BATs 0-3 */
707 static void gen_low_BATs (CPUPPCState *env)
708 {
709 #if !defined(CONFIG_USER_ONLY)
710 spr_register(env, SPR_IBAT0U, "IBAT0U",
711 SPR_NOACCESS, SPR_NOACCESS,
712 &spr_read_ibat, &spr_write_ibatu,
713 0x00000000);
714 spr_register(env, SPR_IBAT0L, "IBAT0L",
715 SPR_NOACCESS, SPR_NOACCESS,
716 &spr_read_ibat, &spr_write_ibatl,
717 0x00000000);
718 spr_register(env, SPR_IBAT1U, "IBAT1U",
719 SPR_NOACCESS, SPR_NOACCESS,
720 &spr_read_ibat, &spr_write_ibatu,
721 0x00000000);
722 spr_register(env, SPR_IBAT1L, "IBAT1L",
723 SPR_NOACCESS, SPR_NOACCESS,
724 &spr_read_ibat, &spr_write_ibatl,
725 0x00000000);
726 spr_register(env, SPR_IBAT2U, "IBAT2U",
727 SPR_NOACCESS, SPR_NOACCESS,
728 &spr_read_ibat, &spr_write_ibatu,
729 0x00000000);
730 spr_register(env, SPR_IBAT2L, "IBAT2L",
731 SPR_NOACCESS, SPR_NOACCESS,
732 &spr_read_ibat, &spr_write_ibatl,
733 0x00000000);
734 spr_register(env, SPR_IBAT3U, "IBAT3U",
735 SPR_NOACCESS, SPR_NOACCESS,
736 &spr_read_ibat, &spr_write_ibatu,
737 0x00000000);
738 spr_register(env, SPR_IBAT3L, "IBAT3L",
739 SPR_NOACCESS, SPR_NOACCESS,
740 &spr_read_ibat, &spr_write_ibatl,
741 0x00000000);
742 spr_register(env, SPR_DBAT0U, "DBAT0U",
743 SPR_NOACCESS, SPR_NOACCESS,
744 &spr_read_dbat, &spr_write_dbatu,
745 0x00000000);
746 spr_register(env, SPR_DBAT0L, "DBAT0L",
747 SPR_NOACCESS, SPR_NOACCESS,
748 &spr_read_dbat, &spr_write_dbatl,
749 0x00000000);
750 spr_register(env, SPR_DBAT1U, "DBAT1U",
751 SPR_NOACCESS, SPR_NOACCESS,
752 &spr_read_dbat, &spr_write_dbatu,
753 0x00000000);
754 spr_register(env, SPR_DBAT1L, "DBAT1L",
755 SPR_NOACCESS, SPR_NOACCESS,
756 &spr_read_dbat, &spr_write_dbatl,
757 0x00000000);
758 spr_register(env, SPR_DBAT2U, "DBAT2U",
759 SPR_NOACCESS, SPR_NOACCESS,
760 &spr_read_dbat, &spr_write_dbatu,
761 0x00000000);
762 spr_register(env, SPR_DBAT2L, "DBAT2L",
763 SPR_NOACCESS, SPR_NOACCESS,
764 &spr_read_dbat, &spr_write_dbatl,
765 0x00000000);
766 spr_register(env, SPR_DBAT3U, "DBAT3U",
767 SPR_NOACCESS, SPR_NOACCESS,
768 &spr_read_dbat, &spr_write_dbatu,
769 0x00000000);
770 spr_register(env, SPR_DBAT3L, "DBAT3L",
771 SPR_NOACCESS, SPR_NOACCESS,
772 &spr_read_dbat, &spr_write_dbatl,
773 0x00000000);
774 env->nb_BATs += 4;
775 #endif
776 }
777
778 /* BATs 4-7 */
779 static void gen_high_BATs (CPUPPCState *env)
780 {
781 #if !defined(CONFIG_USER_ONLY)
782 spr_register(env, SPR_IBAT4U, "IBAT4U",
783 SPR_NOACCESS, SPR_NOACCESS,
784 &spr_read_ibat_h, &spr_write_ibatu_h,
785 0x00000000);
786 spr_register(env, SPR_IBAT4L, "IBAT4L",
787 SPR_NOACCESS, SPR_NOACCESS,
788 &spr_read_ibat_h, &spr_write_ibatl_h,
789 0x00000000);
790 spr_register(env, SPR_IBAT5U, "IBAT5U",
791 SPR_NOACCESS, SPR_NOACCESS,
792 &spr_read_ibat_h, &spr_write_ibatu_h,
793 0x00000000);
794 spr_register(env, SPR_IBAT5L, "IBAT5L",
795 SPR_NOACCESS, SPR_NOACCESS,
796 &spr_read_ibat_h, &spr_write_ibatl_h,
797 0x00000000);
798 spr_register(env, SPR_IBAT6U, "IBAT6U",
799 SPR_NOACCESS, SPR_NOACCESS,
800 &spr_read_ibat_h, &spr_write_ibatu_h,
801 0x00000000);
802 spr_register(env, SPR_IBAT6L, "IBAT6L",
803 SPR_NOACCESS, SPR_NOACCESS,
804 &spr_read_ibat_h, &spr_write_ibatl_h,
805 0x00000000);
806 spr_register(env, SPR_IBAT7U, "IBAT7U",
807 SPR_NOACCESS, SPR_NOACCESS,
808 &spr_read_ibat_h, &spr_write_ibatu_h,
809 0x00000000);
810 spr_register(env, SPR_IBAT7L, "IBAT7L",
811 SPR_NOACCESS, SPR_NOACCESS,
812 &spr_read_ibat_h, &spr_write_ibatl_h,
813 0x00000000);
814 spr_register(env, SPR_DBAT4U, "DBAT4U",
815 SPR_NOACCESS, SPR_NOACCESS,
816 &spr_read_dbat_h, &spr_write_dbatu_h,
817 0x00000000);
818 spr_register(env, SPR_DBAT4L, "DBAT4L",
819 SPR_NOACCESS, SPR_NOACCESS,
820 &spr_read_dbat_h, &spr_write_dbatl_h,
821 0x00000000);
822 spr_register(env, SPR_DBAT5U, "DBAT5U",
823 SPR_NOACCESS, SPR_NOACCESS,
824 &spr_read_dbat_h, &spr_write_dbatu_h,
825 0x00000000);
826 spr_register(env, SPR_DBAT5L, "DBAT5L",
827 SPR_NOACCESS, SPR_NOACCESS,
828 &spr_read_dbat_h, &spr_write_dbatl_h,
829 0x00000000);
830 spr_register(env, SPR_DBAT6U, "DBAT6U",
831 SPR_NOACCESS, SPR_NOACCESS,
832 &spr_read_dbat_h, &spr_write_dbatu_h,
833 0x00000000);
834 spr_register(env, SPR_DBAT6L, "DBAT6L",
835 SPR_NOACCESS, SPR_NOACCESS,
836 &spr_read_dbat_h, &spr_write_dbatl_h,
837 0x00000000);
838 spr_register(env, SPR_DBAT7U, "DBAT7U",
839 SPR_NOACCESS, SPR_NOACCESS,
840 &spr_read_dbat_h, &spr_write_dbatu_h,
841 0x00000000);
842 spr_register(env, SPR_DBAT7L, "DBAT7L",
843 SPR_NOACCESS, SPR_NOACCESS,
844 &spr_read_dbat_h, &spr_write_dbatl_h,
845 0x00000000);
846 env->nb_BATs += 4;
847 #endif
848 }
849
850 /* Generic PowerPC time base */
851 static void gen_tbl (CPUPPCState *env)
852 {
853 spr_register(env, SPR_VTBL, "TBL",
854 &spr_read_tbl, SPR_NOACCESS,
855 &spr_read_tbl, SPR_NOACCESS,
856 0x00000000);
857 spr_register(env, SPR_TBL, "TBL",
858 &spr_read_tbl, SPR_NOACCESS,
859 &spr_read_tbl, &spr_write_tbl,
860 0x00000000);
861 spr_register(env, SPR_VTBU, "TBU",
862 &spr_read_tbu, SPR_NOACCESS,
863 &spr_read_tbu, SPR_NOACCESS,
864 0x00000000);
865 spr_register(env, SPR_TBU, "TBU",
866 &spr_read_tbu, SPR_NOACCESS,
867 &spr_read_tbu, &spr_write_tbu,
868 0x00000000);
869 }
870
871 /* Softare table search registers */
872 static void gen_6xx_7xx_soft_tlb (CPUPPCState *env, int nb_tlbs, int nb_ways)
873 {
874 #if !defined(CONFIG_USER_ONLY)
875 env->nb_tlb = nb_tlbs;
876 env->nb_ways = nb_ways;
877 env->id_tlbs = 1;
878 env->tlb_type = TLB_6XX;
879 spr_register(env, SPR_DMISS, "DMISS",
880 SPR_NOACCESS, SPR_NOACCESS,
881 &spr_read_generic, SPR_NOACCESS,
882 0x00000000);
883 spr_register(env, SPR_DCMP, "DCMP",
884 SPR_NOACCESS, SPR_NOACCESS,
885 &spr_read_generic, SPR_NOACCESS,
886 0x00000000);
887 spr_register(env, SPR_HASH1, "HASH1",
888 SPR_NOACCESS, SPR_NOACCESS,
889 &spr_read_generic, SPR_NOACCESS,
890 0x00000000);
891 spr_register(env, SPR_HASH2, "HASH2",
892 SPR_NOACCESS, SPR_NOACCESS,
893 &spr_read_generic, SPR_NOACCESS,
894 0x00000000);
895 spr_register(env, SPR_IMISS, "IMISS",
896 SPR_NOACCESS, SPR_NOACCESS,
897 &spr_read_generic, SPR_NOACCESS,
898 0x00000000);
899 spr_register(env, SPR_ICMP, "ICMP",
900 SPR_NOACCESS, SPR_NOACCESS,
901 &spr_read_generic, SPR_NOACCESS,
902 0x00000000);
903 spr_register(env, SPR_RPA, "RPA",
904 SPR_NOACCESS, SPR_NOACCESS,
905 &spr_read_generic, &spr_write_generic,
906 0x00000000);
907 #endif
908 }
909
910 /* SPR common to MPC755 and G2 */
911 static void gen_spr_G2_755 (CPUPPCState *env)
912 {
913 /* SGPRs */
914 spr_register(env, SPR_SPRG4, "SPRG4",
915 SPR_NOACCESS, SPR_NOACCESS,
916 &spr_read_generic, &spr_write_generic,
917 0x00000000);
918 spr_register(env, SPR_SPRG5, "SPRG5",
919 SPR_NOACCESS, SPR_NOACCESS,
920 &spr_read_generic, &spr_write_generic,
921 0x00000000);
922 spr_register(env, SPR_SPRG6, "SPRG6",
923 SPR_NOACCESS, SPR_NOACCESS,
924 &spr_read_generic, &spr_write_generic,
925 0x00000000);
926 spr_register(env, SPR_SPRG7, "SPRG7",
927 SPR_NOACCESS, SPR_NOACCESS,
928 &spr_read_generic, &spr_write_generic,
929 0x00000000);
930 }
931
932 /* SPR common to all 7xx PowerPC implementations */
933 static void gen_spr_7xx (CPUPPCState *env)
934 {
935 /* Breakpoints */
936 /* XXX : not implemented */
937 spr_register_kvm(env, SPR_DABR, "DABR",
938 SPR_NOACCESS, SPR_NOACCESS,
939 &spr_read_generic, &spr_write_generic,
940 KVM_REG_PPC_DABR, 0x00000000);
941 /* XXX : not implemented */
942 spr_register(env, SPR_IABR, "IABR",
943 SPR_NOACCESS, SPR_NOACCESS,
944 &spr_read_generic, &spr_write_generic,
945 0x00000000);
946 /* Cache management */
947 /* XXX : not implemented */
948 spr_register(env, SPR_ICTC, "ICTC",
949 SPR_NOACCESS, SPR_NOACCESS,
950 &spr_read_generic, &spr_write_generic,
951 0x00000000);
952 /* Performance monitors */
953 /* XXX : not implemented */
954 spr_register(env, SPR_MMCR0, "MMCR0",
955 SPR_NOACCESS, SPR_NOACCESS,
956 &spr_read_generic, &spr_write_generic,
957 0x00000000);
958 /* XXX : not implemented */
959 spr_register(env, SPR_MMCR1, "MMCR1",
960 SPR_NOACCESS, SPR_NOACCESS,
961 &spr_read_generic, &spr_write_generic,
962 0x00000000);
963 /* XXX : not implemented */
964 spr_register(env, SPR_PMC1, "PMC1",
965 SPR_NOACCESS, SPR_NOACCESS,
966 &spr_read_generic, &spr_write_generic,
967 0x00000000);
968 /* XXX : not implemented */
969 spr_register(env, SPR_PMC2, "PMC2",
970 SPR_NOACCESS, SPR_NOACCESS,
971 &spr_read_generic, &spr_write_generic,
972 0x00000000);
973 /* XXX : not implemented */
974 spr_register(env, SPR_PMC3, "PMC3",
975 SPR_NOACCESS, SPR_NOACCESS,
976 &spr_read_generic, &spr_write_generic,
977 0x00000000);
978 /* XXX : not implemented */
979 spr_register(env, SPR_PMC4, "PMC4",
980 SPR_NOACCESS, SPR_NOACCESS,
981 &spr_read_generic, &spr_write_generic,
982 0x00000000);
983 /* XXX : not implemented */
984 spr_register(env, SPR_SIAR, "SIAR",
985 SPR_NOACCESS, SPR_NOACCESS,
986 &spr_read_generic, SPR_NOACCESS,
987 0x00000000);
988 /* XXX : not implemented */
989 spr_register(env, SPR_UMMCR0, "UMMCR0",
990 &spr_read_ureg, SPR_NOACCESS,
991 &spr_read_ureg, SPR_NOACCESS,
992 0x00000000);
993 /* XXX : not implemented */
994 spr_register(env, SPR_UMMCR1, "UMMCR1",
995 &spr_read_ureg, SPR_NOACCESS,
996 &spr_read_ureg, SPR_NOACCESS,
997 0x00000000);
998 /* XXX : not implemented */
999 spr_register(env, SPR_UPMC1, "UPMC1",
1000 &spr_read_ureg, SPR_NOACCESS,
1001 &spr_read_ureg, SPR_NOACCESS,
1002 0x00000000);
1003 /* XXX : not implemented */
1004 spr_register(env, SPR_UPMC2, "UPMC2",
1005 &spr_read_ureg, SPR_NOACCESS,
1006 &spr_read_ureg, SPR_NOACCESS,
1007 0x00000000);
1008 /* XXX : not implemented */
1009 spr_register(env, SPR_UPMC3, "UPMC3",
1010 &spr_read_ureg, SPR_NOACCESS,
1011 &spr_read_ureg, SPR_NOACCESS,
1012 0x00000000);
1013 /* XXX : not implemented */
1014 spr_register(env, SPR_UPMC4, "UPMC4",
1015 &spr_read_ureg, SPR_NOACCESS,
1016 &spr_read_ureg, SPR_NOACCESS,
1017 0x00000000);
1018 /* XXX : not implemented */
1019 spr_register(env, SPR_USIAR, "USIAR",
1020 &spr_read_ureg, SPR_NOACCESS,
1021 &spr_read_ureg, SPR_NOACCESS,
1022 0x00000000);
1023 /* External access control */
1024 /* XXX : not implemented */
1025 spr_register(env, SPR_EAR, "EAR",
1026 SPR_NOACCESS, SPR_NOACCESS,
1027 &spr_read_generic, &spr_write_generic,
1028 0x00000000);
1029 }
1030
1031 static void gen_spr_thrm (CPUPPCState *env)
1032 {
1033 /* Thermal management */
1034 /* XXX : not implemented */
1035 spr_register(env, SPR_THRM1, "THRM1",
1036 SPR_NOACCESS, SPR_NOACCESS,
1037 &spr_read_generic, &spr_write_generic,
1038 0x00000000);
1039 /* XXX : not implemented */
1040 spr_register(env, SPR_THRM2, "THRM2",
1041 SPR_NOACCESS, SPR_NOACCESS,
1042 &spr_read_generic, &spr_write_generic,
1043 0x00000000);
1044 /* XXX : not implemented */
1045 spr_register(env, SPR_THRM3, "THRM3",
1046 SPR_NOACCESS, SPR_NOACCESS,
1047 &spr_read_generic, &spr_write_generic,
1048 0x00000000);
1049 }
1050
1051 /* SPR specific to PowerPC 604 implementation */
1052 static void gen_spr_604 (CPUPPCState *env)
1053 {
1054 /* Processor identification */
1055 spr_register(env, SPR_PIR, "PIR",
1056 SPR_NOACCESS, SPR_NOACCESS,
1057 &spr_read_generic, &spr_write_pir,
1058 0x00000000);
1059 /* Breakpoints */
1060 /* XXX : not implemented */
1061 spr_register(env, SPR_IABR, "IABR",
1062 SPR_NOACCESS, SPR_NOACCESS,
1063 &spr_read_generic, &spr_write_generic,
1064 0x00000000);
1065 /* XXX : not implemented */
1066 spr_register_kvm(env, SPR_DABR, "DABR",
1067 SPR_NOACCESS, SPR_NOACCESS,
1068 &spr_read_generic, &spr_write_generic,
1069 KVM_REG_PPC_DABR, 0x00000000);
1070 /* Performance counters */
1071 /* XXX : not implemented */
1072 spr_register(env, SPR_MMCR0, "MMCR0",
1073 SPR_NOACCESS, SPR_NOACCESS,
1074 &spr_read_generic, &spr_write_generic,
1075 0x00000000);
1076 /* XXX : not implemented */
1077 spr_register(env, SPR_PMC1, "PMC1",
1078 SPR_NOACCESS, SPR_NOACCESS,
1079 &spr_read_generic, &spr_write_generic,
1080 0x00000000);
1081 /* XXX : not implemented */
1082 spr_register(env, SPR_PMC2, "PMC2",
1083 SPR_NOACCESS, SPR_NOACCESS,
1084 &spr_read_generic, &spr_write_generic,
1085 0x00000000);
1086 /* XXX : not implemented */
1087 spr_register(env, SPR_SIAR, "SIAR",
1088 SPR_NOACCESS, SPR_NOACCESS,
1089 &spr_read_generic, SPR_NOACCESS,
1090 0x00000000);
1091 /* XXX : not implemented */
1092 spr_register(env, SPR_SDA, "SDA",
1093 SPR_NOACCESS, SPR_NOACCESS,
1094 &spr_read_generic, SPR_NOACCESS,
1095 0x00000000);
1096 /* External access control */
1097 /* XXX : not implemented */
1098 spr_register(env, SPR_EAR, "EAR",
1099 SPR_NOACCESS, SPR_NOACCESS,
1100 &spr_read_generic, &spr_write_generic,
1101 0x00000000);
1102 }
1103
1104 /* SPR specific to PowerPC 603 implementation */
1105 static void gen_spr_603 (CPUPPCState *env)
1106 {
1107 /* External access control */
1108 /* XXX : not implemented */
1109 spr_register(env, SPR_EAR, "EAR",
1110 SPR_NOACCESS, SPR_NOACCESS,
1111 &spr_read_generic, &spr_write_generic,
1112 0x00000000);
1113 }
1114
1115 /* SPR specific to PowerPC G2 implementation */
1116 static void gen_spr_G2 (CPUPPCState *env)
1117 {
1118 /* Memory base address */
1119 /* MBAR */
1120 /* XXX : not implemented */
1121 spr_register(env, SPR_MBAR, "MBAR",
1122 SPR_NOACCESS, SPR_NOACCESS,
1123 &spr_read_generic, &spr_write_generic,
1124 0x00000000);
1125 /* Exception processing */
1126 spr_register(env, SPR_BOOKE_CSRR0, "CSRR0",
1127 SPR_NOACCESS, SPR_NOACCESS,
1128 &spr_read_generic, &spr_write_generic,
1129 0x00000000);
1130 spr_register(env, SPR_BOOKE_CSRR1, "CSRR1",
1131 SPR_NOACCESS, SPR_NOACCESS,
1132 &spr_read_generic, &spr_write_generic,
1133 0x00000000);
1134 /* Breakpoints */
1135 /* XXX : not implemented */
1136 spr_register(env, SPR_DABR, "DABR",
1137 SPR_NOACCESS, SPR_NOACCESS,
1138 &spr_read_generic, &spr_write_generic,
1139 0x00000000);
1140 /* XXX : not implemented */
1141 spr_register(env, SPR_DABR2, "DABR2",
1142 SPR_NOACCESS, SPR_NOACCESS,
1143 &spr_read_generic, &spr_write_generic,
1144 0x00000000);
1145 /* XXX : not implemented */
1146 spr_register(env, SPR_IABR, "IABR",
1147 SPR_NOACCESS, SPR_NOACCESS,
1148 &spr_read_generic, &spr_write_generic,
1149 0x00000000);
1150 /* XXX : not implemented */
1151 spr_register(env, SPR_IABR2, "IABR2",
1152 SPR_NOACCESS, SPR_NOACCESS,
1153 &spr_read_generic, &spr_write_generic,
1154 0x00000000);
1155 /* XXX : not implemented */
1156 spr_register(env, SPR_IBCR, "IBCR",
1157 SPR_NOACCESS, SPR_NOACCESS,
1158 &spr_read_generic, &spr_write_generic,
1159 0x00000000);
1160 /* XXX : not implemented */
1161 spr_register(env, SPR_DBCR, "DBCR",
1162 SPR_NOACCESS, SPR_NOACCESS,
1163 &spr_read_generic, &spr_write_generic,
1164 0x00000000);
1165 }
1166
1167 /* SPR specific to PowerPC 602 implementation */
1168 static void gen_spr_602 (CPUPPCState *env)
1169 {
1170 /* ESA registers */
1171 /* XXX : not implemented */
1172 spr_register(env, SPR_SER, "SER",
1173 SPR_NOACCESS, SPR_NOACCESS,
1174 &spr_read_generic, &spr_write_generic,
1175 0x00000000);
1176 /* XXX : not implemented */
1177 spr_register(env, SPR_SEBR, "SEBR",
1178 SPR_NOACCESS, SPR_NOACCESS,
1179 &spr_read_generic, &spr_write_generic,
1180 0x00000000);
1181 /* XXX : not implemented */
1182 spr_register(env, SPR_ESASRR, "ESASRR",
1183 SPR_NOACCESS, SPR_NOACCESS,
1184 &spr_read_generic, &spr_write_generic,
1185 0x00000000);
1186 /* Floating point status */
1187 /* XXX : not implemented */
1188 spr_register(env, SPR_SP, "SP",
1189 SPR_NOACCESS, SPR_NOACCESS,
1190 &spr_read_generic, &spr_write_generic,
1191 0x00000000);
1192 /* XXX : not implemented */
1193 spr_register(env, SPR_LT, "LT",
1194 SPR_NOACCESS, SPR_NOACCESS,
1195 &spr_read_generic, &spr_write_generic,
1196 0x00000000);
1197 /* Watchdog timer */
1198 /* XXX : not implemented */
1199 spr_register(env, SPR_TCR, "TCR",
1200 SPR_NOACCESS, SPR_NOACCESS,
1201 &spr_read_generic, &spr_write_generic,
1202 0x00000000);
1203 /* Interrupt base */
1204 spr_register(env, SPR_IBR, "IBR",
1205 SPR_NOACCESS, SPR_NOACCESS,
1206 &spr_read_generic, &spr_write_generic,
1207 0x00000000);
1208 /* XXX : not implemented */
1209 spr_register(env, SPR_IABR, "IABR",
1210 SPR_NOACCESS, SPR_NOACCESS,
1211 &spr_read_generic, &spr_write_generic,
1212 0x00000000);
1213 }
1214
1215 /* SPR specific to PowerPC 601 implementation */
1216 static void gen_spr_601 (CPUPPCState *env)
1217 {
1218 /* Multiplication/division register */
1219 /* MQ */
1220 spr_register(env, SPR_MQ, "MQ",
1221 &spr_read_generic, &spr_write_generic,
1222 &spr_read_generic, &spr_write_generic,
1223 0x00000000);
1224 /* RTC registers */
1225 spr_register(env, SPR_601_RTCU, "RTCU",
1226 SPR_NOACCESS, SPR_NOACCESS,
1227 SPR_NOACCESS, &spr_write_601_rtcu,
1228 0x00000000);
1229 spr_register(env, SPR_601_VRTCU, "RTCU",
1230 &spr_read_601_rtcu, SPR_NOACCESS,
1231 &spr_read_601_rtcu, SPR_NOACCESS,
1232 0x00000000);
1233 spr_register(env, SPR_601_RTCL, "RTCL",
1234 SPR_NOACCESS, SPR_NOACCESS,
1235 SPR_NOACCESS, &spr_write_601_rtcl,
1236 0x00000000);
1237 spr_register(env, SPR_601_VRTCL, "RTCL",
1238 &spr_read_601_rtcl, SPR_NOACCESS,
1239 &spr_read_601_rtcl, SPR_NOACCESS,
1240 0x00000000);
1241 /* Timer */
1242 #if 0 /* ? */
1243 spr_register(env, SPR_601_UDECR, "UDECR",
1244 &spr_read_decr, SPR_NOACCESS,
1245 &spr_read_decr, SPR_NOACCESS,
1246 0x00000000);
1247 #endif
1248 /* External access control */
1249 /* XXX : not implemented */
1250 spr_register(env, SPR_EAR, "EAR",
1251 SPR_NOACCESS, SPR_NOACCESS,
1252 &spr_read_generic, &spr_write_generic,
1253 0x00000000);
1254 /* Memory management */
1255 #if !defined(CONFIG_USER_ONLY)
1256 spr_register(env, SPR_IBAT0U, "IBAT0U",
1257 SPR_NOACCESS, SPR_NOACCESS,
1258 &spr_read_601_ubat, &spr_write_601_ubatu,
1259 0x00000000);
1260 spr_register(env, SPR_IBAT0L, "IBAT0L",
1261 SPR_NOACCESS, SPR_NOACCESS,
1262 &spr_read_601_ubat, &spr_write_601_ubatl,
1263 0x00000000);
1264 spr_register(env, SPR_IBAT1U, "IBAT1U",
1265 SPR_NOACCESS, SPR_NOACCESS,
1266 &spr_read_601_ubat, &spr_write_601_ubatu,
1267 0x00000000);
1268 spr_register(env, SPR_IBAT1L, "IBAT1L",
1269 SPR_NOACCESS, SPR_NOACCESS,
1270 &spr_read_601_ubat, &spr_write_601_ubatl,
1271 0x00000000);
1272 spr_register(env, SPR_IBAT2U, "IBAT2U",
1273 SPR_NOACCESS, SPR_NOACCESS,
1274 &spr_read_601_ubat, &spr_write_601_ubatu,
1275 0x00000000);
1276 spr_register(env, SPR_IBAT2L, "IBAT2L",
1277 SPR_NOACCESS, SPR_NOACCESS,
1278 &spr_read_601_ubat, &spr_write_601_ubatl,
1279 0x00000000);
1280 spr_register(env, SPR_IBAT3U, "IBAT3U",
1281 SPR_NOACCESS, SPR_NOACCESS,
1282 &spr_read_601_ubat, &spr_write_601_ubatu,
1283 0x00000000);
1284 spr_register(env, SPR_IBAT3L, "IBAT3L",
1285 SPR_NOACCESS, SPR_NOACCESS,
1286 &spr_read_601_ubat, &spr_write_601_ubatl,
1287 0x00000000);
1288 env->nb_BATs = 4;
1289 #endif
1290 }
1291
1292 static void gen_spr_74xx (CPUPPCState *env)
1293 {
1294 /* Processor identification */
1295 spr_register(env, SPR_PIR, "PIR",
1296 SPR_NOACCESS, SPR_NOACCESS,
1297 &spr_read_generic, &spr_write_pir,
1298 0x00000000);
1299 /* XXX : not implemented */
1300 spr_register(env, SPR_MMCR2, "MMCR2",
1301 SPR_NOACCESS, SPR_NOACCESS,
1302 &spr_read_generic, &spr_write_generic,
1303 0x00000000);
1304 /* XXX : not implemented */
1305 spr_register(env, SPR_UMMCR2, "UMMCR2",
1306 &spr_read_ureg, SPR_NOACCESS,
1307 &spr_read_ureg, SPR_NOACCESS,
1308 0x00000000);
1309 /* XXX: not implemented */
1310 spr_register(env, SPR_BAMR, "BAMR",
1311 SPR_NOACCESS, SPR_NOACCESS,
1312 &spr_read_generic, &spr_write_generic,
1313 0x00000000);
1314 /* XXX : not implemented */
1315 spr_register(env, SPR_MSSCR0, "MSSCR0",
1316 SPR_NOACCESS, SPR_NOACCESS,
1317 &spr_read_generic, &spr_write_generic,
1318 0x00000000);
1319 /* Hardware implementation registers */
1320 /* XXX : not implemented */
1321 spr_register(env, SPR_HID0, "HID0",
1322 SPR_NOACCESS, SPR_NOACCESS,
1323 &spr_read_generic, &spr_write_generic,
1324 0x00000000);
1325 /* XXX : not implemented */
1326 spr_register(env, SPR_HID1, "HID1",
1327 SPR_NOACCESS, SPR_NOACCESS,
1328 &spr_read_generic, &spr_write_generic,
1329 0x00000000);
1330 /* Altivec */
1331 spr_register(env, SPR_VRSAVE, "VRSAVE",
1332 &spr_read_generic, &spr_write_generic,
1333 &spr_read_generic, &spr_write_generic,
1334 0x00000000);
1335 /* XXX : not implemented */
1336 spr_register(env, SPR_L2CR, "L2CR",
1337 SPR_NOACCESS, SPR_NOACCESS,
1338 &spr_read_generic, &spr_write_generic,
1339 0x00000000);
1340 /* Not strictly an SPR */
1341 vscr_init(env, 0x00010000);
1342 }
1343
1344 static void gen_l3_ctrl (CPUPPCState *env)
1345 {
1346 /* L3CR */
1347 /* XXX : not implemented */
1348 spr_register(env, SPR_L3CR, "L3CR",
1349 SPR_NOACCESS, SPR_NOACCESS,
1350 &spr_read_generic, &spr_write_generic,
1351 0x00000000);
1352 /* L3ITCR0 */
1353 /* XXX : not implemented */
1354 spr_register(env, SPR_L3ITCR0, "L3ITCR0",
1355 SPR_NOACCESS, SPR_NOACCESS,
1356 &spr_read_generic, &spr_write_generic,
1357 0x00000000);
1358 /* L3PM */
1359 /* XXX : not implemented */
1360 spr_register(env, SPR_L3PM, "L3PM",
1361 SPR_NOACCESS, SPR_NOACCESS,
1362 &spr_read_generic, &spr_write_generic,
1363 0x00000000);
1364 }
1365
1366 static void gen_74xx_soft_tlb (CPUPPCState *env, int nb_tlbs, int nb_ways)
1367 {
1368 #if !defined(CONFIG_USER_ONLY)
1369 env->nb_tlb = nb_tlbs;
1370 env->nb_ways = nb_ways;
1371 env->id_tlbs = 1;
1372 env->tlb_type = TLB_6XX;
1373 /* XXX : not implemented */
1374 spr_register(env, SPR_PTEHI, "PTEHI",
1375 SPR_NOACCESS, SPR_NOACCESS,
1376 &spr_read_generic, &spr_write_generic,
1377 0x00000000);
1378 /* XXX : not implemented */
1379 spr_register(env, SPR_PTELO, "PTELO",
1380 SPR_NOACCESS, SPR_NOACCESS,
1381 &spr_read_generic, &spr_write_generic,
1382 0x00000000);
1383 /* XXX : not implemented */
1384 spr_register(env, SPR_TLBMISS, "TLBMISS",
1385 SPR_NOACCESS, SPR_NOACCESS,
1386 &spr_read_generic, &spr_write_generic,
1387 0x00000000);
1388 #endif
1389 }
1390
1391 #if !defined(CONFIG_USER_ONLY)
1392 static void spr_write_e500_l1csr0 (void *opaque, int sprn, int gprn)
1393 {
1394 TCGv t0 = tcg_temp_new();
1395
1396 tcg_gen_andi_tl(t0, cpu_gpr[gprn], ~256);
1397 gen_store_spr(sprn, t0);
1398 tcg_temp_free(t0);
1399 }
1400
1401 static void spr_write_booke206_mmucsr0 (void *opaque, int sprn, int gprn)
1402 {
1403 TCGv_i32 t0 = tcg_const_i32(sprn);
1404 gen_helper_booke206_tlbflush(cpu_env, t0);
1405 tcg_temp_free_i32(t0);
1406 }
1407
1408 static void spr_write_booke_pid (void *opaque, int sprn, int gprn)
1409 {
1410 TCGv_i32 t0 = tcg_const_i32(sprn);
1411 gen_helper_booke_setpid(cpu_env, t0, cpu_gpr[gprn]);
1412 tcg_temp_free_i32(t0);
1413 }
1414 #endif
1415
1416 static void gen_spr_usprgh (CPUPPCState *env)
1417 {
1418 spr_register(env, SPR_USPRG4, "USPRG4",
1419 &spr_read_ureg, SPR_NOACCESS,
1420 &spr_read_ureg, SPR_NOACCESS,
1421 0x00000000);
1422 spr_register(env, SPR_USPRG5, "USPRG5",
1423 &spr_read_ureg, SPR_NOACCESS,
1424 &spr_read_ureg, SPR_NOACCESS,
1425 0x00000000);
1426 spr_register(env, SPR_USPRG6, "USPRG6",
1427 &spr_read_ureg, SPR_NOACCESS,
1428 &spr_read_ureg, SPR_NOACCESS,
1429 0x00000000);
1430 spr_register(env, SPR_USPRG7, "USPRG7",
1431 &spr_read_ureg, SPR_NOACCESS,
1432 &spr_read_ureg, SPR_NOACCESS,
1433 0x00000000);
1434 }
1435
1436 /* PowerPC BookE SPR */
1437 static void gen_spr_BookE (CPUPPCState *env, uint64_t ivor_mask)
1438 {
1439 const char *ivor_names[64] = {
1440 "IVOR0", "IVOR1", "IVOR2", "IVOR3",
1441 "IVOR4", "IVOR5", "IVOR6", "IVOR7",
1442 "IVOR8", "IVOR9", "IVOR10", "IVOR11",
1443 "IVOR12", "IVOR13", "IVOR14", "IVOR15",
1444 "IVOR16", "IVOR17", "IVOR18", "IVOR19",
1445 "IVOR20", "IVOR21", "IVOR22", "IVOR23",
1446 "IVOR24", "IVOR25", "IVOR26", "IVOR27",
1447 "IVOR28", "IVOR29", "IVOR30", "IVOR31",
1448 "IVOR32", "IVOR33", "IVOR34", "IVOR35",
1449 "IVOR36", "IVOR37", "IVOR38", "IVOR39",
1450 "IVOR40", "IVOR41", "IVOR42", "IVOR43",
1451 "IVOR44", "IVOR45", "IVOR46", "IVOR47",
1452 "IVOR48", "IVOR49", "IVOR50", "IVOR51",
1453 "IVOR52", "IVOR53", "IVOR54", "IVOR55",
1454 "IVOR56", "IVOR57", "IVOR58", "IVOR59",
1455 "IVOR60", "IVOR61", "IVOR62", "IVOR63",
1456 };
1457 #define SPR_BOOKE_IVORxx (-1)
1458 int ivor_sprn[64] = {
1459 SPR_BOOKE_IVOR0, SPR_BOOKE_IVOR1, SPR_BOOKE_IVOR2, SPR_BOOKE_IVOR3,
1460 SPR_BOOKE_IVOR4, SPR_BOOKE_IVOR5, SPR_BOOKE_IVOR6, SPR_BOOKE_IVOR7,
1461 SPR_BOOKE_IVOR8, SPR_BOOKE_IVOR9, SPR_BOOKE_IVOR10, SPR_BOOKE_IVOR11,
1462 SPR_BOOKE_IVOR12, SPR_BOOKE_IVOR13, SPR_BOOKE_IVOR14, SPR_BOOKE_IVOR15,
1463 SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1464 SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1465 SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1466 SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1467 SPR_BOOKE_IVOR32, SPR_BOOKE_IVOR33, SPR_BOOKE_IVOR34, SPR_BOOKE_IVOR35,
1468 SPR_BOOKE_IVOR36, SPR_BOOKE_IVOR37, SPR_BOOKE_IVOR38, SPR_BOOKE_IVOR39,
1469 SPR_BOOKE_IVOR40, SPR_BOOKE_IVOR41, SPR_BOOKE_IVOR42, SPR_BOOKE_IVORxx,
1470 SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1471 SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1472 SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1473 SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1474 SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx, SPR_BOOKE_IVORxx,
1475 };
1476 int i;
1477
1478 /* Interrupt processing */
1479 spr_register(env, SPR_BOOKE_CSRR0, "CSRR0",
1480 SPR_NOACCESS, SPR_NOACCESS,
1481 &spr_read_generic, &spr_write_generic,
1482 0x00000000);
1483 spr_register(env, SPR_BOOKE_CSRR1, "CSRR1",
1484 SPR_NOACCESS, SPR_NOACCESS,
1485 &spr_read_generic, &spr_write_generic,
1486 0x00000000);
1487 /* Debug */
1488 /* XXX : not implemented */
1489 spr_register(env, SPR_BOOKE_IAC1, "IAC1",
1490 SPR_NOACCESS, SPR_NOACCESS,
1491 &spr_read_generic, &spr_write_generic,
1492 0x00000000);
1493 /* XXX : not implemented */
1494 spr_register(env, SPR_BOOKE_IAC2, "IAC2",
1495 SPR_NOACCESS, SPR_NOACCESS,
1496 &spr_read_generic, &spr_write_generic,
1497 0x00000000);
1498 /* XXX : not implemented */
1499 spr_register(env, SPR_BOOKE_DAC1, "DAC1",
1500 SPR_NOACCESS, SPR_NOACCESS,
1501 &spr_read_generic, &spr_write_generic,
1502 0x00000000);
1503 /* XXX : not implemented */
1504 spr_register(env, SPR_BOOKE_DAC2, "DAC2",
1505 SPR_NOACCESS, SPR_NOACCESS,
1506 &spr_read_generic, &spr_write_generic,
1507 0x00000000);
1508 /* XXX : not implemented */
1509 spr_register(env, SPR_BOOKE_DBCR0, "DBCR0",
1510 SPR_NOACCESS, SPR_NOACCESS,
1511 &spr_read_generic, &spr_write_40x_dbcr0,
1512 0x00000000);
1513 /* XXX : not implemented */
1514 spr_register(env, SPR_BOOKE_DBCR1, "DBCR1",
1515 SPR_NOACCESS, SPR_NOACCESS,
1516 &spr_read_generic, &spr_write_generic,
1517 0x00000000);
1518 /* XXX : not implemented */
1519 spr_register(env, SPR_BOOKE_DBCR2, "DBCR2",
1520 SPR_NOACCESS, SPR_NOACCESS,
1521 &spr_read_generic, &spr_write_generic,
1522 0x00000000);
1523 /* XXX : not implemented */
1524 spr_register(env, SPR_BOOKE_DBSR, "DBSR",
1525 SPR_NOACCESS, SPR_NOACCESS,
1526 &spr_read_generic, &spr_write_clear,
1527 0x00000000);
1528 spr_register(env, SPR_BOOKE_DEAR, "DEAR",
1529 SPR_NOACCESS, SPR_NOACCESS,
1530 &spr_read_generic, &spr_write_generic,
1531 0x00000000);
1532 spr_register(env, SPR_BOOKE_ESR, "ESR",
1533 SPR_NOACCESS, SPR_NOACCESS,
1534 &spr_read_generic, &spr_write_generic,
1535 0x00000000);
1536 spr_register(env, SPR_BOOKE_IVPR, "IVPR",
1537 SPR_NOACCESS, SPR_NOACCESS,
1538 &spr_read_generic, &spr_write_excp_prefix,
1539 0x00000000);
1540 /* Exception vectors */
1541 for (i = 0; i < 64; i++) {
1542 if (ivor_mask & (1ULL << i)) {
1543 if (ivor_sprn[i] == SPR_BOOKE_IVORxx) {
1544 fprintf(stderr, "ERROR: IVOR %d SPR is not defined\n", i);
1545 exit(1);
1546 }
1547 spr_register(env, ivor_sprn[i], ivor_names[i],
1548 SPR_NOACCESS, SPR_NOACCESS,
1549 &spr_read_generic, &spr_write_excp_vector,
1550 0x00000000);
1551 }
1552 }
1553 spr_register(env, SPR_BOOKE_PID, "PID",
1554 SPR_NOACCESS, SPR_NOACCESS,
1555 &spr_read_generic, &spr_write_booke_pid,
1556 0x00000000);
1557 spr_register(env, SPR_BOOKE_TCR, "TCR",
1558 SPR_NOACCESS, SPR_NOACCESS,
1559 &spr_read_generic, &spr_write_booke_tcr,
1560 0x00000000);
1561 spr_register(env, SPR_BOOKE_TSR, "TSR",
1562 SPR_NOACCESS, SPR_NOACCESS,
1563 &spr_read_generic, &spr_write_booke_tsr,
1564 0x00000000);
1565 /* Timer */
1566 spr_register(env, SPR_DECR, "DECR",
1567 SPR_NOACCESS, SPR_NOACCESS,
1568 &spr_read_decr, &spr_write_decr,
1569 0x00000000);
1570 spr_register(env, SPR_BOOKE_DECAR, "DECAR",
1571 SPR_NOACCESS, SPR_NOACCESS,
1572 SPR_NOACCESS, &spr_write_generic,
1573 0x00000000);
1574 /* SPRGs */
1575 spr_register(env, SPR_USPRG0, "USPRG0",
1576 &spr_read_generic, &spr_write_generic,
1577 &spr_read_generic, &spr_write_generic,
1578 0x00000000);
1579 spr_register(env, SPR_SPRG4, "SPRG4",
1580 SPR_NOACCESS, SPR_NOACCESS,
1581 &spr_read_generic, &spr_write_generic,
1582 0x00000000);
1583 spr_register(env, SPR_SPRG5, "SPRG5",
1584 SPR_NOACCESS, SPR_NOACCESS,
1585 &spr_read_generic, &spr_write_generic,
1586 0x00000000);
1587 spr_register(env, SPR_SPRG6, "SPRG6",
1588 SPR_NOACCESS, SPR_NOACCESS,
1589 &spr_read_generic, &spr_write_generic,
1590 0x00000000);
1591 spr_register(env, SPR_SPRG7, "SPRG7",
1592 SPR_NOACCESS, SPR_NOACCESS,
1593 &spr_read_generic, &spr_write_generic,
1594 0x00000000);
1595 }
1596
1597 static inline uint32_t gen_tlbncfg(uint32_t assoc, uint32_t minsize,
1598 uint32_t maxsize, uint32_t flags,
1599 uint32_t nentries)
1600 {
1601 return (assoc << TLBnCFG_ASSOC_SHIFT) |
1602 (minsize << TLBnCFG_MINSIZE_SHIFT) |
1603 (maxsize << TLBnCFG_MAXSIZE_SHIFT) |
1604 flags | nentries;
1605 }
1606
1607 /* BookE 2.06 storage control registers */
1608 static void gen_spr_BookE206(CPUPPCState *env, uint32_t mas_mask,
1609 uint32_t *tlbncfg)
1610 {
1611 #if !defined(CONFIG_USER_ONLY)
1612 const char *mas_names[8] = {
1613 "MAS0", "MAS1", "MAS2", "MAS3", "MAS4", "MAS5", "MAS6", "MAS7",
1614 };
1615 int mas_sprn[8] = {
1616 SPR_BOOKE_MAS0, SPR_BOOKE_MAS1, SPR_BOOKE_MAS2, SPR_BOOKE_MAS3,
1617 SPR_BOOKE_MAS4, SPR_BOOKE_MAS5, SPR_BOOKE_MAS6, SPR_BOOKE_MAS7,
1618 };
1619 int i;
1620
1621 /* TLB assist registers */
1622 /* XXX : not implemented */
1623 for (i = 0; i < 8; i++) {
1624 void (*uea_write)(void *o, int sprn, int gprn) = &spr_write_generic32;
1625 if (i == 2 && (mas_mask & (1 << i)) && (env->insns_flags & PPC_64B)) {
1626 uea_write = &spr_write_generic;
1627 }
1628 if (mas_mask & (1 << i)) {
1629 spr_register(env, mas_sprn[i], mas_names[i],
1630 SPR_NOACCESS, SPR_NOACCESS,
1631 &spr_read_generic, uea_write,
1632 0x00000000);
1633 }
1634 }
1635 if (env->nb_pids > 1) {
1636 /* XXX : not implemented */
1637 spr_register(env, SPR_BOOKE_PID1, "PID1",
1638 SPR_NOACCESS, SPR_NOACCESS,
1639 &spr_read_generic, &spr_write_booke_pid,
1640 0x00000000);
1641 }
1642 if (env->nb_pids > 2) {
1643 /* XXX : not implemented */
1644 spr_register(env, SPR_BOOKE_PID2, "PID2",
1645 SPR_NOACCESS, SPR_NOACCESS,
1646 &spr_read_generic, &spr_write_booke_pid,
1647 0x00000000);
1648 }
1649 /* XXX : not implemented */
1650 spr_register(env, SPR_MMUCFG, "MMUCFG",
1651 SPR_NOACCESS, SPR_NOACCESS,
1652 &spr_read_generic, SPR_NOACCESS,
1653 0x00000000); /* TOFIX */
1654 switch (env->nb_ways) {
1655 case 4:
1656 spr_register(env, SPR_BOOKE_TLB3CFG, "TLB3CFG",
1657 SPR_NOACCESS, SPR_NOACCESS,
1658 &spr_read_generic, SPR_NOACCESS,
1659 tlbncfg[3]);
1660 /* Fallthru */
1661 case 3:
1662 spr_register(env, SPR_BOOKE_TLB2CFG, "TLB2CFG",
1663 SPR_NOACCESS, SPR_NOACCESS,
1664 &spr_read_generic, SPR_NOACCESS,
1665 tlbncfg[2]);
1666 /* Fallthru */
1667 case 2:
1668 spr_register(env, SPR_BOOKE_TLB1CFG, "TLB1CFG",
1669 SPR_NOACCESS, SPR_NOACCESS,
1670 &spr_read_generic, SPR_NOACCESS,
1671 tlbncfg[1]);
1672 /* Fallthru */
1673 case 1:
1674 spr_register(env, SPR_BOOKE_TLB0CFG, "TLB0CFG",
1675 SPR_NOACCESS, SPR_NOACCESS,
1676 &spr_read_generic, SPR_NOACCESS,
1677 tlbncfg[0]);
1678 /* Fallthru */
1679 case 0:
1680 default:
1681 break;
1682 }
1683 #endif
1684
1685 gen_spr_usprgh(env);
1686 }
1687
1688 /* SPR specific to PowerPC 440 implementation */
1689 static void gen_spr_440 (CPUPPCState *env)
1690 {
1691 /* Cache control */
1692 /* XXX : not implemented */
1693 spr_register(env, SPR_440_DNV0, "DNV0",
1694 SPR_NOACCESS, SPR_NOACCESS,
1695 &spr_read_generic, &spr_write_generic,
1696 0x00000000);
1697 /* XXX : not implemented */
1698 spr_register(env, SPR_440_DNV1, "DNV1",
1699 SPR_NOACCESS, SPR_NOACCESS,
1700 &spr_read_generic, &spr_write_generic,
1701 0x00000000);
1702 /* XXX : not implemented */
1703 spr_register(env, SPR_440_DNV2, "DNV2",
1704 SPR_NOACCESS, SPR_NOACCESS,
1705 &spr_read_generic, &spr_write_generic,
1706 0x00000000);
1707 /* XXX : not implemented */
1708 spr_register(env, SPR_440_DNV3, "DNV3",
1709 SPR_NOACCESS, SPR_NOACCESS,
1710 &spr_read_generic, &spr_write_generic,
1711 0x00000000);
1712 /* XXX : not implemented */
1713 spr_register(env, SPR_440_DTV0, "DTV0",
1714 SPR_NOACCESS, SPR_NOACCESS,
1715 &spr_read_generic, &spr_write_generic,
1716 0x00000000);
1717 /* XXX : not implemented */
1718 spr_register(env, SPR_440_DTV1, "DTV1",
1719 SPR_NOACCESS, SPR_NOACCESS,
1720 &spr_read_generic, &spr_write_generic,
1721 0x00000000);
1722 /* XXX : not implemented */
1723 spr_register(env, SPR_440_DTV2, "DTV2",
1724 SPR_NOACCESS, SPR_NOACCESS,
1725 &spr_read_generic, &spr_write_generic,
1726 0x00000000);
1727 /* XXX : not implemented */
1728 spr_register(env, SPR_440_DTV3, "DTV3",
1729 SPR_NOACCESS, SPR_NOACCESS,
1730 &spr_read_generic, &spr_write_generic,
1731 0x00000000);
1732 /* XXX : not implemented */
1733 spr_register(env, SPR_440_DVLIM, "DVLIM",
1734 SPR_NOACCESS, SPR_NOACCESS,
1735 &spr_read_generic, &spr_write_generic,
1736 0x00000000);
1737 /* XXX : not implemented */
1738 spr_register(env, SPR_440_INV0, "INV0",
1739 SPR_NOACCESS, SPR_NOACCESS,
1740 &spr_read_generic, &spr_write_generic,
1741 0x00000000);
1742 /* XXX : not implemented */
1743 spr_register(env, SPR_440_INV1, "INV1",
1744 SPR_NOACCESS, SPR_NOACCESS,
1745 &spr_read_generic, &spr_write_generic,
1746 0x00000000);
1747 /* XXX : not implemented */
1748 spr_register(env, SPR_440_INV2, "INV2",
1749 SPR_NOACCESS, SPR_NOACCESS,
1750 &spr_read_generic, &spr_write_generic,
1751 0x00000000);
1752 /* XXX : not implemented */
1753 spr_register(env, SPR_440_INV3, "INV3",
1754 SPR_NOACCESS, SPR_NOACCESS,
1755 &spr_read_generic, &spr_write_generic,
1756 0x00000000);
1757 /* XXX : not implemented */
1758 spr_register(env, SPR_440_ITV0, "ITV0",
1759 SPR_NOACCESS, SPR_NOACCESS,
1760 &spr_read_generic, &spr_write_generic,
1761 0x00000000);
1762 /* XXX : not implemented */
1763 spr_register(env, SPR_440_ITV1, "ITV1",
1764 SPR_NOACCESS, SPR_NOACCESS,
1765 &spr_read_generic, &spr_write_generic,
1766 0x00000000);
1767 /* XXX : not implemented */
1768 spr_register(env, SPR_440_ITV2, "ITV2",
1769 SPR_NOACCESS, SPR_NOACCESS,
1770 &spr_read_generic, &spr_write_generic,
1771 0x00000000);
1772 /* XXX : not implemented */
1773 spr_register(env, SPR_440_ITV3, "ITV3",
1774 SPR_NOACCESS, SPR_NOACCESS,
1775 &spr_read_generic, &spr_write_generic,
1776 0x00000000);
1777 /* XXX : not implemented */
1778 spr_register(env, SPR_440_IVLIM, "IVLIM",
1779 SPR_NOACCESS, SPR_NOACCESS,
1780 &spr_read_generic, &spr_write_generic,
1781 0x00000000);
1782 /* Cache debug */
1783 /* XXX : not implemented */
1784 spr_register(env, SPR_BOOKE_DCDBTRH, "DCDBTRH",
1785 SPR_NOACCESS, SPR_NOACCESS,
1786 &spr_read_generic, SPR_NOACCESS,
1787 0x00000000);
1788 /* XXX : not implemented */
1789 spr_register(env, SPR_BOOKE_DCDBTRL, "DCDBTRL",
1790 SPR_NOACCESS, SPR_NOACCESS,
1791 &spr_read_generic, SPR_NOACCESS,
1792 0x00000000);
1793 /* XXX : not implemented */
1794 spr_register(env, SPR_BOOKE_ICDBDR, "ICDBDR",
1795 SPR_NOACCESS, SPR_NOACCESS,
1796 &spr_read_generic, SPR_NOACCESS,
1797 0x00000000);
1798 /* XXX : not implemented */
1799 spr_register(env, SPR_BOOKE_ICDBTRH, "ICDBTRH",
1800 SPR_NOACCESS, SPR_NOACCESS,
1801 &spr_read_generic, SPR_NOACCESS,
1802 0x00000000);
1803 /* XXX : not implemented */
1804 spr_register(env, SPR_BOOKE_ICDBTRL, "ICDBTRL",
1805 SPR_NOACCESS, SPR_NOACCESS,
1806 &spr_read_generic, SPR_NOACCESS,
1807 0x00000000);
1808 /* XXX : not implemented */
1809 spr_register(env, SPR_440_DBDR, "DBDR",
1810 SPR_NOACCESS, SPR_NOACCESS,
1811 &spr_read_generic, &spr_write_generic,
1812 0x00000000);
1813 /* Processor control */
1814 spr_register(env, SPR_4xx_CCR0, "CCR0",
1815 SPR_NOACCESS, SPR_NOACCESS,
1816 &spr_read_generic, &spr_write_generic,
1817 0x00000000);
1818 spr_register(env, SPR_440_RSTCFG, "RSTCFG",
1819 SPR_NOACCESS, SPR_NOACCESS,
1820 &spr_read_generic, SPR_NOACCESS,
1821 0x00000000);
1822 /* Storage control */
1823 spr_register(env, SPR_440_MMUCR, "MMUCR",
1824 SPR_NOACCESS, SPR_NOACCESS,
1825 &spr_read_generic, &spr_write_generic,
1826 0x00000000);
1827 }
1828
1829 /* SPR shared between PowerPC 40x implementations */
1830 static void gen_spr_40x (CPUPPCState *env)
1831 {
1832 /* Cache */
1833 /* not emulated, as QEMU do not emulate caches */
1834 spr_register(env, SPR_40x_DCCR, "DCCR",
1835 SPR_NOACCESS, SPR_NOACCESS,
1836 &spr_read_generic, &spr_write_generic,
1837 0x00000000);
1838 /* not emulated, as QEMU do not emulate caches */
1839 spr_register(env, SPR_40x_ICCR, "ICCR",
1840 SPR_NOACCESS, SPR_NOACCESS,
1841 &spr_read_generic, &spr_write_generic,
1842 0x00000000);
1843 /* not emulated, as QEMU do not emulate caches */
1844 spr_register(env, SPR_BOOKE_ICDBDR, "ICDBDR",
1845 SPR_NOACCESS, SPR_NOACCESS,
1846 &spr_read_generic, SPR_NOACCESS,
1847 0x00000000);
1848 /* Exception */
1849 spr_register(env, SPR_40x_DEAR, "DEAR",
1850 SPR_NOACCESS, SPR_NOACCESS,
1851 &spr_read_generic, &spr_write_generic,
1852 0x00000000);
1853 spr_register(env, SPR_40x_ESR, "ESR",
1854 SPR_NOACCESS, SPR_NOACCESS,
1855 &spr_read_generic, &spr_write_generic,
1856 0x00000000);
1857 spr_register(env, SPR_40x_EVPR, "EVPR",
1858 SPR_NOACCESS, SPR_NOACCESS,
1859 &spr_read_generic, &spr_write_excp_prefix,
1860 0x00000000);
1861 spr_register(env, SPR_40x_SRR2, "SRR2",
1862 &spr_read_generic, &spr_write_generic,
1863 &spr_read_generic, &spr_write_generic,
1864 0x00000000);
1865 spr_register(env, SPR_40x_SRR3, "SRR3",
1866 &spr_read_generic, &spr_write_generic,
1867 &spr_read_generic, &spr_write_generic,
1868 0x00000000);
1869 /* Timers */
1870 spr_register(env, SPR_40x_PIT, "PIT",
1871 SPR_NOACCESS, SPR_NOACCESS,
1872 &spr_read_40x_pit, &spr_write_40x_pit,
1873 0x00000000);
1874 spr_register(env, SPR_40x_TCR, "TCR",
1875 SPR_NOACCESS, SPR_NOACCESS,
1876 &spr_read_generic, &spr_write_booke_tcr,
1877 0x00000000);
1878 spr_register(env, SPR_40x_TSR, "TSR",
1879 SPR_NOACCESS, SPR_NOACCESS,
1880 &spr_read_generic, &spr_write_booke_tsr,
1881 0x00000000);
1882 }
1883
1884 /* SPR specific to PowerPC 405 implementation */
1885 static void gen_spr_405 (CPUPPCState *env)
1886 {
1887 /* MMU */
1888 spr_register(env, SPR_40x_PID, "PID",
1889 SPR_NOACCESS, SPR_NOACCESS,
1890 &spr_read_generic, &spr_write_generic,
1891 0x00000000);
1892 spr_register(env, SPR_4xx_CCR0, "CCR0",
1893 SPR_NOACCESS, SPR_NOACCESS,
1894 &spr_read_generic, &spr_write_generic,
1895 0x00700000);
1896 /* Debug interface */
1897 /* XXX : not implemented */
1898 spr_register(env, SPR_40x_DBCR0, "DBCR0",
1899 SPR_NOACCESS, SPR_NOACCESS,
1900 &spr_read_generic, &spr_write_40x_dbcr0,
1901 0x00000000);
1902 /* XXX : not implemented */
1903 spr_register(env, SPR_405_DBCR1, "DBCR1",
1904 SPR_NOACCESS, SPR_NOACCESS,
1905 &spr_read_generic, &spr_write_generic,
1906 0x00000000);
1907 /* XXX : not implemented */
1908 spr_register(env, SPR_40x_DBSR, "DBSR",
1909 SPR_NOACCESS, SPR_NOACCESS,
1910 &spr_read_generic, &spr_write_clear,
1911 /* Last reset was system reset */
1912 0x00000300);
1913 /* XXX : not implemented */
1914 spr_register(env, SPR_40x_DAC1, "DAC1",
1915 SPR_NOACCESS, SPR_NOACCESS,
1916 &spr_read_generic, &spr_write_generic,
1917 0x00000000);
1918 spr_register(env, SPR_40x_DAC2, "DAC2",
1919 SPR_NOACCESS, SPR_NOACCESS,
1920 &spr_read_generic, &spr_write_generic,
1921 0x00000000);
1922 /* XXX : not implemented */
1923 spr_register(env, SPR_405_DVC1, "DVC1",
1924 SPR_NOACCESS, SPR_NOACCESS,
1925 &spr_read_generic, &spr_write_generic,
1926 0x00000000);
1927 /* XXX : not implemented */
1928 spr_register(env, SPR_405_DVC2, "DVC2",
1929 SPR_NOACCESS, SPR_NOACCESS,
1930 &spr_read_generic, &spr_write_generic,
1931 0x00000000);
1932 /* XXX : not implemented */
1933 spr_register(env, SPR_40x_IAC1, "IAC1",
1934 SPR_NOACCESS, SPR_NOACCESS,
1935 &spr_read_generic, &spr_write_generic,
1936 0x00000000);
1937 spr_register(env, SPR_40x_IAC2, "IAC2",
1938 SPR_NOACCESS, SPR_NOACCESS,
1939 &spr_read_generic, &spr_write_generic,
1940 0x00000000);
1941 /* XXX : not implemented */
1942 spr_register(env, SPR_405_IAC3, "IAC3",
1943 SPR_NOACCESS, SPR_NOACCESS,
1944 &spr_read_generic, &spr_write_generic,
1945 0x00000000);
1946 /* XXX : not implemented */
1947 spr_register(env, SPR_405_IAC4, "IAC4",
1948 SPR_NOACCESS, SPR_NOACCESS,
1949 &spr_read_generic, &spr_write_generic,
1950 0x00000000);
1951 /* Storage control */
1952 /* XXX: TODO: not implemented */
1953 spr_register(env, SPR_405_SLER, "SLER",
1954 SPR_NOACCESS, SPR_NOACCESS,
1955 &spr_read_generic, &spr_write_40x_sler,
1956 0x00000000);
1957 spr_register(env, SPR_40x_ZPR, "ZPR",
1958 SPR_NOACCESS, SPR_NOACCESS,
1959 &spr_read_generic, &spr_write_generic,
1960 0x00000000);
1961 /* XXX : not implemented */
1962 spr_register(env, SPR_405_SU0R, "SU0R",
1963 SPR_NOACCESS, SPR_NOACCESS,
1964 &spr_read_generic, &spr_write_generic,
1965 0x00000000);
1966 /* SPRG */
1967 spr_register(env, SPR_USPRG0, "USPRG0",
1968 &spr_read_ureg, SPR_NOACCESS,
1969 &spr_read_ureg, SPR_NOACCESS,
1970 0x00000000);
1971 spr_register(env, SPR_SPRG4, "SPRG4",
1972 SPR_NOACCESS, SPR_NOACCESS,
1973 &spr_read_generic, &spr_write_generic,
1974 0x00000000);
1975 spr_register(env, SPR_SPRG5, "SPRG5",
1976 SPR_NOACCESS, SPR_NOACCESS,
1977 spr_read_generic, &spr_write_generic,
1978 0x00000000);
1979 spr_register(env, SPR_SPRG6, "SPRG6",
1980 SPR_NOACCESS, SPR_NOACCESS,
1981 spr_read_generic, &spr_write_generic,
1982 0x00000000);
1983 spr_register(env, SPR_SPRG7, "SPRG7",
1984 SPR_NOACCESS, SPR_NOACCESS,
1985 spr_read_generic, &spr_write_generic,
1986 0x00000000);
1987 gen_spr_usprgh(env);
1988 }
1989
1990 /* SPR shared between PowerPC 401 & 403 implementations */
1991 static void gen_spr_401_403 (CPUPPCState *env)
1992 {
1993 /* Time base */
1994 spr_register(env, SPR_403_VTBL, "TBL",
1995 &spr_read_tbl, SPR_NOACCESS,
1996 &spr_read_tbl, SPR_NOACCESS,
1997 0x00000000);
1998 spr_register(env, SPR_403_TBL, "TBL",
1999 SPR_NOACCESS, SPR_NOACCESS,
2000 SPR_NOACCESS, &spr_write_tbl,
2001 0x00000000);
2002 spr_register(env, SPR_403_VTBU, "TBU",
2003 &spr_read_tbu, SPR_NOACCESS,
2004 &spr_read_tbu, SPR_NOACCESS,
2005 0x00000000);
2006 spr_register(env, SPR_403_TBU, "TBU",
2007 SPR_NOACCESS, SPR_NOACCESS,
2008 SPR_NOACCESS, &spr_write_tbu,
2009 0x00000000);
2010 /* Debug */
2011 /* not emulated, as QEMU do not emulate caches */
2012 spr_register(env, SPR_403_CDBCR, "CDBCR",
2013 SPR_NOACCESS, SPR_NOACCESS,
2014 &spr_read_generic, &spr_write_generic,
2015 0x00000000);
2016 }
2017
2018 /* SPR specific to PowerPC 401 implementation */
2019 static void gen_spr_401 (CPUPPCState *env)
2020 {
2021 /* Debug interface */
2022 /* XXX : not implemented */
2023 spr_register(env, SPR_40x_DBCR0, "DBCR",
2024 SPR_NOACCESS, SPR_NOACCESS,
2025 &spr_read_generic, &spr_write_40x_dbcr0,
2026 0x00000000);
2027 /* XXX : not implemented */
2028 spr_register(env, SPR_40x_DBSR, "DBSR",
2029 SPR_NOACCESS, SPR_NOACCESS,
2030 &spr_read_generic, &spr_write_clear,
2031 /* Last reset was system reset */
2032 0x00000300);
2033 /* XXX : not implemented */
2034 spr_register(env, SPR_40x_DAC1, "DAC",
2035 SPR_NOACCESS, SPR_NOACCESS,
2036 &spr_read_generic, &spr_write_generic,
2037 0x00000000);
2038 /* XXX : not implemented */
2039 spr_register(env, SPR_40x_IAC1, "IAC",
2040 SPR_NOACCESS, SPR_NOACCESS,
2041 &spr_read_generic, &spr_write_generic,
2042 0x00000000);
2043 /* Storage control */
2044 /* XXX: TODO: not implemented */
2045 spr_register(env, SPR_405_SLER, "SLER",
2046 SPR_NOACCESS, SPR_NOACCESS,
2047 &spr_read_generic, &spr_write_40x_sler,
2048 0x00000000);
2049 /* not emulated, as QEMU never does speculative access */
2050 spr_register(env, SPR_40x_SGR, "SGR",
2051 SPR_NOACCESS, SPR_NOACCESS,
2052 &spr_read_generic, &spr_write_generic,
2053 0xFFFFFFFF);
2054 /* not emulated, as QEMU do not emulate caches */
2055 spr_register(env, SPR_40x_DCWR, "DCWR",
2056 SPR_NOACCESS, SPR_NOACCESS,
2057 &spr_read_generic, &spr_write_generic,
2058 0x00000000);
2059 }
2060
2061 static void gen_spr_401x2 (CPUPPCState *env)
2062 {
2063 gen_spr_401(env);
2064 spr_register(env, SPR_40x_PID, "PID",
2065 SPR_NOACCESS, SPR_NOACCESS,
2066 &spr_read_generic, &spr_write_generic,
2067 0x00000000);
2068 spr_register(env, SPR_40x_ZPR, "ZPR",
2069 SPR_NOACCESS, SPR_NOACCESS,
2070 &spr_read_generic, &spr_write_generic,
2071 0x00000000);
2072 }
2073
2074 /* SPR specific to PowerPC 403 implementation */
2075 static void gen_spr_403 (CPUPPCState *env)
2076 {
2077 /* Debug interface */
2078 /* XXX : not implemented */
2079 spr_register(env, SPR_40x_DBCR0, "DBCR0",
2080 SPR_NOACCESS, SPR_NOACCESS,
2081 &spr_read_generic, &spr_write_40x_dbcr0,
2082 0x00000000);
2083 /* XXX : not implemented */
2084 spr_register(env, SPR_40x_DBSR, "DBSR",
2085 SPR_NOACCESS, SPR_NOACCESS,
2086 &spr_read_generic, &spr_write_clear,
2087 /* Last reset was system reset */
2088 0x00000300);
2089 /* XXX : not implemented */
2090 spr_register(env, SPR_40x_DAC1, "DAC1",
2091 SPR_NOACCESS, SPR_NOACCESS,
2092 &spr_read_generic, &spr_write_generic,
2093 0x00000000);
2094 /* XXX : not implemented */
2095 spr_register(env, SPR_40x_DAC2, "DAC2",
2096 SPR_NOACCESS, SPR_NOACCESS,
2097 &spr_read_generic, &spr_write_generic,
2098 0x00000000);
2099 /* XXX : not implemented */
2100 spr_register(env, SPR_40x_IAC1, "IAC1",
2101 SPR_NOACCESS, SPR_NOACCESS,
2102 &spr_read_generic, &spr_write_generic,
2103 0x00000000);
2104 /* XXX : not implemented */
2105 spr_register(env, SPR_40x_IAC2, "IAC2",
2106 SPR_NOACCESS, SPR_NOACCESS,
2107 &spr_read_generic, &spr_write_generic,
2108 0x00000000);
2109 }
2110
2111 static void gen_spr_403_real (CPUPPCState *env)
2112 {
2113 spr_register(env, SPR_403_PBL1, "PBL1",
2114 SPR_NOACCESS, SPR_NOACCESS,
2115 &spr_read_403_pbr, &spr_write_403_pbr,
2116 0x00000000);
2117 spr_register(env, SPR_403_PBU1, "PBU1",
2118 SPR_NOACCESS, SPR_NOACCESS,
2119 &spr_read_403_pbr, &spr_write_403_pbr,
2120 0x00000000);
2121 spr_register(env, SPR_403_PBL2, "PBL2",
2122 SPR_NOACCESS, SPR_NOACCESS,
2123 &spr_read_403_pbr, &spr_write_403_pbr,
2124 0x00000000);
2125 spr_register(env, SPR_403_PBU2, "PBU2",
2126 SPR_NOACCESS, SPR_NOACCESS,
2127 &spr_read_403_pbr, &spr_write_403_pbr,
2128 0x00000000);
2129 }
2130
2131 static void gen_spr_403_mmu (CPUPPCState *env)
2132 {
2133 /* MMU */
2134 spr_register(env, SPR_40x_PID, "PID",
2135 SPR_NOACCESS, SPR_NOACCESS,
2136 &spr_read_generic, &spr_write_generic,
2137 0x00000000);
2138 spr_register(env, SPR_40x_ZPR, "ZPR",
2139 SPR_NOACCESS, SPR_NOACCESS,
2140 &spr_read_generic, &spr_write_generic,
2141 0x00000000);
2142 }
2143
2144 /* SPR specific to PowerPC compression coprocessor extension */
2145 static void gen_spr_compress (CPUPPCState *env)
2146 {
2147 /* XXX : not implemented */
2148 spr_register(env, SPR_401_SKR, "SKR",
2149 SPR_NOACCESS, SPR_NOACCESS,
2150 &spr_read_generic, &spr_write_generic,
2151 0x00000000);
2152 }
2153
2154 #if defined (TARGET_PPC64)
2155 /* SPR specific to PowerPC 620 */
2156 static void gen_spr_620 (CPUPPCState *env)
2157 {
2158 /* Processor identification */
2159 spr_register(env, SPR_PIR, "PIR",
2160 SPR_NOACCESS, SPR_NOACCESS,
2161 &spr_read_generic, &spr_write_pir,
2162 0x00000000);
2163 spr_register(env, SPR_ASR, "ASR",
2164 SPR_NOACCESS, SPR_NOACCESS,
2165 &spr_read_asr, &spr_write_asr,
2166 0x00000000);
2167 /* Breakpoints */
2168 /* XXX : not implemented */
2169 spr_register(env, SPR_IABR, "IABR",
2170 SPR_NOACCESS, SPR_NOACCESS,
2171 &spr_read_generic, &spr_write_generic,
2172 0x00000000);
2173 /* XXX : not implemented */
2174 spr_register(env, SPR_DABR, "DABR",
2175 SPR_NOACCESS, SPR_NOACCESS,
2176 &spr_read_generic, &spr_write_generic,
2177 0x00000000);
2178 /* XXX : not implemented */
2179 spr_register(env, SPR_SIAR, "SIAR",
2180 SPR_NOACCESS, SPR_NOACCESS,
2181 &spr_read_generic, SPR_NOACCESS,
2182 0x00000000);
2183 /* XXX : not implemented */
2184 spr_register(env, SPR_SDA, "SDA",
2185 SPR_NOACCESS, SPR_NOACCESS,
2186 &spr_read_generic, SPR_NOACCESS,
2187 0x00000000);
2188 /* XXX : not implemented */
2189 spr_register(env, SPR_620_PMC1R, "PMC1",
2190 SPR_NOACCESS, SPR_NOACCESS,
2191 &spr_read_generic, SPR_NOACCESS,
2192 0x00000000);
2193 spr_register(env, SPR_620_PMC1W, "PMC1",
2194 SPR_NOACCESS, SPR_NOACCESS,
2195 SPR_NOACCESS, &spr_write_generic,
2196 0x00000000);
2197 /* XXX : not implemented */
2198 spr_register(env, SPR_620_PMC2R, "PMC2",
2199 SPR_NOACCESS, SPR_NOACCESS,
2200 &spr_read_generic, SPR_NOACCESS,
2201 0x00000000);
2202 spr_register(env, SPR_620_PMC2W, "PMC2",
2203 SPR_NOACCESS, SPR_NOACCESS,
2204 SPR_NOACCESS, &spr_write_generic,
2205 0x00000000);
2206 /* XXX : not implemented */
2207 spr_register(env, SPR_620_MMCR0R, "MMCR0",
2208 SPR_NOACCESS, SPR_NOACCESS,
2209 &spr_read_generic, SPR_NOACCESS,
2210 0x00000000);
2211 spr_register(env, SPR_620_MMCR0W, "MMCR0",
2212 SPR_NOACCESS, SPR_NOACCESS,
2213 SPR_NOACCESS, &spr_write_generic,
2214 0x00000000);
2215 /* External access control */
2216 /* XXX : not implemented */
2217 spr_register(env, SPR_EAR, "EAR",
2218 SPR_NOACCESS, SPR_NOACCESS,
2219 &spr_read_generic, &spr_write_generic,
2220 0x00000000);
2221 #if 0 // XXX: check this
2222 /* XXX : not implemented */
2223 spr_register(env, SPR_620_PMR0, "PMR0",
2224 SPR_NOACCESS, SPR_NOACCESS,
2225 &spr_read_generic, &spr_write_generic,
2226 0x00000000);
2227 /* XXX : not implemented */
2228 spr_register(env, SPR_620_PMR1, "PMR1",
2229 SPR_NOACCESS, SPR_NOACCESS,
2230 &spr_read_generic, &spr_write_generic,
2231 0x00000000);
2232 /* XXX : not implemented */
2233 spr_register(env, SPR_620_PMR2, "PMR2",
2234 SPR_NOACCESS, SPR_NOACCESS,
2235 &spr_read_generic, &spr_write_generic,
2236 0x00000000);
2237 /* XXX : not implemented */
2238 spr_register(env, SPR_620_PMR3, "PMR3",
2239 SPR_NOACCESS, SPR_NOACCESS,
2240 &spr_read_generic, &spr_write_generic,
2241 0x00000000);
2242 /* XXX : not implemented */
2243 spr_register(env, SPR_620_PMR4, "PMR4",
2244 SPR_NOACCESS, SPR_NOACCESS,
2245 &spr_read_generic, &spr_write_generic,
2246 0x00000000);
2247 /* XXX : not implemented */
2248 spr_register(env, SPR_620_PMR5, "PMR5",
2249 SPR_NOACCESS, SPR_NOACCESS,
2250 &spr_read_generic, &spr_write_generic,
2251 0x00000000);
2252 /* XXX : not implemented */
2253 spr_register(env, SPR_620_PMR6, "PMR6",
2254 SPR_NOACCESS, SPR_NOACCESS,
2255 &spr_read_generic, &spr_write_generic,
2256 0x00000000);
2257 /* XXX : not implemented */
2258 spr_register(env, SPR_620_PMR7, "PMR7",
2259 SPR_NOACCESS, SPR_NOACCESS,
2260 &spr_read_generic, &spr_write_generic,
2261 0x00000000);
2262 /* XXX : not implemented */
2263 spr_register(env, SPR_620_PMR8, "PMR8",
2264 SPR_NOACCESS, SPR_NOACCESS,
2265 &spr_read_generic, &spr_write_generic,
2266 0x00000000);
2267 /* XXX : not implemented */
2268 spr_register(env, SPR_620_PMR9, "PMR9",
2269 SPR_NOACCESS, SPR_NOACCESS,
2270 &spr_read_generic, &spr_write_generic,
2271 0x00000000);
2272 /* XXX : not implemented */
2273 spr_register(env, SPR_620_PMRA, "PMR10",
2274 SPR_NOACCESS, SPR_NOACCESS,
2275 &spr_read_generic, &spr_write_generic,
2276 0x00000000);
2277 /* XXX : not implemented */
2278 spr_register(env, SPR_620_PMRB, "PMR11",
2279 SPR_NOACCESS, SPR_NOACCESS,
2280 &spr_read_generic, &spr_write_generic,
2281 0x00000000);
2282 /* XXX : not implemented */
2283 spr_register(env, SPR_620_PMRC, "PMR12",
2284 SPR_NOACCESS, SPR_NOACCESS,
2285 &spr_read_generic, &spr_write_generic,
2286 0x00000000);
2287 /* XXX : not implemented */
2288 spr_register(env, SPR_620_PMRD, "PMR13",
2289 SPR_NOACCESS, SPR_NOACCESS,
2290 &spr_read_generic, &spr_write_generic,
2291 0x00000000);
2292 /* XXX : not implemented */
2293 spr_register(env, SPR_620_PMRE, "PMR14",
2294 SPR_NOACCESS, SPR_NOACCESS,
2295 &spr_read_generic, &spr_write_generic,
2296 0x00000000);
2297 /* XXX : not implemented */
2298 spr_register(env, SPR_620_PMRF, "PMR15",
2299 SPR_NOACCESS, SPR_NOACCESS,
2300 &spr_read_generic, &spr_write_generic,
2301 0x00000000);
2302 #endif
2303 /* XXX : not implemented */
2304 spr_register(env, SPR_620_BUSCSR, "BUSCSR",
2305 SPR_NOACCESS, SPR_NOACCESS,
2306 &spr_read_generic, &spr_write_generic,
2307 0x00000000);
2308 /* XXX : not implemented */
2309 spr_register(env, SPR_620_L2CR, "L2CR",
2310 SPR_NOACCESS, SPR_NOACCESS,
2311 &spr_read_generic, &spr_write_generic,
2312 0x00000000);
2313 /* XXX : not implemented */
2314 spr_register(env, SPR_620_L2SR, "L2SR",
2315 SPR_NOACCESS, SPR_NOACCESS,
2316 &spr_read_generic, &spr_write_generic,
2317 0x00000000);
2318 }
2319 #endif /* defined (TARGET_PPC64) */
2320
2321 static void gen_spr_5xx_8xx (CPUPPCState *env)
2322 {
2323 /* Exception processing */
2324 spr_register_kvm(env, SPR_DSISR, "DSISR",
2325 SPR_NOACCESS, SPR_NOACCESS,
2326 &spr_read_generic, &spr_write_generic,
2327 KVM_REG_PPC_DSISR, 0x00000000);
2328 spr_register_kvm(env, SPR_DAR, "DAR",
2329 SPR_NOACCESS, SPR_NOACCESS,
2330 &spr_read_generic, &spr_write_generic,
2331 KVM_REG_PPC_DAR, 0x00000000);
2332 /* Timer */
2333 spr_register(env, SPR_DECR, "DECR",
2334 SPR_NOACCESS, SPR_NOACCESS,
2335 &spr_read_decr, &spr_write_decr,
2336 0x00000000);
2337 /* XXX : not implemented */
2338 spr_register(env, SPR_MPC_EIE, "EIE",
2339 SPR_NOACCESS, SPR_NOACCESS,
2340 &spr_read_generic, &spr_write_generic,
2341 0x00000000);
2342 /* XXX : not implemented */
2343 spr_register(env, SPR_MPC_EID, "EID",
2344 SPR_NOACCESS, SPR_NOACCESS,
2345 &spr_read_generic, &spr_write_generic,
2346 0x00000000);
2347 /* XXX : not implemented */
2348 spr_register(env, SPR_MPC_NRI, "NRI",
2349 SPR_NOACCESS, SPR_NOACCESS,
2350 &spr_read_generic, &spr_write_generic,
2351 0x00000000);
2352 /* XXX : not implemented */
2353 spr_register(env, SPR_MPC_CMPA, "CMPA",
2354 SPR_NOACCESS, SPR_NOACCESS,
2355 &spr_read_generic, &spr_write_generic,
2356 0x00000000);
2357 /* XXX : not implemented */
2358 spr_register(env, SPR_MPC_CMPB, "CMPB",
2359 SPR_NOACCESS, SPR_NOACCESS,
2360 &spr_read_generic, &spr_write_generic,
2361 0x00000000);
2362 /* XXX : not implemented */
2363 spr_register(env, SPR_MPC_CMPC, "CMPC",
2364 SPR_NOACCESS, SPR_NOACCESS,
2365 &spr_read_generic, &spr_write_generic,
2366 0x00000000);
2367 /* XXX : not implemented */
2368 spr_register(env, SPR_MPC_CMPD, "CMPD",
2369 SPR_NOACCESS, SPR_NOACCESS,
2370 &spr_read_generic, &spr_write_generic,
2371 0x00000000);
2372 /* XXX : not implemented */
2373 spr_register(env, SPR_MPC_ECR, "ECR",
2374 SPR_NOACCESS, SPR_NOACCESS,
2375 &spr_read_generic, &spr_write_generic,
2376 0x00000000);
2377 /* XXX : not implemented */
2378 spr_register(env, SPR_MPC_DER, "DER",
2379 SPR_NOACCESS, SPR_NOACCESS,
2380 &spr_read_generic, &spr_write_generic,
2381 0x00000000);
2382 /* XXX : not implemented */
2383 spr_register(env, SPR_MPC_COUNTA, "COUNTA",
2384 SPR_NOACCESS, SPR_NOACCESS,
2385 &spr_read_generic, &spr_write_generic,
2386 0x00000000);
2387 /* XXX : not implemented */
2388 spr_register(env, SPR_MPC_COUNTB, "COUNTB",
2389 SPR_NOACCESS, SPR_NOACCESS,
2390 &spr_read_generic, &spr_write_generic,
2391 0x00000000);
2392 /* XXX : not implemented */
2393 spr_register(env, SPR_MPC_CMPE, "CMPE",
2394 SPR_NOACCESS, SPR_NOACCESS,
2395 &spr_read_generic, &spr_write_generic,
2396 0x00000000);
2397 /* XXX : not implemented */
2398 spr_register(env, SPR_MPC_CMPF, "CMPF",
2399 SPR_NOACCESS, SPR_NOACCESS,
2400 &spr_read_generic, &spr_write_generic,
2401 0x00000000);
2402 /* XXX : not implemented */
2403 spr_register(env, SPR_MPC_CMPG, "CMPG",
2404 SPR_NOACCESS, SPR_NOACCESS,
2405 &spr_read_generic, &spr_write_generic,
2406 0x00000000);
2407 /* XXX : not implemented */
2408 spr_register(env, SPR_MPC_CMPH, "CMPH",
2409 SPR_NOACCESS, SPR_NOACCESS,
2410 &spr_read_generic, &spr_write_generic,
2411 0x00000000);
2412 /* XXX : not implemented */
2413 spr_register(env, SPR_MPC_LCTRL1, "LCTRL1",
2414 SPR_NOACCESS, SPR_NOACCESS,
2415 &spr_read_generic, &spr_write_generic,
2416 0x00000000);
2417 /* XXX : not implemented */
2418 spr_register(env, SPR_MPC_LCTRL2, "LCTRL2",
2419 SPR_NOACCESS, SPR_NOACCESS,
2420 &spr_read_generic, &spr_write_generic,
2421 0x00000000);
2422 /* XXX : not implemented */
2423 spr_register(env, SPR_MPC_BAR, "BAR",
2424 SPR_NOACCESS, SPR_NOACCESS,
2425 &spr_read_generic, &spr_write_generic,
2426 0x00000000);
2427 /* XXX : not implemented */
2428 spr_register(env, SPR_MPC_DPDR, "DPDR",
2429 SPR_NOACCESS, SPR_NOACCESS,
2430 &spr_read_generic, &spr_write_generic,
2431 0x00000000);
2432 /* XXX : not implemented */
2433 spr_register(env, SPR_MPC_IMMR, "IMMR",
2434 SPR_NOACCESS, SPR_NOACCESS,
2435 &spr_read_generic, &spr_write_generic,
2436 0x00000000);
2437 }
2438
2439 static void gen_spr_5xx (CPUPPCState *env)
2440 {
2441 /* XXX : not implemented */
2442 spr_register(env, SPR_RCPU_MI_GRA, "MI_GRA",
2443 SPR_NOACCESS, SPR_NOACCESS,
2444 &spr_read_generic, &spr_write_generic,
2445 0x00000000);
2446 /* XXX : not implemented */
2447 spr_register(env, SPR_RCPU_L2U_GRA, "L2U_GRA",
2448 SPR_NOACCESS, SPR_NOACCESS,
2449 &spr_read_generic, &spr_write_generic,
2450 0x00000000);
2451 /* XXX : not implemented */
2452 spr_register(env, SPR_RPCU_BBCMCR, "L2U_BBCMCR",
2453 SPR_NOACCESS, SPR_NOACCESS,
2454 &spr_read_generic, &spr_write_generic,
2455 0x00000000);
2456 /* XXX : not implemented */
2457 spr_register(env, SPR_RCPU_L2U_MCR, "L2U_MCR",
2458 SPR_NOACCESS, SPR_NOACCESS,
2459 &spr_read_generic, &spr_write_generic,
2460 0x00000000);
2461 /* XXX : not implemented */
2462 spr_register(env, SPR_RCPU_MI_RBA0, "MI_RBA0",
2463 SPR_NOACCESS, SPR_NOACCESS,
2464 &spr_read_generic, &spr_write_generic,
2465 0x00000000);
2466 /* XXX : not implemented */
2467 spr_register(env, SPR_RCPU_MI_RBA1, "MI_RBA1",
2468 SPR_NOACCESS, SPR_NOACCESS,
2469 &spr_read_generic, &spr_write_generic,
2470 0x00000000);
2471 /* XXX : not implemented */
2472 spr_register(env, SPR_RCPU_MI_RBA2, "MI_RBA2",
2473 SPR_NOACCESS, SPR_NOACCESS,
2474 &spr_read_generic, &spr_write_generic,
2475 0x00000000);
2476 /* XXX : not implemented */
2477 spr_register(env, SPR_RCPU_MI_RBA3, "MI_RBA3",
2478 SPR_NOACCESS, SPR_NOACCESS,
2479 &spr_read_generic, &spr_write_generic,
2480 0x00000000);
2481 /* XXX : not implemented */
2482 spr_register(env, SPR_RCPU_L2U_RBA0, "L2U_RBA0",
2483 SPR_NOACCESS, SPR_NOACCESS,
2484 &spr_read_generic, &spr_write_generic,
2485 0x00000000);
2486 /* XXX : not implemented */
2487 spr_register(env, SPR_RCPU_L2U_RBA1, "L2U_RBA1",
2488 SPR_NOACCESS, SPR_NOACCESS,
2489 &spr_read_generic, &spr_write_generic,
2490 0x00000000);
2491 /* XXX : not implemented */
2492 spr_register(env, SPR_RCPU_L2U_RBA2, "L2U_RBA2",
2493 SPR_NOACCESS, SPR_NOACCESS,
2494 &spr_read_generic, &spr_write_generic,
2495 0x00000000);
2496 /* XXX : not implemented */
2497 spr_register(env, SPR_RCPU_L2U_RBA3, "L2U_RBA3",
2498 SPR_NOACCESS, SPR_NOACCESS,
2499 &spr_read_generic, &spr_write_generic,
2500 0x00000000);
2501 /* XXX : not implemented */
2502 spr_register(env, SPR_RCPU_MI_RA0, "MI_RA0",
2503 SPR_NOACCESS, SPR_NOACCESS,
2504 &spr_read_generic, &spr_write_generic,
2505 0x00000000);
2506 /* XXX : not implemented */
2507 spr_register(env, SPR_RCPU_MI_RA1, "MI_RA1",
2508 SPR_NOACCESS, SPR_NOACCESS,
2509 &spr_read_generic, &spr_write_generic,
2510 0x00000000);
2511 /* XXX : not implemented */
2512 spr_register(env, SPR_RCPU_MI_RA2, "MI_RA2",
2513 SPR_NOACCESS, SPR_NOACCESS,
2514 &spr_read_generic, &spr_write_generic,
2515 0x00000000);
2516 /* XXX : not implemented */
2517 spr_register(env, SPR_RCPU_MI_RA3, "MI_RA3",
2518 SPR_NOACCESS, SPR_NOACCESS,
2519 &spr_read_generic, &spr_write_generic,
2520 0x00000000);
2521 /* XXX : not implemented */
2522 spr_register(env, SPR_RCPU_L2U_RA0, "L2U_RA0",
2523 SPR_NOACCESS, SPR_NOACCESS,
2524 &spr_read_generic, &spr_write_generic,
2525 0x00000000);
2526 /* XXX : not implemented */
2527 spr_register(env, SPR_RCPU_L2U_RA1, "L2U_RA1",
2528 SPR_NOACCESS, SPR_NOACCESS,
2529 &spr_read_generic, &spr_write_generic,
2530 0x00000000);
2531 /* XXX : not implemented */
2532 spr_register(env, SPR_RCPU_L2U_RA2, "L2U_RA2",
2533 SPR_NOACCESS, SPR_NOACCESS,
2534 &spr_read_generic, &spr_write_generic,
2535 0x00000000);
2536 /* XXX : not implemented */
2537 spr_register(env, SPR_RCPU_L2U_RA3, "L2U_RA3",
2538 SPR_NOACCESS, SPR_NOACCESS,
2539 &spr_read_generic, &spr_write_generic,
2540 0x00000000);
2541 /* XXX : not implemented */
2542 spr_register(env, SPR_RCPU_FPECR, "FPECR",
2543 SPR_NOACCESS, SPR_NOACCESS,
2544 &spr_read_generic, &spr_write_generic,
2545 0x00000000);
2546 }
2547
2548 static void gen_spr_8xx (CPUPPCState *env)
2549 {
2550 /* XXX : not implemented */
2551 spr_register(env, SPR_MPC_IC_CST, "IC_CST",
2552 SPR_NOACCESS, SPR_NOACCESS,
2553 &spr_read_generic, &spr_write_generic,
2554 0x00000000);
2555 /* XXX : not implemented */
2556 spr_register(env, SPR_MPC_IC_ADR, "IC_ADR",
2557 SPR_NOACCESS, SPR_NOACCESS,
2558 &spr_read_generic, &spr_write_generic,
2559 0x00000000);
2560 /* XXX : not implemented */
2561 spr_register(env, SPR_MPC_IC_DAT, "IC_DAT",
2562 SPR_NOACCESS, SPR_NOACCESS,
2563 &spr_read_generic, &spr_write_generic,
2564 0x00000000);
2565 /* XXX : not implemented */
2566 spr_register(env, SPR_MPC_DC_CST, "DC_CST",
2567 SPR_NOACCESS, SPR_NOACCESS,
2568 &spr_read_generic, &spr_write_generic,
2569 0x00000000);
2570 /* XXX : not implemented */
2571 spr_register(env, SPR_MPC_DC_ADR, "DC_ADR",
2572 SPR_NOACCESS, SPR_NOACCESS,
2573 &spr_read_generic, &spr_write_generic,
2574 0x00000000);
2575 /* XXX : not implemented */
2576 spr_register(env, SPR_MPC_DC_DAT, "DC_DAT",
2577 SPR_NOACCESS, SPR_NOACCESS,
2578 &spr_read_generic, &spr_write_generic,
2579 0x00000000);
2580 /* XXX : not implemented */
2581 spr_register(env, SPR_MPC_MI_CTR, "MI_CTR",
2582 SPR_NOACCESS, SPR_NOACCESS,
2583 &spr_read_generic, &spr_write_generic,
2584 0x00000000);
2585 /* XXX : not implemented */
2586 spr_register(env, SPR_MPC_MI_AP, "MI_AP",
2587 SPR_NOACCESS, SPR_NOACCESS,
2588 &spr_read_generic, &spr_write_generic,
2589 0x00000000);
2590 /* XXX : not implemented */
2591 spr_register(env, SPR_MPC_MI_EPN, "MI_EPN",
2592 SPR_NOACCESS, SPR_NOACCESS,
2593 &spr_read_generic, &spr_write_generic,
2594 0x00000000);
2595 /* XXX : not implemented */
2596 spr_register(env, SPR_MPC_MI_TWC, "MI_TWC",
2597 SPR_NOACCESS, SPR_NOACCESS,
2598 &spr_read_generic, &spr_write_generic,
2599 0x00000000);
2600 /* XXX : not implemented */
2601 spr_register(env, SPR_MPC_MI_RPN, "MI_RPN",
2602 SPR_NOACCESS, SPR_NOACCESS,
2603 &spr_read_generic, &spr_write_generic,
2604 0x00000000);
2605 /* XXX : not implemented */
2606 spr_register(env, SPR_MPC_MI_DBCAM, "MI_DBCAM",
2607 SPR_NOACCESS, SPR_NOACCESS,
2608 &spr_read_generic, &spr_write_generic,
2609 0x00000000);
2610 /* XXX : not implemented */
2611 spr_register(env, SPR_MPC_MI_DBRAM0, "MI_DBRAM0",
2612 SPR_NOACCESS, SPR_NOACCESS,
2613 &spr_read_generic, &spr_write_generic,
2614 0x00000000);
2615 /* XXX : not implemented */
2616 spr_register(env, SPR_MPC_MI_DBRAM1, "MI_DBRAM1",
2617 SPR_NOACCESS, SPR_NOACCESS,
2618 &spr_read_generic, &spr_write_generic,
2619 0x00000000);
2620 /* XXX : not implemented */
2621 spr_register(env, SPR_MPC_MD_CTR, "MD_CTR",
2622 SPR_NOACCESS, SPR_NOACCESS,
2623 &spr_read_generic, &spr_write_generic,
2624 0x00000000);
2625 /* XXX : not implemented */
2626 spr_register(env, SPR_MPC_MD_CASID, "MD_CASID",
2627 SPR_NOACCESS, SPR_NOACCESS,
2628 &spr_read_generic, &spr_write_generic,
2629 0x00000000);
2630 /* XXX : not implemented */
2631 spr_register(env, SPR_MPC_MD_AP, "MD_AP",
2632 SPR_NOACCESS, SPR_NOACCESS,
2633 &spr_read_generic, &spr_write_generic,
2634 0x00000000);
2635 /* XXX : not implemented */
2636 spr_register(env, SPR_MPC_MD_EPN, "MD_EPN",
2637 SPR_NOACCESS, SPR_NOACCESS,
2638 &spr_read_generic, &spr_write_generic,
2639 0x00000000);
2640 /* XXX : not implemented */
2641 spr_register(env, SPR_MPC_MD_TWB, "MD_TWB",
2642 SPR_NOACCESS, SPR_NOACCESS,
2643 &spr_read_generic, &spr_write_generic,
2644 0x00000000);
2645 /* XXX : not implemented */
2646 spr_register(env, SPR_MPC_MD_TWC, "MD_TWC",
2647 SPR_NOACCESS, SPR_NOACCESS,
2648 &spr_read_generic, &spr_write_generic,
2649 0x00000000);
2650 /* XXX : not implemented */
2651 spr_register(env, SPR_MPC_MD_RPN, "MD_RPN",
2652 SPR_NOACCESS, SPR_NOACCESS,
2653 &spr_read_generic, &spr_write_generic,
2654 0x00000000);
2655 /* XXX : not implemented */
2656 spr_register(env, SPR_MPC_MD_TW, "MD_TW",
2657 SPR_NOACCESS, SPR_NOACCESS,
2658 &spr_read_generic, &spr_write_generic,
2659 0x00000000);
2660 /* XXX : not implemented */
2661 spr_register(env, SPR_MPC_MD_DBCAM, "MD_DBCAM",
2662 SPR_NOACCESS, SPR_NOACCESS,
2663 &spr_read_generic, &spr_write_generic,
2664 0x00000000);
2665 /* XXX : not implemented */
2666 spr_register(env, SPR_MPC_MD_DBRAM0, "MD_DBRAM0",
2667 SPR_NOACCESS, SPR_NOACCESS,
2668 &spr_read_generic, &spr_write_generic,
2669 0x00000000);
2670 /* XXX : not implemented */
2671 spr_register(env, SPR_MPC_MD_DBRAM1, "MD_DBRAM1",
2672 SPR_NOACCESS, SPR_NOACCESS,
2673 &spr_read_generic, &spr_write_generic,
2674 0x00000000);
2675 }
2676
2677 // XXX: TODO
2678 /*
2679 * AMR => SPR 29 (Power 2.04)
2680 * CTRL => SPR 136 (Power 2.04)
2681 * CTRL => SPR 152 (Power 2.04)
2682 * SCOMC => SPR 276 (64 bits ?)
2683 * SCOMD => SPR 277 (64 bits ?)
2684 * TBU40 => SPR 286 (Power 2.04 hypv)
2685 * HSPRG0 => SPR 304 (Power 2.04 hypv)
2686 * HSPRG1 => SPR 305 (Power 2.04 hypv)
2687 * HDSISR => SPR 306 (Power 2.04 hypv)
2688 * HDAR => SPR 307 (Power 2.04 hypv)
2689 * PURR => SPR 309 (Power 2.04 hypv)
2690 * HDEC => SPR 310 (Power 2.04 hypv)
2691 * HIOR => SPR 311 (hypv)
2692 * RMOR => SPR 312 (970)
2693 * HRMOR => SPR 313 (Power 2.04 hypv)
2694 * HSRR0 => SPR 314 (Power 2.04 hypv)
2695 * HSRR1 => SPR 315 (Power 2.04 hypv)
2696 * LPCR => SPR 316 (970)
2697 * LPIDR => SPR 317 (970)
2698 * EPR => SPR 702 (Power 2.04 emb)
2699 * perf => 768-783 (Power 2.04)
2700 * perf => 784-799 (Power 2.04)
2701 * PPR => SPR 896 (Power 2.04)
2702 * EPLC => SPR 947 (Power 2.04 emb)
2703 * EPSC => SPR 948 (Power 2.04 emb)
2704 * DABRX => 1015 (Power 2.04 hypv)
2705 * FPECR => SPR 1022 (?)
2706 * ... and more (thermal management, performance counters, ...)
2707 */
2708
2709 /*****************************************************************************/
2710 /* Exception vectors models */
2711 static void init_excp_4xx_real (CPUPPCState *env)
2712 {
2713 #if !defined(CONFIG_USER_ONLY)
2714 env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000100;
2715 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
2716 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2717 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
2718 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
2719 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
2720 env->excp_vectors[POWERPC_EXCP_PIT] = 0x00001000;
2721 env->excp_vectors[POWERPC_EXCP_FIT] = 0x00001010;
2722 env->excp_vectors[POWERPC_EXCP_WDT] = 0x00001020;
2723 env->excp_vectors[POWERPC_EXCP_DEBUG] = 0x00002000;
2724 env->hreset_excp_prefix = 0x00000000UL;
2725 env->ivor_mask = 0x0000FFF0UL;
2726 env->ivpr_mask = 0xFFFF0000UL;
2727 /* Hardware reset vector */
2728 env->hreset_vector = 0xFFFFFFFCUL;
2729 #endif
2730 }
2731
2732 static void init_excp_4xx_softmmu (CPUPPCState *env)
2733 {
2734 #if !defined(CONFIG_USER_ONLY)
2735 env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000100;
2736 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
2737 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
2738 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
2739 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2740 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
2741 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
2742 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
2743 env->excp_vectors[POWERPC_EXCP_PIT] = 0x00001000;
2744 env->excp_vectors[POWERPC_EXCP_FIT] = 0x00001010;
2745 env->excp_vectors[POWERPC_EXCP_WDT] = 0x00001020;
2746 env->excp_vectors[POWERPC_EXCP_DTLB] = 0x00001100;
2747 env->excp_vectors[POWERPC_EXCP_ITLB] = 0x00001200;
2748 env->excp_vectors[POWERPC_EXCP_DEBUG] = 0x00002000;
2749 env->hreset_excp_prefix = 0x00000000UL;
2750 env->ivor_mask = 0x0000FFF0UL;
2751 env->ivpr_mask = 0xFFFF0000UL;
2752 /* Hardware reset vector */
2753 env->hreset_vector = 0xFFFFFFFCUL;
2754 #endif
2755 }
2756
2757 static void init_excp_MPC5xx (CPUPPCState *env)
2758 {
2759 #if !defined(CONFIG_USER_ONLY)
2760 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
2761 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
2762 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2763 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
2764 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
2765 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000900;
2766 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
2767 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
2768 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
2769 env->excp_vectors[POWERPC_EXCP_FPA] = 0x00000E00;
2770 env->excp_vectors[POWERPC_EXCP_EMUL] = 0x00001000;
2771 env->excp_vectors[POWERPC_EXCP_DABR] = 0x00001C00;
2772 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001C00;
2773 env->excp_vectors[POWERPC_EXCP_MEXTBR] = 0x00001E00;
2774 env->excp_vectors[POWERPC_EXCP_NMEXTBR] = 0x00001F00;
2775 env->hreset_excp_prefix = 0x00000000UL;
2776 env->ivor_mask = 0x0000FFF0UL;
2777 env->ivpr_mask = 0xFFFF0000UL;
2778 /* Hardware reset vector */
2779 env->hreset_vector = 0xFFFFFFFCUL;
2780 #endif
2781 }
2782
2783 static void init_excp_MPC8xx (CPUPPCState *env)
2784 {
2785 #if !defined(CONFIG_USER_ONLY)
2786 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
2787 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
2788 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
2789 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
2790 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2791 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
2792 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
2793 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000900;
2794 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
2795 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
2796 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
2797 env->excp_vectors[POWERPC_EXCP_FPA] = 0x00000E00;
2798 env->excp_vectors[POWERPC_EXCP_EMUL] = 0x00001000;
2799 env->excp_vectors[POWERPC_EXCP_ITLB] = 0x00001100;
2800 env->excp_vectors[POWERPC_EXCP_DTLB] = 0x00001200;
2801 env->excp_vectors[POWERPC_EXCP_ITLBE] = 0x00001300;
2802 env->excp_vectors[POWERPC_EXCP_DTLBE] = 0x00001400;
2803 env->excp_vectors[POWERPC_EXCP_DABR] = 0x00001C00;
2804 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001C00;
2805 env->excp_vectors[POWERPC_EXCP_MEXTBR] = 0x00001E00;
2806 env->excp_vectors[POWERPC_EXCP_NMEXTBR] = 0x00001F00;
2807 env->hreset_excp_prefix = 0x00000000UL;
2808 env->ivor_mask = 0x0000FFF0UL;
2809 env->ivpr_mask = 0xFFFF0000UL;
2810 /* Hardware reset vector */
2811 env->hreset_vector = 0xFFFFFFFCUL;
2812 #endif
2813 }
2814
2815 static void init_excp_G2 (CPUPPCState *env)
2816 {
2817 #if !defined(CONFIG_USER_ONLY)
2818 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
2819 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
2820 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
2821 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
2822 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2823 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
2824 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
2825 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
2826 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
2827 env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000A00;
2828 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
2829 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
2830 env->excp_vectors[POWERPC_EXCP_IFTLB] = 0x00001000;
2831 env->excp_vectors[POWERPC_EXCP_DLTLB] = 0x00001100;
2832 env->excp_vectors[POWERPC_EXCP_DSTLB] = 0x00001200;
2833 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
2834 env->excp_vectors[POWERPC_EXCP_SMI] = 0x00001400;
2835 env->hreset_excp_prefix = 0x00000000UL;
2836 /* Hardware reset vector */
2837 env->hreset_vector = 0xFFFFFFFCUL;
2838 #endif
2839 }
2840
2841 static void init_excp_e200(CPUPPCState *env, target_ulong ivpr_mask)
2842 {
2843 #if !defined(CONFIG_USER_ONLY)
2844 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000FFC;
2845 env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000000;
2846 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000000;
2847 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000000;
2848 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000000;
2849 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000000;
2850 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000000;
2851 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000000;
2852 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000000;
2853 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000000;
2854 env->excp_vectors[POWERPC_EXCP_APU] = 0x00000000;
2855 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000000;
2856 env->excp_vectors[POWERPC_EXCP_FIT] = 0x00000000;
2857 env->excp_vectors[POWERPC_EXCP_WDT] = 0x00000000;
2858 env->excp_vectors[POWERPC_EXCP_DTLB] = 0x00000000;
2859 env->excp_vectors[POWERPC_EXCP_ITLB] = 0x00000000;
2860 env->excp_vectors[POWERPC_EXCP_DEBUG] = 0x00000000;
2861 env->excp_vectors[POWERPC_EXCP_SPEU] = 0x00000000;
2862 env->excp_vectors[POWERPC_EXCP_EFPDI] = 0x00000000;
2863 env->excp_vectors[POWERPC_EXCP_EFPRI] = 0x00000000;
2864 env->hreset_excp_prefix = 0x00000000UL;
2865 env->ivor_mask = 0x0000FFF7UL;
2866 env->ivpr_mask = ivpr_mask;
2867 /* Hardware reset vector */
2868 env->hreset_vector = 0xFFFFFFFCUL;
2869 #endif
2870 }
2871
2872 static void init_excp_BookE (CPUPPCState *env)
2873 {
2874 #if !defined(CONFIG_USER_ONLY)
2875 env->excp_vectors[POWERPC_EXCP_CRITICAL] = 0x00000000;
2876 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000000;
2877 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000000;
2878 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000000;
2879 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000000;
2880 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000000;
2881 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000000;
2882 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000000;
2883 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000000;
2884 env->excp_vectors[POWERPC_EXCP_APU] = 0x00000000;
2885 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000000;
2886 env->excp_vectors[POWERPC_EXCP_FIT] = 0x00000000;
2887 env->excp_vectors[POWERPC_EXCP_WDT] = 0x00000000;
2888 env->excp_vectors[POWERPC_EXCP_DTLB] = 0x00000000;
2889 env->excp_vectors[POWERPC_EXCP_ITLB] = 0x00000000;
2890 env->excp_vectors[POWERPC_EXCP_DEBUG] = 0x00000000;
2891 env->hreset_excp_prefix = 0x00000000UL;
2892 env->ivor_mask = 0x0000FFE0UL;
2893 env->ivpr_mask = 0xFFFF0000UL;
2894 /* Hardware reset vector */
2895 env->hreset_vector = 0xFFFFFFFCUL;
2896 #endif
2897 }
2898
2899 static void init_excp_601 (CPUPPCState *env)
2900 {
2901 #if !defined(CONFIG_USER_ONLY)
2902 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
2903 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
2904 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
2905 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
2906 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2907 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
2908 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
2909 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
2910 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
2911 env->excp_vectors[POWERPC_EXCP_IO] = 0x00000A00;
2912 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
2913 env->excp_vectors[POWERPC_EXCP_RUNM] = 0x00002000;
2914 env->hreset_excp_prefix = 0xFFF00000UL;
2915 /* Hardware reset vector */
2916 env->hreset_vector = 0x00000100UL;
2917 #endif
2918 }
2919
2920 static void init_excp_602 (CPUPPCState *env)
2921 {
2922 #if !defined(CONFIG_USER_ONLY)
2923 /* XXX: exception prefix has a special behavior on 602 */
2924 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
2925 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
2926 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
2927 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
2928 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2929 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
2930 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
2931 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
2932 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
2933 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
2934 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
2935 env->excp_vectors[POWERPC_EXCP_IFTLB] = 0x00001000;
2936 env->excp_vectors[POWERPC_EXCP_DLTLB] = 0x00001100;
2937 env->excp_vectors[POWERPC_EXCP_DSTLB] = 0x00001200;
2938 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
2939 env->excp_vectors[POWERPC_EXCP_SMI] = 0x00001400;
2940 env->excp_vectors[POWERPC_EXCP_WDT] = 0x00001500;
2941 env->excp_vectors[POWERPC_EXCP_EMUL] = 0x00001600;
2942 env->hreset_excp_prefix = 0xFFF00000UL;
2943 /* Hardware reset vector */
2944 env->hreset_vector = 0xFFFFFFFCUL;
2945 #endif
2946 }
2947
2948 static void init_excp_603 (CPUPPCState *env)
2949 {
2950 #if !defined(CONFIG_USER_ONLY)
2951 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
2952 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
2953 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
2954 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
2955 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2956 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
2957 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
2958 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
2959 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
2960 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
2961 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
2962 env->excp_vectors[POWERPC_EXCP_IFTLB] = 0x00001000;
2963 env->excp_vectors[POWERPC_EXCP_DLTLB] = 0x00001100;
2964 env->excp_vectors[POWERPC_EXCP_DSTLB] = 0x00001200;
2965 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
2966 env->excp_vectors[POWERPC_EXCP_SMI] = 0x00001400;
2967 env->hreset_excp_prefix = 0x00000000UL;
2968 /* Hardware reset vector */
2969 env->hreset_vector = 0xFFFFFFFCUL;
2970 #endif
2971 }
2972
2973 static void init_excp_604 (CPUPPCState *env)
2974 {
2975 #if !defined(CONFIG_USER_ONLY)
2976 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
2977 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
2978 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
2979 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
2980 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
2981 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
2982 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
2983 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
2984 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
2985 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
2986 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
2987 env->excp_vectors[POWERPC_EXCP_PERFM] = 0x00000F00;
2988 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
2989 env->excp_vectors[POWERPC_EXCP_SMI] = 0x00001400;
2990 env->hreset_excp_prefix = 0xFFF00000UL;
2991 /* Hardware reset vector */
2992 env->hreset_vector = 0x00000100UL;
2993 #endif
2994 }
2995
2996 #if defined(TARGET_PPC64)
2997 static void init_excp_620 (CPUPPCState *env)
2998 {
2999 #if !defined(CONFIG_USER_ONLY)
3000 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
3001 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
3002 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
3003 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
3004 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3005 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
3006 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
3007 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
3008 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
3009 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
3010 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
3011 env->excp_vectors[POWERPC_EXCP_PERFM] = 0x00000F00;
3012 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
3013 env->excp_vectors[POWERPC_EXCP_SMI] = 0x00001400;
3014 env->hreset_excp_prefix = 0xFFF00000UL;
3015 /* Hardware reset vector */
3016 env->hreset_vector = 0x0000000000000100ULL;
3017 #endif
3018 }
3019 #endif /* defined(TARGET_PPC64) */
3020
3021 static void init_excp_7x0 (CPUPPCState *env)
3022 {
3023 #if !defined(CONFIG_USER_ONLY)
3024 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
3025 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
3026 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
3027 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
3028 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3029 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
3030 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
3031 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
3032 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
3033 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
3034 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
3035 env->excp_vectors[POWERPC_EXCP_PERFM] = 0x00000F00;
3036 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
3037 env->excp_vectors[POWERPC_EXCP_SMI] = 0x00001400;
3038 env->excp_vectors[POWERPC_EXCP_THERM] = 0x00001700;
3039 env->hreset_excp_prefix = 0x00000000UL;
3040 /* Hardware reset vector */
3041 env->hreset_vector = 0xFFFFFFFCUL;
3042 #endif
3043 }
3044
3045 static void init_excp_750cl (CPUPPCState *env)
3046 {
3047 #if !defined(CONFIG_USER_ONLY)
3048 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
3049 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
3050 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
3051 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
3052 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3053 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
3054 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
3055 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
3056 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
3057 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
3058 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
3059 env->excp_vectors[POWERPC_EXCP_PERFM] = 0x00000F00;
3060 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
3061 env->excp_vectors[POWERPC_EXCP_SMI] = 0x00001400;
3062 env->hreset_excp_prefix = 0x00000000UL;
3063 /* Hardware reset vector */
3064 env->hreset_vector = 0xFFFFFFFCUL;
3065 #endif
3066 }
3067
3068 static void init_excp_750cx (CPUPPCState *env)
3069 {
3070 #if !defined(CONFIG_USER_ONLY)
3071 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
3072 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
3073 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
3074 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
3075 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3076 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
3077 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
3078 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
3079 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
3080 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
3081 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
3082 env->excp_vectors[POWERPC_EXCP_PERFM] = 0x00000F00;
3083 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
3084 env->excp_vectors[POWERPC_EXCP_THERM] = 0x00001700;
3085 env->hreset_excp_prefix = 0x00000000UL;
3086 /* Hardware reset vector */
3087 env->hreset_vector = 0xFFFFFFFCUL;
3088 #endif
3089 }
3090
3091 /* XXX: Check if this is correct */
3092 static void init_excp_7x5 (CPUPPCState *env)
3093 {
3094 #if !defined(CONFIG_USER_ONLY)
3095 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
3096 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
3097 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
3098 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
3099 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3100 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
3101 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
3102 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
3103 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
3104 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
3105 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
3106 env->excp_vectors[POWERPC_EXCP_PERFM] = 0x00000F00;
3107 env->excp_vectors[POWERPC_EXCP_IFTLB] = 0x00001000;
3108 env->excp_vectors[POWERPC_EXCP_DLTLB] = 0x00001100;
3109 env->excp_vectors[POWERPC_EXCP_DSTLB] = 0x00001200;
3110 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
3111 env->excp_vectors[POWERPC_EXCP_SMI] = 0x00001400;
3112 env->excp_vectors[POWERPC_EXCP_THERM] = 0x00001700;
3113 env->hreset_excp_prefix = 0x00000000UL;
3114 /* Hardware reset vector */
3115 env->hreset_vector = 0xFFFFFFFCUL;
3116 #endif
3117 }
3118
3119 static void init_excp_7400 (CPUPPCState *env)
3120 {
3121 #if !defined(CONFIG_USER_ONLY)
3122 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
3123 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
3124 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
3125 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
3126 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3127 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
3128 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
3129 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
3130 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
3131 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
3132 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
3133 env->excp_vectors[POWERPC_EXCP_PERFM] = 0x00000F00;
3134 env->excp_vectors[POWERPC_EXCP_VPU] = 0x00000F20;
3135 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
3136 env->excp_vectors[POWERPC_EXCP_SMI] = 0x00001400;
3137 env->excp_vectors[POWERPC_EXCP_VPUA] = 0x00001600;
3138 env->excp_vectors[POWERPC_EXCP_THERM] = 0x00001700;
3139 env->hreset_excp_prefix = 0x00000000UL;
3140 /* Hardware reset vector */
3141 env->hreset_vector = 0xFFFFFFFCUL;
3142 #endif
3143 }
3144
3145 static void init_excp_7450 (CPUPPCState *env)
3146 {
3147 #if !defined(CONFIG_USER_ONLY)
3148 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
3149 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
3150 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
3151 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
3152 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3153 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
3154 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
3155 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
3156 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
3157 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
3158 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
3159 env->excp_vectors[POWERPC_EXCP_PERFM] = 0x00000F00;
3160 env->excp_vectors[POWERPC_EXCP_VPU] = 0x00000F20;
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 env->excp_vectors[POWERPC_EXCP_VPUA] = 0x00001600;
3167 env->hreset_excp_prefix = 0x00000000UL;
3168 /* Hardware reset vector */
3169 env->hreset_vector = 0xFFFFFFFCUL;
3170 #endif
3171 }
3172
3173 #if defined (TARGET_PPC64)
3174 static void init_excp_970 (CPUPPCState *env)
3175 {
3176 #if !defined(CONFIG_USER_ONLY)
3177 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
3178 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
3179 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
3180 env->excp_vectors[POWERPC_EXCP_DSEG] = 0x00000380;
3181 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
3182 env->excp_vectors[POWERPC_EXCP_ISEG] = 0x00000480;
3183 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3184 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
3185 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
3186 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
3187 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
3188 env->excp_vectors[POWERPC_EXCP_HDECR] = 0x00000980;
3189 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
3190 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
3191 env->excp_vectors[POWERPC_EXCP_PERFM] = 0x00000F00;
3192 env->excp_vectors[POWERPC_EXCP_VPU] = 0x00000F20;
3193 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
3194 env->excp_vectors[POWERPC_EXCP_MAINT] = 0x00001600;
3195 env->excp_vectors[POWERPC_EXCP_VPUA] = 0x00001700;
3196 env->excp_vectors[POWERPC_EXCP_THERM] = 0x00001800;
3197 env->hreset_excp_prefix = 0x00000000FFF00000ULL;
3198 /* Hardware reset vector */
3199 env->hreset_vector = 0x0000000000000100ULL;
3200 #endif
3201 }
3202
3203 static void init_excp_POWER7 (CPUPPCState *env)
3204 {
3205 #if !defined(CONFIG_USER_ONLY)
3206 env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
3207 env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
3208 env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
3209 env->excp_vectors[POWERPC_EXCP_DSEG] = 0x00000380;
3210 env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
3211 env->excp_vectors[POWERPC_EXCP_ISEG] = 0x00000480;
3212 env->excp_vectors[POWERPC_EXCP_EXTERNAL] = 0x00000500;
3213 env->excp_vectors[POWERPC_EXCP_ALIGN] = 0x00000600;
3214 env->excp_vectors[POWERPC_EXCP_PROGRAM] = 0x00000700;
3215 env->excp_vectors[POWERPC_EXCP_FPU] = 0x00000800;
3216 env->excp_vectors[POWERPC_EXCP_DECR] = 0x00000900;
3217 env->excp_vectors[POWERPC_EXCP_HDECR] = 0x00000980;
3218 env->excp_vectors[POWERPC_EXCP_SYSCALL] = 0x00000C00;
3219 env->excp_vectors[POWERPC_EXCP_TRACE] = 0x00000D00;
3220 env->excp_vectors[POWERPC_EXCP_PERFM] = 0x00000F00;
3221 env->excp_vectors[POWERPC_EXCP_VPU] = 0x00000F20;
3222 env->excp_vectors[POWERPC_EXCP_IABR] = 0x00001300;
3223 env->excp_vectors[POWERPC_EXCP_MAINT] = 0x00001600;
3224 env->excp_vectors[POWERPC_EXCP_VPUA] = 0x00001700;
3225 env->excp_vectors[POWERPC_EXCP_THERM] = 0x00001800;
3226 env->hreset_excp_prefix = 0;
3227 /* Hardware reset vector */
3228 env->hreset_vector = 0x0000000000000100ULL;
3229 #endif
3230 }
3231 #endif
3232
3233 /*****************************************************************************/
3234 /* Power management enable checks */
3235 static int check_pow_none (CPUPPCState *env)
3236 {
3237 return 0;
3238 }
3239
3240 static int check_pow_nocheck (CPUPPCState *env)
3241 {
3242 return 1;
3243 }
3244
3245 static int check_pow_hid0 (CPUPPCState *env)
3246 {
3247 if (env->spr[SPR_HID0] & 0x00E00000)
3248 return 1;
3249
3250 return 0;
3251 }
3252
3253 static int check_pow_hid0_74xx (CPUPPCState *env)
3254 {
3255 if (env->spr[SPR_HID0] & 0x00600000)
3256 return 1;
3257
3258 return 0;
3259 }
3260
3261 /*****************************************************************************/
3262 /* PowerPC implementations definitions */
3263
3264 #define POWERPC_FAMILY(_name) \
3265 static void \
3266 glue(glue(ppc_, _name), _cpu_family_class_init)(ObjectClass *, void *); \
3267 \
3268 static const TypeInfo \
3269 glue(glue(ppc_, _name), _cpu_family_type_info) = { \
3270 .name = stringify(_name) "-family-" TYPE_POWERPC_CPU, \
3271 .parent = TYPE_POWERPC_CPU, \
3272 .abstract = true, \
3273 .class_init = glue(glue(ppc_, _name), _cpu_family_class_init), \
3274 }; \
3275 \
3276 static void glue(glue(ppc_, _name), _cpu_family_register_types)(void) \
3277 { \
3278 type_register_static( \
3279 &glue(glue(ppc_, _name), _cpu_family_type_info)); \
3280 } \
3281 \
3282 type_init(glue(glue(ppc_, _name), _cpu_family_register_types)) \
3283 \
3284 static void glue(glue(ppc_, _name), _cpu_family_class_init)
3285
3286 static void init_proc_401 (CPUPPCState *env)
3287 {
3288 gen_spr_40x(env);
3289 gen_spr_401_403(env);
3290 gen_spr_401(env);
3291 init_excp_4xx_real(env);
3292 env->dcache_line_size = 32;
3293 env->icache_line_size = 32;
3294 /* Allocate hardware IRQ controller */
3295 ppc40x_irq_init(env);
3296
3297 SET_FIT_PERIOD(12, 16, 20, 24);
3298 SET_WDT_PERIOD(16, 20, 24, 28);
3299 }
3300
3301 POWERPC_FAMILY(401)(ObjectClass *oc, void *data)
3302 {
3303 DeviceClass *dc = DEVICE_CLASS(oc);
3304 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3305
3306 dc->desc = "PowerPC 401";
3307 pcc->init_proc = init_proc_401;
3308 pcc->check_pow = check_pow_nocheck;
3309 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3310 PPC_WRTEE | PPC_DCR |
3311 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3312 PPC_CACHE_DCBZ |
3313 PPC_MEM_SYNC | PPC_MEM_EIEIO |
3314 PPC_4xx_COMMON | PPC_40x_EXCP;
3315 pcc->insns_flags2 = PPC_NONE;
3316 pcc->msr_mask = 0x00000000000FD201ULL;
3317 pcc->mmu_model = POWERPC_MMU_REAL;
3318 pcc->excp_model = POWERPC_EXCP_40x;
3319 pcc->bus_model = PPC_FLAGS_INPUT_401;
3320 pcc->bfd_mach = bfd_mach_ppc_403;
3321 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
3322 POWERPC_FLAG_BUS_CLK;
3323 }
3324
3325 static void init_proc_401x2 (CPUPPCState *env)
3326 {
3327 gen_spr_40x(env);
3328 gen_spr_401_403(env);
3329 gen_spr_401x2(env);
3330 gen_spr_compress(env);
3331 /* Memory management */
3332 #if !defined(CONFIG_USER_ONLY)
3333 env->nb_tlb = 64;
3334 env->nb_ways = 1;
3335 env->id_tlbs = 0;
3336 env->tlb_type = TLB_EMB;
3337 #endif
3338 init_excp_4xx_softmmu(env);
3339 env->dcache_line_size = 32;
3340 env->icache_line_size = 32;
3341 /* Allocate hardware IRQ controller */
3342 ppc40x_irq_init(env);
3343
3344 SET_FIT_PERIOD(12, 16, 20, 24);
3345 SET_WDT_PERIOD(16, 20, 24, 28);
3346 }
3347
3348 POWERPC_FAMILY(401x2)(ObjectClass *oc, void *data)
3349 {
3350 DeviceClass *dc = DEVICE_CLASS(oc);
3351 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3352
3353 dc->desc = "PowerPC 401x2";
3354 pcc->init_proc = init_proc_401x2;
3355 pcc->check_pow = check_pow_nocheck;
3356 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
3357 PPC_DCR | PPC_WRTEE |
3358 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3359 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3360 PPC_MEM_SYNC | PPC_MEM_EIEIO |
3361 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3362 PPC_4xx_COMMON | PPC_40x_EXCP;
3363 pcc->insns_flags2 = PPC_NONE;
3364 pcc->msr_mask = 0x00000000001FD231ULL;
3365 pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3366 pcc->excp_model = POWERPC_EXCP_40x;
3367 pcc->bus_model = PPC_FLAGS_INPUT_401;
3368 pcc->bfd_mach = bfd_mach_ppc_403;
3369 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
3370 POWERPC_FLAG_BUS_CLK;
3371 }
3372
3373 static void init_proc_401x3 (CPUPPCState *env)
3374 {
3375 gen_spr_40x(env);
3376 gen_spr_401_403(env);
3377 gen_spr_401(env);
3378 gen_spr_401x2(env);
3379 gen_spr_compress(env);
3380 init_excp_4xx_softmmu(env);
3381 env->dcache_line_size = 32;
3382 env->icache_line_size = 32;
3383 /* Allocate hardware IRQ controller */
3384 ppc40x_irq_init(env);
3385
3386 SET_FIT_PERIOD(12, 16, 20, 24);
3387 SET_WDT_PERIOD(16, 20, 24, 28);
3388 }
3389
3390 POWERPC_FAMILY(401x3)(ObjectClass *oc, void *data)
3391 {
3392 DeviceClass *dc = DEVICE_CLASS(oc);
3393 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3394
3395 dc->desc = "PowerPC 401x3";
3396 pcc->init_proc = init_proc_401x3;
3397 pcc->check_pow = check_pow_nocheck;
3398 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
3399 PPC_DCR | PPC_WRTEE |
3400 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3401 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3402 PPC_MEM_SYNC | PPC_MEM_EIEIO |
3403 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3404 PPC_4xx_COMMON | PPC_40x_EXCP;
3405 pcc->insns_flags2 = PPC_NONE;
3406 pcc->msr_mask = 0x00000000001FD631ULL;
3407 pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3408 pcc->excp_model = POWERPC_EXCP_40x;
3409 pcc->bus_model = PPC_FLAGS_INPUT_401;
3410 pcc->bfd_mach = bfd_mach_ppc_403;
3411 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
3412 POWERPC_FLAG_BUS_CLK;
3413 }
3414
3415 static void init_proc_IOP480 (CPUPPCState *env)
3416 {
3417 gen_spr_40x(env);
3418 gen_spr_401_403(env);
3419 gen_spr_401x2(env);
3420 gen_spr_compress(env);
3421 /* Memory management */
3422 #if !defined(CONFIG_USER_ONLY)
3423 env->nb_tlb = 64;
3424 env->nb_ways = 1;
3425 env->id_tlbs = 0;
3426 env->tlb_type = TLB_EMB;
3427 #endif
3428 init_excp_4xx_softmmu(env);
3429 env->dcache_line_size = 32;
3430 env->icache_line_size = 32;
3431 /* Allocate hardware IRQ controller */
3432 ppc40x_irq_init(env);
3433
3434 SET_FIT_PERIOD(8, 12, 16, 20);
3435 SET_WDT_PERIOD(16, 20, 24, 28);
3436 }
3437
3438 POWERPC_FAMILY(IOP480)(ObjectClass *oc, void *data)
3439 {
3440 DeviceClass *dc = DEVICE_CLASS(oc);
3441 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3442
3443 dc->desc = "IOP480";
3444 pcc->init_proc = init_proc_IOP480;
3445 pcc->check_pow = check_pow_nocheck;
3446 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3447 PPC_DCR | PPC_WRTEE |
3448 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3449 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3450 PPC_MEM_SYNC | PPC_MEM_EIEIO |
3451 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3452 PPC_4xx_COMMON | PPC_40x_EXCP;
3453 pcc->insns_flags2 = PPC_NONE;
3454 pcc->msr_mask = 0x00000000001FD231ULL;
3455 pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3456 pcc->excp_model = POWERPC_EXCP_40x;
3457 pcc->bus_model = PPC_FLAGS_INPUT_401;
3458 pcc->bfd_mach = bfd_mach_ppc_403;
3459 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
3460 POWERPC_FLAG_BUS_CLK;
3461 }
3462
3463 static void init_proc_403 (CPUPPCState *env)
3464 {
3465 gen_spr_40x(env);
3466 gen_spr_401_403(env);
3467 gen_spr_403(env);
3468 gen_spr_403_real(env);
3469 init_excp_4xx_real(env);
3470 env->dcache_line_size = 32;
3471 env->icache_line_size = 32;
3472 /* Allocate hardware IRQ controller */
3473 ppc40x_irq_init(env);
3474
3475 SET_FIT_PERIOD(8, 12, 16, 20);
3476 SET_WDT_PERIOD(16, 20, 24, 28);
3477 }
3478
3479 POWERPC_FAMILY(403)(ObjectClass *oc, void *data)
3480 {
3481 DeviceClass *dc = DEVICE_CLASS(oc);
3482 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3483
3484 dc->desc = "PowerPC 403";
3485 pcc->init_proc = init_proc_403;
3486 pcc->check_pow = check_pow_nocheck;
3487 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3488 PPC_DCR | PPC_WRTEE |
3489 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3490 PPC_CACHE_DCBZ |
3491 PPC_MEM_SYNC | PPC_MEM_EIEIO |
3492 PPC_4xx_COMMON | PPC_40x_EXCP;
3493 pcc->insns_flags2 = PPC_NONE;
3494 pcc->msr_mask = 0x000000000007D00DULL;
3495 pcc->mmu_model = POWERPC_MMU_REAL;
3496 pcc->excp_model = POWERPC_EXCP_40x;
3497 pcc->bus_model = PPC_FLAGS_INPUT_401;
3498 pcc->bfd_mach = bfd_mach_ppc_403;
3499 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_PX |
3500 POWERPC_FLAG_BUS_CLK;
3501 }
3502
3503 static void init_proc_403GCX (CPUPPCState *env)
3504 {
3505 gen_spr_40x(env);
3506 gen_spr_401_403(env);
3507 gen_spr_403(env);
3508 gen_spr_403_real(env);
3509 gen_spr_403_mmu(env);
3510 /* Bus access control */
3511 /* not emulated, as QEMU never does speculative access */
3512 spr_register(env, SPR_40x_SGR, "SGR",
3513 SPR_NOACCESS, SPR_NOACCESS,
3514 &spr_read_generic, &spr_write_generic,
3515 0xFFFFFFFF);
3516 /* not emulated, as QEMU do not emulate caches */
3517 spr_register(env, SPR_40x_DCWR, "DCWR",
3518 SPR_NOACCESS, SPR_NOACCESS,
3519 &spr_read_generic, &spr_write_generic,
3520 0x00000000);
3521 /* Memory management */
3522 #if !defined(CONFIG_USER_ONLY)
3523 env->nb_tlb = 64;
3524 env->nb_ways = 1;
3525 env->id_tlbs = 0;
3526 env->tlb_type = TLB_EMB;
3527 #endif
3528 init_excp_4xx_softmmu(env);
3529 env->dcache_line_size = 32;
3530 env->icache_line_size = 32;
3531 /* Allocate hardware IRQ controller */
3532 ppc40x_irq_init(env);
3533
3534 SET_FIT_PERIOD(8, 12, 16, 20);
3535 SET_WDT_PERIOD(16, 20, 24, 28);
3536 }
3537
3538 POWERPC_FAMILY(403GCX)(ObjectClass *oc, void *data)
3539 {
3540 DeviceClass *dc = DEVICE_CLASS(oc);
3541 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3542
3543 dc->desc = "PowerPC 403 GCX";
3544 pcc->init_proc = init_proc_403GCX;
3545 pcc->check_pow = check_pow_nocheck;
3546 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3547 PPC_DCR | PPC_WRTEE |
3548 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3549 PPC_CACHE_DCBZ |
3550 PPC_MEM_SYNC | PPC_MEM_EIEIO |
3551 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3552 PPC_4xx_COMMON | PPC_40x_EXCP;
3553 pcc->insns_flags2 = PPC_NONE;
3554 pcc->msr_mask = 0x000000000007D00DULL;
3555 pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3556 pcc->excp_model = POWERPC_EXCP_40x;
3557 pcc->bus_model = PPC_FLAGS_INPUT_401;
3558 pcc->bfd_mach = bfd_mach_ppc_403;
3559 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_PX |
3560 POWERPC_FLAG_BUS_CLK;
3561 }
3562
3563 static void init_proc_405 (CPUPPCState *env)
3564 {
3565 /* Time base */
3566 gen_tbl(env);
3567 gen_spr_40x(env);
3568 gen_spr_405(env);
3569 /* Bus access control */
3570 /* not emulated, as QEMU never does speculative access */
3571 spr_register(env, SPR_40x_SGR, "SGR",
3572 SPR_NOACCESS, SPR_NOACCESS,
3573 &spr_read_generic, &spr_write_generic,
3574 0xFFFFFFFF);
3575 /* not emulated, as QEMU do not emulate caches */
3576 spr_register(env, SPR_40x_DCWR, "DCWR",
3577 SPR_NOACCESS, SPR_NOACCESS,
3578 &spr_read_generic, &spr_write_generic,
3579 0x00000000);
3580 /* Memory management */
3581 #if !defined(CONFIG_USER_ONLY)
3582 env->nb_tlb = 64;
3583 env->nb_ways = 1;
3584 env->id_tlbs = 0;
3585 env->tlb_type = TLB_EMB;
3586 #endif
3587 init_excp_4xx_softmmu(env);
3588 env->dcache_line_size = 32;
3589 env->icache_line_size = 32;
3590 /* Allocate hardware IRQ controller */
3591 ppc40x_irq_init(env);
3592
3593 SET_FIT_PERIOD(8, 12, 16, 20);
3594 SET_WDT_PERIOD(16, 20, 24, 28);
3595 }
3596
3597 POWERPC_FAMILY(405)(ObjectClass *oc, void *data)
3598 {
3599 DeviceClass *dc = DEVICE_CLASS(oc);
3600 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3601
3602 dc->desc = "PowerPC 405";
3603 pcc->init_proc = init_proc_405;
3604 pcc->check_pow = check_pow_nocheck;
3605 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
3606 PPC_DCR | PPC_WRTEE |
3607 PPC_CACHE | PPC_CACHE_ICBI | PPC_40x_ICBT |
3608 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3609 PPC_MEM_SYNC | PPC_MEM_EIEIO |
3610 PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3611 PPC_4xx_COMMON | PPC_405_MAC | PPC_40x_EXCP;
3612 pcc->insns_flags2 = PPC_NONE;
3613 pcc->msr_mask = 0x000000000006E630ULL;
3614 pcc->mmu_model = POWERPC_MMU_SOFT_4xx;
3615 pcc->excp_model = POWERPC_EXCP_40x;
3616 pcc->bus_model = PPC_FLAGS_INPUT_405;
3617 pcc->bfd_mach = bfd_mach_ppc_403;
3618 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
3619 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
3620 }
3621
3622 static void init_proc_440EP (CPUPPCState *env)
3623 {
3624 /* Time base */
3625 gen_tbl(env);
3626 gen_spr_BookE(env, 0x000000000000FFFFULL);
3627 gen_spr_440(env);
3628 gen_spr_usprgh(env);
3629 /* Processor identification */
3630 spr_register(env, SPR_BOOKE_PIR, "PIR",
3631 SPR_NOACCESS, SPR_NOACCESS,
3632 &spr_read_generic, &spr_write_pir,
3633 0x00000000);
3634 /* XXX : not implemented */
3635 spr_register(env, SPR_BOOKE_IAC3, "IAC3",
3636 SPR_NOACCESS, SPR_NOACCESS,
3637 &spr_read_generic, &spr_write_generic,
3638 0x00000000);
3639 /* XXX : not implemented */
3640 spr_register(env, SPR_BOOKE_IAC4, "IAC4",
3641 SPR_NOACCESS, SPR_NOACCESS,
3642 &spr_read_generic, &spr_write_generic,
3643 0x00000000);
3644 /* XXX : not implemented */
3645 spr_register(env, SPR_BOOKE_DVC1, "DVC1",
3646 SPR_NOACCESS, SPR_NOACCESS,
3647 &spr_read_generic, &spr_write_generic,
3648 0x00000000);
3649 /* XXX : not implemented */
3650 spr_register(env, SPR_BOOKE_DVC2, "DVC2",
3651 SPR_NOACCESS, SPR_NOACCESS,
3652 &spr_read_generic, &spr_write_generic,
3653 0x00000000);
3654 /* XXX : not implemented */
3655 spr_register(env, SPR_BOOKE_MCSR, "MCSR",
3656 SPR_NOACCESS, SPR_NOACCESS,
3657 &spr_read_generic, &spr_write_generic,
3658 0x00000000);
3659 spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
3660 SPR_NOACCESS, SPR_NOACCESS,
3661 &spr_read_generic, &spr_write_generic,
3662 0x00000000);
3663 spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
3664 SPR_NOACCESS, SPR_NOACCESS,
3665 &spr_read_generic, &spr_write_generic,
3666 0x00000000);
3667 /* XXX : not implemented */
3668 spr_register(env, SPR_440_CCR1, "CCR1",
3669 SPR_NOACCESS, SPR_NOACCESS,
3670 &spr_read_generic, &spr_write_generic,
3671 0x00000000);
3672 /* Memory management */
3673 #if !defined(CONFIG_USER_ONLY)
3674 env->nb_tlb = 64;
3675 env->nb_ways = 1;
3676 env->id_tlbs = 0;
3677 env->tlb_type = TLB_EMB;
3678 #endif
3679 init_excp_BookE(env);
3680 env->dcache_line_size = 32;
3681 env->icache_line_size = 32;
3682 ppc40x_irq_init(env);
3683
3684 SET_FIT_PERIOD(12, 16, 20, 24);
3685 SET_WDT_PERIOD(20, 24, 28, 32);
3686 }
3687
3688 POWERPC_FAMILY(440EP)(ObjectClass *oc, void *data)
3689 {
3690 DeviceClass *dc = DEVICE_CLASS(oc);
3691 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3692
3693 dc->desc = "PowerPC 440 EP";
3694 pcc->init_proc = init_proc_440EP;
3695 pcc->check_pow = check_pow_nocheck;
3696 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3697 PPC_FLOAT | PPC_FLOAT_FRES | PPC_FLOAT_FSEL |
3698 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
3699 PPC_FLOAT_STFIWX |
3700 PPC_DCR | PPC_WRTEE | PPC_RFMCI |
3701 PPC_CACHE | PPC_CACHE_ICBI |
3702 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3703 PPC_MEM_TLBSYNC | PPC_MFTB |
3704 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3705 PPC_440_SPEC;
3706 pcc->insns_flags2 = PPC_NONE;
3707 pcc->msr_mask = 0x000000000006FF30ULL;
3708 pcc->mmu_model = POWERPC_MMU_BOOKE;
3709 pcc->excp_model = POWERPC_EXCP_BOOKE;
3710 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
3711 pcc->bfd_mach = bfd_mach_ppc_403;
3712 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
3713 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
3714 }
3715
3716 static void init_proc_440GP (CPUPPCState *env)
3717 {
3718 /* Time base */
3719 gen_tbl(env);
3720 gen_spr_BookE(env, 0x000000000000FFFFULL);
3721 gen_spr_440(env);
3722 gen_spr_usprgh(env);
3723 /* Processor identification */
3724 spr_register(env, SPR_BOOKE_PIR, "PIR",
3725 SPR_NOACCESS, SPR_NOACCESS,
3726 &spr_read_generic, &spr_write_pir,
3727 0x00000000);
3728 /* XXX : not implemented */
3729 spr_register(env, SPR_BOOKE_IAC3, "IAC3",
3730 SPR_NOACCESS, SPR_NOACCESS,
3731 &spr_read_generic, &spr_write_generic,
3732 0x00000000);
3733 /* XXX : not implemented */
3734 spr_register(env, SPR_BOOKE_IAC4, "IAC4",
3735 SPR_NOACCESS, SPR_NOACCESS,
3736 &spr_read_generic, &spr_write_generic,
3737 0x00000000);
3738 /* XXX : not implemented */
3739 spr_register(env, SPR_BOOKE_DVC1, "DVC1",
3740 SPR_NOACCESS, SPR_NOACCESS,
3741 &spr_read_generic, &spr_write_generic,
3742 0x00000000);
3743 /* XXX : not implemented */
3744 spr_register(env, SPR_BOOKE_DVC2, "DVC2",
3745 SPR_NOACCESS, SPR_NOACCESS,
3746 &spr_read_generic, &spr_write_generic,
3747 0x00000000);
3748 /* Memory management */
3749 #if !defined(CONFIG_USER_ONLY)
3750 env->nb_tlb = 64;
3751 env->nb_ways = 1;
3752 env->id_tlbs = 0;
3753 env->tlb_type = TLB_EMB;
3754 #endif
3755 init_excp_BookE(env);
3756 env->dcache_line_size = 32;
3757 env->icache_line_size = 32;
3758 /* XXX: TODO: allocate internal IRQ controller */
3759
3760 SET_FIT_PERIOD(12, 16, 20, 24);
3761 SET_WDT_PERIOD(20, 24, 28, 32);
3762 }
3763
3764 POWERPC_FAMILY(440GP)(ObjectClass *oc, void *data)
3765 {
3766 DeviceClass *dc = DEVICE_CLASS(oc);
3767 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3768
3769 dc->desc = "PowerPC 440 GP";
3770 pcc->init_proc = init_proc_440GP;
3771 pcc->check_pow = check_pow_nocheck;
3772 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3773 PPC_DCR | PPC_DCRX | PPC_WRTEE | PPC_MFAPIDI |
3774 PPC_CACHE | PPC_CACHE_ICBI |
3775 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3776 PPC_MEM_TLBSYNC | PPC_TLBIVA | PPC_MFTB |
3777 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3778 PPC_440_SPEC;
3779 pcc->insns_flags2 = PPC_NONE;
3780 pcc->msr_mask = 0x000000000006FF30ULL;
3781 pcc->mmu_model = POWERPC_MMU_BOOKE;
3782 pcc->excp_model = POWERPC_EXCP_BOOKE;
3783 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
3784 pcc->bfd_mach = bfd_mach_ppc_403;
3785 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
3786 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
3787 }
3788
3789 static void init_proc_440x4 (CPUPPCState *env)
3790 {
3791 /* Time base */
3792 gen_tbl(env);
3793 gen_spr_BookE(env, 0x000000000000FFFFULL);
3794 gen_spr_440(env);
3795 gen_spr_usprgh(env);
3796 /* Processor identification */
3797 spr_register(env, SPR_BOOKE_PIR, "PIR",
3798 SPR_NOACCESS, SPR_NOACCESS,
3799 &spr_read_generic, &spr_write_pir,
3800 0x00000000);
3801 /* XXX : not implemented */
3802 spr_register(env, SPR_BOOKE_IAC3, "IAC3",
3803 SPR_NOACCESS, SPR_NOACCESS,
3804 &spr_read_generic, &spr_write_generic,
3805 0x00000000);
3806 /* XXX : not implemented */
3807 spr_register(env, SPR_BOOKE_IAC4, "IAC4",
3808 SPR_NOACCESS, SPR_NOACCESS,
3809 &spr_read_generic, &spr_write_generic,
3810 0x00000000);
3811 /* XXX : not implemented */
3812 spr_register(env, SPR_BOOKE_DVC1, "DVC1",
3813 SPR_NOACCESS, SPR_NOACCESS,
3814 &spr_read_generic, &spr_write_generic,
3815 0x00000000);
3816 /* XXX : not implemented */
3817 spr_register(env, SPR_BOOKE_DVC2, "DVC2",
3818 SPR_NOACCESS, SPR_NOACCESS,
3819 &spr_read_generic, &spr_write_generic,
3820 0x00000000);
3821 /* Memory management */
3822 #if !defined(CONFIG_USER_ONLY)
3823 env->nb_tlb = 64;
3824 env->nb_ways = 1;
3825 env->id_tlbs = 0;
3826 env->tlb_type = TLB_EMB;
3827 #endif
3828 init_excp_BookE(env);
3829 env->dcache_line_size = 32;
3830 env->icache_line_size = 32;
3831 /* XXX: TODO: allocate internal IRQ controller */
3832
3833 SET_FIT_PERIOD(12, 16, 20, 24);
3834 SET_WDT_PERIOD(20, 24, 28, 32);
3835 }
3836
3837 POWERPC_FAMILY(440x4)(ObjectClass *oc, void *data)
3838 {
3839 DeviceClass *dc = DEVICE_CLASS(oc);
3840 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3841
3842 dc->desc = "PowerPC 440x4";
3843 pcc->init_proc = init_proc_440x4;
3844 pcc->check_pow = check_pow_nocheck;
3845 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3846 PPC_DCR | PPC_WRTEE |
3847 PPC_CACHE | PPC_CACHE_ICBI |
3848 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3849 PPC_MEM_TLBSYNC | PPC_MFTB |
3850 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3851 PPC_440_SPEC;
3852 pcc->insns_flags2 = PPC_NONE;
3853 pcc->msr_mask = 0x000000000006FF30ULL;
3854 pcc->mmu_model = POWERPC_MMU_BOOKE;
3855 pcc->excp_model = POWERPC_EXCP_BOOKE;
3856 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
3857 pcc->bfd_mach = bfd_mach_ppc_403;
3858 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
3859 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
3860 }
3861
3862 static void init_proc_440x5 (CPUPPCState *env)
3863 {
3864 /* Time base */
3865 gen_tbl(env);
3866 gen_spr_BookE(env, 0x000000000000FFFFULL);
3867 gen_spr_440(env);
3868 gen_spr_usprgh(env);
3869 /* Processor identification */
3870 spr_register(env, SPR_BOOKE_PIR, "PIR",
3871 SPR_NOACCESS, SPR_NOACCESS,
3872 &spr_read_generic, &spr_write_pir,
3873 0x00000000);
3874 /* XXX : not implemented */
3875 spr_register(env, SPR_BOOKE_IAC3, "IAC3",
3876 SPR_NOACCESS, SPR_NOACCESS,
3877 &spr_read_generic, &spr_write_generic,
3878 0x00000000);
3879 /* XXX : not implemented */
3880 spr_register(env, SPR_BOOKE_IAC4, "IAC4",
3881 SPR_NOACCESS, SPR_NOACCESS,
3882 &spr_read_generic, &spr_write_generic,
3883 0x00000000);
3884 /* XXX : not implemented */
3885 spr_register(env, SPR_BOOKE_DVC1, "DVC1",
3886 SPR_NOACCESS, SPR_NOACCESS,
3887 &spr_read_generic, &spr_write_generic,
3888 0x00000000);
3889 /* XXX : not implemented */
3890 spr_register(env, SPR_BOOKE_DVC2, "DVC2",
3891 SPR_NOACCESS, SPR_NOACCESS,
3892 &spr_read_generic, &spr_write_generic,
3893 0x00000000);
3894 /* XXX : not implemented */
3895 spr_register(env, SPR_BOOKE_MCSR, "MCSR",
3896 SPR_NOACCESS, SPR_NOACCESS,
3897 &spr_read_generic, &spr_write_generic,
3898 0x00000000);
3899 spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
3900 SPR_NOACCESS, SPR_NOACCESS,
3901 &spr_read_generic, &spr_write_generic,
3902 0x00000000);
3903 spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
3904 SPR_NOACCESS, SPR_NOACCESS,
3905 &spr_read_generic, &spr_write_generic,
3906 0x00000000);
3907 /* XXX : not implemented */
3908 spr_register(env, SPR_440_CCR1, "CCR1",
3909 SPR_NOACCESS, SPR_NOACCESS,
3910 &spr_read_generic, &spr_write_generic,
3911 0x00000000);
3912 /* Memory management */
3913 #if !defined(CONFIG_USER_ONLY)
3914 env->nb_tlb = 64;
3915 env->nb_ways = 1;
3916 env->id_tlbs = 0;
3917 env->tlb_type = TLB_EMB;
3918 #endif
3919 init_excp_BookE(env);
3920 env->dcache_line_size = 32;
3921 env->icache_line_size = 32;
3922 ppc40x_irq_init(env);
3923
3924 SET_FIT_PERIOD(12, 16, 20, 24);
3925 SET_WDT_PERIOD(20, 24, 28, 32);
3926 }
3927
3928 POWERPC_FAMILY(440x5)(ObjectClass *oc, void *data)
3929 {
3930 DeviceClass *dc = DEVICE_CLASS(oc);
3931 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
3932
3933 dc->desc = "PowerPC 440x5";
3934 pcc->init_proc = init_proc_440x5;
3935 pcc->check_pow = check_pow_nocheck;
3936 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
3937 PPC_DCR | PPC_WRTEE | PPC_RFMCI |
3938 PPC_CACHE | PPC_CACHE_ICBI |
3939 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
3940 PPC_MEM_TLBSYNC | PPC_MFTB |
3941 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3942 PPC_440_SPEC;
3943 pcc->insns_flags2 = PPC_NONE;
3944 pcc->msr_mask = 0x000000000006FF30ULL;
3945 pcc->mmu_model = POWERPC_MMU_BOOKE;
3946 pcc->excp_model = POWERPC_EXCP_BOOKE;
3947 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
3948 pcc->bfd_mach = bfd_mach_ppc_403;
3949 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
3950 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
3951 }
3952
3953 static void init_proc_460 (CPUPPCState *env)
3954 {
3955 /* Time base */
3956 gen_tbl(env);
3957 gen_spr_BookE(env, 0x000000000000FFFFULL);
3958 gen_spr_440(env);
3959 gen_spr_usprgh(env);
3960 /* Processor identification */
3961 spr_register(env, SPR_BOOKE_PIR, "PIR",
3962 SPR_NOACCESS, SPR_NOACCESS,
3963 &spr_read_generic, &spr_write_pir,
3964 0x00000000);
3965 /* XXX : not implemented */
3966 spr_register(env, SPR_BOOKE_IAC3, "IAC3",
3967 SPR_NOACCESS, SPR_NOACCESS,
3968 &spr_read_generic, &spr_write_generic,
3969 0x00000000);
3970 /* XXX : not implemented */
3971 spr_register(env, SPR_BOOKE_IAC4, "IAC4",
3972 SPR_NOACCESS, SPR_NOACCESS,
3973 &spr_read_generic, &spr_write_generic,
3974 0x00000000);
3975 /* XXX : not implemented */
3976 spr_register(env, SPR_BOOKE_DVC1, "DVC1",
3977 SPR_NOACCESS, SPR_NOACCESS,
3978 &spr_read_generic, &spr_write_generic,
3979 0x00000000);
3980 /* XXX : not implemented */
3981 spr_register(env, SPR_BOOKE_DVC2, "DVC2",
3982 SPR_NOACCESS, SPR_NOACCESS,
3983 &spr_read_generic, &spr_write_generic,
3984 0x00000000);
3985 /* XXX : not implemented */
3986 spr_register(env, SPR_BOOKE_MCSR, "MCSR",
3987 SPR_NOACCESS, SPR_NOACCESS,
3988 &spr_read_generic, &spr_write_generic,
3989 0x00000000);
3990 spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
3991 SPR_NOACCESS, SPR_NOACCESS,
3992 &spr_read_generic, &spr_write_generic,
3993 0x00000000);
3994 spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
3995 SPR_NOACCESS, SPR_NOACCESS,
3996 &spr_read_generic, &spr_write_generic,
3997 0x00000000);
3998 /* XXX : not implemented */
3999 spr_register(env, SPR_440_CCR1, "CCR1",
4000 SPR_NOACCESS, SPR_NOACCESS,
4001 &spr_read_generic, &spr_write_generic,
4002 0x00000000);
4003 /* XXX : not implemented */
4004 spr_register(env, SPR_DCRIPR, "SPR_DCRIPR",
4005 &spr_read_generic, &spr_write_generic,
4006 &spr_read_generic, &spr_write_generic,
4007 0x00000000);
4008 /* Memory management */
4009 #if !defined(CONFIG_USER_ONLY)
4010 env->nb_tlb = 64;
4011 env->nb_ways = 1;
4012 env->id_tlbs = 0;
4013 env->tlb_type = TLB_EMB;
4014 #endif
4015 init_excp_BookE(env);
4016 env->dcache_line_size = 32;
4017 env->icache_line_size = 32;
4018 /* XXX: TODO: allocate internal IRQ controller */
4019
4020 SET_FIT_PERIOD(12, 16, 20, 24);
4021 SET_WDT_PERIOD(20, 24, 28, 32);
4022 }
4023
4024 POWERPC_FAMILY(460)(ObjectClass *oc, void *data)
4025 {
4026 DeviceClass *dc = DEVICE_CLASS(oc);
4027 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4028
4029 dc->desc = "PowerPC 460 (guessed)";
4030 pcc->init_proc = init_proc_460;
4031 pcc->check_pow = check_pow_nocheck;
4032 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
4033 PPC_DCR | PPC_DCRX | PPC_DCRUX |
4034 PPC_WRTEE | PPC_MFAPIDI | PPC_MFTB |
4035 PPC_CACHE | PPC_CACHE_ICBI |
4036 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4037 PPC_MEM_TLBSYNC | PPC_TLBIVA |
4038 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
4039 PPC_440_SPEC;
4040 pcc->insns_flags2 = PPC_NONE;
4041 pcc->msr_mask = 0x000000000006FF30ULL;
4042 pcc->mmu_model = POWERPC_MMU_BOOKE;
4043 pcc->excp_model = POWERPC_EXCP_BOOKE;
4044 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4045 pcc->bfd_mach = bfd_mach_ppc_403;
4046 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
4047 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
4048 }
4049
4050 static void init_proc_460F (CPUPPCState *env)
4051 {
4052 /* Time base */
4053 gen_tbl(env);
4054 gen_spr_BookE(env, 0x000000000000FFFFULL);
4055 gen_spr_440(env);
4056 gen_spr_usprgh(env);
4057 /* Processor identification */
4058 spr_register(env, SPR_BOOKE_PIR, "PIR",
4059 SPR_NOACCESS, SPR_NOACCESS,
4060 &spr_read_generic, &spr_write_pir,
4061 0x00000000);
4062 /* XXX : not implemented */
4063 spr_register(env, SPR_BOOKE_IAC3, "IAC3",
4064 SPR_NOACCESS, SPR_NOACCESS,
4065 &spr_read_generic, &spr_write_generic,
4066 0x00000000);
4067 /* XXX : not implemented */
4068 spr_register(env, SPR_BOOKE_IAC4, "IAC4",
4069 SPR_NOACCESS, SPR_NOACCESS,
4070 &spr_read_generic, &spr_write_generic,
4071 0x00000000);
4072 /* XXX : not implemented */
4073 spr_register(env, SPR_BOOKE_DVC1, "DVC1",
4074 SPR_NOACCESS, SPR_NOACCESS,
4075 &spr_read_generic, &spr_write_generic,
4076 0x00000000);
4077 /* XXX : not implemented */
4078 spr_register(env, SPR_BOOKE_DVC2, "DVC2",
4079 SPR_NOACCESS, SPR_NOACCESS,
4080 &spr_read_generic, &spr_write_generic,
4081 0x00000000);
4082 /* XXX : not implemented */
4083 spr_register(env, SPR_BOOKE_MCSR, "MCSR",
4084 SPR_NOACCESS, SPR_NOACCESS,
4085 &spr_read_generic, &spr_write_generic,
4086 0x00000000);
4087 spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
4088 SPR_NOACCESS, SPR_NOACCESS,
4089 &spr_read_generic, &spr_write_generic,
4090 0x00000000);
4091 spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
4092 SPR_NOACCESS, SPR_NOACCESS,
4093 &spr_read_generic, &spr_write_generic,
4094 0x00000000);
4095 /* XXX : not implemented */
4096 spr_register(env, SPR_440_CCR1, "CCR1",
4097 SPR_NOACCESS, SPR_NOACCESS,
4098 &spr_read_generic, &spr_write_generic,
4099 0x00000000);
4100 /* XXX : not implemented */
4101 spr_register(env, SPR_DCRIPR, "SPR_DCRIPR",
4102 &spr_read_generic, &spr_write_generic,
4103 &spr_read_generic, &spr_write_generic,
4104 0x00000000);
4105 /* Memory management */
4106 #if !defined(CONFIG_USER_ONLY)
4107 env->nb_tlb = 64;
4108 env->nb_ways = 1;
4109 env->id_tlbs = 0;
4110 env->tlb_type = TLB_EMB;
4111 #endif
4112 init_excp_BookE(env);
4113 env->dcache_line_size = 32;
4114 env->icache_line_size = 32;
4115 /* XXX: TODO: allocate internal IRQ controller */
4116
4117 SET_FIT_PERIOD(12, 16, 20, 24);
4118 SET_WDT_PERIOD(20, 24, 28, 32);
4119 }
4120
4121 POWERPC_FAMILY(460F)(ObjectClass *oc, void *data)
4122 {
4123 DeviceClass *dc = DEVICE_CLASS(oc);
4124 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4125
4126 dc->desc = "PowerPC 460F (guessed)";
4127 pcc->init_proc = init_proc_460F;
4128 pcc->check_pow = check_pow_nocheck;
4129 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
4130 PPC_FLOAT | PPC_FLOAT_FRES | PPC_FLOAT_FSEL |
4131 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
4132 PPC_FLOAT_STFIWX | PPC_MFTB |
4133 PPC_DCR | PPC_DCRX | PPC_DCRUX |
4134 PPC_WRTEE | PPC_MFAPIDI |
4135 PPC_CACHE | PPC_CACHE_ICBI |
4136 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4137 PPC_MEM_TLBSYNC | PPC_TLBIVA |
4138 PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
4139 PPC_440_SPEC;
4140 pcc->insns_flags2 = PPC_NONE;
4141 pcc->msr_mask = 0x000000000006FF30ULL;
4142 pcc->mmu_model = POWERPC_MMU_BOOKE;
4143 pcc->excp_model = POWERPC_EXCP_BOOKE;
4144 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4145 pcc->bfd_mach = bfd_mach_ppc_403;
4146 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DWE |
4147 POWERPC_FLAG_DE | POWERPC_FLAG_BUS_CLK;
4148 }
4149
4150 static void init_proc_MPC5xx (CPUPPCState *env)
4151 {
4152 /* Time base */
4153 gen_tbl(env);
4154 gen_spr_5xx_8xx(env);
4155 gen_spr_5xx(env);
4156 init_excp_MPC5xx(env);
4157 env->dcache_line_size = 32;
4158 env->icache_line_size = 32;
4159 /* XXX: TODO: allocate internal IRQ controller */
4160 }
4161
4162 POWERPC_FAMILY(MPC5xx)(ObjectClass *oc, void *data)
4163 {
4164 DeviceClass *dc = DEVICE_CLASS(oc);
4165 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4166
4167 dc->desc = "Freescale 5xx cores (aka RCPU)";
4168 pcc->init_proc = init_proc_MPC5xx;
4169 pcc->check_pow = check_pow_none;
4170 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
4171 PPC_MEM_EIEIO | PPC_MEM_SYNC |
4172 PPC_CACHE_ICBI | PPC_FLOAT | PPC_FLOAT_STFIWX |
4173 PPC_MFTB;
4174 pcc->insns_flags2 = PPC_NONE;
4175 pcc->msr_mask = 0x000000000001FF43ULL;
4176 pcc->mmu_model = POWERPC_MMU_REAL;
4177 pcc->excp_model = POWERPC_EXCP_603;
4178 pcc->bus_model = PPC_FLAGS_INPUT_RCPU;
4179 pcc->bfd_mach = bfd_mach_ppc_505;
4180 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
4181 POWERPC_FLAG_BUS_CLK;
4182 }
4183
4184 static void init_proc_MPC8xx (CPUPPCState *env)
4185 {
4186 /* Time base */
4187 gen_tbl(env);
4188 gen_spr_5xx_8xx(env);
4189 gen_spr_8xx(env);
4190 init_excp_MPC8xx(env);
4191 env->dcache_line_size = 32;
4192 env->icache_line_size = 32;
4193 /* XXX: TODO: allocate internal IRQ controller */
4194 }
4195
4196 POWERPC_FAMILY(MPC8xx)(ObjectClass *oc, void *data)
4197 {
4198 DeviceClass *dc = DEVICE_CLASS(oc);
4199 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4200
4201 dc->desc = "Freescale 8xx cores (aka PowerQUICC)";
4202 pcc->init_proc = init_proc_MPC8xx;
4203 pcc->check_pow = check_pow_none;
4204 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING |
4205 PPC_MEM_EIEIO | PPC_MEM_SYNC |
4206 PPC_CACHE_ICBI | PPC_MFTB;
4207 pcc->insns_flags2 = PPC_NONE;
4208 pcc->msr_mask = 0x000000000001F673ULL;
4209 pcc->mmu_model = POWERPC_MMU_MPC8xx;
4210 pcc->excp_model = POWERPC_EXCP_603;
4211 pcc->bus_model = PPC_FLAGS_INPUT_RCPU;
4212 pcc->bfd_mach = bfd_mach_ppc_860;
4213 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
4214 POWERPC_FLAG_BUS_CLK;
4215 }
4216
4217 /* Freescale 82xx cores (aka PowerQUICC-II) */
4218
4219 static void init_proc_G2 (CPUPPCState *env)
4220 {
4221 gen_spr_ne_601(env);
4222 gen_spr_G2_755(env);
4223 gen_spr_G2(env);
4224 /* Time base */
4225 gen_tbl(env);
4226 /* External access control */
4227 /* XXX : not implemented */
4228 spr_register(env, SPR_EAR, "EAR",
4229 SPR_NOACCESS, SPR_NOACCESS,
4230 &spr_read_generic, &spr_write_generic,
4231 0x00000000);
4232 /* Hardware implementation register */
4233 /* XXX : not implemented */
4234 spr_register(env, SPR_HID0, "HID0",
4235 SPR_NOACCESS, SPR_NOACCESS,
4236 &spr_read_generic, &spr_write_generic,
4237 0x00000000);
4238 /* XXX : not implemented */
4239 spr_register(env, SPR_HID1, "HID1",
4240 SPR_NOACCESS, SPR_NOACCESS,
4241 &spr_read_generic, &spr_write_generic,
4242 0x00000000);
4243 /* XXX : not implemented */
4244 spr_register(env, SPR_HID2, "HID2",
4245 SPR_NOACCESS, SPR_NOACCESS,
4246 &spr_read_generic, &spr_write_generic,
4247 0x00000000);
4248 /* Memory management */
4249 gen_low_BATs(env);
4250 gen_high_BATs(env);
4251 gen_6xx_7xx_soft_tlb(env, 64, 2);
4252 init_excp_G2(env);
4253 env->dcache_line_size = 32;
4254 env->icache_line_size = 32;
4255 /* Allocate hardware IRQ controller */
4256 ppc6xx_irq_init(env);
4257 }
4258
4259 POWERPC_FAMILY(G2)(ObjectClass *oc, void *data)
4260 {
4261 DeviceClass *dc = DEVICE_CLASS(oc);
4262 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4263
4264 dc->desc = "PowerPC G2";
4265 pcc->init_proc = init_proc_G2;
4266 pcc->check_pow = check_pow_hid0;
4267 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
4268 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
4269 PPC_FLOAT_STFIWX |
4270 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
4271 PPC_MEM_SYNC | PPC_MEM_EIEIO |
4272 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
4273 PPC_SEGMENT | PPC_EXTERN;
4274 pcc->insns_flags2 = PPC_NONE;
4275 pcc->msr_mask = 0x000000000006FFF2ULL;
4276 pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4277 pcc->excp_model = POWERPC_EXCP_G2;
4278 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
4279 pcc->bfd_mach = bfd_mach_ppc_ec603e;
4280 pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
4281 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
4282 }
4283
4284 static void init_proc_G2LE (CPUPPCState *env)
4285 {
4286 gen_spr_ne_601(env);
4287 gen_spr_G2_755(env);
4288 gen_spr_G2(env);
4289 /* Time base */
4290 gen_tbl(env);
4291 /* External access control */
4292 /* XXX : not implemented */
4293 spr_register(env, SPR_EAR, "EAR",
4294 SPR_NOACCESS, SPR_NOACCESS,
4295 &spr_read_generic, &spr_write_generic,
4296 0x00000000);
4297 /* Hardware implementation register */
4298 /* XXX : not implemented */
4299 spr_register(env, SPR_HID0, "HID0",
4300 SPR_NOACCESS, SPR_NOACCESS,
4301 &spr_read_generic, &spr_write_generic,
4302 0x00000000);
4303 /* XXX : not implemented */
4304 spr_register(env, SPR_HID1, "HID1",
4305 SPR_NOACCESS, SPR_NOACCESS,
4306 &spr_read_generic, &spr_write_generic,
4307 0x00000000);
4308 /* XXX : not implemented */
4309 spr_register(env, SPR_HID2, "HID2",
4310 SPR_NOACCESS, SPR_NOACCESS,
4311 &spr_read_generic, &spr_write_generic,
4312 0x00000000);
4313 /* Memory management */
4314 gen_low_BATs(env);
4315 gen_high_BATs(env);
4316 gen_6xx_7xx_soft_tlb(env, 64, 2);
4317 init_excp_G2(env);
4318 env->dcache_line_size = 32;
4319 env->icache_line_size = 32;
4320 /* Allocate hardware IRQ controller */
4321 ppc6xx_irq_init(env);
4322 }
4323
4324 POWERPC_FAMILY(G2LE)(ObjectClass *oc, void *data)
4325 {
4326 DeviceClass *dc = DEVICE_CLASS(oc);
4327 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4328
4329 dc->desc = "PowerPC G2LE";
4330 pcc->init_proc = init_proc_G2LE;
4331 pcc->check_pow = check_pow_hid0;
4332 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
4333 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
4334 PPC_FLOAT_STFIWX |
4335 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
4336 PPC_MEM_SYNC | PPC_MEM_EIEIO |
4337 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
4338 PPC_SEGMENT | PPC_EXTERN;
4339 pcc->insns_flags2 = PPC_NONE;
4340 pcc->msr_mask = 0x000000000007FFF3ULL;
4341 pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4342 pcc->excp_model = POWERPC_EXCP_G2;
4343 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
4344 pcc->bfd_mach = bfd_mach_ppc_ec603e;
4345 pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
4346 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
4347 }
4348
4349 static void init_proc_e200 (CPUPPCState *env)
4350 {
4351 /* Time base */
4352 gen_tbl(env);
4353 gen_spr_BookE(env, 0x000000070000FFFFULL);
4354 /* XXX : not implemented */
4355 spr_register(env, SPR_BOOKE_SPEFSCR, "SPEFSCR",
4356 &spr_read_spefscr, &spr_write_spefscr,
4357 &spr_read_spefscr, &spr_write_spefscr,
4358 0x00000000);
4359 /* Memory management */
4360 gen_spr_BookE206(env, 0x0000005D, NULL);
4361 /* XXX : not implemented */
4362 spr_register(env, SPR_HID0, "HID0",
4363 SPR_NOACCESS, SPR_NOACCESS,
4364 &spr_read_generic, &spr_write_generic,
4365 0x00000000);
4366 /* XXX : not implemented */
4367 spr_register(env, SPR_HID1, "HID1",
4368 SPR_NOACCESS, SPR_NOACCESS,
4369 &spr_read_generic, &spr_write_generic,
4370 0x00000000);
4371 /* XXX : not implemented */
4372 spr_register(env, SPR_Exxx_ALTCTXCR, "ALTCTXCR",
4373 SPR_NOACCESS, SPR_NOACCESS,
4374 &spr_read_generic, &spr_write_generic,
4375 0x00000000);
4376 /* XXX : not implemented */
4377 spr_register(env, SPR_Exxx_BUCSR, "BUCSR",
4378 SPR_NOACCESS, SPR_NOACCESS,
4379 &spr_read_generic, &spr_write_generic,
4380 0x00000000);
4381 /* XXX : not implemented */
4382 spr_register(env, SPR_Exxx_CTXCR, "CTXCR",
4383 SPR_NOACCESS, SPR_NOACCESS,
4384 &spr_read_generic, &spr_write_generic,
4385 0x00000000);
4386 /* XXX : not implemented */
4387 spr_register(env, SPR_Exxx_DBCNT, "DBCNT",
4388 SPR_NOACCESS, SPR_NOACCESS,
4389 &spr_read_generic, &spr_write_generic,
4390 0x00000000);
4391 /* XXX : not implemented */
4392 spr_register(env, SPR_Exxx_DBCR3, "DBCR3",
4393 SPR_NOACCESS, SPR_NOACCESS,
4394 &spr_read_generic, &spr_write_generic,
4395 0x00000000);
4396 /* XXX : not implemented */
4397 spr_register(env, SPR_Exxx_L1CFG0, "L1CFG0",
4398 SPR_NOACCESS, SPR_NOACCESS,
4399 &spr_read_generic, &spr_write_generic,
4400 0x00000000);
4401 /* XXX : not implemented */
4402 spr_register(env, SPR_Exxx_L1CSR0, "L1CSR0",
4403 SPR_NOACCESS, SPR_NOACCESS,
4404 &spr_read_generic, &spr_write_generic,
4405 0x00000000);
4406 /* XXX : not implemented */
4407 spr_register(env, SPR_Exxx_L1FINV0, "L1FINV0",
4408 SPR_NOACCESS, SPR_NOACCESS,
4409 &spr_read_generic, &spr_write_generic,
4410 0x00000000);
4411 /* XXX : not implemented */
4412 spr_register(env, SPR_BOOKE_TLB0CFG, "TLB0CFG",
4413 SPR_NOACCESS, SPR_NOACCESS,
4414 &spr_read_generic, &spr_write_generic,
4415 0x00000000);
4416 /* XXX : not implemented */
4417 spr_register(env, SPR_BOOKE_TLB1CFG, "TLB1CFG",
4418 SPR_NOACCESS, SPR_NOACCESS,
4419 &spr_read_generic, &spr_write_generic,
4420 0x00000000);
4421 /* XXX : not implemented */
4422 spr_register(env, SPR_BOOKE_IAC3, "IAC3",
4423 SPR_NOACCESS, SPR_NOACCESS,
4424 &spr_read_generic, &spr_write_generic,
4425 0x00000000);
4426 /* XXX : not implemented */
4427 spr_register(env, SPR_BOOKE_IAC4, "IAC4",
4428 SPR_NOACCESS, SPR_NOACCESS,
4429 &spr_read_generic, &spr_write_generic,
4430 0x00000000);
4431 /* XXX : not implemented */
4432 spr_register(env, SPR_MMUCSR0, "MMUCSR0",
4433 SPR_NOACCESS, SPR_NOACCESS,
4434 &spr_read_generic, &spr_write_generic,
4435 0x00000000); /* TOFIX */
4436 spr_register(env, SPR_BOOKE_DSRR0, "DSRR0",
4437 SPR_NOACCESS, SPR_NOACCESS,
4438 &spr_read_generic, &spr_write_generic,
4439 0x00000000);
4440 spr_register(env, SPR_BOOKE_DSRR1, "DSRR1",
4441 SPR_NOACCESS, SPR_NOACCESS,
4442 &spr_read_generic, &spr_write_generic,
4443 0x00000000);
4444 #if !defined(CONFIG_USER_ONLY)
4445 env->nb_tlb = 64;
4446 env->nb_ways = 1;
4447 env->id_tlbs = 0;
4448 env->tlb_type = TLB_EMB;
4449 #endif
4450 init_excp_e200(env, 0xFFFF0000UL);
4451 env->dcache_line_size = 32;
4452 env->icache_line_size = 32;
4453 /* XXX: TODO: allocate internal IRQ controller */
4454 }
4455
4456 POWERPC_FAMILY(e200)(ObjectClass *oc, void *data)
4457 {
4458 DeviceClass *dc = DEVICE_CLASS(oc);
4459 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4460
4461 dc->desc = "e200 core";
4462 pcc->init_proc = init_proc_e200;
4463 pcc->check_pow = check_pow_hid0;
4464 /* XXX: unimplemented instructions:
4465 * dcblc
4466 * dcbtlst
4467 * dcbtstls
4468 * icblc
4469 * icbtls
4470 * tlbivax
4471 * all SPE multiply-accumulate instructions
4472 */
4473 pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL |
4474 PPC_SPE | PPC_SPE_SINGLE |
4475 PPC_WRTEE | PPC_RFDI |
4476 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |
4477 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4478 PPC_MEM_TLBSYNC | PPC_TLBIVAX |
4479 PPC_BOOKE;
4480 pcc->insns_flags2 = PPC_NONE;
4481 pcc->msr_mask = 0x000000000606FF30ULL;
4482 pcc->mmu_model = POWERPC_MMU_BOOKE206;
4483 pcc->excp_model = POWERPC_EXCP_BOOKE;
4484 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4485 pcc->bfd_mach = bfd_mach_ppc_860;
4486 pcc->flags = POWERPC_FLAG_SPE | POWERPC_FLAG_CE |
4487 POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |
4488 POWERPC_FLAG_BUS_CLK;
4489 }
4490
4491 static void init_proc_e300 (CPUPPCState *env)
4492 {
4493 gen_spr_ne_601(env);
4494 gen_spr_603(env);
4495 /* Time base */
4496 gen_tbl(env);
4497 /* hardware implementation registers */
4498 /* XXX : not implemented */
4499 spr_register(env, SPR_HID0, "HID0",
4500 SPR_NOACCESS, SPR_NOACCESS,
4501 &spr_read_generic, &spr_write_generic,
4502 0x00000000);
4503 /* XXX : not implemented */
4504 spr_register(env, SPR_HID1, "HID1",
4505 SPR_NOACCESS, SPR_NOACCESS,
4506 &spr_read_generic, &spr_write_generic,
4507 0x00000000);
4508 /* XXX : not implemented */
4509 spr_register(env, SPR_HID2, "HID2",
4510 SPR_NOACCESS, SPR_NOACCESS,
4511 &spr_read_generic, &spr_write_generic,
4512 0x00000000);
4513 /* Memory management */
4514 gen_low_BATs(env);
4515 gen_high_BATs(env);
4516 gen_6xx_7xx_soft_tlb(env, 64, 2);
4517 init_excp_603(env);
4518 env->dcache_line_size = 32;
4519 env->icache_line_size = 32;
4520 /* Allocate hardware IRQ controller */
4521 ppc6xx_irq_init(env);
4522 }
4523
4524 POWERPC_FAMILY(e300)(ObjectClass *oc, void *data)
4525 {
4526 DeviceClass *dc = DEVICE_CLASS(oc);
4527 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4528
4529 dc->desc = "e300 core";
4530 pcc->init_proc = init_proc_e300;
4531 pcc->check_pow = check_pow_hid0;
4532 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
4533 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
4534 PPC_FLOAT_STFIWX |
4535 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
4536 PPC_MEM_SYNC | PPC_MEM_EIEIO |
4537 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
4538 PPC_SEGMENT | PPC_EXTERN;
4539 pcc->insns_flags2 = PPC_NONE;
4540 pcc->msr_mask = 0x000000000007FFF3ULL;
4541 pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4542 pcc->excp_model = POWERPC_EXCP_603;
4543 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
4544 pcc->bfd_mach = bfd_mach_ppc_603;
4545 pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
4546 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
4547 }
4548
4549 #if !defined(CONFIG_USER_ONLY)
4550 static void spr_write_mas73(void *opaque, int sprn, int gprn)
4551 {
4552 TCGv val = tcg_temp_new();
4553 tcg_gen_ext32u_tl(val, cpu_gpr[gprn]);
4554 gen_store_spr(SPR_BOOKE_MAS3, val);
4555 tcg_gen_shri_tl(val, cpu_gpr[gprn], 32);
4556 gen_store_spr(SPR_BOOKE_MAS7, val);
4557 tcg_temp_free(val);
4558 }
4559
4560 static void spr_read_mas73(void *opaque, int gprn, int sprn)
4561 {
4562 TCGv mas7 = tcg_temp_new();
4563 TCGv mas3 = tcg_temp_new();
4564 gen_load_spr(mas7, SPR_BOOKE_MAS7);
4565 tcg_gen_shli_tl(mas7, mas7, 32);
4566 gen_load_spr(mas3, SPR_BOOKE_MAS3);
4567 tcg_gen_or_tl(cpu_gpr[gprn], mas3, mas7);
4568 tcg_temp_free(mas3);
4569 tcg_temp_free(mas7);
4570 }
4571
4572 #endif
4573
4574 enum fsl_e500_version {
4575 fsl_e500v1,
4576 fsl_e500v2,
4577 fsl_e500mc,
4578 fsl_e5500,
4579 };
4580
4581 static void init_proc_e500 (CPUPPCState *env, int version)
4582 {
4583 uint32_t tlbncfg[2];
4584 uint64_t ivor_mask;
4585 uint64_t ivpr_mask = 0xFFFF0000ULL;
4586 uint32_t l1cfg0 = 0x3800 /* 8 ways */
4587 | 0x0020; /* 32 kb */
4588 #if !defined(CONFIG_USER_ONLY)
4589 int i;
4590 #endif
4591
4592 /* Time base */
4593 gen_tbl(env);
4594 /*
4595 * XXX The e500 doesn't implement IVOR7 and IVOR9, but doesn't
4596 * complain when accessing them.
4597 * gen_spr_BookE(env, 0x0000000F0000FD7FULL);
4598 */
4599 switch (version) {
4600 case fsl_e500v1:
4601 case fsl_e500v2:
4602 default:
4603 ivor_mask = 0x0000000F0000FFFFULL;
4604 break;
4605 case fsl_e500mc:
4606 case fsl_e5500:
4607 ivor_mask = 0x000003FE0000FFFFULL;
4608 break;
4609 }
4610 gen_spr_BookE(env, ivor_mask);
4611 /* Processor identification */
4612 spr_register(env, SPR_BOOKE_PIR, "PIR",
4613 SPR_NOACCESS, SPR_NOACCESS,
4614 &spr_read_generic, &spr_write_pir,
4615 0x00000000);
4616 /* XXX : not implemented */
4617 spr_register(env, SPR_BOOKE_SPEFSCR, "SPEFSCR",
4618 &spr_read_spefscr, &spr_write_spefscr,
4619 &spr_read_spefscr, &spr_write_spefscr,
4620 0x00000000);
4621 #if !defined(CONFIG_USER_ONLY)
4622 /* Memory management */
4623 env->nb_pids = 3;
4624 env->nb_ways = 2;
4625 env->id_tlbs = 0;
4626 switch (version) {
4627 case fsl_e500v1:
4628 tlbncfg[0] = gen_tlbncfg(2, 1, 1, 0, 256);
4629 tlbncfg[1] = gen_tlbncfg(16, 1, 9, TLBnCFG_AVAIL | TLBnCFG_IPROT, 16);
4630 break;
4631 case fsl_e500v2:
4632 tlbncfg[0] = gen_tlbncfg(4, 1, 1, 0, 512);
4633 tlbncfg[1] = gen_tlbncfg(16, 1, 12, TLBnCFG_AVAIL | TLBnCFG_IPROT, 16);
4634 break;
4635 case fsl_e500mc:
4636 case fsl_e5500:
4637 tlbncfg[0] = gen_tlbncfg(4, 1, 1, 0, 512);
4638 tlbncfg[1] = gen_tlbncfg(64, 1, 12, TLBnCFG_AVAIL | TLBnCFG_IPROT, 64);
4639 break;
4640 default:
4641 cpu_abort(env, "Unknown CPU: " TARGET_FMT_lx "\n", env->spr[SPR_PVR]);
4642 }
4643 #endif
4644 /* Cache sizes */
4645 switch (version) {
4646 case fsl_e500v1:
4647 case fsl_e500v2:
4648 env->dcache_line_size = 32;
4649 env->icache_line_size = 32;
4650 break;
4651 case fsl_e500mc:
4652 case fsl_e5500:
4653 env->dcache_line_size = 64;
4654 env->icache_line_size = 64;
4655 l1cfg0 |= 0x1000000; /* 64 byte cache block size */
4656 break;
4657 default:
4658 cpu_abort(env, "Unknown CPU: " TARGET_FMT_lx "\n", env->spr[SPR_PVR]);
4659 }
4660 gen_spr_BookE206(env, 0x000000DF, tlbncfg);
4661 /* XXX : not implemented */
4662 spr_register(env, SPR_HID0, "HID0",
4663 SPR_NOACCESS, SPR_NOACCESS,
4664 &spr_read_generic, &spr_write_generic,
4665 0x00000000);
4666 /* XXX : not implemented */
4667 spr_register(env, SPR_HID1, "HID1",
4668 SPR_NOACCESS, SPR_NOACCESS,
4669 &spr_read_generic, &spr_write_generic,
4670 0x00000000);
4671 /* XXX : not implemented */
4672 spr_register(env, SPR_Exxx_BBEAR, "BBEAR",
4673 SPR_NOACCESS, SPR_NOACCESS,
4674 &spr_read_generic, &spr_write_generic,
4675 0x00000000);
4676 /* XXX : not implemented */
4677 spr_register(env, SPR_Exxx_BBTAR, "BBTAR",
4678 SPR_NOACCESS, SPR_NOACCESS,
4679 &spr_read_generic, &spr_write_generic,
4680 0x00000000);
4681 /* XXX : not implemented */
4682 spr_register(env, SPR_Exxx_MCAR, "MCAR",
4683 SPR_NOACCESS, SPR_NOACCESS,
4684 &spr_read_generic, &spr_write_generic,
4685 0x00000000);
4686 /* XXX : not implemented */
4687 spr_register(env, SPR_BOOKE_MCSR, "MCSR",
4688 SPR_NOACCESS, SPR_NOACCESS,
4689 &spr_read_generic, &spr_write_generic,
4690 0x00000000);
4691 /* XXX : not implemented */
4692 spr_register(env, SPR_Exxx_NPIDR, "NPIDR",
4693 SPR_NOACCESS, SPR_NOACCESS,
4694 &spr_read_generic, &spr_write_generic,
4695 0x00000000);
4696 /* XXX : not implemented */
4697 spr_register(env, SPR_Exxx_BUCSR, "BUCSR",
4698 SPR_NOACCESS, SPR_NOACCESS,
4699 &spr_read_generic, &spr_write_generic,
4700 0x00000000);
4701 /* XXX : not implemented */
4702 spr_register(env, SPR_Exxx_L1CFG0, "L1CFG0",
4703 SPR_NOACCESS, SPR_NOACCESS,
4704 &spr_read_generic, &spr_write_generic,
4705 l1cfg0);
4706 /* XXX : not implemented */
4707 spr_register(env, SPR_Exxx_L1CSR0, "L1CSR0",
4708 SPR_NOACCESS, SPR_NOACCESS,
4709 &spr_read_generic, &spr_write_e500_l1csr0,
4710 0x00000000);
4711 /* XXX : not implemented */
4712 spr_register(env, SPR_Exxx_L1CSR1, "L1CSR1",
4713 SPR_NOACCESS, SPR_NOACCESS,
4714 &spr_read_generic, &spr_write_generic,
4715 0x00000000);
4716 spr_register(env, SPR_BOOKE_MCSRR0, "MCSRR0",
4717 SPR_NOACCESS, SPR_NOACCESS,
4718 &spr_read_generic, &spr_write_generic,
4719 0x00000000);
4720 spr_register(env, SPR_BOOKE_MCSRR1, "MCSRR1",
4721 SPR_NOACCESS, SPR_NOACCESS,
4722 &spr_read_generic, &spr_write_generic,
4723 0x00000000);
4724 spr_register(env, SPR_MMUCSR0, "MMUCSR0",
4725 SPR_NOACCESS, SPR_NOACCESS,
4726 &spr_read_generic, &spr_write_booke206_mmucsr0,
4727 0x00000000);
4728 spr_register(env, SPR_BOOKE_EPR, "EPR",
4729 SPR_NOACCESS, SPR_NOACCESS,
4730 &spr_read_generic, SPR_NOACCESS,
4731 0x00000000);
4732 /* XXX better abstract into Emb.xxx features */
4733 if (version == fsl_e5500) {
4734 spr_register(env, SPR_BOOKE_EPCR, "EPCR",
4735 SPR_NOACCESS, SPR_NOACCESS,
4736 &spr_read_generic, &spr_write_generic,
4737 0x00000000);
4738 spr_register(env, SPR_BOOKE_MAS7_MAS3, "MAS7_MAS3",
4739 SPR_NOACCESS, SPR_NOACCESS,
4740 &spr_read_mas73, &spr_write_mas73,
4741 0x00000000);
4742 ivpr_mask = (target_ulong)~0xFFFFULL;
4743 }
4744
4745 #if !defined(CONFIG_USER_ONLY)
4746 env->nb_tlb = 0;
4747 env->tlb_type = TLB_MAS;
4748 for (i = 0; i < BOOKE206_MAX_TLBN; i++) {
4749 env->nb_tlb += booke206_tlb_size(env, i);
4750 }
4751 #endif
4752
4753 init_excp_e200(env, ivpr_mask);
4754 /* Allocate hardware IRQ controller */
4755 ppce500_irq_init(env);
4756 }
4757
4758 static void init_proc_e500v1(CPUPPCState *env)
4759 {
4760 init_proc_e500(env, fsl_e500v1);
4761 }
4762
4763 POWERPC_FAMILY(e500v1)(ObjectClass *oc, void *data)
4764 {
4765 DeviceClass *dc = DEVICE_CLASS(oc);
4766 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4767
4768 dc->desc = "e500v1 core";
4769 pcc->init_proc = init_proc_e500v1;
4770 pcc->check_pow = check_pow_hid0;
4771 pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL |
4772 PPC_SPE | PPC_SPE_SINGLE |
4773 PPC_WRTEE | PPC_RFDI |
4774 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |
4775 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4776 PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC;
4777 pcc->insns_flags2 = PPC2_BOOKE206;
4778 pcc->msr_mask = 0x000000000606FF30ULL;
4779 pcc->mmu_model = POWERPC_MMU_BOOKE206;
4780 pcc->excp_model = POWERPC_EXCP_BOOKE;
4781 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4782 pcc->bfd_mach = bfd_mach_ppc_860;
4783 pcc->flags = POWERPC_FLAG_SPE | POWERPC_FLAG_CE |
4784 POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |
4785 POWERPC_FLAG_BUS_CLK;
4786 }
4787
4788 static void init_proc_e500v2(CPUPPCState *env)
4789 {
4790 init_proc_e500(env, fsl_e500v2);
4791 }
4792
4793 POWERPC_FAMILY(e500v2)(ObjectClass *oc, void *data)
4794 {
4795 DeviceClass *dc = DEVICE_CLASS(oc);
4796 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4797
4798 dc->desc = "e500v2 core";
4799 pcc->init_proc = init_proc_e500v2;
4800 pcc->check_pow = check_pow_hid0;
4801 pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL |
4802 PPC_SPE | PPC_SPE_SINGLE | PPC_SPE_DOUBLE |
4803 PPC_WRTEE | PPC_RFDI |
4804 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |
4805 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4806 PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC;
4807 pcc->insns_flags2 = PPC2_BOOKE206;
4808 pcc->msr_mask = 0x000000000606FF30ULL;
4809 pcc->mmu_model = POWERPC_MMU_BOOKE206;
4810 pcc->excp_model = POWERPC_EXCP_BOOKE;
4811 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4812 pcc->bfd_mach = bfd_mach_ppc_860;
4813 pcc->flags = POWERPC_FLAG_SPE | POWERPC_FLAG_CE |
4814 POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |
4815 POWERPC_FLAG_BUS_CLK;
4816 }
4817
4818 static void init_proc_e500mc(CPUPPCState *env)
4819 {
4820 init_proc_e500(env, fsl_e500mc);
4821 }
4822
4823 POWERPC_FAMILY(e500mc)(ObjectClass *oc, void *data)
4824 {
4825 DeviceClass *dc = DEVICE_CLASS(oc);
4826 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4827
4828 dc->desc = "e500mc core";
4829 pcc->init_proc = init_proc_e500mc;
4830 pcc->check_pow = check_pow_none;
4831 pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL |
4832 PPC_WRTEE | PPC_RFDI | PPC_RFMCI |
4833 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |
4834 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4835 PPC_FLOAT | PPC_FLOAT_FRES |
4836 PPC_FLOAT_FRSQRTE | PPC_FLOAT_FSEL |
4837 PPC_FLOAT_STFIWX | PPC_WAIT |
4838 PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC;
4839 pcc->insns_flags2 = PPC2_BOOKE206 | PPC2_PRCNTL;
4840 pcc->msr_mask = 0x000000001402FB36ULL;
4841 pcc->mmu_model = POWERPC_MMU_BOOKE206;
4842 pcc->excp_model = POWERPC_EXCP_BOOKE;
4843 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4844 /* FIXME: figure out the correct flag for e500mc */
4845 pcc->bfd_mach = bfd_mach_ppc_e500;
4846 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
4847 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
4848 }
4849
4850 #ifdef TARGET_PPC64
4851 static void init_proc_e5500(CPUPPCState *env)
4852 {
4853 init_proc_e500(env, fsl_e5500);
4854 }
4855
4856 POWERPC_FAMILY(e5500)(ObjectClass *oc, void *data)
4857 {
4858 DeviceClass *dc = DEVICE_CLASS(oc);
4859 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4860
4861 dc->desc = "e5500 core";
4862 pcc->init_proc = init_proc_e5500;
4863 pcc->check_pow = check_pow_none;
4864 pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL |
4865 PPC_WRTEE | PPC_RFDI | PPC_RFMCI |
4866 PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |
4867 PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4868 PPC_FLOAT | PPC_FLOAT_FRES |
4869 PPC_FLOAT_FRSQRTE | PPC_FLOAT_FSEL |
4870 PPC_FLOAT_STFIWX | PPC_WAIT |
4871 PPC_MEM_TLBSYNC | PPC_TLBIVAX | PPC_MEM_SYNC |
4872 PPC_64B | PPC_POPCNTB | PPC_POPCNTWD;
4873 pcc->insns_flags2 = PPC2_BOOKE206 | PPC2_PRCNTL;
4874 pcc->msr_mask = 0x000000009402FB36ULL;
4875 pcc->mmu_model = POWERPC_MMU_BOOKE206;
4876 pcc->excp_model = POWERPC_EXCP_BOOKE;
4877 pcc->bus_model = PPC_FLAGS_INPUT_BookE;
4878 /* FIXME: figure out the correct flag for e5500 */
4879 pcc->bfd_mach = bfd_mach_ppc_e500;
4880 pcc->flags = POWERPC_FLAG_CE | POWERPC_FLAG_DE |
4881 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
4882 }
4883 #endif
4884
4885 /* Non-embedded PowerPC */
4886
4887 /* POWER : same as 601, without mfmsr, mfsr */
4888 POWERPC_FAMILY(POWER)(ObjectClass *oc, void *data)
4889 {
4890 DeviceClass *dc = DEVICE_CLASS(oc);
4891 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4892
4893 dc->desc = "POWER";
4894 /* pcc->insns_flags = XXX_TODO; */
4895 /* POWER RSC (from RAD6000) */
4896 pcc->msr_mask = 0x00000000FEF0ULL;
4897 }
4898
4899 #define POWERPC_MSRR_601 (0x0000000000001040ULL)
4900
4901 static void init_proc_601 (CPUPPCState *env)
4902 {
4903 gen_spr_ne_601(env);
4904 gen_spr_601(env);
4905 /* Hardware implementation registers */
4906 /* XXX : not implemented */
4907 spr_register(env, SPR_HID0, "HID0",
4908 SPR_NOACCESS, SPR_NOACCESS,
4909 &spr_read_generic, &spr_write_hid0_601,
4910 0x80010080);
4911 /* XXX : not implemented */
4912 spr_register(env, SPR_HID1, "HID1",
4913 SPR_NOACCESS, SPR_NOACCESS,
4914 &spr_read_generic, &spr_write_generic,
4915 0x00000000);
4916 /* XXX : not implemented */
4917 spr_register(env, SPR_601_HID2, "HID2",
4918 SPR_NOACCESS, SPR_NOACCESS,
4919 &spr_read_generic, &spr_write_generic,
4920 0x00000000);
4921 /* XXX : not implemented */
4922 spr_register(env, SPR_601_HID5, "HID5",
4923 SPR_NOACCESS, SPR_NOACCESS,
4924 &spr_read_generic, &spr_write_generic,
4925 0x00000000);
4926 /* Memory management */
4927 init_excp_601(env);
4928 /* XXX: beware that dcache line size is 64
4929 * but dcbz uses 32 bytes "sectors"
4930 * XXX: this breaks clcs instruction !
4931 */
4932 env->dcache_line_size = 32;
4933 env->icache_line_size = 64;
4934 /* Allocate hardware IRQ controller */
4935 ppc6xx_irq_init(env);
4936 }
4937
4938 POWERPC_FAMILY(601)(ObjectClass *oc, void *data)
4939 {
4940 DeviceClass *dc = DEVICE_CLASS(oc);
4941 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4942
4943 dc->desc = "PowerPC 601";
4944 pcc->init_proc = init_proc_601;
4945 pcc->check_pow = check_pow_none;
4946 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_POWER_BR |
4947 PPC_FLOAT |
4948 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
4949 PPC_MEM_SYNC | PPC_MEM_EIEIO | PPC_MEM_TLBIE |
4950 PPC_SEGMENT | PPC_EXTERN;
4951 pcc->insns_flags2 = PPC_NONE;
4952 pcc->msr_mask = 0x000000000000FD70ULL;
4953 pcc->mmu_model = POWERPC_MMU_601;
4954 pcc->excp_model = POWERPC_EXCP_601;
4955 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
4956 pcc->bfd_mach = bfd_mach_ppc_601;
4957 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_RTC_CLK;
4958 }
4959
4960 #define POWERPC_MSRR_601v (0x0000000000001040ULL)
4961
4962 static void init_proc_601v (CPUPPCState *env)
4963 {
4964 init_proc_601(env);
4965 /* XXX : not implemented */
4966 spr_register(env, SPR_601_HID15, "HID15",
4967 SPR_NOACCESS, SPR_NOACCESS,
4968 &spr_read_generic, &spr_write_generic,
4969 0x00000000);
4970 }
4971
4972 POWERPC_FAMILY(601v)(ObjectClass *oc, void *data)
4973 {
4974 DeviceClass *dc = DEVICE_CLASS(oc);
4975 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
4976
4977 dc->desc = "PowerPC 601v";
4978 pcc->init_proc = init_proc_601v;
4979 pcc->check_pow = check_pow_none;
4980 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_POWER_BR |
4981 PPC_FLOAT |
4982 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
4983 PPC_MEM_SYNC | PPC_MEM_EIEIO | PPC_MEM_TLBIE |
4984 PPC_SEGMENT | PPC_EXTERN;
4985 pcc->insns_flags2 = PPC_NONE;
4986 pcc->msr_mask = 0x000000000000FD70ULL;
4987 pcc->mmu_model = POWERPC_MMU_601;
4988 pcc->excp_model = POWERPC_EXCP_601;
4989 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
4990 pcc->bfd_mach = bfd_mach_ppc_601;
4991 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_RTC_CLK;
4992 }
4993
4994 static void init_proc_602 (CPUPPCState *env)
4995 {
4996 gen_spr_ne_601(env);
4997 gen_spr_602(env);
4998 /* Time base */
4999 gen_tbl(env);
5000 /* hardware implementation registers */
5001 /* XXX : not implemented */
5002 spr_register(env, SPR_HID0, "HID0",
5003 SPR_NOACCESS, SPR_NOACCESS,
5004 &spr_read_generic, &spr_write_generic,
5005 0x00000000);
5006 /* XXX : not implemented */
5007 spr_register(env, SPR_HID1, "HID1",
5008 SPR_NOACCESS, SPR_NOACCESS,
5009 &spr_read_generic, &spr_write_generic,
5010 0x00000000);
5011 /* Memory management */
5012 gen_low_BATs(env);
5013 gen_6xx_7xx_soft_tlb(env, 64, 2);
5014 init_excp_602(env);
5015 env->dcache_line_size = 32;
5016 env->icache_line_size = 32;
5017 /* Allocate hardware IRQ controller */
5018 ppc6xx_irq_init(env);
5019 }
5020
5021 POWERPC_FAMILY(602)(ObjectClass *oc, void *data)
5022 {
5023 DeviceClass *dc = DEVICE_CLASS(oc);
5024 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5025
5026 dc->desc = "PowerPC 602";
5027 pcc->init_proc = init_proc_602;
5028 pcc->check_pow = check_pow_hid0;
5029 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5030 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5031 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5032 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5033 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5034 PPC_MEM_TLBIE | PPC_6xx_TLB | PPC_MEM_TLBSYNC |
5035 PPC_SEGMENT | PPC_602_SPEC;
5036 pcc->insns_flags2 = PPC_NONE;
5037 pcc->msr_mask = 0x0000000000C7FF73ULL;
5038 /* XXX: 602 MMU is quite specific. Should add a special case */
5039 pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5040 pcc->excp_model = POWERPC_EXCP_602;
5041 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5042 pcc->bfd_mach = bfd_mach_ppc_602;
5043 pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
5044 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
5045 }
5046
5047 static void init_proc_603 (CPUPPCState *env)
5048 {
5049 gen_spr_ne_601(env);
5050 gen_spr_603(env);
5051 /* Time base */
5052 gen_tbl(env);
5053 /* hardware implementation registers */
5054 /* XXX : not implemented */
5055 spr_register(env, SPR_HID0, "HID0",
5056 SPR_NOACCESS, SPR_NOACCESS,
5057 &spr_read_generic, &spr_write_generic,
5058 0x00000000);
5059 /* XXX : not implemented */
5060 spr_register(env, SPR_HID1, "HID1",
5061 SPR_NOACCESS, SPR_NOACCESS,
5062 &spr_read_generic, &spr_write_generic,
5063 0x00000000);
5064 /* Memory management */
5065 gen_low_BATs(env);
5066 gen_6xx_7xx_soft_tlb(env, 64, 2);
5067 init_excp_603(env);
5068 env->dcache_line_size = 32;
5069 env->icache_line_size = 32;
5070 /* Allocate hardware IRQ controller */
5071 ppc6xx_irq_init(env);
5072 }
5073
5074 POWERPC_FAMILY(603)(ObjectClass *oc, void *data)
5075 {
5076 DeviceClass *dc = DEVICE_CLASS(oc);
5077 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5078
5079 dc->desc = "PowerPC 603";
5080 pcc->init_proc = init_proc_603;
5081 pcc->check_pow = check_pow_hid0;
5082 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5083 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5084 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5085 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5086 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5087 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
5088 PPC_SEGMENT | PPC_EXTERN;
5089 pcc->insns_flags2 = PPC_NONE;
5090 pcc->msr_mask = 0x000000000007FF73ULL;
5091 pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5092 pcc->excp_model = POWERPC_EXCP_603;
5093 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5094 pcc->bfd_mach = bfd_mach_ppc_603;
5095 pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
5096 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
5097 }
5098
5099 static void init_proc_603E (CPUPPCState *env)
5100 {
5101 gen_spr_ne_601(env);
5102 gen_spr_603(env);
5103 /* Time base */
5104 gen_tbl(env);
5105 /* hardware implementation registers */
5106 /* XXX : not implemented */
5107 spr_register(env, SPR_HID0, "HID0",
5108 SPR_NOACCESS, SPR_NOACCESS,
5109 &spr_read_generic, &spr_write_generic,
5110 0x00000000);
5111 /* XXX : not implemented */
5112 spr_register(env, SPR_HID1, "HID1",
5113 SPR_NOACCESS, SPR_NOACCESS,
5114 &spr_read_generic, &spr_write_generic,
5115 0x00000000);
5116 /* XXX : not implemented */
5117 spr_register(env, SPR_IABR, "IABR",
5118 SPR_NOACCESS, SPR_NOACCESS,
5119 &spr_read_generic, &spr_write_generic,
5120 0x00000000);
5121 /* Memory management */
5122 gen_low_BATs(env);
5123 gen_6xx_7xx_soft_tlb(env, 64, 2);
5124 init_excp_603(env);
5125 env->dcache_line_size = 32;
5126 env->icache_line_size = 32;
5127 /* Allocate hardware IRQ controller */
5128 ppc6xx_irq_init(env);
5129 }
5130
5131 POWERPC_FAMILY(603E)(ObjectClass *oc, void *data)
5132 {
5133 DeviceClass *dc = DEVICE_CLASS(oc);
5134 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5135
5136 dc->desc = "PowerPC 603e";
5137 pcc->init_proc = init_proc_603E;
5138 pcc->check_pow = check_pow_hid0;
5139 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5140 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5141 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5142 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5143 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5144 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
5145 PPC_SEGMENT | PPC_EXTERN;
5146 pcc->insns_flags2 = PPC_NONE;
5147 pcc->msr_mask = 0x000000000007FF73ULL;
5148 pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5149 pcc->excp_model = POWERPC_EXCP_603E;
5150 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5151 pcc->bfd_mach = bfd_mach_ppc_ec603e;
5152 pcc->flags = POWERPC_FLAG_TGPR | POWERPC_FLAG_SE |
5153 POWERPC_FLAG_BE | POWERPC_FLAG_BUS_CLK;
5154 }
5155
5156 static void init_proc_604 (CPUPPCState *env)
5157 {
5158 gen_spr_ne_601(env);
5159 gen_spr_604(env);
5160 /* Time base */
5161 gen_tbl(env);
5162 /* Hardware implementation registers */
5163 /* XXX : not implemented */
5164 spr_register(env, SPR_HID0, "HID0",
5165 SPR_NOACCESS, SPR_NOACCESS,
5166 &spr_read_generic, &spr_write_generic,
5167 0x00000000);
5168 /* Memory management */
5169 gen_low_BATs(env);
5170 init_excp_604(env);
5171 env->dcache_line_size = 32;
5172 env->icache_line_size = 32;
5173 /* Allocate hardware IRQ controller */
5174 ppc6xx_irq_init(env);
5175 }
5176
5177 POWERPC_FAMILY(604)(ObjectClass *oc, void *data)
5178 {
5179 DeviceClass *dc = DEVICE_CLASS(oc);
5180 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5181
5182 dc->desc = "PowerPC 604";
5183 pcc->init_proc = init_proc_604;
5184 pcc->check_pow = check_pow_nocheck;
5185 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5186 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5187 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5188 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5189 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5190 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5191 PPC_SEGMENT | PPC_EXTERN;
5192 pcc->insns_flags2 = PPC_NONE;
5193 pcc->msr_mask = 0x000000000005FF77ULL;
5194 pcc->mmu_model = POWERPC_MMU_32B;
5195 pcc->excp_model = POWERPC_EXCP_604;
5196 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5197 pcc->bfd_mach = bfd_mach_ppc_604;
5198 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5199 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5200 }
5201
5202 static void init_proc_604E (CPUPPCState *env)
5203 {
5204 gen_spr_ne_601(env);
5205 gen_spr_604(env);
5206 /* XXX : not implemented */
5207 spr_register(env, SPR_MMCR1, "MMCR1",
5208 SPR_NOACCESS, SPR_NOACCESS,
5209 &spr_read_generic, &spr_write_generic,
5210 0x00000000);
5211 /* XXX : not implemented */
5212 spr_register(env, SPR_PMC3, "PMC3",
5213 SPR_NOACCESS, SPR_NOACCESS,
5214 &spr_read_generic, &spr_write_generic,
5215 0x00000000);
5216 /* XXX : not implemented */
5217 spr_register(env, SPR_PMC4, "PMC4",
5218 SPR_NOACCESS, SPR_NOACCESS,
5219 &spr_read_generic, &spr_write_generic,
5220 0x00000000);
5221 /* Time base */
5222 gen_tbl(env);
5223 /* Hardware implementation registers */
5224 /* XXX : not implemented */
5225 spr_register(env, SPR_HID0, "HID0",
5226 SPR_NOACCESS, SPR_NOACCESS,
5227 &spr_read_generic, &spr_write_generic,
5228 0x00000000);
5229 /* XXX : not implemented */
5230 spr_register(env, SPR_HID1, "HID1",
5231 SPR_NOACCESS, SPR_NOACCESS,
5232 &spr_read_generic, &spr_write_generic,
5233 0x00000000);
5234 /* Memory management */
5235 gen_low_BATs(env);
5236 init_excp_604(env);
5237 env->dcache_line_size = 32;
5238 env->icache_line_size = 32;
5239 /* Allocate hardware IRQ controller */
5240 ppc6xx_irq_init(env);
5241 }
5242
5243 POWERPC_FAMILY(604E)(ObjectClass *oc, void *data)
5244 {
5245 DeviceClass *dc = DEVICE_CLASS(oc);
5246 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5247
5248 dc->desc = "PowerPC 604E";
5249 pcc->init_proc = init_proc_604E;
5250 pcc->check_pow = check_pow_nocheck;
5251 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5252 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5253 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5254 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5255 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5256 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5257 PPC_SEGMENT | PPC_EXTERN;
5258 pcc->insns_flags2 = PPC_NONE;
5259 pcc->msr_mask = 0x000000000005FF77ULL;
5260 pcc->mmu_model = POWERPC_MMU_32B;
5261 pcc->excp_model = POWERPC_EXCP_604;
5262 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5263 pcc->bfd_mach = bfd_mach_ppc_604;
5264 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5265 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5266 }
5267
5268 static void init_proc_740 (CPUPPCState *env)
5269 {
5270 gen_spr_ne_601(env);
5271 gen_spr_7xx(env);
5272 /* Time base */
5273 gen_tbl(env);
5274 /* Thermal management */
5275 gen_spr_thrm(env);
5276 /* Hardware implementation registers */
5277 /* XXX : not implemented */
5278 spr_register(env, SPR_HID0, "HID0",
5279 SPR_NOACCESS, SPR_NOACCESS,
5280 &spr_read_generic, &spr_write_generic,
5281 0x00000000);
5282 /* XXX : not implemented */
5283 spr_register(env, SPR_HID1, "HID1",
5284 SPR_NOACCESS, SPR_NOACCESS,
5285 &spr_read_generic, &spr_write_generic,
5286 0x00000000);
5287 /* Memory management */
5288 gen_low_BATs(env);
5289 init_excp_7x0(env);
5290 env->dcache_line_size = 32;
5291 env->icache_line_size = 32;
5292 /* Allocate hardware IRQ controller */
5293 ppc6xx_irq_init(env);
5294 }
5295
5296 POWERPC_FAMILY(740)(ObjectClass *oc, void *data)
5297 {
5298 DeviceClass *dc = DEVICE_CLASS(oc);
5299 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5300
5301 dc->desc = "PowerPC 740";
5302 pcc->init_proc = init_proc_740;
5303 pcc->check_pow = check_pow_hid0;
5304 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5305 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5306 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5307 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5308 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5309 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5310 PPC_SEGMENT | PPC_EXTERN;
5311 pcc->insns_flags2 = PPC_NONE;
5312 pcc->msr_mask = 0x000000000005FF77ULL;
5313 pcc->mmu_model = POWERPC_MMU_32B;
5314 pcc->excp_model = POWERPC_EXCP_7x0;
5315 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5316 pcc->bfd_mach = bfd_mach_ppc_750;
5317 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5318 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5319 }
5320
5321 static void init_proc_750 (CPUPPCState *env)
5322 {
5323 gen_spr_ne_601(env);
5324 gen_spr_7xx(env);
5325 /* XXX : not implemented */
5326 spr_register(env, SPR_L2CR, "L2CR",
5327 SPR_NOACCESS, SPR_NOACCESS,
5328 &spr_read_generic, &spr_write_generic,
5329 0x00000000);
5330 /* Time base */
5331 gen_tbl(env);
5332 /* Thermal management */
5333 gen_spr_thrm(env);
5334 /* Hardware implementation registers */
5335 /* XXX : not implemented */
5336 spr_register(env, SPR_HID0, "HID0",
5337 SPR_NOACCESS, SPR_NOACCESS,
5338 &spr_read_generic, &spr_write_generic,
5339 0x00000000);
5340 /* XXX : not implemented */
5341 spr_register(env, SPR_HID1, "HID1",
5342 SPR_NOACCESS, SPR_NOACCESS,
5343 &spr_read_generic, &spr_write_generic,
5344 0x00000000);
5345 /* Memory management */
5346 gen_low_BATs(env);
5347 /* XXX: high BATs are also present but are known to be bugged on
5348 * die version 1.x
5349 */
5350 init_excp_7x0(env);
5351 env->dcache_line_size = 32;
5352 env->icache_line_size = 32;
5353 /* Allocate hardware IRQ controller */
5354 ppc6xx_irq_init(env);
5355 }
5356
5357 POWERPC_FAMILY(750)(ObjectClass *oc, void *data)
5358 {
5359 DeviceClass *dc = DEVICE_CLASS(oc);
5360 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5361
5362 dc->desc = "PowerPC 750";
5363 pcc->init_proc = init_proc_750;
5364 pcc->check_pow = check_pow_hid0;
5365 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5366 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5367 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5368 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5369 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5370 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5371 PPC_SEGMENT | PPC_EXTERN;
5372 pcc->insns_flags2 = PPC_NONE;
5373 pcc->msr_mask = 0x000000000005FF77ULL;
5374 pcc->mmu_model = POWERPC_MMU_32B;
5375 pcc->excp_model = POWERPC_EXCP_7x0;
5376 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5377 pcc->bfd_mach = bfd_mach_ppc_750;
5378 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5379 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5380 }
5381
5382 static void init_proc_750cl (CPUPPCState *env)
5383 {
5384 gen_spr_ne_601(env);
5385 gen_spr_7xx(env);
5386 /* XXX : not implemented */
5387 spr_register(env, SPR_L2CR, "L2CR",
5388 SPR_NOACCESS, SPR_NOACCESS,
5389 &spr_read_generic, &spr_write_generic,
5390 0x00000000);
5391 /* Time base */
5392 gen_tbl(env);
5393 /* Thermal management */
5394 /* Those registers are fake on 750CL */
5395 spr_register(env, SPR_THRM1, "THRM1",
5396 SPR_NOACCESS, SPR_NOACCESS,
5397 &spr_read_generic, &spr_write_generic,
5398 0x00000000);
5399 spr_register(env, SPR_THRM2, "THRM2",
5400 SPR_NOACCESS, SPR_NOACCESS,
5401 &spr_read_generic, &spr_write_generic,
5402 0x00000000);
5403 spr_register(env, SPR_THRM3, "THRM3",
5404 SPR_NOACCESS, SPR_NOACCESS,
5405 &spr_read_generic, &spr_write_generic,
5406 0x00000000);
5407 /* XXX: not implemented */
5408 spr_register(env, SPR_750_TDCL, "TDCL",
5409 SPR_NOACCESS, SPR_NOACCESS,
5410 &spr_read_generic, &spr_write_generic,
5411 0x00000000);
5412 spr_register(env, SPR_750_TDCH, "TDCH",
5413 SPR_NOACCESS, SPR_NOACCESS,
5414 &spr_read_generic, &spr_write_generic,
5415 0x00000000);
5416 /* DMA */
5417 /* XXX : not implemented */
5418 spr_register(env, SPR_750_WPAR, "WPAR",
5419 SPR_NOACCESS, SPR_NOACCESS,
5420 &spr_read_generic, &spr_write_generic,
5421 0x00000000);
5422 spr_register(env, SPR_750_DMAL, "DMAL",
5423 SPR_NOACCESS, SPR_NOACCESS,
5424 &spr_read_generic, &spr_write_generic,
5425 0x00000000);
5426 spr_register(env, SPR_750_DMAU, "DMAU",
5427 SPR_NOACCESS, SPR_NOACCESS,
5428 &spr_read_generic, &spr_write_generic,
5429 0x00000000);
5430 /* Hardware implementation registers */
5431 /* XXX : not implemented */
5432 spr_register(env, SPR_HID0, "HID0",
5433 SPR_NOACCESS, SPR_NOACCESS,
5434 &spr_read_generic, &spr_write_generic,
5435 0x00000000);
5436 /* XXX : not implemented */
5437 spr_register(env, SPR_HID1, "HID1",
5438 SPR_NOACCESS, SPR_NOACCESS,
5439 &spr_read_generic, &spr_write_generic,
5440 0x00000000);
5441 /* XXX : not implemented */
5442 spr_register(env, SPR_750CL_HID2, "HID2",
5443 SPR_NOACCESS, SPR_NOACCESS,
5444 &spr_read_generic, &spr_write_generic,
5445 0x00000000);
5446 /* XXX : not implemented */
5447 spr_register(env, SPR_750CL_HID4, "HID4",
5448 SPR_NOACCESS, SPR_NOACCESS,
5449 &spr_read_generic, &spr_write_generic,
5450 0x00000000);
5451 /* Quantization registers */
5452 /* XXX : not implemented */
5453 spr_register(env, SPR_750_GQR0, "GQR0",
5454 SPR_NOACCESS, SPR_NOACCESS,
5455 &spr_read_generic, &spr_write_generic,
5456 0x00000000);
5457 /* XXX : not implemented */
5458 spr_register(env, SPR_750_GQR1, "GQR1",
5459 SPR_NOACCESS, SPR_NOACCESS,
5460 &spr_read_generic, &spr_write_generic,
5461 0x00000000);
5462 /* XXX : not implemented */
5463 spr_register(env, SPR_750_GQR2, "GQR2",
5464 SPR_NOACCESS, SPR_NOACCESS,
5465 &spr_read_generic, &spr_write_generic,
5466 0x00000000);
5467 /* XXX : not implemented */
5468 spr_register(env, SPR_750_GQR3, "GQR3",
5469 SPR_NOACCESS, SPR_NOACCESS,
5470 &spr_read_generic, &spr_write_generic,
5471 0x00000000);
5472 /* XXX : not implemented */
5473 spr_register(env, SPR_750_GQR4, "GQR4",
5474 SPR_NOACCESS, SPR_NOACCESS,
5475 &spr_read_generic, &spr_write_generic,
5476 0x00000000);
5477 /* XXX : not implemented */
5478 spr_register(env, SPR_750_GQR5, "GQR5",
5479 SPR_NOACCESS, SPR_NOACCESS,
5480 &spr_read_generic, &spr_write_generic,
5481 0x00000000);
5482 /* XXX : not implemented */
5483 spr_register(env, SPR_750_GQR6, "GQR6",
5484 SPR_NOACCESS, SPR_NOACCESS,
5485 &spr_read_generic, &spr_write_generic,
5486 0x00000000);
5487 /* XXX : not implemented */
5488 spr_register(env, SPR_750_GQR7, "GQR7",
5489 SPR_NOACCESS, SPR_NOACCESS,
5490 &spr_read_generic, &spr_write_generic,
5491 0x00000000);
5492 /* Memory management */
5493 gen_low_BATs(env);
5494 /* PowerPC 750cl has 8 DBATs and 8 IBATs */
5495 gen_high_BATs(env);
5496 init_excp_750cl(env);
5497 env->dcache_line_size = 32;
5498 env->icache_line_size = 32;
5499 /* Allocate hardware IRQ controller */
5500 ppc6xx_irq_init(env);
5501 }
5502
5503 POWERPC_FAMILY(750cl)(ObjectClass *oc, void *data)
5504 {
5505 DeviceClass *dc = DEVICE_CLASS(oc);
5506 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5507
5508 dc->desc = "PowerPC 750 CL";
5509 pcc->init_proc = init_proc_750cl;
5510 pcc->check_pow = check_pow_hid0;
5511 /* XXX: not implemented:
5512 * cache lock instructions:
5513 * dcbz_l
5514 * floating point paired instructions
5515 * psq_lux
5516 * psq_lx
5517 * psq_stux
5518 * psq_stx
5519 * ps_abs
5520 * ps_add
5521 * ps_cmpo0
5522 * ps_cmpo1
5523 * ps_cmpu0
5524 * ps_cmpu1
5525 * ps_div
5526 * ps_madd
5527 * ps_madds0
5528 * ps_madds1
5529 * ps_merge00
5530 * ps_merge01
5531 * ps_merge10
5532 * ps_merge11
5533 * ps_mr
5534 * ps_msub
5535 * ps_mul
5536 * ps_muls0
5537 * ps_muls1
5538 * ps_nabs
5539 * ps_neg
5540 * ps_nmadd
5541 * ps_nmsub
5542 * ps_res
5543 * ps_rsqrte
5544 * ps_sel
5545 * ps_sub
5546 * ps_sum0
5547 * ps_sum1
5548 */
5549 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5550 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5551 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5552 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5553 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5554 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5555 PPC_SEGMENT | PPC_EXTERN;
5556 pcc->insns_flags2 = PPC_NONE;
5557 pcc->msr_mask = 0x000000000005FF77ULL;
5558 pcc->mmu_model = POWERPC_MMU_32B;
5559 pcc->excp_model = POWERPC_EXCP_7x0;
5560 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5561 pcc->bfd_mach = bfd_mach_ppc_750;
5562 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5563 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5564 }
5565
5566 static void init_proc_750cx (CPUPPCState *env)
5567 {
5568 gen_spr_ne_601(env);
5569 gen_spr_7xx(env);
5570 /* XXX : not implemented */
5571 spr_register(env, SPR_L2CR, "L2CR",
5572 SPR_NOACCESS, SPR_NOACCESS,
5573 &spr_read_generic, &spr_write_generic,
5574 0x00000000);
5575 /* Time base */
5576 gen_tbl(env);
5577 /* Thermal management */
5578 gen_spr_thrm(env);
5579 /* This register is not implemented but is present for compatibility */
5580 spr_register(env, SPR_SDA, "SDA",
5581 SPR_NOACCESS, SPR_NOACCESS,
5582 &spr_read_generic, &spr_write_generic,
5583 0x00000000);
5584 /* Hardware implementation registers */
5585 /* XXX : not implemented */
5586 spr_register(env, SPR_HID0, "HID0",
5587 SPR_NOACCESS, SPR_NOACCESS,
5588 &spr_read_generic, &spr_write_generic,
5589 0x00000000);
5590 /* XXX : not implemented */
5591 spr_register(env, SPR_HID1, "HID1",
5592 SPR_NOACCESS, SPR_NOACCESS,
5593 &spr_read_generic, &spr_write_generic,
5594 0x00000000);
5595 /* Memory management */
5596 gen_low_BATs(env);
5597 /* PowerPC 750cx has 8 DBATs and 8 IBATs */
5598 gen_high_BATs(env);
5599 init_excp_750cx(env);
5600 env->dcache_line_size = 32;
5601 env->icache_line_size = 32;
5602 /* Allocate hardware IRQ controller */
5603 ppc6xx_irq_init(env);
5604 }
5605
5606 POWERPC_FAMILY(750cx)(ObjectClass *oc, void *data)
5607 {
5608 DeviceClass *dc = DEVICE_CLASS(oc);
5609 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5610
5611 dc->desc = "PowerPC 750CX";
5612 pcc->init_proc = init_proc_750cx;
5613 pcc->check_pow = check_pow_hid0;
5614 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5615 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5616 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5617 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5618 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5619 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5620 PPC_SEGMENT | PPC_EXTERN;
5621 pcc->insns_flags2 = PPC_NONE;
5622 pcc->msr_mask = 0x000000000005FF77ULL;
5623 pcc->mmu_model = POWERPC_MMU_32B;
5624 pcc->excp_model = POWERPC_EXCP_7x0;
5625 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5626 pcc->bfd_mach = bfd_mach_ppc_750;
5627 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5628 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5629 }
5630
5631 static void init_proc_750fx (CPUPPCState *env)
5632 {
5633 gen_spr_ne_601(env);
5634 gen_spr_7xx(env);
5635 /* XXX : not implemented */
5636 spr_register(env, SPR_L2CR, "L2CR",
5637 SPR_NOACCESS, SPR_NOACCESS,
5638 &spr_read_generic, &spr_write_generic,
5639 0x00000000);
5640 /* Time base */
5641 gen_tbl(env);
5642 /* Thermal management */
5643 gen_spr_thrm(env);
5644 /* XXX : not implemented */
5645 spr_register(env, SPR_750_THRM4, "THRM4",
5646 SPR_NOACCESS, SPR_NOACCESS,
5647 &spr_read_generic, &spr_write_generic,
5648 0x00000000);
5649 /* Hardware implementation registers */
5650 /* XXX : not implemented */
5651 spr_register(env, SPR_HID0, "HID0",
5652 SPR_NOACCESS, SPR_NOACCESS,
5653 &spr_read_generic, &spr_write_generic,
5654 0x00000000);
5655 /* XXX : not implemented */
5656 spr_register(env, SPR_HID1, "HID1",
5657 SPR_NOACCESS, SPR_NOACCESS,
5658 &spr_read_generic, &spr_write_generic,
5659 0x00000000);
5660 /* XXX : not implemented */
5661 spr_register(env, SPR_750FX_HID2, "HID2",
5662 SPR_NOACCESS, SPR_NOACCESS,
5663 &spr_read_generic, &spr_write_generic,
5664 0x00000000);
5665 /* Memory management */
5666 gen_low_BATs(env);
5667 /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */
5668 gen_high_BATs(env);
5669 init_excp_7x0(env);
5670 env->dcache_line_size = 32;
5671 env->icache_line_size = 32;
5672 /* Allocate hardware IRQ controller */
5673 ppc6xx_irq_init(env);
5674 }
5675
5676 POWERPC_FAMILY(750fx)(ObjectClass *oc, void *data)
5677 {
5678 DeviceClass *dc = DEVICE_CLASS(oc);
5679 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5680
5681 dc->desc = "PowerPC 750FX";
5682 pcc->init_proc = init_proc_750fx;
5683 pcc->check_pow = check_pow_hid0;
5684 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5685 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5686 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5687 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5688 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5689 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5690 PPC_SEGMENT | PPC_EXTERN;
5691 pcc->insns_flags2 = PPC_NONE;
5692 pcc->msr_mask = 0x000000000005FF77ULL;
5693 pcc->mmu_model = POWERPC_MMU_32B;
5694 pcc->excp_model = POWERPC_EXCP_7x0;
5695 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5696 pcc->bfd_mach = bfd_mach_ppc_750;
5697 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5698 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5699 }
5700
5701 static void init_proc_750gx (CPUPPCState *env)
5702 {
5703 gen_spr_ne_601(env);
5704 gen_spr_7xx(env);
5705 /* XXX : not implemented (XXX: different from 750fx) */
5706 spr_register(env, SPR_L2CR, "L2CR",
5707 SPR_NOACCESS, SPR_NOACCESS,
5708 &spr_read_generic, &spr_write_generic,
5709 0x00000000);
5710 /* Time base */
5711 gen_tbl(env);
5712 /* Thermal management */
5713 gen_spr_thrm(env);
5714 /* XXX : not implemented */
5715 spr_register(env, SPR_750_THRM4, "THRM4",
5716 SPR_NOACCESS, SPR_NOACCESS,
5717 &spr_read_generic, &spr_write_generic,
5718 0x00000000);
5719 /* Hardware implementation registers */
5720 /* XXX : not implemented (XXX: different from 750fx) */
5721 spr_register(env, SPR_HID0, "HID0",
5722 SPR_NOACCESS, SPR_NOACCESS,
5723 &spr_read_generic, &spr_write_generic,
5724 0x00000000);
5725 /* XXX : not implemented */
5726 spr_register(env, SPR_HID1, "HID1",
5727 SPR_NOACCESS, SPR_NOACCESS,
5728 &spr_read_generic, &spr_write_generic,
5729 0x00000000);
5730 /* XXX : not implemented (XXX: different from 750fx) */
5731 spr_register(env, SPR_750FX_HID2, "HID2",
5732 SPR_NOACCESS, SPR_NOACCESS,
5733 &spr_read_generic, &spr_write_generic,
5734 0x00000000);
5735 /* Memory management */
5736 gen_low_BATs(env);
5737 /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */
5738 gen_high_BATs(env);
5739 init_excp_7x0(env);
5740 env->dcache_line_size = 32;
5741 env->icache_line_size = 32;
5742 /* Allocate hardware IRQ controller */
5743 ppc6xx_irq_init(env);
5744 }
5745
5746 POWERPC_FAMILY(750gx)(ObjectClass *oc, void *data)
5747 {
5748 DeviceClass *dc = DEVICE_CLASS(oc);
5749 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5750
5751 dc->desc = "PowerPC 750GX";
5752 pcc->init_proc = init_proc_750gx;
5753 pcc->check_pow = check_pow_hid0;
5754 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5755 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5756 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5757 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5758 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5759 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5760 PPC_SEGMENT | PPC_EXTERN;
5761 pcc->insns_flags2 = PPC_NONE;
5762 pcc->msr_mask = 0x000000000005FF77ULL;
5763 pcc->mmu_model = POWERPC_MMU_32B;
5764 pcc->excp_model = POWERPC_EXCP_7x0;
5765 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5766 pcc->bfd_mach = bfd_mach_ppc_750;
5767 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5768 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5769 }
5770
5771 static void init_proc_745 (CPUPPCState *env)
5772 {
5773 gen_spr_ne_601(env);
5774 gen_spr_7xx(env);
5775 gen_spr_G2_755(env);
5776 /* Time base */
5777 gen_tbl(env);
5778 /* Thermal management */
5779 gen_spr_thrm(env);
5780 /* Hardware implementation registers */
5781 /* XXX : not implemented */
5782 spr_register(env, SPR_HID0, "HID0",
5783 SPR_NOACCESS, SPR_NOACCESS,
5784 &spr_read_generic, &spr_write_generic,
5785 0x00000000);
5786 /* XXX : not implemented */
5787 spr_register(env, SPR_HID1, "HID1",
5788 SPR_NOACCESS, SPR_NOACCESS,
5789 &spr_read_generic, &spr_write_generic,
5790 0x00000000);
5791 /* XXX : not implemented */
5792 spr_register(env, SPR_HID2, "HID2",
5793 SPR_NOACCESS, SPR_NOACCESS,
5794 &spr_read_generic, &spr_write_generic,
5795 0x00000000);
5796 /* Memory management */
5797 gen_low_BATs(env);
5798 gen_high_BATs(env);
5799 gen_6xx_7xx_soft_tlb(env, 64, 2);
5800 init_excp_7x5(env);
5801 env->dcache_line_size = 32;
5802 env->icache_line_size = 32;
5803 /* Allocate hardware IRQ controller */
5804 ppc6xx_irq_init(env);
5805 }
5806
5807 POWERPC_FAMILY(745)(ObjectClass *oc, void *data)
5808 {
5809 DeviceClass *dc = DEVICE_CLASS(oc);
5810 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5811
5812 dc->desc = "PowerPC 745";
5813 pcc->init_proc = init_proc_745;
5814 pcc->check_pow = check_pow_hid0;
5815 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5816 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5817 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5818 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5819 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5820 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
5821 PPC_SEGMENT | PPC_EXTERN;
5822 pcc->insns_flags2 = PPC_NONE;
5823 pcc->msr_mask = 0x000000000005FF77ULL;
5824 pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5825 pcc->excp_model = POWERPC_EXCP_7x5;
5826 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5827 pcc->bfd_mach = bfd_mach_ppc_750;
5828 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5829 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5830 }
5831
5832 static void init_proc_755 (CPUPPCState *env)
5833 {
5834 gen_spr_ne_601(env);
5835 gen_spr_7xx(env);
5836 gen_spr_G2_755(env);
5837 /* Time base */
5838 gen_tbl(env);
5839 /* L2 cache control */
5840 /* XXX : not implemented */
5841 spr_register(env, SPR_L2CR, "L2CR",
5842 SPR_NOACCESS, SPR_NOACCESS,
5843 &spr_read_generic, &spr_write_generic,
5844 0x00000000);
5845 /* XXX : not implemented */
5846 spr_register(env, SPR_L2PMCR, "L2PMCR",
5847 SPR_NOACCESS, SPR_NOACCESS,
5848 &spr_read_generic, &spr_write_generic,
5849 0x00000000);
5850 /* Thermal management */
5851 gen_spr_thrm(env);
5852 /* Hardware implementation registers */
5853 /* XXX : not implemented */
5854 spr_register(env, SPR_HID0, "HID0",
5855 SPR_NOACCESS, SPR_NOACCESS,
5856 &spr_read_generic, &spr_write_generic,
5857 0x00000000);
5858 /* XXX : not implemented */
5859 spr_register(env, SPR_HID1, "HID1",
5860 SPR_NOACCESS, SPR_NOACCESS,
5861 &spr_read_generic, &spr_write_generic,
5862 0x00000000);
5863 /* XXX : not implemented */
5864 spr_register(env, SPR_HID2, "HID2",
5865 SPR_NOACCESS, SPR_NOACCESS,
5866 &spr_read_generic, &spr_write_generic,
5867 0x00000000);
5868 /* Memory management */
5869 gen_low_BATs(env);
5870 gen_high_BATs(env);
5871 gen_6xx_7xx_soft_tlb(env, 64, 2);
5872 init_excp_7x5(env);
5873 env->dcache_line_size = 32;
5874 env->icache_line_size = 32;
5875 /* Allocate hardware IRQ controller */
5876 ppc6xx_irq_init(env);
5877 }
5878
5879 POWERPC_FAMILY(755)(ObjectClass *oc, void *data)
5880 {
5881 DeviceClass *dc = DEVICE_CLASS(oc);
5882 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5883
5884 dc->desc = "PowerPC 755";
5885 pcc->init_proc = init_proc_755;
5886 pcc->check_pow = check_pow_hid0;
5887 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5888 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5889 PPC_FLOAT_FRSQRTE | PPC_FLOAT_STFIWX |
5890 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
5891 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5892 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
5893 PPC_SEGMENT | PPC_EXTERN;
5894 pcc->insns_flags2 = PPC_NONE;
5895 pcc->msr_mask = 0x000000000005FF77ULL;
5896 pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5897 pcc->excp_model = POWERPC_EXCP_7x5;
5898 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5899 pcc->bfd_mach = bfd_mach_ppc_750;
5900 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
5901 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
5902 }
5903
5904 static void init_proc_7400 (CPUPPCState *env)
5905 {
5906 gen_spr_ne_601(env);
5907 gen_spr_7xx(env);
5908 /* Time base */
5909 gen_tbl(env);
5910 /* 74xx specific SPR */
5911 gen_spr_74xx(env);
5912 /* XXX : not implemented */
5913 spr_register(env, SPR_UBAMR, "UBAMR",
5914 &spr_read_ureg, SPR_NOACCESS,
5915 &spr_read_ureg, SPR_NOACCESS,
5916 0x00000000);
5917 /* XXX: this seems not implemented on all revisions. */
5918 /* XXX : not implemented */
5919 spr_register(env, SPR_MSSCR1, "MSSCR1",
5920 SPR_NOACCESS, SPR_NOACCESS,
5921 &spr_read_generic, &spr_write_generic,
5922 0x00000000);
5923 /* Thermal management */
5924 gen_spr_thrm(env);
5925 /* Memory management */
5926 gen_low_BATs(env);
5927 init_excp_7400(env);
5928 env->dcache_line_size = 32;
5929 env->icache_line_size = 32;
5930 /* Allocate hardware IRQ controller */
5931 ppc6xx_irq_init(env);
5932 }
5933
5934 POWERPC_FAMILY(7400)(ObjectClass *oc, void *data)
5935 {
5936 DeviceClass *dc = DEVICE_CLASS(oc);
5937 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
5938
5939 dc->desc = "PowerPC 7400 (aka G4)";
5940 pcc->init_proc = init_proc_7400;
5941 pcc->check_pow = check_pow_hid0;
5942 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
5943 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
5944 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
5945 PPC_FLOAT_STFIWX |
5946 PPC_CACHE | PPC_CACHE_ICBI |
5947 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
5948 PPC_MEM_SYNC | PPC_MEM_EIEIO |
5949 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5950 PPC_MEM_TLBIA |
5951 PPC_SEGMENT | PPC_EXTERN |
5952 PPC_ALTIVEC;
5953 pcc->insns_flags2 = PPC_NONE;
5954 pcc->msr_mask = 0x000000000205FF77ULL;
5955 pcc->mmu_model = POWERPC_MMU_32B;
5956 pcc->excp_model = POWERPC_EXCP_74xx;
5957 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
5958 pcc->bfd_mach = bfd_mach_ppc_7400;
5959 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
5960 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
5961 POWERPC_FLAG_BUS_CLK;
5962 }
5963
5964 static void init_proc_7410 (CPUPPCState *env)
5965 {
5966 gen_spr_ne_601(env);
5967 gen_spr_7xx(env);
5968 /* Time base */
5969 gen_tbl(env);
5970 /* 74xx specific SPR */
5971 gen_spr_74xx(env);
5972 /* XXX : not implemented */
5973 spr_register(env, SPR_UBAMR, "UBAMR",
5974 &spr_read_ureg, SPR_NOACCESS,
5975 &spr_read_ureg, SPR_NOACCESS,
5976 0x00000000);
5977 /* Thermal management */
5978 gen_spr_thrm(env);
5979 /* L2PMCR */
5980 /* XXX : not implemented */
5981 spr_register(env, SPR_L2PMCR, "L2PMCR",
5982 SPR_NOACCESS, SPR_NOACCESS,
5983 &spr_read_generic, &spr_write_generic,
5984 0x00000000);
5985 /* LDSTDB */
5986 /* XXX : not implemented */
5987 spr_register(env, SPR_LDSTDB, "LDSTDB",
5988 SPR_NOACCESS, SPR_NOACCESS,
5989 &spr_read_generic, &spr_write_generic,
5990 0x00000000);
5991 /* Memory management */
5992 gen_low_BATs(env);
5993 init_excp_7400(env);
5994 env->dcache_line_size = 32;
5995 env->icache_line_size = 32;
5996 /* Allocate hardware IRQ controller */
5997 ppc6xx_irq_init(env);
5998 }
5999
6000 POWERPC_FAMILY(7410)(ObjectClass *oc, void *data)
6001 {
6002 DeviceClass *dc = DEVICE_CLASS(oc);
6003 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6004
6005 dc->desc = "PowerPC 7410 (aka G4)";
6006 pcc->init_proc = init_proc_7410;
6007 pcc->check_pow = check_pow_hid0;
6008 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6009 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6010 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6011 PPC_FLOAT_STFIWX |
6012 PPC_CACHE | PPC_CACHE_ICBI |
6013 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6014 PPC_MEM_SYNC | PPC_MEM_EIEIO |
6015 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6016 PPC_MEM_TLBIA |
6017 PPC_SEGMENT | PPC_EXTERN |
6018 PPC_ALTIVEC;
6019 pcc->insns_flags2 = PPC_NONE;
6020 pcc->msr_mask = 0x000000000205FF77ULL;
6021 pcc->mmu_model = POWERPC_MMU_32B;
6022 pcc->excp_model = POWERPC_EXCP_74xx;
6023 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6024 pcc->bfd_mach = bfd_mach_ppc_7400;
6025 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6026 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6027 POWERPC_FLAG_BUS_CLK;
6028 }
6029
6030 static void init_proc_7440 (CPUPPCState *env)
6031 {
6032 gen_spr_ne_601(env);
6033 gen_spr_7xx(env);
6034 /* Time base */
6035 gen_tbl(env);
6036 /* 74xx specific SPR */
6037 gen_spr_74xx(env);
6038 /* XXX : not implemented */
6039 spr_register(env, SPR_UBAMR, "UBAMR",
6040 &spr_read_ureg, SPR_NOACCESS,
6041 &spr_read_ureg, SPR_NOACCESS,
6042 0x00000000);
6043 /* LDSTCR */
6044 /* XXX : not implemented */
6045 spr_register(env, SPR_LDSTCR, "LDSTCR",
6046 SPR_NOACCESS, SPR_NOACCESS,
6047 &spr_read_generic, &spr_write_generic,
6048 0x00000000);
6049 /* ICTRL */
6050 /* XXX : not implemented */
6051 spr_register(env, SPR_ICTRL, "ICTRL",
6052 SPR_NOACCESS, SPR_NOACCESS,
6053 &spr_read_generic, &spr_write_generic,
6054 0x00000000);
6055 /* MSSSR0 */
6056 /* XXX : not implemented */
6057 spr_register(env, SPR_MSSSR0, "MSSSR0",
6058 SPR_NOACCESS, SPR_NOACCESS,
6059 &spr_read_generic, &spr_write_generic,
6060 0x00000000);
6061 /* PMC */
6062 /* XXX : not implemented */
6063 spr_register(env, SPR_PMC5, "PMC5",
6064 SPR_NOACCESS, SPR_NOACCESS,
6065 &spr_read_generic, &spr_write_generic,
6066 0x00000000);
6067 /* XXX : not implemented */
6068 spr_register(env, SPR_UPMC5, "UPMC5",
6069 &spr_read_ureg, SPR_NOACCESS,
6070 &spr_read_ureg, SPR_NOACCESS,
6071 0x00000000);
6072 /* XXX : not implemented */
6073 spr_register(env, SPR_PMC6, "PMC6",
6074 SPR_NOACCESS, SPR_NOACCESS,
6075 &spr_read_generic, &spr_write_generic,
6076 0x00000000);
6077 /* XXX : not implemented */
6078 spr_register(env, SPR_UPMC6, "UPMC6",
6079 &spr_read_ureg, SPR_NOACCESS,
6080 &spr_read_ureg, SPR_NOACCESS,
6081 0x00000000);
6082 /* Memory management */
6083 gen_low_BATs(env);
6084 gen_74xx_soft_tlb(env, 128, 2);
6085 init_excp_7450(env);
6086 env->dcache_line_size = 32;
6087 env->icache_line_size = 32;
6088 /* Allocate hardware IRQ controller */
6089 ppc6xx_irq_init(env);
6090 }
6091
6092 POWERPC_FAMILY(7440)(ObjectClass *oc, void *data)
6093 {
6094 DeviceClass *dc = DEVICE_CLASS(oc);
6095 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6096
6097 dc->desc = "PowerPC 7440 (aka G4)";
6098 pcc->init_proc = init_proc_7440;
6099 pcc->check_pow = check_pow_hid0_74xx;
6100 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6101 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6102 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6103 PPC_FLOAT_STFIWX |
6104 PPC_CACHE | PPC_CACHE_ICBI |
6105 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6106 PPC_MEM_SYNC | PPC_MEM_EIEIO |
6107 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6108 PPC_MEM_TLBIA | PPC_74xx_TLB |
6109 PPC_SEGMENT | PPC_EXTERN |
6110 PPC_ALTIVEC;
6111 pcc->insns_flags2 = PPC_NONE;
6112 pcc->msr_mask = 0x000000000205FF77ULL;
6113 pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6114 pcc->excp_model = POWERPC_EXCP_74xx;
6115 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6116 pcc->bfd_mach = bfd_mach_ppc_7400;
6117 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6118 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6119 POWERPC_FLAG_BUS_CLK;
6120 }
6121
6122 static void init_proc_7450 (CPUPPCState *env)
6123 {
6124 gen_spr_ne_601(env);
6125 gen_spr_7xx(env);
6126 /* Time base */
6127 gen_tbl(env);
6128 /* 74xx specific SPR */
6129 gen_spr_74xx(env);
6130 /* Level 3 cache control */
6131 gen_l3_ctrl(env);
6132 /* L3ITCR1 */
6133 /* XXX : not implemented */
6134 spr_register(env, SPR_L3ITCR1, "L3ITCR1",
6135 SPR_NOACCESS, SPR_NOACCESS,
6136 &spr_read_generic, &spr_write_generic,
6137 0x00000000);
6138 /* L3ITCR2 */
6139 /* XXX : not implemented */
6140 spr_register(env, SPR_L3ITCR2, "L3ITCR2",
6141 SPR_NOACCESS, SPR_NOACCESS,
6142 &spr_read_generic, &spr_write_generic,
6143 0x00000000);
6144 /* L3ITCR3 */
6145 /* XXX : not implemented */
6146 spr_register(env, SPR_L3ITCR3, "L3ITCR3",
6147 SPR_NOACCESS, SPR_NOACCESS,
6148 &spr_read_generic, &spr_write_generic,
6149 0x00000000);
6150 /* L3OHCR */
6151 /* XXX : not implemented */
6152 spr_register(env, SPR_L3OHCR, "L3OHCR",
6153 SPR_NOACCESS, SPR_NOACCESS,
6154 &spr_read_generic, &spr_write_generic,
6155 0x00000000);
6156 /* XXX : not implemented */
6157 spr_register(env, SPR_UBAMR, "UBAMR",
6158 &spr_read_ureg, SPR_NOACCESS,
6159 &spr_read_ureg, SPR_NOACCESS,
6160 0x00000000);
6161 /* LDSTCR */
6162 /* XXX : not implemented */
6163 spr_register(env, SPR_LDSTCR, "LDSTCR",
6164 SPR_NOACCESS, SPR_NOACCESS,
6165 &spr_read_generic, &spr_write_generic,
6166 0x00000000);
6167 /* ICTRL */
6168 /* XXX : not implemented */
6169 spr_register(env, SPR_ICTRL, "ICTRL",
6170 SPR_NOACCESS, SPR_NOACCESS,
6171 &spr_read_generic, &spr_write_generic,
6172 0x00000000);
6173 /* MSSSR0 */
6174 /* XXX : not implemented */
6175 spr_register(env, SPR_MSSSR0, "MSSSR0",
6176 SPR_NOACCESS, SPR_NOACCESS,
6177 &spr_read_generic, &spr_write_generic,
6178 0x00000000);
6179 /* PMC */
6180 /* XXX : not implemented */
6181 spr_register(env, SPR_PMC5, "PMC5",
6182 SPR_NOACCESS, SPR_NOACCESS,
6183 &spr_read_generic, &spr_write_generic,
6184 0x00000000);
6185 /* XXX : not implemented */
6186 spr_register(env, SPR_UPMC5, "UPMC5",
6187 &spr_read_ureg, SPR_NOACCESS,
6188 &spr_read_ureg, SPR_NOACCESS,
6189 0x00000000);
6190 /* XXX : not implemented */
6191 spr_register(env, SPR_PMC6, "PMC6",
6192 SPR_NOACCESS, SPR_NOACCESS,
6193 &spr_read_generic, &spr_write_generic,
6194 0x00000000);
6195 /* XXX : not implemented */
6196 spr_register(env, SPR_UPMC6, "UPMC6",
6197 &spr_read_ureg, SPR_NOACCESS,
6198 &spr_read_ureg, SPR_NOACCESS,
6199 0x00000000);
6200 /* Memory management */
6201 gen_low_BATs(env);
6202 gen_74xx_soft_tlb(env, 128, 2);
6203 init_excp_7450(env);
6204 env->dcache_line_size = 32;
6205 env->icache_line_size = 32;
6206 /* Allocate hardware IRQ controller */
6207 ppc6xx_irq_init(env);
6208 }
6209
6210 POWERPC_FAMILY(7450)(ObjectClass *oc, void *data)
6211 {
6212 DeviceClass *dc = DEVICE_CLASS(oc);
6213 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6214
6215 dc->desc = "PowerPC 7450 (aka G4)";
6216 pcc->init_proc = init_proc_7450;
6217 pcc->check_pow = check_pow_hid0_74xx;
6218 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6219 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6220 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6221 PPC_FLOAT_STFIWX |
6222 PPC_CACHE | PPC_CACHE_ICBI |
6223 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6224 PPC_MEM_SYNC | PPC_MEM_EIEIO |
6225 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6226 PPC_MEM_TLBIA | PPC_74xx_TLB |
6227 PPC_SEGMENT | PPC_EXTERN |
6228 PPC_ALTIVEC;
6229 pcc->insns_flags2 = PPC_NONE;
6230 pcc->msr_mask = 0x000000000205FF77ULL;
6231 pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6232 pcc->excp_model = POWERPC_EXCP_74xx;
6233 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6234 pcc->bfd_mach = bfd_mach_ppc_7400;
6235 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6236 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6237 POWERPC_FLAG_BUS_CLK;
6238 }
6239
6240 static void init_proc_7445 (CPUPPCState *env)
6241 {
6242 gen_spr_ne_601(env);
6243 gen_spr_7xx(env);
6244 /* Time base */
6245 gen_tbl(env);
6246 /* 74xx specific SPR */
6247 gen_spr_74xx(env);
6248 /* LDSTCR */
6249 /* XXX : not implemented */
6250 spr_register(env, SPR_LDSTCR, "LDSTCR",
6251 SPR_NOACCESS, SPR_NOACCESS,
6252 &spr_read_generic, &spr_write_generic,
6253 0x00000000);
6254 /* ICTRL */
6255 /* XXX : not implemented */
6256 spr_register(env, SPR_ICTRL, "ICTRL",
6257 SPR_NOACCESS, SPR_NOACCESS,
6258 &spr_read_generic, &spr_write_generic,
6259 0x00000000);
6260 /* MSSSR0 */
6261 /* XXX : not implemented */
6262 spr_register(env, SPR_MSSSR0, "MSSSR0",
6263 SPR_NOACCESS, SPR_NOACCESS,
6264 &spr_read_generic, &spr_write_generic,
6265 0x00000000);
6266 /* PMC */
6267 /* XXX : not implemented */
6268 spr_register(env, SPR_PMC5, "PMC5",
6269 SPR_NOACCESS, SPR_NOACCESS,
6270 &spr_read_generic, &spr_write_generic,
6271 0x00000000);
6272 /* XXX : not implemented */
6273 spr_register(env, SPR_UPMC5, "UPMC5",
6274 &spr_read_ureg, SPR_NOACCESS,
6275 &spr_read_ureg, SPR_NOACCESS,
6276 0x00000000);
6277 /* XXX : not implemented */
6278 spr_register(env, SPR_PMC6, "PMC6",
6279 SPR_NOACCESS, SPR_NOACCESS,
6280 &spr_read_generic, &spr_write_generic,
6281 0x00000000);
6282 /* XXX : not implemented */
6283 spr_register(env, SPR_UPMC6, "UPMC6",
6284 &spr_read_ureg, SPR_NOACCESS,
6285 &spr_read_ureg, SPR_NOACCESS,
6286 0x00000000);
6287 /* SPRGs */
6288 spr_register(env, SPR_SPRG4, "SPRG4",
6289 SPR_NOACCESS, SPR_NOACCESS,
6290 &spr_read_generic, &spr_write_generic,
6291 0x00000000);
6292 spr_register(env, SPR_USPRG4, "USPRG4",
6293 &spr_read_ureg, SPR_NOACCESS,
6294 &spr_read_ureg, SPR_NOACCESS,
6295 0x00000000);
6296 spr_register(env, SPR_SPRG5, "SPRG5",
6297 SPR_NOACCESS, SPR_NOACCESS,
6298 &spr_read_generic, &spr_write_generic,
6299 0x00000000);
6300 spr_register(env, SPR_USPRG5, "USPRG5",
6301 &spr_read_ureg, SPR_NOACCESS,
6302 &spr_read_ureg, SPR_NOACCESS,
6303 0x00000000);
6304 spr_register(env, SPR_SPRG6, "SPRG6",
6305 SPR_NOACCESS, SPR_NOACCESS,
6306 &spr_read_generic, &spr_write_generic,
6307 0x00000000);
6308 spr_register(env, SPR_USPRG6, "USPRG6",
6309 &spr_read_ureg, SPR_NOACCESS,
6310 &spr_read_ureg, SPR_NOACCESS,
6311 0x00000000);
6312 spr_register(env, SPR_SPRG7, "SPRG7",
6313 SPR_NOACCESS, SPR_NOACCESS,
6314 &spr_read_generic, &spr_write_generic,
6315 0x00000000);
6316 spr_register(env, SPR_USPRG7, "USPRG7",
6317 &spr_read_ureg, SPR_NOACCESS,
6318 &spr_read_ureg, SPR_NOACCESS,
6319 0x00000000);
6320 /* Memory management */
6321 gen_low_BATs(env);
6322 gen_high_BATs(env);
6323 gen_74xx_soft_tlb(env, 128, 2);
6324 init_excp_7450(env);
6325 env->dcache_line_size = 32;
6326 env->icache_line_size = 32;
6327 /* Allocate hardware IRQ controller */
6328 ppc6xx_irq_init(env);
6329 }
6330
6331 POWERPC_FAMILY(7445)(ObjectClass *oc, void *data)
6332 {
6333 DeviceClass *dc = DEVICE_CLASS(oc);
6334 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6335
6336 dc->desc = "PowerPC 7445 (aka G4)";
6337 pcc->init_proc = init_proc_7445;
6338 pcc->check_pow = check_pow_hid0_74xx;
6339 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6340 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6341 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6342 PPC_FLOAT_STFIWX |
6343 PPC_CACHE | PPC_CACHE_ICBI |
6344 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6345 PPC_MEM_SYNC | PPC_MEM_EIEIO |
6346 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6347 PPC_MEM_TLBIA | PPC_74xx_TLB |
6348 PPC_SEGMENT | PPC_EXTERN |
6349 PPC_ALTIVEC;
6350 pcc->insns_flags2 = PPC_NONE;
6351 pcc->msr_mask = 0x000000000205FF77ULL;
6352 pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6353 pcc->excp_model = POWERPC_EXCP_74xx;
6354 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6355 pcc->bfd_mach = bfd_mach_ppc_7400;
6356 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6357 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6358 POWERPC_FLAG_BUS_CLK;
6359 }
6360
6361 static void init_proc_7455 (CPUPPCState *env)
6362 {
6363 gen_spr_ne_601(env);
6364 gen_spr_7xx(env);
6365 /* Time base */
6366 gen_tbl(env);
6367 /* 74xx specific SPR */
6368 gen_spr_74xx(env);
6369 /* Level 3 cache control */
6370 gen_l3_ctrl(env);
6371 /* LDSTCR */
6372 /* XXX : not implemented */
6373 spr_register(env, SPR_LDSTCR, "LDSTCR",
6374 SPR_NOACCESS, SPR_NOACCESS,
6375 &spr_read_generic, &spr_write_generic,
6376 0x00000000);
6377 /* ICTRL */
6378 /* XXX : not implemented */
6379 spr_register(env, SPR_ICTRL, "ICTRL",
6380 SPR_NOACCESS, SPR_NOACCESS,
6381 &spr_read_generic, &spr_write_generic,
6382 0x00000000);
6383 /* MSSSR0 */
6384 /* XXX : not implemented */
6385 spr_register(env, SPR_MSSSR0, "MSSSR0",
6386 SPR_NOACCESS, SPR_NOACCESS,
6387 &spr_read_generic, &spr_write_generic,
6388 0x00000000);
6389 /* PMC */
6390 /* XXX : not implemented */
6391 spr_register(env, SPR_PMC5, "PMC5",
6392 SPR_NOACCESS, SPR_NOACCESS,
6393 &spr_read_generic, &spr_write_generic,
6394 0x00000000);
6395 /* XXX : not implemented */
6396 spr_register(env, SPR_UPMC5, "UPMC5",
6397 &spr_read_ureg, SPR_NOACCESS,
6398 &spr_read_ureg, SPR_NOACCESS,
6399 0x00000000);
6400 /* XXX : not implemented */
6401 spr_register(env, SPR_PMC6, "PMC6",
6402 SPR_NOACCESS, SPR_NOACCESS,
6403 &spr_read_generic, &spr_write_generic,
6404 0x00000000);
6405 /* XXX : not implemented */
6406 spr_register(env, SPR_UPMC6, "UPMC6",
6407 &spr_read_ureg, SPR_NOACCESS,
6408 &spr_read_ureg, SPR_NOACCESS,
6409 0x00000000);
6410 /* SPRGs */
6411 spr_register(env, SPR_SPRG4, "SPRG4",
6412 SPR_NOACCESS, SPR_NOACCESS,
6413 &spr_read_generic, &spr_write_generic,
6414 0x00000000);
6415 spr_register(env, SPR_USPRG4, "USPRG4",
6416 &spr_read_ureg, SPR_NOACCESS,
6417 &spr_read_ureg, SPR_NOACCESS,
6418 0x00000000);
6419 spr_register(env, SPR_SPRG5, "SPRG5",
6420 SPR_NOACCESS, SPR_NOACCESS,
6421 &spr_read_generic, &spr_write_generic,
6422 0x00000000);
6423 spr_register(env, SPR_USPRG5, "USPRG5",
6424 &spr_read_ureg, SPR_NOACCESS,
6425 &spr_read_ureg, SPR_NOACCESS,
6426 0x00000000);
6427 spr_register(env, SPR_SPRG6, "SPRG6",
6428 SPR_NOACCESS, SPR_NOACCESS,
6429 &spr_read_generic, &spr_write_generic,
6430 0x00000000);
6431 spr_register(env, SPR_USPRG6, "USPRG6",
6432 &spr_read_ureg, SPR_NOACCESS,
6433 &spr_read_ureg, SPR_NOACCESS,
6434 0x00000000);
6435 spr_register(env, SPR_SPRG7, "SPRG7",
6436 SPR_NOACCESS, SPR_NOACCESS,
6437 &spr_read_generic, &spr_write_generic,
6438 0x00000000);
6439 spr_register(env, SPR_USPRG7, "USPRG7",
6440 &spr_read_ureg, SPR_NOACCESS,
6441 &spr_read_ureg, SPR_NOACCESS,
6442 0x00000000);
6443 /* Memory management */
6444 gen_low_BATs(env);
6445 gen_high_BATs(env);
6446 gen_74xx_soft_tlb(env, 128, 2);
6447 init_excp_7450(env);
6448 env->dcache_line_size = 32;
6449 env->icache_line_size = 32;
6450 /* Allocate hardware IRQ controller */
6451 ppc6xx_irq_init(env);
6452 }
6453
6454 POWERPC_FAMILY(7455)(ObjectClass *oc, void *data)
6455 {
6456 DeviceClass *dc = DEVICE_CLASS(oc);
6457 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6458
6459 dc->desc = "PowerPC 7455 (aka G4)";
6460 pcc->init_proc = init_proc_7455;
6461 pcc->check_pow = check_pow_hid0_74xx;
6462 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6463 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6464 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6465 PPC_FLOAT_STFIWX |
6466 PPC_CACHE | PPC_CACHE_ICBI |
6467 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6468 PPC_MEM_SYNC | PPC_MEM_EIEIO |
6469 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6470 PPC_MEM_TLBIA | PPC_74xx_TLB |
6471 PPC_SEGMENT | PPC_EXTERN |
6472 PPC_ALTIVEC;
6473 pcc->insns_flags2 = PPC_NONE;
6474 pcc->msr_mask = 0x000000000205FF77ULL;
6475 pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6476 pcc->excp_model = POWERPC_EXCP_74xx;
6477 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6478 pcc->bfd_mach = bfd_mach_ppc_7400;
6479 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6480 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6481 POWERPC_FLAG_BUS_CLK;
6482 }
6483
6484 static void init_proc_7457 (CPUPPCState *env)
6485 {
6486 gen_spr_ne_601(env);
6487 gen_spr_7xx(env);
6488 /* Time base */
6489 gen_tbl(env);
6490 /* 74xx specific SPR */
6491 gen_spr_74xx(env);
6492 /* Level 3 cache control */
6493 gen_l3_ctrl(env);
6494 /* L3ITCR1 */
6495 /* XXX : not implemented */
6496 spr_register(env, SPR_L3ITCR1, "L3ITCR1",
6497 SPR_NOACCESS, SPR_NOACCESS,
6498 &spr_read_generic, &spr_write_generic,
6499 0x00000000);
6500 /* L3ITCR2 */
6501 /* XXX : not implemented */
6502 spr_register(env, SPR_L3ITCR2, "L3ITCR2",
6503 SPR_NOACCESS, SPR_NOACCESS,
6504 &spr_read_generic, &spr_write_generic,
6505 0x00000000);
6506 /* L3ITCR3 */
6507 /* XXX : not implemented */
6508 spr_register(env, SPR_L3ITCR3, "L3ITCR3",
6509 SPR_NOACCESS, SPR_NOACCESS,
6510 &spr_read_generic, &spr_write_generic,
6511 0x00000000);
6512 /* L3OHCR */
6513 /* XXX : not implemented */
6514 spr_register(env, SPR_L3OHCR, "L3OHCR",
6515 SPR_NOACCESS, SPR_NOACCESS,
6516 &spr_read_generic, &spr_write_generic,
6517 0x00000000);
6518 /* LDSTCR */
6519 /* XXX : not implemented */
6520 spr_register(env, SPR_LDSTCR, "LDSTCR",
6521 SPR_NOACCESS, SPR_NOACCESS,
6522 &spr_read_generic, &spr_write_generic,
6523 0x00000000);
6524 /* ICTRL */
6525 /* XXX : not implemented */
6526 spr_register(env, SPR_ICTRL, "ICTRL",
6527 SPR_NOACCESS, SPR_NOACCESS,
6528 &spr_read_generic, &spr_write_generic,
6529 0x00000000);
6530 /* MSSSR0 */
6531 /* XXX : not implemented */
6532 spr_register(env, SPR_MSSSR0, "MSSSR0",
6533 SPR_NOACCESS, SPR_NOACCESS,
6534 &spr_read_generic, &spr_write_generic,
6535 0x00000000);
6536 /* PMC */
6537 /* XXX : not implemented */
6538 spr_register(env, SPR_PMC5, "PMC5",
6539 SPR_NOACCESS, SPR_NOACCESS,
6540 &spr_read_generic, &spr_write_generic,
6541 0x00000000);
6542 /* XXX : not implemented */
6543 spr_register(env, SPR_UPMC5, "UPMC5",
6544 &spr_read_ureg, SPR_NOACCESS,
6545 &spr_read_ureg, SPR_NOACCESS,
6546 0x00000000);
6547 /* XXX : not implemented */
6548 spr_register(env, SPR_PMC6, "PMC6",
6549 SPR_NOACCESS, SPR_NOACCESS,
6550 &spr_read_generic, &spr_write_generic,
6551 0x00000000);
6552 /* XXX : not implemented */
6553 spr_register(env, SPR_UPMC6, "UPMC6",
6554 &spr_read_ureg, SPR_NOACCESS,
6555 &spr_read_ureg, SPR_NOACCESS,
6556 0x00000000);
6557 /* SPRGs */
6558 spr_register(env, SPR_SPRG4, "SPRG4",
6559 SPR_NOACCESS, SPR_NOACCESS,
6560 &spr_read_generic, &spr_write_generic,
6561 0x00000000);
6562 spr_register(env, SPR_USPRG4, "USPRG4",
6563 &spr_read_ureg, SPR_NOACCESS,
6564 &spr_read_ureg, SPR_NOACCESS,
6565 0x00000000);
6566 spr_register(env, SPR_SPRG5, "SPRG5",
6567 SPR_NOACCESS, SPR_NOACCESS,
6568 &spr_read_generic, &spr_write_generic,
6569 0x00000000);
6570 spr_register(env, SPR_USPRG5, "USPRG5",
6571 &spr_read_ureg, SPR_NOACCESS,
6572 &spr_read_ureg, SPR_NOACCESS,
6573 0x00000000);
6574 spr_register(env, SPR_SPRG6, "SPRG6",
6575 SPR_NOACCESS, SPR_NOACCESS,
6576 &spr_read_generic, &spr_write_generic,
6577 0x00000000);
6578 spr_register(env, SPR_USPRG6, "USPRG6",
6579 &spr_read_ureg, SPR_NOACCESS,
6580 &spr_read_ureg, SPR_NOACCESS,
6581 0x00000000);
6582 spr_register(env, SPR_SPRG7, "SPRG7",
6583 SPR_NOACCESS, SPR_NOACCESS,
6584 &spr_read_generic, &spr_write_generic,
6585 0x00000000);
6586 spr_register(env, SPR_USPRG7, "USPRG7",
6587 &spr_read_ureg, SPR_NOACCESS,
6588 &spr_read_ureg, SPR_NOACCESS,
6589 0x00000000);
6590 /* Memory management */
6591 gen_low_BATs(env);
6592 gen_high_BATs(env);
6593 gen_74xx_soft_tlb(env, 128, 2);
6594 init_excp_7450(env);
6595 env->dcache_line_size = 32;
6596 env->icache_line_size = 32;
6597 /* Allocate hardware IRQ controller */
6598 ppc6xx_irq_init(env);
6599 }
6600
6601 POWERPC_FAMILY(7457)(ObjectClass *oc, void *data)
6602 {
6603 DeviceClass *dc = DEVICE_CLASS(oc);
6604 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6605
6606 dc->desc = "PowerPC 7457 (aka G4)";
6607 pcc->init_proc = init_proc_7457;
6608 pcc->check_pow = check_pow_hid0_74xx;
6609 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6610 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6611 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6612 PPC_FLOAT_STFIWX |
6613 PPC_CACHE | PPC_CACHE_ICBI |
6614 PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
6615 PPC_MEM_SYNC | PPC_MEM_EIEIO |
6616 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6617 PPC_MEM_TLBIA | PPC_74xx_TLB |
6618 PPC_SEGMENT | PPC_EXTERN |
6619 PPC_ALTIVEC;
6620 pcc->insns_flags2 = PPC_NONE;
6621 pcc->msr_mask = 0x000000000205FF77ULL;
6622 pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6623 pcc->excp_model = POWERPC_EXCP_74xx;
6624 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6625 pcc->bfd_mach = bfd_mach_ppc_7400;
6626 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6627 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6628 POWERPC_FLAG_BUS_CLK;
6629 }
6630
6631 #if defined (TARGET_PPC64)
6632 #if defined(CONFIG_USER_ONLY)
6633 #define POWERPC970_HID5_INIT 0x00000080
6634 #else
6635 #define POWERPC970_HID5_INIT 0x00000000
6636 #endif
6637
6638 static int check_pow_970 (CPUPPCState *env)
6639 {
6640 if (env->spr[SPR_HID0] & 0x00600000)
6641 return 1;
6642
6643 return 0;
6644 }
6645
6646 static void init_proc_970 (CPUPPCState *env)
6647 {
6648 gen_spr_ne_601(env);
6649 gen_spr_7xx(env);
6650 /* Time base */
6651 gen_tbl(env);
6652 /* Hardware implementation registers */
6653 /* XXX : not implemented */
6654 spr_register(env, SPR_HID0, "HID0",
6655 SPR_NOACCESS, SPR_NOACCESS,
6656 &spr_read_generic, &spr_write_clear,
6657 0x60000000);
6658 /* XXX : not implemented */
6659 spr_register(env, SPR_HID1, "HID1",
6660 SPR_NOACCESS, SPR_NOACCESS,
6661 &spr_read_generic, &spr_write_generic,
6662 0x00000000);
6663 /* XXX : not implemented */
6664 spr_register(env, SPR_750FX_HID2, "HID2",
6665 SPR_NOACCESS, SPR_NOACCESS,
6666 &spr_read_generic, &spr_write_generic,
6667 0x00000000);
6668 /* XXX : not implemented */
6669 spr_register(env, SPR_970_HID5, "HID5",
6670 SPR_NOACCESS, SPR_NOACCESS,
6671 &spr_read_generic, &spr_write_generic,
6672 POWERPC970_HID5_INIT);
6673 /* XXX : not implemented */
6674 spr_register(env, SPR_L2CR, "L2CR",
6675 SPR_NOACCESS, SPR_NOACCESS,
6676 &spr_read_generic, &spr_write_generic,
6677 0x00000000);
6678 /* Memory management */
6679 /* XXX: not correct */
6680 gen_low_BATs(env);
6681 /* XXX : not implemented */
6682 spr_register(env, SPR_MMUCFG, "MMUCFG",
6683 SPR_NOACCESS, SPR_NOACCESS,
6684 &spr_read_generic, SPR_NOACCESS,
6685 0x00000000); /* TOFIX */
6686 /* XXX : not implemented */
6687 spr_register(env, SPR_MMUCSR0, "MMUCSR0",
6688 SPR_NOACCESS, SPR_NOACCESS,
6689 &spr_read_generic, &spr_write_generic,
6690 0x00000000); /* TOFIX */
6691 spr_register(env, SPR_HIOR, "SPR_HIOR",
6692 SPR_NOACCESS, SPR_NOACCESS,
6693 &spr_read_hior, &spr_write_hior,
6694 0x00000000);
6695 #if !defined(CONFIG_USER_ONLY)
6696 env->slb_nr = 32;
6697 #endif
6698 init_excp_970(env);
6699 env->dcache_line_size = 128;
6700 env->icache_line_size = 128;
6701 /* Allocate hardware IRQ controller */
6702 ppc970_irq_init(env);
6703 /* Can't find information on what this should be on reset. This
6704 * value is the one used by 74xx processors. */
6705 vscr_init(env, 0x00010000);
6706 }
6707
6708 POWERPC_FAMILY(970)(ObjectClass *oc, void *data)
6709 {
6710 DeviceClass *dc = DEVICE_CLASS(oc);
6711 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6712
6713 dc->desc = "PowerPC 970";
6714 pcc->init_proc = init_proc_970;
6715 pcc->check_pow = check_pow_970;
6716 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6717 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6718 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6719 PPC_FLOAT_STFIWX |
6720 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
6721 PPC_MEM_SYNC | PPC_MEM_EIEIO |
6722 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6723 PPC_64B | PPC_ALTIVEC |
6724 PPC_SEGMENT_64B | PPC_SLBI;
6725 pcc->insns_flags2 = PPC_NONE;
6726 pcc->msr_mask = 0x900000000204FF36ULL;
6727 pcc->mmu_model = POWERPC_MMU_64B;
6728 pcc->excp_model = POWERPC_EXCP_970;
6729 pcc->bus_model = PPC_FLAGS_INPUT_970;
6730 pcc->bfd_mach = bfd_mach_ppc64;
6731 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6732 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6733 POWERPC_FLAG_BUS_CLK;
6734 }
6735
6736 static int check_pow_970FX (CPUPPCState *env)
6737 {
6738 if (env->spr[SPR_HID0] & 0x00600000)
6739 return 1;
6740
6741 return 0;
6742 }
6743
6744 static void init_proc_970FX (CPUPPCState *env)
6745 {
6746 gen_spr_ne_601(env);
6747 gen_spr_7xx(env);
6748 /* Time base */
6749 gen_tbl(env);
6750 /* Hardware implementation registers */
6751 /* XXX : not implemented */
6752 spr_register(env, SPR_HID0, "HID0",
6753 SPR_NOACCESS, SPR_NOACCESS,
6754 &spr_read_generic, &spr_write_clear,
6755 0x60000000);
6756 /* XXX : not implemented */
6757 spr_register(env, SPR_HID1, "HID1",
6758 SPR_NOACCESS, SPR_NOACCESS,
6759 &spr_read_generic, &spr_write_generic,
6760 0x00000000);
6761 /* XXX : not implemented */
6762 spr_register(env, SPR_750FX_HID2, "HID2",
6763 SPR_NOACCESS, SPR_NOACCESS,
6764 &spr_read_generic, &spr_write_generic,
6765 0x00000000);
6766 /* XXX : not implemented */
6767 spr_register(env, SPR_970_HID5, "HID5",
6768 SPR_NOACCESS, SPR_NOACCESS,
6769 &spr_read_generic, &spr_write_generic,
6770 POWERPC970_HID5_INIT);
6771 /* XXX : not implemented */
6772 spr_register(env, SPR_L2CR, "L2CR",
6773 SPR_NOACCESS, SPR_NOACCESS,
6774 &spr_read_generic, &spr_write_generic,
6775 0x00000000);
6776 /* Memory management */
6777 /* XXX: not correct */
6778 gen_low_BATs(env);
6779 /* XXX : not implemented */
6780 spr_register(env, SPR_MMUCFG, "MMUCFG",
6781 SPR_NOACCESS, SPR_NOACCESS,
6782 &spr_read_generic, SPR_NOACCESS,
6783 0x00000000); /* TOFIX */
6784 /* XXX : not implemented */
6785 spr_register(env, SPR_MMUCSR0, "MMUCSR0",
6786 SPR_NOACCESS, SPR_NOACCESS,
6787 &spr_read_generic, &spr_write_generic,
6788 0x00000000); /* TOFIX */
6789 spr_register(env, SPR_HIOR, "SPR_HIOR",
6790 SPR_NOACCESS, SPR_NOACCESS,
6791 &spr_read_hior, &spr_write_hior,
6792 0x00000000);
6793 spr_register(env, SPR_CTRL, "SPR_CTRL",
6794 SPR_NOACCESS, SPR_NOACCESS,
6795 &spr_read_generic, &spr_write_generic,
6796 0x00000000);
6797 spr_register(env, SPR_UCTRL, "SPR_UCTRL",
6798 SPR_NOACCESS, SPR_NOACCESS,
6799 &spr_read_generic, &spr_write_generic,
6800 0x00000000);
6801 spr_register(env, SPR_VRSAVE, "SPR_VRSAVE",
6802 &spr_read_generic, &spr_write_generic,
6803 &spr_read_generic, &spr_write_generic,
6804 0x00000000);
6805 #if !defined(CONFIG_USER_ONLY)
6806 env->slb_nr = 64;
6807 #endif
6808 init_excp_970(env);
6809 env->dcache_line_size = 128;
6810 env->icache_line_size = 128;
6811 /* Allocate hardware IRQ controller */
6812 ppc970_irq_init(env);
6813 /* Can't find information on what this should be on reset. This
6814 * value is the one used by 74xx processors. */
6815 vscr_init(env, 0x00010000);
6816 }
6817
6818 POWERPC_FAMILY(970FX)(ObjectClass *oc, void *data)
6819 {
6820 DeviceClass *dc = DEVICE_CLASS(oc);
6821 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6822
6823 dc->desc = "PowerPC 970FX (aka G5)";
6824 pcc->init_proc = init_proc_970FX;
6825 pcc->check_pow = check_pow_970FX;
6826 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6827 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6828 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6829 PPC_FLOAT_STFIWX |
6830 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
6831 PPC_MEM_SYNC | PPC_MEM_EIEIO |
6832 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6833 PPC_64B | PPC_ALTIVEC |
6834 PPC_SEGMENT_64B | PPC_SLBI;
6835 pcc->insns_flags2 = PPC_NONE;
6836 pcc->msr_mask = 0x800000000204FF36ULL;
6837 pcc->mmu_model = POWERPC_MMU_64B;
6838 pcc->excp_model = POWERPC_EXCP_970;
6839 pcc->bus_model = PPC_FLAGS_INPUT_970;
6840 pcc->bfd_mach = bfd_mach_ppc64;
6841 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6842 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6843 POWERPC_FLAG_BUS_CLK;
6844 }
6845
6846 static int check_pow_970GX (CPUPPCState *env)
6847 {
6848 if (env->spr[SPR_HID0] & 0x00600000)
6849 return 1;
6850
6851 return 0;
6852 }
6853
6854 static void init_proc_970GX (CPUPPCState *env)
6855 {
6856 gen_spr_ne_601(env);
6857 gen_spr_7xx(env);
6858 /* Time base */
6859 gen_tbl(env);
6860 /* Hardware implementation registers */
6861 /* XXX : not implemented */
6862 spr_register(env, SPR_HID0, "HID0",
6863 SPR_NOACCESS, SPR_NOACCESS,
6864 &spr_read_generic, &spr_write_clear,
6865 0x60000000);
6866 /* XXX : not implemented */
6867 spr_register(env, SPR_HID1, "HID1",
6868 SPR_NOACCESS, SPR_NOACCESS,
6869 &spr_read_generic, &spr_write_generic,
6870 0x00000000);
6871 /* XXX : not implemented */
6872 spr_register(env, SPR_750FX_HID2, "HID2",
6873 SPR_NOACCESS, SPR_NOACCESS,
6874 &spr_read_generic, &spr_write_generic,
6875 0x00000000);
6876 /* XXX : not implemented */
6877 spr_register(env, SPR_970_HID5, "HID5",
6878 SPR_NOACCESS, SPR_NOACCESS,
6879 &spr_read_generic, &spr_write_generic,
6880 POWERPC970_HID5_INIT);
6881 /* XXX : not implemented */
6882 spr_register(env, SPR_L2CR, "L2CR",
6883 SPR_NOACCESS, SPR_NOACCESS,
6884 &spr_read_generic, &spr_write_generic,
6885 0x00000000);
6886 /* Memory management */
6887 /* XXX: not correct */
6888 gen_low_BATs(env);
6889 /* XXX : not implemented */
6890 spr_register(env, SPR_MMUCFG, "MMUCFG",
6891 SPR_NOACCESS, SPR_NOACCESS,
6892 &spr_read_generic, SPR_NOACCESS,
6893 0x00000000); /* TOFIX */
6894 /* XXX : not implemented */
6895 spr_register(env, SPR_MMUCSR0, "MMUCSR0",
6896 SPR_NOACCESS, SPR_NOACCESS,
6897 &spr_read_generic, &spr_write_generic,
6898 0x00000000); /* TOFIX */
6899 spr_register(env, SPR_HIOR, "SPR_HIOR",
6900 SPR_NOACCESS, SPR_NOACCESS,
6901 &spr_read_hior, &spr_write_hior,
6902 0x00000000);
6903 #if !defined(CONFIG_USER_ONLY)
6904 env->slb_nr = 32;
6905 #endif
6906 init_excp_970(env);
6907 env->dcache_line_size = 128;
6908 env->icache_line_size = 128;
6909 /* Allocate hardware IRQ controller */
6910 ppc970_irq_init(env);
6911 /* Can't find information on what this should be on reset. This
6912 * value is the one used by 74xx processors. */
6913 vscr_init(env, 0x00010000);
6914 }
6915
6916 POWERPC_FAMILY(970GX)(ObjectClass *oc, void *data)
6917 {
6918 DeviceClass *dc = DEVICE_CLASS(oc);
6919 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
6920
6921 dc->desc = "PowerPC 970 GX";
6922 pcc->init_proc = init_proc_970GX;
6923 pcc->check_pow = check_pow_970GX;
6924 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
6925 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
6926 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
6927 PPC_FLOAT_STFIWX |
6928 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
6929 PPC_MEM_SYNC | PPC_MEM_EIEIO |
6930 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6931 PPC_64B | PPC_ALTIVEC |
6932 PPC_SEGMENT_64B | PPC_SLBI;
6933 pcc->insns_flags2 = PPC_NONE;
6934 pcc->msr_mask = 0x800000000204FF36ULL;
6935 pcc->mmu_model = POWERPC_MMU_64B;
6936 pcc->excp_model = POWERPC_EXCP_970;
6937 pcc->bus_model = PPC_FLAGS_INPUT_970;
6938 pcc->bfd_mach = bfd_mach_ppc64;
6939 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
6940 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
6941 POWERPC_FLAG_BUS_CLK;
6942 }
6943
6944 static int check_pow_970MP (CPUPPCState *env)
6945 {
6946 if (env->spr[SPR_HID0] & 0x01C00000)
6947 return 1;
6948
6949 return 0;
6950 }
6951
6952 static void init_proc_970MP (CPUPPCState *env)
6953 {
6954 gen_spr_ne_601(env);
6955 gen_spr_7xx(env);
6956 /* Time base */
6957 gen_tbl(env);
6958 /* Hardware implementation registers */
6959 /* XXX : not implemented */
6960 spr_register(env, SPR_HID0, "HID0",
6961 SPR_NOACCESS, SPR_NOACCESS,
6962 &spr_read_generic, &spr_write_clear,
6963 0x60000000);
6964 /* XXX : not implemented */
6965 spr_register(env, SPR_HID1, "HID1",
6966 SPR_NOACCESS, SPR_NOACCESS,
6967 &spr_read_generic, &spr_write_generic,
6968 0x00000000);
6969 /* XXX : not implemented */
6970 spr_register(env, SPR_750FX_HID2, "HID2",
6971 SPR_NOACCESS, SPR_NOACCESS,
6972 &spr_read_generic, &spr_write_generic,
6973 0x00000000);
6974 /* XXX : not implemented */
6975 spr_register(env, SPR_970_HID5, "HID5",
6976 SPR_NOACCESS, SPR_NOACCESS,
6977 &spr_read_generic, &spr_write_generic,
6978 POWERPC970_HID5_INIT);
6979 /* XXX : not implemented */
6980 spr_register(env, SPR_L2CR, "L2CR",
6981 SPR_NOACCESS, SPR_NOACCESS,
6982 &spr_read_generic, &spr_write_generic,
6983 0x00000000);
6984 /* Memory management */
6985 /* XXX: not correct */
6986 gen_low_BATs(env);
6987 /* XXX : not implemented */
6988 spr_register(env, SPR_MMUCFG, "MMUCFG",
6989 SPR_NOACCESS, SPR_NOACCESS,
6990 &spr_read_generic, SPR_NOACCESS,
6991 0x00000000); /* TOFIX */
6992 /* XXX : not implemented */
6993 spr_register(env, SPR_MMUCSR0, "MMUCSR0",
6994 SPR_NOACCESS, SPR_NOACCESS,
6995 &spr_read_generic, &spr_write_generic,
6996 0x00000000); /* TOFIX */
6997 spr_register(env, SPR_HIOR, "SPR_HIOR",
6998 SPR_NOACCESS, SPR_NOACCESS,
6999 &spr_read_hior, &spr_write_hior,
7000 0x00000000);
7001 #if !defined(CONFIG_USER_ONLY)
7002 env->slb_nr = 32;
7003 #endif
7004 init_excp_970(env);
7005 env->dcache_line_size = 128;
7006 env->icache_line_size = 128;
7007 /* Allocate hardware IRQ controller */
7008 ppc970_irq_init(env);
7009 /* Can't find information on what this should be on reset. This
7010 * value is the one used by 74xx processors. */
7011 vscr_init(env, 0x00010000);
7012 }
7013
7014 POWERPC_FAMILY(970MP)(ObjectClass *oc, void *data)
7015 {
7016 DeviceClass *dc = DEVICE_CLASS(oc);
7017 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
7018
7019 dc->desc = "PowerPC 970 MP";
7020 pcc->init_proc = init_proc_970MP;
7021 pcc->check_pow = check_pow_970MP;
7022 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
7023 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
7024 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
7025 PPC_FLOAT_STFIWX |
7026 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
7027 PPC_MEM_SYNC | PPC_MEM_EIEIO |
7028 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
7029 PPC_64B | PPC_ALTIVEC |
7030 PPC_SEGMENT_64B | PPC_SLBI;
7031 pcc->insns_flags2 = PPC_NONE;
7032 pcc->msr_mask = 0x900000000204FF36ULL;
7033 pcc->mmu_model = POWERPC_MMU_64B;
7034 pcc->excp_model = POWERPC_EXCP_970;
7035 pcc->bus_model = PPC_FLAGS_INPUT_970;
7036 pcc->bfd_mach = bfd_mach_ppc64;
7037 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
7038 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
7039 POWERPC_FLAG_BUS_CLK;
7040 }
7041
7042 static void init_proc_POWER7 (CPUPPCState *env)
7043 {
7044 gen_spr_ne_601(env);
7045 gen_spr_7xx(env);
7046 /* Time base */
7047 gen_tbl(env);
7048 /* Processor identification */
7049 spr_register(env, SPR_PIR, "PIR",
7050 SPR_NOACCESS, SPR_NOACCESS,
7051 &spr_read_generic, &spr_write_pir,
7052 0x00000000);
7053 #if !defined(CONFIG_USER_ONLY)
7054 /* PURR & SPURR: Hack - treat these as aliases for the TB for now */
7055 spr_register_kvm(env, SPR_PURR, "PURR",
7056 &spr_read_purr, SPR_NOACCESS,
7057 &spr_read_purr, SPR_NOACCESS,
7058 KVM_REG_PPC_PURR, 0x00000000);
7059 spr_register_kvm(env, SPR_SPURR, "SPURR",
7060 &spr_read_purr, SPR_NOACCESS,
7061 &spr_read_purr, SPR_NOACCESS,
7062 KVM_REG_PPC_SPURR, 0x00000000);
7063 spr_register(env, SPR_CFAR, "SPR_CFAR",
7064 SPR_NOACCESS, SPR_NOACCESS,
7065 &spr_read_cfar, &spr_write_cfar,
7066 0x00000000);
7067 spr_register_kvm(env, SPR_DSCR, "SPR_DSCR",
7068 SPR_NOACCESS, SPR_NOACCESS,
7069 &spr_read_generic, &spr_write_generic,
7070 KVM_REG_PPC_DSCR, 0x00000000);
7071 #endif /* !CONFIG_USER_ONLY */
7072 /* Memory management */
7073 /* XXX : not implemented */
7074 spr_register(env, SPR_MMUCFG, "MMUCFG",
7075 SPR_NOACCESS, SPR_NOACCESS,
7076 &spr_read_generic, SPR_NOACCESS,
7077 0x00000000); /* TOFIX */
7078 /* XXX : not implemented */
7079 spr_register(env, SPR_CTRL, "SPR_CTRLT",
7080 SPR_NOACCESS, SPR_NOACCESS,
7081 &spr_read_generic, &spr_write_generic,
7082 0x80800000);
7083 spr_register(env, SPR_UCTRL, "SPR_CTRLF",
7084 SPR_NOACCESS, SPR_NOACCESS,
7085 &spr_read_generic, &spr_write_generic,
7086 0x80800000);
7087 spr_register(env, SPR_VRSAVE, "SPR_VRSAVE",
7088 &spr_read_generic, &spr_write_generic,
7089 &spr_read_generic, &spr_write_generic,
7090 0x00000000);
7091 #if !defined(CONFIG_USER_ONLY)
7092 env->slb_nr = 32;
7093 #endif
7094 init_excp_POWER7(env);
7095 env->dcache_line_size = 128;
7096 env->icache_line_size = 128;
7097 /* Allocate hardware IRQ controller */
7098 ppcPOWER7_irq_init(env);
7099 /* Can't find information on what this should be on reset. This
7100 * value is the one used by 74xx processors. */
7101 vscr_init(env, 0x00010000);
7102 }
7103
7104 POWERPC_FAMILY(POWER7)(ObjectClass *oc, void *data)
7105 {
7106 DeviceClass *dc = DEVICE_CLASS(oc);
7107 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
7108
7109 dc->desc = "POWER7";
7110 pcc->init_proc = init_proc_POWER7;
7111 pcc->check_pow = check_pow_nocheck;
7112 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
7113 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
7114 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
7115 PPC_FLOAT_STFIWX |
7116 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
7117 PPC_MEM_SYNC | PPC_MEM_EIEIO |
7118 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
7119 PPC_64B | PPC_ALTIVEC |
7120 PPC_SEGMENT_64B | PPC_SLBI |
7121 PPC_POPCNTB | PPC_POPCNTWD;
7122 pcc->insns_flags2 = PPC2_VSX | PPC2_DFP | PPC2_DBRX;
7123 pcc->msr_mask = 0x800000000204FF36ULL;
7124 pcc->mmu_model = POWERPC_MMU_2_06;
7125 pcc->excp_model = POWERPC_EXCP_POWER7;
7126 pcc->bus_model = PPC_FLAGS_INPUT_POWER7;
7127 pcc->bfd_mach = bfd_mach_ppc64;
7128 pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
7129 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
7130 POWERPC_FLAG_BUS_CLK | POWERPC_FLAG_CFAR;
7131 }
7132
7133 static void init_proc_620 (CPUPPCState *env)
7134 {
7135 gen_spr_ne_601(env);
7136 gen_spr_620(env);
7137 /* Time base */
7138 gen_tbl(env);
7139 /* Hardware implementation registers */
7140 /* XXX : not implemented */
7141 spr_register(env, SPR_HID0, "HID0",
7142 SPR_NOACCESS, SPR_NOACCESS,
7143 &spr_read_generic, &spr_write_generic,
7144 0x00000000);
7145 /* Memory management */
7146 gen_low_BATs(env);
7147 init_excp_620(env);
7148 env->dcache_line_size = 64;
7149 env->icache_line_size = 64;
7150 /* Allocate hardware IRQ controller */
7151 ppc6xx_irq_init(env);
7152 }
7153
7154 POWERPC_FAMILY(620)(ObjectClass *oc, void *data)
7155 {
7156 DeviceClass *dc = DEVICE_CLASS(oc);
7157 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
7158
7159 dc->desc = "PowerPC 620";
7160 pcc->init_proc = init_proc_620;
7161 pcc->check_pow = check_pow_nocheck; /* Check this */
7162 pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
7163 PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
7164 PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
7165 PPC_FLOAT_STFIWX |
7166 PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
7167 PPC_MEM_SYNC | PPC_MEM_EIEIO |
7168 PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
7169 PPC_SEGMENT | PPC_EXTERN |
7170 PPC_64B | PPC_SLBI;
7171 pcc->insns_flags2 = PPC_NONE;
7172 pcc->msr_mask = 0x800000000005FF77ULL;
7173 pcc->mmu_model = POWERPC_MMU_620;
7174 pcc->excp_model = POWERPC_EXCP_970;
7175 pcc->bus_model = PPC_FLAGS_INPUT_6xx;
7176 pcc->bfd_mach = bfd_mach_ppc64;
7177 pcc->flags = POWERPC_FLAG_SE | POWERPC_FLAG_BE |
7178 POWERPC_FLAG_PMM | POWERPC_FLAG_BUS_CLK;
7179 }
7180
7181 #endif /* defined (TARGET_PPC64) */
7182
7183
7184 /*****************************************************************************/
7185 /* Generic CPU instantiation routine */
7186 static void init_ppc_proc(PowerPCCPU *cpu)
7187 {
7188 PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
7189 CPUPPCState *env = &cpu->env;
7190 #if !defined(CONFIG_USER_ONLY)
7191 int i;
7192
7193 env->irq_inputs = NULL;
7194 /* Set all exception vectors to an invalid address */
7195 for (i = 0; i < POWERPC_EXCP_NB; i++)
7196 env->excp_vectors[i] = (target_ulong)(-1ULL);
7197 env->hreset_excp_prefix = 0x00000000;
7198 env->ivor_mask = 0x00000000;
7199 env->ivpr_mask = 0x00000000;
7200 /* Default MMU definitions */
7201 env->nb_BATs = 0;
7202 env->nb_tlb = 0;
7203 env->nb_ways = 0;
7204 env->tlb_type = TLB_NONE;
7205 #endif
7206 /* Register SPR common to all PowerPC implementations */
7207 gen_spr_generic(env);
7208 spr_register(env, SPR_PVR, "PVR",
7209 /* Linux permits userspace to read PVR */
7210 #if defined(CONFIG_LINUX_USER)
7211 &spr_read_generic,
7212 #else
7213 SPR_NOACCESS,
7214 #endif
7215 SPR_NOACCESS,
7216 &spr_read_generic, SPR_NOACCESS,
7217 pcc->pvr);
7218 /* Register SVR if it's defined to anything else than POWERPC_SVR_NONE */
7219 if (pcc->svr != POWERPC_SVR_NONE) {
7220 if (pcc->svr & POWERPC_SVR_E500) {
7221 spr_register(env, SPR_E500_SVR, "SVR",
7222 SPR_NOACCESS, SPR_NOACCESS,
7223 &spr_read_generic, SPR_NOACCESS,
7224 pcc->svr & ~POWERPC_SVR_E500);
7225 } else {
7226 spr_register(env, SPR_SVR, "SVR",
7227 SPR_NOACCESS, SPR_NOACCESS,
7228 &spr_read_generic, SPR_NOACCESS,
7229 pcc->svr);
7230 }
7231 }
7232 /* PowerPC implementation specific initialisations (SPRs, timers, ...) */
7233 (*pcc->init_proc)(env);
7234 #if !defined(CONFIG_USER_ONLY)
7235 env->excp_prefix = env->hreset_excp_prefix;
7236 #endif
7237 /* MSR bits & flags consistency checks */
7238 if (env->msr_mask & (1 << 25)) {
7239 switch (env->flags & (POWERPC_FLAG_SPE | POWERPC_FLAG_VRE)) {
7240 case POWERPC_FLAG_SPE:
7241 case POWERPC_FLAG_VRE:
7242 break;
7243 default:
7244 fprintf(stderr, "PowerPC MSR definition inconsistency\n"
7245 "Should define POWERPC_FLAG_SPE or POWERPC_FLAG_VRE\n");
7246 exit(1);
7247 }
7248 } else if (env->flags & (POWERPC_FLAG_SPE | POWERPC_FLAG_VRE)) {
7249 fprintf(stderr, "PowerPC MSR definition inconsistency\n"
7250 "Should not define POWERPC_FLAG_SPE nor POWERPC_FLAG_VRE\n");
7251 exit(1);
7252 }
7253 if (env->msr_mask & (1 << 17)) {
7254 switch (env->flags & (POWERPC_FLAG_TGPR | POWERPC_FLAG_CE)) {
7255 case POWERPC_FLAG_TGPR:
7256 case POWERPC_FLAG_CE:
7257 break;
7258 default:
7259 fprintf(stderr, "PowerPC MSR definition inconsistency\n"
7260 "Should define POWERPC_FLAG_TGPR or POWERPC_FLAG_CE\n");
7261 exit(1);
7262 }
7263 } else if (env->flags & (POWERPC_FLAG_TGPR | POWERPC_FLAG_CE)) {
7264 fprintf(stderr, "PowerPC MSR definition inconsistency\n"
7265 "Should not define POWERPC_FLAG_TGPR nor POWERPC_FLAG_CE\n");
7266 exit(1);
7267 }
7268 if (env->msr_mask & (1 << 10)) {
7269 switch (env->flags & (POWERPC_FLAG_SE | POWERPC_FLAG_DWE |
7270 POWERPC_FLAG_UBLE)) {
7271 case POWERPC_FLAG_SE:
7272 case POWERPC_FLAG_DWE:
7273 case POWERPC_FLAG_UBLE:
7274 break;
7275 default:
7276 fprintf(stderr, "PowerPC MSR definition inconsistency\n"
7277 "Should define POWERPC_FLAG_SE or POWERPC_FLAG_DWE or "
7278 "POWERPC_FLAG_UBLE\n");
7279 exit(1);
7280 }
7281 } else if (env->flags & (POWERPC_FLAG_SE | POWERPC_FLAG_DWE |
7282 POWERPC_FLAG_UBLE)) {
7283 fprintf(stderr, "PowerPC MSR definition inconsistency\n"
7284 "Should not define POWERPC_FLAG_SE nor POWERPC_FLAG_DWE nor "
7285 "POWERPC_FLAG_UBLE\n");
7286 exit(1);
7287 }
7288 if (env->msr_mask & (1 << 9)) {
7289 switch (env->flags & (POWERPC_FLAG_BE | POWERPC_FLAG_DE)) {
7290 case POWERPC_FLAG_BE:
7291 case POWERPC_FLAG_DE:
7292 break;
7293 default:
7294 fprintf(stderr, "PowerPC MSR definition inconsistency\n"
7295 "Should define POWERPC_FLAG_BE or POWERPC_FLAG_DE\n");
7296 exit(1);
7297 }
7298 } else if (env->flags & (POWERPC_FLAG_BE | POWERPC_FLAG_DE)) {
7299 fprintf(stderr, "PowerPC MSR definition inconsistency\n"
7300 "Should not define POWERPC_FLAG_BE nor POWERPC_FLAG_DE\n");
7301 exit(1);
7302 }
7303 if (env->msr_mask & (1 << 2)) {
7304 switch (env->flags & (POWERPC_FLAG_PX | POWERPC_FLAG_PMM)) {
7305 case POWERPC_FLAG_PX:
7306 case POWERPC_FLAG_PMM:
7307 break;
7308 default:
7309 fprintf(stderr, "PowerPC MSR definition inconsistency\n"
7310 "Should define POWERPC_FLAG_PX or POWERPC_FLAG_PMM\n");
7311 exit(1);
7312 }
7313 } else if (env->flags & (POWERPC_FLAG_PX | POWERPC_FLAG_PMM)) {
7314 fprintf(stderr, "PowerPC MSR definition inconsistency\n"
7315 "Should not define POWERPC_FLAG_PX nor POWERPC_FLAG_PMM\n");
7316 exit(1);
7317 }
7318 if ((env->flags & (POWERPC_FLAG_RTC_CLK | POWERPC_FLAG_BUS_CLK)) == 0) {
7319 fprintf(stderr, "PowerPC flags inconsistency\n"
7320 "Should define the time-base and decrementer clock source\n");
7321 exit(1);
7322 }
7323 /* Allocate TLBs buffer when needed */
7324 #if !defined(CONFIG_USER_ONLY)
7325 if (env->nb_tlb != 0) {
7326 int nb_tlb = env->nb_tlb;
7327 if (env->id_tlbs != 0)
7328 nb_tlb *= 2;
7329 switch (env->tlb_type) {
7330 case TLB_6XX:
7331 env->tlb.tlb6 = g_malloc0(nb_tlb * sizeof(ppc6xx_tlb_t));
7332 break;
7333 case TLB_EMB:
7334 env->tlb.tlbe = g_malloc0(nb_tlb * sizeof(ppcemb_tlb_t));
7335 break;
7336 case TLB_MAS:
7337 env->tlb.tlbm = g_malloc0(nb_tlb * sizeof(ppcmas_tlb_t));
7338 break;
7339 }
7340 /* Pre-compute some useful values */
7341 env->tlb_per_way = env->nb_tlb / env->nb_ways;
7342 }
7343 if (env->irq_inputs == NULL) {
7344 fprintf(stderr, "WARNING: no internal IRQ controller registered.\n"
7345 " Attempt QEMU to crash very soon !\n");
7346 }
7347 #endif
7348 if (env->check_pow == NULL) {
7349 fprintf(stderr, "WARNING: no power management check handler "
7350 "registered.\n"
7351 " Attempt QEMU to crash very soon !\n");
7352 }
7353 }
7354
7355 #if defined(PPC_DUMP_CPU)
7356 static void dump_ppc_sprs (CPUPPCState *env)
7357 {
7358 ppc_spr_t *spr;
7359 #if !defined(CONFIG_USER_ONLY)
7360 uint32_t sr, sw;
7361 #endif
7362 uint32_t ur, uw;
7363 int i, j, n;
7364
7365 printf("Special purpose registers:\n");
7366 for (i = 0; i < 32; i++) {
7367 for (j = 0; j < 32; j++) {
7368 n = (i << 5) | j;
7369 spr = &env->spr_cb[n];
7370 uw = spr->uea_write != NULL && spr->uea_write != SPR_NOACCESS;
7371 ur = spr->uea_read != NULL && spr->uea_read != SPR_NOACCESS;
7372 #if !defined(CONFIG_USER_ONLY)
7373 sw = spr->oea_write != NULL && spr->oea_write != SPR_NOACCESS;
7374 sr = spr->oea_read != NULL && spr->oea_read != SPR_NOACCESS;
7375 if (sw || sr || uw || ur) {
7376 printf("SPR: %4d (%03x) %-8s s%c%c u%c%c\n",
7377 (i << 5) | j, (i << 5) | j, spr->name,
7378 sw ? 'w' : '-', sr ? 'r' : '-',
7379 uw ? 'w' : '-', ur ? 'r' : '-');
7380 }
7381 #else
7382 if (uw || ur) {
7383 printf("SPR: %4d (%03x) %-8s u%c%c\n",
7384 (i << 5) | j, (i << 5) | j, spr->name,
7385 uw ? 'w' : '-', ur ? 'r' : '-');
7386 }
7387 #endif
7388 }
7389 }
7390 fflush(stdout);
7391 fflush(stderr);
7392 }
7393 #endif
7394
7395 /*****************************************************************************/
7396 #include <stdlib.h>
7397 #include <string.h>
7398
7399 /* Opcode types */
7400 enum {
7401 PPC_DIRECT = 0, /* Opcode routine */
7402 PPC_INDIRECT = 1, /* Indirect opcode table */
7403 };
7404
7405 static inline int is_indirect_opcode (void *handler)
7406 {
7407 return ((uintptr_t)handler & 0x03) == PPC_INDIRECT;
7408 }
7409
7410 static inline opc_handler_t **ind_table(void *handler)
7411 {
7412 return (opc_handler_t **)((uintptr_t)handler & ~3);
7413 }
7414
7415 /* Instruction table creation */
7416 /* Opcodes tables creation */
7417 static void fill_new_table (opc_handler_t **table, int len)
7418 {
7419 int i;
7420
7421 for (i = 0; i < len; i++)
7422 table[i] = &invalid_handler;
7423 }
7424
7425 static int create_new_table (opc_handler_t **table, unsigned char idx)
7426 {
7427 opc_handler_t **tmp;
7428
7429 tmp = malloc(0x20 * sizeof(opc_handler_t));
7430 fill_new_table(tmp, 0x20);
7431 table[idx] = (opc_handler_t *)((uintptr_t)tmp | PPC_INDIRECT);
7432
7433 return 0;
7434 }
7435
7436 static int insert_in_table (opc_handler_t **table, unsigned char idx,
7437 opc_handler_t *handler)
7438 {
7439 if (table[idx] != &invalid_handler)
7440 return -1;
7441 table[idx] = handler;
7442
7443 return 0;
7444 }
7445
7446 static int register_direct_insn (opc_handler_t **ppc_opcodes,
7447 unsigned char idx, opc_handler_t *handler)
7448 {
7449 if (insert_in_table(ppc_opcodes, idx, handler) < 0) {
7450 printf("*** ERROR: opcode %02x already assigned in main "
7451 "opcode table\n", idx);
7452 #if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)
7453 printf(" Registered handler '%s' - new handler '%s'\n",
7454 ppc_opcodes[idx]->oname, handler->oname);
7455 #endif
7456 return -1;
7457 }
7458
7459 return 0;
7460 }
7461
7462 static int register_ind_in_table (opc_handler_t **table,
7463 unsigned char idx1, unsigned char idx2,
7464 opc_handler_t *handler)
7465 {
7466 if (table[idx1] == &invalid_handler) {
7467 if (create_new_table(table, idx1) < 0) {
7468 printf("*** ERROR: unable to create indirect table "
7469 "idx=%02x\n", idx1);
7470 return -1;
7471 }
7472 } else {
7473 if (!is_indirect_opcode(table[idx1])) {
7474 printf("*** ERROR: idx %02x already assigned to a direct "
7475 "opcode\n", idx1);
7476 #if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)
7477 printf(" Registered handler '%s' - new handler '%s'\n",
7478 ind_table(table[idx1])[idx2]->oname, handler->oname);
7479 #endif
7480 return -1;
7481 }
7482 }
7483 if (handler != NULL &&
7484 insert_in_table(ind_table(table[idx1]), idx2, handler) < 0) {
7485 printf("*** ERROR: opcode %02x already assigned in "
7486 "opcode table %02x\n", idx2, idx1);
7487 #if defined(DO_PPC_STATISTICS) || defined(PPC_DUMP_CPU)
7488 printf(" Registered handler '%s' - new handler '%s'\n",
7489 ind_table(table[idx1])[idx2]->oname, handler->oname);
7490 #endif
7491 return -1;
7492 }
7493
7494 return 0;
7495 }
7496
7497 static int register_ind_insn (opc_handler_t **ppc_opcodes,
7498 unsigned char idx1, unsigned char idx2,
7499 opc_handler_t *handler)
7500 {
7501 int ret;
7502
7503 ret = register_ind_in_table(ppc_opcodes, idx1, idx2, handler);
7504
7505 return ret;
7506 }
7507
7508 static int register_dblind_insn (opc_handler_t **ppc_opcodes,
7509 unsigned char idx1, unsigned char idx2,
7510 unsigned char idx3, opc_handler_t *handler)
7511 {
7512 if (register_ind_in_table(ppc_opcodes, idx1, idx2, NULL) < 0) {
7513 printf("*** ERROR: unable to join indirect table idx "
7514 "[%02x-%02x]\n", idx1, idx2);
7515 return -1;
7516 }
7517 if (register_ind_in_table(ind_table(ppc_opcodes[idx1]), idx2, idx3,
7518 handler) < 0) {
7519 printf("*** ERROR: unable to insert opcode "
7520 "[%02x-%02x-%02x]\n", idx1, idx2, idx3);
7521 return -1;
7522 }
7523
7524 return 0;
7525 }
7526
7527 static int register_insn (opc_handler_t **ppc_opcodes, opcode_t *insn)
7528 {
7529 if (insn->opc2 != 0xFF) {
7530 if (insn->opc3 != 0xFF) {
7531 if (register_dblind_insn(ppc_opcodes, insn->opc1, insn->opc2,
7532 insn->opc3, &insn->handler) < 0)
7533 return -1;
7534 } else {
7535 if (register_ind_insn(ppc_opcodes, insn->opc1,
7536 insn->opc2, &insn->handler) < 0)
7537 return -1;
7538 }
7539 } else {
7540 if (register_direct_insn(ppc_opcodes, insn->opc1, &insn->handler) < 0)
7541 return -1;
7542 }
7543
7544 return 0;
7545 }
7546
7547 static int test_opcode_table (opc_handler_t **table, int len)
7548 {
7549 int i, count, tmp;
7550
7551 for (i = 0, count = 0; i < len; i++) {
7552 /* Consistency fixup */
7553 if (table[i] == NULL)
7554 table[i] = &invalid_handler;
7555 if (table[i] != &invalid_handler) {
7556 if (is_indirect_opcode(table[i])) {
7557 tmp = test_opcode_table(ind_table(table[i]), 0x20);
7558 if (tmp == 0) {
7559 free(table[i]);
7560 table[i] = &invalid_handler;
7561 } else {
7562 count++;
7563 }
7564 } else {
7565 count++;
7566 }
7567 }
7568 }
7569
7570 return count;
7571 }
7572
7573 static void fix_opcode_tables (opc_handler_t **ppc_opcodes)
7574 {
7575 if (test_opcode_table(ppc_opcodes, 0x40) == 0)
7576 printf("*** WARNING: no opcode defined !\n");
7577 }
7578
7579 /*****************************************************************************/
7580 static void create_ppc_opcodes(PowerPCCPU *cpu, Error **errp)
7581 {
7582 PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
7583 CPUPPCState *env = &cpu->env;
7584 opcode_t *opc;
7585
7586 fill_new_table(env->opcodes, 0x40);
7587 for (opc = opcodes; opc < &opcodes[ARRAY_SIZE(opcodes)]; opc++) {
7588 if (((opc->handler.type & pcc->insns_flags) != 0) ||
7589 ((opc->handler.type2 & pcc->insns_flags2) != 0)) {
7590 if (register_insn(env->opcodes, opc) < 0) {
7591 error_setg(errp, "ERROR initializing PowerPC instruction "
7592 "0x%02x 0x%02x 0x%02x", opc->opc1, opc->opc2,
7593 opc->opc3);
7594 return;
7595 }
7596 }
7597 }
7598 fix_opcode_tables(env->opcodes);
7599 fflush(stdout);
7600 fflush(stderr);
7601 }
7602
7603 #if defined(PPC_DUMP_CPU)
7604 static void dump_ppc_insns (CPUPPCState *env)
7605 {
7606 opc_handler_t **table, *handler;
7607 const char *p, *q;
7608 uint8_t opc1, opc2, opc3;
7609
7610 printf("Instructions set:\n");
7611 /* opc1 is 6 bits long */
7612 for (opc1 = 0x00; opc1 < 0x40; opc1++) {
7613 table = env->opcodes;
7614 handler = table[opc1];
7615 if (is_indirect_opcode(handler)) {
7616 /* opc2 is 5 bits long */
7617 for (opc2 = 0; opc2 < 0x20; opc2++) {
7618 table = env->opcodes;
7619 handler = env->opcodes[opc1];
7620 table = ind_table(handler);
7621 handler = table[opc2];
7622 if (is_indirect_opcode(handler)) {
7623 table = ind_table(handler);
7624 /* opc3 is 5 bits long */
7625 for (opc3 = 0; opc3 < 0x20; opc3++) {
7626 handler = table[opc3];
7627 if (handler->handler != &gen_invalid) {
7628 /* Special hack to properly dump SPE insns */
7629 p = strchr(handler->oname, '_');
7630 if (p == NULL) {
7631 printf("INSN: %02x %02x %02x (%02d %04d) : "
7632 "%s\n",
7633 opc1, opc2, opc3, opc1,
7634 (opc3 << 5) | opc2,
7635 handler->oname);
7636 } else {
7637 q = "speundef";
7638 if ((p - handler->oname) != strlen(q) ||
7639 memcmp(handler->oname, q, strlen(q)) != 0) {
7640 /* First instruction */
7641 printf("INSN: %02x %02x %02x (%02d %04d) : "
7642 "%.*s\n",
7643 opc1, opc2 << 1, opc3, opc1,
7644 (opc3 << 6) | (opc2 << 1),
7645 (int)(p - handler->oname),
7646 handler->oname);
7647 }
7648 if (strcmp(p + 1, q) != 0) {
7649 /* Second instruction */
7650 printf("INSN: %02x %02x %02x (%02d %04d) : "
7651 "%s\n",
7652 opc1, (opc2 << 1) | 1, opc3, opc1,
7653 (opc3 << 6) | (opc2 << 1) | 1,
7654 p + 1);
7655 }
7656 }
7657 }
7658 }
7659 } else {
7660 if (handler->handler != &gen_invalid) {
7661 printf("INSN: %02x %02x -- (%02d %04d) : %s\n",
7662 opc1, opc2, opc1, opc2, handler->oname);
7663 }
7664 }
7665 }
7666 } else {
7667 if (handler->handler != &gen_invalid) {
7668 printf("INSN: %02x -- -- (%02d ----) : %s\n",
7669 opc1, opc1, handler->oname);
7670 }
7671 }
7672 }
7673 }
7674 #endif
7675
7676 static int gdb_get_float_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
7677 {
7678 if (n < 32) {
7679 stfq_p(mem_buf, env->fpr[n]);
7680 return 8;
7681 }
7682 if (n == 32) {
7683 stl_p(mem_buf, env->fpscr);
7684 return 4;
7685 }
7686 return 0;
7687 }
7688
7689 static int gdb_set_float_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
7690 {
7691 if (n < 32) {
7692 env->fpr[n] = ldfq_p(mem_buf);
7693 return 8;
7694 }
7695 if (n == 32) {
7696 /* FPSCR not implemented */
7697 return 4;
7698 }
7699 return 0;
7700 }
7701
7702 static int gdb_get_avr_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
7703 {
7704 if (n < 32) {
7705 #ifdef HOST_WORDS_BIGENDIAN
7706 stq_p(mem_buf, env->avr[n].u64[0]);
7707 stq_p(mem_buf+8, env->avr[n].u64[1]);
7708 #else
7709 stq_p(mem_buf, env->avr[n].u64[1]);
7710 stq_p(mem_buf+8, env->avr[n].u64[0]);
7711 #endif
7712 return 16;
7713 }
7714 if (n == 32) {
7715 stl_p(mem_buf, env->vscr);
7716 return 4;
7717 }
7718 if (n == 33) {
7719 stl_p(mem_buf, (uint32_t)env->spr[SPR_VRSAVE]);
7720 return 4;
7721 }
7722 return 0;
7723 }
7724
7725 static int gdb_set_avr_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
7726 {
7727 if (n < 32) {
7728 #ifdef HOST_WORDS_BIGENDIAN
7729 env->avr[n].u64[0] = ldq_p(mem_buf);
7730 env->avr[n].u64[1] = ldq_p(mem_buf+8);
7731 #else
7732 env->avr[n].u64[1] = ldq_p(mem_buf);
7733 env->avr[n].u64[0] = ldq_p(mem_buf+8);
7734 #endif
7735 return 16;
7736 }
7737 if (n == 32) {
7738 env->vscr = ldl_p(mem_buf);
7739 return 4;
7740 }
7741 if (n == 33) {
7742 env->spr[SPR_VRSAVE] = (target_ulong)ldl_p(mem_buf);
7743 return 4;
7744 }
7745 return 0;
7746 }
7747
7748 static int gdb_get_spe_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
7749 {
7750 if (n < 32) {
7751 #if defined(TARGET_PPC64)
7752 stl_p(mem_buf, env->gpr[n] >> 32);
7753 #else
7754 stl_p(mem_buf, env->gprh[n]);
7755 #endif
7756 return 4;
7757 }
7758 if (n == 32) {
7759 stq_p(mem_buf, env->spe_acc);
7760 return 8;
7761 }
7762 if (n == 33) {
7763 stl_p(mem_buf, env->spe_fscr);
7764 return 4;
7765 }
7766 return 0;
7767 }
7768
7769 static int gdb_set_spe_reg(CPUPPCState *env, uint8_t *mem_buf, int n)
7770 {
7771 if (n < 32) {
7772 #if defined(TARGET_PPC64)
7773 target_ulong lo = (uint32_t)env->gpr[n];
7774 target_ulong hi = (target_ulong)ldl_p(mem_buf) << 32;
7775 env->gpr[n] = lo | hi;
7776 #else
7777 env->gprh[n] = ldl_p(mem_buf);
7778 #endif
7779 return 4;
7780 }
7781 if (n == 32) {
7782 env->spe_acc = ldq_p(mem_buf);
7783 return 8;
7784 }
7785 if (n == 33) {
7786 env->spe_fscr = ldl_p(mem_buf);
7787 return 4;
7788 }
7789 return 0;
7790 }
7791
7792 static int ppc_fixup_cpu(PowerPCCPU *cpu)
7793 {
7794 CPUPPCState *env = &cpu->env;
7795
7796 /* TCG doesn't (yet) emulate some groups of instructions that
7797 * are implemented on some otherwise supported CPUs (e.g. VSX
7798 * and decimal floating point instructions on POWER7). We
7799 * remove unsupported instruction groups from the cpu state's
7800 * instruction masks and hope the guest can cope. For at
7801 * least the pseries machine, the unavailability of these
7802 * instructions can be advertised to the guest via the device
7803 * tree. */
7804 if ((env->insns_flags & ~PPC_TCG_INSNS)
7805 || (env->insns_flags2 & ~PPC_TCG_INSNS2)) {
7806 fprintf(stderr, "Warning: Disabling some instructions which are not "
7807 "emulated by TCG (0x%" PRIx64 ", 0x%" PRIx64 ")\n",
7808 env->insns_flags & ~PPC_TCG_INSNS,
7809 env->insns_flags2 & ~PPC_TCG_INSNS2);
7810 }
7811 env->insns_flags &= PPC_TCG_INSNS;
7812 env->insns_flags2 &= PPC_TCG_INSNS2;
7813 return 0;
7814 }
7815
7816 static void ppc_cpu_realizefn(DeviceState *dev, Error **errp)
7817 {
7818 PowerPCCPU *cpu = POWERPC_CPU(dev);
7819 CPUPPCState *env = &cpu->env;
7820 PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
7821 Error *local_err = NULL;
7822 #if !defined(CONFIG_USER_ONLY)
7823 int max_smt = kvm_enabled() ? kvmppc_smt_threads() : 1;
7824 #endif
7825
7826 #if !defined(CONFIG_USER_ONLY)
7827 if (smp_threads > max_smt) {
7828 error_setg(errp, "Cannot support more than %d threads on PPC with %s",
7829 max_smt, kvm_enabled() ? "KVM" : "TCG");
7830 return;
7831 }
7832 #endif
7833
7834 if (kvm_enabled()) {
7835 if (kvmppc_fixup_cpu(cpu) != 0) {
7836 error_setg(errp, "Unable to virtualize selected CPU with KVM");
7837 return;
7838 }
7839 } else {
7840 if (ppc_fixup_cpu(cpu) != 0) {
7841 error_setg(errp, "Unable to emulate selected CPU with TCG");
7842 return;
7843 }
7844 }
7845
7846 #if defined(TARGET_PPCEMB)
7847 if (pcc->mmu_model != POWERPC_MMU_BOOKE) {
7848 error_setg(errp, "CPU does not possess a BookE MMU. "
7849 "Please use qemu-system-ppc or qemu-system-ppc64 instead "
7850 "or choose another CPU model.");
7851 return;
7852 }
7853 #endif
7854
7855 create_ppc_opcodes(cpu, &local_err);
7856 if (local_err != NULL) {
7857 error_propagate(errp, local_err);
7858 return;
7859 }
7860 init_ppc_proc(cpu);
7861
7862 if (pcc->insns_flags & PPC_FLOAT) {
7863 gdb_register_coprocessor(env, gdb_get_float_reg, gdb_set_float_reg,
7864 33, "power-fpu.xml", 0);
7865 }
7866 if (pcc->insns_flags & PPC_ALTIVEC) {
7867 gdb_register_coprocessor(env, gdb_get_avr_reg, gdb_set_avr_reg,
7868 34, "power-altivec.xml", 0);
7869 }
7870 if (pcc->insns_flags & PPC_SPE) {
7871 gdb_register_coprocessor(env, gdb_get_spe_reg, gdb_set_spe_reg,
7872 34, "power-spe.xml", 0);
7873 }
7874
7875 qemu_init_vcpu(env);
7876
7877 pcc->parent_realize(dev, errp);
7878
7879 #if defined(PPC_DUMP_CPU)
7880 {
7881 const char *mmu_model, *excp_model, *bus_model;
7882 switch (env->mmu_model) {
7883 case POWERPC_MMU_32B:
7884 mmu_model = "PowerPC 32";
7885 break;
7886 case POWERPC_MMU_SOFT_6xx:
7887 mmu_model = "PowerPC 6xx/7xx with software driven TLBs";
7888 break;
7889 case POWERPC_MMU_SOFT_74xx:
7890 mmu_model = "PowerPC 74xx with software driven TLBs";
7891 break;
7892 case POWERPC_MMU_SOFT_4xx:
7893 mmu_model = "PowerPC 4xx with software driven TLBs";
7894 break;
7895 case POWERPC_MMU_SOFT_4xx_Z:
7896 mmu_model = "PowerPC 4xx with software driven TLBs "
7897 "and zones protections";
7898 break;
7899 case POWERPC_MMU_REAL:
7900 mmu_model = "PowerPC real mode only";
7901 break;
7902 case POWERPC_MMU_MPC8xx:
7903 mmu_model = "PowerPC MPC8xx";
7904 break;
7905 case POWERPC_MMU_BOOKE:
7906 mmu_model = "PowerPC BookE";
7907 break;
7908 case POWERPC_MMU_BOOKE206:
7909 mmu_model = "PowerPC BookE 2.06";
7910 break;
7911 case POWERPC_MMU_601:
7912 mmu_model = "PowerPC 601";
7913 break;
7914 #if defined (TARGET_PPC64)
7915 case POWERPC_MMU_64B:
7916 mmu_model = "PowerPC 64";
7917 break;
7918 case POWERPC_MMU_620:
7919 mmu_model = "PowerPC 620";
7920 break;
7921 #endif
7922 default:
7923 mmu_model = "Unknown or invalid";
7924 break;
7925 }
7926 switch (env->excp_model) {
7927 case POWERPC_EXCP_STD:
7928 excp_model = "PowerPC";
7929 break;
7930 case POWERPC_EXCP_40x:
7931 excp_model = "PowerPC 40x";
7932 break;
7933 case POWERPC_EXCP_601:
7934 excp_model = "PowerPC 601";
7935 break;
7936 case POWERPC_EXCP_602:
7937 excp_model = "PowerPC 602";
7938 break;
7939 case POWERPC_EXCP_603:
7940 excp_model = "PowerPC 603";
7941 break;
7942 case POWERPC_EXCP_603E:
7943 excp_model = "PowerPC 603e";
7944 break;
7945 case POWERPC_EXCP_604:
7946 excp_model = "PowerPC 604";
7947 break;
7948 case POWERPC_EXCP_7x0:
7949 excp_model = "PowerPC 740/750";
7950 break;
7951 case POWERPC_EXCP_7x5:
7952 excp_model = "PowerPC 745/755";
7953 break;
7954 case POWERPC_EXCP_74xx:
7955 excp_model = "PowerPC 74xx";
7956 break;
7957 case POWERPC_EXCP_BOOKE:
7958 excp_model = "PowerPC BookE";
7959 break;
7960 #if defined (TARGET_PPC64)
7961 case POWERPC_EXCP_970:
7962 excp_model = "PowerPC 970";
7963 break;
7964 #endif
7965 default:
7966 excp_model = "Unknown or invalid";
7967 break;
7968 }
7969 switch (env->bus_model) {
7970 case PPC_FLAGS_INPUT_6xx:
7971 bus_model = "PowerPC 6xx";
7972 break;
7973 case PPC_FLAGS_INPUT_BookE:
7974 bus_model = "PowerPC BookE";
7975 break;
7976 case PPC_FLAGS_INPUT_405:
7977 bus_model = "PowerPC 405";
7978 break;
7979 case PPC_FLAGS_INPUT_401:
7980 bus_model = "PowerPC 401/403";
7981 break;
7982 case PPC_FLAGS_INPUT_RCPU:
7983 bus_model = "RCPU / MPC8xx";
7984 break;
7985 #if defined (TARGET_PPC64)
7986 case PPC_FLAGS_INPUT_970:
7987 bus_model = "PowerPC 970";
7988 break;
7989 #endif
7990 default:
7991 bus_model = "Unknown or invalid";
7992 break;
7993 }
7994 printf("PowerPC %-12s : PVR %08x MSR %016" PRIx64 "\n"
7995 " MMU model : %s\n",
7996 pcc->name, pcc->pvr, pcc->msr_mask, mmu_model);
7997 #if !defined(CONFIG_USER_ONLY)
7998 if (env->tlb != NULL) {
7999 printf(" %d %s TLB in %d ways\n",
8000 env->nb_tlb, env->id_tlbs ? "splitted" : "merged",
8001 env->nb_ways);
8002 }
8003 #endif
8004 printf(" Exceptions model : %s\n"
8005 " Bus model : %s\n",
8006 excp_model, bus_model);
8007 printf(" MSR features :\n");
8008 if (env->flags & POWERPC_FLAG_SPE)
8009 printf(" signal processing engine enable"
8010 "\n");
8011 else if (env->flags & POWERPC_FLAG_VRE)
8012 printf(" vector processor enable\n");
8013 if (env->flags & POWERPC_FLAG_TGPR)
8014 printf(" temporary GPRs\n");
8015 else if (env->flags & POWERPC_FLAG_CE)
8016 printf(" critical input enable\n");
8017 if (env->flags & POWERPC_FLAG_SE)
8018 printf(" single-step trace mode\n");
8019 else if (env->flags & POWERPC_FLAG_DWE)
8020 printf(" debug wait enable\n");
8021 else if (env->flags & POWERPC_FLAG_UBLE)
8022 printf(" user BTB lock enable\n");
8023 if (env->flags & POWERPC_FLAG_BE)
8024 printf(" branch-step trace mode\n");
8025 else if (env->flags & POWERPC_FLAG_DE)
8026 printf(" debug interrupt enable\n");
8027 if (env->flags & POWERPC_FLAG_PX)
8028 printf(" inclusive protection\n");
8029 else if (env->flags & POWERPC_FLAG_PMM)
8030 printf(" performance monitor mark\n");
8031 if (env->flags == POWERPC_FLAG_NONE)
8032 printf(" none\n");
8033 printf(" Time-base/decrementer clock source: %s\n",
8034 env->flags & POWERPC_FLAG_RTC_CLK ? "RTC clock" : "bus clock");
8035 }
8036 dump_ppc_insns(env);
8037 dump_ppc_sprs(env);
8038 fflush(stdout);
8039 #endif
8040 }
8041
8042 static gint ppc_cpu_compare_class_pvr(gconstpointer a, gconstpointer b)
8043 {
8044 ObjectClass *oc = (ObjectClass *)a;
8045 uint32_t pvr = *(uint32_t *)b;
8046 PowerPCCPUClass *pcc = (PowerPCCPUClass *)a;
8047
8048 /* -cpu host does a PVR lookup during construction */
8049 if (unlikely(strcmp(object_class_get_name(oc),
8050 TYPE_HOST_POWERPC_CPU) == 0)) {
8051 return -1;
8052 }
8053
8054 #if defined(TARGET_PPCEMB)
8055 if (pcc->mmu_model != POWERPC_MMU_BOOKE) {
8056 return -1;
8057 }
8058 #endif
8059
8060 return pcc->pvr == pvr ? 0 : -1;
8061 }
8062
8063 PowerPCCPUClass *ppc_cpu_class_by_pvr(uint32_t pvr)
8064 {
8065 GSList *list, *item;
8066 PowerPCCPUClass *pcc = NULL;
8067
8068 list = object_class_get_list(TYPE_POWERPC_CPU, false);
8069 item = g_slist_find_custom(list, &pvr, ppc_cpu_compare_class_pvr);
8070 if (item != NULL) {
8071 pcc = POWERPC_CPU_CLASS(item->data);
8072 }
8073 g_slist_free(list);
8074
8075 return pcc;
8076 }
8077
8078 static gint ppc_cpu_compare_class_name(gconstpointer a, gconstpointer b)
8079 {
8080 ObjectClass *oc = (ObjectClass *)a;
8081 const char *name = b;
8082 #if defined(TARGET_PPCEMB)
8083 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
8084 #endif
8085
8086 if (strncasecmp(name, object_class_get_name(oc), strlen(name)) == 0 &&
8087 #if defined(TARGET_PPCEMB)
8088 pcc->mmu_model == POWERPC_MMU_BOOKE &&
8089 #endif
8090 strcmp(object_class_get_name(oc) + strlen(name),
8091 "-" TYPE_POWERPC_CPU) == 0) {
8092 return 0;
8093 }
8094 return -1;
8095 }
8096
8097 #include <ctype.h>
8098
8099 static ObjectClass *ppc_cpu_class_by_name(const char *name)
8100 {
8101 GSList *list, *item;
8102 ObjectClass *ret = NULL;
8103 const char *p;
8104 int i, len;
8105
8106 /* Check if the given name is a PVR */
8107 len = strlen(name);
8108 if (len == 10 && name[0] == '0' && name[1] == 'x') {
8109 p = name + 2;
8110 goto check_pvr;
8111 } else if (len == 8) {
8112 p = name;
8113 check_pvr:
8114 for (i = 0; i < 8; i++) {
8115 if (!qemu_isxdigit(*p++))
8116 break;
8117 }
8118 if (i == 8) {
8119 ret = OBJECT_CLASS(ppc_cpu_class_by_pvr(strtoul(name, NULL, 16)));
8120 return ret;
8121 }
8122 }
8123
8124 for (i = 0; ppc_cpu_aliases[i].alias != NULL; i++) {
8125 if (strcmp(ppc_cpu_aliases[i].alias, name) == 0) {
8126 return ppc_cpu_class_by_name(ppc_cpu_aliases[i].model);
8127 }
8128 }
8129
8130 list = object_class_get_list(TYPE_POWERPC_CPU, false);
8131 item = g_slist_find_custom(list, name, ppc_cpu_compare_class_name);
8132 if (item != NULL) {
8133 ret = OBJECT_CLASS(item->data);
8134 }
8135 g_slist_free(list);
8136
8137 return ret;
8138 }
8139
8140 PowerPCCPU *cpu_ppc_init(const char *cpu_model)
8141 {
8142 PowerPCCPU *cpu;
8143 CPUPPCState *env;
8144 ObjectClass *oc;
8145 Error *err = NULL;
8146
8147 oc = ppc_cpu_class_by_name(cpu_model);
8148 if (oc == NULL) {
8149 return NULL;
8150 }
8151
8152 cpu = POWERPC_CPU(object_new(object_class_get_name(oc)));
8153 env = &cpu->env;
8154 env->cpu_model_str = cpu_model;
8155
8156 object_property_set_bool(OBJECT(cpu), true, "realized", &err);
8157 if (err != NULL) {
8158 fprintf(stderr, "%s\n", error_get_pretty(err));
8159 error_free(err);
8160 object_unref(OBJECT(cpu));
8161 return NULL;
8162 }
8163
8164 return cpu;
8165 }
8166
8167 /* Sort by PVR, ordering special case "host" last. */
8168 static gint ppc_cpu_list_compare(gconstpointer a, gconstpointer b)
8169 {
8170 ObjectClass *oc_a = (ObjectClass *)a;
8171 ObjectClass *oc_b = (ObjectClass *)b;
8172 PowerPCCPUClass *pcc_a = POWERPC_CPU_CLASS(oc_a);
8173 PowerPCCPUClass *pcc_b = POWERPC_CPU_CLASS(oc_b);
8174 const char *name_a = object_class_get_name(oc_a);
8175 const char *name_b = object_class_get_name(oc_b);
8176
8177 if (strcmp(name_a, TYPE_HOST_POWERPC_CPU) == 0) {
8178 return 1;
8179 } else if (strcmp(name_b, TYPE_HOST_POWERPC_CPU) == 0) {
8180 return -1;
8181 } else {
8182 /* Avoid an integer overflow during subtraction */
8183 if (pcc_a->pvr < pcc_b->pvr) {
8184 return -1;
8185 } else if (pcc_a->pvr > pcc_b->pvr) {
8186 return 1;
8187 } else {
8188 return 0;
8189 }
8190 }
8191 }
8192
8193 static void ppc_cpu_list_entry(gpointer data, gpointer user_data)
8194 {
8195 ObjectClass *oc = data;
8196 CPUListState *s = user_data;
8197 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
8198 const char *typename = object_class_get_name(oc);
8199 char *name;
8200 int i;
8201
8202 #if defined(TARGET_PPCEMB)
8203 if (pcc->mmu_model != POWERPC_MMU_BOOKE) {
8204 return;
8205 }
8206 #endif
8207 if (unlikely(strcmp(typename, TYPE_HOST_POWERPC_CPU) == 0)) {
8208 return;
8209 }
8210
8211 name = g_strndup(typename,
8212 strlen(typename) - strlen("-" TYPE_POWERPC_CPU));
8213 (*s->cpu_fprintf)(s->file, "PowerPC %-16s PVR %08x\n",
8214 name, pcc->pvr);
8215 for (i = 0; ppc_cpu_aliases[i].alias != NULL; i++) {
8216 const PowerPCCPUAlias *alias = &ppc_cpu_aliases[i];
8217 ObjectClass *alias_oc = ppc_cpu_class_by_name(alias->model);
8218
8219 if (alias_oc != oc) {
8220 continue;
8221 }
8222 (*s->cpu_fprintf)(s->file, "PowerPC %-16s (alias for %s)\n",
8223 alias->alias, name);
8224 }
8225 g_free(name);
8226 }
8227
8228 void ppc_cpu_list(FILE *f, fprintf_function cpu_fprintf)
8229 {
8230 CPUListState s = {
8231 .file = f,
8232 .cpu_fprintf = cpu_fprintf,
8233 };
8234 GSList *list;
8235
8236 list = object_class_get_list(TYPE_POWERPC_CPU, false);
8237 list = g_slist_sort(list, ppc_cpu_list_compare);
8238 g_slist_foreach(list, ppc_cpu_list_entry, &s);
8239 g_slist_free(list);
8240
8241 #ifdef CONFIG_KVM
8242 cpu_fprintf(f, "\n");
8243 cpu_fprintf(f, "PowerPC %-16s\n", "host");
8244 #endif
8245 }
8246
8247 static void ppc_cpu_defs_entry(gpointer data, gpointer user_data)
8248 {
8249 ObjectClass *oc = data;
8250 CpuDefinitionInfoList **first = user_data;
8251 const char *typename;
8252 CpuDefinitionInfoList *entry;
8253 CpuDefinitionInfo *info;
8254 #if defined(TARGET_PPCEMB)
8255 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
8256
8257 if (pcc->mmu_model != POWERPC_MMU_BOOKE) {
8258 return;
8259 }
8260 #endif
8261
8262 typename = object_class_get_name(oc);
8263 info = g_malloc0(sizeof(*info));
8264 info->name = g_strndup(typename,
8265 strlen(typename) - strlen("-" TYPE_POWERPC_CPU));
8266
8267 entry = g_malloc0(sizeof(*entry));
8268 entry->value = info;
8269 entry->next = *first;
8270 *first = entry;
8271 }
8272
8273 CpuDefinitionInfoList *arch_query_cpu_definitions(Error **errp)
8274 {
8275 CpuDefinitionInfoList *cpu_list = NULL;
8276 GSList *list;
8277 int i;
8278
8279 list = object_class_get_list(TYPE_POWERPC_CPU, false);
8280 g_slist_foreach(list, ppc_cpu_defs_entry, &cpu_list);
8281 g_slist_free(list);
8282
8283 for (i = 0; ppc_cpu_aliases[i].alias != NULL; i++) {
8284 const PowerPCCPUAlias *alias = &ppc_cpu_aliases[i];
8285 ObjectClass *oc;
8286 CpuDefinitionInfoList *entry;
8287 CpuDefinitionInfo *info;
8288
8289 oc = ppc_cpu_class_by_name(alias->model);
8290 if (oc == NULL) {
8291 continue;
8292 }
8293
8294 info = g_malloc0(sizeof(*info));
8295 info->name = g_strdup(alias->alias);
8296
8297 entry = g_malloc0(sizeof(*entry));
8298 entry->value = info;
8299 entry->next = cpu_list;
8300 cpu_list = entry;
8301 }
8302
8303 return cpu_list;
8304 }
8305
8306 /* CPUClass::reset() */
8307 static void ppc_cpu_reset(CPUState *s)
8308 {
8309 PowerPCCPU *cpu = POWERPC_CPU(s);
8310 PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
8311 CPUPPCState *env = &cpu->env;
8312 target_ulong msr;
8313
8314 if (qemu_loglevel_mask(CPU_LOG_RESET)) {
8315 qemu_log("CPU Reset (CPU %d)\n", s->cpu_index);
8316 log_cpu_state(env, 0);
8317 }
8318
8319 pcc->parent_reset(s);
8320
8321 msr = (target_ulong)0;
8322 if (0) {
8323 /* XXX: find a suitable condition to enable the hypervisor mode */
8324 msr |= (target_ulong)MSR_HVB;
8325 }
8326 msr |= (target_ulong)0 << MSR_AP; /* TO BE CHECKED */
8327 msr |= (target_ulong)0 << MSR_SA; /* TO BE CHECKED */
8328 msr |= (target_ulong)1 << MSR_EP;
8329 #if defined(DO_SINGLE_STEP) && 0
8330 /* Single step trace mode */
8331 msr |= (target_ulong)1 << MSR_SE;
8332 msr |= (target_ulong)1 << MSR_BE;
8333 #endif
8334 #if defined(CONFIG_USER_ONLY)
8335 msr |= (target_ulong)1 << MSR_FP; /* Allow floating point usage */
8336 msr |= (target_ulong)1 << MSR_VR; /* Allow altivec usage */
8337 msr |= (target_ulong)1 << MSR_SPE; /* Allow SPE usage */
8338 msr |= (target_ulong)1 << MSR_PR;
8339 #else
8340 env->excp_prefix = env->hreset_excp_prefix;
8341 env->nip = env->hreset_vector | env->excp_prefix;
8342 if (env->mmu_model != POWERPC_MMU_REAL) {
8343 ppc_tlb_invalidate_all(env);
8344 }
8345 #endif
8346 env->msr = msr & env->msr_mask;
8347 #if defined(TARGET_PPC64)
8348 if (env->mmu_model & POWERPC_MMU_64) {
8349 env->msr |= (1ULL << MSR_SF);
8350 }
8351 #endif
8352 hreg_compute_hflags(env);
8353 env->reserve_addr = (target_ulong)-1ULL;
8354 /* Be sure no exception or interrupt is pending */
8355 env->pending_interrupts = 0;
8356 env->exception_index = POWERPC_EXCP_NONE;
8357 env->error_code = 0;
8358
8359 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
8360 env->vpa_addr = 0;
8361 env->slb_shadow_addr = 0;
8362 env->slb_shadow_size = 0;
8363 env->dtl_addr = 0;
8364 env->dtl_size = 0;
8365 #endif /* TARGET_PPC64 */
8366
8367 /* Flush all TLBs */
8368 tlb_flush(env, 1);
8369 }
8370
8371 static void ppc_cpu_initfn(Object *obj)
8372 {
8373 CPUState *cs = CPU(obj);
8374 PowerPCCPU *cpu = POWERPC_CPU(obj);
8375 PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
8376 CPUPPCState *env = &cpu->env;
8377
8378 cs->env_ptr = env;
8379 cpu_exec_init(env);
8380
8381 env->msr_mask = pcc->msr_mask;
8382 env->mmu_model = pcc->mmu_model;
8383 env->excp_model = pcc->excp_model;
8384 env->bus_model = pcc->bus_model;
8385 env->insns_flags = pcc->insns_flags;
8386 env->insns_flags2 = pcc->insns_flags2;
8387 env->flags = pcc->flags;
8388 env->bfd_mach = pcc->bfd_mach;
8389 env->check_pow = pcc->check_pow;
8390
8391 #if defined(TARGET_PPC64)
8392 if (pcc->sps) {
8393 env->sps = *pcc->sps;
8394 } else if (env->mmu_model & POWERPC_MMU_64) {
8395 /* Use default sets of page sizes */
8396 static const struct ppc_segment_page_sizes defsps = {
8397 .sps = {
8398 { .page_shift = 12, /* 4K */
8399 .slb_enc = 0,
8400 .enc = { { .page_shift = 12, .pte_enc = 0 } }
8401 },
8402 { .page_shift = 24, /* 16M */
8403 .slb_enc = 0x100,
8404 .enc = { { .page_shift = 24, .pte_enc = 0 } }
8405 },
8406 },
8407 };
8408 env->sps = defsps;
8409 }
8410 #endif /* defined(TARGET_PPC64) */
8411
8412 if (tcg_enabled()) {
8413 ppc_translate_init();
8414 }
8415 }
8416
8417 static void ppc_cpu_class_init(ObjectClass *oc, void *data)
8418 {
8419 PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
8420 CPUClass *cc = CPU_CLASS(oc);
8421 DeviceClass *dc = DEVICE_CLASS(oc);
8422
8423 pcc->parent_realize = dc->realize;
8424 dc->realize = ppc_cpu_realizefn;
8425
8426 pcc->parent_reset = cc->reset;
8427 cc->reset = ppc_cpu_reset;
8428
8429 cc->class_by_name = ppc_cpu_class_by_name;
8430 }
8431
8432 static const TypeInfo ppc_cpu_type_info = {
8433 .name = TYPE_POWERPC_CPU,
8434 .parent = TYPE_CPU,
8435 .instance_size = sizeof(PowerPCCPU),
8436 .instance_init = ppc_cpu_initfn,
8437 .abstract = true,
8438 .class_size = sizeof(PowerPCCPUClass),
8439 .class_init = ppc_cpu_class_init,
8440 };
8441
8442 static void ppc_cpu_register_types(void)
8443 {
8444 type_register_static(&ppc_cpu_type_info);
8445 }
8446
8447 type_init(ppc_cpu_register_types)
Qemu copy for testing